// [Authorize]
public async Task <IActionResult> Patch([FromRoute] int id, [FromBody] EditOrganizationViewModel organization)
{
if (ModelState.IsValid)
{
// Confirm that the logged in user is the organizer
var user = await GetCurrentUserAsync();
// For testing purposes
// ApplicationUser user = await context.ApplicationUser.SingleOrDefaultAsync(u => u.FirstName == "Matt");
Organization originalOrg = await context.Organization.Include(o => o.Organizer).Where(o => o.Organizer.Id == user.Id).SingleOrDefaultAsync();
// Organization must be organized by the current user
if (originalOrg == null)
{
return(BadRequest(new
{
Error = $"Can't find organization with id {id} organized by user {user.FirstName} {user.LastName} with user id {user.Id}.",
StatusCode = "400"
}));
}
originalOrg.Name = organization.Name;
originalOrg.Description = organization.Description;
originalOrg.City = organization.City;
originalOrg.State = organization.State;
context.Entry(originalOrg).State = EntityState.Modified;
context.Update(originalOrg);
await context.SaveChangesAsync();
return(Json(new OrganizationViewModel(originalOrg, new ApplicationUserViewModel(user))));
}
return(Json(ModelState));
}
public async Task <IActionResult> EditOrganization(int id)
{
var hasPermission = await _accessManager.HasPermission(User.Identity.Name, _adminSubsystemName);
if (hasPermission)
{
var organization = _organizationService.GetById(id);
var users = _userData.GetAllUsers()
.Select(u => new Select()
{
Id = u.Id,
Name = $"{u.LastName} {u.Name} {u.Patronymic}"
});
var model = new EditOrganizationViewModel()
{
Id = organization.Id,
Name = organization.Name,
SelectedUserId = organization.UserId,
INN = organization.INN,
OGRN = organization.OGRN,
Users = users
};
return(View(model));
}
return(Forbid(CookieAuthenticationDefaults.AuthenticationScheme));
}
public async Task <IActionResult> Edit(Guid id, EditOrganizationViewModel viewModel)
{
if (!await IsOrganizationOwnerAsync(id))
{
return(new HttpUnauthorizedResult());
}
if (!ModelState.IsValid)
{
return(RedirectToAction("Edit", new { id }));
}
return(await _organizationService.EditAsync(id, viewModel.Name)
.Execute(
onSuccess: () =>
{
Notify(FlashNotificationType.Success, "Organization has been updated.");
return RedirectToAction("Details", new { id });
},
onFailure: ex =>
{
Notify(FlashNotificationType.Error, ex.Message);
return RedirectToAction("Edit", new { id });
}));
}
public EditOrganizationViewModel GetEditOrganization(int?id)
{
//PENDING => display image
var org = repository.GetById(id);
var vmorg = new EditOrganizationViewModel();
vmorg.OrganizationID = org.OrganizationID;
vmorg.Name = org.Name;
vmorg.LogoPath = org.LogoPath;
return(vmorg);
}
public virtual ActionResult Index(int id)
{
var org = _serviceFactory.GetService <OrganizationByIdQuery>()
.Execute(new OrganizationByIdQueryParams {
OrganizationId = id
});
var model = new EditOrganizationViewModel(org);
return(View(model));
}
//[ValidateAntiForgeryToken]
public ActionResult Edit(EditOrganizationViewModel editOrganizationViewModel)
{
OrganizationManager organizationManager = new OrganizationManager();
var oldOrganization = organizationManager.Read(editOrganizationViewModel.OrganizationID);
oldOrganization.Name = editOrganizationViewModel.Name;
oldOrganization.ParentOrganization =
organizationManager.Read(editOrganizationViewModel.ParentOrganizationGUID);
organizationManager.Update(oldOrganization);
organizationManager.saveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Edit(Guid id)
{
if (!await IsOrganizationOwnerAsync(id))
{
return(new HttpUnauthorizedResult());
}
var organization = await _organizationService.GetAsync(id);
var viewModel = new EditOrganizationViewModel
{
Name = organization.Name
};
return(View(viewModel));
}
public virtual ActionResult Index(EditOrganizationViewModel model)
{
// Make sure a domain was entered if DomainRestricted is true
if (model.IsEmailDomainRestricted && string.IsNullOrWhiteSpace(model.RestrictedDomain))
{
ModelState.AddModelError("RestrictedDomain", "When restricting registration to a specific email domain, a valid domain name is required");
return(View(model));
}
_serviceFactory.GetService <EditOrganizationCommand>()
.Execute(new EditOrganizationCommandParams
{
OrganizationId = model.Id,
Name = model.Name,
IsEmailDomainRestricted = model.IsEmailDomainRestricted,
EmailDomainRestriction = model.RestrictedDomain
});
return(RedirectToAction(MVC.Organization.Dashboard.Index()));
}
public async Task <IActionResult> EditOrganization(EditOrganizationViewModel model)
{
var organization = _organizationService.GetById(model.Id);
organization.Name = model.Name;
organization.INN = model.INN;
organization.OGRN = model.OGRN;
if (model.SelectedUserId != null)
{
var userId = (int)model.SelectedUserId;
var user = await _userData.GetUserData(userId);
organization.User = user;
}
organization.UserId = model.SelectedUserId;
_organizationService.Update(organization);
return(RedirectToAction("Index", "Organization"));
}
public String EditOrganization(EditOrganizationViewModel organizationViewModel, HttpPostedFileBase LogoPath)
{
String path = "";
if (LogoPath != null)
{
//validate image
if (ValidateImage(LogoPath))
{
//deleting image
DeleteLogoImage(organizationViewModel.OrganizationID);
//Save image
path = SaveImage(LogoPath);
}
}
Organization org = new Organization();
org.OrganizationID = organizationViewModel.OrganizationID;
org.Name = organizationViewModel.Name;
org.LogoPath = Path.GetFileName(path);
org.CreatedOn = DateTime.Now;
repository.Update(org);
return("Organization Edited");
}
public ActionResult Edit(EditOrganizationViewModel model)
{
if (!this.ModelState.IsValid)
{
return this.View(model);
}
Organization organization = this.organizations.Edit(model.Id, model.Name);
this.SetTempDataSuccessMessage("Organization edited successfully.");
return this.RedirectToAction("Details", new { organizationId = model.Id });
}
public ActionResult EditOrganization(EditOrganizationViewModel OrganizationViewModel, HttpPostedFileBase LogoPath)
{
String status = _organizationBl.EditOrganization(OrganizationViewModel, LogoPath);
return(RedirectToAction("index"));
}
