/// <summary>
/// Step 0
/// </summary>
/// <param name="urn"></param>
/// <returns></returns>
public async Task <ViewResult> ComparisonStrategy(long urn)
{
ViewBag.URN = urn;
var benchmarkSchool = await InstantiateBenchmarkSchoolAsync(urn);
_benchmarkBasketService.SetSchoolAsDefault(benchmarkSchool);
benchmarkSchool.ComparisonList = _benchmarkBasketService.GetSchoolBenchmarkList();
return(View(benchmarkSchool));
}
public async Task <ActionResult> Index(long urn,
UnitType unit = UnitType.AbsoluteMoney,
CentralFinancingType financing = CentralFinancingType.Include,
TabType tab = TabType.Expenditure,
ChartFormat format = ChartFormat.Charts)
{
if (FeatureManager.IsDisabled(Features.RevisedSchoolPage))
{
return(Redirect($"/school/detail?urn={urn}"));
}
OverwriteDefaultUnitTypeForSelectedTab(tab, ref unit);
await _schoolVMBuilder.BuildCoreAsync(urn);
_schoolVMBuilder.SetTab(tab);
await _schoolVMBuilder.AddHistoricalChartsAsync(tab, DetectDefaultChartGroupFromTabType(tab), financing, unit);
await _schoolVMBuilder.AddHistoricalChartsAsync(TabType.Workforce, DetectDefaultChartGroupFromTabType(TabType.Workforce), CentralFinancingType.Include, UnitType.AbsoluteCount);
_schoolVMBuilder.SetChartGroups(tab);
_schoolVMBuilder.AssignLaName();
var schoolVM = _schoolVMBuilder.GetResult();
var hasCscpUrl = await _cscpLookupService.CscpHasPage((int)urn, false);
var hasGiasUrl = await _giasLookupService.GiasHasPage((int)urn, false);
schoolVM.HasCscpUrl = hasCscpUrl;
schoolVM.HasGiasUrl = hasGiasUrl;
if (schoolVM.IsFederation)
{
return(Redirect("/federation/detail?fuid=" + schoolVM.Id));
}
if (schoolVM.ContextData == null)
{
return(View("EmptyResult", new SearchViewModel(_benchmarkBasketService.GetSchoolBenchmarkList(), SearchTypes.SEARCH_BY_NAME_ID)));
}
ViewBag.Tab = tab;
ViewBag.ChartGroup = schoolVM.HistoricalCharts.First().ChartGroup;
ViewBag.UnitType = schoolVM.HistoricalCharts.First().ShowValue;
ViewBag.Financing = financing;
ViewBag.IsSATinLatestFinance = schoolVM.IsSATinLatestFinance;
ViewBag.EstablishmentType = schoolVM.EstablishmentType;
ViewBag.ChartFormat = format;
return(View("Index", schoolVM));
}
private SearchedSchoolListViewModel GetSchoolViewModelList(dynamic response, string orderBy, int page)
{
var schoolListVm = new List <SchoolSearchResultViewModel>();
var vm = new SearchedSchoolListViewModel(schoolListVm, null, SearchTypes.SEARCH_BY_MAT, null, null, null, orderBy);
if (response != null)
{
foreach (var result in response.Results)
{
var schoolVm = new SchoolSearchResultViewModel(result);
schoolListVm.Add(schoolVm);
}
vm.SchoolComparisonList = _benchmarkBasketService.GetSchoolBenchmarkList();
_filterBuilder.AddSchoolLevelFilters(response.Facets, Request.QueryString);
_filterBuilder.AddOfstedRatingFilters(response.Facets, Request.QueryString);
_filterBuilder.AddGenderFilters(response.Facets, Request.QueryString);
var filters = _filterBuilder.GetResult();
vm.Filters = filters;
vm.FilterSelectionState = DetermineSelectionState(filters);
vm.Pagination = new Pagination
{
Start = (SearchDefaults.TRUST_SCHOOLS_PER_PAGE * (page - 1)) + 1,
Total = response.NumberOfResults,
PageLinksPerPage = SearchDefaults.LINKS_PER_PAGE,
MaxResultsPerPage = SearchDefaults.TRUST_SCHOOLS_PER_PAGE,
PagedEntityType = PagedEntityType.School
};
}
return(vm);
}
public ActionResult Index()
{
var vm = new SearchViewModel(_benchmarkBasketService.GetSchoolBenchmarkList(), null);
vm.Authorities = _laService.GetLocalAuthorities();
return(View(vm));
}
public async Task <ActionResult> Index()
{
var comparisonList = _benchmarkBasketService.GetSchoolBenchmarkList();
var benchmarkSchoolDataObjects = await _contextDataService.GetMultipleSchoolDataObjectsByUrnsAsync(comparisonList.BenchmarkSchools.Select(b => long.Parse(b.Urn)).ToList());
comparisonList.BenchmarkSchools = new List <BenchmarkSchoolModel>();
if (benchmarkSchoolDataObjects != null)
{
foreach (var benchmarkSchoolDataObject in benchmarkSchoolDataObjects)
{
BenchmarkSchoolModel benchmarkSchool;
if (benchmarkSchoolDataObject.IsFederation)
{
var federation = new FederationViewModel(benchmarkSchoolDataObject);
var financialDataModel = await _financialDataService.GetSchoolsLatestFinancialDataModelAsync(federation.Id, federation.EstablishmentType);
benchmarkSchool = new BenchmarkSchoolModel(federation)
{
IsReturnsComplete = financialDataModel.IsReturnsComplete,
WorkforceDataPresent = financialDataModel.WorkforceDataPresent
};
}
else
{
var school = new SchoolViewModel(benchmarkSchoolDataObject);
var financialDataModel = await _financialDataService.GetSchoolsLatestFinancialDataModelAsync(school.Id, school.EstablishmentType);
benchmarkSchool = new BenchmarkSchoolModel(school)
{
Address = school.Address,
IsReturnsComplete = financialDataModel.IsReturnsComplete,
WorkforceDataPresent = financialDataModel.WorkforceDataPresent
};
}
comparisonList.BenchmarkSchools.Add(benchmarkSchool);
}
}
comparisonList.BenchmarkSchools = comparisonList.BenchmarkSchools.OrderBy(s => SanitizeSchoolName(s.Name)).ToList();
return(View(comparisonList));
}
private async Task <TrustViewModel> BuildFinancialTrustVMAsync(int companyNo, TabType tab, ChartGroupType chartGroup, MatFinancingType matFinancing)
{
var comparisonListVM = _benchmarkBasketService.GetSchoolBenchmarkList();
var trustVM = new TrustViewModel(companyNo, comparisonListVM);
trustVM.HistoricalCharts = _historicalChartBuilder.Build(tab, chartGroup, trustVM.EstablishmentType);
trustVM.ChartGroups = _historicalChartBuilder.Build(tab, trustVM.EstablishmentType).DistinctBy(c => c.ChartGroup).ToList();
trustVM.LatestTerm = await LatestMATTermAsync();
trustVM.HistoricalFinancialDataModels = await this.GetFinancialDataHistoricallyAsync(trustVM.CompanyNo, matFinancing);
trustVM.AcademiesInFinanceList = (await _financialDataService.GetAcademiesByCompanyNumberAsync(await LatestMATTermAsync(), companyNo)).OrderBy(a => a.EstablishmentName).ToList();
return(trustVM);
}
private async Task <FederationViewModel> BuildFullFederationViewModelAsync(long fuid, TabType tab, ChartGroupType chartGroup, UnitType unitType)
{
var vm = new FederationViewModel(fuid, _benchmarkBasketService.GetSchoolBenchmarkList());
vm.HistoricalCharts.AddRange(_historicalChartBuilder.Build(tab, chartGroup, vm.EstablishmentType, unitType));
vm.HistoricalCharts.AddRange(_historicalChartBuilder.Build(TabType.Workforce, DetectDefaultChartGroupFromTabType(TabType.Workforce), vm.EstablishmentType, UnitType.AbsoluteCount));
vm.ChartGroups = _historicalChartBuilder.Build(tab, vm.EstablishmentType).DistinctBy(c => c.ChartGroup).ToList();
vm.LatestTerm = await LatestFederationTermAsync();
vm.Tab = tab;
vm.ContextData = await _contextDataService.GetSchoolDataObjectByUrnAsync(fuid);
vm.HistoricalFinancialDataModels = await GetFinancialDataHistoricallyAsync(fuid);
_fcService.PopulateHistoricalChartsWithFinancialData(vm.HistoricalCharts, vm.HistoricalFinancialDataModels, vm.LatestTerm, vm.Tab, unitType, vm.EstablishmentType);
_fcService.PopulateHistoricalChartsWithFinancialData(vm.HistoricalCharts, vm.HistoricalFinancialDataModels, vm.LatestTerm, TabType.Workforce, UnitType.AbsoluteCount, vm.EstablishmentType);
vm.SchoolsInFederation = await _contextDataService.GetMultipleSchoolDataObjectsByUrnsAsync(vm.FederationMembersURNs.ToList());
vm.LaName = _laService.GetLaName(vm.La.ToString());
return(vm);
}
public ActionResult Suggest(string locationOrPostcode, bool openOnly = false)
{
var suggestions = TempData["LocationResults"] as SuggestionQueryResult;
var searchMethod = TempData["SearchMethod"] as string;
if (suggestions is null)
{
suggestions = _locationSearchService.SuggestLocationName(locationOrPostcode);
}
var result = new List <LocationViewModel>();
suggestions.Matches.ForEach(item => result.Add(new LocationViewModel(item.Text, item.LatLon)));
var vm = new LocationListViewModel(result, _benchmarkBasketService.GetSchoolBenchmarkList(), locationOrPostcode, string.Empty, openOnly, searchMethod);
return(View(vm));
}
public ActionResult Search(string name, string orderby = "", int page = 1, bool openOnly = false)
{
var searchMethod = TempData["SearchMethod"] as string;
var laModels = _laService.SearchContains(name);
var laViewModels = laModels.Select(la => new LaViewModel(la.Id, la.LaName)).ToList();
var vm = new LaListViewModel(laViewModels, _benchmarkBasketService.GetSchoolBenchmarkList(), orderby, openOnly, searchMethod);
vm.Pagination = new Pagination
{
Start = (SearchDefaults.RESULTS_PER_PAGE * (page - 1)) + 1,
Total = laModels.Count,
PageLinksPerPage = SearchDefaults.LINKS_PER_PAGE,
MaxResultsPerPage = SearchDefaults.RESULTS_PER_PAGE,
PagedEntityType = PagedEntityType.LA
};
return(View(vm));
}
public async Task BuildCoreAsync(long urn)
{
SchoolVM = new SchoolViewModel(await _contextDataService.GetSchoolDataObjectByUrnAsync(urn), _schoolBenchmarkListService.GetSchoolBenchmarkList());
SchoolVM.LatestTerm = await LatestTermAsync(SchoolVM.EstablishmentType);
}