Пример #1
0
        public void StartService()
        {
            RabbitMQWorker.Start("PaymentGatewayPayOrder", Payment);
            RabbitMQWorker.Start("PaymentGatewayRefund", Refund);
            RabbitMQWorker.Start("PaymentNotification", Notification);

            _process.ReNotification();
        }
Пример #2
0
 protected override void OnStart(string[] args)
 {
     RabbitMQWorker.Start("MiningConfirmed", message =>
     {
         try
         {
             var model = JsonConvert.DeserializeObject <MiningConfirmedModel>(message);
             if (model == null)
             {
                 _log.Info($"MiningConfirmed message deserialize error,message:{message}");
             }
             new MiningComponent().MiningConfirmed(model);
         }
         catch (Exception exception)
         {
             _log.Error(exception.Message, exception);
         }
     });
     _log.Info("FiiiPayMQBussiness process service started");
 }
Пример #3
0
 public void Start()
 {
     RabbitMQWorker.Start("MiningConfirmed", message =>
     {
         try
         {
             var model = JsonConvert.DeserializeObject <MiningConfirmedModel>(message);
             if (model == null)
             {
                 LogHelper.Info($"MiningConfirmed message deserialize error,message:{message}");
             }
             new MiningComponent().MiningConfirmed(model);
         }
         catch (Exception exception)
         {
             LogHelper.Error(exception.Message, exception);
         }
     });
     LogHelper.Info("FiiiPayMQBussiness process service started");
 }
Пример #4
0
        protected override void OnStart(string[] args)
        {
            try
            {
                LogHelper.Config();

                RabbitMQWorker.Start("FiiiPosInviteReward", (msg) =>
                {
                    LogHelper.Info($"Received MQ message:{msg}");
                    FiiiPayRewardMessage message = JsonConvert.DeserializeObject <FiiiPayRewardMessage>(msg);
                    try
                    {
                        if (cryptoId == 0)
                        {
                            var fiiicoin = new CryptocurrencyDAC().GetByCode("FIII");
                            cryptoId     = fiiicoin.Id;
                        }
                        new InviteReward().DistributeRewards(message, cryptoId);
                    }
                    catch (CommonException cex)
                    {
                        LogHelper.Info($"DistributeRewards faild, error message:{cex.Message}, param:{msg}");
                    }
                    catch (Exception ex)
                    {
                        _logger.Info($"InviteFaild - ErrorMessage:{ex.Message}, param:{msg}");
                        throw ex;
                    }
                });

                LogHelper.Info("FiiiPos.InviteReward process service started.");
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex);
            }
        }
Пример #5
0
 protected override void OnStop()
 {
     RabbitMQWorker.Stop();
 }
