public List <CardDetailResponse> UpdateCards(List <CardDetail> cards, ExternalSystemFields externalFields, IConfig config)
        {
            List <CardDetailResponse> updated = new List <CardDetailResponse>();

            foreach (var card in cards)
            {
                if (card.product_id == 99)
                {
                    throw new Exception("Some exception");
                }

                updated.Add(new CardDetailResponse
                {
                    CardId           = card.card_id,
                    Detail           = "Success",
                    TimeUpdated      = DateTime.Now,
                    UpdateSuccessful = true
                });
            }

            return(updated);
        }
Exemple #2
0
        public BaseResponse ChargeAmount(CustomerDetails customerDetails, AuditInfo auditInfo, Veneka.Indigo.Integration.Config.IConfig config, ExternalSystemFields externalFields)
        {
            List <IProductPrintField> printFields = _cardManService.GetProductPrintFields(customerDetails.ProductId, null, null);

            _log.Trace(t => t("Looking up account in Core Banking System."));

            if (config == null)
            {
                _log.Trace("FeeChargeLogic: ChargeAmount config IS NULL");
            }

            InterfaceInfo interfaceInfo = new InterfaceInfo
            {
                Config        = config,
                InterfaceGuid = config.InterfaceGuid.ToString()
            };

            _log.Trace("InterfaceInfo interfaceInfo = new InterfaceInfo : No Issues");

            CardObject _object = new CardObject();

            _object.CustomerAccount = new AccountDetails();
            _object.CustomerAccount.AccountNumber = customerDetails.AccountNumber;
            _object.PrintFields = printFields;
            var response = _comsCore.CheckBalance(customerDetails, externalFields, interfaceInfo, auditInfo);

            if (response.ResponseCode == 0)
            {
                {
                    try
                    {
                        string feeResponse = String.Empty;

                        // Charge Fee if it's greater than 0 and has not already been charged for.
                        if (customerDetails.FeeCharge != null && customerDetails.FeeCharge.Value > 0 && String.IsNullOrWhiteSpace(customerDetails.FeeReferenceNumber))
                        {
                            _log.Trace(t => t("FeeChargeLogic: ChargeAmount : calling Charge the fee."));
                            string feeReferenceNumber = string.Empty;

                            var response_fee = _comsCore.ChargeFee(customerDetails, externalFields, interfaceInfo, auditInfo);

                            if (response_fee.ResponseCode == 0)
                            {
                                // customerDetails.FeeReferenceNumber = feeReferenceNumber;
                                _log.DebugFormat($"FeeReferenceNumber {customerDetails.FeeReferenceNumber}");
                                return(new BaseResponse(ResponseType.SUCCESSFUL, feeResponse, feeResponse));
                            }
                            else
                            {
                                _log.Trace(t => t(feeResponse));

                                return(new BaseResponse(ResponseType.UNSUCCESSFUL, feeResponse, feeResponse));
                            }
                        }
                        else
                        {
                            if (!String.IsNullOrWhiteSpace(customerDetails.FeeReferenceNumber))
                            {
                                if (_log.IsDebugEnabled)
                                {
                                    _log.DebugFormat("Fee already charged: Ref{0}", customerDetails.FeeReferenceNumber);
                                }
                                else
                                {
                                    _log.Trace(t => t("Fee already charged."));
                                }
                            }
                            return(new BaseResponse(ResponseType.SUCCESSFUL, feeResponse, feeResponse));
                        }
                    }
                    catch (NotImplementedException nie)
                    {
                        _log.Warn(nie);
                        return(new BaseResponse(ResponseType.ERROR,
                                                nie.Message,
                                                nie.Message));
                    }
                    catch (Exception ex)
                    {
                        _log.Error(ex);
                        return(new BaseResponse(ResponseType.ERROR,
                                                ex.Message,
                                                _log.IsDebugEnabled || _log.IsTraceEnabled ? ex.Message : ""));
                    }
                }
            }

            return(new BaseResponse(ResponseType.UNSUCCESSFUL, response.ResponseMessage, response.ResponseMessage));
        }