public IActionResult UpdateOrCreateCustomer(string customerId, [FromBody] CustomerUpdateRequest customerUpdateRequest) { if (customerUpdateRequest == null) { return(BadRequest(new BadRequestResponse("invalid model"))); } if (customerUpdateRequest.Id != customerId) { return(BadRequest(new BadRequestResponse("different id in body and path"))); } if (String.IsNullOrEmpty(customerUpdateRequest.Id)) { return(BadRequest(new BadRequestResponse("empty id"))); } if (String.IsNullOrEmpty(customerUpdateRequest.FirstName)) { return(BadRequest(new BadRequestResponse("empty FirstName"))); } if (String.IsNullOrEmpty(customerUpdateRequest.LastName)) { return(BadRequest(new BadRequestResponse("empty LastName"))); } Customer customer = Mapper.Map <Customer>(customerUpdateRequest); //DataProvider.Instance.AddOrUpdateCustomer(customer); _dataManager.UpdateOrCreateCustomer(customer); return(Ok(Mapper.Map <CustomerResponse>(customer))); }
public async Task <ApiResult <bool> > Update(int id, CustomerUpdateRequest request) { try { if (await _context.Customers.AnyAsync(x => x.email == request.email && x.id != id)) { return(new ApiErrorResult <bool>("Emai đã tồn tại")); } var cusExist = await _context.Customers.FindAsync(request.Id); if (cusExist != null || cusExist.isDelete) { cusExist.email = request.email; cusExist.name = request.name; cusExist.phone = request.phone; cusExist.isActive = request.isActive; cusExist.birthday = request.birthday; cusExist.sex = request.sex; cusExist.update_at = DateTime.Now; await _context.SaveChangesAsync(); return(new ApiSuccessResult <bool>()); } else { return(new ApiErrorResult <bool>("Không tìm thấy khách hàng này")); } } catch { return(new ApiErrorResult <bool>("Cập nhật thất bại")); } }
private async Task <bool> UpdateEntity(Database.Customer entity, CustomerUpdateRequest request) { if (request.AreaId != 0) { entity.AreaId = request.AreaId; } if (request.Address != null) { entity.Address = request.Address; } if (request.CompanyName != null) { entity.CompanyName = request.CompanyName; } if (request.Email != null) { entity.Account.Email = request.Email; } if (request.PhoneNumber != null) { entity.Account.PhoneNumber = request.PhoneNumber; } if (request.Username != null) { entity.Account.Username = request.Username; } await _context.SaveChangesAsync(); return(true); }
public async Task <IActionResult> UpdateOrCreateCustomer(string customerId, [FromBody] CustomerUpdateRequest updateCustomerRequest) { if (updateCustomerRequest == null) { return(BadRequest(new BadRequestResponse("invalid model"))); } if (updateCustomerRequest.Id != customerId) { return(BadRequest(new BadRequestResponse("different id in body and path"))); } if (String.IsNullOrEmpty(updateCustomerRequest.Id)) { return(BadRequest(new BadRequestResponse("empty id"))); } if (String.IsNullOrEmpty(updateCustomerRequest.FirstName)) { return(BadRequest(new BadRequestResponse("empty FirstName"))); } if (String.IsNullOrEmpty(updateCustomerRequest.LastName)) { return(BadRequest(new BadRequestResponse("empty LastName"))); } var customer = Mapper.Map <Customer>(updateCustomerRequest); await _customersRepository.Replace(customer); return(Ok(Mapper.Map <CustomerResponse>(customer))); }
public async Task <Model.Models.Customer> Update(int?id, CustomerUpdateRequest request) { if (id == null) { throw new UserException("ID ne može biti prazno polje"); } var entity = await _context.Customer.Include(x => x.Account) .Include(x => x.Area).Where(x => x.Id == id).SingleOrDefaultAsync(); if (entity == null) { throw new UserException("Korisnik nije pronađen"); } if (!String.IsNullOrWhiteSpace(request.Password)) { if (request.Password == request.PasswordConfirm) { entity.Account.PasswordSalt = AccountService.GenerateSalt(); entity.Account.PasswordHash = AccountService .GenerateHash(entity.Account.PasswordSalt, request.Password); } else { throw new UserException("Lozinke moraju biti jednake"); } } await UpdateEntity(entity, request); return(_mapper.Map <Model.Models.Customer>(entity)); }
public async Task <IActionResult> Update(int id) { var result = await _customerApiClient.GetById(id); var latest_order = await _customerApiClient.GetLatestOrder(id, 20); if (!result.IsSuccess || result.ResultObject == null) { TempData["error"] = result.Message; return(RedirectToAction("Index")); } var updateRequest = new CustomerUpdateRequest() { Id = id, name = result.ResultObject.name, address = result.ResultObject.address, birthday = result.ResultObject.birthday, email = result.ResultObject.email, sex = result.ResultObject.sex, phone = result.ResultObject.phone, isActive = result.ResultObject.isActive }; if (TempData["result"] != null) { ViewBag.SuccessMsg = TempData["result"]; } ViewBag.LatestOrde = latest_order; return(View(updateRequest)); }
public ApiResponse <CustomerUpdateResponse> Update(CustomerUpdateRequest request) { return(this.Send <CustomerUpdateResponse>(new ApiRequest { Service = "customer.update", Data = request })); }
public async Task <IWrappedResponse> Update(CustomerUpdateRequest request) { var cmd = ServiceCommand <Customer, Rules.Customer.Update.MainRule> .Create(_serviceProvider) .When(new Rules.Customer.Update.MainRule(request)) .Then(UpdateAction); return(await cmd.Execute()); }
public async Task <IActionResult> Update([FromForm] CustomerUpdateRequest request) { var result = await _customerService.Update(request); if (result == 0) { return(BadRequest()); } return(Ok()); }
public HttpResponseMessage UpdateCustomer([FromBody] CustomerUpdateRequest customerRequest) { var customer = customerService.GetCustomerByKey(customerRequest.ID); customer.Name = customerRequest.Name; customer.Sex = customerRequest.Sex; customer.ParentID = customerRequest.ParentID; customerService.UpdateCustomer(customer); return(new HttpResponseMessage(HttpStatusCode.OK)); }
public async Task <IActionResult> Update([FromBody] CustomerUpdateRequest request) { var result = await _customerService.Update(request.Id, request); if (!result.IsSuccess) { return(BadRequest(result)); } return(Ok(result)); }
public CustomerItemResponse Update(CustomerUpdateRequest request) { var customerId = Uri.EscapeUriString(request.customer_id); var requestData = SerializeHelper.Serialize(request); var responseJson = _serviceHelper.CallPaydock("customers/" + customerId, HttpMethod.POST, requestData, overrideConfigSecretKey: _overrideConfigSecretKey); var response = SerializeHelper.Deserialize <CustomerItemResponse>(responseJson); response.JsonResponse = responseJson; return(response); }
public async Task <int> Update(CustomerUpdateRequest request) { var cus = await db.Ib_customers.FindAsync(request.Ib_record_primary_key); if (cus == null) { throw new LinxOneException($"Cannot find a customer :{request.Ib_record_primary_key}"); } cus.Ib_customer_name = request.Ib_customer_name; cus.Ib_customer_registration = request.Ib_customer_registration; cus.Ib_customer_type = request.Ib_customer_type; return(await db.SaveChangesAsync()); }
public async Task <CustomerResponse> UpdateCustomer([Required] CustomerUpdateRequest customerRequest) { var response = await GrpcCallerService.CallService(urlGrpc : GRPCUrl.IdentityService, logger : _logger, func : async channel => { var client = new Customer.CustomerClient(channel); _logger.LogDebug("Grpc get customer request {@request}", customerRequest); var customer = await client.UpdateCustomerAsync(customerRequest); await UpdateProductCustomer(customer, false); return(customer); }); return(response); }
public CustomerResponse Any(CustomerUpdateRequest request) { if (Validator != null) { Validator.ValidateAndThrow(request, ApplyTo.Put); } OnBeforeCustomerUpdateRequest(request); var output = Repository.Update(request); OnAfterCustomerUpdateRequest(request, output); return(output); }
public async Task <bool> Validate(CustomerUpdateRequest request) { var result = (_validator as SettingsValidator).Validate(request); if (!result.IsValid) { foreach (var error in result.Errors) { await Application.Current.MainPage.DisplayAlert("Greška", error.ErrorMessage, "OK"); } return(false); } return(true); }
public bool Update(CustomerUpdateRequest updateRequest) { using (DataAccess dataAccess = new DataAccess()) { var customerUpdated = dataAccess.Customers.Where(x => x.CustomerID == updateRequest.CustomerID) .FirstOrDefault <Customer>(); customerUpdated.Name = updateRequest.Name; customerUpdated.Surname = updateRequest.Surname; customerUpdated.Email = updateRequest.Email; customerUpdated.Password = updateRequest.Password; customerUpdated.CityID = GetCityID(new CityIDRequest(updateRequest.CityName)); customerUpdated.Photo = updateRequest.Photo; dataAccess.Update(customerUpdated); return(dataAccess.SaveChanges() > 0); } }
public async Task <IActionResult> Update(CustomerUpdateRequest request) { if (!ModelState.IsValid) { return(View(request)); } var result = await _customerApiClient.UpdateCustomer(request); if (result.IsSuccess) { TempData["result"] = "Cập nhật khách hàng thành công"; return(RedirectToAction("Index")); } ModelState.AddModelError("", result.Message); return(View(request)); }
public async Task <int> UpdateCustomer(CustomerUpdateRequest request) { var customer = await _context.Customers.FindAsync(request.Id); if (customer == null) { throw new CafeException($"Cannot find a customer: {request.Id}"); } customer.Id = request.Id; customer.Name = request.Name; customer.PhoneNumber = request.PhoneNumber; customer.Adress = request.Adress; customer.Sex = request.Sex; customer.DOB = request.DOB; return(await _context.SaveChangesAsync()); }
public async Task <IActionResult> UpdateCustomer(CustomerUpdateRequest customerRequest) { try { if (ModelState.IsValid) { await _customerService.UpdateCustomerAsync(customerRequest); return(RedirectToAction("Index", "Customer")); } return(View(customerRequest)); } catch (Exception e) { return(BadRequest(e.Message)); } }
public async Task UpdateCustomerAsync(CustomerUpdateRequest customerRequest) { _nullCheckMethod.CheckIfRequestIsNull(customerRequest); var customer = await _unitOfWork.Customers.GetCustomerByIdAsync(customerRequest.CustomerId); _nullCheckMethod.CheckIfResponseIsNull(customer); //TODO: Add CustomerAddresId in Request var customerAddresId = customer.Addres.CustomerAddresId; customer = Mapper.Map <CustomerUpdateRequest, Customer>(customerRequest); customer.Addres.CustomerAddresId = customerAddresId; _unitOfWork.Customers.UpdateCustomer(customer); await _unitOfWork.CompleteAsync(); }
public ActionResult <CustomerResponse> UpdateCustomer(int id, CustomerUpdateRequest request) { var cityToUpdate = _customerRepository.FindCustomerResponseById(id); if (cityToUpdate == null) { return(NotFound()); } if (!ModelState.IsValid) { return(BadRequest()); } var result = _customerRepository.UpdateCustomer(id, request); return(Ok(result)); }
public async Task UpdateCustomer(string overideSecretKey) { var customer = await CreateBasicCustomer(overideSecretKey : overideSecretKey); CustomerItemResponse getCustomer; if (overideSecretKey != null) { getCustomer = await new Customers(overideSecretKey).Get(customer.resource.data._id); } else { getCustomer = await new Customers().Get(customer.resource.data._id); } var request = new CustomerUpdateRequest { customer_id = getCustomer.resource.data._id, first_name = "john1", last_name = "smith1", payment_source = new PaymentSource { gateway_id = TestConfig.GatewayId, card_name = "John Smith", card_number = "4111111111111111", card_ccv = "123", expire_month = "10", expire_year = "2020" } }; CustomerItemResponse result; if (overideSecretKey != null) { result = await new Customers(overideSecretKey).Update(request); } else { result = await new Customers().Update(request); } Assert.IsTrue(result.IsSuccess); }
public CustomerResponse Update(CustomerUpdateRequest request) { using (var adapter = DataAccessAdapterFactory.NewDataAccessAdapter()) { OnBeforeCustomerUpdateRequest(adapter, request); var entity = request.FromDto(); entity.IsNew = false; entity.IsDirty = true; if (adapter.SaveEntity(entity, true)) { OnAfterCustomerUpdateRequest(adapter, request); return(new CustomerResponse(entity.ToDto())); } } throw new InvalidOperationException(); }
public override Task <CustomerResponse> UpdateCustomer(CustomerUpdateRequest request, ServerCallContext context) { var user = _kernel.GetEntity <User>(externalId: ParseUserID(id: request.Id)); ValidateUserType(user); user.PersonalEmail = request.Email; user.City = request.City; user.ContactNumber = request.ContactNumber; user.ModifiedOn = DateTime.UtcNow; user.Line1 = request.Line1; user.Line2 = request.Line2; user.Name = request.Name; user.State = request.State; user.Zipcode = request.Zipcode; _kernel.UpdateEntity(entity: user, saveChanges: true); ValidateUserType(user); context.Status = new Status(StatusCode.OK, string.Empty); return(Task.FromResult(MapToResponse(user: user))); }
public async Task <ApiResult <bool> > UpdateCustomer(CustomerUpdateRequest request) { var client = _httpClientFactory.CreateClient(); client.BaseAddress = new Uri(_configuration["BaseAddress"]); var json = JsonConvert.SerializeObject(request); var httpContent = new StringContent(json, Encoding.UTF8, "application/json"); var respone = await client.PutAsync($"/api/Customer/{request.Id}", httpContent); var result = await respone.Content.ReadAsStringAsync(); if (respone.IsSuccessStatusCode) { return(JsonConvert.DeserializeObject <ApiSuccessResult <bool> >(result)); } else { return(JsonConvert.DeserializeObject <ApiErrorResult <bool> >(result)); } }
private async Task UpdateUser() { try { var request = new CustomerUpdateRequest() { Address = _address, AreaId = _selectedArea.Id, CompanyName = _companyName, Email = _email, Password = _password, PasswordConfirm = _passwordConfirm, PhoneNumber = _phoneNumber, Username = _username }; var isValid = await Validate(request); if (!isValid) { return; } var result = await _customerService.Update <Customer>(APIService.Client.Id, request); if (result != null) { await Application.Current.MainPage.DisplayAlert("Info", "Uspješno ste promijenili podatke", "OK"); APIService.Username = request.Username; APIService.Password = request.Password; APIService.Client = result; } } catch (Exception ex) { await Application.Current.MainPage.DisplayAlert("Greška", ex.Message, "OK"); } }
public async Task UpdateCustomerTest() { var requestTester = GetRequestTester(); var customerId = "1"; var cardRequest = _cardRequestBuilder.Build(); var customerUpdaterequest = new CustomerUpdateRequest() { CustomerId = customerId, Card = cardRequest, DefaultCardId = "2" }; await requestTester.TestMethod <Customer>( async (api) => { await api.UpdateCustomer(customerUpdaterequest); }, new RequestDescriptor() { Method = HttpMethod.Post, Action = string.Format("customers/{0}", customerId), Parameter = customerUpdaterequest } ); }
public async Task <IActionResult> UpdateCustomer([FromRoute] int id, [FromBody] CustomerUpdateRequest model) { var customer = await _customerRepository.GetCustomerByIdAsync(id); if (customer == null) { return(NotFound()); } customer.Name = model.Name; customer.Email = model.Email; customer.State = model.State; var updated = await _customerRepository.UpdateCustomerAsync(customer); if (!updated) { return(NotFound()); } var customerResponse = _mapper.Map <CustomerResponse>(customer); return(Ok(customerResponse)); // Can return nocontent() here }
public CustomerUpdateResponse Update(string customerIdOrCode, CustomerUpdateRequest request) => _api.Put <CustomerUpdateResponse, CustomerUpdateRequest>($"customer/{customerIdOrCode}", request);