public ActionResult Edit(PersonEditViewModel editPerson)
{
var person = Mapper.Map <PersonEditViewModel, Person>(editPerson);
person.PhotoUrl = _personRepository.Get(person.Id).PhotoUrl;
if (editPerson.DeletePhoto)
{
person.PhotoUrl = null;
}
else if (editPerson.Photo != null)
{
var fileName = Path.GetFileName(editPerson.Photo.FileName);
person.PhotoUrl = fileName;
var path = GetPhotoPath(editPerson.Id);
var photoPath = path + "/" + fileName;
Directory.CreateDirectory(path);
editPerson.Photo.SaveAs(photoPath);
}
if (_personRepository.Update(person))
{
return(Json(new { success = true }));
}
return(Json(new { error = true }));
}
public async Task <IActionResult> Edit(PersonEditViewModel model)
{
if (ModelState.IsValid)
{
try
{
var path = model.ImageUrl;
if (model.ImageFile != null)
{
path = await _imageHelper.UploadImageAsync(model.ImageFile, "People");
}
var admin = _converterHelper.ToAdminEdit(model, path);
await _adminRepository.UpdateAsync(admin);
ViewBag.UserMessage = "User Sucessfully Updated!";
}
catch (DbUpdateConcurrencyException)
{
if (!await _adminRepository.ExistAsync(model.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(View(model));
}
return(View(model));
}
public PersonEditViewModel Update(PersonEditViewModel P)
{
Person PP = personRepo.Update(P.ToModel());
unitOfWork.Submit();
return(PP.ToEditableViewModel());
}
public bool SaveCustomer(PersonEditViewModel personEdit)
{
if (personEdit != null)
{
using (var context = new AppDbContext())
{
var person = new PersonPoco()
{
Id = personEdit.Id,
Name = personEdit.Name,
ProvinceId = personEdit.SelectedProvinceId,
Telephone = personEdit.Telephone,
PostalCode = personEdit.PostalCode,
Salary = personEdit.Salary
};
person.ProvincePoco = context.ProvincePocos.Find(personEdit.SelectedProvinceId);
context.PersonPocos.Add(person);
context.SaveChanges();
return(true);
}
}
// Return false if customeredit == null or CustomerID is not a guid
return(false);
}
public PersonEdit(PersonEditViewModel vm)
{
_PersonEditViewModel = vm;
DataContext = vm;
InitializeComponent();
}
public IActionResult Update(PersonEditViewModel personVM)
{
if (!ModelState.IsValid)
{
personVM.Groups = _groupRepository.GetAll();
return(View(personVM));
}
_personRepository.Update(personVM.Person);
return(RedirectToAction("List"));
}
public PersonEditViewModel CreatePerson()
{
var cRepo = new ProvinceRepository();
var customer = new PersonEditViewModel()
{
Id = Guid.NewGuid(),
ProvincePoco = cRepo.GetProvinces()
};
return(customer);
}
public ActionResult Edit(PersonEditViewModel info)
{
#region 驗證Model
if (!ModelState.IsValid)
{
throw new Exception(ModelStateErrorClass.FormatToString(ModelState));
}
#endregion
return(View("Index", info));
}
public PersonEditView(bool add, Action editSuccessAction, Action cancelAction)
{
InitializeComponent();
if (add)
{
DataContext = new PersonAddViewModel(editSuccessAction, cancelAction);
}
else
{
DataContext = new PersonEditViewModel(editSuccessAction, cancelAction);
}
}
public ActionResult Edit(int?id, PersonEditViewModel viewModel)
{
if (ModelState.IsValid)
{
// TODO: Save changes of viewModel.Addresses to database
return(RedirectToAction("Details", new { id = id }));
}
else
{
return(View(viewModel));
}
}
public async Task UpdatePerson(Guid id, PersonEditViewModel viewModel)
{
var person = await _unitOfWork.Persons.GetBy(p => p.Id == id);
if (person == null)
{
throw new PersonNotFoundException();
}
_mapper.Map(viewModel, person);
_unitOfWork.Persons.Update(person);
await _unitOfWork.Save();
}
public IActionResult Save(PersonEditViewModel person)
{
if (ModelState.IsValid)
{
var personModel = person.Id.HasValue ? _personManager.GetPerson(person.Id.Value) : new Person();
var mappedModel = Mapper.Map(person, personModel, typeof(PersonEditViewModel), typeof(Person)) as Person;
_personManager.Save(mappedModel);
return(RedirectToAction(nameof(Index)));
}
return(View(nameof(Edit), person));
}
public ActionResult Details(Guid?id)
{
IEnumerable <Address> addressEntities = Db.Addresses.ToList();
var viewModel = new PersonEditViewModel
{
Addresses = addressEntities.Select(a => new AddressEditorViewModel
{
Id = a.Id,
Street = a.Address1,
City = a.City
}),
};
return(View(viewModel));
}
//public async Task<ActionResult> Edit(int id)
//{
// //IEnumerable<Address> addressEntities = await GetAddressesAsync(id);
// var viewModel = new PersonEditViewModel
// {
// Addresses = addressEntities.Select(a => new AddressEditorViewModel
// {
// Id = a.Id,
// Street = a.Street,
// City = a.City
// }),
// };
// return View(viewModel);
//}
public ActionResult Index()
{
var temp = new List <AddressEditorViewModel>();
temp.Add(new AddressEditorViewModel {
Id = 1, Street = "Street", City = "City"
});
var viewModel = new PersonEditViewModel
{
Addresses = temp
};
return(View(viewModel));
}
public IActionResult Update(int id)
{
Person person = _personRepository.FindWithGroup(a => a.PersonId == id).FirstOrDefault();
if (person == null)
{
return(NotFound());
}
var personVM = new PersonEditViewModel
{
Person = person,
Groups = _groupRepository.GetAll()
};
return(View(personVM));
}
public IActionResult Create(int?groupId)
{
Person person = new Person();
if (groupId != null)
{
person.GroupId = (int)groupId;
}
var vm = new PersonEditViewModel
{
Groups = _groupRepository.GetAll(),
Person = person
};
return(View(vm));
}
public Admin ToAdminEdit(PersonEditViewModel model, string path)
{
return(new Admin
{
Id = model.Id,
FirstName = model.FirstName,
LastName = model.LastName,
StreetAddress = model.StreetAddress,
PhoneNumber = model.PhoneNumber,
PostalCode = model.PostalCode,
DateofBirth = model.DateofBirth,
TaxIdentificationNumber = model.TaxIdentificationNumber,
CitizenCardNumber = model.CitizenCardNumber,
UserId = model.UserId,
ImageUrl = path
});
}
public ActionResult Edit(PersonEditViewModel model)
{
var currentUser = personFacade.GetPeople(new PersonFilter {
Email = User.Identity.Name
}).First();
if (!(currentUser.IsAdmin))
{
return(RedirectToAction("People"));
}
if (ModelState.IsValid)
{
personFacade.UpdatePerson(model.Person);
return(RedirectToAction("People"));
}
ViewBag.CurrentPerson = currentUser;
return(View(model));
}
public async Task <IActionResult> Edit(Guid id, PersonEditViewModel viewModel)
{
if (ModelState.IsValid)
{
try
{
await _personService.UpdatePerson(id, viewModel);
return(RedirectToAction(nameof(Index)));
}
catch (PersonNotFoundException)
{
return(NotFound());
}
}
return(View(viewModel));
}
public IActionResult Create(PersonEditViewModel model)
{
if (ModelState.IsValid)
{
string[] split = model.Name.Split(new char[0]);
var newPerson = new Person();
newPerson.FirstName = split[0];
newPerson.LastName = split[1];
newPerson.Interests = model.Interests;
newPerson.Birth = model.Birth;
newPerson = _peopleData.Add(newPerson);
_peopleData.Commit();
return(RedirectToAction("Search"));
}
return(View());
}
public ActionResult Account(string userName)
{
notificationFacade.DeleteStaleNotifications();
var prs = personFacade.GetPeople(new PersonFilter {
Email = userName
}).First();
var personEditViewModel = new PersonEditViewModel()
{
Person = personFacade.GetPeople(new PersonFilter {
Email = userName
}).First(),
Notifications = notificationFacade
.GetNotifications(new NotificationFilter {
PersonRecipient = prs.Id, Seen = false
})
.OrderBy(y => y.CreationTime).ToList()
};
personEditViewModel.Notifications.ForEach(y => notificationFacade.MarkAsSeen(y.Id));
notificationFacade.DeleteByIds(personEditViewModel.Notifications.Select(y => y.Id).ToArray());
return(View(personEditViewModel));
}
public PersonEdit()
{
InitializeComponent();
DataContext = new PersonEditViewModel();
}
public PersonEditPage()
{
InitializeComponent();
BindingContext = viewModel = new PersonEditViewModel();
}
public PersonEditView(PersonEditViewModel personEditViewModel)
{
this.DataContext = personEditViewModel;
this.InitializeComponent();
}
