public async Task <ActionResult> GroupEditDelegation(EditGroupDelegationInformationViewModel model)
{
var result = await new EditGroupDelegationInformationViewModelValidator().ValidateAsync(model);
if (ModelState.IsValid)
{
var groupResult = await _groupReadService.GetAsync(model.GroupUId.Value, User);
if (groupResult.Success)
{
var group = groupResult.ReturnValue;
group.DelegationInformation = model.DelegationInformation;
var updatedGroup = new SaveGroupDto(group);
await _groupWriteService.SaveAsync(updatedGroup, User);
}
var url = Url.RouteUrl("GroupDetails", new { id = model.GroupUId, saved = true });
return(Redirect($"{url}#governance"));
}
result.EduBaseAddToModelState(ModelState, null, true);
await _layoutHelper.PopulateLayoutProperties(model, null, model.GroupUId, User);
return(View(model));
}
public async Task <ActionResult> GroupEditCorporateContact(EditGroupCorporateContactViewModel model)
{
var result = await new EditGroupCorporateContactViewModelValidator().ValidateAsync(model);
if (ModelState.IsValid)
{
var groupResult = await _groupReadService.GetAsync(model.GroupUId.Value, User);
if (groupResult.Success)
{
var group = groupResult.ReturnValue;
group.CorporateContact = model.CorporateContact;
var updatedGroup = new SaveGroupDto(group);
var validation = await _groupWriteService.SaveAsync(updatedGroup, User);
if (!validation.HasErrors)
{
var url = Url.RouteUrl("GroupDetails", new { id = model.GroupUId, saved = true });
return(Redirect($"{url}#governance"));
}
validation.ApplyToModelState(ControllerContext);
}
}
else
{
result.EduBaseAddToModelState(ModelState, null);
}
await _layoutHelper.PopulateLayoutProperties(model, null, model.GroupUId, User);
return(View(model));
}
public async Task <IHttpActionResult> ValidateGroupWithEstablishments(ValidateCCGroupWithEstablishments model)
{
var dto = new SaveGroupDto
{
Group = new GroupModel
{
GroupTypeId = model?.GroupTypeId,
LocalAuthorityId = model?.LocalAuthorityId,
Name = model?.Name,
OpenDate = model?.OpenDate,
},
LinkedEstablishments = model?.Establishments?.Select(e => new LinkedEstablishmentGroup
{
CCIsLeadCentre = e?.CCIsLeadCentre ?? false,
Urn = e?.Urn,
JoinedDate = e?.JoinedDate
})
.ToList()
};
var validation = await groupsWriteService.ValidateAsync(dto, User);
validation.Errors.ForEach(x => x.Message = x.GetMessage());
return(Json(validation));
}
private SaveGroupDto CreateSaveDto(GroupEditorViewModel viewModel)
{
viewModel.SetCCLeadCentreUrn();
Func <GroupModel> createDomainModel = () => new GroupModel
{
CompaniesHouseNumber = viewModel.CompaniesHouseNumber,
GroupId = viewModel.GroupId,
GroupTypeId = viewModel.GroupTypeId,
GroupUId = viewModel.GroupUId,
LocalAuthorityId = viewModel.LocalAuthorityId,
ManagerEmailAddress = viewModel.ManagerEmailAddress,
Name = viewModel.GroupName,
OpenDate = viewModel.OpenDate.ToDateTime(),
ClosedDate = viewModel.ClosedDate.ToDateTime(),
Address = UriHelper.TryDeserializeUrlToken <AddressDto>(viewModel.AddressJsonToken)
};
Func <List <LinkedEstablishmentGroup> > createLinksDomainModel =
() => viewModel.LinkedEstablishments.Establishments.Select(x => new LinkedEstablishmentGroup
{
Urn = x.Urn,
Id = x.Id,
JoinedDate = x.JoinedDate ?? x.JoinedDateEditable.ToDateTime(),
CCIsLeadCentre = x.CCIsLeadCentre
}).ToList();
SaveGroupDto dto = null;
if (viewModel.SaveMode == eSaveMode.Details)
{
dto = new SaveGroupDto(createDomainModel());
}
else if (viewModel.SaveMode == eSaveMode.DetailsAndLinks)
{
dto = new SaveGroupDto(createDomainModel(), createLinksDomainModel());
}
else if (viewModel.SaveMode == eSaveMode.Links)
{
dto = new SaveGroupDto(viewModel.GroupUId.Value, createLinksDomainModel());
}
else
{
throw new NotImplementedException($"SaveMode '{viewModel.SaveMode}' is not supported");
}
if (viewModel.CanUserCloseMATAndMarkAsCreatedInError &&
viewModel.CloseMATAndMarkAsCreatedInError &&
dto.Group != null)
{
dto.Group.StatusId = (int)GS.CreatedInError;
}
return(dto);
}
public async Task <ValidationEnvelopeDto> ValidateAsync(SaveGroupDto dto, IPrincipal principal)
{
if (dto.IsNewEntity)
{
return((await _httpClient.PostAsync <ValidationEnvelopeDto>($"group/validate", dto, principal)).GetResponse());
}
else
{
return((await _httpClient.PutAsync <ValidationEnvelopeDto>($"group/validate", dto, principal)).Response);
}
}
public async Task <ActionResult> SaveNewAcademyTrust(CreateAcademyTrustViewModel viewModel)
{
var permission = await _securityService.GetCreateGroupPermissionAsync(User);
if (!permission.GroupTypes.Any(x => x == GT.MultiacademyTrust || x == GT.SingleacademyTrust))
{
throw new PermissionDeniedException("Current principal does not have permission to create a group of this type.");
}
var dto = new SaveGroupDto(new GroupModel
{
Address = UriHelper.DeserializeUrlToken <AddressDto>(viewModel.CompaniesHouseAddressToken),
CompaniesHouseNumber = viewModel.CompaniesHouseNumber,
GroupTypeId = viewModel.TypeId,
Name = viewModel.Name,
OpenDate = viewModel.OpenDate,
StatusId = (int)eLookupGroupStatus.Open,
GroupId = viewModel.GroupId
});
if (ModelState.IsValid)
{
var validationEnvelope = await _groupWriteService.ValidateAsync(dto, User);
if (validationEnvelope.HasErrors)
{
validationEnvelope.Errors.ForEach(x => ModelState.AddModelError(x.Fields, x.GetMessage()));
}
}
if (ModelState.IsValid)
{
var apiResponse = (await _groupWriteService.SaveNewAsync(dto, User));
if (!apiResponse.HasErrors)
{
return(RedirectToAction(nameof(Details), new { id = apiResponse.GetResponse().Value }));
}
else
{
apiResponse.Errors.ForEach(x => ModelState.AddModelError(x.Fields, x.GetMessage()));
}
}
else
{
viewModel.GroupTypes = await GetAcademyTrustGroupTypes(viewModel.TypeId);
}
return(View("CreateAcademyTrust", viewModel));
}
public async Task <ActionResult> SaveNewAcademyTrust(CreateAcademyTrustViewModel viewModel)
{
var dto = new SaveGroupDto(new GroupModel
{
Address = UriHelper.DeserializeUrlToken <AddressDto>(viewModel.CompaniesHouseAddressToken),
CompaniesHouseNumber = viewModel.CompaniesHouseNumber,
GroupTypeId = viewModel.TypeId,
Name = viewModel.Name,
OpenDate = viewModel.OpenDate,
StatusId = (int)eLookupGroupStatus.Open,
GroupId = viewModel.GroupId
});
if (ModelState.IsValid)
{
var validationEnvelope = await _groupWriteService.ValidateAsync(dto, User);
if (validationEnvelope.HasErrors)
{
validationEnvelope.Errors.ForEach(x => ModelState.AddModelError(x.Fields, x.GetMessage()));
}
}
if (ModelState.IsValid)
{
var apiResponse = (await _groupWriteService.SaveNewAsync(dto, User));
if (apiResponse.HasErrors)
{
apiResponse.Errors.ForEach(x => ModelState.AddModelError(x.Fields, x.GetMessage()));
}
else
{
return(RedirectToAction(nameof(Details), new { id = apiResponse.GetResponse().Value }));
}
}
else
{
viewModel.GroupTypes = await GetAcademyTrustGroupTypes(viewModel.TypeId);
}
return(View("CreateAcademyTrust", viewModel));
}
private SaveGroupDto CreateSaveDto(GroupEditorViewModel viewModel)
{
viewModel.SetCCLeadCentreUrn();
GroupModel createDomainModel() => new GroupModel
{
CompaniesHouseNumber = viewModel.CompaniesHouseNumber,
GroupId = viewModel.GroupId,
GroupTypeId = viewModel.GroupTypeId,
GroupUId = viewModel.GroupUId,
LocalAuthorityId = viewModel.LocalAuthorityId,
ManagerEmailAddress = viewModel.ManagerEmailAddress,
Name = viewModel.GroupName,
OpenDate = viewModel.OpenDate.ToDateTime(),
ClosedDate = viewModel.ClosedDate.ToDateTime(),
Address = UriHelper.TryDeserializeUrlToken <AddressDto>(viewModel.AddressJsonToken),
StatusId = viewModel.StatusId,
UKPRN = viewModel.UKPRN?.ToString()
};
List <LinkedEstablishmentGroup> createLinksDomainModel()
{
var domainList = viewModel.LinkedEstablishments.Establishments.Select(x => new LinkedEstablishmentGroup
{
Urn = x.Urn,
Id = x.Id,
JoinedDate = x.JoinedDate ?? x.JoinedDateEditable.ToDateTime(),
CCIsLeadCentre = x.CCIsLeadCentre
}).ToList();
if (domainList.Any() && !domainList.Any(x => x.CCIsLeadCentre))
{
domainList.First().CCIsLeadCentre = true;
viewModel.LinkedEstablishments.Establishments.First().CCIsLeadCentre = true;
}
return(domainList);
}
List <LinkedEstablishmentGroup> createLinkedEstablishmentFromSearch(bool isSearch = false) => new List <LinkedEstablishmentGroup>
{
new LinkedEstablishmentGroup
{
Urn = viewModel.LinkedEstablishments.LinkedEstablishmentSearch.Urn.ToInteger(),
JoinedDate =
viewModel.LinkedEstablishments.LinkedEstablishmentSearch.JoinedDate
.ToDateTime() ?? viewModel.OpenDate.ToDateTime(),
CCIsLeadCentre = isSearch || !createLinksDomainModel().Any(x => x.CCIsLeadCentre)
}
};
List <LinkedEstablishmentGroup> createLinkedEstablishmentFromEdit() => new List <LinkedEstablishmentGroup>
{
new LinkedEstablishmentGroup
{
Urn = viewModel.LinkedEstablishments.Establishments.First(x => x.Urn == viewModel.ActionUrn).Urn,
JoinedDate = viewModel.LinkedEstablishments.Establishments.First(x => x.Urn == viewModel.ActionUrn).JoinedDate,
CCIsLeadCentre = true // the validation always needs this to be set to true when in edit
}
};
List <LinkedEstablishmentGroup> createLinkedEstablishmentFromAdd()
{
var domainList = createLinksDomainModel();
if (domainList.Any(x => x.Urn == viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn))
{
// edit
domainList.First(x => x.Urn == viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn)
.JoinedDate = viewModel.LinkedEstablishments.LinkedEstablishmentSearch.JoinedDate.ToDateTime();
viewModel.LinkedEstablishments.Establishments.First(x =>
viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn != null &&
x.Urn == viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn.Value).JoinedDate
= viewModel.LinkedEstablishments.LinkedEstablishmentSearch.JoinedDate.ToDateTime();
}
else
{
// add
domainList.AddRange(createLinkedEstablishmentFromSearch(false));
if (viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn != null)
{
viewModel.LinkedEstablishments.Establishments.Add(new EstablishmentGroupViewModel
{
Name = viewModel.LinkedEstablishments.LinkedEstablishmentSearch.Name,
JoinedDate =
viewModel.LinkedEstablishments.LinkedEstablishmentSearch.JoinedDate
.ToDateTime(),
Urn = viewModel.LinkedEstablishments.LinkedEstablishmentSearch.FoundUrn.Value,
CCIsLeadCentre = viewModel.LinkedEstablishments.Establishments.All(x => x.CCIsLeadCentre == false)
});
}
}
viewModel.LinkedEstablishments.LinkedEstablishmentSearch = new LinkedEstablishmentSearchViewModel();
return(domainList);
}
SaveGroupDto dto = null;
if (viewModel.SaveMode == eSaveMode.Details)
{
dto = new SaveGroupDto(createDomainModel());
}
else if (viewModel.SaveMode == eSaveMode.DetailsAndLinks)
{
if (viewModel.Action == ActionLinkedEstablishmentSearch)
{
dto = new SaveGroupDto(createDomainModel(), createLinkedEstablishmentFromSearch(true));
_ = SearchForLinkedEstablishment(viewModel);
}
else if (viewModel.Action.StartsWith(ActionLinkedEstablishmentEdit))
{
dto = new SaveGroupDto(createDomainModel(), createLinkedEstablishmentFromEdit());
_ = EditLinkedEstablishment(viewModel);
}
else if (viewModel.Action == ActionLinkedEstablishmentAdd)
{
dto = new SaveGroupDto(createDomainModel(), createLinkedEstablishmentFromAdd());
}
else if (viewModel.Action.StartsWith(ActionLinkedEstablishmentRemove))
{
viewModel.LinkedEstablishments.Establishments.RemoveAll(x => x.Urn == viewModel.ActionUrn);
dto = new SaveGroupDto(createDomainModel(), createLinksDomainModel());
}
else
{
dto = new SaveGroupDto(createDomainModel(), createLinksDomainModel());
}
}
else if (viewModel.SaveMode == eSaveMode.Links)
{
dto = new SaveGroupDto(viewModel.GroupUId.Value, createLinksDomainModel());
}
else
{
throw new NotImplementedException($"SaveMode '{viewModel.SaveMode}' is not supported");
}
if (viewModel.CanUserCloseAndMarkAsCreatedInError &&
viewModel.CloseAndMarkAsCreatedInError &&
dto.Group != null)
{
dto.Group.StatusId = (int)GS.CreatedInError;
}
viewModel.DeriveCCLeadCentreUrn();
return(dto);
}
public async Task <ApiResponse <NumericResultDto> > SaveNewAsync(SaveGroupDto dto, IPrincipal principal) => (await _httpClient.PostAsync <NumericResultDto>($"group", dto, principal));
public async Task <ApiResponse> SaveAsync(SaveGroupDto dto, IPrincipal principal) => await _httpClient.PutAsync($"group", dto, principal);