24Hour.Service/WebApplication1/MDossier.cs

using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;

namespace test
{
    internal class MDossier
    {
        private string TyywAddr
        {
            get;
            set;
        }
        private string DWBM
        {
            get;
            set;
        }

        public MDossier(string _dwbm, string _TyywAddr)
        {
            DWBM = _dwbm;
            TyywAddr = _TyywAddr;
        }

        #region 获取卷宗信息操作
        public async Task<JZJBXX> GetJZXX(string dwbm, string bmsah)
        {
            JZJBXX jbxx = new JZJBXX();
            #region POST
            string apiUrl = "http://" + TyywAddr + "/dzjz-service/api/dzjz/getDzjzInfo"; // 接口
            //创建一个HTTP请求  
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiUrl);
            //Post请求方式  
            request.Method = "POST";
            //内容类型
            request.ContentType = "application/json";
            //设置参数，并进行URL编码 
            string paraUrlCoded = "{\"bmsah\":\"" + bmsah + "\",\"dwbm\":\"" + dwbm + "\"}";
            byte[] payload;
            //将Json字符串转化为字节  
            payload = System.Text.Encoding.UTF8.GetBytes(paraUrlCoded);
            //设置请求的ContentLength   
            request.ContentLength = payload.Length;
            //发送请求，获得请求流 
            Stream writer;
            try
            {
                //获取用于写入请求数据的Stream对象
                writer = request.GetRequestStream();
            }
            catch (Exception ex)
            {
                LogHelpe.WriteInfoLog("接口 1 参数序列化失败：" + ex.Message);
                return jbxx;
            }
            //将请求参数写入流
            writer.Write(payload, 0, payload.Length);
            writer.Close();//关闭请求流

            HttpWebResponse response;
            try
            {
                //获得响应流
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                LogHelpe.WriteInfoLog("接口 1 请求异常：" + ex.Message);
                return jbxx;
            }

