OmegaAi/BackEnd/OmegaLogic/Util/Logic/LogicToolNodeHelper.cs

using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using Common;
using Infrastructure;
using LitJson;
using Model;
using Model.Custom;
using Model.Source;

namespace Util.Logic
{
    public class LogicToolNodeHelper
    {
        /// <summary>
        /// HTTP请求节点
        /// </summary>
        /// <param name="node">节点数据</param>
        /// <param name="paramList">参数列表</param>
        /// <param name="logDic">日志列表</param>
        public static void httpRequest(NodeList node, List<ParamList> paramList, List<LogItem> logDic)
        {
            Dictionary<string, object> condi = new Dictionary<string, object>(); // 条件参数字典
            JsonData nodeData = node.nodeData;
            string requestMethod = nodeData["data"]["formData"]["requestMethod"]["value"].ToString(); // HTTP方法
            string requestUrl = nodeData["data"]["formData"]["requestApi"]["value"].ToString(); // HTTP请求URL
            JsonData responseParam = nodeData["data"]["formData"]["output"]["value"]; // HTTP响应参数
            JsonData requestHeaders = nodeData["data"]["formData"]["requestHeaders"]["value"]; //请求头
            string requestEncrypt = nodeData["data"]["formData"]["requestEncrypt"]["value"].ToString(); //加密方式
            string requestEncryptParam = nodeData["data"]["formData"]["requestEncryptParam"]["value"].ToString(); //加密参数
            string responseDecrypt = nodeData["data"]["formData"]["responseDecrypt"]["value"].ToString(); //解密方式
            string responseDecryptParam = nodeData["data"]["formData"]["responseDecryptParam"]["value"].ToString(); //解密参数

            string response = ""; // HTTP响应
            Dictionary<string, string> headers = new Dictionary<string, string>();
            foreach (JsonData header in requestHeaders)
            {
                string headerName = header["label"].ToString();
                string headerValue = header["value"].ToString();
                if (headerValue.Contains('.'))
                {
                    headerValue = headerValue.Substring(headerValue.LastIndexOf(".") + 1);
                    var paramData = paramList.FirstOrDefault(x => x.paramName == headerValue);
                    if (paramData != null)
                    {
                        headerValue = paramData.paramValueTransfer;
                    }
                }
                headers.Add(headerName, headerValue);
            }
            condi.Add("请求地址", requestUrl);
            condi.Add("请求方式", requestMethod);
            if (requestMethod == "GET") // GET请求
            {
                // 处理GET请求参数
                JsonData requestParams = nodeData["data"]["formData"]["requestParams"]["value"]; // HTTP请求参数
                // 处理GET请求参数中的参数
                Dictionary<string, string> requestParamsDict = new Dictionary<string, string>();
                foreach (JsonData param in requestParams)
                {
                    string label = param["label"].ToString();
                    string value = param["value"].ToString();
                    if (value.Contains('.'))
                    {
                        value = value.Substring(value.LastIndexOf(".") + 1);
                        var paramData = paramList.FirstOrDefault(x => x.paramName == value);
                        if (paramData != null)
                        {
                            value = paramData.paramValueTransfer;
                        }
                    }
                    requestParamsDict.Add(label, value);
                }
                string requestParamString = Newtonsoft.Json.JsonConvert.SerializeObject(requestParamsDict);
                condi.Add("get请求参数", requestParamString);
                if (requestEncrypt != "NO")
                {
                    requestParamString = Encrypt(requestParamString, requestEncrypt, requestEncryptParam);
                }
                condi.Add("get请求参数加密", requestParamString);
                response = Function.GetWebRequest(requestUrl + "?value=" + requestParamString, headers); // 发送GET请求
                condi.Add("get返回数据", response);
            }
            else if (requestMethod == "POST" || requestMethod == "PUT") // POST/PUT请求
            {
                // 处理POST/PUT请求参数
                string requestBody = nodeData["data"]["formData"]["requestBody"]["value"]["bodyData"]["json"].ToString(); // HTTP请求体
                // 处理POST/PUT请求体中的参数
                MatchCollection matches = Regex.Matches(requestBody, "\\$\\{.*?\\}");
                foreach (Match match in matches)
                {
                    string paramName = match.Value.Replace("${", "").Replace("}", "");
                    ParamList paramData = new ParamList();
                    if(paramName.StartsWith("p."))
                    {
                        string pName = paramName.Replace("p.", "");
                        paramData = paramList.FirstOrDefault(x => x.paramName == pName && x.paramAttribute == "iterationInputField") ?? new ParamList();
                    }
                    else
                    {
                        paramData = paramList.FirstOrDefault(x => x.paramName == paramName) ?? new ParamList();
                    }
                    if (!string.IsNullOrEmpty(paramData.paramName))
                    {
                        requestBody = requestBody.Replace("${" + paramName + "}", paramData.paramValue);
                    }
                }
                requestBody = LogicHelper.MatchExpressionVal(requestBody);
                condi.Add("post请求参数", requestBody);
                if (requestEncrypt != "NO")
                {
                    requestBody = Encrypt(requestBody, requestEncrypt, requestEncryptParam);
                }
                condi.Add("post请求参数加密", requestBody);
                response = Function.PostWebRequest(requestUrl, requestBody, headers, requestMethod, "application/json"); // 发送POST/PUT请求
                condi.Add("post返回数据", response);
            }
            // 处理POST/PUT请求响应
            JsonData responseJson = JsonMapper.ToObject(response);
            if(responseDecrypt != "NO")
            {
                JsonData decryptedResponseJson = JsonMapper.ToObject(Decrypt(response, responseDecrypt, responseDecryptParam));
                string[] decryptedResponseFields = decryptedResponseJson["fields"].ToString().Split('.');
                JsonData responseDecryptData = responseJson;
                foreach (string field in decryptedResponseFields)
                {
                    responseDecryptData = responseDecryptData[field];
                }
                string responseDecryptDataString = responseDecryptData.ToString();
                responseDecryptDataString = Decrypt(responseDecryptDataString, responseDecrypt, responseDecryptParam);
                responseDecryptData = JsonMapper.ToObject(responseDecryptDataString);
            }
            // 处理POST/PUT请求响应中的参数
            foreach (JsonData param in responseParam)
            {
                string paramName = param["label"].ToString();
                string paramType = param["type"][0].ToString();
                JsonData paramValue = responseJson[paramName];
                ParamList paramListObj = new ParamList();
                paramListObj.nodeId = node.nodeId;
                paramListObj.paramName = paramName;
                paramListObj.paramType = paramType;
                if (paramType == "object" || paramType == "array")
                {
                    paramListObj.paramValue = paramValue != null ? paramValue.ToJson() : "";
                }
                else
                {
                    paramListObj.paramValue = paramValue != null ? paramValue.ToString() : "";
                }
                paramList.Add(paramListObj);
            }
            logDic.Add(new LogItem()
            {
                title = node.nodeData["data"]["nodeMeta"]["label"].ToString(),
                param = condi
            });
        }

