예제 #1
0
        /// <summary>
        /// 执行结算
        /// </summary>
        public override void Execute()
        {
            _context = new DataContext();

            #region//检测订单有效性

            if (null == _order)
            {
                _errorMessage = "订单数据不存在!";
                return;
            }
            if (_order.BusinessType != (int)BusinessServiceType.Visiting)
            {
                _errorMessage = "当前订单不是有效的上门服务订单!";
                return;
            }
            if (_order.Status != (int)VisitingServiceOrderStatus.WorkerServiceDone)
            {
                _errorMessage = "当前订单状态不适合进行结算处理!";
                return;
            }

            #endregion

            #region //结算处理

            #region //1、计算订单需要结算的金额
            //线下支付,但下单时有预约金
            if (_order.PaymentType == (int)BusinessServiceOrderPayment.OffLine)
            {
                if (_order.PrepaidAmount > 0)
                {
                    _settlementAmount = _order.PrepaidAmount;
                }
            }
            else if (_order.PaiedTime.HasValue)
            {
                _settlementAmount = _order.ActualOrderAmount;
            }
            else
            {
                throw new Exception("当前订单数据异常(线上支付方式但未检测到付款信息),不能自动确定服务完成!");
            }
            _settlementAmount = Math.Abs(_settlementAmount);
            #endregion

            //需要结算,先结算
            if (_settlementAmount > 0)
            {
                #region//2、检测订单付款方
                //支付方
                BusinessServicePayer payer = default(BusinessServicePayer);
                //业务信息
                var business = _context.KylinService_Business.SingleOrDefault(p => p.BusinessID == _order.BusinessID);
                payer = (BusinessServicePayer)Enum.Parse(typeof(BusinessServicePayer), business.PayerType.ToString());
                #endregion

                #region//3、获取用户资金并检测
                _user = _context.User_Account.SingleOrDefault(p => p.UserID == _order.UserID);
                if (null == _user)
                {
                    _errorMessage = "用户数据异常,未检测到用户信息!";
                    return;
                }
                _context.User_Account.Attach(_user);
                _context.Entry(_user).Property(p => p.Balance).IsModified = true;
                #endregion

                #region //4、检测并获取服务提供方信息
                //服务提供方类型
                BusinessOrderServiceProvider servicerProvider = default(BusinessOrderServiceProvider);
                servicerProvider = (BusinessOrderServiceProvider)Enum.Parse(typeof(BusinessOrderServiceProvider), _order.ServerType.ToString());

                switch (servicerProvider)
                {
                case BusinessOrderServiceProvider.Merchant:
                    _merchant = _context.Merchant_Account.SingleOrDefault(p => p.MerchantID == _order.MerchantID);
                    break;

                case BusinessOrderServiceProvider.Person:
                    _worker = _context.User_Account.SingleOrDefault(p => p.UserID == _order.WorkerID);
                    break;
                }
                //如果服务者不存在,则返回错误
                if (_merchant == null && _worker == null)
                {
                    _errorMessage = "启奏陛下,订单的服务提供者最近学会一种新的奇门循土术,突然就不见了,请陛下明察!";
                    return;
                }
                if (_merchant != null)
                {
                    _context.Merchant_Account.Attach(_merchant);
                    _context.Entry(_merchant).Property(p => p.Balance).IsModified     = true;
                    _context.Entry(_merchant).Property(p => p.FreezeMoney).IsModified = true;
                }
                if (_worker != null)
                {
                    _context.User_Account.Attach(_worker);
                    _context.Entry(_worker).Property(p => p.Balance).IsModified     = true;
                    _context.Entry(_worker).Property(p => p.FreezeMoney).IsModified = true;
                }
                #endregion

                #region //5、获取当前订单所归属区域的运营商
                //区域(大区域,即运营商区域)
                var operatorQuery = from op in _context.Area_Operator
                                    join ao in _context.Area_OperatorRelation
                                    on op.OperatorID equals ao.OperatorID
                                    where ao.AreaID == _order.AreaID
                                    select op;
                _operator = operatorQuery.FirstOrDefault();
                if (null == _operator)
                {
                    _errorMessage = "启奏陛下,订单所在区域运营商不存在,微臣不敢擅作主张,还请陛下圣断!";
                    return;
                }
                _context.Area_Operator.Attach(_operator);
                _context.Entry(_operator).Property(p => p.Balance).IsModified = true;
                //运营商基本资料
                _operatorProfile = _context.Area_OperatorProfile.SingleOrDefault(p => p.OperatorID == _operator.OperatorID);
                #endregion

                #region //6、处理结算及记录
                //6.1 如果付款方为服务者(商),表示服务人员付款给用户,则不需要考虑抽成
                if (payer == BusinessServicePayer.Servicer)
                {
                    //商户接单,商家付
                    if (servicerProvider == BusinessOrderServiceProvider.Merchant)
                    {
                        MerchantPaymentToUser();
                    }
                    //个人服务者接单,个人服务者付
                    else if (servicerProvider == BusinessOrderServiceProvider.Person)
                    {
                        WorkerPaymentToUser();
                    }
                }
                //6.2 如果付款方为用户,表示用户付款给服务提供者,则从服务者(商)抽成
                else if (payer == BusinessServicePayer.Custom)
                {
                    //商户接单,付给商家
                    if (servicerProvider == BusinessOrderServiceProvider.Merchant)
                    {
                        UserPaymentToMerchant();
                    }
                    //个人服务者接单,付给个人服务人员
                    else if (servicerProvider == BusinessOrderServiceProvider.Person)
                    {
                        UserPaymentToWorker();
                    }
                }
                else
                {
                    _errorMessage = "妈呀,即不是服务受用方也不是服务提供方买单,莫非有雷锋慈善家赞助?先不处理了,陛下,你决定吧!";
                    return;
                }
                #endregion
            }

            if (Success)
            {
                #region//7、更新订单状态
                if (_needProcessOrder)
                {
                    _context.KylinService_Order.Attach(_order);
                    _context.Entry(_order).Property(p => p.Status).IsModified       = true;
                    _context.Entry(_order).Property(p => p.ReceivedTime).IsModified = true;

                    //修改订单状态为已完成
                    _order.Status       = (int)VisitingServiceOrderStatus.UserServiceConfirmDone;
                    _order.ReceivedTime = DateTime.Now;
                }
                #endregion

                #region//8、用户积分奖励
                var pointCalc = new PointCalculator(_order.UserID, UserActivityType.OrderFinish);
                if (pointCalc.CanContinue)
                {
                    int points = pointCalc.Score;

                    //更新用户积分
                    _context.Entry(_user).Property(p => p.Points).IsModified = true;
                    _user.Points += points;

                    //积分获取记录
                    _context.User_PointsRecords.Add(new User_PointsRecords
                    {
                        ActivityType = (int)UserActivityType.OrderFinish,
                        CreateTime   = DateTime.Now,
                        RecordsID    = IDCreater.Instance.GetID(),
                        Remark       = string.Format("上门订单(编号:{0})交易完成,获得{1}积分。", _order.OrderCode, points),
                        Score        = points,
                        UserID       = _order.UserID
                    });
                }
                #endregion

                #region//9、用户经验值奖励
                var empiricalCalc = new EmpiricalCalculator(_order.UserID, UserActivityType.OrderFinish);
                if (empiricalCalc.CanContinue)
                {
                    int empirical = empiricalCalc.Score;

                    //更新用户经验值
                    _context.Entry(_user).Property(p => p.Empirical).IsModified = true;
                    _user.Empirical += empirical;

                    //经验值获取记录
                    _context.User_EmpiricalRecords.Add(new User_EmpiricalRecords
                    {
                        ActivityType = (int)UserActivityType.OrderFinish,
                        CreateTime   = DateTime.Now,
                        RecordsID    = IDCreater.Instance.GetID(),
                        Remark       = string.Format("上门订单(编号:{0})交易完成,获得{1}点经验值。", _order.OrderCode, empirical),
                        Score        = empirical,
                        UserID       = _order.UserID
                    });
                }
                #endregion

                //返回处理结果
                if (_context.SaveChanges() < 1)
                {
                    _errorMessage = "操作失败!";
                    return;
                }
                else
                {
                    _errorMessage = null;

                    #region//10、消息推送
                    try
                    {
                        var pushRedis = Startup.PushRedisConfigs[RedisPushType.AppointOrderReceivedGoods];

                        if (null != pushRedis)
                        {
                            var msgContent = new AppointOrderReceivedGoodsContent
                            {
                                ActualOrderAmount = _order.ActualOrderAmount,
                                OrderCode         = _order.OrderCode,
                                OrderID           = _order.OrderID,
                                UserFinishTime    = _order.UserFinishTime ?? DateTime.Now,
                                UserID            = _order.UserID,
                                UserName          = _user.Username,
                                MerchantID        = _order.MerchantID,
                                BusinessType      = _order.BusinessType,
                                ServerType        = _order.ServerType,
                                WorkerID          = _order.WorkerID
                            };
                            var pushDb = PushRedisContext.Redis.GetDatabase(pushRedis.DbIndex);

                            if (pushDb != null)
                            {
                                pushDb.ListRightPush(pushRedis.Key, msgContent);
                            }
                        }
                    }
                    catch { }
                    #endregion
                }
            }

            #endregion

            _context.Dispose();
        }
