Beispiel #1
0
        public List <异常信息对象> 获得错误消息_用户编码(int startRowIndex, int maxRows, Guid 用户编码)
        {
            错误消息处理逻辑      错误逻辑 = new 错误消息处理逻辑();
            List <异常信息对象> 异常列表 = 错误逻辑.获得错误信息_用户编码(startRowIndex, maxRows, 用户编码);

            return(异常列表);
        }
Beispiel #2
0
        public void 添加错误消息(String 异常描述, String 异常代码, String 异常信息, int 异常级别, int 异常类型, String 主机名称, String 方法名称, String 消息编码, String 绑定地址编码, int 异常信息状态, String 请求消息体, int 请求类型, String 请求密码, int 绑定类型)
        {
            //bool isAddOk = true;
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();
            异常信息对象   异常对象 = new 异常信息对象();

            异常对象.异常时间   = System.DateTime.Now;
            异常对象.异常描述   = 异常描述.Trim();
            异常对象.异常代码   = 异常代码.Trim();
            异常对象.异常信息   = 异常信息.Trim();
            异常对象.异常级别   = 异常级别;
            异常对象.异常类型   = 异常类型;
            异常对象.主机名称   = 主机名称.Trim();
            异常对象.方法名称   = 方法名称.Trim();
            异常对象.请求密码   = 请求密码.Trim();
            异常对象.绑定类型   = 绑定类型;
            异常对象.请求类型   = 请求类型;
            异常对象.消息编码   = new Guid(消息编码);
            异常对象.绑定地址编码 = new Guid(绑定地址编码);
            异常对象.异常信息状态 = 异常信息状态;
            异常对象.请求消息体  = 请求消息体;
            XmlDocument document = new XmlDocument();

            document.LoadXml(请求消息体);

            string serviceName  = document.DocumentElement.SelectSingleNode("服务名称").InnerText.Trim();
            string reqBeginTime = document.DocumentElement.SelectSingleNode("请求时间").InnerText.Trim();

            //Audit.AuditServcie auditServcie = new JN.ESB.Exception.Service.Audit.AuditServcie();
            //auditServcie.AddAuditBusiness(主机名称, 请求消息体, 消息编码, 方法名称, reqBeginTime, serviceName, 0);
            务目录业务逻辑   UDDI  = new  务目录业务逻辑();
            List <个人> 系统管理员 = UDDI.获得系统管理员();

            if ((String.IsNullOrEmpty(绑定地址编码.Trim()) || 绑定地址编码.Trim() == "00000000-0000-0000-0000-000000000000"))
            {
                if (UDDI.获得绑定信息_服务名称(serviceName) != null)
                {
                    异常对象.绑定地址编码 = UDDI.获得绑定信息_服务名称(serviceName).务地址编码;
                }
            }

            错误逻辑.创建错误消息(异常对象);

            try
            {
                if (!(异常对象.绑定地址编码.Value == Guid.Empty))
                {
                    务地址 地址   = UDDI.获得绑定信息_服务地址编码(异常对象.绑定地址编码.Value);
                    个人  务管理员 = UDDI.获得管理员_具体绑定服务(地址);
                    if (!(系统管理员.Contains(务管理员)))
                    {
                        系统管理员.Add(务管理员);
                    }
                }
                this.发送OA邮件(异常对象, 系统管理员);
            }
            catch { }
        }
Beispiel #3
0
        public bool  除错误消息_异常编码(Guid 异常编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();
            //异常信息对象 异常 = 错误逻辑.获得错误消息_异常编码(异常编码);

            //AuditServcie audit = new AuditServcie();
            bool result = 错误逻辑.除错误消息(异常编码);

            //if (result)
            //    audit.ExceptionResend(异常.消息编码.Value);

            return(result);
        }
Beispiel #4
0
        public int 获取未处理异常数量_服务提供者编码(Guid 务提供者编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();
            务目录业务逻辑  UDDI = new  务目录业务逻辑();
            业务实体     务提供者 = new 业务实体();

            务提供者.业务编码 = 务提供者编码;
            int      异常数量 = 0;
            List <务> 务集   = UDDI.获得具体服务_服务提供者(务提供者);

            foreach (务 具体服务 in  务集)
            {
                异常数量 = 异常数量 + 错误逻辑.获得未处理的错误_服务编码(具体服务.务编码).Count;
            }
            return(异常数量);
        }
Beispiel #5
0
        public int 获得所有错误消息数量(int startRowIndex, int maxRows)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得全部错误数量());
        }
Beispiel #6
0
        public int 获得错误消息数量_服务编码(int startRowIndex, int maxRows, Guid 务编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得所有错误信息_服务编码(务编码).Count);
        }
Beispiel #7
0
        public List <异常信息对象> 获得分页错误消息_服务编码(int startRowIndex, int maxRows, Guid 务编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得所有错误信息_服务编码(startRowIndex, maxRows, 务编码));
        }
Beispiel #8
0
        public string 获得错误消息内容(Guid exceptionId)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得错误消息_异常编码(exceptionId).请求消息体);
        }
Beispiel #9
0
        public List <异常信息对象> 获得错误消息(int startRowIndex, int maxRows)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得错误信息(startRowIndex, maxRows));
        }
Beispiel #10
0
        public 异常信息对象 获得错误消息_异常编码(Guid 异常编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得错误消息_异常编码(异常编码));
        }
Beispiel #11
0
        public List <异常信息对象> 获得错误消息_服务提供者编码(Guid 务提供者编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得所有错误信息_服务提供者编码(务提供者编码));
        }
Beispiel #12
0
        public List <异常信息对象> 获得分页错误消息_服务提供者_用户编码(int startRowIndex, int maxRows, Guid 用户编码, Guid 务提供者编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得错误信息_服务提供者编码_用户编码(startRowIndex, maxRows, 务提供者编码, 用户编码));
        }
Beispiel #13
0
        public int 获得分页错误消息数量_服务提供者_用户编码(int startRowIndex, int maxRows, Guid 用户编码, Guid 务提供者编码)
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得错误信息数量_服务提供者_用户编码(务提供者编码, 用户编码));
        }
Beispiel #14
0
        public List <异常信息对象> 获得所有错误消息()
        {
            错误消息处理逻辑 错误逻辑 = new 错误消息处理逻辑();

            return(错误逻辑.获得所有错误信息());
        }