        /// <summary>
        /// 内部项目API请求节点
        /// </summary>
        /// <param name="node">节点数据</param>
        /// <param name="paramList">参数列表</param>
        /// <param name="logDic">日志列表</param>
        public static void apiSourceRequest(NodeList node, List<ParamList> paramList, List<LogItem> logDic)
        {
            Dictionary<string, object> condi = new Dictionary<string, object>(); // 条件参数字典
            JsonData nodeData = node.nodeData;

            JsonData requestParams = nodeData["data"]["formData"]["apiSource"]["value"]["requestParams"]; // HTTP请求参数
            JsonData responseParams = nodeData["data"]["formData"]["apiSource"]["value"]["responseParams"]; // 返回体
            JsonData outputParams = nodeData["data"]["formData"]["apiSource"]["value"]["outputParams"]; // 输出主体
            // 收集请求参数
            Dictionary<string, string> requestParamsDict = new Dictionary<string, string>();
            foreach (JsonData param in requestParams)
            {
                string label = param["label"].ToString();
                string value = param["defaultVal"].ToString();
                requestParamsDict.Add(label, value);
            }
            Dictionary<string, string> responseParamsDict = new Dictionary<string, string>();
            foreach (JsonData param in responseParams)
            {
                string label = param["label"].ToString();
                string value = param["defaultVal"].ToString();
                responseParamsDict.Add(label, value);
            }
            Dictionary<string, string> outputParamsDict = new Dictionary<string, string>();
            foreach (JsonData param in outputParams)
            {
                string label = param["label"].ToString();
                string value = param["defaultVal"].ToString();
                outputParamsDict.Add(label, value);
            }

            ApiInfo apiInfoData = JsonMapper.ToObject<ApiInfo>(nodeData["data"]["formData"]["apiSource"]["value"]["apiContext"]["selectedApis"][0].ToJson()); // 接口数据

            string requestMethod = apiInfoData.apiMethod; // HTTP方法
            string requestUrl = apiInfoData.apiPath; // HTTP请求URL
            string requestEncrypt = nodeData["data"]["formData"]["requestEncrypt"]["value"].ToString(); //加密方式
            string requestEncryptParam = nodeData["data"]["formData"]["requestEncryptParam"]["value"].ToString(); //加密参数

            string response = ""; // HTTP响应
            Dictionary<string, string> headers = new Dictionary<string, string>();
            if(paramList.Any(m => m.paramName == "Authorization"))
            {
                headers.Add("Authorization", paramList.FirstOrDefault(m => m.paramName == "Authorization")?.paramValue ?? "");
            }
            
            condi.Add("请求方式", requestMethod);
            if (requestMethod == "GET") // GET请求
            {
                // 处理GET请求参数
                string requestParamString = Newtonsoft.Json.JsonConvert.SerializeObject(requestParamsDict);
                condi.Add("get请求参数", requestParamString);
                if (requestEncrypt != "NO")
                {
                    requestParamString = Encrypt(requestParamString, requestEncrypt, requestEncryptParam);
                }
                condi.Add("get请求参数加密", requestParamString);
                response = Function.GetWebRequest(requestUrl + "?value=" + requestParamString, headers); // 发送GET请求
                condi.Add("get返回数据", response);
            }
            else if (requestMethod == "POST" || requestMethod == "PUT") // POST/PUT请求
            {
                // 处理POST/PUT请求参数                
                string requestBody = Newtonsoft.Json.JsonConvert.SerializeObject(requestParamsDict);
                condi.Add("post请求参数", requestBody);
                if (requestEncrypt != "NO")
                {
                    requestBody = Encrypt(requestBody, requestEncrypt, requestEncryptParam);
                }
                condi.Add("post请求参数加密", requestBody);
                response = Function.PostWebRequest(requestUrl, requestBody, headers, requestMethod, "application/json"); // 发送POST/PUT请求
                condi.Add("post返回数据", response);
            }
            else if (requestMethod == "DELETE") // DELETE请求
            { 
                // 处理DELETE请求参数                
                string requestValue = requestParamsDict[requestParamsDict.Keys?.FirstOrDefault() ?? ""];
                condi.Add("delete请求参数", requestValue);
                if (requestEncrypt != "NO")
                {
                    requestValue = Encrypt(requestValue, requestEncrypt, requestEncryptParam);
                }
                condi.Add("delete请求参数加密", requestValue);
                requestUrl = Regex.Replace(requestUrl, "\\{.*?\\}", requestValue);
                response = Function.DeleteWithBody(requestUrl, "", headers); // 发送DELETE请求
                condi.Add("delete返回数据", response);
            }
            condi.Add("请求地址", requestUrl);
            // 处理POST/PUT请求响应
            JsonData responseJson = JsonMapper.ToObject(response);            
            // 处理POST/PUT请求响应中的参数
            foreach (JsonData param in outputParams)
            {
                string paramName = param["label"].ToString();
                string paramType = param["type"][0].ToString();
                JsonData paramValue = responseJson[paramName];
                ParamList paramListObj = new ParamList();
                paramListObj.nodeId = node.nodeId;
                paramListObj.paramName = paramName;
                paramListObj.paramType = paramType;
                if (paramType == "object" || paramType == "array")
                {
                    paramListObj.paramValue = paramValue != null ? paramValue.ToJson() : "";
                }
                else
                {
                    paramListObj.paramValue = paramValue != null ? paramValue.ToString() : "";
                }
                paramList.Add(paramListObj);
            }
            logDic.Add(new LogItem()
            {
                title = node.nodeData["data"]["nodeMeta"]["label"].ToString(),
                param = condi
            });
        }

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="str">待加密字符串</param>
        /// <param name="encryptType">加密类型</param>
        /// <param name="encryptParam">加密参数</param>
        /// <returns>加密后字符串</returns>
        private static string Encrypt(string str, string encryptType, string encryptParam)
        {
            if (encryptType == "AES")
            {
                JsonData jsonData = JsonMapper.ToObject(encryptParam);
                return AesEncrypt(str, jsonData["key"].ToString(), jsonData["iv"].ToString(), jsonData["mode"].ToString(), jsonData["padding"].ToString());
            }
            else if (encryptType == "RSA")
            {
                JsonData jsonData = JsonMapper.ToObject(encryptParam);
                return RsaEncrypt(str, jsonData["key"].ToString(), jsonData["kind"].ToString());
            }
            else if (encryptType == "DES")
            {
                JsonData jsonData = JsonMapper.ToObject(encryptParam);
                return Dbconn.DesEncrypt(str, jsonData["key"].ToString());
            }
            return "";
        }

