private async Task <DialogTurnResult> ProcessStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { //Need to call service inside if condition TODO... if ((bool)stepContext.Result) { ServiceResponceModel lstServiceResult = new ServiceResponceModel(); List <ServiceModel> lstService = new List <ServiceModel>(); // lstServiceResult.LstServiceResp = new List<ServiceModel>(); ServiceModel s = new ServiceModel(); // lstServiceResult.LstServiceResp.Add(s); // lstServiceResult.LstServiceResp.Add(resultData); var customerDetails = (CustomerDetailsModel)stepContext.Options; var response = await CollectionServiceBL.GetServiceResponse(customerDetails.DebtorNumber, customerDetails.DebtorName); var resultData = JsonConvert.DeserializeObject <ServiceModel>(response.ToString()); var messageText = $"Customer Account balance is in Inprocess"; var promptMessage = MessageFactory.Text(messageText, InputHints.ExpectingInput); return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken)); } CustomerDetailsModel c = new CustomerDetailsModel(); c.DebtorNumber = null; //return await stepContext.ReplaceDialogAsync(InitialDialogId, c, cancellationToken); return(await stepContext.NextAsync(null, cancellationToken)); }
public static void AddOrUpdateCustomerDetails(CustomerDetailsModel customerDetails) { try { var addCustomerDetails = @"if exists(SELECT * from [CustomerDetails] where [CustomerId]= @CustomerId) BEGIN update [CustomerDetails] set [SkinType]=@SkinType, [HairType] = @HairType,[IsSensitiveSkin] = @IsSensitiveSkin, [MedicalHistory] = @MedicalHistory, [Allergies] = @Allergies, [Problems] = @Problems, [CurrentProducts] = @CurrentProducts where [CustomerId]= @CustomerId End else BEGIN insert into [CustomerDetails] values(@CustomerId, @SkinType, @HairType, @IsSensitiveSkin, @MedicalHistory, @Allergies, @Problems, @CurrentProducts) end"; using (var connection = OpenConnection()) { var inputObj = new { @CustomerId = customerDetails.CustomerId, @SkinType = customerDetails.SkinType, @HairType = customerDetails.HairType, @IsSensitiveSkin = customerDetails.IsSensitiveSkin, @MedicalHistory = customerDetails.MedicalHistory, @Allergies = customerDetails.Allergies, @Problems = customerDetails.Problems, @CurrentProducts = customerDetails.CurrentProducts }; connection.Query(addCustomerDetails, inputObj); } } catch (Exception ex) { throw ex; } }
public ActionResult BouquetDetails(string type, string cardNumber) { ViewBag.BouquetDetails = "current"; if (string.IsNullOrEmpty(type)) { ShowMessage("Type of bouquet must be selected", AlertType.Danger); return(RedirectToAction("Index")); } if (!type.Equals("gotv") && !type.Equals("dstv")) { ShowMessage("Bouquet type can only be gotv or dstv", AlertType.Danger); return(RedirectToAction("Index")); } if (string.IsNullOrEmpty(cardNumber)) { ShowMessage("Smart card number is required.", AlertType.Danger); return(RedirectToAction("Index")); } var response = new CustomerDetailsModel(); try { var url = ApiConstantService.BASE_URL + type + "/details/" + cardNumber; response = _request.MakeRequest <CustomerDetailsModel>(url); return(View(response)); } catch (Exception exception) { ShowMessage(exception.Message, AlertType.Danger); return(View(response)); } }
// GET: DesignationMasterController/Edit/5 public async Task <ActionResult> Edit(int id) { var existingcustomer = await _coDealerMasterService.GetAllCoDealerByIdAsync(id); if (existingcustomer == null) { return(RedirectToAction("List")); } var viewModel = new CustomerDetailsModel { Id = existingcustomer.Id, CustomerName = existingcustomer.SubDealerName, EmailId = existingcustomer.EmailId, MobileNo1 = existingcustomer.ContactNo1, MobileNo2 = Convert.ToDecimal(existingcustomer.ContactNo2), Address1 = existingcustomer.Address, Pin = existingcustomer.Pincode, District = existingcustomer.City, StateId = (await _stateListService.GetStateList()).Where(x => x.State == existingcustomer.State).FirstOrDefault().Id, DealerCode = existingcustomer.DealerCode, ContinueEditing = IsContinueEditingAllowed() }; viewModel.AvailableStates = await BindStates(); return(View(viewModel)); }
public IActionResult Create(CustomerViewModel model) { try { var options = new CustomerCreateOptions { Description = model.FullName, Email = model.Email, Source = model.CreditCardToken, Metadata = new Dictionary <string, string> { { "Phone Number", model.Phone } } }; var service = new CustomerService(); var customer = service.Create(options); var res = new CustomerDetailsModel { Id = customer.Id, Details = JsonConvert.SerializeObject(customer, Formatting.Indented) }; return(View("CustomerStatus", res)); } catch (Exception ex) { ViewData["ErrorMessage"] = ex.Message; return(View("Create")); } }
public CustomerDetailsModel GetAgreements(int customerId) { Customer customer = customerRepository.GetNameByPersonalId(customerId); if (customer == null) { return(null); } var ab = new CustomerDetailsModel() { Name = customer.Name, Id = customer.PersonalId, Agreements = customer.Agreements.Select(t => new AgreementDTO { Id = t.Id, Amount = t.Amount, Margin = t.Margin, Duration = t.Duration, Code = t.BaseRateCode, PersonaId = t.CustomerId }).ToList() }; return(ab); }
public async Task <string> UpdateCustomerDetails(CustomerDetailsModel existedCustomerDetails) { var updateCustomerResult = this.userContext.CustomerDetailsDB. Where(op => op.Id == existedCustomerDetails.Id).FirstOrDefault(); if (updateCustomerResult != null) { updateCustomerResult.Name = existedCustomerDetails.Name; updateCustomerResult.Phonenumber = existedCustomerDetails.Phonenumber; updateCustomerResult.Pincode = existedCustomerDetails.Pincode; updateCustomerResult.Locality = existedCustomerDetails.Locality; updateCustomerResult.Address = existedCustomerDetails.Address; updateCustomerResult.City = existedCustomerDetails.City; updateCustomerResult.Landmark = existedCustomerDetails.Landmark; updateCustomerResult.Type = existedCustomerDetails.Type; this.userContext.CustomerDetailsDB.Update(updateCustomerResult); await Task.Run(() => userContext.SaveChanges()); return("Customer updation succesfull"); } else { return(null); } }
// GET: DesignationMasterController/Edit/5 public async Task <ActionResult> Edit(int id) { var existingcustomer = await _customerService.GetAllCustomerByIdAsync(id); if (existingcustomer == null) { return(RedirectToAction("List")); } var viewModel = new CustomerDetailsModel { Id = existingcustomer.Id, Salutation = existingcustomer.Salutation, CustomerName = existingcustomer.CustomerName, EmailId = existingcustomer.EmailId, MobileNo1 = existingcustomer.MobileNo1, MobileNo2 = Convert.ToDecimal(existingcustomer.MobileNo2), Address1 = existingcustomer.Address1, Address2 = existingcustomer.Address2, Pin = existingcustomer.Pin, Taluka = existingcustomer.Taluka, District = existingcustomer.District, StateId = (int)existingcustomer.State, PanNo = existingcustomer.PanNo, AdharNo = existingcustomer.AdharNo, Gstno = existingcustomer.Gstno, ContinueEditing = IsContinueEditingAllowed() }; viewModel.AvailableSalutations = BindSalutations(); viewModel.AvailableStates = await BindStates(); return(View(viewModel)); }
public async Task <IActionResult> GetCustomer(Guid customerId) { CustomerResult customer = await _customerQueries.GetCustomer(customerId); if (customer == null) { return(new NoContentResult()); } List <AccountDetailsModel> accounts = new List <AccountDetailsModel>(); foreach (var account in customer.Accounts) { List <TransactionModel> transactions = new List <TransactionModel>(); foreach (var item in account.Transactions) { var transaction = new TransactionModel( item.Amount, item.Description, item.TransactionDate); transactions.Add(transaction); } accounts.Add(new AccountDetailsModel( account.AccountId, account.CurrentBalance, transactions)); } CustomerDetailsModel model = new CustomerDetailsModel( customer.CustomerId, customer.PersonNummer, customer.Name, accounts); return(new ObjectResult(model)); }
public async Task <IActionResult> GetExistingCustomer(string searchTerm) { var existingcustomer = await _customerService.GetCustomerByAnyAsync(searchTerm); if (existingcustomer == null) { return(Json("Not Found")); } var model = new CustomerDetailsModel { CustId = existingcustomer.Id, Salutation = existingcustomer.Salutation, CustomerName = existingcustomer.CustomerName, EmailId = existingcustomer.EmailId, MobileNo1 = existingcustomer.MobileNo1, MobileNo2 = Convert.ToDecimal(existingcustomer.MobileNo2), Address1 = existingcustomer.Address1, Address2 = existingcustomer.Address2, Pin = existingcustomer.Pin, Taluka = existingcustomer.Taluka, District = existingcustomer.District, StateId = (int)existingcustomer.State, PanNo = existingcustomer.PanNo, AdharNo = existingcustomer.AdharNo, Gstno = existingcustomer.Gstno, }; model.AvailableSalutations = BindSalutations(); model.AvailableStates = await BindStates(); return(PartialView("~/Views/CustomerMaster/_CreateOrUpdate.cshtml", model)); }
public void Handle(Output output) { List <AccountDetailsModel> accounts = new List <AccountDetailsModel>(); foreach (var account in output.Accounts) { List <TransactionModel> transactions = new List <TransactionModel>(); foreach (var item in account.Transactions) { var transaction = new TransactionModel( item.Amount, item.Description, item.TransactionDate); transactions.Add(transaction); } accounts.Add(new AccountDetailsModel( account.AccountId, account.CurrentBalance, transactions)); } CustomerDetailsModel model = new CustomerDetailsModel( output.CustomerId, output.SSN, output.UserName, accounts ); ViewModel = new ObjectResult(model); }
public async Task <IActionResult> Create() { var model = new CustomerDetailsModel(); model.AvailableStates = await BindStates(); return(View(model)); }
public async Task <IActionResult> CustomerDetailsUpdate([FromBody] CustomerDetailsModel customerDetails) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } _repository.CustomerDetails_Update(customerDetails); await _repository.SaveChangesAsync(); return(CreatedAtAction("GetCustomerAddressDetails", new { id = customerDetails.Id }, customerDetails)); }
// POST: api/Customers public CustomerDetailsModel Post([FromBody] CustomerDetailsModel value) { var customer = new Customer() { Id = value.Id, FirstName = value.FirstName, SurName = value.SurName, Address = value.Address, PhoneNumber = value.PhoneNumber }; _dataManager.Customers.Add(customer); return(mapToCustomerDetailsModel(customer)); }
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { var user = new ApplicationUser { UserName = model.Email, Email = model.Email }; var customerDetails = new CustomerDetailsModel { AspUserId = user.Id, Email = model.Email, FirstName = model.FirstName, LastName = model.LastName, EmailUpdates = model.EmailUpdates }; var result = await _userManager.CreateAsync(user, model.Password); if (result.Succeeded) { var contextAccessor = new HttpContextAccessor(); var hostBaseUrl = contextAccessor.HttpContext.Request.Host; using (var httpClient = new HttpClient()) { var apiUrl = string.Format("https://" + hostBaseUrl + "/api/CustomerDetails"); var data = JsonConvert.SerializeObject(customerDetails); var content = new StringContent(data, Encoding.UTF8, "application/json"); await httpClient.PostAsync(apiUrl, content); } _logger.LogInformation("User created a new account with password."); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme); await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl); await _signInManager.SignInAsync(user, isPersistent : false); _logger.LogInformation("User created a new account with password."); return(RedirectToLocal(returnUrl)); } AddErrors(result); } // If we got this far, something failed, redisplay form return(View(model)); }
private List <SelectListItem> BindSalutations() { var model = new CustomerDetailsModel(); foreach (SalutationEnum e in Enum.GetValues(typeof(SalutationEnum))) { model.AvailableSalutations.Add(new SelectListItem { Value = e.ToString(), Text = e.ToString() }); } return(model.AvailableSalutations); }
// PUT: api/Customers/5 public CustomerViewModel Put([FromBody] CustomerDetailsModel value) { Customer customer = _dataManager.Customers.GetById(value.Id); customer.FirstName = value.FirstName; customer.SurName = value.SurName; customer.Address = value.Address; customer.PhoneNumber = value.PhoneNumber; _dataManager.Customers.Update(customer); return(new CustomerViewModel() { Id = customer.Id, FirstName = customer.FirstName, SurName = customer.SurName }); }
public async Task <IActionResult> Create(CustomerDetailsModel model, bool continueEditing) { try { var existingcustomer = (await _customerService.GetAllCustomerListAsync(model.EmailId, model.MobileNo1.ToString(), model.PanNo, model.AdharNo)).FirstOrDefault(); if (existingcustomer == null) { TempData["UserMessageError"] = "Records allready exist."; return(View()); } var customerInfo = new CustomerDetailsTable { Salutation = model.Salutation, CustomerName = model.CustomerName, EmailId = model.EmailId, MobileNo1 = model.MobileNo1, MobileNo2 = Convert.ToDecimal(model.MobileNo2), Address1 = model.Address1, Address2 = model.Address2, Pin = model.Pin, Taluka = model.Taluka, District = model.District, State = model.StateId, PanNo = model.PanNo, AdharNo = model.AdharNo, Gstno = model.Gstno, DateUpdated = DateTime.UtcNow, DateCreated = DateTime.UtcNow }; await _customerService.InsertAsync(customerInfo); if (continueEditing) { return(RedirectToAction(nameof(Edit), new { id = customerInfo.Id })); } TempData["UserMessageSuccess"] = "Record saved sucessfully."; return(RedirectToAction(nameof(List))); } catch (Exception ex) { TempData["UserMessageError"] = ex.Message.ToString(); return(RedirectToAction(nameof(Create))); } }
public void AddOrUpdateCustomerDetails() { var customer = Customer.GetAllCustomers().FirstOrDefault(); var customerDetails = new CustomerDetailsModel() { IsSensitiveSkin = false, HairType = "Dry", SkinType = "Oily", MedicalHistory = "Cosmetic Surgery", Problems = "Frizzy Hair", CurrentProducts = "Dove shampoo and conditioner", Allergies = "Synus", CustomerId = customer.Id }; Customer.AddOrUpdateCustomerDetails(customerDetails); }
public async Task <ActionResult> Edit(CustomerDetailsModel model, bool continueEditing) { try { var existingcustomer = await _customerService.GetAllCustomerByIdAsync(model.Id); if (existingcustomer == null) { return(RedirectToAction("List")); } existingcustomer.Salutation = model.Salutation; existingcustomer.CustomerName = model.CustomerName; existingcustomer.EmailId = model.EmailId; existingcustomer.MobileNo1 = model.MobileNo1; existingcustomer.MobileNo2 = Convert.ToDecimal(model.MobileNo2); existingcustomer.Address1 = model.Address1; existingcustomer.Address2 = model.Address2; existingcustomer.Pin = model.Pin; existingcustomer.Taluka = model.Taluka; existingcustomer.District = model.District; existingcustomer.State = model.StateId; existingcustomer.PanNo = model.PanNo; existingcustomer.AdharNo = model.AdharNo; existingcustomer.Gstno = model.Gstno; existingcustomer.DateUpdated = DateTime.UtcNow; await _customerService.UpdateAsync(existingcustomer); AllowContinueEditing(continueEditing); TempData["UserMessageSuccess"] = "Record saved sucessfully."; if (continueEditing) { return(RedirectToAction(nameof(Edit), new { id = existingcustomer.Id })); } return(RedirectToAction(nameof(List))); } catch (Exception ex) { TempData["UserMessageError"] = ex.Message.ToString(); return(RedirectToAction(nameof(Create))); } }
public async Task <string> NewCustomerDetails(CustomerDetailsModel customerDetails) { CustomerDetailsModel newCustomer = new CustomerDetailsModel() { Name = customerDetails.Name, Phonenumber = customerDetails.Phonenumber, Pincode = customerDetails.Pincode, Locality = customerDetails.Locality, Address = customerDetails.Address, City = customerDetails.City, Landmark = customerDetails.Landmark, Type = customerDetails.Type }; this.userContext.CustomerDetailsDB.Add(newCustomer); await Task.Run(() => userContext.SaveChanges()); return("New customer added"); }
public void Populate(CustomerOutput output) { Output = output; if (output == null) { ViewModel = new NoContentResult(); return; } List <AccountDetailsModel> accounts = new List <AccountDetailsModel>(); foreach (var account in output.Accounts) { List <TransactionModel> transactions = new List <TransactionModel>(); foreach (var item in account.Transactions) { var transaction = new TransactionModel( item.Amount, item.Description, item.TransactionDate); transactions.Add(transaction); } accounts.Add(new AccountDetailsModel( account.AccountId, account.CurrentBalance, transactions)); } CustomerDetailsModel model = new CustomerDetailsModel( output.CustomerId, output.Personnummer, output.Name, accounts ); ViewModel = new ObjectResult(model); }
public ActionResult Register(CustomerDetailsModel customerDetails) { CustomerInfo customer = new CustomerInfo(); LoginInfo login = new LoginInfo(); AccountDetail accountDetail = new AccountDetail(); //Adding details to CustomerInfo customer.UserID = customerDetails.UserID; customer.UserName = customerDetails.UserName; customer.Gender = customerDetails.Gender; customer.DOB = customerDetails.DOB; customer.AddressLine = customerDetails.AddressLine; customer.City = customerDetails.City; customer.StateDetails = customerDetails.State; customer.Country = customerDetails.Country; customer.Pincode = customerDetails.Pincode; customer.Email = customerDetails.Email; customer.PrimaryPhoneNumber = customerDetails.PrimaryPhoneNumber; customer.AccountNumber = customerDetails.AccountNumber; customer.Password = customerDetails.Password; customer.Status = "Active"; customer.BalanceAvailable = decimal.Parse(customerDetails.BalanceAvailable); //Adding details to LoginInfo login.UserID = customerDetails.UserID; login.UserName = customerDetails.UserName; login.UserType = "Customer"; login.Password = customerDetails.Password; //Adding details to AccountDetails accountDetail.UserID = customerDetails.UserID; accountDetail.AccountNumber = customerDetails.AccountNumber; accountDetail.UserName = customer.UserName; accountDetail.BalanceAvailable = customer.BalanceAvailable; accountDetail.Status = customer.Status; //Adding to Entities onlineBankingEntities.CustomerInfo.Add(customer); onlineBankingEntities.AccountDetails.Add(accountDetail); onlineBankingEntities.LoginInfo.Add(login); // onlineBankingEntities.SaveChanges(); //return View(); return(RedirectToAction("AdminHomePage", "Admin")); }
public async Task <IActionResult> Create(CustomerDetailsModel model, bool continueEditing) { try { var existingcustomer = (await _coDealerMasterService.GetAllCoDealerListAsync(model.EmailId, model.MobileNo1.ToString())).FirstOrDefault(); if (existingcustomer != null) { TempData["UserMessageError"] = "Records allready exist."; return(await Create()); } var coDealerInfo = new SubDealerMaster { SubDealerName = model.CustomerName, EmailId = model.EmailId, ContactNo1 = model.MobileNo1, ContactNo2 = model.MobileNo2, Address = model.Address1, Pincode = model.Pin, City = model.District, State = (await _stateListService.GetStateById(model.StateId)).State, DealerCode = model.DealerCode, DateCreated = DateTime.UtcNow }; await _coDealerMasterService.InsertAsync(coDealerInfo); if (continueEditing) { return(RedirectToAction(nameof(Edit), new { id = coDealerInfo.Id })); } TempData["UserMessageSuccess"] = "Record saved sucessfully."; return(RedirectToAction(nameof(List))); } catch (Exception ex) { TempData["UserMessageError"] = ex.Message.ToString(); return(RedirectToAction(nameof(Create))); } }
public void Populate(CustomerOutput output) { Output = output; if (output == null) { ViewModel = new NoContentResult(); return; } List <OrderDetailsModel> orders = Utils.GetOrderDetailsModel(output.Orders); CustomerDetailsModel model = new CustomerDetailsModel( output.CustomerId, output.Personnummer, output.Name, orders ); ViewModel = new ObjectResult(model); }
public ActionResult GetView(string customerID, string viewName) { //object model = null; CustomerDetailsModel customerModel = new CustomerDetailsModel(); OrderModel orderModel = new OrderModel(); if (viewName == "CustomerDetails") { customerModel.Customer = cusomterList.Where(x => x.CustomerId == Convert.ToInt32(customerID)).FirstOrDefault(); return(PartialView(viewName, customerModel)); } if (viewName == "OrderDetails") { orderModel.Order = orderList.Where(x => x.CustomerId == Convert.ToInt32(customerID)).OrderBy(o => o.OrderId).ToList(); return(PartialView(viewName, orderModel)); } return(PartialView(viewName)); }
private async Task <DialogTurnResult> ProcessStepAsync(WaterfallStepContext stepContext, CancellationToken cancellationToken) { CustomerDetailsModel c = new CustomerDetailsModel(); var customerDetails = (CustomerDetailsModel)stepContext.Options; var messageText = string.Empty; string balance = string.Empty; string no = string.Empty; string name = string.Empty; // c.DebtorName = null; //Need to call service inside if condition TODO... if ((bool)stepContext.Result) { List <CustomerModel> response = await CollectionServiceBL.GetServiceResponse(customerDetails.DebtorNumber, customerDetails.DebtorName); for (int i = 0; i < response.Count; i++) { balance = response[i].Balance; no = response[i].CustomerNumber; name = response[i].CustomerName; } messageText = "Customer Name :" + name + " Customer No :" + no + " Balance :" + balance; if (messageText == "" || messageText == null) { messageText = "We coundn't find any customer no " + customerDetails.DebtorNumber; } var promptMessage = MessageFactory.Text(messageText, InputHints.ExpectingInput); return(await stepContext.PromptAsync(nameof(TextPrompt), new PromptOptions { Prompt = promptMessage }, cancellationToken)); // return await stepContext.NextAsync(null, cancellationToken); } else { return(await stepContext.ReplaceDialogAsync(InitialDialogId, c, cancellationToken)); } //return await stepContext.ReplaceDialogAsync(InitialDialogId, c, cancellationToken); }
public async Task <ActionResult> Edit(CustomerDetailsModel model, bool continueEditing) { try { var existingcustomer = await _coDealerMasterService.GetAllCoDealerByIdAsync(model.Id); if (existingcustomer == null) { return(RedirectToAction("List")); } existingcustomer.SubDealerName = model.CustomerName; existingcustomer.EmailId = model.EmailId; existingcustomer.ContactNo1 = model.MobileNo1; existingcustomer.ContactNo2 = Convert.ToDecimal(model.MobileNo2); existingcustomer.Address = model.Address1; existingcustomer.Pincode = model.Pin; existingcustomer.City = model.District; existingcustomer.State = (await _stateListService.GetStateById(model.StateId)).State; existingcustomer.DealerCode = model.DealerCode; await _coDealerMasterService.UpdateAsync(existingcustomer); AllowContinueEditing(continueEditing); TempData["UserMessageSuccess"] = "Record saved sucessfully."; if (continueEditing) { return(RedirectToAction(nameof(Edit), new { id = existingcustomer.Id })); } return(RedirectToAction(nameof(List))); } catch (Exception ex) { TempData["UserMessageError"] = ex.Message.ToString(); return(RedirectToAction(nameof(Create))); } }
private async Task <List <SelectListItem> > BindStates() { var modelList = new CustomerDetailsModel(); modelList.AvailableStates.Add(new SelectListItem { Value = "0", Text = "Select State" }); var stateList = await _stateListService.GetStateList(); foreach (var state in stateList) { modelList.AvailableStates.Add(new SelectListItem { Value = state.Id.ToString(), Text = state.State }); } return(modelList.AvailableStates); }
//[Route] public async Task <IActionResult> Update(CustomerDetailsModel detailsModel) { try { var updateResult = await this.customerDetails.UpdateCustomerDetails(detailsModel); if (updateResult != null) { logger.LogInformation("log infrmation"); return(Ok(new { updateResult })); } else { var jsonObj = new JsonError(); jsonObj.ErrorCode = 405; jsonObj.ErrorMessage = "Update customers details failed"; return(BadRequest(jsonObj)); } } catch (Exception ex) { return(BadRequest(ex.Message)); } }