public async Task <ActionResult <PersonViewModel> > Post([FromBody] PersonInputModel model)
{
try
{
Person person = new Person()
{
PersonId = model.PersonId,
Name = model.Name,
Age = model.Age,
Sex = model.Sex
};
dbContext.People.Add(person);
dbContext.SaveChanges();
await _hubContext.Clients.All.SendAsync("New person", person);
return(new PersonViewModel(person));
}
catch (Exception)
{
return(Conflict());
}
}
public async Task <ResponseModel <Person> > AddPerson(PersonInputModel person)
{
ResponseModel <Person> personObj
= new ResponseModel <Person>();
try
{
var query = new GraphQLRequest()
{
Query = @"mutation($person : personInput!){
createPerson(person:$person)
{
firstName
lastName
gender
}
}",
Variables = new { person }
};
var response = await _client.PostAsync(query);
personObj.Data = response.GetDataFieldAs <Person>("createPerson");
return(personObj);
}
catch (Exception)
{
throw;
}
}
public async Task <string> AddPersonAsync(PersonInputModel input)
{
if (this.peopleRepository.All().Any(p => p.CompanyId == input.CompanyId &&
p.FirstName == input.FirstName &&
p.LastName == input.LastName &&
p.RoleId == input.RoleId))
{
throw new ArgumentException("Person already exists.");
}
var person = new Person
{
CompanyId = input.CompanyId,
RoleId = input.RoleId,
FirstName = input.FirstName,
LastName = input.LastName,
BirthDate = input.BirthDate?.ToUniversalTime(),
Comunicators = new Comunicators
{
Mobile1 = input.Comunicators is null ? "-" : input.Comunicators.Mobile1,
},
};
await this.peopleRepository.AddAsync(person);
person.Comunicators.AdminId = person.AdminId;
await this.peopleRepository.SaveChangesAsync();
return(person.Id);
}
public ActionResult Save(PersonInputModel inputModel)
{
string message = string.Format("Created user '{0}' in the system.", inputModel.Name);
return(Json(new PersonViewModel {
Message = message
}));
}
public ActionResult Index(PersonInputModel inputModel)
{
if (inputModel == null) {
return View();
}
return RedirectToAction("Index");
}
public ActionResult Index(PersonInputModel inputModel)
{
if (inputModel == null)
{
return(View());
}
return(RedirectToAction("Index"));
}
public ActionResult <PersonViewModel> Modify(PersonInputModel personInput)
{
Person person = MapPerson(personInput);
ServiceResponse response = personService.Modidy(person);
if (response.Error)
{
return(BadRequest(response.Message));
}
return(Ok(response.Person));
}
public Person Add(PersonInputModel person)
{
return(_personService.Add(
new Person
{
FirstName = person.FirstName,
LastName = person.LastName,
Email = person.Email
}
));
}
public ActionResult <PersonViewModel> Post(PersonInputModel personInput)
{
Person person = Map(personInput);
var response = personService.Save(person);
if (response.Error)
{
return(BadRequest(response.Message));
}
return(Ok(response.Person));
}
private Person MapPerson(PersonInputModel personInput)
{
var person = new Person
{
Identification = personInput.Identification,
Name = personInput.Name,
Sex = personInput.Sex,
Age = personInput.Age
};
return(person);
}
public async void AddPersonTest()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var person = new PersonInputModel {
FirstName = "testFN", LastName = "testLN"
};
var res = await service.AddPersonAsync(person);
Assert.NotNull(res);
Assert.True(dbContext.People.Any(x => x.FirstName == person.FirstName));
}
public Person MapPerson(PersonInputModel personInput)
{
var person = new Person()
{
Id = personInput.Id,
Name = personInput.Name,
Age = personInput.Age,
Gender = personInput.Gender
};
return(person);
}
public PersonInputModel GetPersonInputModel(PersonInputModel model = null)
{
var viewModel = model ?? new PersonInputModel();
viewModel.CompanyItems = this.companiesRepository.AllAsNoTracking()
.Select(c => new System.Collections.Generic.KeyValuePair <string, string>(c.Id, c.Name))
.ToList();
viewModel.RoleItems = this.rolesRepo.AllAsNoTracking()
.Select(r => new System.Collections.Generic.KeyValuePair <string, string>(r.Id.ToString(), r.Name))
.ToList();
return(viewModel);
}
public async Task <ActionResult <PersonViewModel> > CreatePerson(PersonInputModel personInputModel)
{
var model = this.mapper.Map <CreatePersonServiceModel>(personInputModel);
var person = await this.service.CreatePersonAsync(model);
if (person == null)
{
return(this.BadRequest());
}
return(this.Ok(this.mapper.Map <PersonViewModel>(person)));
}
public async void AddingSamePersonTwiceShouldReturnNull()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var person = new PersonInputModel {
FirstName = "testFN", LastName = "testLN"
};
await service.AddPersonAsync(person);
var res = await service.AddPersonAsync(person);
Assert.Null(res);
}
private async Task <PersonViewModel> CreatePerson(PersonInputModel personInputModel)
{
var json = JsonConvert.SerializeObject(personInputModel);
var content = new StringContent(json, Encoding.UTF8, "application/json");
var response = await this.client.PostAsync(EndPoint.PersonsBaseUrl, content);
var responseStringContent = await response.Content.ReadAsStringAsync();
var responseContent = JsonConvert.DeserializeObject <PersonViewModel>(responseStringContent);
return(responseContent);
}
public async void DeletePersonTest()
{
using var dbContext = this.GetDbContext();
var service = this.GetContactsService(dbContext);
var person = new PersonInputModel {
FirstName = "testFN", LastName = "testLN"
};
await service.AddPersonAsync(person);
var res = await service.DeleteAsync(dbContext.People.First().Id);
Assert.True(res);
Assert.Equal(0, dbContext.People.Count());
}
public async Task <ActionResult <PersonViewModel> > Save(PersonInputModel personInput)
{
Person person = MapPerson(personInput);
ServiceResponse response = personService.Save(person);
if (response.Error)
{
return(BadRequest(response.Message));
}
var personViewModel = new PersonViewModel(response.Person);
await _hubContext.Clients.All.SendAsync("PersonaRegistrada", personViewModel);
return(Ok(personViewModel));
}
private Person MapPerson(PersonInputModel personModel)
{
var person = new Person
{
Identificacion = personModel.Identificacion,
Name = personModel.Name,
LastName = personModel.LastName,
E_mail = personModel.E_mail,
Password = personModel.Password,
Phone = personModel.Phone,
};
return(person);
}
public async Task <IActionResult> AddPerson(PersonInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(this.contactsService.GetPersonInputModel(input)));
}
try
{
await this.contactsService.AddPersonAsync(input);
}
catch (Exception ex)
{
this.notyfService.Error(ex.Message);
}
return(this.Redirect(GlobalConstants.Index));
}
public async Task <IActionResult> AddPersonModal(PersonInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(this.contactsService.GetPersonInputModel(input)));
}
try
{
await this.contactsService.AddPersonAsync(input);
}
catch (Exception ex)
{
this.notyfService.Error(ex.Message);
}
return(this.Json(new { isValid = true, redirectToUrl = string.Empty }));
}
public async Task <IActionResult> EditPersonModal(PersonInputModel model)
{
if (!this.ModelState.IsValid)
{
return(this.Json(new { isValid = false, redirectToUrl = string.Empty, html = this.View(model) }));
}
try
{
await this.contactsService.EditPersonAsync(model);
}
catch (Exception)
{
return(this.Json(new { isValid = false, redirectToUrl = "reload" }));
}
return(this.Json(new { isValid = true, redirectToUrl = "reload" }));
}
private Person Map(PersonInputModel personInput)
{
var person = new Person();
person.Identification = personInput.Identification;
person.Name = personInput.Name;
person.Surnames = personInput.Surnames;
person.Sex = personInput.Sex;
person.Age = personInput.Age;
person.Department = personInput.Department;
person.City = personInput.City;
person.Support = new Support();
person.Support.IdSupport = personInput.Support.IdSupport;
person.Support.Value = personInput.Support.Value;
person.Support.Modality = personInput.Support.Modality;
person.Support.Date = personInput.Support.Date;
return(person);
}
public void Add(PersonInputModel personInputModel)
{
Person person = new Person()
{
FirstName = personInputModel.FirstName,
MiddleName = personInputModel.MiddleName,
LastName = personInputModel.LastName,
PersonalNumber = personInputModel.PersonalNumber,
HasHealthInsurance = personInputModel.HasHealthInsurance,
BloodId = personInputModel.BloodId,
DoctorId = personInputModel.DoctorId
};
if (personInputModel.Address != null &&
!string.IsNullOrEmpty(personInputModel.Address.Town) &&
!string.IsNullOrEmpty(personInputModel.Address.Street))
{
string addressId = this.addressesService.Add(personInputModel.Address);
Address address = this.addressesService.GetAddress(addressId);
person.Addresses.Add(address);
}
if (personInputModel.Phone != null &&
!string.IsNullOrEmpty(personInputModel.Phone.PhoneNumber))
{
string phoneId = this.phonesService.Add(personInputModel.Phone);
Phone phone = this.phonesService.GetPhone(phoneId);
person.Phones.Add(phone);
}
if (personInputModel.Email != null &&
!string.IsNullOrEmpty(personInputModel.Email.Email))
{
string emailId = this.emailsService.Add(personInputModel.Email);
EmailAddress emailAddress = this.emailsService.GetEmail(emailId);
person.Emails.Add(emailAddress);
}
this.db.Persons.Add(person);
this.db.SaveChanges();
}
public IActionResult Create(CreatePersonViewModel viewModel)
{
PersonInputModel inputModel = new PersonInputModel()
{
FirstName = viewModel.FirstName,
MiddleName = viewModel.MiddleName,
LastName = viewModel.LastName,
PersonalNumber = viewModel.PersonalNumber,
Address = new AddressInputModel()
{
Town = viewModel.Address.Town,
Street = viewModel.Address.Street,
AdditionalDescription = viewModel.Address.AdditionalDescription
},
Phone = new PhoneInputModel()
{
PhoneNumber = viewModel.Phone.PhoneNumber
},
Email = new EmailAddressInputModel()
{
Email = viewModel.Email.Email
},
BloodId = this.bloodsService.GetBloodId(viewModel.BloodId, viewModel.RhDId) == 0 ?
null : (int?)this.bloodsService.GetBloodId(viewModel.BloodId, viewModel.RhDId),
HasHealthInsurance = viewModel.HasHealthInsurance,
DoctorId = viewModel.DoctorId
};
if (!ModelState.IsValid)
{
viewModel.BloodTypes = this.bloodsService.AllBloodTypes();
viewModel.RhDs = this.bloodsService.AllRhDs();
return(this.View(viewModel));
}
this.personsService.Add(inputModel);
return(this.Redirect("/"));
}
public async Task <string> EditPersonAsync(PersonInputModel input)
{
var person = this.peopleRepository.All().FirstOrDefault(c => c.Id == input.Id);
if (person == null)
{
throw new ArgumentException("Person do not exist!");
}
person.CompanyId = input.CompanyId;
person.RoleId = input.RoleId;
person.FirstName = input.FirstName;
person.LastName = input.LastName;
person.BirthDate = input.BirthDate;
person.Comunicators.Mobile1 = input.Comunicators.Mobile1;
person.Comunicators.Email1 = input.Comunicators.Email1;
person.Comunicators.Details = input.Comunicators.Details;
await this.peopleRepository.SaveChangesAsync();
return(person.Id);
}
public async Task <ActionResult> Post([FromForm] PersonInputModel input)
{
try
{
var fileDTO = await _personDomain.GetPeopleFileWithIds(input.file);
if (fileDTO.Status)
{
var personOutputModel = _mapper.Map <Response <PersonOutputModel> >(fileDTO);
return(personOutputModel.Data.OutputFile);
}
else
{
//LogException(e);
throw new Exception(fileDTO.Message);
}
}
catch (Exception ex)
{
return(StatusCode(500));
}
}
public ActionResult Save(PersonInputModel inputModel)
{
string message = string.Format("Created user '{0}' in the system.", inputModel.Name);
return Json(new PersonViewModel {Message = message});
}