            if (response != null)
            {
                Stream s = response.GetResponseStream();
                StreamReader sRead = new StreamReader(s);
                string postContent = sRead.ReadToEnd();
                sRead.Close();
                s.Close();
                try
                {
                    var jsonObj = JsonConvert.DeserializeObject<JBXXStruct>(postContent);
                    if (jsonObj != null)
                    {
                        if (jsonObj.jzjbxx != null)
                        {
                            if (jsonObj.jzjbxx.Count > 0)
                            {
                                jbxx = jsonObj.jzjbxx[0];
                                List<JZML> jzml = await GetJZML(bmsah);
                                jbxx.jzml = jzml;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelpe.WriteErrorLog($"接口 1 失败原因：{ex.Message}");
                }
            }
            return jbxx;
            #endregion
        }
        private async Task<List<JZML>> GetJZML(string bmsah)
        {
            List<JZML> jzml = new List<JZML>();
            #region POST
            string apiUrl = "http://" + TyywAddr + "/dzjzzz-service/api/dzjz/getDzjzMlWjInfo"; // 集中部署
            //创建一个HTTP请求  
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiUrl);
            //Post请求方式  
            request.Method = "POST";
            //内容类型
            request.ContentType = "application/json";
            //设置参数，并进行URL编码 
            string paraUrlCoded = "{\"bmsah\":\"" + bmsah + "\"}";
            byte[] payload;
            //将Json字符串转化为字节  
            payload = System.Text.Encoding.UTF8.GetBytes(paraUrlCoded);
            //设置请求的ContentLength   
            request.ContentLength = payload.Length;
            //发送请求，获得请求流 
            Stream writer;
            try
            {
                //获取用于写入请求数据的Stream对象
                writer = request.GetRequestStream();
            }
            catch (Exception ex)
            {
                LogHelpe.WriteInfoLog("接口 2 参数序列化失败：" + ex.Message);
                return jzml;
            }
            //将请求参数写入流
            writer.Write(payload, 0, payload.Length);
            writer.Close();//关闭请求流

            HttpWebResponse response;
            try
            {
                //获得响应流
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                LogHelpe.WriteInfoLog("接口 2 请求异常：" + ex.Message);
                return jzml;
            }

            if (response != null)
            {
                Stream s = response.GetResponseStream();
                StreamReader sRead = new StreamReader(s);
                string postContent = sRead.ReadToEnd();
                sRead.Close();
                s.Close();
                try
                {

                    var jsonObj = JsonConvert.DeserializeObject<JZMLStruct>(postContent);
                    if (jsonObj != null)
                    {
                        jzml = jsonObj.data.jzml;
                        if (jsonObj.data != null)
                        {
                            LogHelpe.WriteInfoLog("目录数据：" + jsonObj.data.jzml.Count);
                            foreach (var item in jzml)
                            {
                                // 文件接口的参数
                                var mlbh = item.mlbh;
                                var jzbh = item.jzbh;
                                //获取卷或目录下的所有文件列表
                                List<JZWJItem> wjlist = await GetJZMLWJ(mlbh, jzbh);
                                if (jsonObj.data.jzmlwj != null)
                                {
                                    for (int i = 0; i < wjlist.Count; i++)
                                    {
                                        var wj = jsonObj.data.jzmlwj.Where(w => w.wjxh.Equals(wjlist[i].wjxh)).FirstOrDefault();
                                        if (wj != null)
                                        {
                                            wjlist[i].bsbh = jsonObj.data.jzmlwj[i].bsbh;
                                        }
                                    }
                                }
                                item.jzwj = wjlist;
                            }
                            return jzml;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelpe.WriteErrorLog($"接口 2 失败原因：{ex.Message}");
                    return jzml;
                }

            }
            return jzml;
            #endregion
        }
        /// <summary>
        /// 获取卷或目录下的所有文件列表
        /// </summary>
        private async Task<List<JZWJItem>> GetJZMLWJ(string mlbh, string jzbh)
        {
            string apiUrl = "http://" + TyywAddr + "/dzjzzz-service/api/dzjzzz/dzjzzzYxJzmlwj/getJzmlwjInfo"; // 集中部署
            LogHelpe.WriteInfoLog($"请求地址：{apiUrl}");                                                                                                                 //创建一个HTTP请求  
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(apiUrl);
            //Post请求方式  
            request.Method = "POST";
            //内容类型
            request.ContentType = "application/json";
            //设置参数，并进行URL编码 
            string paraUrlCoded = "{\"mlbh\":\"" + mlbh + "\",\"jzbh\": \"" + jzbh + "\"}";
            byte[] payload;
            //将Json字符串转化为字节  
            payload = System.Text.Encoding.UTF8.GetBytes(paraUrlCoded);
            //设置请求的ContentLength   
            request.ContentLength = payload.Length;
            //发送请求，获得请求流 
            Stream writer;
            try
            {
                //获取用于写入请求数据的Stream对象
                writer = request.GetRequestStream();
            }
            catch (Exception ex)
            {
                LogHelpe.WriteInfoLog("接口 3 参数序列化失败：" + ex.Message);
                return new List<JZWJItem>();
            }
            //将请求参数写入流
            writer.Write(payload, 0, payload.Length);
            writer.Close();//关闭请求流
            HttpWebResponse response;
            try
            {
                //获得响应流
                response = (HttpWebResponse)request.GetResponse();
            }
            catch (WebException ex)
            {
                LogHelpe.WriteInfoLog("接口 3 请求异常：" + ex.Message);
                return new List<JZWJItem>();
            }

            if (response != null)
            {
                Stream s = response.GetResponseStream();
                StreamReader sRead = new StreamReader(s);
                string postContent = sRead.ReadToEnd();
                s.Close();
                sRead.Close();

                try
                {
                    var jsonObj = JsonConvert.DeserializeObject<JZWJStruct>(postContent);
                    if (jsonObj != null)
                    {
                        if (jsonObj.code == "0" && jsonObj.success == "true")
                        {
                            if (jsonObj.data != null && jsonObj.data.Count > 0)
                            {
                                List<JZWJItem> mLWJItems = jsonObj.data;
                                return mLWJItems;
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogHelpe.WriteErrorLog($"接口 3 失败原因：{ex.Message}");
                }
            }

            return new List<JZWJItem>();
        }
        #endregion

        #region 下载文件
        //任务数据队列
        private List<string> lst_bmsah = new List<string>();
        private bool taskStatus = true;
        private int taskCount = 0;
        public async void DownJZFiles(JZJBXX jbxx, string dirPath, bool cacheFile = true)
        {
            if (jbxx != null)
            {
                if (jbxx.jzml != null && jbxx.jzml.Count > 0)
                {
                    for (int m = 0; m < jbxx.jzml.Count; m++)
                    {
                        if (jbxx.jzml[m].jzwj != null && jbxx.jzml[m].jzwj.Count > 0)
                        {
                            for (int j = 0; j < jbxx.jzml[m].jzwj.Count; j++)
                            {
                                if (!Directory.Exists(dirPath))
                                {
                                    Directory.CreateDirectory(dirPath);
                                }
                                if (Directory.Exists(dirPath))
                                {
                                    string filePath = Path.Combine(dirPath, Path.GetFileName(jbxx.jzml[m].jzwj[j].wjxh + ".jpg"));
                                    byte[] jpgBytes = DownJZWJFile(jbxx.jzml[m].jzwj[j].jpgwjlj, jbxx.jzml[m].jzwj[j].wjxsmc, jbxx.jzml[m].mlxsmc, filePath, cacheFile);
                                }
                            }
                        }
                    }
                }
            }

        }


        //下载图片
        private byte[] DownJZWJFile(string url, string wjxsmc, string mlxsmc, string filePath, bool cacheFile = true)
        {
            byte[] jpgByte = new byte[] { };

            try
            {
                HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
                //发送请求并获取相应回应数据
                HttpWebResponse response = request.GetResponse() as HttpWebResponse;

                Stream responseStream = response.GetResponseStream();
                try
                {
                    #region 正式
                    MemoryStream memory = new MemoryStream();
                    byte[] bArr = new byte[1024];
                    int size = responseStream.Read(bArr, 0, (int)bArr.Length);
                    while (size > 0)
                    {
                        memory.Write(bArr, 0, size);
                        size = responseStream.Read(bArr, 0, (int)bArr.Length);
                    }

                    if (cacheFile)
                    {
                        //文件落地（本地存放）
                        using (var fileStream = File.Create(filePath))
                        {
                            memory.Seek(0, SeekOrigin.Begin);
                            memory.CopyTo(fileStream);
                        }
                    }
                    jpgByte = memory.ToArray();
                    // 关闭请求流
                    memory.Close();

                    responseStream.Close();

                    #endregion
                }
                catch (Exception ex)
                {
                    LogHelpe.WriteErrorLog(string.Format("文件下载失败,文件名：{0}/{1}，{2}", wjxsmc, mlxsmc, ex.Message));
                }
            }
            catch (Exception ex)
            {
                LogHelpe.WriteErrorLog($"GetBytesFromUrl失败原因：{ex.Message}");
            }
            return jpgByte;
        }


        #endregion


    }
}