public IActionResult Create([FromForm] LegalPersonViewModel model)
{
try
{
if (ModelState.IsValid)
{
_personService.Add(model);
return(RedirectToAction(nameof(Index)));
}
}
catch (BusinessRuleException ex)
{
ModelState.AddModelError(ex.Key, ex.Message);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
ModelState.AddModelError(string.Empty, _sharedLocalizer["GenericErrorMessage"]);
}
ViewBag.CountryList = _addressService.GetContriesName();
return(View(model));
}
public async Task <ActionResult> Edit(int id, [FromForm] LegalPersonViewModel model)
{
if (id != model.Id)
{
return(NotFound());
}
try
{
if (ModelState.IsValid)
{
await _personService.UpdateAsync(model);
return(RedirectToAction(nameof(Index)));
}
}
catch (BusinessRuleException ex)
{
ModelState.AddModelError(ex.Key, ex.Message);
}
catch (Exception ex)
{
_logger.LogError(ex.Message);
ModelState.AddModelError(string.Empty, _sharedLocalizer["GenericErrorMessage"]);
}
ViewBag.CountryList = _addressService.GetContriesName();
return(View(model));
}
public IActionResult CreateLegalPerson(ClientCreateViewModel clientCreateViewModel)
{
var client = HttpContext.Session.Get <Client>("NewClientData");
var legalPersonCreateViewModel = new LegalPersonViewModel()
{
Client = client
};
return(View(legalPersonCreateViewModel));
}
public void Add(LegalPersonViewModel model)
{
if (!_personRepository.IsIdDocumentUnique(model.IdDocument))
{
throw new BusinessRuleException("IdDocument", "ID Document already informed.");
}
var person = new LegalPerson(model.CompanyName, model.TradeName, model.IdDocument)
{
Address = new Address(
model.Country, model.State, model.City, model.ZipCode, model.AddressLine1, model.AddressLine2)
};
_personRepository.Add(person);
_personRepository.SaveChanges();
}
public async Task <IActionResult> EditLegalPerson(LegalPersonViewModel legalPersonViewModel)
{
if (ModelState.IsValid)
{
try
{
var client = legalPersonViewModel.Client;
var legalPerson = new LegalPerson
{
IdEdrpou = legalPersonViewModel.Client.IdClient,
Director = legalPersonViewModel.LegalPerson.Director,
Name = legalPersonViewModel.LegalPerson.Name,
OwnershipType = legalPersonViewModel.LegalPerson.OwnershipType
};
await _clientRepository.UpdateAsync(entity : client);
await _legalPersonRepository.UpdateAsync(legalPerson);
var userId = HttpContext.Session.Get <string>(key: "IdIdentity");
var user = await _userManager.FindByIdAsync(userId : userId);
user.UserName = legalPersonViewModel.Client.Login;
user.Email = legalPersonViewModel.Client.Login;
user.PhoneNumber = legalPersonViewModel.Client.TelNumber;
await _userManager.UpdateAsync(user : user);
}
catch (DbUpdateConcurrencyException)
{
if (!ClientExists(id: legalPersonViewModel.Client.IdClient))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(actionName: nameof(Index)));
}
return(View(model: legalPersonViewModel));
}
public async Task <IActionResult> CreateLegalPerson(LegalPersonViewModel legalPersonViewModel)
{
if (ModelState.IsValid)
{
var client = legalPersonViewModel.Client;
client.LegalPerson = legalPersonViewModel.LegalPerson;
//Add new User to Identity
var user = new IdentityUser()
{
UserName = legalPersonViewModel.Client.Login,
Email = legalPersonViewModel.Client.Login,
PhoneNumber = legalPersonViewModel.Client.TelNumber
};
var password = HttpContext.Session.Get <string>(key: "PassClient");
var result = await _userManager.CreateAsync(user : user, password : password);
if (result.Succeeded)
{
//Set Roles CLIENT to new User
await _userManager.AddToRoleAsync(user : user, role : AuthorizationConstants.Roles.CLIENT);
//Add to tables Client and LegalPerson
await _clientRepository.AddAsync(entity : client);
if (HttpContext.User.IsInRole(AuthorizationConstants.Roles.ADMINISTRATOR))
{
return(RedirectToAction(actionName: nameof(Index)));
}
return(RedirectToAction("UserRegistered", "Account"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(key: string.Empty, errorMessage: error.Description);
}
}
return(View(model: legalPersonViewModel));
}
private void Open_OnClick(object sender, RoutedEventArgs e)
{
try
{
if (Contractor == null)
{
Contractor = new Contractor()
{
City = new City(),
Region = new Region()
}
}
;
if (Contractor.LegalPerson == null)
{
var viewModel = new ContractorInfoViewModel(Contractor, this);
var view = new ContractorInfoView(viewModel);
view.ShowDialog();
OnPropertyChanged("ContractorSignature");
}
else
{
var viewModel = new LegalPersonViewModel(Contractor, this);
var view = new LegalPersonInfoView(viewModel);
view.ShowDialog();
OnPropertyChanged("ContractorSignature");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
public async Task <IActionResult> CreateLegalPerson(LegalPersonViewModel legalPersonViewModel)
{
if (ModelState.IsValid)
{
var client = legalPersonViewModel.Client;
client.LegalPerson = legalPersonViewModel.LegalPerson;
//Add to tables Client and LegalPerson
await Repository.AddAsync(client);
//Add new User to Identity
ApplicationUser user = new ApplicationUser()
{
UserName = legalPersonViewModel.Client.Login,
Email = legalPersonViewModel.Client.Login,
PhoneNumber = legalPersonViewModel.Client.TelNumber
};
var password = HttpContext.Session.Get <string>("PassClient");
var result = await _userManager.CreateAsync(user, password);
if (result.Succeeded)
{
//Set Roles CLIENT to new User
await _userManager.AddToRoleAsync(user, AuthorizationConstants.Roles.CLIENT);
return(RedirectToAction(nameof(Index)));
}
else
{
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
}
return(View(legalPersonViewModel));
}
public async Task UpdateAsync(LegalPersonViewModel model)
{
var person = await _personRepository.GetAsync(model.Id);
if (person == null)
{
return;
}
person.CompanyName = model.CompanyName;
person.TradeName = model.TradeName;
person.SetIdDocument(model.IdDocument);
// Address is optional, if country not informed delete address entity
if (!string.IsNullOrWhiteSpace(model.Country))
{
if (person.Address == null)
{
person.Address = new Address(
model.Country, model.State, model.City, model.ZipCode, model.AddressLine1, model.AddressLine2);
}
else
{
person.Address.ChangeAddress(
model.Country, model.State, model.City, model.ZipCode, model.AddressLine1, model.AddressLine2);
}
}
else
{
person.Address = null;
}
_personRepository.Update(person);
_personRepository.SaveChanges();
}
public async Task <IActionResult> EditLegalPerson(LegalPersonViewModel legalPersonViewModel)
{
if (ModelState.IsValid)
{
try
{
var client = legalPersonViewModel.Client;
client.LegalPerson = legalPersonViewModel.LegalPerson;
await Repository.UpdateAsync(client);
var userId = HttpContext.Session.Get <string>("IdIdentity");
var user = await _userManager.FindByIdAsync(userId);
user.UserName = legalPersonViewModel.Client.Login;
user.Email = legalPersonViewModel.Client.Login;
user.PhoneNumber = legalPersonViewModel.Client.TelNumber;
await _userManager.UpdateAsync(user);
}
catch (DbUpdateConcurrencyException)
{
if (!ClientExists(id: legalPersonViewModel.Client.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(actionName: nameof(Index)));
}
return(View(legalPersonViewModel));
}
private async Task SignUpAsync()
{
var success = false;
try
{
switch (PersonType)
{
case PersonType.NaturalPerson:
// set naturalPerson values
NaturalPersonViewModel.NaturalPerson.PrimaryEmail =
CredentialViewModel.UserCredential.PrimaryEmail;
NaturalPersonViewModel.Password = CredentialViewModel.UserCredential.Password;
// first validate naturalPersonViewModel and credentialViewModel
//
this.IsPersonValid = NaturalPersonViewModel.ValidateForm();
this.IsCredentialValid = CredentialViewModel.ValidateForm();
// if validation is true signup person
if (this.IsPersonValid && this.IsCredentialValid)
{
await NaturalPersonViewModel.ProcessFormAsync();
success = true;
}
break;
case PersonType.LegalPerson:
// set legalPerson values
LegalPersonViewModel.LegalPerson.PrimaryEmail = CredentialViewModel.UserCredential.PrimaryEmail;
LegalPersonViewModel.Password = CredentialViewModel.UserCredential.Password;
// first validate naturalPersonViewModel and credentialViewModel
//
this.IsPersonValid = LegalPersonViewModel.ValidateForm();
this.IsCredentialValid = CredentialViewModel.ValidateForm();
// if validation is true signup person
if (this.IsPersonValid && this.IsCredentialValid)
{
await LegalPersonViewModel.ProcessFormAsync();
success = true;
}
break;
case PersonType.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
//if success clear sencetive information from memory and navigate to confirm registration page
if (success)
{
NaturalPersonViewModel.Password = LegalPersonViewModel.Password = null;
_navigationService.Navigate(ViewNames.ConfirmRegistration, null);
}
}
catch (Exception)
{
await
_alertMessageService.ShowAsync(_resourceLoader.GetString("ErrorServiceUnreachable"), null,
DialogCommands.CloseDialogCommand);
}
}
public LegalPersonInfoView(LegalPersonViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
}