예제 #2
0
        /// <summary>
        /// 执行结算
        /// </summary>
        public override void Execute()
        {
            #region//检测订单有效性

            if (null == _order)
            {
                _errorMessage = "订单数据不存在!";
                return;
            }

            if (_order.OrderStatus != (int)MerchantOrderStatus.WaitingReceipt)
            {
                _errorMessage = "当前订单状态不适合进行结算处理!";
                return;
            }

            #endregion

            #region //结算处理

            using (var db = new DataContext())
            {
                #region//1、获取用户资金并检测
                var user = db.User_Account.SingleOrDefault(p => p.UserID == _order.UserID);
                if (null == user)
                {
                    _errorMessage = "用户数据异常,未检测到用户信息!";
                    return;
                }
                if (user.FreezeMoney < _order.ActualOrderAmount)
                {
                    _errorMessage = "呼叫程序猿,用户钱跑哪去了?冻结资金结算不了当前订单!";
                    return;
                }
                #endregion

                #region//2、获得商家信息
                var merchant = db.Merchant_Account.SingleOrDefault(p => p.MerchantID == _order.MerchantID);
                if (null == merchant)
                {
                    _errorMessage = "哇哦,商家呢?跑哪去了,不见了?钱给谁?给谁?给谁……";
                    return;
                }
                #endregion

                #region//3、得到区域运营商信息
                //区域(大区域,即运营商区域)
                var areaID     = merchant.AreaID;
                var openAreas  = CacheCollection.OpenAreaCache.Value();
                var areaLayers = merchant.AreaLayer.Split(new[] { ',', '|' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var area in openAreas)
                {
                    if (areaLayers.Contains(area.AreaID.ToString()))
                    {
                        areaID = area.AreaID;
                        break;
                    }
                }

                var operatorQuery = from op in db.Area_Operator
                                    join ao in db.Area_OperatorRelation
                                    on op.OperatorID equals ao.OperatorID
                                    where ao.AreaID == areaID
                                    select op;
                var operater = operatorQuery.FirstOrDefault();
                if (null == operater)
                {
                    _errorMessage = "启奏陛下,订单所在区域运营商不存在,微臣不敢擅作主张,还请陛下圣断!";
                    return;
                }
                //运营商基本资料
                var operatorProfile = db.Area_OperatorProfile.SingleOrDefault(p => p.OperatorID == operater.OperatorID);
                #endregion

                #region//4、用户货款从冻结金额中结算并写入交易记录、资金明细
                db.User_Account.Attach(user);
                db.Entry(user).Property(p => p.FreezeMoney).IsModified = true;
                user.FreezeMoney -= _order.ActualOrderAmount;
                #endregion

                #region//5、获取用户支付时的交易记录信息(从中获取平台交易流水号)
                var userTradeRecord = db.User_TradeRecords.Where(p => p.DataID == _order.OrderID).FirstOrDefault();

                string mainTransCode = null != userTradeRecord ? userTradeRecord.PlatformTransactionCode : string.Empty;
                if (!string.IsNullOrWhiteSpace(mainTransCode) && mainTransCode.Length == 24)
                {
                    mainTransCode = mainTransCode.Remove(23, 1);
                }
                if (mainTransCode.Length != 23)
                {
                    mainTransCode = IDCreater.Instance.GetPlatformTransactionCode(PlatformTransactionType.BuyProduct, areaID);
                }
                //业务序号
                int transIndex = 0;
                #endregion

                #region//6、货款结算给商家
                string merchantGetSaleTransCode = mainTransCode + (++transIndex);
                db.Merchant_Account.Attach(merchant);
                db.Entry(merchant).Property(p => p.Balance).IsModified = true;
                merchant.Balance = merchant.Balance + _order.ActualOrderAmount;

                //写入商家交易记录
                var merchantSaleTrandsRecords = new Merchant_TradeRecords
                {
                    Amount                  = _order.ActualOrderAmount,
                    CounterpartyId          = _order.UserID,
                    CounterpartyIdentity    = (int)CounterpartyIdentity.User,
                    CreateTime              = DateTime.Now,
                    DataID                  = _order.OrderID,
                    LastBalance             = merchant.Balance,
                    MerchantID              = merchant.MerchantID,
                    PaymentType             = (int)OnlinePaymentType.Balance,
                    PlatformTransactionCode = merchantGetSaleTransCode,
                    TradeID                 = IDCreater.Instance.GetID(),
                    TradeInfo               = string.Format("销售商品,订单编号:{0}", _order.OrderCode),
                    TradeNo                 = string.Empty,
                    TradeType               = (int)MerchantTransType.ProductSales
                };
                db.Merchant_TradeRecords.Add(merchantSaleTrandsRecords);

                //写入平台资金流水
                db.Platform_MoneyTransaction.Add(new Platform_MoneyTransaction
                {
                    Amount               = merchantSaleTrandsRecords.Amount,
                    AreaID               = areaID,
                    CustomAccountID      = merchantSaleTrandsRecords.MerchantID,
                    CustomIdentity       = (int)CounterpartyIdentity.Merchant,
                    CustomName           = merchant.Name,
                    IsMainTransaction    = false,
                    LastBalance          = merchantSaleTrandsRecords.LastBalance,
                    Remark               = string.Format("销售商品,订单编号:{0}", _order.OrderCode),
                    ThirdTransactionCode = string.Empty,
                    TransactionCode      = merchantGetSaleTransCode,
                    TransactionTime      = DateTime.Now,
                    TransactionType      = (int)PlatformTransactionType.SaleProduct
                });
                #endregion

                //总抽成
                decimal totalCommissionMoney = new AreaForMerchantCommissionCalculator(areaID, _order.MerchantID, AreaMerchantCommissionOption.MerchantProductOrder, _order.ActualOrderAmount).CommissionMoney;

                //抽成金额>0时
                if (totalCommissionMoney > 0)
                {
                    #region //7、区域运营商抽成

                    #region //商家返佣给运营商
                    merchant.Balance -= totalCommissionMoney;
                    string merchantReturnTransCode = mainTransCode + (++transIndex);
                    //写入商家返佣记录
                    var merchantReturnTrandsRecords = new Merchant_TradeRecords
                    {
                        Amount                  = -totalCommissionMoney,
                        CounterpartyId          = operater.OperatorID,
                        CounterpartyIdentity    = (int)CounterpartyIdentity.AreaOperator,
                        CreateTime              = DateTime.Now,
                        DataID                  = _order.OrderID,
                        LastBalance             = merchant.Balance,
                        MerchantID              = _order.MerchantID,
                        PaymentType             = (int)OnlinePaymentType.Balance,
                        PlatformTransactionCode = merchantReturnTransCode,
                        TradeID                 = IDCreater.Instance.GetID(),
                        TradeInfo               = string.Format("销售商品返佣金给运营商,订单编号:{0}", _order.OrderCode),
                        TradeNo                 = string.Empty,
                        TradeType               = (int)MerchantTransType.ReturnCommissionToOperator
                    };
                    db.Merchant_TradeRecords.Add(merchantReturnTrandsRecords);

                    //写入平台资金流水
                    db.Platform_MoneyTransaction.Add(new Platform_MoneyTransaction
                    {
                        Amount               = merchantReturnTrandsRecords.Amount,
                        AreaID               = areaID,
                        CustomAccountID      = merchantReturnTrandsRecords.MerchantID,
                        CustomIdentity       = (int)CounterpartyIdentity.Merchant,
                        CustomName           = merchant.Name,
                        IsMainTransaction    = false,
                        LastBalance          = merchantReturnTrandsRecords.LastBalance,
                        Remark               = string.Format("销售商品返佣金给运营商,订单编号:{0}", _order.OrderCode),
                        ThirdTransactionCode = string.Empty,
                        TransactionCode      = merchantReturnTransCode,
                        TransactionTime      = DateTime.Now,
                        TransactionType      = (int)PlatformTransactionType.PayCommission
                    });
                    #endregion

                    #region//运营商接收商家返佣
                    db.Area_Operator.Attach(operater);
                    db.Entry(operater).Property(p => p.Balance).IsModified = true;
                    operater.Balance += totalCommissionMoney;
                    string operatorGetReturnCommissionTransCode = mainTransCode + (++transIndex);
                    //写入运营商交易记录
                    var operatorGetReturnCommissionTrandsRecords = new AreaOperator_TradeRecords
                    {
                        Amount                  = totalCommissionMoney,
                        CounterpartyId          = _order.MerchantID,
                        CounterpartyIdentity    = (int)CounterpartyIdentity.Merchant,
                        CreateTime              = DateTime.Now,
                        DataID                  = _order.OrderID,
                        LastBalance             = operater.Balance,
                        OpeartorID              = operater.OperatorID,
                        PaymentType             = (int)OnlinePaymentType.Balance,
                        PlatformTransactionCode = operatorGetReturnCommissionTransCode,
                        TradeID                 = IDCreater.Instance.GetID(),
                        TradeInfo               = string.Format("从商家销售商品中抽成,订单编号:{0}", _order.OrderCode),
                        TradeNo                 = string.Empty,
                        TradeType               = (int)OperatorTradeType.CommissionGet
                    };
                    db.AreaOperator_TradeRecords.Add(operatorGetReturnCommissionTrandsRecords);
                    //写入平台资金流水
                    db.Platform_MoneyTransaction.Add(new Platform_MoneyTransaction
                    {
                        Amount               = operatorGetReturnCommissionTrandsRecords.Amount,
                        AreaID               = areaID,
                        CustomAccountID      = operatorGetReturnCommissionTrandsRecords.OpeartorID,
                        CustomIdentity       = (int)CounterpartyIdentity.AreaOperator,
                        CustomName           = operatorProfile?.CompanyName,
                        IsMainTransaction    = false,
                        LastBalance          = operatorGetReturnCommissionTrandsRecords.LastBalance,
                        Remark               = string.Format("从商家销售商品中抽成,订单编号:{0}", _order.OrderCode),
                        ThirdTransactionCode = string.Empty,
                        TransactionCode      = operatorGetReturnCommissionTransCode,
                        TransactionTime      = DateTime.Now,
                        TransactionType      = (int)PlatformTransactionType.CommissionGet
                    });
                    #endregion

                    #endregion

                    #region//8、运营商返佣金给平台(平台抽成)
                    //平台应抽成金额
                    decimal platformCommissionMoney = new PlatformCommissionCalculator(areaID, PlatformCommissionOption.AreaCommissionByMerchantOrder, totalCommissionMoney).CommissionMoney;

                    //需要抽佣时(抽佣金额>0)才进入
                    if (platformCommissionMoney > 0)
                    {
                        //从余额中支付佣金给平台
                        operater.Balance = operater.Balance - platformCommissionMoney;

                        //本次流水号
                        string operatorPayCommissionTransCode = mainTransCode + (++transIndex);
                        //记录本次操作,写入运营商交易记录
                        var operatorPayCommissionTrandsRecords = new AreaOperator_TradeRecords
                        {
                            Amount                  = -platformCommissionMoney,
                            CounterpartyId          = 0,
                            CounterpartyIdentity    = (int)CounterpartyIdentity.Platform,
                            CreateTime              = DateTime.Now,
                            DataID                  = _order.OrderID,
                            LastBalance             = operater.Balance,
                            OpeartorID              = operater.OperatorID,
                            PaymentType             = (int)OnlinePaymentType.Balance,
                            PlatformTransactionCode = operatorPayCommissionTransCode,
                            TradeID                 = IDCreater.Instance.GetID(),
                            TradeInfo               = string.Format("从商家订单抽成后返佣金给平台,订单编号:{0}", _order.OrderCode),
                            TradeNo                 = string.Empty,
                            TradeType               = (int)OperatorTradeType.PayCommission
                        };
                        db.AreaOperator_TradeRecords.Add(operatorPayCommissionTrandsRecords);
                        //写入平台资金流水
                        db.Platform_MoneyTransaction.Add(new Platform_MoneyTransaction
                        {
                            Amount               = operatorPayCommissionTrandsRecords.Amount,
                            AreaID               = areaID,
                            CustomAccountID      = operater.OperatorID,
                            CustomIdentity       = (int)CounterpartyIdentity.AreaOperator,
                            CustomName           = operatorProfile?.CompanyName,
                            IsMainTransaction    = false,
                            LastBalance          = operatorPayCommissionTrandsRecords.LastBalance,
                            Remark               = string.Format("从商家订单抽成后返佣金给平台,订单编号:{0}", _order.OrderCode),
                            ThirdTransactionCode = string.Empty,
                            TransactionCode      = operatorPayCommissionTransCode,
                            TransactionTime      = DateTime.Now,
                            TransactionType      = (int)PlatformTransactionType.PayCommission
                        });
                    }
                    #endregion
                }

                #region//9、更新订单状态
                if (_needProcessOrder)
                {
                    db.Merchant_Order.Attach(_order);
                    db.Entry(_order).Property(p => p.OrderStatus).IsModified  = true;
                    db.Entry(_order).Property(p => p.ReceivedTime).IsModified = true;

                    //修改订单状态为已完成
                    _order.OrderStatus  = (int)MerchantOrderStatus.Done;
                    _order.ReceivedTime = DateTime.Now;
                }
                #endregion

                #region//10、用户积分奖励
                var pointCalc = new PointCalculator(_order.UserID, UserActivityType.OrderFinish);
                if (pointCalc.CanContinue)
                {
                    int points = pointCalc.Score;

                    //更新用户积分
                    db.Entry(user).Property(p => p.Points).IsModified = true;
                    user.Points += points;

                    //积分获取记录
                    db.User_PointsRecords.Add(new User_PointsRecords
                    {
                        ActivityType = (int)UserActivityType.OrderFinish,
                        CreateTime   = DateTime.Now,
                        RecordsID    = IDCreater.Instance.GetID(),
                        Remark       = string.Format("订单(编号:{0})交易完成,获得{1}积分。", _order.OrderCode, points),
                        Score        = points,
                        UserID       = _order.UserID
                    });
                }
                #endregion

                #region//11、用户经验值奖励
                var empiricalCalc = new EmpiricalCalculator(_order.UserID, UserActivityType.OrderFinish);
                if (empiricalCalc.CanContinue)
                {
                    int empirical = empiricalCalc.Score;

                    //更新用户经验值
                    db.Entry(user).Property(p => p.Empirical).IsModified = true;
                    user.Empirical += empirical;

                    //经验值获取记录
                    db.User_EmpiricalRecords.Add(new User_EmpiricalRecords
                    {
                        ActivityType = (int)UserActivityType.OrderFinish,
                        CreateTime   = DateTime.Now,
                        RecordsID    = IDCreater.Instance.GetID(),
                        Remark       = string.Format("订单(编号:{0})交易完成,获得{1}点经验值。", _order.OrderCode, empirical),
                        Score        = empirical,
                        UserID       = _order.UserID
                    });
                }
                #endregion

                //返回处理结果
                if (db.SaveChanges() < 1)
                {
                    _errorMessage = "操作失败!";
                    return;
                }
                else
                {
                    _errorMessage = null;

                    #region//12、消息推送
                    try
                    {
                        var pushRedis = Startup.PushRedisConfigs[RedisPushType.MerchantOrderReceivedGoods];

                        if (null != pushRedis)
                        {
                            var msgContent = new MerchantOrderReceivedGoodsContent
                            {
                                ActualOrderAmount = _order.ActualOrderAmount,
                                OrderCode         = _order.OrderCode,
                                OrderID           = _order.OrderID,
                                ReceivedTime      = _order.ReceivedTime ?? DateTime.Now,
                                UserID            = _order.UserID,
                                UserName          = user.Username,
                                MerchantID        = _order.MerchantID
                            };

                            var pushDb = PushRedisContext.Redis.GetDatabase(pushRedis.DbIndex);

                            if (pushDb != null)
                            {
                                pushDb.ListRightPush(pushRedis.Key, msgContent);
                            }
                        }
                    }
                    catch { }
                    #endregion
                }
            }
            #endregion
        }