xiaomiMes/MainForm/ClassFile/XiaomiAPI_MES/XiaomiMESHttp_UpLoadFile.cs

using BZFAStandardLib;
using Newtonsoft.Json;
using Sunny.UI.Win32;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Security.Policy;
using System.Text;
using System.Threading.Tasks;
using static MainForm.ClassFile.XiaomiAPI.XiaomiMqttClient_Extend;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationInbound;
using static MainForm.ClassFile.XiaomiAPI_MES.XiaomiMESHttp_StationOutbound.XmMES_StationOutRequest_Body;
using static MainForm.ClassFile.XiaomiClass.MesHelper;

namespace MainForm.ClassFile.XiaomiAPI_MES
{
    /// <summary>
    /// 小米MES - 进站接⼝
    /// 接口地址：
    /// 接口方法：UnitConfirmDataSetIn
    /// </summary>
    public class XiaomiMESHttp_UpLoadFile : XiaomiMESHttp_X5
    {
        #region 变量
        /// <summary>
        /// 接口地址
        /// </summary>
        protected new static string UpFileUrl { set; get; } = GlobalContext.UpFileUrl;

        /// <summary>
        /// 接口方法
        /// </summary>
        protected new static string Method { set; get; } = "UploadMqtt";
        #endregion 变量
        /// <summary>
        /// 文件上传到 MES 系统
        /// </summary>
        /// <param name="wJPath">文件路径</param>
        /// <param name="fileUpload_X5">文件上传参数</param>
        /// <param name="fileMqttPayload">MQTT 负载参数</param>
        /// <returns>(状态码, 结果信息)</returns>
        public static async Task<(int, string)> FileUoladToMes(string wJPath, FileUpload_X5 fileUpload_X5, FileMqttPayload fileMqttPayload)
        {
            try
            {
                // 基础参数
                string url = "http://cm.pre.mi.com/file/x5/file/upload/mqtt";
                url = "http://im.pre.mi.com/file/x5/file/upload/mqtt";
                //这个之后要加到配置文件config中
                string appid = "Auto-Soft";
                //这个之后要加到配置文件config中
                string appkey = "5984710e-bb38-4806-b94d-7a9a727e3880";
                string method = "UploadMqtt";

                // 检查文件是否存在
                if (!System.IO.File.Exists(wJPath))
                {
                    return (-1, "文件不存在");
                }
                // 获取文件信息
                FileInfo file = new FileInfo(wJPath);

                // 构造 body
                string body = BuildBody(fileUpload_X5, fileMqttPayload);

                // 计算 sign
                string sign = GetSign(appid + body + appkey); // MD5 加密

                // 构造 header
                Dictionary<string, string> header = BuildHeader(url, appid, method, sign);

                // 构造 data 参数
                Dictionary<string, object> dataParam = new Dictionary<string, object>
                {
                    { "header", header },
                    { "body", body }
                };

                // 将 data 参数序列化为 Base64 编码的字符串
                string data = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(dataParam)));

                // 调用上传方法
                var uploadResult = UploadFile(url, file, data).Result;

                string logPath = GlobalContext.MqttFileUpLogDir + "FileInfo" + DateTime.Now.ToString("yyyyMMdd") + ".txt";
                FileOperate.NewTxtFile(logPath, "【文件提交】HTTP提交：" + JsonConvert.SerializeObject(dataParam) + "\r\n==>提交结果：" + uploadResult + "");

                //获取返回参数
                FileUpload_Result fileUpList = JsonConvert.DeserializeObject<FileUpload_Result>(uploadResult);
                //附件信息添加到主页面
                FileData fileData = new FileData();
                fileData.FileName = file.Name;
                fileData.FileId = fileUpList.body.uuid;
                fileData.Bucket = fileUpList.body.bucket;
                Form_Home home = new Form_Home();
                home.fileUploadData.fileData.Add(fileData);

