public async Task <Person> UpdateAsync(PersonUpdateModel Person)
{
var existing = await this.Get(Person);
var result = this.Mapper.Map(Person, existing);
this.Context.Update(result);
await this.Context.SaveChangesAsync();
return(this.Mapper.Map <Person>(result));
}
public Parking.Person Update(PersonIdentityModel id, PersonUpdateModel person)
{
var existing = this.ApplicationContext.Person.Where(p => p.Id == id.Id).First();
var result = this.Mapper.Map(person, existing);
this.ApplicationContext.Update(result);
this.ApplicationContext.SaveChanges();
return(this.Mapper.Map <Parking.Person>(result));
}
public Parking.Person Insert(PersonUpdateModel person)
{
var result = this.ApplicationContext.Add(this.Mapper.Map <DataAccess.Entities.Person>(person));
this.ApplicationContext.SaveChanges();
Parking.Person res = new Parking.Person {
Id = result.Entity.Id
};
this.Mapper.Map(result.Entity, res);
return(res);
}
public ActionResult EditPerson(PersonUpdateModel changeModel)
{
if (ModelState.IsValid)
{
Person person = service.GetPersonByUsername(changeModel.Username);
string role = person.Discriminator;
service.EditPerson(Mapper.Map <PersonUpdateModel, Person>(changeModel));
if (role.Equals("Teacher"))
{
return(Redirect("teachers"));
}
if (role.Equals("Student"))
{
return(Redirect("students"));
}
}
return(View(changeModel));
}
public async Task CreateAsync_PhoneNumberValidationSucceed_CreatesPerson()
{
// Arrange
var Person = new PersonUpdateModel();
var expected = new Person();
var PhoneNumberGetService = new Mock <IPhoneNumberGetService>();
PhoneNumberGetService.Setup(x => x.ValidateAsync(Person));
var PersonDataAccess = new Mock <IPersonDataAccess>();
PersonDataAccess.Setup(x => x.InsertAsync(Person)).ReturnsAsync(expected);
var PersonGetService = new PersonCreateService(PersonDataAccess.Object, PhoneNumberGetService.Object);
// Act
var result = await PersonGetService.CreateAsync(Person);
// Assert
result.Should().Be(expected);
}
public async Task CreateAsync_PersonValidationSucceed_CreatesEmployee()
{
// Arrange
var person = new PersonUpdateModel();
var expected = new Person();
var secretGetService = new Mock <ISecretGetService>();
secretGetService.Setup(x => x.ValidateAsync(person));
var personDataAccess = new Mock <IPersonDataAccess>();
personDataAccess.Setup(x => x.InsertAsync(person)).ReturnsAsync(expected);
var personGetService = new PersonCreateService(personDataAccess.Object, secretGetService.Object);
// Act
var result = await personGetService.CreateAsync(person);
// Assert
result.Should().Be(expected);
}
/// <summary>
/// პიროვნების განახლება : სახელი, გვარი, სქესი, პირადი ნომერი, დაბადების თარიღი, ქალაქი, ტელეფონის ნომრები
/// </summary>
/// <param name="personModel"></param>
/// <returns></returns>
public async Task <Result> UpdatePerson(PersonUpdateModel personModel)
{
var currentDate = DateTime.Now;
if (personModel.Id == 0)
{
return(new Result(false, 12, ValidationMassages.PersonIdMustProvided));
}
// არსებობს თუ არა ასეთ იდენტიფიქატორით ჩანაწერი
var personDB = await personRepository.GetParentPersonAsync(personModel.Id);
if (personDB == null)
{
return(new Result(false, 13, ValidationMassages.PersonNotFound));
}
#region ქალაქზე ჩანაწერი არსებობს თუ არა
if (personModel.CityId != null)
{
var city = await citiesRepository.GetByIdAsync(personModel.CityId.Value);
if (city == null)
{
return(new Result(false, 11, "ქალაქიზე ჩანაწერი მოცემული იდენტიფიქატორით არ მოიძებნა"));
}
}
#endregion ქალაქზე ჩანაწერი არსებობს თუ არა
// ისტორიის შექმნა
Persons personsHistroy = new Persons
{
DateCreated = DateTime.Now,
FirstName = personDB.FirstName,
LastName = personDB.LastName,
PersonalNumber = personDB.PersonalNumber,
BirthDate = personDB.BirthDate,
CityId = personDB.CityId,
GenderId = personDB.GenderId,
PersonPhoneNumbers = personDB.PersonPhoneNumbers,
RelationTypeId = personDB.RelationTypeId,
HistoryRowId = personDB.Id
};
// პიროვნების ცხრილში კორექტირება
if (personModel.FirstName != null && personDB.FirstName != personModel.FirstName)
{
personDB.FirstName = personModel.FirstName;
}
if (personModel.LastName != null && personDB.LastName != personModel.LastName)
{
personDB.LastName = personModel.LastName;
}
if (personModel.PersonalNumber != null && personDB.PersonalNumber != personModel.PersonalNumber)
{
personDB.PersonalNumber = personModel.PersonalNumber;
}
if (personModel.BirthDate != null && personDB.BirthDate != personModel.BirthDate)
{
personDB.BirthDate = personModel.BirthDate.GetValueOrDefault();
}
if (personModel.CityId != null && personDB.CityId != personModel.CityId)
{
personDB.CityId = personModel.CityId;
}
if (personModel.GenderId != null && personDB.GenderId != personModel.GenderId)
{
personDB.GenderId = personModel.GenderId;
}
var personPhoneNumber = new List <PersonPhoneNumbers>();
if (!personModel.PersonPhoneNumbers.IsNullOrEmpty())
{
foreach (var phoneModel in personModel.PersonPhoneNumbers)
{
if (!personDB.PersonPhoneNumbers.Any(a => a.PhoneNumber == phoneModel.PhoneNumber && a.PhoneTypeId == phoneModel.PhoneTypeId && a.DateDeleted == null))
{
personPhoneNumber.Add(
new PersonPhoneNumbers
{
PhoneNumber = phoneModel.PhoneNumber,
PhoneTypeId = (int)phoneModel.PhoneTypeId,
DateCreated = currentDate
}
);
}
}
if (!personPhoneNumber.IsNullOrEmpty())
{
foreach (var phone in personDB.PersonPhoneNumbers)
{
if (phone.DateDeleted == null)
{
phone.DateDeleted = currentDate;
}
}
foreach (var newPhone in personPhoneNumber)
{
personDB.PersonPhoneNumbers.Add(newPhone);
}
}
}
var result = await personRepository.UpdatePersonAsync(personDB, personsHistroy);
return(result);
}
public async Task <Person> UpdateAsync(PersonUpdateModel person)
{
await this.SecretGetService.ValidateAsync(person);
return(await this.PersonDataAccess.UpdateAsync(person));
}
public async Task <Result> UpdatePerson([FromBody] PersonUpdateModel personModel)
{
return(await personBLL.UpdatePerson(personModel));
}
public Person CreatePerson(PersonUpdateModel person)
{
this.PersonGetService.ValidatePerson(person);
return(PersonDataAccess.Insert(person));
}
public async Task <Person> CreateAsync(PersonUpdateModel Person)
{
await this.PhoneNumberGetService.ValidateAsync(Person);
return(await this.PersonDataAccess.InsertAsync(Person));
}
public Person UpdatePerson(PersonIdentityModel id, PersonUpdateModel person)
{
PersonGetService.ValidatePerson(person);
return(this.PersonDataAccess.Update(id, person));
}
