public IActionResult UpdateCustomer([FromRoute] string Id)
{
try
{
var customerToUpdate = customerService.GetCustomerById(Id);
var editCustomerViewModel = new UpdateCustomerViewModel()
{
Id = Id,
Name = customerToUpdate.Name,
PhoneNo = customerToUpdate.ContactDetails.PhoneNo,
Email = customerToUpdate.ContactDetails.Email
};
return(PartialView("_UpdateCustomerPartial", editCustomerViewModel));
} catch (CustomerNotFoundException notFound)
{
logger.LogError("Failed to find the customer entity {@Exception}", notFound.Message);
logger.LogDebug("Failed to find the customer entity {@ExceptionMessage}", notFound);
return(BadRequest("Failed to find customer"));
}
catch (Exception e)
{
logger.LogError("Failed to update customer entity at Get {@Exception}", e.Message);
logger.LogDebug("Failed to update customer entity at Get {@ExceptionMessage}", e);
return(BadRequest("Failed to update customer entity"));
}
}
public IActionResult UpdateCustomer([FromForm] UpdateCustomerViewModel updatedData)
{
if (!ModelState.IsValid || updatedData == null ||
updatedData.Email == null ||
updatedData.Name == null ||
updatedData.PhoneNo == null)
{
return(PartialView("_UpdateCustomerPartial", new NewCustomerViewModel()));
}
try
{
var customerToUpdate = customerService.GetCustomerById(updatedData.Id);
customerService.UpdateCustomer(customerToUpdate.Id,
updatedData.Name,
updatedData.PhoneNo,
updatedData.Email);
return(PartialView("_UpdateCustomerPartial", updatedData));
}
catch (Exception e)
{
logger.LogError("Failed to edit customer entity {@Exception}", e.Message);
logger.LogDebug("Failed to edit customer entity {@ExceptionMessage}", e);
return(BadRequest("Failed to edit customer entity"));
}
}
private ApiResponse Update(int id, UpdateCustomerViewModel model)
{
var apiResp = new ApiResponse
{
Type = ResponseType.Fail
};
var customer = new Dto.Customer
{
Id = id,
AuthorizedPersonName = model.AuthorizedPersonName,
PhoneNumber = model.PhoneNumber,
Title = model.Title,
UserId = GetUserId().Value
};
_customerBusiness.OwnerId = customer.UserId;
var resp = _customerBusiness.Edit(customer);
if (resp.Type != ResponseType.Success)
{
apiResp.ErrorCode = resp.ErrorCode;
return(apiResp);
}
apiResp.Type = ResponseType.Success;
return(apiResp);
}
public async Task <UpdateCustomerViewModel> Update(UpdateCustomerViewModel updateCustomerViewModel)
{
var customer = new Customer
{
EmploymentType = updateCustomerViewModel.EmploymentType,
FirstName = updateCustomerViewModel.FirstName,
LastName = updateCustomerViewModel.LastName,
EmploymentTypeNotes = updateCustomerViewModel.EmploymentType == EmploymentType.Other ? updateCustomerViewModel.EmploymentTypeNotes : null,
PhoneNumber = updateCustomerViewModel.PhoneNumber,
Ssn = updateCustomerViewModel.Ssn,
Id = updateCustomerViewModel.Id
};
try
{
_context.Update(customer);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (await Fetch(customer.Id) == null)
{
return(null);
}
else
{
throw;
}
}
return(updateCustomerViewModel);
}
public async Task <IActionResult> UpdateContactInfo(UpdateCustomerViewModel model)
{
if (ModelState.IsValid)
{
var cust = _context.Kunds.SingleOrDefault(x => x.KundId == model.Kund.KundId);
cust.Namn = model.Kund.Namn;
cust.Gatuadress = model.Kund.Gatuadress;
cust.Postnr = model.Kund.Postnr;
cust.Postort = model.Kund.Postort;
cust.Telefon = model.Kund.Telefon;
_context.SaveChanges();
var user = await _userManager.GetUserAsync(User);
var result = await _userManager.SetEmailAsync(user, model.Kund.Email);
if (result.Succeeded)
{
return(RedirectToAction("Index", "Home"));
}
foreach (var identError in result.Errors)
{
ModelState.AddModelError("", identError.Description);
}
}
return(View());
}
public void Update(UpdateCustomerViewModel model)
{
Customer customer = uow.RepostiryCustomer.Find(c => c.CustomerId == model.CustomerId);
if (customer is null)
{
throw new CustomerNullException("Customer doesn't exist! ");
}
if (model.Type == CustomerType.NaturalPerson)
{
NaturalPerson np = customer as NaturalPerson;
np.FirstName = model.FirstName;
np.LastName = model.LastName;
np.PhoneNumber = model.PhoneNumber;
np.Address.CityName = model.CityName;
np.Address.StreetName = model.StreetName;
np.Address.PTT = model.PTT;
np.Address.StreetNumber = model.StreetNumber;
}
else
{
LegalEntity lg = customer as LegalEntity;
lg.CompanyName = model.CompanyName;
lg.TIN = model.TIN;
lg.PhoneNumber = model.PhoneNumber;
lg.Address.CityName = model.CityName;
lg.Address.StreetName = model.StreetName;
lg.Address.PTT = model.PTT;
lg.Address.StreetNumber = model.StreetNumber;
}
uow.Commit();
}
public void UpdateCustomer(UpdateCustomerViewModel model)
{
var addedInfo = UpdateModel(model.Country);
model.Telephonecountrycode = addedInfo[0];
model.CountryCode = addedInfo[1];
_customerRepository.UpdateCustomer(model);
}
public async Task <IActionResult> UpdateContactInfo()
{
var model = new UpdateCustomerViewModel();
model.User = await _userManager.GetUserAsync(User);
model.Kund = _context.Kunds.SingleOrDefault(x => x.KundId == model.User.KundId);
return(View(model));
}
public IActionResult UpdateCustomer(UpdateCustomerViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_service.UpdateCustomer(model);
return(RedirectToAction("Index", new { searchWord = "" }));
}
public string UpdateCustomer(UpdateCustomerViewModel data)
{
string result = string.Empty;
if (!this._CustomersRepository.Update(data))
{
result = "新增失敗";
}
return(result);
}
private void BtnSaveCustomer_Click(object sender, RoutedEventArgs e)
{
customer.Name = txbCustomer.Text;
customer.Address = txbAddress.Text;
customer.City = txbCity.Text;
customer.Postcode = txbPostcode.Text;
customer.Phone = txbPhone.Text;
customer.Email = txbEmail.Text;
UpdateCustomerViewModel.UpdateCustomerInfo(customer);
MessageBox.Show(customer.Name + " tiedot päivitetty");
this.Close();
}
public ActionResult Update(UpdateCustomerViewModel data)
{
var isUpdate = this._CustomerLogic.UpdateCustomer(data);
if (string.IsNullOrWhiteSpace(isUpdate))
{
return(RedirectToAction("Index", "Customer"));
}
TempData["message"] = isUpdate;
return(View());
}
public void Update(UpdateCustomerViewModel customer)
{
var objCustomer = _customerRepository.Get(customer.IdCustomer);
if (objCustomer == null)
{
AddError("Customer not found");
return;
}
objCustomer.Update(customer.Name, objCustomer.DocumentNumber);
Commit();
}
public ActionResult UpdateCustomer(int id)
{
var data = new UpdateCustomerViewModel
{
Customers = _customerDal.GetList(),
Customer = _customerDal.Get(x => x.CustomerID == id)
};
ViewBag.CustomerDetails = _customerDetailDal.GetList();
return(View(data));
}
public async Task <IActionResult> UpdateCustomerConfirmed(UpdateCustomerViewModel vm)
{
if (ModelState.IsValid)
{
var result = await _services.UpdateCustomerAsync(_mapper.Map <CustomerDTO>(vm));
if (result.IsValid)
{
await _systemAuditService.AuditAsync(User.GetEmail(), _accessor.GetIp(), Operations.Update, Tables.DimCustomer);
return(RedirectToAction("Details", new { id = vm.CustomerKey }));
}
TempData["ErrorsList"] = result.ErrorsList;
}
return(View(vm));
}
public IActionResult Put([FromRoute] IdViewModel idModel, [FromBody] UpdateCustomerViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(GetModelStateErrorResponse(ModelState)));
}
var resp = Update(idModel.Id, model);
if (resp.Type != ResponseType.Success)
{
return(BadRequest(resp));
}
return(Ok(resp));
}
public UpdateCustomerViewModel GetCustomer(int Id)
{
UpdateCustomerViewModel reCustomerData = new UpdateCustomerViewModel();
CustomerModel CustomerData = this._CustomersRepository.GetOneById(Id);
if (CustomerData != null)
{
reCustomerData.id = CustomerData.id;
reCustomerData.firstname = CustomerData.firstname;
reCustomerData.lastname = CustomerData.lastname;
reCustomerData.age = CustomerData.age;
reCustomerData.email = CustomerData.email;
reCustomerData.birthday = CustomerData.birthday.ToString("yyyy/MM/dd");
}
return(reCustomerData);
}
public HttpResponseMessage Put(UpdateCustomerViewModel updateCustomerViewModel)
{
UpdateCustomerRequest req =
new UpdateCustomerRequest(updateCustomerViewModel.Id)
{
CustomerProperties = new CustomerPropertiesViewModel()
{
AddressLine1 = updateCustomerViewModel.AddressLine1
,AddressLine2 = updateCustomerViewModel.AddressLine2
,City = updateCustomerViewModel.City
,Name = updateCustomerViewModel.Name
,PostalCode = updateCustomerViewModel.PostalCode
}
};
UpdateCustomerResponse updateCustomerResponse = _customerService.UpdateCustomer(req);
return Request.BuildResponse(updateCustomerResponse);
}
public async Task <IActionResult> Edit(int id, UpdateCustomerViewModel updateCustomerViewModel)
{
var customer = new Customer();
if (ModelState.IsValid)
{
if (id != updateCustomerViewModel.Id)
{
return(NotFound());
}
else
{
await _customerService.Update(updateCustomerViewModel);
}
return(RedirectToAction(nameof(Index)));
}
return(View(updateCustomerViewModel));
}
public UpdateCustomerViewModel Get(int?customerId)
{
Customer customer = uow.RepostiryCustomer.Find(c => c.CustomerId == customerId);
UpdateCustomerViewModel model;
if (customer is NaturalPerson)
{
NaturalPerson np = customer as NaturalPerson;
model = new UpdateCustomerViewModel()
{
FirstName = np.FirstName,
LastName = np.LastName,
PhoneNumber = np.PhoneNumber,
CityName = np.Address.CityName,
PTT = np.Address.PTT,
StreetName = np.Address.StreetName,
StreetNumber = np.Address.StreetNumber,
Type = CustomerType.NaturalPerson,
CustomerId = np.CustomerId
};
}
else
{
LegalEntity np = customer as LegalEntity;
model = new UpdateCustomerViewModel()
{
CompanyName = np.CompanyName,
TIN = np.TIN,
PhoneNumber = np.PhoneNumber,
CityName = np.Address.CityName,
PTT = np.Address.PTT,
StreetName = np.Address.StreetName,
StreetNumber = np.Address.StreetNumber,
Type = CustomerType.LegalEntity,
CustomerId = np.CustomerId
};
}
return(model);
}
// GET: Customers/Edit/5
public async Task <IActionResult> Edit(int?id)
{
var updateCustomerViewModel = new UpdateCustomerViewModel();
var customer = await _customerService.Fetch(id);
if (customer == null)
{
return(NotFound());
}
else
{
updateCustomerViewModel.Id = customer.Id;
updateCustomerViewModel.EmploymentType = customer.EmploymentType;
updateCustomerViewModel.EmploymentTypeNotes = customer.EmploymentTypeNotes;
updateCustomerViewModel.FirstName = customer.FirstName;
updateCustomerViewModel.LastName = customer.LastName;
updateCustomerViewModel.PhoneNumber = customer.PhoneNumber;
updateCustomerViewModel.Ssn = customer.Ssn;
}
return(View(updateCustomerViewModel));
}
public IActionResult UpdateCustomer([FromBody] UpdateCustomerViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Errors = ModelState }));
}
_customerService.Update(model);
if (Errors.Any())
{
return(BadRequest(new { Errors }));
}
return(Ok());
}
catch (Exception ex)
{
return(StatusCode(500, new { Errors = ex.Message }));
}
}
public IActionResult UpdateCustomer([FromBody] UpdateCustomerViewModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(new { IsSuccessStatusCode = false, Errors = ModelState }));
}
_customerService.Update(model);
if (Errors.Any())
{
return(BadRequest(new { IsSuccessStatusCode = false, Errors }));
}
return(Ok(new { IsSuccessStatusCode = true }));
}
catch (Exception ex)
{
return(NotFound(new { IsSuccessStatusCode = false, Errors = ex.Message }));
}
}
public bool Update(UpdateCustomerViewModel data)
{
bool result = true;
string sql = string.Empty;
sql = @"UPDATE Customers
SET
firstname = @firstname,
lastname = @lastname,
age = @age,
birthday = @birthday,
email = @email,
updatedate = GETDATE()
WHERE id = @id ";
DynamicParameters param = new DynamicParameters();
param.Add("firstname", data.firstname);
param.Add("lastname", data.lastname);
param.Add("age", data.age);
param.Add("birthday", data.birthday);
param.Add("email", data.email);
param.Add("id", data.id);
try
{
using (SqlConnection conn = new SqlConnection(connectionString.DemoDB))
{
conn.Execute(sql, param);
}
}
catch (Exception ex)
{
result = false;
}
return(result);
}
/// <summary>
/// Updates the specified model.
/// </summary>
/// <param name="model">The model.</param>
public void Update(UpdateCustomerViewModel model)
{
var updateCustomerCommand = _mapper.Map <UpdateCustomerCommand>(model);
_commandDispatcher.Send(updateCustomerCommand);
}
public ActionResult Update(UpdateCustomerViewModel model)
{
service.Update(model);
return(RedirectToAction("Index", "Book"));
}
public async Task <IActionResult> Update([FromBody] UpdateCustomerViewModel model)
{
string strRuta = _config["CustomerAvatar"];
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (model.Id <= 0)
{
return(BadRequest());
}
var modelo = await _context.Customers.FirstOrDefaultAsync(x => x.Id == model.Id);
if (modelo == null)
{
return(BadRequest("Cliente inexistente"));
}
modelo.Address = model.Address;
modelo.CountryId = model.CountryId;
modelo.StateId = model.StateId;
modelo.CityId = model.CityId;
modelo.Documento = model.Documento;
modelo.DocumentTypeId = model.DocumentTypeId;
modelo.Email = model.Email;
modelo.Favorite = model.Favorite;
modelo.Observation = model.Observation;
modelo.Phone = model.Phone;
modelo.Names = model.Names;
modelo.PriceListId = model.PriceListId;
////Guardo el avatar
if (!(string.IsNullOrEmpty(model.LogoName)) && (!string.IsNullOrEmpty(model.Logo)))
{
strRuta = strRuta + "//" + modelo.Id.ToString() + "//" + model.LogoName;
System.IO.FileInfo file = new System.IO.FileInfo(strRuta);
file.Directory.Create();
System.IO.File.WriteAllBytes(strRuta, Convert.FromBase64String(model.Logo.Substring(model.Logo.LastIndexOf(',') + 1)));
modelo.Logo = strRuta;
}
_context.Entry(modelo).State = EntityState.Modified;
if (modelo == null)
{
return(NotFound());
}
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException ex)
{
//Guardar Exception
return(BadRequest(ex.Message));
}
return(Ok());
}
public IActionResult Edit(UpdateCustomerViewModel viewModel)
{
return(View());
}
public Task <ObjectResult> Update(UpdateCustomerViewModel updateCustomerViewModel)
{
_customerApplication.Update(updateCustomerViewModel);
return(CreateResponse(null));
}
