using GMLawCore.Common;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Reflection;
using System.Text;
namespace GMLawCore.Common
{

    public class ChangeLogHelper
    {
        public static string SystemID = ConfigManage.Configuration["SystemID"] ?? "10000053420854";

        /// <summary>
        /// 变更记录查询
        /// </summary>
        /// <param name="mainTableName">主表表名 必填</param>
        /// <param name="mainId">主表ID 必填</param>
        /// <param name="tag">标签 没有可为空</param>
        /// <param name="workflowActorId">节点ID</param>
        /// <param name="pageIndex">当前页码(第几页就传入几)</param>
        /// <param name="pageSize">每页显示数量</param>
        /// <param name="systemId">系统ID 必填</param>
        /// <returns></returns>
        public static ReturnObject<EsLogPageRes<SysChangeLogEs>> QueryESLogRes(string mainTableName, string mainId, string tag = "", string workflowActorId = "", int pageIndex = 1, int pageSize = 1000, string systemId = "")
        {
            var res = ReturnObject<EsLogPageRes<SysChangeLogEs>>.Success();
            systemId = string.IsNullOrWhiteSpace(systemId) ? SystemID : systemId;
            var url = ConstManage.ESLogGet + $"/EsInterface/changeLog/?systemId={systemId}&mainTableName={mainTableName}&mainId={mainId}&tag={tag}&workflowActorId={workflowActorId}&pageIndex={pageIndex}&pageSize={pageSize}";
            var getRes = HttpHelper.HttpGet(url, SessionManagerHelper.RequestAuthorization);
            res = Newtonsoft.Json.JsonConvert.DeserializeObject<ReturnObject<EsLogPageRes<SysChangeLogEs>>>(getRes);
            return res;
        }

        /// <summary>
        /// 推送ES
        /// </summary>
        /// <typeparam name="T">比较的对象类型</typeparam>
        /// <param name="original">初始对象</param>
        /// <param name="current">当前对象</param>
        /// <param name="mainTableName">指定主表名称(匿名对象请指定)</param>
        /// <param name="mainId">主表id值(匿名对象请指定)</param>
        /// <param name="tag">查询标记</param>
        /// <param name="remark">备注</param>
        /// <param name="esType">es类型 menuEs菜单埋点日志、messageEs消息日志、interfaceEs开发接口日志、登陆埋点日志</param>
        /// <param name="logType">日志类型 info error</param>
        /// <returns>EsLogRes对象</returns>
        public static EsLogRes PostES<T>(T original, T current, string mainTableName = "", string mainId = "", string tag = "", string remark = "", string esType = "menuEs", string logType = "info")
        {
            try
            {
                var logList = GetChangeLogES(original, current, mainTableName, mainId, tag, remark, esType, logType);
                // 调用es
                if (logList.Count > 0)
                {
                    var esObj = HttpHelper.Post(ConstManage.ESLog + "/sysChangeLogs", Newtonsoft.Json.JsonConvert.SerializeObject(logList), "UTF-8", SessionManagerHelper.RequestAuthorization, "application/json");
                    EsLogRes esLogRes = Newtonsoft.Json.JsonConvert.DeserializeObject<EsLogRes>(esObj);
                    return esLogRes;
                }
                else
                {
                    return new EsLogRes()
                    {
                        code = 200,
                        msg = "未发现差异",
                        data = new { },
                    };
                }
            }
            catch (Exception e)
            {
                return new EsLogRes()
                {
                    code = 400,
                    msg = e.Message,
                    data = new { },
                };
            }
        }