                // 判断上传结果
                if (!string.IsNullOrEmpty(uploadResult) && !uploadResult.StartsWith("异常:") && !uploadResult.StartsWith("HTTP 错误:"))
                {
                    //删除文件
                    (bool, string) newResult = DeleteFile(wJPath);
                    if (!newResult.Item1)
                    {
                        return (0, fileUpload_X5.name+newResult.Item2);

                    }
                    return (0, fileUpload_X5.name + $"文件上传成功");
                }
                else
                {
                    return (-2, fileUpload_X5.name+$"文件上传失败: {uploadResult}");
                }
            }
            catch (Exception ex)
            {
                return (-3, fileUpload_X5.name+$"发生异常: {ex.Message}");
            }
        }

        /// <summary>
        /// 将文件复制到目标文件夹，并删除源文件
        /// </summary>
        /// <param name="sourceFilePath">源文件路径</param>
        /// <param name="destinationFolderPath">目标文件夹路径</param>
        static string CopyAndDeleteFile(string sourceFilePath, string destinationFolderPath)
        {
            try
            {
                // 检查目标文件夹是否存在，如果不存在则创建
                if (!Directory.Exists(destinationFolderPath))
                {
                    Directory.CreateDirectory(destinationFolderPath);
                }

                // 构建目标文件的完整路径
                string fileName = Path.GetFileName(sourceFilePath); // 获取源文件的文件名
                string destinationFilePath = Path.Combine(destinationFolderPath, fileName);

                // 如果目标文件已存在，则删除已有文件以避免冲突
                if (File.Exists(destinationFilePath))
                {
                    File.Delete(destinationFilePath); // 删除已有文件
                }

                // 检查文件是否准备好
                if (!IsFileReady(sourceFilePath))
                {
                    throw new IOException($"文件 {sourceFilePath} 正被其他进程占用，无法进行复制和删除操作。");
                }

                // 复制文件到目标文件夹
                File.Copy(sourceFilePath, destinationFilePath);

                // 删除源文件
                File.Delete(sourceFilePath);

                Console.WriteLine($"文件已从 {sourceFilePath} 成功复制到 {destinationFilePath} 并删除原文件。");

                // 返回目标文件路径
                return destinationFilePath;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"文件转移失败: {ex.Message}");
                return null; // 或者返回空字符串，根据需求决定
            }
        }

        /// <summary>
        /// 删除文件
        /// </summary>
        /// <param name="sourceFilePath">文件路径</param>
        static (bool,string) DeleteFile(string sourceFilePath)
        {
            try
            {
                // 构建目标文件的完整路径
                string fileName = Path.GetFileName(sourceFilePath); // 获取源文件的文件名

                // 检查文件是否准备好
                if (!IsFileReady(sourceFilePath))
                {
                    throw new IOException($"文件 {sourceFilePath} 正被其他进程占用，无法进行复制和删除操作。");
                }
                // 删除源文件
                File.Delete(sourceFilePath);

                return (true, "文件删除成功!");
            }
            catch (Exception ex)
            {
                return (false, "文件删除失败!"+ex.Message);
            }
        }
        public static bool IsFileReady(string filePath)
        {
            try
            {
                using (FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.ReadWrite, FileShare.None))
                {
                    stream.Close();
                }
                return true;
            }
            catch (IOException)
            {
                return false;
            }
        }

        /// <summary>
        /// 文件MD5加密
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public static string GetMD5Hex(FileInfo file)
        {
            using (MD5 md5 = MD5.Create())
            {
                using (FileStream stream = file.OpenRead())
                {
                    byte[] hashBytes = md5.ComputeHash(stream);
                    StringBuilder sb = new StringBuilder();
                    for (int i = 0; i < hashBytes.Length; i++)
                    {
                        sb.Append(hashBytes[i].ToString("x2"));
                    }
                    return sb.ToString();
                }
            }
        }
        /// <summary>
        /// 数据pin接
        /// </summary>
        /// <param name="file"></param>
        /// <param name="fileMd5Hex"></param>
        /// <returns></returns>
        public static string BuildBody(FileUpload_X5 file, FileMqttPayload payload)
        {
            Dictionary<string, object> fileMetadata = new Dictionary<string, object>();
            Dictionary<string, string> mqttPayLoad = new Dictionary<string, string>();
            mqttPayLoad.Add("factory", payload.factory);
            mqttPayLoad.Add("project_name", payload.project_name);
            mqttPayLoad.Add("product_mode", payload.product_mode);
            mqttPayLoad.Add("line_no", payload.line_no);
            mqttPayLoad.Add("work_station_no", payload.work_station_no);
            mqttPayLoad.Add("equipment_no", payload.equipment_no);
            mqttPayLoad.Add("station_no", payload.station_no);
            mqttPayLoad.Add("file_id", payload.file_id);
            mqttPayLoad.Add("file_name", payload.file_name);
            mqttPayLoad.Add("sn", payload.sn);
            mqttPayLoad.Add("opt_time", payload.opt_time);
            mqttPayLoad.Add("file_type", payload.file_type);
            mqttPayLoad.Add("file_category", payload.file_category);
            mqttPayLoad.Add("tag", payload.tag);
            mqttPayLoad.Add("reference_info", Newtonsoft.Json.JsonConvert.SerializeObject(new object[] { new { pass_station_id = payload.reference_info.pass_station_id } }));

            fileMetadata.Add("bucket", file.bucket);
            fileMetadata.Add("name", file.name);
            fileMetadata.Add("uuid", file.uuid);
            fileMetadata.Add("md5", file.md5);
            fileMetadata.Add("uploadCloud", file.uploadCloud);
            fileMetadata.Add("informMqtt", file.informMqtt);
            fileMetadata.Add("mqttPayload", Newtonsoft.Json.JsonConvert.SerializeObject(mqttPayLoad));
            string body = Newtonsoft.Json.JsonConvert.SerializeObject(fileMetadata);
            return body;
        }
        /// <summary>
        /// 数据头拼接
        /// </summary>
        /// <param name="url"></param>
        /// <param name="appid"></param>
        /// <param name="method"></param>
        /// <param name="sign"></param>
        /// <returns></returns>
        public static Dictionary<string, string> BuildHeader(string url, string appid, string method, string sign)
        {
            Dictionary<string, string> header = new Dictionary<string, string>();
            header.Add("appid", appid);
            header.Add("method", method);
            header.Add("sign", sign);
            header.Add("url", url);
            return header;
        }

        public static string GetGuid()
        {
            return (System.Guid.NewGuid().ToString("N"));
        }

        /// <summary>
        /// 异步文件上传
        /// </summary>
        /// <param name="url">上传地址</param>
        /// <param name="file">文件路径</param>
        /// <param name="data">上传的数据</param>
        /// <returns>返回上传结果</returns>
        public static async Task<string> UploadFile(string url, FileInfo file, string data)
        {
            using (var httpClient = new HttpClient())
            {
                //httpClient.Timeout = new TimeSpan(80000000);

                var formData = new MultipartFormDataContent();
                // 添加文件
                var fileContent = new StreamContent(file.OpenRead());
                formData.Add(fileContent, "file", file.Name);
                // 添加数据
                formData.Add(new StringContent(data), "data");

                try
                {
                    //var response = await httpClient.PostAsync(url, formData);
                    var response = httpClient.PostAsync(url, formData).Result;

                    if (response.IsSuccessStatusCode)
                    {
                        return await response.Content.ReadAsStringAsync();
                    }
                    else
                    {
                        return $"HTTP 错误: {response.StatusCode}";
                    }
                }
                catch (Exception e)
                {
                    return $"异常: {e.Message}";
                }

            }
        }

        /// <summary>
        /// MD5加密
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string GetSign(string data)
        {
            // 实例化一个md5对像
            MD5 md5 = MD5.Create();
            // MD5加密
            byte[] encodingMd5Data = md5.ComputeHash(Encoding.UTF8.GetBytes(data));
            // 生成签名字段
            string sign = "";
            for (int i = 0; i < encodingMd5Data.Length; i++)
            {
                // 将得到的字符串使用十六进制类型格式。格式后的字符是小写的字母，如果使用大写（X）则格式后的字符是大写字符
                sign += encodingMd5Data[i].ToString("X2");
            }
            return sign;
        }


        public class FileUpload_X5
        {
            /// <summary>
            /// ⽂件所属包
            /// 必填
            /*
             ${file_category}/${file_type}/${项⽬号}/${⽣
                产阶段}/${运⾏模式}/${过站结果}/${装备编
                码}/${sn}/${pass_station_id}
                • 其中file_category的枚举值为：
                ◦ IMAGE
                ◦ TEXT
                • 若对应字段的值为空，则使⽤默认值
                UNKNOWN
                注意：⾸位不能出现/，否则会出现路径错误
                问题。
                如：
                正确⽰例
                IMAGE/IMAGE/N3/debug/online/PASS/MPA-0001/P320N000006B/382f55e9-c2bb 
             */
            /// </summary>
            public string bucket { get; set; } = string.Empty;
            /// <summary>
            /// 文件名
            /// </summary>
            public string name { get; set; } = string.Empty;
            /// <summary>
            /// 文件唯一标识符
            /// </summary>
            public string uuid { get; set; } = string.Empty;
            /// <summary>
            /// md5 传空
            /// </summary>
            public string md5 { get; set; } = string.Empty;
            /// <summary>
            /// 是否上云 默认true
            /// </summary>
            public Boolean uploadCloud { get; set; }
            /// <summary>
            /// 是否通知Mqtt 默认true
            /// </summary>
            public Boolean informMqtt { get; set; }

        }

        public class FileMqttPayload
        {
            /// <summary>
            /// 工厂编码
            /// </summary>
            public string factory { get; set; } = string.Empty;
            /// <summary>
            /// 项目号
            /// </summary>
            public string project_name { get; set; } = string.Empty;
            /// <summary>
            /// 生产阶段
            /// </summary>
            public string product_mode { get; set; } = string.Empty;
            /// <summary>
            /// 线体
            /// </summary>
            public string line_no { get; set; } = string.Empty;
            /// <summary>
            /// 工站
            /// </summary>
            public string work_station_no { get; set; } = string.Empty;
            /// <summary>
            /// 装备
            /// </summary>
            public string equipment_no { get; set; } = string.Empty;
            /// <summary>
            /// 工位
            /// </summary>
            public string station_no { get; set; } = string.Empty;
            /// <summary>
            /// 文件ID
            /// </summary>
            public string file_id { get; set; } = string.Empty;
            /// <summary>
            /// 文件名
            /// </summary>
            public string file_name { get; set; } = string.Empty;
            /// <summary>
            /// 产品sn    
            /// </summary>
            public string sn { get; set; } = string.Empty;
            /// <summary>
            /// 文件生成时间
            /// </summary>
            public string opt_time { get; set; } = string.Empty;
            /// <summary>
            /// 文件类型
            /// </summary>
            public string file_type { get; set; } = string.Empty;
            /// <summary>
            /// 文件类别
            /// </summary>
            public string file_category { get; set; } = string.Empty;
            /// <summary>
            /// 自定义标签信息
            /// </summary>
            public string tag { get; set; } = string.Empty;
            /// <summary>
            /// 关联业务信息
            /// </summary>
            public Reference_Info reference_info { get; set; }=new Reference_Info();
        }

        public class Reference_Info {
         public string pass_station_id {  get; set; } = string.Empty;   
        }

        /// <summary>
        /// 上传文件-返回参数
        /// </summary>
        public struct FileUpload_Result
        {
            public Header header { get; set; }
            public Body body { get; set; }

            public struct Header
            {
                public string code { get; set; }
                public string desc { get; set; }
            }
            public struct Body
            {
                public string uuid { get; set; }
                public string md5 { get; set; }
                public string bucket { get; set; }
            }
        }

        /// <summary>
        /// 待上传MES、Iot的文件信息
        /// </summary>
        public class FileUpload_FileData
        {
            public List<FileData> fileData { get; set; } = new List<FileData>();
        }
        public class FileData
        {
            /// <summary>
            /// ⽂件名称
            /// </summary>
            public string FileName { get; set; } = string.Empty;
            /// <summary>
            /// ⽂件在⽂件服务器对应的uuid,可以采⽤异步上传，⾃定义uuid，先上传out，然后再异步上传⽂件，提升过站效率
            /// </summary>
            public string FileId { get; set; } = string.Empty;
            /// <summary>
            /// ⽂件服务器bucket
            /// </summary>
            public string Bucket { get; set; } = string.Empty;
        }

    }


}