public async Task <ActionResult> Create(CreatePersonModel person)
{
string userId = Session["userId"].ToString();
if (string.IsNullOrWhiteSpace(person.FirstName))
{
return(View());
}
if (person.DateCreated is null)
{
person.DateCreated = System.DateTime.Now;
}
var updatedCount = await _personOrchestrator.CreatePerson(new PersonViewModel
{
PersonId = Guid.Parse(userId),
FirstName = person.FirstName,
LastName = person.LastName,
DateCreated = person.DateCreated,
Email = person.Email,
Gender = person.Gender,
PhoneNumber = person.PhoneNumber
});
return(View());
}
public void Create_BadRequest()
{
var model = new CreatePersonModel("", "");
var result = _controller.Post(model);
Assert.IsInstanceOf <BadRequestObjectResult>(result.Result);
}
public async Task <IActionResult> PostAsync([FromBody] CreatePersonModel model, [FromServices] ICreatePersonModelToPersonMapper mapper)
{
var entity = mapper.Map(model);
await _service.CreatePersonAsync(entity);
return(Created($"/api/persons/{entity.Key}", model));
}
public static Result Evaluate(this CreatePersonModel model)
{
var firstName = PersonFirstName.Create(model.FirstName);
var name = PersonName.Create(model.Name);
var email = PersonEmail.Create(model.Email);
return Result.Combine(firstName, name, email);
}
public static Person ToBusinessObject(this CreatePersonModel model)
{
return new Person(
surrogateId: Option.None<string>(),
firstName: PersonFirstName.Create(model.FirstName).Value,
name: PersonName.Create(model.Name).Value,
email: PersonEmail.Create(model.Email).Value);
}
public Domain.Entities.Person Map(CreatePersonModel source)
{
return(new Domain.Entities.Person
{
Age = source.Age,
Key = KeyBuilder.Build(),
Name = source.Name
});
}
public void CreatePerson_FirstNameIsBlank_IsInvalid()
{
var person = new CreatePersonModel()
{
ClubId = 1, FirstName = "", LastName = "2"
};
var results = Setup(person);
results.IsValid.ShouldBe(false);
}
public void CreatePerson_PersonClubIdLessThan1_IsInvalid()
{
var person = new CreatePersonModel()
{
ClubId = 0, FirstName = "1", LastName = "2"
};
var results = Setup(person);
results.IsValid.ShouldBe(false);
}
public void CreatePerson_IsValid()
{
var person = new CreatePersonModel()
{
ClubId = 1, FirstName = "1", LastName = "2"
};
var results = Setup(person);
results.IsValid.ShouldBe(true);
}
public void CreatePerson_LastNameIsNull_IsInvalid()
{
var person = new CreatePersonModel()
{
ClubId = 1, FirstName = "1", LastName = null
};
var results = Setup(person);
results.IsValid.ShouldBe(false);
}
public async Task Handle(CreatePersonModel model)
{
var person = new Person(model.FirstName)
{
LastName = model.LastName,
DateOfBirth = model.DateOfBirth
};
_context.People.Add(person);
await _context.SaveChangesAsync();
}
public void CreatePerson_FirstNameIsGreaterThan20_IsInvalid()
{
var person = new CreatePersonModel()
{
ClubId = 1, FirstName = "012345678901234567890", LastName = "2"
};
var results = Setup(person);
results.IsValid.ShouldBe(false);
}
public Guid CreatePerson(CreatePersonModel person)
{
var personModel = new PersonModel
{
Id = Guid.NewGuid(),
Age = person.Age,
Name = person.Name
};
PersistPerson(personModel);
return(personModel.Id);
}
public void CreateClub_ValidMapping()
{
var newPerson = new CreatePersonModel()
{
ClubId = 1, LastName = "T", FirstName = "T"
};
var person = CreatePersonModel.ToPerson(newPerson);
person.ClubId.ShouldBe(newPerson.ClubId);
person.FirstName.ShouldBe(newPerson.FirstName);
person.LastName.ShouldBe(newPerson.LastName);
}
public static void CreatePerson()
{
var person = new CreatePersonModel
{
FirstName = View.GetString("FirstName"),
Name = View.GetString("Name"),
Email = View.GetString("Email")
};
var message = _controller.CreatePerson(person);
Console.WriteLine(message);
}
public void Should_Map_CreatePersonModel_To_PersonEntity()
{
var createPersonModel = new CreatePersonModel()
{
GroupId = 1,
Name = "Test"
};
var personEntity = _mapper.Map <PersonEntity>(createPersonModel);
Assert.Equal(createPersonModel.GroupId, personEntity.GroupId);
Assert.Equal(createPersonModel.Name, personEntity.Name);
}
public async Task <ActionResult> CreatePerson(CreatePersonModel person)
{
string userId = Session["userId"].ToString();
var updatedCount = await _personOrchestrator.CreatePerson(new PersonViewModel
{
PersonId = Guid.Parse(userId),
FirstName = person.FirstName,
LastName = person.LastName,
Gender = person.Gender,
DateCreated = person.DateCreated,
Email = person.Email,
PhoneNumber = person.PhoneNumber
});
return(Json(updatedCount, JsonRequestBehavior.AllowGet));
}
public async Task <Person> Create(CreatePersonModel newPerson)
{
var club = await _clubRepository.GetByIdAsync(newPerson.ClubId);
if (club == null)
{
return(null);
}
var person = CreatePersonModel.ToPerson(newPerson);
club.AddPerson(person);
await _clubRepository.UpdateAndSaveAsync(club);
return(person);
}
public IActionResult CreatePerson([FromBody] CreatePersonModel model)
{
if (model == null)
{
return(BadRequest());
}
var person = new Person
{
Name = model.Name,
Age = model.Age
};
_dataService.CreatePerson(person);
return(Ok(person));
}
public void Create_CreatedAt()
{
var model = new CreatePersonModel("Derek", "France");
var result = _controller.Post(model);
Assert.IsInstanceOf <CreatedAtActionResult>(result.Result);
var createdResult = result.Result as CreatedAtActionResult;
Assert.AreEqual(201, createdResult.StatusCode);
var value = createdResult.Value as Person;
Assert.AreEqual(1, value.Id);
Assert.AreEqual("Derek", value.Name);
Assert.AreEqual("France", value.Nationality);
}
public async Task <IActionResult> Create([Bind(include: "Name, GroupId")] CreatePersonModel create)
{
try
{
if (ModelState.IsValid)
{
await _personRepository.AddPerson(_mapper.Map <PersonEntity>(create));
return(RedirectToAction("Index"));
}
}
catch (Exception)
{
ModelState.AddModelError("", "Saving failed");
}
await PopulateGroupList(create.GroupId);
return(View(create));
}
public void CreateNewPerson(CreatePersonModel model)
{
Person newPerson = null;
if (model.Age != 0 && !String.IsNullOrWhiteSpace(model.Name))
{
newPerson = new Person(model.Name, model.Age);
}
else if (model.Age != 0)
{
newPerson = new Person(model.Age);
}
else
{
newPerson = new Person();
}
Task1Repo.AddPerson(newPerson);
}
public string CreatePerson(CreatePersonModel personModel)
{
try
{
var validationResult = personModel.Evaluate();
if (validationResult.IsFailure)
{
return(validationResult.Error);
}
var person = personModel.ToBusinessObject();
if (this.personQuery.WithSameName(person.FirstName, person.Name))
{
var createNewPerson =
View.YesNoChoice(
"A person with same firstname an name exist, are you sure you want to create a new one ?");
if (!createNewPerson)
{
return("Person has not been created");
}
}
this.personService.CreatePerson(person);
return("Person created");
}
catch (ArgumentNullException exception)
{
var parameter = exception.GetParameter();
return($"It is not possible to create a person without {parameter}");
}
catch (Exception)
{
return("An unknow error was thrown");
}
}
public async Task <IActionResult> AddPerson([FromBody] CreatePersonModel user)
{
var userEntity = _mapper.Map <PersonEntity>(user);
var res = await _persons.GetByUsername(user.Username).ConfigureAwait(false);
if (res != null)
{
return(BadRequest());
}
var ress = await _persons.GetByEmail(user.Email).ConfigureAwait(false);
if (ress != null)
{
return(BadRequest());
}
userEntity.Password = PersonExtensions.PasswordHashing(userEntity.Password);
await _persons.AddAsync(userEntity).ConfigureAwait(false);
var userResult = await _persons.GetByIdAsync(userEntity.Id).ConfigureAwait(false);
return(CreatedAtRoute("GetPersonById", new { id = userResult.Id }, _mapper.Map <PersonEntity>(userResult)));
}
public static Person CreatePerson(CreatePersonModel model)
{
var createDate = DateTime.Now;
return(new Person
{
FirstName = model.FirstName,
PreferredFirstName = model.PreferredFirstName,
LastName = model.PreferredLastName,
PreferredLastName = model.PreferredLastName,
MiddleName = model.MiddleName,
Title = model.Title,
NhsNumber = model.NhsNumber,
CreatedDate = createDate,
Deleted = false,
Gender = model.Gender,
Dob = model.Dob,
EthnicityId = model.EthnicityId,
Directory = new Directory
{
Name = "person-root"
}
});
}
public ActionResult RegisterStudent(CreatePersonModel b)
{
if (ModelState.IsValid)
{
Registered_Person a = new Registered_Person();
//hash password
var hashPassword = FormsAuthentication.HashPasswordForStoringInConfigFile(b.Person_Password, "MD5");
a.Person_ID = b.Person_ID;
a.Person_Name = b.Person_Name;
a.Person_Surname = b.Person_Surname;
a.Person_Email = b.Person_Email;
a.Person_Password = hashPassword;
a.Person_Type = "Student";
a.Person_Registration_DateTime = DateTime.Now;
Session["newStudent"] = a;
return(RedirectToAction("oneTimePin"));
}
return(View(b));
}
public IActionResult CreatePerson(CreatePersonModel inputModel)
{
this.task1Service.CreateNewPerson(inputModel);
return(LocalRedirect("/Task1/Index"));
}
/// <summary>
/// Método de criação de pessoa
/// </summary>
/// <param name="request">Dados de pessoa.</param>
/// <returns>Pessoa criada.</returns>
public async Task <CreatePersonViewModel> CreatePerson(CreatePersonModel request)
{
_command.Model = request;
return(await _command.Execute());
}
public async Task <int> CreatePerson([FromQuery] CreatePersonModel request) => await _mediator.Send(_mapper.Map <CreatePersonCommand>(request));
public static ValidationResult Setup(CreatePersonModel person)
{
var validator = new CreatePersonModelValidator();
return(validator.Validate(person));
}