        /// <summary>
        /// 推送ES
        /// </summary>
        /// <typeparam name="T">比较的对象类型</typeparam>
        /// <param name="original">初始对象</param>
        /// <param name="current">当前对象</param> 
        /// <param name="logEs">指定日志对象格式</param> 
        /// <returns>EsLogRes对象</returns>
        public static EsLogRes PostES<T>(T original, T current, SysChangeLogEs logEs)
        {
            try
            {
                var logList = GetChangeLogES(original, current, logEs);
                // 调用es
                if (logList.Count > 0)
                {
                    var esObj = HttpHelper.Post(ConstManage.ESLog + "/sysChangeLogs", Newtonsoft.Json.JsonConvert.SerializeObject(logList), "UTF-8", SessionManagerHelper.RequestAuthorization, "application/json");
                    EsLogRes esLogRes = Newtonsoft.Json.JsonConvert.DeserializeObject<EsLogRes>(esObj);
                    return esLogRes;
                }
                else
                {
                    return new EsLogRes()
                    {
                        code = 200,
                        msg = "未发现差异",
                        data = new { },
                    };
                }
            }
            catch (Exception e)
            {
                return new EsLogRes()
                {
                    code = 400,
                    msg = e.Message,
                    data = new { },
                };
            }
        }

        /// <summary>
        /// 推送ES
        /// </summary>
        /// <param name="logList">收集好的SysChangeLogEs集合</param>
        /// <returns>EsLogRes对象</returns>
        public static EsLogRes PostES(IList<SysChangeLogEs> logList)
        {
            try
            {
                // 调用es
                if (logList.Count > 0)
                {
                    var esObj = HttpHelper.Post(ConstManage.ESLog + "/sysChangeLogs", Newtonsoft.Json.JsonConvert.SerializeObject(logList), "UTF-8", SessionManagerHelper.RequestAuthorization, "application/json");
                    EsLogRes esLogRes = Newtonsoft.Json.JsonConvert.DeserializeObject<EsLogRes>(esObj);
                    return esLogRes;
                }
                else
                {
                    return new EsLogRes()
                    {
                        code = 200,
                        msg = "未发现差异",
                        data = new { },
                    };
                }
            }
            catch (Exception e)
            {
                return new EsLogRes()
                {
                    code = 400,
                    msg = e.Message,
                    data = new { },
                };
            }
        }

        /// <summary>
        /// esLog收集器
        /// </summary>
        /// <typeparam name="T">泛型T</typeparam>
        /// <param name="original">初始对象</param>
        /// <param name="current">当前对象</param>
        /// <param name="mainTableName">指定主表名称</param>
        /// <param name="mainId">主表id值</param>
        /// <param name="tag">查询标记</param>
        /// <param name="remark">备注</param>
        /// <param name="esType">es类型 menuEs菜单埋点日志、messageEs消息日志、interfaceEs开发接口日志、登陆埋点日志</param>
        /// <param name="logType">日志类型 info error</param>
        /// <returns>EsLogRes对象</returns>
        public static List<SysChangeLogEs> GetChangeLogES<T>(T original, T current, string mainTableName = "", string mainId = "", string tag = "", string remark = "", string esType = "menuEs", string logType = "info")
        {
            string systemId = SystemID;
            string jobNumber = SessionManagerHelper.SessionManager.UserInfo.JOBNUMBER;
            string updateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff");
            string updateUser = SessionManagerHelper.SessionManager.UserInfo.USERID.ToString();
            string updateUserName = SessionManagerHelper.SessionManager.UserInfo.FULLNAME;
            if (!current.GetType().Name.Contains("AnonymousType"))
            {
                if (string.IsNullOrWhiteSpace(mainTableName) && string.IsNullOrWhiteSpace(mainId))
                {
                    mainTableName = GetTableNameAttribute(current.GetType());
                    if (string.IsNullOrWhiteSpace(mainTableName))
                    {
                        mainTableName = current.GetType().Name;
                    }
                    mainId = GetKeyId(current);
                }
            }
            object obj = null;
            List<ChangeInfo> res = CompareType(original, current, obj);
            List<SysChangeLogEs> list = new List<SysChangeLogEs>();
            res.ForEach(x =>
            {
                list.Add(new SysChangeLogEs()
                {
                    mainTableName = mainTableName,
                    mainId = mainId,
                    detailTableName = x.detailTableName,
                    detailId = x.detailId,
                    parentTableName = x.parentTableName,
                    parentId = x.parentId,
                    property = x.CurrentField,
                    alias = x.CurrentFieldName,
                    newDisplay = x.CurrentDescribe,
                    newValue = x.CurrentValue == null ? string.Empty : x.CurrentValue.ToString(),
                    oldDisplay = x.OriginalDescribe,
                    oldValue = x.OriginalValue == null ? string.Empty : x.OriginalValue.ToString(),
                    remark = remark,
                    systemId = systemId,
                    tag = tag,
                    updateJobNumber = jobNumber,
                    updateTime = updateTime,
                    updateUser = updateUserName,
                    esType = esType,
                    extraOne = x.Ext1,
                    extraTwo = x.Ext2,
                    extraThree = string.Empty,
                    logType = logType,

                });
            });
            return list;
        }