Пример #6
0
        protected override void OnStart(string[] args)
        {
            try
            {
                #region 用于消息推送的消息队列

                RabbitMQWorker.Start("MerchantArticle", message =>
                {
                    _log.Info("ReciveMessage:MerchantArticle");
                    try
                    {
                        int.TryParse(message, out int id);
                        new FiiiPOSPushComponent().PushArticle(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("FiiiPos_BackOfficeRefundOrder", message =>
                {
                    _log.Info("ReciveMessage:FiiiPos_BackOfficeRefundOrder");
                    try
                    {
                        new FiiiPOSPushComponent().PushRefundOrder(message);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantDepositCancel", message =>
                {
                    _log.Info("ReciveMessage:MerchantDepositCancel");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushDepositCancel(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("MerchantDeposit", message =>
                {
                    _log.Info("ReciveMessage:MerchantDeposit");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushDeposit(id);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantInviteSuccessed", message =>
                {
                    _log.Info("ReciveMessage:MerchantInviteSuccessed");
                    try
                    {
                        long.TryParse(message, out long id);
                        _log.Info("message id " + id);
                        new FiiiPOSPushComponent().PushInviteSuccess(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("MerchantLv1VerifiedFailed", message =>
                {
                    _log.Info("ReciveMessage:MerchantLv1VerifiedFailed");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().MerchantLv1Reject(id);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantLv1Verified", message =>
                {
                    _log.Info("ReciveMessage:MerchantLv1Verified");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().MerchantLv1Verified(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("MerchantLv2VerifiedFailed", message =>
                {
                    _log.Info("ReciveMessage:MerchantLv2VerifiedFailed");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().MerchantLv2Reject(id);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantLv2Verified", message =>
                {
                    _log.Info("ReciveMessage:MerchantLv2Verified");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().MerchantLv2Verified(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("OrderPayed", message =>
                {
                    _log.Info("ReciveMessage:OrderPayed");
                    try
                    {
                        Guid.TryParse(message, out Guid orderId);
                        new FiiiPOSPushComponent().PushOrderPayed(orderId);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantTransferFromEx", message =>
                {
                    _log.Info("ReciveMessage:MerchantTransferFromEx");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushTransferFromEx(id);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantTransferToEx", message =>
                {
                    _log.Info("ReciveMessage:MerchantTransferToEx");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushTransferToEx(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("MerchantWithdrawCompleted", message =>
                {
                    _log.Info("ReciveMessage:MerchantWithdrawCompleted");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushWithdrawCompleted(id);
                    }
                    catch (FiiiPay.Framework.Exceptions.CommonException x)
                    {
                        _log.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                    }
                });

                RabbitMQWorker.Start("MerchantWithdrawReject", message =>
                {
                    _log.Info("ReciveMessage:MerchantWithdrawReject");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushWithdrawReject(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });
                RabbitMQWorker.Start("STORE_VERIFIED", message =>
                {
                    _log.Info("ReciveMessage:STORE_VERIFIED");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushStoreVerified(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });
                RabbitMQWorker.Start("STORE_REJECT", message =>
                {
                    _log.Info("ReciveMessage:STORE_REJECT");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPOSPushComponent().PushStoreReject(id);
                    }
                    catch (Exception exception)
                    {
                        _log.Error(exception.Message, exception);
                    }
                });


                #endregion
            }
            catch (Exception ex)
            {
                _log.Error(ex);
            }
        }
Пример #7
0
        protected override void OnStop()
        {
            RabbitMQWorker.Stop();

            _log.Info("FiiiPayMQBussiness process service stopped.");
        }
Пример #8
0
 public void Stop()
 {
     RabbitMQWorker.Stop();
     LogHelper.Info("FiiiPayMQBussiness process service stopped.");
 }
Пример #9
0
 protected override void OnStop()
 {
     RabbitMQWorker.Stop();
     LogHelper.Info("FiiiPay.Background.GatewayMQPull process service stopped.");
     base.OnStop();
 }
Пример #10
0
        public void Start()
        {
            try
            {
                #region 用于跨系统访问的消息队列

                RabbitMQWorker.Start("Gateway_FiiiPay_ScanOrder", message =>
                {
                    try
                    {
                        new GatewayOrderComponent().GatewayPay(message);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("Gateway_FiiiPay_Refund", message =>
                {
                    try
                    {
                        new GatewayOrderComponent().GatewayRefund(message);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                #endregion


                RabbitMQWorker.StartNack("WithdrawSubmit", message =>
                {
                    LogHelper.Info($"ReciveMessage:WithdrawSubmit,message:{message}");
                    try
                    {
                        var model = JsonConvert.DeserializeObject <CreateWithdrawModel>(message);
                        new WithdrawSubmitComponent().SubmitWithdrawal(model);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                        throw exception;
                    }
                });

                RabbitMQWorker.Start("FiiiPay_RedPocket-delay", message =>
                {
                    LogHelper.Info($"ReciveMessage:RedPocket,message:{message}");
                    try
                    {
                        long.TryParse(message, out long id);
                        new RedPocketComponent().Refund(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                        throw exception;
                    }
                });

                #region 用于消息推送的消息队列

                RabbitMQWorker.Start("UserArticle", message =>
                {
                    LogHelper.Info("ReciveMessage:UserArticle");
                    try
                    {
                        int.TryParse(message, out int id);
                        new FiiiPayPushComponent().PushArticle(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("FiiiPay_BackOfficeRefundOrder", message =>
                {
                    LogHelper.Info("ReciveMessage:FiiiPay_BackOfficeRefundOrder");
                    try
                    {
                        new FiiiPayPushComponent().BackOfficeRefundOrder(message);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserDepositCancel", message =>
                {
                    LogHelper.Info("ReciveMessage:UserDepositCancel");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushDepositCancel(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserDeposit", message =>
                {
                    LogHelper.Info("ReciveMessage:UserDeposit");
                    try
                    {
                        var id = long.Parse(message);
                        new FiiiPayPushComponent().PushDeposit(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserInviteSuccessed", message =>
                {
                    LogHelper.Info("ReciveMessage:UserInviteSuccessed");
                    try
                    {
                        long.TryParse(message, out long id);
                        LogHelper.Info("message id " + id);
                        new FiiiPayPushComponent().PushInviteSuccess(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserKYC_LV1_REJECT", message =>
                {
                    LogHelper.Info("ReciveMessage:UserKYC_LV1_REJECT");
                    try
                    {
                        var id = long.Parse(message);
                        new FiiiPayPushComponent().PushKYC_LV1_REJECT(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserKYC_LV1_VERIFIED", message =>
                {
                    LogHelper.Info("ReciveMessage:UserKYC_LV1_VERIFIED");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushKYC_LV1_VERIFIED(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserKYC_LV2_REJECT", message =>
                {
                    LogHelper.Info("ReciveMessage:UserKYC_LV2_REJECT");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushKYC_LV2_REJECT(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("ConsumeOrder", message =>
                {
                    LogHelper.Info("ReciveMessage:ConsumeOrder");
                    try
                    {
                        new FiiiPayPushComponent().PushConsume(message);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserKYC_LV2_VERIFIED", message =>
                {
                    LogHelper.Info("ReciveMessage:UserKYC_LV2_VERIFIED");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushKYC_LV2_VERIFIED(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("PayOrder", message =>
                {
                    LogHelper.Info("ReciveMessage:PayOrder");
                    try
                    {
                        new FiiiPayPushComponent().PushPayOrder(message);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("RefundOrder", message =>
                {
                    LogHelper.Info("ReciveMessage:RefundOrder");
                    try
                    {
                        new FiiiPayPushComponent().RefundOrder(message);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserTransferFromEx", message =>
                {
                    LogHelper.Info("ReciveMessage:UserTransferFromEx");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushTransferFromEx(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserTransferToEx", message =>
                {
                    LogHelper.Info("ReciveMessage:UserTransferToEx");
                    try
                    {
                        long.TryParse(message, out long id);
                        LogHelper.Info("message id " + id);
                        new FiiiPayPushComponent().PushTransferToEx(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserWithdrawCompleted", message =>
                {
                    LogHelper.Info("ReciveMessage:UserWithdrawCompleted");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushWithdrawCompleted(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserWithdrawReject", message =>
                {
                    LogHelper.Info("ReciveMessage:UserWithdrawReject");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushWithdrawReject(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("UserTransferOutFiiiPay", message =>
                {
                    LogHelper.Info("ReciveMessage:UserTransferOutFiiiPay");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushTransferOut(id);
                    }
                    catch (Framework.Exceptions.CommonException x)
                    {
                        LogHelper.Error(x.ReasonCode, x);
                    }
                    catch (Exception ex)
                    {
                        LogHelper.Error(ex);
                    }
                });

                RabbitMQWorker.Start("UserTransferIntoFiiiPay", message =>
                {
                    LogHelper.Info("ReciveMessage:UserTransferIntoFiiiPay");
                    try
                    {
                        long.TryParse(message, out long id);
                        new FiiiPayPushComponent().PushTransferInto(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });
                RabbitMQWorker.Start("UnBindingAccount", message =>
                {
                    LogHelper.Info("ReciveMessage:UnBindingAccount");
                    try
                    {
                        var data = JsonConvert.DeserializeObject <Tuple <Guid, long> >(message);

                        new FiiiPayPushComponent().UnBindingFiiipos(data);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("InvitePosBindSuccess", message =>
                {
                    LogHelper.Info("ReciveMessage:InvitePosBindSuccess");
                    try
                    {
                        var data = JsonConvert.DeserializeObject <Tuple <Guid, long> >(message);

                        new FiiiPayPushComponent().InviteFiiiposSuccess(data);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("ShopPayment", message =>
                {
                    LogHelper.Info("ReciveMessage:ShopPayment");
                    try
                    {
                        Guid.TryParse(message, out Guid id);

                        new FiiiPayPushComponent().ShopPayment(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("ShopPaymentRefund", message =>
                {
                    LogHelper.Info("ReciveMessage:ShopPaymentRefund");
                    try
                    {
                        Guid.TryParse(message, out Guid id);

                        new FiiiPayPushComponent().ShopPaymentRefund(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("Biller", message =>
                {
                    LogHelper.Info("ReciveMessage:Biller");
                    try
                    {
                        Guid.TryParse(message, out Guid id);

                        new FiiiPayPushComponent().PushBiller(id);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("StoreOrderPayed", message =>
                {
                    LogHelper.Info("ReciveMessage:StoreOrderPayed,Message:" + message);
                    try
                    {
                        var messageEntity = JsonConvert.DeserializeObject <StoreOrderMessage>(message);

                        new FiiiPayPushComponent().StoreOrderPayed(messageEntity);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                RabbitMQWorker.Start("FiiipayMerchantProfileVerified", message =>
                {
                    LogHelper.Info("ReciveMessage:FiiipayMerchantProfileVerified,Message:" + message);
                    try
                    {
                        var messageEntity = JsonConvert.DeserializeObject <FiiiPayMerchantProfileVerified>(message);

                        new FiiiPayPushComponent().FiiipayMerchantProfileVerified(messageEntity);
                    }
                    catch (Exception exception)
                    {
                        LogHelper.Error(exception.Message, exception);
                    }
                });

                #endregion

                LogHelper.Info("FiiiPay.Background.GatewayMQPull process service started.");
            }
            catch (Exception ex)
            {
                LogHelper.Error(ex);
            }
        }