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);