public async Task <ActionResult> CreateAcademyTrust(string companiesHouseNumber)
{
if (string.IsNullOrWhiteSpace(companiesHouseNumber))
{
return(HttpNotFound());
}
var companyProfile = await _companiesHouseService.SearchByCompaniesHouseNumber(companiesHouseNumber);
var groupTypes = await GetAcademyTrustGroupTypes();
var vm = new CreateAcademyTrustViewModel(companyProfile.Items.First(), groupTypes);
var existingTrust = await _groupReadService.SearchByIdsAsync(null, null, companiesHouseNumber, User);
if (existingTrust != null && existingTrust.Items.Any())
{
vm.TrustExists = true;
vm.TypeId = existingTrust.Items.First().GroupTypeId;
vm.GroupId = existingTrust.Items.First().GroupId;
}
if (vm.Address == null)
{
ModelState.AddModelError("", "This company record doesn't have an address");
}
if (!vm.OpenDate.HasValue)
{
ModelState.AddModelError("", "This company record doesn't have an incorporation date");
}
vm.AllowSave = !vm.TrustExists && ModelState.IsValid;
return(View(vm));
}
public async Task <ActionResult> Convert(ConvertSATViewModel viewModel)
{
if (viewModel.ActionName == "find" && ModelState.IsValid)
{
var result = (await _groupReadService.SearchByIdsAsync(viewModel.Text, viewModel.Text.ToInteger(), viewModel.Text, viewModel.Text.ToInteger(), User)).Items.FirstOrDefault();
if (result == null)
{
ModelState.AddModelError(nameof(viewModel.Text), "We were unable to find a single-academy trust matching those details");
}
else if (result.StatusId == ((int)GS.Closed))
{
ModelState.AddModelError(nameof(viewModel.Text), "Closed single-academy trusts can not be converted");
}
else if (result.GroupTypeId != (int)GT.SingleacademyTrust)
{
ModelState.AddModelError(nameof(viewModel.Text), "That's an invalid group because it's of the wrong type.");
}
else
{
viewModel.Details = result;
viewModel.CountryName = await _lookup.GetNameAsync(() => result.Address.CountryId);
viewModel.CountyName = await _lookup.GetNameAsync(() => result.Address.CountyId);
viewModel.Token = UriHelper.SerializeToUrlToken(result);
}
}
else if (viewModel.ActionName == "confirm")
{
viewModel.Details = UriHelper.DeserializeUrlToken <SearchGroupDocument>(viewModel.Token);
var apiResponse = await _groupWriteService.ConvertSAT2MAT(viewModel.Details.GroupUId, viewModel.CopyGovernanceInfo, User);
if (apiResponse.HasErrors)
{
apiResponse.Errors.ForEach(x => ModelState.AddModelError("", x.GetMessage()));
}
else
{
TempData["ShowSaved"] = "saved";
return(RedirectToRoute("GroupDetails", new { id = apiResponse.GetResponse().Value }));
}
}
return(View(viewModel));
}
private async Task <ActionResult> SearchGroups(GroupSearchViewModel model)
{
if (model.SearchType == eSearchType.Group &&
model.GroupSearchModel.Text.IsNullOrEmpty())
{
return(RedirectToSearchPage(model));
}
if (model.GroupSearchModel.AutoSuggestValueAsInt.HasValue)
{
return(RedirectToDetailPage(model.GroupSearchModel.AutoSuggestValueAsInt.Value));
}
else
{
model.SearchQueryString = Request.QueryString.ToString();
var text = model.GroupSearchModel.Text.Clean();
model.GroupTypes = (await _lookupService.GroupTypesGetAllAsync()).Select(x => new LookupItemViewModel(x)).ToList();
model.GroupStatuses = (await _lookupService.GroupStatusesGetAllAsync()).Select(x => new LookupItemViewModel(x)).ToList();
ApiPagedResult <SearchGroupDocument> results = null;
if (text != null)
{
results = await _groupReadService.SearchByIdsAsync(text, text.ToInteger(), text, text.ToInteger(), User);
}
if (results != null && results.Count > 0)
{
model.Results.Add(results.Items[0]);
model.Count = 1;
}
else
{
var payload = CreateSearchPayload(model);
results = await _groupReadService.SearchAsync(payload, User);
model.Results = results.Items;
if (model.StartIndex == 0)
{
model.Count = results.Count;
}
}
if (model.Count == 1)
{
return(RedirectToDetailPage(model.Results.Single().GroupUId));
}
if (model.Count == 0)
{
return(RedirectToSearchPage(model));
}
return(View("GroupResults", model));
}
}
private async Task <Tuple <int, string> > TryGetGoupUid(ChangeHistoryViewModel model)
{
int?groupUid = null;
var groupName = "";
if (model.GroupSearchModel.AutoSuggestValueAsInt.HasValue)
{
groupUid = model.GroupSearchModel.AutoSuggestValueAsInt.Value;
var group = await _groupReadService.GetAsync(groupUid.Value, User);
if (group.Success)
{
groupName = group.ReturnValue.Name;
}
}
if (groupUid == null || string.IsNullOrWhiteSpace(groupName))
{
ApiPagedResult <SearchGroupDocument> results = null;
var searchText = model.GroupSearchModel.Text.Clean();
if (searchText != null)
{
results =
await _groupReadService.SearchByIdsAsync(searchText, searchText.ToInteger(), searchText, searchText.ToInteger(), User);
}
if (results == null || results.Count == 0)
{
var payload = new GroupSearchPayload(model.Skip, model.Take)
{
Text = model.GroupSearchModel.Text.Clean()
};
results = await _groupReadService.SearchAsync(payload, User);
}
if (results != null && results.Count > 0)
{
groupUid = results.Items.First().GroupUId;
groupName = results.Items.First().Name;
}
else
{
return(null);
}
}
return(new Tuple <int, string>(groupUid.Value, groupName));
}