        /// <summary>
        /// esLog收集器
        /// </summary>
        /// <typeparam name="T">泛型T</typeparam>
        /// <param name="original">初始对象</param>
        /// <param name="current">当前对象</param>
        /// <param name="logEs">指定日志对象格式</param> 
        /// <returns>EsLogRes对象</returns>
        public static List<SysChangeLogEs> GetChangeLogES<T>(T original, T current, SysChangeLogEs logEs)
        {
            logEs = logEs ?? new SysChangeLogEs();
            string systemId = SystemID;
            string jobNumber = SessionManagerHelper.SessionManager.UserInfo.JOBNUMBER;
            string updateTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ffff");
            string updateUser = SessionManagerHelper.SessionManager.UserInfo.USERID.ToString();
            string updateUserName = SessionManagerHelper.SessionManager.UserInfo.FULLNAME;
            string mainTableName = "", mainId = "";
            if (!current.GetType().Name.Contains("AnonymousType"))
            {
                if (string.IsNullOrWhiteSpace(logEs.mainTableName) && string.IsNullOrWhiteSpace(logEs.mainId))
                {
                    mainTableName = GetTableNameAttribute(current.GetType());
                    if (string.IsNullOrWhiteSpace(mainTableName))
                    {
                        mainTableName = current.GetType().Name;
                    }
                    mainId = GetKeyId(current);
                }
            }
            object obj = null;
            List<ChangeInfo> res = CompareType(original, current, obj);
            List<SysChangeLogEs> list = new List<SysChangeLogEs>();
            res.ForEach(x =>
            {
                list.Add(new SysChangeLogEs()
                {
                    mainTableName = mainTableName,
                    mainId = mainId,
                    detailTableName = x.detailTableName,
                    detailId = x.detailId,
                    parentTableName = x.parentTableName,
                    parentId = x.parentId,
                    property = x.CurrentField,
                    alias = x.CurrentFieldName,
                    newDisplay = x.CurrentDescribe,
                    newValue = x.CurrentValue == null ? string.Empty : x.CurrentValue.ToString(),
                    oldDisplay = x.OriginalDescribe,
                    oldValue = x.OriginalValue == null ? string.Empty : x.CurrentValue.ToString(),
                    remark = logEs.remark,
                    systemId = string.IsNullOrWhiteSpace(logEs.systemId) ? systemId : logEs.systemId,
                    tag = logEs.tag,
                    updateJobNumber = string.IsNullOrWhiteSpace(logEs.updateJobNumber) ? jobNumber : logEs.updateJobNumber,
                    updateTime = string.IsNullOrWhiteSpace(logEs.updateTime) ? updateTime : logEs.updateTime,
                    updateUser = string.IsNullOrWhiteSpace(logEs.updateUser) ? updateUserName : logEs.updateUser,
                    esType = string.IsNullOrWhiteSpace(logEs.esType) ? "menuEs" : logEs.esType,
                    extraOne = string.IsNullOrWhiteSpace(logEs.extraOne) ? x.Ext1 : logEs.extraOne,
                    extraTwo = string.IsNullOrWhiteSpace(logEs.extraTwo) ? x.Ext2 : logEs.extraTwo,
                    extraThree = logEs.extraThree,
                    logType = string.IsNullOrWhiteSpace(logEs.logType) ? "info" : logEs.logType,

                });
            });
            return list;
        }

