using AksWebBrowser;
using AksWebBrowser.Common;
using AksWebBrowser.Devices;
using AKSWebBrowser.Commen;
using CPF.Cef;
using CPF.Shapes;
using CPF.Windows;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Authentication;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Web;

namespace AKS.EnterpriseLibrary.WebBrowser
{
    public class MainModel : CPF.CpfObject
    {

        //初始化网络连接
        public static void DeviceControllerInit()
        {
            List<string> lit = new List<string>();
            SAEA.WebSocket.WSServer ws = new SAEA.WebSocket.WSServer(19983);
            ws.OnConnected += (s) =>
            {
                lit.Add(s.ToString());
                string result = "{\"keycode\":\"" + "" + "\",\"message\":\"seccse\",\"code\":\"200\",\"status\":true,\"data\":\"连接成功\"}";
                byte[] bytes = SerializeContent(result);
                ws.Reply(s.ToString(), new SAEA.WebSocket.Model.WSProtocal(SAEA.WebSocket.Type.WSProtocalType.Text, bytes));
            };
            ws.OnMessage += (s, e) =>
            {
                string content = Encoding.UTF8.GetString(e.Content);
                //读取参数
                if (content != "ping" && !string.IsNullOrEmpty(content))
                {
                    //返回内容
                    string result = string.Empty;
                    content = Base64str2(content);
                    if (!string.IsNullOrEmpty(content))
                    {
                        try
                        {
                            var json = content.ConvertToAnonymousType(new
                            {
                                code = default(string)
                            });
                            if (json != null)
                            {
                                //接收指令和参数
                                string keycode = json.code;
                                switch (keycode)
                                {
                                    //aks100101  
                                    //读取身份证卡号 {"code":"aks100101"}
                                    case "aks100101":
                                        result = IDCardRead(keycode);
                                        break;
                                    //aks100102  
                                    //打印排队票据 {"code":"aks100102","ph":"100101","ddrs":"中国检察","qrcode":"90087100100124433002","ywmc":"信访"}
                                    case "aks100102":
                                        result = SendByPrint(content);
                                        break;
                                    //aks100103  
                                    //文字语音播报  
                                    //播放：{ "code":"aks100103","text":"你好！","ispaye":false}， 
                                    //停止播放：{ "code":"aks100104","text":"","ispaye":true}
                                    case "aks100103":
                                        result = payleText(content);
                                        break;
                                    //aks100104  
                                    //打开高拍仪并且进行快速扫描文件 {"code":"aks100104"}
                                    case "aks100104":
                                        result = openCamera(keycode);
                                        break;
                                    //aks100105  
                                    //打开签字版  {"code":"aks100105"}
                                    case "aks100105":
                                        result = OpenSign(content);
                                        break;
                                    //aks100112  
                                    //关闭签字版 {"code":"aks100112"}
                                    case "aks100112":
                                        result = CloseSign(keycode);
                                        break;
                                    //aks100106 
                                    //指纹 {"code":"aks100106"}
                                    case "aks100106":
                                        result = ReadFingerData(keycode);
                                        break;
                                    //aks100107 开始录音、取消录音、结束录音
                                    // 开始录音：{ "code":"aks100107","url":"","isopen":true}
                                    // 取消录音：  { "code":"aks100107","url":"","isopen":false}
                                    // 结束录音：  { "code":"aks100107","url":"http://127.0.0.1/Upload","isopen":false}
                                    case "aks100107":
                                        result = SoundRecording(content);
                                        break;
                                    //aks100108 
                                    //根据文件地址在线打印  { "code":"aks100108","url":"http://127.0.0.1/test.doc","ext":"doc"}
                                    case "aks100108":
                                        result = PrintFile(content);
                                        break;
                                    //aks100109 
                                    //根据文件base64打印(PDF) { "code":"aks100109","base64":"ADFJLAKSDJFLKASJF...","ext":"pdf"}
                                    case "aks100109":
                                        //result = PrintBase64(content);
                                        result = "{\"keycode\":\"" + "aks100109" + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"Base64打印保留原方式\"}";
                                        break;
                                    //aks100110
                                    //播放音频文件 { "code":"aks100110","url":"http://127.0.0.1/test.wav","ispaye":false}
                                    //停止播放音频文件 { "code":"aks100110","url":"","ispaye":true}
                                    case "aks100110":
                                        result = PalyFile(content);
                                        break;
                                    //aks100111 唤醒键盘 {"code":"aks100111"}
                                    case "aks100111":
                                        result = openKey(keycode);
                                        break;
                                    //aks100113 指纹 {"code":"aks100113"}
                                    case "aks100113":
                                        result = ReadFingerData(keycode);
                                        break;
                                    default:
                                        result = "{\"keycode\":\"" + "" + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"无效指令\"}";
                                        break;
                                }
                            }
                            else
                            {
                                result = "{\"keycode\":\"" + "hert" + "\",\"message\":\"seccse\",\"code\":\"400\",\"status\":true,\"data\":\"参数解析错误\"}";
                            }
                        }
                        catch { result = "{\"keycode\":\"" + "hert" + "\",\"message\":\"seccse\",\"code\":\"400\",\"status\":true,\"data\":\"参数解析错误\"}"; }
                        finally { }
                    }
                    else
                    {
                        result = "{\"keycode\":\"" + "" + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"无效指令\"}";
                    }
                    //答复请求者(处理完请求后在些答复)
                    byte[] bytes = SerializeContent(result);
                    ws.Reply(s.ToString(), new SAEA.WebSocket.Model.WSProtocal(SAEA.WebSocket.Type.WSProtocalType.Text, bytes));
                }
                //监听心跳并且回复客户端“已ping作为关键字”
                else if (content == "ping")
                {
                    string result = "{\"keycode\":\"" + "hert" + "\",\"message\":\"seccse\",\"code\":\"200\",\"status\":true,\"data\":\"收到客户端心跳\"}";
                    byte[] bytes = SerializeContent(result);
                    ws.Reply(s.ToString(), new SAEA.WebSocket.Model.WSProtocal(SAEA.WebSocket.Type.WSProtocalType.Text, bytes));
                }
                else
                {
                    string result = "{\"keycode\":\"" + "hert" + "\",\"message\":\"seccse\",\"code\":\"200\",\"status\":true,\"data\":\"收到客户端心跳\"}";
                    byte[] bytes = SerializeContent(result);
                    ws.Reply(s.ToString(), new SAEA.WebSocket.Model.WSProtocal(SAEA.WebSocket.Type.WSProtocalType.Text, bytes));
                }
            };
            ws.OnDisconnected += (s) =>
            {
                try
                {
                    lit.RemoveAll(n => n == s);
                }
                catch { }
                finally { }
            };
            ws.Start();
        }

