private void RegisterCreatePersonDialog(IPersonDataStore personDataStore)
{
_messenger.Register <CreatePersonDialogMessage>(this,
x =>
{
var m = new CreatePersonViewModel
{
Title = "Person erstellen"
};
IWindow w = _vs.ExecuteFunction <CreatePersonViewModel, IWindow>((IWindow)Current.MainWindow, m);
bool?result = w.ShowDialog();
if (!result.HasValue || !result.Value)
{
return;
}
Person person = new Person
{
FirstName = m.FirstName,
LastName = m.LastName,
DateOfBirth = m.DateOfBirth,
Address = m.Address,
City = m.City,
ZipCode = m.ZipCode,
Email = m.Email,
Phone = m.Phone
};
personDataStore.Create(person);
_messenger.Send(new RefreshDataFromRepositoriesMessage());
_messenger.Send(new SetSelectedPersonMessage(person.PersonId));
});
}
public async Task <IActionResult> Create(CreatePersonViewModel model)
{
if (ModelState.IsValid)
{
int id = Int32.MaxValue;
// if model has image, handle it:
if (model.PersonImage != null)
{
// scale & encode to base64
string img = await ImageService.GetJpegBase64String(model.PersonImage);
if (!String.IsNullOrEmpty(img))
{
id = await _svc.AddAsync(model.FullName, model.JobTitle, img);
}
else
{
ModelState.AddModelError("PersonImage", "Please upload " + string.Join(", ", _config.AllowedImageFileExtensions) + " files only.");
return(View(model));
}
}
// put default images
else
{
id = await _svc.AddAsync(model.FullName, model.JobTitle, defaultBase64profile);
}
return(RedirectToAction("Details", new { id }));
}
return(View(model));
}
public IActionResult Create(CreatePersonViewModel model)
{
try
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
UploadFile upload = new UploadFile(_hosting);
string uniqueFileName = upload.UploadedFile(model.image, @"wwwroot\images\People");
_repositoryCustomer.AddNew(new Customer()
{
Adresse = model.Adresse,
CreatedBy = User.Identity.Name,
DateOfBirth = model.DateOfBirth,
First_Name = model.First_Name,
Last_Name = model.Last_Name,
genre = model.genre,
image = uniqueFileName,
Phone = model.Phone
});
return(RedirectToAction(nameof(Index)).WithSuccess("Ajouter", "vous avez ajouté avec succès "));
}
return(View().WithDanger("Ajouter", "Echeq d'ajout !!!"));
}
catch (AjouterException e)
{
ModelState.AddModelError("", e.Message);
return(View());
}
}
public IActionResult Edit(Guid id, CreatePersonViewModel customer)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
UploadFile upload = new UploadFile(_hosting);
var newPath = upload.UploadedFile(customer.image, customer.ImageUrl, @"wwwroot\images\People") ?? String.Empty;
_repositoryCustomer.UpdateElement(id, new Customer()
{
Person_Id = customer.Person_Id,
Adresse = customer.Adresse,
CreatedBy = User.Identity.Name,
DateOfBirth = customer.DateOfBirth,
First_Name = customer.First_Name,
Last_Name = customer.Last_Name,
genre = customer.genre,
image = newPath,
Phone = customer.Phone
});
return(RedirectToAction(nameof(Index)).WithSuccess("Modifier", "vous avez modifié avec succès "));
}
return(View().WithDanger("Modifier", "Echeq de modifier"));
}
catch (Exception e)
{
return(View().WithDanger("ERREUR", e.Message));
}
}
public IActionResult EditPerson(int id, CreatePersonViewModel createPerson)
{
if (ModelState.IsValid)
{
Person car = _peopleService.EditPerson(id, createPerson);
return(RedirectToAction(nameof(Index)));
}
EditPerson editPerson = new EditPerson();
editPerson.Id = id;
editPerson.CreatePerson = createPerson;
return(View(editPerson));
//[HttpPost]
//public IActionResult Delete(int id, DeletePerson deletePerson)
//{
// Person person = _peopleService.FindBy(id);
// if (person == null)
// {
// return RedirectToAction("Index");
// }
// DeletePerson deletePerson = new DeletePerson();
// deletePerson.Delete = _peopleService.Remove(id);
// return View(deletePerson);
//}
}
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,
});
}
public async Task <ActionResult> Create(CreatePersonViewModel model)
{
// Check that all required items are present: in this case, first name, last name and group ID.
if (!ModelState.IsValid)
{
// We still need to reinitialize the groups dropdown - they will not magically reappear.
var groups = await Context.PersonGroups.ToListAsync();
model.Groups = groups;
return(View("Create", model));
}
// Prefer using 'var' when possible (instead of writing Person twice).
// Prefer giving variables descriptive names (i.e. 'person' and not, say, 'x')
var person = new Person
{
FirstName = model.FirstName,
LastName = model.LastName,
PersonGroupId = model.Group.Value
};
Context.People.Add(person);
// In EF, SaveChanges (or SaveChangesAsync) is required in order to persist data to the database.
await Context.SaveChangesAsync();
// After save, 'person' has the database generated ID and CreatedDate automatically attached to it.
return(View("Details", person));
}
public async Task <IActionResult> Create([FromBody] CreatePersonViewModel person)
{
if (!ModelState.IsValid)
{
return(BadRequest(new { Message = "Invalid input(s)" }));
}
var userIdGUID = await GetCurrentUserIdAsync();
var groupOfCurrentUser = await _context.Groups
.Where(a => a.AppUser.IdentityGUID == userIdGUID &&
a.GroupId == person.GroupId)
.FirstOrDefaultAsync();
if (groupOfCurrentUser == null)
{
return(BadRequest(new { Message = "Invalid input(s)" }));
}
var newPerson = new Person
{
PersonGroup = groupOfCurrentUser,
LastName = person.LastName,
FirstName = person.FirstName,
ContactNo = person.ContactNo
};
_context.People.Add(newPerson);
await _context.SaveChangesAsync();
return(Ok(new { Message = "Successfully created new person", NewPerson = newPerson }));
}
public IActionResult Add_View_People(PeopleViewModel objModel)
{
CreatePersonViewModel createPersonModelView = new CreatePersonViewModel();
if (objModel.AddPerson != null)
{
if (ModelState.IsValid)
{
createPersonModelView = objModel.AddPerson;
peopleViewModel = null;
ps.Add(createPersonModelView);
}
else
{
peopleViewModel.ModelErr = "Required fields are missing";
}
}
if (objModel.Search != null)
{
peopleViewModel = ps.FindBy(objModel);
}
return(RedirectToAction(nameof(Add_View_People)));
}
public async Task <ActionResult <Person> > Store(
[FromServices] DataContext context,
[FromBody] CreatePersonViewModel person)
{
if (ModelState.IsValid)
{
var newPerson = new Person
{
Name = person.Name,
Cpf = person.Cpf,
DataBirth = person.DataBirth,
ContryBirth = person.ContryBirth,
StateBirth = person.StateBirth,
CityBirth = person.CityBirth,
FatherName = person.FatherName,
MotherName = person.MotherName,
Email = person.Email
};
context.People.Add(newPerson);
await context.SaveChangesAsync();
return(newPerson);
}
else
{
return(BadRequest(ModelState));
}
}
public Person Create(CreatePersonViewModel createPerson)
{
Person person = new Person(); // skapar en person
{
person.Name = createPerson.Name; // överför datan från createPerson till Person.
person.InCityId = createPerson.CityId;
person.Phone = createPerson.Phone;
}
_peopleDbContext.Add(person); // lägger till person med rätt namn city phone.
int result = _peopleDbContext.SaveChanges(); //sparar ändringar.
if (result == 0)
{
throw new Exception("Unable to add a Person to database");
}
person = Read(person.Id);
return(person);
}
// GET: Patient/Create
public ActionResult Create()
{
//PopulateBarangaysDropDownList();
PopulateBloodTypeDropDownList();
CreatePersonViewModel Model = new CreatePersonViewModel();
return(View(Model));
}
public IActionResult Index()
{
//the book says nothing about initializing this and it took hours to find the problem.
var model = new CreatePersonViewModel();
model.Country = "";
return(View(model));
}
public async Task <IActionResult> AddPerson()
{
var model = new CreatePersonViewModel();
var groups = await _groupService.GetGroups();
model.Groups = new SelectList(groups, "GroupId", "GroupName");
return(PartialView("_CreatePersonModalPartial", model));
}
public ActionResult <Person> Create([FromBody] CreatePersonViewModel person)
{
if (ModelState.IsValid)
{
return(_peopleService.Add(person));
}
return(BadRequest(person));
}
public IActionResult Index(CreatePersonViewModel createPersonViewModel)
{
if (ModelState.IsValid)
{
_peopleService.Add(createPersonViewModel);
}
return(View(_peopleService.All()));
}
public IActionResult Create()
{
CreatePersonViewModel model = new CreatePersonViewModel()
{
Groups = GetGroups()
};
return(View(model));
}
public ActionResult Create()
{
var personTypes = _context.PersonType.ToList();
CreatePersonViewModel model = new CreatePersonViewModel();
model.PersonTypes = personTypes;
return(View(model));
}
public async Task <IActionResult> AddPerson(CreatePersonViewModel model)
{
var createdPerson = await _personService.CreatePerson(new CreatePersonDto { Name = model.Name, GroupId = model.GroupId });
return(PartialView("_CreatePersonModalPartial", new CreatePersonViewModel()
{
PersonId = createdPerson.PersonId, Name = createdPerson.Name, GroupId = createdPerson.GroupId
}));
}
public void Validate_EmptyViewModel_ShouldReturnErrorMessages()
{
var viewModel = new CreatePersonViewModel();
var validator = CreateSut();
var result = validator.Validate(viewModel);
result.IsValid.Should().BeFalse();
result.Errors.Count.Should().Be(2);
}
public IActionResult Index()
{
var viewModel = new CreatePersonViewModel
{
Country = "Please select country"
};
return(View(viewModel));
}
public IActionResult Index()
{
var viewModel = new CreatePersonViewModel
{
School = "DMACC"
};
return(View(viewModel));
}
public IActionResult Index(CreatePersonViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
return(RedirectToAction("Index", "Home"));
}
public IActionResult Create()
{
//Pattern for these view models came from https://stackoverflow.com/questions/17107334/same-view-for-both-create-and-edit-in-mvc4/25374200
var model = new CreatePersonViewModel();
model.Mode = CreateUpdateModeEnum.Create;
BindAvailableDoors(model);
return(View(model));
}
public async Task <IActionResult> Post(CreatePersonViewModel model)
{
var response = await _personAppService.Create(model);
if (!response)
{
return(BadRequest());
}
return(Ok());
}
// GET: PeopleController/Create
public ActionResult Create()
{
CreatePersonViewModel createPersonViewModel = new CreatePersonViewModel();
createPersonViewModel.Cities = _citysService.All().cityList;
createPersonViewModel.Countries = _countryService.All().countrieList;
createPersonViewModel.AllStoredLanguage = _languageService.All().LanguagesList;
// createCountryViewModel.Cities = _citysService.All().cityList;
return(View(createPersonViewModel));
}
public IActionResult Create()
{
CreatePersonViewModel viewModel = new CreatePersonViewModel()
{
BloodTypes = this.bloodsService.AllBloodTypes(),
RhDs = this.bloodsService.AllRhDs()
};
return(this.View(viewModel));
}
public ActionResult Create()
{
CreatePersonViewModel createPersonViewModel = new CreatePersonViewModel();
createPersonViewModel.CityList = _cityService.All();
return(View(createPersonViewModel));
}
public Person Add(CreatePersonViewModel createPerson)
{
if (createPerson.CityId == 0) //no city
{
createPerson.CityId = null;
}
Person createdPerson = _memory.Create(createPerson);
return(createdPerson);
}
public IActionResult Create(CreatePersonViewModel createPerson)
{
if (ModelState.IsValid)
{
_peopleService.Add(createPerson);
return(RedirectToAction(nameof(Index)));
}
return(View(createPerson));
}
