public ActionResult Add(AddPersonViewModel addPersonViewModel)
{
addPersonViewModel.Person.Avatar = new ArchiveFile();
if (addPersonViewModel.fileUpload != null && addPersonViewModel.fileUpload.ContentLength > 0 && addPersonViewModel.fileUpload.ContentType.Contains("image"))
{
//Get Content of image
MemoryStream target = new MemoryStream();
addPersonViewModel.fileUpload.InputStream.CopyTo(target);
addPersonViewModel.Person.Avatar.Content = target.ToArray();
addPersonViewModel.Person.Avatar.Name = addPersonViewModel.fileUpload.FileName;
addPersonViewModel.Person.Avatar.ContentType = addPersonViewModel.fileUpload.ContentType;
}
if (!string.IsNullOrEmpty(addPersonViewModel.BirthDay))
{
addPersonViewModel.Person.BirthDay = addPersonViewModel.BirthDay.toEnglishNumber().ToGeorgianDateTime();
}
PersonManager personManager = new PersonManager();
//Add Organizations
personManager.AddPostOrganization(addPersonViewModel.Person, addPersonViewModel.SelectedOrganizations, addPersonViewModel.SelectedPosts);
personManager.Add(addPersonViewModel.Person);
personManager.saveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create([FromBody] AddPersonViewModel model)
{
var response = new ApiResponseModel();
if (model == null)
{
response.Message = "Invalid input object.";
return(BadRequest(response));
}
if (string.IsNullOrEmpty(model.FirstName))
{
response.Message = "First name can not be empty.";
return(BadRequest(response));
}
if (string.IsNullOrEmpty(model.LastName))
{
response.Message = "Last name can not be empty.";
return(BadRequest(response));
}
try {
var domainModel = Mapper.Map <PersonModel>(model);
response.Data = await _personService.Create(domainModel);
response.Status = Status.SUCCESS;
response.Message = "Added!";
return(Ok(response));
} catch {
response.Message = "Unknown error. Please, contact support team.";
return(StatusCode(500, response));
}
}
public ActionResult <PersonViewModel> AddPerson([FromBody] AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var person = new Person
{
Name = model.Name,
CreatedTimestamp = DateTime.UtcNow,
GroupId = model.GroupId.GetValueOrDefault()
};
this.personRepository.AddPerson(person);
person = this.personRepository.GetPerson(person.Id);
return(Ok(new PersonViewModel
{
Id = person.Id,
Name = person.Name,
GroupName = person.Group.Name,
CreatedTimestamp = person.CreatedTimestamp
}));
}
public IActionResult Add()
{
AddPersonViewModel addPersonViewModel = new AddPersonViewModel();
//Add
return(View(addPersonViewModel));
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode != NavigationMode.Back)
{
SlideTransition transition = new SlideTransition();
transition.Mode = SlideTransitionMode.SlideRightFadeIn;
PhoneApplicationPage page = (PhoneApplicationPage)((PhoneApplicationFrame)Application.Current.RootVisual).Content;
ITransition trans = transition.GetTransition(page);
trans.Completed += delegate
{
trans.Stop();
if (e.NavigationMode == NavigationMode.New)
{
addPersonViewModel = new AddPersonViewModel(this);
this.DataContext = addPersonViewModel;
}
};
trans.Begin();
}
}
public bool AddPerson(AddPersonViewModel model, string getUserId)
{
var client = _applicationDbContext.Clients.Find(model.ClientId);
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
var user = _applicationDbContext.Users.Find(getUserId);
if (!user.Id.Equals(client.SearchProfile.UserId))
{
throw new UnauthorizedAccessException("Unfortunately you can't edit someone else's listing...");
}
client.Persons.Add(new Person
{
EmploymentStatus = model.EmploymentStatus,
Profession = model.Profession,
Income = model.Income,
Gender = model.Gender,
Age = model.Age
});
_applicationDbContext.SaveChanges();
return(true);
}
public async Task <IActionResult> AddPerson(AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var specification = new OrganizationWithPeopleSpecification(model.OrganizationId);
var organization = _organizationRepository.GetBySpecification(specification);
if (organization == null)
{
return(BadRequest());
}
var authorizationResult = await _authorizationService
.AuthorizeAsync(User, organization, Operations.Update);
if (!authorizationResult.Succeeded)
{
return(Forbid());
}
organization.AddPerson(model.FirstName, model.LastName, model.EmailAddress,
model.PhoneNumber, model.Title, model.ReportsToPersonID);
_organizationRepository.Update(organization);
return(RedirectToAction(nameof(People), new { organizationId = organization.Id }));
}
/// <summary>
/// Default constructor.
/// </summary>
/// <param name="lines">List of lines to add a person.</param>
public AddPersonWindow(ItemsChangeObservableCollection <Line> lines)
{
// Instanciate the view model and set it as the data context.
ViewModel = new AddPersonViewModel(lines);
this.DataContext = ViewModel;
InitializeComponent();
}
public ActionResult AddPerson(int id, int spId)
{
AddPersonViewModel model = new AddPersonViewModel {
ClientId = id, SearchProfileId = spId
};
return(View(model));
}
public ActionResult AddPerson(AddPersonViewModel model)
{
if (_searchProfileService.AddPerson(model, User.Identity.GetUserId()))
{
return(RedirectToAction("Detail", "SearchProfile", new { id = model.SearchProfileId }));
}
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public IActionResult AddRelatedPerson(AddPersonViewModel model)
{
var person = _personService.GetPersonById(model.Id);
var relatedPerson = _personService.GetPersonById(model.RelatedPersonId);
_personService.AddRelatedPerson(person, relatedPerson, model.RelationTypeId);
return(RedirectToAction("RelatedPersons", new { id = model.Id }));
}
public IActionResult AddPersonForm(AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
return(View("AddPerson", model));
}
return(View("AddPerson", model));
}
public void Handle(AddPersonViewModel model)
{
_personResourceService
.AddPerson(new AddPersonInfo
{
GivenName = model.GivenName,
Surname = model.Surname
});
}
public ActionResult Edit(int id)
{
var model = _db.People.Include("City").Include("Country").First(x => x.PersonId == id);
var model2 = _db.Countries.Include("Cities").ToList();
var viewModel = new AddPersonViewModel(model, model2);
return(View(viewModel));
}
public ActionResult Create()
{
var model = new Person();
var model2 = db.Countries.Include("Cities").ToList();
var viewModel = new AddPersonViewModel(model, model2);
return(View(viewModel));
}
public ActionResult Add(AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
_personAddActionHandler.Handle(model);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Add(AddPersonViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var person = _mapper.Map <Person>(viewModel);
await _personService.AddPersonAsync(person);
return(Ok());
}
public async Task AddPerson_WithInvalidModel()
{
var newPerson = new AddPersonViewModel();
SUT.ModelState.AddModelError("DummyModelError", "Model error for testing purposes");
var result = await SUT.Add(newPerson);
_mockMapper.Verify(m => m.Map <Person>(It.IsAny <AddPersonViewModel>()), Times.Never);
_mockService.Verify(svc => svc.AddPersonAsync(It.IsAny <Person>()), Times.Never);
result.ShouldBeAssignableTo <BadRequestResult>();
}
private void AddPerson()
{
var vm = new AddPersonViewModel();
if (dialogSvc.ShowDialog(vm))
{
IPerson person = vm.Item.Person;
if (person != null)
{
addressBook.AddPerson(person);
}
}
}
public IActionResult Add(AddPersonViewModel addPersonViewModel)
{
Person newPerson = new Person
{
Name = addPersonViewModel.Name
};
context.Persons.Add(newPerson);
context.SaveChanges();
return(Redirect("/Person/ViewPerson/" + newPerson.ID));
}
public void AddPerson(AddPersonViewModel vm)
{
var person = new Person
{
FirstName = vm.FirstName,
LastName = vm.LastName,
Age = (DateTime.Now - vm.Birthday).Days / 365
};
var repo = new PeopleRepository(_connectionString);
repo.Add(person);
}
private async void ContentDialog_PrimaryButtonClick(ContentDialog sender, ContentDialogButtonClickEventArgs args)
{
var personName = this.txtPersonName.Text;
// todo: MVP or MVVM
// Raise event
const int GroupId = 1;
AddPersonViewModel addPersonDialogViewModel = new AddPersonViewModel();
NewlyCreatedPerson = await addPersonDialogViewModel.AddPerson(personName, GroupId);
}
public async Task <IActionResult> AddPersonForm(AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
return(View("AddPerson", model));
}
var person = mapper.Map <Person>(model);
var result = await personService.AddPersonAsync(person);
return(RedirectToAction("Person", new { @id = result.Id }));
}
public ActionResult Add()
{
AddPersonViewModel addPersonViewModel = new AddPersonViewModel {
PageId = "AddPerson"
};
PostManager postManager = new PostManager();
UserManager userManager = new UserManager();
User currentUser = userManager.Read(new Guid(User.Identity.Name));
addPersonViewModel.Organizations = userManager.GetUserShowableOrganizations(currentUser);
addPersonViewModel.Posts = postManager.Read(null);
return(View(addPersonViewModel));
}
public IActionResult AddRelatedPersonView(int id)
{
var relationTypes = _personService.GetPersonRelationTypes();
var persons = _personService.GetPersons();
var model = new AddPersonViewModel
{
Id = id,
RelatedPersons = persons.ToList(),
RelationTypes = relationTypes.ToList()
};
return(View(model));
}
//-----------------------------------------------
public AddPersonViewModel Model()
{
var people = _context.PersonCompany.ToList();
var addresses = _context.Address.ToList();
List <SelectListItem> sliPeople = new List <SelectListItem>();
List <SelectListItem> sliAddresses = new List <SelectListItem>();
foreach (PersonCompany person in people)
{
if (person.IsPerson)
{
sliPeople.Add(new SelectListItem {
Value = person.PersonId.ToString(), Text = person.Name + " " + person.Surname
});
}
else
{
sliPeople.Add(new SelectListItem {
Value = person.PersonId.ToString(), Text = person.CompanyName
});
}
}
foreach (Address address in addresses)
{
var text = "";
if (address.ApartmentNumber != null)
{
text = address.City + " ul. " + address.Street + " " + address.BuildingNumber + " / " + address.ApartmentNumber;
}
else
{
text = address.City + " ul. " + address.Street + " " + address.BuildingNumber;
}
sliAddresses.Add(new SelectListItem {
Value = address.AddressId.ToString(), Text = text
});
}
AddPersonViewModel vm = new AddPersonViewModel()
{
Addresses = sliAddresses
};
return(vm);
}
public IActionResult Add([FromForm] AddPersonViewModel model)
{
if (!ModelState.IsValid)
{
model.Groups = GetGroupSelectListItems(model.GroupId);
return(View(model));
}
this.personRepository.AddPerson(new Person
{
Name = model.Name,
CreatedTimestamp = DateTime.UtcNow,
GroupId = model.GroupId.GetValueOrDefault()
});
this.TempData["Success"] = "The person was created successfully.";
return(RedirectToAction("Index"));
}
public async Task <IActionResult> AddPerson(int organizationId)
{
var specification = new OrganizationWithPeopleSpecification(organizationId);
var organization = _organizationRepository.GetBySpecification(specification);
if (organization == null)
{
return(NotFound());
}
var authorizationResult = await _authorizationService.AuthorizeAsync(User, organization, Operations.Read);
if (!authorizationResult.Succeeded)
{
return(Forbid());
}
var viewModel = new AddPersonViewModel(organization);
return(View(viewModel));
}
public async Task <IActionResult> AddPerson()
{
//IEnumerable<CityModel> cities = _peopleDBContext.Cities;
IEnumerable <CityModel> cities;
using (var httpClient = new HttpClient())
{
using (var response = await httpClient.GetAsync("https://localhost:44333/api/people/GetCities"))
{
string apiResponse = await response.Content.ReadAsStringAsync();
cities = JsonConvert.DeserializeObject <List <CityModel> >(apiResponse);
}
}
AddPersonViewModel addPersonViewModel = new AddPersonViewModel()
{
Cities = cities
};
return(View(addPersonViewModel));
}
public AddPersonView()
{
InitializeComponent();
DataContext = new AddPersonViewModel();
}
public IActionResult AddPerson()
{
var model = new AddPersonViewModel();
return(View("AddPerson", model));
}