        //解包
        private static string DeserializeContent(byte[] param)
        {
            try
            {
                return Encoding.UTF8.GetString(param);
            }
            catch
            {
                return "参数无效";
            }
        }
        //封包
        private static byte[] SerializeContent(string param)
        {
            try
            {
                return Encoding.UTF8.GetBytes(param);
            }
            catch
            {
                return null;
                //return "参数无效";
            }
        }

        public static string callback = string.Empty;
        public static string PrinterName = "Lexmark-MS430-Series";
        public static Process recordingProcess;
        public static Process Typrocess;
        private static string srpath = string.Empty;

        /// <summary>
        /// aks100101 读取身份证卡号（已国产化）
        /// </summary>
        /// <param name="paramsString"></param>
        /// <returns></returns>
        public static string IDCardRead(string code)
        {
            try
            {
                //Finger("","");
                IDCard iDCard = new IDCard();
                string result = iDCard.getIdCard(code);
                SubmitLogs(result, "IDCardRead");
                return result;
            }
            catch (Exception ex)
            {
                //Log.Error("读取身份证卡号异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "IDCardRead");
                return result;
            }
        }

        /// <summary>
        /// aks100102 打印排队票据（已国产化）
        /// </summary>
        /// <param name="ph">排号</param>
        /// <param name="ddrs">等待人数</param>
        /// <param name="qrcode">二维码</param>
        /// <param name="ywmc">办理业务名称</param>
        /// <returns></returns>
        public static string SendByPrint(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string),
                ph = default(string),
                ddrs = default(string),
                qrcode = default(string),
                ywmc = default(string)
            });
            try
            {

                string ph = param.ph;
                string ddrs = param.ddrs;
                string qrcode = param.qrcode;
                string ywmc = param.ywmc;

                if (!isFuncisFuncObject("SendByPrint"))
                {
                    Utils.MessagesBox("打印排队票据设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "打印排队票据设备未授权使用" + "\"}";
                }
                else
                {
                    PrintPJ print = new PrintPJ(Parame.pritPj, Parame.pritPjPort);
                    var data = print.SendPrint(ph, ddrs, qrcode, ywmc);
                    if (data == 0)
                    {
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"seccse\",\"code\":\"200\",\"status\":true,\"data\":\"" + "打印成功" + "\"}";
                        SubmitLogs(result, "SendByPrint");
                        return result;
                    }
                    else
                    {
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + (data == 1 ? "打印失败" : (data == 2 ? "打印机未连接" : "打印机初始化失败")) + "\"}";
                        SubmitLogs(result, "SendByPrint");
                        return result;
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("打印排队票据异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "SendByPrint");
                return result;
            }
        }

        /// <summary>
        /// 文字语音播报（已国产化）
        /// apt install sox 
        /// apt install libsox-fmt-all
        /// </summary>
        /// <param name="text"></param>
        /// <param name="ispaye"></param>
        /// <returns></returns>
        public static string tempWav = string.Empty;
        /// <summary>
        /// aks100103文字语音播报
        /// </summary>
        /// <param name="content"></param>
        /// <returns></returns>
        public static string payleText(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string),
                text = default(string),
                ispaye = default(bool),
            });

            try
            {
                string text = param.text;
                bool ispaye = param.ispaye;
                if (!isFuncisFuncObject("payleText"))
                {
                    Utils.MessagesBox("文字语音播报设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "文字语音播报设备未授权使用" + "\"}";
                }
                else
                {
                    if (ispaye)
                    {
                        Task.Run(() =>
                        {
                            try
                            {
                                if (Typrocess != null)
                                {
                                    // 如果进程还在运行
                                    if (!Typrocess.HasExited)
                                    {
                                        // 发送SIGTERM信号来停止进程
                                        Typrocess.Kill();
                                        // 等待进程真正停止
                                        Typrocess.WaitForExit();
                                    }
                                }
                            }
                            catch (Exception ex)
                            {
                                //Log.Error("停止失败: " + ex.Message + "");
                            }
                            //AutoAudio(false, "");
                        });
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":\"" + "停止播放成功" + "\"}";
                        SubmitLogs(result, "payleText");
                        return result;
                    }
                    else
                    {
                        Task.Run(() =>
                        {
                            //形成语音
                            tempWav = GenerateWavFromText(text);
                            ////开始播放
                            string command = $"sox {tempWav} -d";
                            ShllCommad(command);
                            //AutoAudio(true, tempWav);
                        });
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":\"" + "开始播放" + "\"}";
                        SubmitLogs(result, "payleText");
                        return result;
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("文字语音播报异常2: " + ex.Message + "");
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "payleText");
                return result;
            }
        }

        /// <summary>
        /// aks100104打开高拍仪并且进行快速扫描文件 （已国产化）
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static string openCamera(string code)
        {
            try
            {
                string devIndex = GetSnIndex();
                if (string.IsNullOrEmpty(devIndex))
                {
                    string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"suffix\":\"jpg\",\"data\":\"" + "扫描仪打开失败" + "\"}";
                    SubmitLogs(result, "openCamera");
                    return result;
                }
                else
                {
                    //打开高拍仪
                    string param = OpenSn(devIndex);
                    if (string.IsNullOrEmpty(param))
                    {
                        string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"suffix\":\"jpg\",\"data\":\"" + "扫描仪打开失败" + "\"}";
                        SubmitLogs(result, "openCamera");
                        return result;
                    }
                    else
                    {
                        //拍照
                        param = getFrame();
                        if (string.IsNullOrEmpty(param))
                        {
                            //关闭
                            StopSn(devIndex);
                            string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"suffix\":\"jpg\",\"data\":\"" + "获取图片失败" + "\"}";
                            SubmitLogs(result, "openCamera");
                            return result;
                        }
                        else
                        {
                            //关闭
                            StopSn(devIndex);
                            string result = "{\"keycode\":\"" + code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"suffix\":\"jpg\",\"data\":\"" + param + "\"}";
                            SubmitLogs(result, "openCamera");
                            return result;
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("打开高拍仪并且进行快速扫描文件异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "openCamera");
                return result;
            }
        }

        /// <summary>
        ///  aks100105打开签字版 sudo apt-get install libgdiplus （已国产化）
        /// </summary>
        /// <param name="paramsString"></param>
        /// <returns></returns>
        public static string OpenSign(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string)
            });
            try
            {
                if (!isFuncisFuncObject("OpenSign"))
                {
                    Utils.MessagesBox("签字版设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "签字版设备未授权使用" + "\"}";
                }
                else
                {
                    Task.Run(() => { HttpPostResponseBySign("open", 1, param.code); event2.WaitOne(); });
                    string result = sginStr;
                    SubmitLogs(result, "OpenSign");
                    return result;
                }
            }
            catch (Exception ex)
            {
                //Log.Error("打开签字版异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "OpenSign");
                return result;
            }
        }

        /// <summary>
        /// 关闭签字版  （已国产化）
        /// </summary>
        /// <param name="paramsString"></param>
        /// <returns></returns>
        private static string CloseSign(string code)
        {
            try
            {
                if (!isFuncisFuncObject("OpenSign"))
                {
                    Utils.MessagesBox("签字版设备未授权使用");
                    return "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "签字版设备未授权使用" + "\"}";
                }
                else
                {
                    Task.Run(() => HttpPostResponseBySign("close", 2, ""));
                    string result = "{\"keycode\":\"" + code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"suffix\":\"jpg\",\"data\":\"" + "签字版已关闭" + "\"}";
                    SubmitLogs(result, "openCamera");
                    return result;
                }
            }
            catch (Exception ex)
            {
                //Log.Error("关闭签字版异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "OpenSign");
                return result;
            }
        }

        /// <summary>
        /// aks100106指纹 （已国产化，未完成测试）
        /// </summary>
        /// <param name="paramsString"></param>
        /// <returns></returns>
        public static string ReadFingerData(string code)
        {
            try
            {
                if (false)//!isFuncisFuncObject("Finger")
                {
                    Utils.MessagesBox("指纹设备未授权使用");
                    return "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "指纹设备未授权使用" + "\"}";
                }
                else
                {

                    string result = Fingerprint.LIVESCANFinger(code);
                    SubmitLogs(result, "Finger");
                    return result;
                }
            }
            catch (Exception ex)
            {
                //Log.Error("指纹异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "Finger");
                return result;
            }
        }

        /// <summary>
        /// aks100107开始录音、取消录音、结束录音 （已国产化）
        /// sudo apt-get update
        /// sudo apt-get install alsa-utils
        /// </summary>
        /// <param name="isopen"></param>
        /// <param name="url"></param>
        /// <returns></returns>
        public static string SoundRecording(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string),
                isopen = default(bool),
                url = default(string)
            });

            try
            {

                bool isopen = param.isopen;
                string url = param.url;
                if (!isFuncisFuncObject("SoundRecording"))
                {
                    Utils.MessagesBox("录音设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "录音设备未授权使用" + "\"}";
                }
                else
                {
                    //结束录音上传文件
                    if (!string.IsNullOrEmpty(url) && !isopen)
                    {
                        if (StopRecording())
                        {
                            Task.Run(async () =>
                            {
                                UploadInfo(url, srpath);
                            });
                            @event2.WaitOne();
                            Regex re = new Regex(@"(((?:[-;:&=\+\$,\w]+@)?[A-Za-z0-9.-]+(:[0-9]+)?|(?:ww‌​w.|[-;:&=\+\$,\w]+@)[A-Za-z0-9.-]+)((?:\/[\+~%\/.\w-_]*)?\??(?:[-\+=&;%@.\w_]*)#?‌​(?:[\w]*))?)");
                            MatchCollection mc = re.Matches(url);//获取的是一个数组
                            string reurl = mc[0].ToString() + "://" + mc[1].ToString() + urlpath;
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"suffix\":\"wav\",\"data\":\"" + reurl + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }
                        else
                        {
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"fali\",\"code\":\"400\",\"status\":false,\"suffix\":\"wav\",\"data\":\"" + "结束录音失败" + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }
                    }
                    else if (isopen)//开始录音
                    {
                        if (StartRecording())
                        {
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"suffix\":\"wav\",\"data\":\"" + "开始录音" + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }
                        else
                        {
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"fali\",\"code\":\"400\",\"status\":false,\"suffix\":\"wav\",\"data\":\"" + "录音失败" + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }
                    }
                    else //取消录音
                    {
                        if (StopRecording())
                        {
                            srpath = string.Empty;
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"suffix\":\"wav\",\"data\":\"" + "取消录音" + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }
                        else
                        {
                            srpath = string.Empty;
                            string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"suffix\":\"wav\",\"data\":\"" + "取消录音失败" + "\"}";
                            SubmitLogs(result, "SoundRecording");
                            return result;
                        }

                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("开始录音、取消录音、结束录音异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "SoundRecording");
                return result;
            }
        }

        /// <summary>
        /// aks100108根据文件地址在线打印 （已国产化）
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public static string PrintFile(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string),
                url = default(string),
                ext = default(string)
            });
            try
            {

                string url = param.url;
                string ext = param.ext;
                if (!isFuncisFuncObject("PrintFile"))
                {
                    Utils.MessagesBox("打印机设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "打印机设备未授权使用" + "\"}";
                }
                else
                {
                    Task.Run(async () =>
                    {
                        DateTime dateTime = DateTime.Now;
                        string time = DateTime.Now.ToString(
                            "yyyyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
                        string dirpath = System.IO.Directory.GetCurrentDirectory();
                        string[] array = dirpath.Split("/");
                        var groupCount = array.GroupBy(x => x).Select(group => new { Element = group.Key, Count = group.Count() }).Where(x => x.Count > 0);
                        if (groupCount.Count() == 1)
                        {
                            dirpath = dirpath + "/aks";
                        }
                        else if (groupCount.Count() == 0)
                        {
                            dirpath = dirpath + "/aks/aks";
                        }
                        dirpath = dirpath + @"/wwwroot/PrintFile";
                        if (!Directory.Exists(dirpath))
                        {
                            Directory.CreateDirectory(dirpath);
                        }
                        var filepath = System.IO.Path.Combine(dirpath, time);
                        string path = dirpath + @"/" + time + "." + ext;
                        WebRequest request = WebRequest.Create(url);
                        WebResponse response = request.GetResponse();
                        using (Stream stream = response.GetResponseStream())
                        {
                            using (FileStream fileStream = new FileStream(path, FileMode.Create))
                            {
                                stream.CopyTo(fileStream);
                            }
                        }
                        response.Close();
                        //Log.Info("根据文件base64打印: " + path + "");
                        string command = $"lp -d {PrinterName} {path}";
                        ShllCommad(command);
                    });
                    string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":\"" + "打印成功" + "\"}";
                    SubmitLogs(result, "PrintFile");
                    return result;
                }
            }
            catch (Exception ex)
            {
                //Log.Error("根据文件地址在线打印异常: " + ex.Message + "");
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "PrintFile");
                return result;
            }

        }

        /// <summary>
        /// aks100109根据文件base64打印 （已国产化）PrintBase64
        /// </summary>
        /// <param name="base64"></param>
        /// <param name="ext"></param>
        /// <returns></returns>
        [JSFunction]
        public static string PrintBase64(string url, string base64, string ext)
        {
            try
            {
                if (!isFuncisFuncObject("PrintBase64"))
                {
                    Utils.MessagesBox("打印机设备未授权使用");
                    return "{\"keycode\":\"" + "" + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "打印机设备未授权使用" + "\"}";
                }
                else
                {
                    Task.Run(async () =>
                    {
                        DateTime dateTime = DateTime.Now;
                        string time = DateTime.Now.ToString(
                            "yyyyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
                        string dirpath = System.IO.Directory.GetCurrentDirectory();
                        string[] array = dirpath.Split("/");
                        var groupCount = array.GroupBy(x => x).Select(group => new { Element = group.Key, Count = group.Count() }).Where(x => x.Count > 0);
                        if (groupCount.Count() == 1)
                        {
                            dirpath = dirpath + "/aks";
                        }
                        else if (groupCount.Count() == 0)
                        {
                            dirpath = dirpath + "/aks/aks";
                        }
                        dirpath = dirpath + @"/wwwroot/PrintFile";
                        if (!Directory.Exists(dirpath))
                        {
                            Directory.CreateDirectory(dirpath);
                        }
                        var filepath = System.IO.Path.Combine(dirpath, time);
                        string path = dirpath + @"/" + time + "." + ext;
                        byte[] bytes = Convert.FromBase64String(base64);
                        System.IO.FileStream stream = new System.IO.FileStream(path, System.IO.FileMode.CreateNew);
                        System.IO.BinaryWriter writer = new System.IO.BinaryWriter(stream);
                        writer.Write(bytes, 0, bytes.Length);
                        writer.Close();
                        //Log.Info("根据文件base64打印: " + path + "");
                        string command = $"lp -d {PrinterName} {path}";
                        ShllCommad(command);
                    });
                    string result = "{\"keycode\":\"" + "" + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":\"" + "打印成功" + "\"}";
                    SubmitLogs(result, "PrintBase64");
                    return result;
                }
            }
            catch (Exception ex)
            {
                string result = "{\"keycode\":\"" + "" + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "PrintBase64");
                return result;
            }
        }

        /// <summary>
        /// aks100110播放音频文件 （已国产化）
        /// </summary>
        /// <param name="url"></param>
        /// <param name="ispaly"></param>
        /// <returns></returns>
        public static string PalyFile(string content)
        {
            var param = content.ConvertToAnonymousType(new
            {
                code = default(string),
                url = default(string),
                ispaly = default(bool)
            });
            try
            {
                string url = param.url;
                bool ispaly = param.ispaly;
                if (!isFuncisFuncObject("PalyFile"))
                {
                    Utils.MessagesBox("音频设备未授权使用");
                    return "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + "音频设备未授权使用" + "\"}";
                }
                else
                {
                    if (ispaly)
                    {
                        Task.Run(() =>
                        {
                            //if (Typrocess != null)
                            //{
                            //    // 如果进程还在运行
                            //    if (!Typrocess.HasExited)
                            //    {
                            //        // 发送SIGTERM信号来停止进程
                            //        Typrocess.Kill();
                            //        // 等待进程真正停止
                            //        Typrocess.WaitForExit();
                            //    }
                            //}
                            AutoAudio(ispaly, "");
                        });
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":" + "停止播放成功" + "}";
                        SubmitLogs(result, "PalyFile");
                        return result;
                    }
                    else
                    {
                        Task.Run(() =>
                        {
                            Uri uri = new Uri(url);
                            //返回 123.xlsx
                            var filename = HttpUtility.UrlDecode(uri.Segments.Last());
                            //获取文件后缀
                            string ext = System.IO.Path.GetExtension(filename);
                            DateTime dateTime = DateTime.Now;
                            string time = DateTime.Now.ToString(
                                "yyyyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
                            string dirpath = System.IO.Directory.GetCurrentDirectory();
                            string[] array = dirpath.Split("/");
                            var groupCount = array.GroupBy(x => x).Select(group => new { Element = group.Key, Count = group.Count() }).Where(x => x.Count > 0);
                            if (groupCount.Count() == 1)
                            {
                                dirpath = dirpath + "/aks";
                            }
                            else if (groupCount.Count() == 0)
                            {
                                dirpath = dirpath + "/aks/aks";
                            }
                            dirpath = dirpath + @"/wwwroot/WaveOutFile";
                            if (!Directory.Exists(dirpath))
                            {
                                Directory.CreateDirectory(dirpath);
                            }
                            string path = dirpath + @"/" + time + ext;
                            WebRequest request = WebRequest.Create(url);
                            WebResponse response = request.GetResponse();
                            using (Stream stream = response.GetResponseStream())
                            {
                                using (FileStream fileStream = new FileStream(path, FileMode.Create))
                                {
                                    stream.CopyTo(fileStream);
                                }
                            }
                            response.Close();

                            //开始播放
                            //string command = $"sox {path} -d";
                            //ShllCommad(command);
                            AutoAudio(ispaly, path);
                        });
                        string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"success\",\"code\":\"200\",\"status\":true,\"data\":" + "开始播放" + "}";
                        SubmitLogs(result, "PalyFile");
                        return result;
                    }
                }
            }
            catch (Exception ex)
            {
                string result = "{\"keycode\":\"" + param.code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
                SubmitLogs(result, "PalyFile");
                return result;
            }
        }

        /// <summary>
        /// aks100111唤醒键盘 （已国产化）
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public static string openKey(string code)
        {
            try
            {
                Task.Run(() =>
                {
                    Bash("/usr/bin/python3 /usr/bin/onboard");
                });
                return "{\"keycode\":\"" + code + "\",\"message\":\"seccse\",\"code\":\"200\",\"status\":true,\"data\":\"" + "唤醒键盘成功" + "\"}";
            }
            catch (Exception ex)
            {
                //Log.Error("唤醒键盘异常: " + ex.Message + "");
                return "{\"keycode\":\"" + code + "\",\"message\":\"Falied\",\"code\":\"400\",\"status\":false,\"data\":\"" + ex.Message + "\"}";
            }
        }

        /// <summary>
        /// 执行文件
        /// </summary>
        /// <param name="command"></param>
        /// <returns></returns>
        public static string Bash(string command)
        {
            try
            {
                var escapedArgs = command.Replace("\"", "\\\"");
                var process = new Process()
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "/bin/bash",
                        Arguments = $"-c \"{escapedArgs}\"",
                        RedirectStandardOutput = true,
                        UseShellExecute = false,
                        CreateNoWindow = true,
                    }
                };
                process.Start();
                string result = process.StandardOutput.ReadToEnd();
                process.WaitForExit();
                process.Dispose();
                return result;
            }
            catch (Exception ex)
            {
                //Log.Error("执行文件异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 获取设备index
        /// </summary>
        /// <returns></returns>
        public static string GetSnIndex()
        {
            try
            {
                //获取设备信息
                string param = "/GetAllDisplayInfo";
                Task.Run(() => HttpResponse(param));
                @event6.WaitOne();
                if (string.IsNullOrEmpty(gpyStr))
                {
                    return "";
                }
                else
                {
                    JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                    if (jo["returnCode"].ToString() == "0")
                    {
                        string result = jo["data"].ToString();
                        // Log.Info(result);
                        JArray jo1 = (JArray)JsonConvert.DeserializeObject(result);
                        string devidx = string.Empty;
                        string name = string.Empty;
                        foreach (JObject jo2 in jo1)
                        {
                            devidx = jo2["dev_idx"].ToString();
                            name = jo2["name"].ToString();
                            // Log.Info(name);
                            break;
                        }
                        return devidx;
                    }
                    else
                    {
                        // Log.Info(jo["returnMsg"].ToString());
                        return "";
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("获取设备index异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 打开高拍仪
        /// </summary>
        /// <returns></returns>
        public static string OpenSn(string dev_idx)
        {
            try
            {
                //获取设备信息
                string param = "/StartPreview?dev_idx=" + dev_idx + "&res_id=0";
                Task.Run(() => HttpResponse(param));
                @event6.WaitOne();
                if (string.IsNullOrEmpty(gpyStr))
                {
                    return "";
                }
                else
                {
                    JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                    if (jo["returnCode"].ToString() == "0")
                    {
                        return "200";
                    }
                    if (jo["returnCode"].ToString() == "2")
                    {
                        return "200";
                    }
                    else
                    {
                        // Log.Info(jo["returnMsg"].ToString());
                        return "";
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("打开高拍仪异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 关闭高拍仪
        /// </summary>
        /// <returns></returns>
        public static string StopSn(string dev_idx)
        {
            //获取设备信息
            string param = "/StopPreview?dev_idx=" + dev_idx;
            Task.Run(() => HttpResponse(param));
            @event6.WaitOne();
            if (string.IsNullOrEmpty(gpyStr))
            {
                return "";
            }
            else
            {
                JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                if (jo["returnCode"].ToString() == "0")
                {
                    return "200";
                }
                else
                {
                    // Log.Info(jo["returnMsg"].ToString());
                    return "";
                }
            }
        }

        /// <summary>
        /// 拍照
        /// </summary>
        /// <returns></returns>
        public static string getFrame()
        {
            try
            {
                //获取设备信息
                string param = "/getFrame";
                Task.Run(() => HttpResponse(param));
                @event6.WaitOne();
                if (string.IsNullOrEmpty(gpyStr))
                {
                    return "";
                }
                else
                {
                    JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                    if (jo["returnCode"].ToString() == "0")
                    {
                        string result = jo["data"].ToString();
                        JObject jo1 = (JObject)JsonConvert.DeserializeObject(result);
                        return jo1["img"].ToString();
                    }
                    else
                    {
                        // Log.Info(jo["returnMsg"].ToString());
                        return "";
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("拍照异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 右转
        /// </summary>
        /// <returns></returns>
        public static string RotateRight()
        {
            try
            {
                //获取设备信息
                string param = "/rotate/right";
                Task.Run(() => HttpResponse(param));
                @event6.WaitOne();
                if (string.IsNullOrEmpty(gpyStr))
                {
                    return "";
                }
                else
                {
                    JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                    if (jo["returnCode"].ToString() == "0")
                    {
                        return "200";
                    }
                    else
                    {
                        // Log.Info(jo["returnMsg"].ToString());
                        return "";
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("右转异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 左转
        /// </summary>
        /// <returns></returns>
        public static string RotateLeft()
        {
            try
            {
                //获取设备信息
                string param = "/rotate/left";
                Task.Run(() => HttpResponse(param));
                @event6.WaitOne();
                if (string.IsNullOrEmpty(gpyStr))
                {
                    return "";
                }
                else
                {
                    JObject jo = (JObject)JsonConvert.DeserializeObject(gpyStr);
                    if (jo["returnCode"].ToString() == "0")
                    {
                        return "200";
                    }
                    else
                    {
                        // Log.Info(jo["returnMsg"].ToString());
                        return "";
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("左转异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// 高拍仪
        /// </summary>
        private static string gpyStr = string.Empty;
        private static AutoResetEvent @event6 = new AutoResetEvent(false);
        private static async void HttpResponse(string param)
        {
            try
            {
                var httpClient = new HttpClient();
                var uploader = new ChunkedUpload(httpClient);
                gpyStr = await uploader.getReq(param);
                @event6.Set();
            }
            catch (Exception ex)
            {
                //Log.Error("高拍仪异常：" + ex.Message);
            }
        }

        private static string sginStr = string.Empty;
        /// <summary>
        /// 签字版
        /// </summary>
        private static async void HttpPostResponseBySign(string type, int typeCode, string code)
        {
            try
            {
                var httpClient = new HttpClient();
                var uploader = new ChunkedUpload(httpClient);
                sginStr = await uploader.PostSign(type, typeCode, code);
                @event2.Set();
            }
            catch (Exception ex)
            {
                //Log.Error("签字版异常：" + ex.Message);
            }
        }

        /// <summary>
        /// 初始文件上传
        /// </summary>
        private static string urlpath = string.Empty;
        private static AutoResetEvent @event2 = new AutoResetEvent(false);
        private static async void UploadInfo(string url, string srpath)
        {
            try
            {
                var httpClient = new HttpClient();
                var uploader = new ChunkedUpload(httpClient);
                urlpath = await uploader.UploadFileAsync(url, srpath);
                @event2.Set();
            }
            catch (Exception ex)
            {
                //Log.Error("初始文件上传异常：" + ex.Message);
            }
        }

        //上传本地文件中转
        private static string urlP = string.Empty;
        private static AutoResetEvent @event5 = new AutoResetEvent(false);
        private static async void UploadInfoByFile(string url, string strpath)
        {
            try
            {
                var httpClient = new HttpClient();
                var uploader = new ChunkedUpload(httpClient);
                urlP = await uploader.UploadFileAsync(url, strpath);
                File.Delete(strpath);
                @event5.Set();
            }
            catch (Exception ex)
            {
                //Log.Error("上传本地文件中转异常：" + ex.Message);
            }
        }

        //根据程序名称杀死进程
        public static void KillProcessByName(string processName)
        {
            try
            {
                Process[] processes = Process.GetProcessesByName(processName);

                foreach (Process process in processes)
                {
                    try
                    {
                        process.Kill();
                        process.WaitForExit(); // 等待进程退出
                    }
                    catch (Exception ex) { }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("根据程序名称杀死进程异常：" + ex.Message);
            }
        }

        /// <summary>
        /// 开始录音
        /// </summary>
        /// <returns></returns>
        public static bool StartRecording()
        {
            try
            {
                if (recordingProcess != null)
                {
                    // 如果进程还在运行
                    if (!recordingProcess.HasExited)
                    {
                        // 发送SIGTERM信号来停止arecord进程
                        recordingProcess.Kill();
                        recordingProcess.WaitForExit(); // 等待进程真正停止
                    }
                }
                string time = DateTime.Now.ToString(
                "yyyyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
                string dirpath = System.IO.Directory.GetCurrentDirectory();
                string[] array = dirpath.Split("/");
                var groupCount = array.GroupBy(x => x).Select(group => new { Element = group.Key, Count = group.Count() }).Where(x => x.Count > 0);
                if (groupCount.Count() == 1)
                {
                    dirpath = dirpath + "/aks";
                }
                else if (groupCount.Count() == 0)
                {
                    dirpath = dirpath + "/aks/aks";
                }
                dirpath = dirpath + @"/wwwroot/Record";
                if (!Directory.Exists(dirpath))
                {
                    Directory.CreateDirectory(dirpath);
                }
                srpath = dirpath + "/" + time + ".wav";
                string outputFile = srpath; // 输出文件名
                string device = "default"; // 音频设备，可以通过arecord -l来列出所有设备
                                           // 构建arecord命令
                string command = $"arecord --device={device} --file-type=wav --duration=10 --quiet {outputFile}";
                // 启动进程
                recordingProcess = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "/bin/bash",
                        Arguments = $"-c \"{command}\"",
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true
                    }
                };
                recordingProcess.Start();
                return true;
            }
            catch (Exception ex)
            {
                //Log.Error("开始录音异常：" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 结束录音
        /// </summary>
        public static bool StopRecording()
        {
            try
            {
                // 如果进程还在运行
                if (!recordingProcess.HasExited)
                {
                    // 发送SIGTERM信号来停止arecord进程
                    recordingProcess.Kill();
                    recordingProcess.WaitForExit(); // 等待进程真正停止
                }
                return true;
            }
            catch (Exception ex)
            {
                //Log.Error("结束录音异常：" + ex.Message);
                return false;
            }
        }

        /// <summary>
        /// 执行命令
        /// </summary>
        public static void ShllCommad(string command)
        {
            try
            {
                //Log.Info("执行命令：" + command);
                // 启动进程
                Typrocess = new Process
                {
                    StartInfo = new ProcessStartInfo
                    {
                        FileName = "/bin/bash",
                        Arguments = $"-c \"{command}\"",
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        CreateNoWindow = true
                    }
                };
                Typrocess.Start();
                Typrocess.WaitForExit();
            }
            catch (Exception ex)
            {
                //Log.Error("执行命令异常：" + ex.Message);
            }
        }

        /// <summary>
        /// 开源文字转语音
        /// sudo apt-get install espeak
        /// </summary>
        /// <param name="text"></param>
        /// <returns></returns>
        static string GenerateWavFromText(string text)
        {
            string time = DateTime.Now.ToString(
                "yyyyMMddHHmmss", DateTimeFormatInfo.InvariantInfo);
            string dirpath = System.IO.Directory.GetCurrentDirectory();
            string[] array = dirpath.Split("/");
            var groupCount = array.GroupBy(x => x).Select(group => new { Element = group.Key, Count = group.Count() }).Where(x => x.Count > 0);
            if (groupCount.Count() == 1)
            {
                dirpath = dirpath + "/aks";
            }
            else if (groupCount.Count() == 0)
            {
                dirpath = dirpath + "/aks/aks";
            }
            dirpath = dirpath + @"/wwwroot/WavFile";
            // Log.Info(dirpath);
            if (!Directory.Exists(dirpath))
            {
                Directory.CreateDirectory(dirpath);
            }
            var tempFile = dirpath + "/" + time + ".wav";
            try
            {
                text = text.Replace("（", "").Replace("）", "、");
                ProcessStartInfo startInfo = new ProcessStartInfo
                {
                    FileName = "espeak",
                    Arguments = $" -vzh -s 150  \"{text}\" -w {tempFile}", // 设置语速为150，输出为WAV文件
                    UseShellExecute = false,
                    RedirectStandardOutput = true,
                    CreateNoWindow = true
                };
                using (Process process = Process.Start(startInfo))
                {
                    process.WaitForExit(); // 等待进程结束
                    process.Close();
                    process.Dispose();
                }
            }
            catch (Exception ex)
            {
                //Log.Error("文字转语音失败：" + ex.Message);
            }
            return tempFile;
        }

        /// <summary>
        /// 是否已获取收取
        /// </summary>
        /// <param name="funcName"></param>
        /// <returns></returns>
        public static bool isFuncisFuncObject(string funcName)
        {
            bool isFunc = false;
            try
            {
                if (Parame.FuncObject != null)
                {
                    if (Parame.FuncObject.Count > 0)
                    {
                        foreach (Func func in Parame.FuncObject)
                        {
                            if (func.Interfaceaddress.Contains(funcName))
                            {
                                isFunc = true;
                                break;
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                //Log.Error("是否已获取收取异常：" + ex.Message);
            }
            return isFunc;
        }

        /// <summary>
        /// 提交设备操作日志
        /// </summary>
        /// <param name="Describer"></param>
        /// <param name="funcName"></param>
        public static void SubmitLogs(string Describer, string funcName)
        {
            try
            {
                Task.Run(async () =>
                    {
                        string ApiId = string.Empty;
                        string Name = string.Empty;
                        string Interfaceaddress = string.Empty;
                        bool isFunc = false;
                        if (Parame.FuncObject != null)
                        {
                            if (Parame.FuncObject.Count > 0)
                            {
                                foreach (Func func in Parame.FuncObject)
                                {
                                    if (func.Interfaceaddress.Contains(funcName))
                                    {
                                        isFunc = true;
                                        ApiId = func.Id;
                                        Name = func.Platform;
                                        Interfaceaddress = func.Interfaceaddress;
                                        break;
                                    }
                                }
                            }
                        }
                        if (isFunc)
                        {
                            var client = new HttpClient();
                            var request = new HttpRequestMessage(HttpMethod.Post, $"{Parame.apiUrl}/api/Interface/JournalAdd");
                            var content = new StringContent("{\"Name\": \"" + Name + "\",\"Describer\": \"" + str2Base64(Describer) + "\", \"Interfaceaddress\": \"" + Interfaceaddress + "\", \"ApiId\": \"" + ApiId + "\"}", null, "application/json");
                            request.Content = content;
                            var response = await client.SendAsync(request);
                            if (response.StatusCode.ToString() == "200")
                            {
                                response.EnsureSuccessStatusCode();
                                var body = await response.Content.ReadAsStringAsync();
                                //Log.Info(body);
                            }
                        }
                    });
            }
            catch (Exception ex)
            {
                //Log.Error("提交设备操作日志异常：" + ex.Message);
            }
        }

        /// <summary>
        /// 播放语音文件
        /// </summary>
        /// <param name="ispaly"></param>
        public static void AutoAudio(bool ispaly, string path)
        {
            try
            {
                if (ispaly)
                {
                    Parame.videoV.Play(new Uri(path));//播放
                }
                else
                {
                    Parame.videoV.Pause();//停止
                }
            }
            catch (Exception ex)
            {
                //Log.Error("播放语音文件异常：" + ex.Message);
            }
        }

        /// <summary>
        /// string 转换为 base64
        /// </summary>
        /// <returns></returns>
        public static string str2Base64(string str)
        {
            try
            {
                byte[] b = System.Text.Encoding.UTF8.GetBytes(str);
                string result = Convert.ToBase64String(b);
                return result;
            }
            catch (Exception ex)
            {
                //Log.Error("string 转换为 base64异常：" + ex.Message);
            }
            return "";
        }

        /// <summary>
        /// base64 转换为 string
        /// </summary>
        /// <param name="data"></param>
        public static string Base64str2(string data)
        {
            try
            {
                byte[] c = Convert.FromBase64String(data);
                string result = System.Text.Encoding.UTF8.GetString(c);
                //Log.Info("接收返回数据：" + result);
                return result;
            }
            catch (Exception ex)
            {
                //Log.Error("base64 转换为 string异常：" + ex.Message);
            }
            return "";
        }
    }
}