Example #1
0
        public async Task <DatabaseResponse> GetAccountInvoiceMessageQueueBody(int invoiceId)
        {
            try
            {
                SqlParameter[] parameters =
                {
                    new SqlParameter("@InvoiceID", SqlDbType.Int)
                };

                parameters[0].Value = invoiceId;

                _DataHelper = new DataAccessHelper("Orders_GetInvoiceMessageQueueBody", parameters, _configuration);

                DataSet ds = new DataSet();

                int result = await _DataHelper.RunAsync(ds); // 105 /102

                DatabaseResponse response = new DatabaseResponse();

                if (result == 105)
                {
                    InvoceQM order = new InvoceQM();

                    if (ds != null && ds.Tables[0] != null && ds.Tables[0].Rows.Count > 0)
                    {
                        order = (from model in ds.Tables[0].AsEnumerable()
                                 select new InvoceQM()
                        {
                            accountID = model.Field <int>("accountID"),
                            customerID = model.Field <int>("customerID"),
                            mobilenumber = model.Field <string>("mobilenumber"),
                            email = model.Field <string>("email"),
                            MPGSOrderID = model.Field <string>("MPGSOrderID"),
                            MaskedCardNumber = model.Field <string>("MaskedCardNumber"),
                            Token = model.Field <string>("Token"),
                            CardType = model.Field <string>("CardType"),
                            IsDefault = model.Field <int?>("IsDefault"),
                            CardHolderName = model.Field <string>("CardHolderName"),
                            ExpiryMonth = model.Field <int?>("ExpiryMonth"),
                            ExpiryYear = model.Field <int?>("ExpiryYear"),
                            CardFundMethod = model.Field <string>("CardFundMethod"),
                            CardBrand = model.Field <string>("CardBrand"),
                            CardIssuer = model.Field <string>("CardIssuer"),
                            //paymentmode
                            amountpaid = model.Field <double?>("amountPaid"),
                            //invoicelist-- need to take from bss
                            invoiceamounts = model.Field <double?>("invoiceamounts")
                        }).FirstOrDefault();
                    }

                    response = new DatabaseResponse {
                        ResponseCode = result, Results = order
                    };
                }

                else
                {
                    response = new DatabaseResponse {
                        ResponseCode = result
                    };
                }

                return(response);
            }

            catch (Exception ex)
            {
                LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));

                throw (ex);
            }
            finally
            {
                _DataHelper.Dispose();
            }
        }
Example #2
0
        public async void ProcessAccountInvoiceQueueMessage(int InvoiceID)
        {
            try
            {
                OrderDataAccess _orderAccess = new OrderDataAccess(_iconfiguration);

                DatabaseResponse accountTypeResponse = await _orderAccess.GetInvoiceRemarksFromInvoiceID(InvoiceID);

                if (((string)accountTypeResponse.Results) == "RecheduleDeliveryInformation")
                {
                    DatabaseResponse orderMqResponse = new DatabaseResponse();
                    orderMqResponse = await _messageQueueDataAccess.GetRescheduleMessageQueueBody(InvoiceID);

                    QMHelper qMHelper = new QMHelper(_iconfiguration, _messageQueueDataAccess);
                    var      result   = await qMHelper.SendMQ(orderMqResponse);

                    var invoiceDetails = (RescheduleDeliveryMessage)orderMqResponse.Results;

                    if (invoiceDetails != null && invoiceDetails.slotDate != null)
                    {
                        CustomerDetails customer = new CustomerDetails
                        {
                            Name                  = invoiceDetails.name,
                            DeliveryEmail         = invoiceDetails.email,
                            ShippingContactNumber = invoiceDetails.shippingContactNumber,
                            OrderNumber           = invoiceDetails.orderNumber,
                            SlotDate              = invoiceDetails.slotDate ?? DateTime.Now,
                            SlotFromTime          = invoiceDetails.slotFromTime ?? DateTime.Now.TimeOfDay,
                            SlotToTime            = invoiceDetails.slotToTime ?? DateTime.Now.TimeOfDay
                        };

                        string status = await SendOrderSuccessSMSNotification(customer, NotificationEvent.RescheduleDelivery.ToString());
                    }
                }

                else
                {
                    DatabaseResponse invoiceMqResponse = new DatabaseResponse();

                    invoiceMqResponse = await _messageQueueDataAccess.GetAccountInvoiceMessageQueueBody(InvoiceID);

                    InvoceQM invoiceDetails = new InvoceQM();

                    string topicName = string.Empty;

                    string pushResult = string.Empty;

                    if (invoiceMqResponse != null && invoiceMqResponse.Results != null)
                    {
                        invoiceDetails = (InvoceQM)invoiceMqResponse.Results;

                        // invoiceDetails.invoicelist= await GetInvoiceList(invoiceDetails.customerID);

                        invoiceDetails.paymentmode = invoiceDetails.CardFundMethod == EnumExtensions.GetDescription(PaymentMode.CC) ? PaymentMode.CC.ToString() : PaymentMode.DC.ToString();

                        MessageQueueRequest queueRequest = new MessageQueueRequest
                        {
                            Source           = CheckOutType.AccountInvoices.ToString(),
                            NumberOfRetries  = 1,
                            SNSTopic         = topicName,
                            CreatedOn        = DateTime.Now,
                            LastTriedOn      = DateTime.Now,
                            PublishedOn      = DateTime.Now,
                            MessageAttribute = EnumExtensions.GetDescription(RequestType.PayBill),
                            MessageBody      = JsonConvert.SerializeObject(invoiceDetails),
                            Status           = 0
                        };

                        try
                        {
                            Dictionary <string, string> attribute = new Dictionary <string, string>();

                            topicName = ConfigHelper.GetValueByKey(ConfigKey.SNS_Topic_ChangeRequest.GetDescription(), _iconfiguration).Results.ToString().Trim();

                            attribute.Add(EventTypeString.EventType, EnumExtensions.GetDescription(RequestType.PayBill));

                            pushResult = await _messageQueueDataAccess.PublishMessageToMessageQueue(topicName, invoiceDetails, attribute);

                            queueRequest.PublishedOn = DateTime.Now;

                            if (pushResult.Trim().ToUpper() == "OK")
                            {
                                queueRequest.Status = 1;

                                await _messageQueueDataAccess.InsertMessageInMessageQueueRequest(queueRequest);
                            }
                            else
                            {
                                queueRequest.Status = 0;

                                await _messageQueueDataAccess.InsertMessageInMessageQueueRequest(queueRequest);
                            }
                        }
                        catch (Exception ex)
                        {
                            LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));

                            queueRequest.Status = 0;

                            await _messageQueueDataAccess.InsertMessageInMessageQueueRequest(queueRequest);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogInfo.Error(new ExceptionHelper().GetLogString(ex, ErrorLevel.Critical));
            }
        }