public void AddPerson([FromBody] AddPersonRequest request)
{
_logger.LogInformation("Adding a person");
var command = AddPersonCommand.ConvertFromRequest(request);
_peopleCommandHandler.Handle(command);
}
public AddPersonResponse AddPerson(AddPersonRequest request)
{
try
{
var person = new Person()
{
Fname = request.Fname,
Lname = request.Lname,
PersonalNumber = request.PersonalNumber,
BirthDate = request.BirthDate,
GenderId = request.GenderId,
CityId = request.CityId,
PersonPhones = request.PersonPhones?.Select(t => new PersonPhone {
PhoneNumber = t.PhoneNumber, PhoneTypeId = (int)Enum.Parse(typeof(PhoneType), t.PhoneType)
}).ToList()
};
_db.Persons.Add(person);
_db.SaveChanges();
return(Success(new AddPersonResponse()
{
PersonId = person.Id
}));
}
catch (Exception ex)
{
return(Error(new AddPersonResponse(), RsStrings.AddPersonUnexpectedException));
}
}
public bool Add(AddPersonRequest request)
{
using (var scope = _collection.CreateScope())
{
return(_collection.GetService <IPersonService>().Add(request));
}
}
public static AddPersonCommand ConvertFromRequest(AddPersonRequest request)
{
return(new AddPersonCommand {
FirstName = request.FirstName,
MiddleName = request.MiddleName,
LastName = request.LastName,
NIN = request.NIN,
Dob = DateTime.Parse(request.Dob)
});
}
public override Task <AddPersonResponse> AddPerson(AddPersonRequest request, ServerCallContext context)
{
var person = request.Person;
var people = personOperations.AddPerson(person);
_logger.Log(LogLevel.Information, "Added person: " + person.Name);
return(Task.FromResult(new AddPersonResponse()
{
Status = AddPersonResponse.Types.Status.Success
}));
}
public async Task <IAddPersonResponse> AddPerson([FromBody] string personName, int groupId, string userData)
{
//todo: mapping
var request = new AddPersonRequest
{
GroupId = groupId,
Name = personName,
UserData = userData
};
return(await _cognitiveAdminService.Handle(request));
}
public async Task <PersonResponse> AddPersonAsync(AddPersonRequest request)
{
Person person = _personMapper.Map(request);
Person result = _personRespository.Add(person);
int modifiedRecords = await _personRespository.UnitOfWork.SaveChangesAsync();
_logger.LogInformation(Events.Add, Messages.NumberOfRecordAffected_modifiedRecords, modifiedRecords);
_logger.LogInformation(Events.Add, Messages.ChangesApplied_id, result?.Id);
return(_personMapper.Map(result));
}
public static Person ToPerson(this AddPersonRequest addPersonRequest) =>
new Person()
{
FirstName = addPersonRequest.FirstName,
LastName = addPersonRequest.LastName,
Gender = addPersonRequest.Gender,
PrivateNumber = addPersonRequest.PrivateNumber,
BirthDate = addPersonRequest.BirthDate,
CityId = addPersonRequest.CityId,
PhoneNumbers = addPersonRequest.PhoneNumbers?.ToPhoneNumbers().ToList(),
RelatedPersons = addPersonRequest.RelatedPersons?.ToRelatedPersons().ToList()
};
public bool Add(AddPersonRequest request)
{
Person entity = new Person();
entity.BirthDate = request.BirthDate;
entity.FirstName = request.FirstName;
entity.LastName = request.LastName;
entity.CreateDate = DateTime.Now;
var person = _collection.GetService <IPersonRepository>().Add(entity);
return(person != null ? true : false);
}
public ActionResult PostPerson(AddPersonRequest addPersonRequest)
{
var addPersonResponse = this.addPersonInteractor.Handle(addPersonRequest);
if (addPersonResponse.PersonId != 0)
{
return(Ok(addPersonResponse));
}
else
{
return(BadRequest());
}
}
public async Task AddPerson()
{
var addPersonRequest = new AddPersonRequest()
{
Name = "Brian Mooney",
GroupId = _groupId
};
var persistedPerson = await _cognitiveAdminService.Handle(addPersonRequest);
Assert.IsNotNull(persistedPerson.PersonId);
}
public override Task <AddPersonResponse> AddPerson(AddPersonRequest request, ServerCallContext context)
{
var person = request.Person;
//add to persons
string editableCNP = person.Cnp;
person.BirthYear = getBirthYear(editableCNP).ToString();
person.Gender = getGender(editableCNP);
_logger.Log(LogLevel.Information, "\nAdded person: " + person.Name + "\nBorn in: " + person.BirthYear + "\nGender: " + person.Gender);
return(Task.FromResult(new AddPersonResponse()
{
Status = AddPersonResponse.Types.Status.Succes
}));
}
public Task <int> AddPerson(AddPersonRequest person)
{
var personToAdd = new Person()
{
Forename = person.Forename,
Surname = person.Surname,
Dob = person.DateOfBirth,
AddressLine1 = person.AddressLine1,
AddressLine2 = person.AddressLine2,
City = person.City,
Email = person.EmailAddress,
Username = person.Username
};
return(_personRepository.AddPerson(personToAdd));
}
public async Task <IActionResult> Add(PersonViewModel personViewModel)
{
var person = new AddPersonRequest()
{
Forename = personViewModel.Forename,
Surname = personViewModel.Surname,
DateOfBirth = personViewModel.DateOfBirth,
AddressLine1 = personViewModel.AddressLine1,
AddressLine2 = personViewModel.AddressLine2,
City = personViewModel.City,
EmailAddress = personViewModel.EmailAddress,
Username = personViewModel.Username
};
var id = await _personService.AddPerson(person);
return(RedirectToAction("Index", "Person"));
}
public Person Map(AddPersonRequest request)
{
if (request == null)
{
return(null);
}
Person person = new Person
{
LastName = request.LastName,
FirstName = request.FirstName,
Sex = request.Sex,
Department = request.Department,
PhoneOffice = request.PhoneOffice,
PhonePrivate = request.PhonePrivate,
Email = request.Email,
PictureId = request.PictureId
};
return(person);
}
public PersonResponseStatus NewPersonValidation(AddPersonRequest clientRequest)
{
throw new NotImplementedException();
}
public record Command(AddPersonRequest PersonRequest) : IRequest <PersonResponse>;
public async Task <IActionResult> AddPersonAsync(AddPersonRequest addPersonRequest)
{
await _personsRepo.AddAsync(addPersonRequest.ToPerson());
return(Ok());
}
public ActionResult <AddPersonResponse> AddPerson([FromBody] AddPersonRequest request)
{
return(_personService.AddPerson(request));
}
public async Task <IActionResult> Post(AddPersonRequest request)
{
RespContainer <PersonResponse> result = await _mediator.Send(new AddPersonCommand(request));
return(CreatedAtAction(nameof(GetById), new { id = result.Data.Id }, result));
}
