public IActionResult Post([FromBody] Person value) { if (personRepository.Add(value)) { return(Ok()); } return(BadRequest()); }
public HttpResponseMessage PostPerson(Person person) { person = databasePlaceholder.Add(person); string apiName = WebApiConfig.DEFAULT_ROUTE_NAME; //this.Request.SetConfiguration(new HttpConfiguration()); var response = this.Request.CreateResponse <Person>(HttpStatusCode.Created, person); string uri = Url.Link(apiName, new { id = person.id, controller = "person" }); response.Headers.Location = new Uri(uri); return(response); }
public int AddStudent(Person person) { using (TransactionScope tran = new TransactionScope()) { Persons.Add(person); Students.Add(new Student() { Id = person.Id }); // Complete(); tran.Complete(); return(person.Id); } }
public Person Add(string firstName, string lastName, string surName, Genders gender, DateTime?birthDate, string snils, string email, string phone, string registrationAddress, string factAddress, string otherPhones) { var person = _personFactory.Create(firstName, lastName, surName, gender, birthDate, snils, email, phone, registrationAddress, factAddress, otherPhones); _personRepository.Add(person); return(person); }
public bool Create(Person entity) { Random rnd = new Random(); entity.Id = Convert.ToString(rnd.Next(10000, 99999)); var personas = _personRepository.GetAll().ToList().SkipWhile(s => s.Id == entity.Id); //Evita a si mismo if (entity.Rol == "Catador") { if (personBll.ValidateCatador(entity).StartsWith("Error")) { return(false); } } if (personBll.ValidatePersona(entity, personas).StartsWith("Error")) { return(false); } try { _personRepository.Add(entity); _unitOfWork.Commit(); } catch (Exception ex) { return(false); } return(true); }
public void Add(PersonViewModel personViewModel) { var config = _configuration.GetValue <string>("Config:AtletaBase64"); personViewModel.Password = Divers.GenerateMD5(personViewModel.Password); if (personViewModel.Picture == "") { personViewModel.Picture = Divers.Base64ToImage(config, "PERSON"); } else { personViewModel.Picture = Divers.Base64ToImage(personViewModel.Picture, "PERSON"); } Person _person = _mapper.Map <Person>(personViewModel); _personRepository.Add(_person); foreach (var item in personViewModel.ProfileType) { PersonProfile _personProfile = new PersonProfile { PersonId = _person.Id, ProfileType = (ProfileType)int.Parse(item) }; _personProfileRepository.Add(_personProfile); } //var registerCommand = _mapper.Map<RegisterNewCustomerCommand>(personViewModel); //Bus.SendCommand(registerCommand); }
public Person Register(Person person) { person.Password = new ToPasswordRepository().Md5(person.Password); person.IsValid = true; person.PersonTypeID = 1; return(_personRepository.Add(person)); }
public async Task Handle(CreatePersonCommand command, UnitOfWork uow) { IPersonRepository personRepository = PersonRepositoryFactory.Create(uow.Context); var person = new Person(command.Name, command.Email); personRepository.Add(person); }
public async Task <IActionResult> Info(Person personDto) { var Pfr = await _pfrRepository.Get(personDto.Snils); PostgreSQL.Entities.Person personDb; if (Pfr == null) { var personEntitiesDb = _mapper.Map <PostgreSQL.Entities.Person>(personDto); await _personRepository.Add(personEntitiesDb); personDb = await _personRepository.Get(personEntitiesDb.LastName); var personDbId = personDb.PersonId; await _pfrRepository.Add(new PostgreSQL.Entities.PFR { Snils = personDto.Snils, PersonId = personDbId }); } Pfr = await _pfrRepository.Get(personDto.Snils); personDb = await _personRepository.GetById(Pfr.PersonId); var newPfr = _mapper.Map <PFR>(Pfr); var newPerson = _mapper.Map <Person>(personDb); Tuple <Person, PFR> tuple = new Tuple <Person, PFR>(newPerson, newPfr); return(View(tuple)); }
public void DeleteTest() { var p1 = new Person() { FirstName = "Person1_First", LastName = "Delete", Email = "*****@*****.**", CreatedOn = DateTime.UtcNow }; Person added; using (_context = new AllTheSameDbContext()) { using (_personRepository = new PersonRepository(_context)) { //add so we can delete added = _personRepository.Add(p1); Assert.IsNotNull(added); Assert.IsTrue((p1.FirstName == added.FirstName && (p1.LastName == added.LastName))); } } using (_context = new AllTheSameDbContext()) { using (_personRepository = new PersonRepository(_context)) { //now delete var deleted = _personRepository.Delete(added); //_context.SaveChanges(); Assert.IsNotNull(deleted); } } }
public async Task <Guid> Execute(PersonAddRequest person) { var entity = mapper.Map <Person>(person); await personRepository.Add(entity); return(entity.Id); }
public Task <bool> Handle(RegisterNewPersonCommand message, CancellationToken cancellationToken) { //se nao for válido if (!message.IsValid()) { NotifyValidationErrors(message); return(Task.FromResult(false)); } var person = new Person(Guid.NewGuid(), message.Name, message.Email, message.Password, DateTime.Now, message.Active); if (_personRepository.GetByEmail(person.Email) != null) { Bus.RaiseEvent(new DomainNotification(message.MessageType, "O e-mail desta pessoa já está sendo usado!")); return(Task.FromResult(false)); } _personRepository.Add(person); if (Commit()) { //Bus.RaiseEvent(new PersonRegisteredEvent(person.Id, person.Name, person.Email, person.Password, person.DtRegister, person.Active)); } return(Task.FromResult(true)); }
public async Task <IActionResult> Create([FromBody] Person person) { _logger.LogDebug("Starting save"); if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var jsSkill = new Skill { Name = "Test Skill 1" }; var personSkill = new PersonSkill { Skill = jsSkill }; _personRepository.Add(new Person { LastName = person.LastName, FirstName = person.FirstName, Skills = new Collection <PersonSkill> { personSkill } }); await _personRepository.SaveChangesAsync(); _logger.LogDebug("Finished save"); return(CreatedAtAction(nameof(Get), new { id = person.LastName }, person)); }
public async Task <ResponseModel> Post(PersonModel model) { //TODO: Integrate var errorMsg = _message.Find(MessageKey.AddUserFail); try { //This can be placed in a separate validator class if (!ModelState.IsValid) { return(new ResponseModel(false, errorMsg)); } var dataModel = _mapper.Map(model); dataModel.TaskName = "CreatePerson"; dataModel.TaskId = Guid.NewGuid(); var personId = await _personRepository.Add(dataModel); if (personId != 0) { return(new ResponseModel(true)); } _logger.Error(errorMsg); return(new ResponseModel(false, errorMsg)); } catch (Exception ex) { _logger.Error(ex.ToString()); return(new ResponseModel(false, _message.Find(MessageKey.AddUserFail))); } }
/// <inheritdoc /> public void FileReader(string file) { StreamReader reader = null; try { // Clear the repository. _personRepository.RemoveAll(); reader = new StreamReader(file); string strline; while ((strline = reader.ReadLine()) != null) { var values = strline.Split(',').Select(p => p.Trim()).ToList(); Person person = new PersonBuilder().WithFirstName(values[1]).WithLastName(values[0]).Build(); _personRepository.Add(person); _logger.WriteLog("Person: " + person.LastName + ", " + person.FirstName + " successfully read from file."); } } catch (Exception exception) { _logger.WriteLog("An exception occurred in method 'FileReader' from 'FileHandling'. ", exception); throw; } finally { if (reader != null) { reader.Close(); } } }
public Domain.Entities.Person Add(Domain.Entities.Person entity) { if (!entity.IsValid()) { return(entity); } var newPersonCpf = entity.Documents.FirstOrDefault(x => x.DocumentTypeId == Domain.Enum.EDocumentType.CPF); if (newPersonCpf == null) { entity.AddError($"CPF não encontrado - Pessoa a ser cadastrada: {entity.FirstName} {entity.MiddleName} {entity.LastName} "); return(entity); } //TODO - validate all documents, in a later moment if (_personRepository.GetByCPF(newPersonCpf.DocumentNumber) != null) { entity.AddError($"CPF {newPersonCpf.DocumentNumber} já cadastrado"); return(entity); } _personRepository.Add(entity); return(entity); }
public async Task <int> CreateNew(PersonInput input) { try { var person = new Person { Name = input.Name, Images = input.Files.Select(x => new ImageAttachment { Name = x.FileName, ImageAttachmentTypeId = ImageTypes.Person }).ToList() }; peopleRepo.Add(person); peopleRepo.Save(); await filesService.Upload(input.Files, $"{nameof(ImageTypes.Person)}/{person.Id}"); return(person.Id); } catch (Exception ex) { logger.LogError(ex, "exception when saving new Person"); throw; } }
public IActionResult Appointment(Person model) { if (ModelState.IsValid) { Person nwePerson = new Person { Name = model.Name, PhoneNo = model.PhoneNo, Email = model.Email, BirthDate = model.BirthDate, Gender = model.Gender, BloodGroup = model.BloodGroup, PresentAddress = model.PresentAddress, PermanentAddress = model.PermanentAddress, Password = model.Password, IUser = 1, IDate = DateTime.Now }; _personRepository.Add(nwePerson); return(RedirectToAction("Index")); //return RedirectToAction("details", new { id = newEmployee.EmpId }); } return(View()); }
public void Add(PersonViewModel person) { Person p = _Mapper.Map <Person>(person); _PersonRepository.Add(p); _PersonRepository.Save(); }
public void Handle(AddPersonCommand command) { if (!command.IsValid()) { NotifyValidationErrors(command); return; } var address = new Address(command.Adress.PostalCode, command.Adress.City, command.Adress.State, command.Adress.Country, command.Adress.NeighborHood, command.Adress.Street, command.Adress.Complement, command.Adress.Number); var person = new Person(command.Name, address); // if exists bussiness validation, you should validate here! _personRepository.Add(person); if (Commit()) { _mediatorHandler.RaiseEvent(new AddPersonEvent(person.Id, person.Name)); } }
public ICommandResult Handle(UserRegisterCommand command) { var commandResult = new UserRegisterCommandResult(); if (!(_validationService.Validate(command))) { return(commandResult); } //Validações de coisas que não vão em repositório if (!(command.HasValidEmail() & command.HasValidPassword())) { return(commandResult); } //Validações de coisas que vão em repositório if (!(command.HasUniqueUserEmail(_personRepository))) { return(commandResult); } //Gera nova entidade var person = new Person(Guid.NewGuid(), command.Name, command.DocumentNumber, phoneNumber: command.PhoneNumber, email: command.Email, password: _passwordService.Encrypt(command.Password), serialKey: Guid.NewGuid().ToString().Replace("-", "")); //Adiciona as entidades ao repositório var personAdded = _personRepository.Add(person); commandResult.SerialKey = personAdded.SerialKey; return(commandResult); }
public async Task <ResultViewModel> Post( [FromBody] CreatePersonViewModel personViewModel) { personViewModel.Validate(); if (personViewModel.Invalid) { return(new ResultViewModel { Success = false, Message = "Não foi possível cadastrar a pessoa", Data = personViewModel.Notifications }); } var person = new Person( personViewModel.FirstName, personViewModel.LastName, personViewModel.Email); person.Addresses.Add(personViewModel.Address); await _personRepository.Add(person); _personRepository.SaveChanges(); return(new ResultViewModel { Success = true, Message = "Cadastrado com sucesso", Data = person, }); }
private Person CreateNewPerson() { var person = new Person(); _personRepository.Add(person); return(person); }
public async Task <ActionResult <PersonViewModel> > AddPerson(AddViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (await _personRepository.CheckEmail(model.Email)) { return(BadRequest("El email ya existe")); } var person = _mapper.Map <Person>(model); var newPerson = await _personRepository.Add(person); if (newPerson == null) { return(BadRequest()); } var newPersonResult = _mapper.Map <PersonViewModel>(newPerson); return(CreatedAtAction(nameof(AddPerson), new { id = newPersonResult.IdPerson }, newPersonResult)); }
public void Add(Person person) { if (_personValidator.Validate(person)) { _personRepository.Add(person); } }
public ActionResult SaveEmployee(PersonAddressViewModel personAddressViewModel) { if (ModelState.IsValid) { var Person = new Person(); var Address = new Address(); Person.FirstName = personAddressViewModel.FirstName; Person.LastName = personAddressViewModel.LastName; Person.Email = personAddressViewModel.Email; Address.Address1 = personAddressViewModel.Address1; Address.Address2 = personAddressViewModel.Address2; Address.City = personAddressViewModel.City; Address.State = personAddressViewModel.State; Address.ZipCode = personAddressViewModel.ZipCode; _personRepository.Add(Person); _personRepository.Save(); Address.AddressId = Person.PersonId; _addressRepository.Add(Address); _addressRepository.Save(); return(RedirectToAction("EmployeeDetails")); } else { return(View("AddAddress", personAddressViewModel)); } }
public IActionResult AddPerson([FromBody] Person person) { _personRepo.Add(person); int result = _unitOfWork.SaveAll(); return(NoContent()); }
public ActionResult Post([FromBody] CreatePersonDto personDto) { if (!ModelState.IsValid) { return(BadRequest()); } var personWithoutAddress = _mapper.Map <PersonWithoutAddressDto>(personDto); var personEntity = _mapper.Map <Person>(personWithoutAddress); _personRepository.Add(personEntity); if (!_personRepository.Save()) { return(StatusCode(500, "An error occured while making the change")); } foreach (var address in personDto.Addresses) { address.PersonID = personEntity.ID; var addressEntity = _mapper.Map <Address>(address); _addressRepository.Create(addressEntity); if (!_addressRepository.Save()) { return(StatusCode(500, "An error occured while making the change")); } } return(CreatedAtAction("Post", new { id = personEntity.ID }, personEntity)); }
public void RegisterNewStudent(Person student) { if (_personRepository.Find(student.Id) == null) { _personRepository.Add(student); } }
public async Task <int> Handle(CreatePersonCommand request, CancellationToken cancellationToken) { var person = _mapper.Map <Person>(request); var result = await _personRepository.Add(person); return(result); }