MedicalInsurance/Common/Utils.cs

using Newtonsoft.Json.Linq;
using PTMedicalInsurance.Variables;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace PTMedicalInsurance.Common
{
    public class Utils
    {
        #region 工具
        /// <summary>
        /// 获取交易号
        /// </summary>
        /// <returns></returns>
        public static string GetTradeNo()
        {
            return Global.inf.hospitalNO + DateTime.Now.ToString("yyyyMMddHHmmssffff");
        }

        /// <summary>
        /// 日期转换为时间戳Timestamp
        /// </summary>
        /// <param name="dateTime">要转换的日期</param>
        /// <returns></returns>
        public static long GetTimeStamp(DateTime dateTime)
        {
            DateTime _dtStart = new DateTime(1970, 1, 1, 8, 0, 0);
            //10位的时间戳
            long timeStamp = Convert.ToInt32(dateTime.Subtract(_dtStart).TotalSeconds);
            //13位的时间戳
            //long timeStamp = Convert.ToInt64(dateTime.Subtract(_dtStart).TotalMilliseconds);
            return timeStamp;
        }

        /// <summary>
        /// UTC时间戳Timestamp转换为北京时间
        /// </summary>
        /// <param name="timestamp">要转换的时间戳</param>
        /// <returns></returns>
        public static DateTime GetDateTime(long timestamp)
        {
            //DateTime dtStart = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)); 
            //使用上面的方式会显示TimeZone已过时
            DateTime dtStart = TimeZoneInfo.ConvertTime(new DateTime(1970, 1, 1), TimeZoneInfo.Local);
            DateTime targetDt = dtStart.AddMilliseconds(timestamp).AddHours(8);
            return targetDt;
        }

        public static string GetDateTimeNow()
        {
            return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
        }

        public static string ConvertLongToDate(string strValue)
        {
            DateTime dateTime = DateTimeOffset.FromUnixTimeMilliseconds(long.Parse(strValue)).DateTime;
            return dateTime.ToString("yyyy-MM-dd");
        }

        public static string ConvertShortDate(string strValue)
        {
            if (!strValue.Contains("-") && strValue.Length >= 8)
            {
                return strValue.Substring(0, 4) + "-" + strValue.Substring(4, 2) + "-" + strValue.Substring(6, 2);
            }
            return strValue.Length > 10 ? strValue.Substring(0, 10) : strValue;
        }
        public static string ConvertNoSplitDate(string strValue)
        {
            strValue = strValue.Replace("-", "");
            if (strValue.Length > 8)
            {
                strValue = strValue.Substring(0, 8);
            }
            return strValue;
        }



        /// <summary>
        /// 将JObject对象中的timestamp数据转为yyyy-MM-dd格式
        /// </summary>
        /// <param name="joObject"></param>
        /// <param name="key"></param>
        public static void convertTimestamp(JObject joObject,string key)
        {
            if (joObject.ContainsKey(key))
            {
                Global.writeLog(string.Format("当前对象[{0}]的类型为:{1}", key, joObject.GetValue(key).Type.GetType()));
            }
            
            if (joObject.ContainsKey(key) && joObject.GetValue(key).Type.GetType() != typeof(string))
            {
                long timestamp = long.Parse(joObject.GetValue(key).ToString());
                string datetime = Utils.GetDateTime(timestamp).ToString("yyyy-MM-dd");
                joObject[key] = datetime;
                Global.writeLog(string.Format("转换后的日期为:{0}",datetime));
            }


        }
        public static string convertTimestamp(string key)
        {


            long timestamp = long.Parse(key);
            string datetime = Utils.GetDateTime(timestamp).ToString("yyyy-MM-dd HH:mm:ss");
            return datetime;

        }
        #endregion

        #region BeanUtils
        /// <summary>
        /// 用反射对实体进行属性值合并,返回合并后的属性并集
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity">合并对象1</param>
        /// <param name="addtional">合并对象2</param>
        /// <param name="forceCover">是否强制覆盖</param>
        /// <returns></returns>
        public static T merge<T>(T entity, T addtional,bool forceCover)
        {
            if (entity == null) return addtional;
            if (addtional == null) return entity;
            // 进行合并
            Type mType = typeof(T);
            object result = Activator.CreateInstance(mType);
            PropertyInfo[] pi = mType.GetProperties();
            pi.ToList().ForEach((p) =>
            {
                object v1 = p.GetValue(entity);
                object v2 = p.GetValue(addtional);
                if (forceCover)
                {
                    v1 = v2;
                }
                else {
                    v1 = (v1 == null ? v2 : v1);
                }
                p.SetValue(result, v1);
            });
            return (T)result;
        }
        /// <summary>
        /// 对2个对象进行合并，以第一个对象为重点
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="entity"></param>
        /// <param name="addtional"></param>
        /// <returns></returns>
        public static T merge<T>(T entity, T addtional)
        {
            return merge(entity, addtional, false);
        }

        private static JObject merge(JObject to, JObject from)
        {
            to.Merge(from);
            return to;
        }
        /// <summary>
        /// 采用Json的方式进行属性合并（默认会覆盖）
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="to"></param>
        /// <param name="from"></param>
        /// <returns></returns>
        public static T mergeObject<T>(T to, T from)
        {
            JObject toObj = JObject.FromObject(to);
            JObject fromObj = JObject.FromObject(from);
            JObject result = merge(toObj, fromObj);
            return result.ToObject<T>();
        }

        #endregion


        #region 业务个性化

        /// <summary>
        /// 在JObject对象基础上进行包装
        /// </summary>
        /// <param name="jsonInParam"></param>
        /// <returns></returns>
        public static JObject Wrapper(JObject jsonInParam)
        {
            dynamic request = new JObject();
            request.arg0 = jsonInParam;
            return request;
        }
        /// <summary>
        /// 删除JObject上的进行包装
        /// </summary>
        /// <param name="jsonInParam"></param>
        /// <returns></returns>
        public static JObject removeWrapper(JObject jsonInParam)
        {
            if (jsonInParam.ContainsKey("arg0"))
            {
                return (JObject)jsonInParam.GetValue("arg0");
            }
            return jsonInParam;
        }

        public static bool isOtherCityPatient()
        {
            // 重庆没有市内异地
            string areaCode = Global.pat.insuplc_admdvs;
            if (!string.IsNullOrEmpty(areaCode) && areaCode.Length>2 && areaCode.Substring(0, 2) != "50")
            {
                return true;
            }
            return false;
        }

        public static string convertAdmDr(string admNo)
        {
            // 重庆异地（每次唯一）
            if (isOtherCityPatient())
            {
                // 住院号15位，控制总长度不超过20
                string ret = admNo + "-" + DateTime.Now.ToString("HHmm");
                // 保存到扩展信息字段中
                JObject exp = new JObject();
                exp.Add("admDr",ret);
                Global.pat.ExpContent = exp.ToString();

                return ret;
            }

            return admNo;
        }

        #endregion

        public static string MockData(bool requestFlag, string tradeNo)
        {
            string dataFile = Global.curEvt.path + "/config/mock/" + (requestFlag ? "request" : "response") + "/" + tradeNo + ".json";
            // 加载字段映射配置
            if (File.Exists(dataFile))
            {
                return File.ReadAllText(dataFile);
            }
            else
            {
                Global.writeLog("配置文件不存在:" + dataFile);
            }
            return "";
        }

        /// <summary>
        /// 保存信息到pat.Expand字段
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public static void ExpandData(string key, object value)
        {
            string expand = Global.pat.ExpContent;
            JObject obj = new JObject();
            if (!string.IsNullOrEmpty(expand))
            {
                obj = JObject.Parse(expand);
            }
            if (!obj.ContainsKey(key))
            {
                obj.Add(key, value?.ToString());
            }
            else
            {
                obj[key] = value?.ToString();
            }
            Global.pat.ExpContent = obj.ToString();
        }

        /// <summary>
        /// 获取参保地编码
        /// </summary>
        /// <returns></returns>
        public static string GetInsuCode()
        {
            if (string.IsNullOrEmpty(Global.pat.insuplc_admdvs))
            {
                Global.pat.insuplc_admdvs = Global.inf.areaCode;
            }


            return Global.pat.insuplc_admdvs;
        }

        /// <summary>
        /// 获取医院编码（社保）
        /// </summary>
        /// <returns></returns>
        public static string GetInsuOrgCode()
        {
            return Global.inf.hospitalNO;
        }


        public static bool Confirm(string title)
        {
            if (MessageBox.Show(title, "警告", MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes)
            {
                return false;
            }

            return true;
        }
    }
}