        /// <summary>
        /// AES加密
        /// </summary>
        /// <param name="str">待加密字符串</param>
        /// <param name="key">密钥</param>
        /// <param name="iv">初始向量</param>
        /// <param name="mode">加密模式</param>
        /// <param name="padding">填充方式</param>
        /// <returns>加密后字符串</returns>
        public static string AesEncrypt(string str, string key, string iv, string mode = "CBC", string padding = "PKCS7")
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            CipherMode cipherMode = CipherMode.CBC;
            PaddingMode paddingMode = PaddingMode.PKCS7;
            if (mode == "CBC") cipherMode = CipherMode.CBC;
            if (mode == "ECB") cipherMode = CipherMode.ECB;
            if (mode == "CFB") cipherMode = CipherMode.CFB;
            if (mode == "CTS") cipherMode = CipherMode.CTS;
            if (padding == "PKCS7") paddingMode = PaddingMode.PKCS7;
            if (padding == "None") paddingMode = PaddingMode.None;
            if (padding == "Zeros") paddingMode = PaddingMode.Zeros;
            if (padding == "ISO10126") paddingMode = PaddingMode.ISO10126;
            if (padding == "ANSIX923") paddingMode = PaddingMode.ANSIX923;

            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                IV = Encoding.UTF8.GetBytes(iv),
                Mode = cipherMode,
                Padding = paddingMode
            };
            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            string jsonData = Convert.ToBase64String(resultArray, 0, resultArray.Length);
            return Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonData));
        }

        public static string RsaEncrypt(string data, string key, string kind)
        {
            if (kind == "privateKey")
            {
                var toDecryptArray = Convert.FromBase64String(data);
                var toKey = Convert.FromBase64String(key);
                var rsa = RSA.Create();
                rsa.ImportPkcs8PrivateKey(toKey, out _);
                var encryptData = rsa.Encrypt(toDecryptArray, RSAEncryptionPadding.Pkcs1);
                var result = Convert.ToBase64String(encryptData);
                return result;
            }
            else if (kind == "publicKey")
            {
                var toDecryptArray = Convert.FromBase64String(data);
                var toKey = Convert.FromBase64String(key);
                var rsa = RSA.Create();
                rsa.ImportRSAPublicKey(toKey, out _);
                var encryptData = rsa.Encrypt(toDecryptArray, RSAEncryptionPadding.Pkcs1);
                var result = Convert.ToBase64String(encryptData);
                return result;
            }
            if (kind == "privateKey2")
            {
                return new RSAHelper(RSAType.RSA, System.Text.Encoding.UTF8, key).Encrypt(data);
            }
            else if (kind == "publicKey2")
            {
                return new RSAHelper(RSAType.RSA, System.Text.Encoding.UTF8, "", key).Encrypt(data);
            }
            return "";
        }


        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="str">待解密字符串</param>
        /// <param name="decryptType">解密类型</param>
        /// <param name="decryptParam">解密参数</param>
        /// <returns>解密后字符串</returns>
        private static string Decrypt(string str, string decryptType, string decryptParam)
        {
            if (decryptType == "AES")
            {
                JsonData jsonData = JsonMapper.ToObject(decryptParam);
                return AesDecrypt(str, jsonData["key"].ToString(), jsonData["iv"].ToString(), jsonData["mode"].ToString(), jsonData["padding"].ToString());
            }
            else if (decryptType == "RSA")
            {
                JsonData jsonData = JsonMapper.ToObject(decryptParam);
                return RsaDecrypt(str, jsonData["key"].ToString(), jsonData["kind"].ToString());
            }
            else if (decryptType == "DES")
            {
                JsonData jsonData = JsonMapper.ToObject(decryptParam);
                return Dbconn.DesDecrypt(str, jsonData["key"].ToString());
            }
            return "";
        }

        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">待解密字符串</param>
        /// <param name="key">密钥</param>
        /// <param name="iv">初始向量</param>
        /// <param name="mode">解密模式</param>
        /// <param name="padding">填充方式</param>
        /// <returns>解密后字符串</returns>
        public static string AesDecrypt(string str, string key, string iv, string mode = "CBC", string padding = "PKCS7")
        {
            if (string.IsNullOrEmpty(str)) return null;
            Byte[] toEncryptArray = Encoding.UTF8.GetBytes(str);

            CipherMode cipherMode = CipherMode.CBC;
            PaddingMode paddingMode = PaddingMode.PKCS7;
            if (mode == "CBC") cipherMode = CipherMode.CBC;
            if (mode == "ECB") cipherMode = CipherMode.ECB;
            if (mode == "CFB") cipherMode = CipherMode.CFB;
            if (mode == "CTS") cipherMode = CipherMode.CTS;
            if (padding == "PKCS7") paddingMode = PaddingMode.PKCS7;
            if (padding == "None") paddingMode = PaddingMode.None;
            if (padding == "Zeros") paddingMode = PaddingMode.Zeros;
            if (padding == "ISO10126") paddingMode = PaddingMode.ISO10126;
            if (padding == "ANSIX923") paddingMode = PaddingMode.ANSIX923;

            System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged
            {
                Key = Encoding.UTF8.GetBytes(key),
                IV = Encoding.UTF8.GetBytes(iv),
                Mode = cipherMode,
                Padding = paddingMode
            };
            System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor();
            Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
            return Encoding.UTF8.GetString(resultArray);
        }

        public static string RsaDecrypt(string data, string key, string kind)
        {
            if (kind == "privateKey")
            {
                var toDecryptArray = Convert.FromBase64String(data);
                var toKey = Convert.FromBase64String(key);
                var rsa = RSA.Create();
                rsa.ImportPkcs8PrivateKey(toKey, out _);
                var encryptData = rsa.Decrypt(toDecryptArray, RSAEncryptionPadding.Pkcs1);
                var result = Convert.ToBase64String(encryptData);
                return result;
            }
            else if (kind == "publicKey")
            {
                var toDecryptArray = Convert.FromBase64String(data);
                var toKey = Convert.FromBase64String(key);
                var rsa = RSA.Create();
                rsa.ImportRSAPublicKey(toKey, out _);
                var encryptData = rsa.Decrypt(toDecryptArray, RSAEncryptionPadding.Pkcs1);
                var result = Convert.ToBase64String(encryptData);
                return result;
            }
            if (kind == "privateKey2")
            {
                return new RSAHelper(RSAType.RSA, System.Text.Encoding.UTF8, key).Decrypt(data);
            }
            else if (kind == "publicKey2")
            {
                return new RSAHelper(RSAType.RSA, System.Text.Encoding.UTF8, "", key).Decrypt(data);
            }
            return "";
        }
    }
}