        /// <summary>
        /// 比较器
        /// </summary>
        /// <typeparam name="T">比较的对象类型</typeparam>
        /// <typeparam name="Tp">父节点类型</typeparam>
        /// <param name="original">初始对象</param>
        /// <param name="current">当前对象</param>
        /// <param name="parent">父节点对象</param>
        /// <returns>差异集合</returns>
        private static List<ChangeInfo> CompareType<T, Tp>(T original, T current, Tp parent)
        {
            List<ChangeInfo> lst = new List<ChangeInfo>();
            // null 处理
            if (original == null && current == null)
                return lst;
            if (original == null && current != null)
            {
                original = (T)Activator.CreateInstance(current.GetType());
            }
            if (original != null && current == null)
            {
                current = (T)Activator.CreateInstance(original.GetType());
            }
            if (IsIgnoreRecord(current))
            {
                return lst;
            }
            // 集合处理
            if ((original.GetType().IsGenericType && original is IEnumerable<object>) || current.GetType().IsGenericType && current is IEnumerable<object>)
            {
                List<object> originalIEnum = (original as IEnumerable<object>).ToList();
                List<object> currentIEnum = (current as IEnumerable<object>).ToList();
                if (originalIEnum.Count < currentIEnum.Count)
                {
                    foreach (var item in currentIEnum)
                    {
                        int currentIndex = currentIEnum.IndexOf(item);
                        if (currentIndex > originalIEnum.Count - 1)
                        {
                            originalIEnum.Insert(currentIndex, Activator.CreateInstance(item.GetType()));
                        }
                        var orginalItem = originalIEnum.ElementAtOrDefault(currentIndex);
                        List<ChangeInfo> subChange = CompareType(orginalItem, item, parent);
                        if (subChange.Count > 0)
                        {
                            lst.AddRange(subChange);
                        }
                    }
                }
                else
                {
                    foreach (var item in originalIEnum)
                    {
                        int originalIndex = originalIEnum.IndexOf(item);
                        if (originalIndex > currentIEnum.Count - 1)
                        {
                            currentIEnum.Insert(originalIndex, Activator.CreateInstance(item.GetType()));
                        }
                        var currentItem = currentIEnum.ElementAtOrDefault(originalIndex);
                        List<ChangeInfo> subChange = CompareType(item, currentItem, parent);
                        if (subChange.Count > 0)
                        {
                            lst.AddRange(subChange);
                        }
                    }
                }
            }
            else
            {
                Type typeOriginal = original.GetType();
                Type typeCurrent = current.GetType();
                PropertyInfo[] propsOriginal = typeOriginal.GetProperties();
                PropertyInfo[] propsCurrent = typeCurrent.GetProperties();
                List<PropertyInfo> lstOriginal = propsOriginal == null ? new List<PropertyInfo>() : propsOriginal.ToList();
                List<PropertyInfo> lstCurrent = propsCurrent == null ? new List<PropertyInfo>() : propsCurrent.ToList();
                List<PropertyInfo> exp1 = lstCurrent.Where(a => lstOriginal.Exists(t => a.Name.Contains(t.Name))).ToList(); // 获取同时存在的字段
                List<PropertyInfo> exp2 = lstCurrent.Where(a => !lstOriginal.Exists(t => a.Name.Contains(t.Name))).ToList(); // 差异字段(视为新增)暂不处理 业务不需要
                // table parent 获取
                var tableName = GetTableNameAttribute(typeCurrent);
                string detailId = GetKeyId(current);
                if (string.IsNullOrWhiteSpace(tableName))
                {
                    if (current != null && !typeCurrent.Name.Contains("AnonymousType"))
                    {
                        tableName = typeCurrent.Name;
                    }
                }
                var parentTableName = GetTableNameAttribute(typeCurrent, "parent");
                string parentId = string.Empty;
                if (parent != null)
                {
                    parentId = GetKeyId(parent);
                    if (string.IsNullOrWhiteSpace(parentTableName))
                    {
                        if (parent != null && !parent.GetType().Name.Contains("AnonymousType"))
                        {
                            parentTableName = parent.GetType().Name;
                        }
                    }
                }
                // 收集字段信息
                foreach (PropertyInfo item in exp1)
                {
                    try
                    {
                        if (IsIgnoreRecord(item))
                        {
                            continue;
                        }
                        var originalProp = lstOriginal.FirstOrDefault(a => a.Name.Equals(item.Name));
                        var changeInfo = new ChangeInfo()
                        {
                            OriginalField = originalProp.Name,
                            OriginalFieldName = GetFieldNameCN(originalProp, typeof(DisplayNameAttribute)),
                            OriginalValue = originalProp.GetValue(original, null),
                            OriginalDescribe = GetDescribe(original, originalProp),
                            CurrentField = item.Name,
                            CurrentFieldName = GetFieldNameCN(item, typeof(DisplayNameAttribute)),
                            CurrentValue = item.GetValue(current, null),
                            CurrentDescribe = GetDescribe(current, item),
                            detailId = detailId,
                            parentId = parentId,
                            detailTableName = tableName,
                            parentTableName = parentTableName,
                            Ext1 = (Attribute.GetCustomAttribute(item, typeof(DependencePropAttribute)) as DependencePropAttribute)?.Ext1,
                            Ext2 = (Attribute.GetCustomAttribute(item, typeof(DependencePropAttribute)) as DependencePropAttribute)?.Ext2,
                        };
                        // 比较 值类型
                        if (item.PropertyType.IsValueType || item.PropertyType.Name.StartsWith("String") || item.PropertyType.Name.StartsWith("DateTime") || item.PropertyType.FullName.Contains("System.DateTime"))
                        {
                            if (changeInfo.CurrentValue == null)
                            {
                                if (changeInfo.OriginalValue != null)
                                {
                                    if (item.PropertyType.FullName.Contains("System.DateTime"))
                                    {
                                        bool isOnlyCompareDate = Attribute.GetCustomAttribute(item, typeof(OnlyCompareDateAttribute)) != null;
                                        DateTime dtO;
                                        DateTime.TryParse(changeInfo.OriginalValue.ToString(), out dtO);
                                        if (dtO != null)
                                            changeInfo.OriginalValue = dtO.ToString(isOnlyCompareDate ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm:ss");
                                    }
                                    lst.Add(changeInfo);
                                }
                            }
                            else
                            {
                                if (!changeInfo.CurrentValue.Equals(changeInfo.OriginalValue))
                                {
                                    if (item.PropertyType.FullName.Contains("System.DateTime"))
                                    {
                                        bool isOnlyCompareDate = Attribute.GetCustomAttribute(item, typeof(OnlyCompareDateAttribute)) != null;
                                        if (changeInfo.OriginalValue != null)
                                        {
                                            DateTime dtO;
                                            DateTime.TryParse(changeInfo.OriginalValue.ToString(), out dtO);
                                            if (dtO != null)
                                                changeInfo.OriginalValue = dtO.ToString(isOnlyCompareDate ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm:ss");
                                        }
                                        DateTime dtC;
                                        DateTime.TryParse(changeInfo.CurrentValue.ToString(), out dtC);
                                        if (dtC != null)
                                            changeInfo.CurrentValue = dtC.ToString(isOnlyCompareDate ? "yyyy-MM-dd" : "yyyy-MM-dd HH:mm:ss");
                                    }
                                    if (!changeInfo.CurrentValue.Equals(changeInfo.OriginalValue))
                                        lst.Add(changeInfo);
                                }
                            }
                        }
                        else
                        {
                            //如果对象中的属性是实体类对象,递归遍历比较
                            List<ChangeInfo> subChange = CompareType(changeInfo.OriginalValue, changeInfo.CurrentValue, current);
                            if (subChange.Count > 0)
                            {
                                lst.AddRange(subChange);
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        continue;
                    }
                }
            }

            return lst;
        }
        private class ChangeInfo
        {
            public string OriginalFieldName { get; set; }
            /// <summary>
            /// 字段名
            /// </summary>
            public string CurrentFieldName { get; set; }
            public string OriginalField { get; set; }
            public string CurrentField { get; set; }
            public object OriginalValue { get; set; }
            public object CurrentValue { get; set; }
            public string OriginalDescribe { get; set; }
            public string CurrentDescribe { get; set; }
            public string detailId { get; set; }
            public string detailTableName { get; set; }
            public string parentId { get; set; }
            public string parentTableName { get; set; }
            public string mainId { get; set; }
            public string mainTableName { get; set; }

            public string Ext1 { get; set; }
            public string Ext2 { get; set; }
        }
        private static string GetKeyId<T>(T type)
        {
            var keyId = string.Empty;
            PropertyInfo[] props = type.GetType().GetProperties();
            foreach (var item in props)
            {
                var keyAttr = Attribute.GetCustomAttribute(item, typeof(KeyAttribute));
                if (keyAttr != null)
                {
                    var value = item.GetValue(type, null);
                    keyId = value == null ? string.Empty : value.ToString();
                    break;
                }
            }
            return keyId;
        }

        private static string GetDescribe<T>(T t, PropertyInfo propertyInfo)
        {
            var res = string.Empty;
            res = GetKVInfo(t, propertyInfo);
            res = string.IsNullOrWhiteSpace(res) ? GetDependencePropValue(t, propertyInfo) : res;
            return res;
        }

        private static string GetKVInfo<T>(T t, PropertyInfo propertyInfo)
        {
            var res = string.Empty;
            var kvAttrs = Attribute.GetCustomAttributes(propertyInfo, typeof(KVAttribute)) as KVAttribute[];
            if (kvAttrs != null)
            {
                res = kvAttrs.FirstOrDefault(a => a.Key.ToString() == propertyInfo.GetValue(t, null)?.ToString())?.Value?.ToString();
            }
            return res;
        }

        /// <summary>
        /// 获取依赖关系属性值
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="t">类的对象</param>
        /// <param name="propertyInfo">带DependencePropAttribute特性的字段</param>
        /// <returns></returns>
        private static string GetDependencePropValue<T>(T t, PropertyInfo propertyInfo)
        {
            string resValue = string.Empty;
            string propName = (Attribute.GetCustomAttribute(propertyInfo, typeof(DependencePropAttribute)) as DependencePropAttribute)?.PropName;
            if (string.IsNullOrWhiteSpace(propName))
                return resValue;
            PropertyInfo dependenceProp = t.GetType().GetProperty(propName);
            if (dependenceProp == null)
                return resValue;
            var obj = dependenceProp.GetValue(t, null);
            return resValue = obj?.ToString();
        }
        private static bool IsIgnoreRecord<T>(T t)
        {
            bool res = false;
            if (t is PropertyInfo)
            {
                res = Attribute.GetCustomAttribute(t as PropertyInfo, typeof(IgnoreRecordAttribute)) == null ? false : true;
            }
            else
            {
                res = t.GetType().GetCustomAttribute<IgnoreRecordAttribute>() == null ? false : true;
            }
            return res;
        }
        private static string GetFieldNameCN(PropertyInfo pInfo, Type attributeType = null)
        {
            string propValue = string.Empty;
            Attribute attribute = null;
            if (attributeType == null)
            {
                attributeType = typeof(DisplayNameAttribute);
                attribute = Attribute.GetCustomAttribute(pInfo, attributeType);
                propValue = attribute == null ? string.Empty : ((DisplayNameAttribute)attribute).DisplayName;
            }
            else
            {
                if (attributeType.Equals(typeof(DisplayNameAttribute)))
                {
                    attribute = Attribute.GetCustomAttribute(pInfo, attributeType);
                    propValue = attribute == null ? string.Empty : ((DisplayNameAttribute)attribute).DisplayName;
                }
                // 其它特性
            }
            return propValue;
        }
        private static string GetTableNameAttribute(Type type, string propName = "table")
        {
            var res = "";
            TableRelationAttribute tableRelationAttribute = type.GetCustomAttribute<TableRelationAttribute>();
            switch (propName.ToLower())
            {
                case "table":
                    res = tableRelationAttribute?.TableName;
                    if (string.IsNullOrWhiteSpace(res))
                    {
                        res = type.GetCustomAttribute<TableAttribute>()?.Name;
                    }
                    break;
                case "parent":
                    res = tableRelationAttribute?.ParentTableName;
                    break;
            }
            return res;
        }
    }

    public class EsLogRes
    {
        public int code { get; set; }
        public string msg { get; set; }
        public object data { get; set; }
    }
    /// <summary>
    /// 变更记录对象
    /// </summary>
    public class SysChangeLogEs
    {
        public string parentId { get; set; }
        public string parentTableName { get; set; }
        /// <summary>
        /// 属性别名
        /// </summary>
        public string alias { get; set; }

        /// <summary>
        /// 子表主键(冗余存,用于单独查询明细变更记录使用)
        /// </summary>
        public string detailId { get; set; }

        /// <summary>
        /// 子表表名(冗余存,用于单独查询明细变更记录使用)
        /// </summary>
        public string detailTableName { get; set; }

        /// <summary>
        /// es类型 menuEs菜单埋点日志、messageEs消息日志、interfaceEs开发接口日志、登陆埋点日志
        /// </summary>
        public string esType { get; set; }

        /// <summary>
        /// 预留字段1(用于自定义查询使用)
        /// </summary>
        public string extraOne { get; set; }

        /// <summary>
        /// 预留字段3(用于自定义查询使用)
        /// </summary>
        public string extraThree { get; set; }

        /// <summary>
        /// 预留字段2(用于自定义查询使用)
        /// </summary>
        public string extraTwo { get; set; }

        /// <summary>
        /// 日志类型 info error
        /// </summary>
        public string logType { get; set; }

        /// <summary>
        /// 主表主键
        /// </summary>
        public string mainId { get; set; }

        /// <summary>
        /// 主表表名
        /// </summary>
        public string mainTableName { get; set; }

        /// <summary>
        /// 新的展示值
        /// </summary>
        public string newDisplay { get; set; }

        /// <summary>
        /// 新的值
        /// </summary>
        public string newValue { get; set; }

        /// <summary>
        /// 老的展示值
        /// </summary>
        public string oldDisplay { get; set; }

        /// <summary>
        /// 老的值
        /// </summary>
        public string oldValue { get; set; }

        /// <summary>
        /// 属性名
        /// </summary>
        public string property { get; set; }

        /// <summary>
        /// 备注
        /// </summary>
        public string remark { get; set; }

        /// <summary>
        /// 业务系统ID
        /// </summary>
        public string systemId { get; set; }

        /// <summary>
        /// 标签(自定义标签,基本用于查询使用)
        /// </summary>
        public string tag { get; set; }

        /// <summary>
        /// 操作人工号
        /// </summary>
        public string updateJobNumber { get; set; }

        /// <summary>
        /// 操作时间
        /// </summary>
        public string updateTime { get; set; }

        /// <summary>
        /// 操作人(直接记录userName)
        /// </summary>
        public string updateUser { get; set; }
    }

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)]
    public class TableRelationAttribute : Attribute
    {
        public string TableName { get; }
        public string ParentTableName { get; set; }
    }

    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property)]
    public class IgnoreRecordAttribute : Attribute
    {
    }

    [AttributeUsage(AttributeTargets.Property)]
    public class OnlyCompareDateAttribute : Attribute
    {
    }

    /// <summary>
    /// 标识依赖关系属性
    /// </summary>
    [AttributeUsage(AttributeTargets.Property)]
    public class DependencePropAttribute : Attribute
    {
        /// <summary>
        /// 依赖属性用于展示Display
        /// </summary>
        public string PropName { get; set; }
        /// <summary>
        /// 扩展字段用于查询标记或处理值
        /// </summary>
        public string Ext1 { get; set; }
        /// <summary>
        /// 扩展字段用于查询标记或处理值
        /// </summary>
        public string Ext2 { get; set; }
    }

    [AttributeUsage(AttributeTargets.Property, AllowMultiple = true)]
    public class KVAttribute : Attribute
    {
        public object Key { get; set; }
        public object Value { get; set; }

        public KVAttribute(object key, object value)
        {
            Key = key;
            Value = value;
        }
    }

    public class EsLogPageRes<T>
    {
        public int pageIndex { get; set; }
        public int pageSize { get; set; }
        public int total { get; set; }
        public List<T> list { get; set; }
    }
}

 

posted on 2021-08-05 13:24  沙雕界一哥  阅读(191)  评论(0)    收藏  举报