private void SortedApplications_OnFilter(object sender, FilterEventArgs e)
{
if (_vm == null && DataContext != null)
{
_vm = (ApplicationsViewModel)DataContext;
}
if (_vm == null || e.Item == null)
return;
if (e.Item.GetType() == typeof(DirectoryItemViewModel))
{
e.Accepted = false;
return;
}
FileItemViewModel fileItem = (FileItemViewModel)e.Item;
if (!fileItem.Pinned && fileItem.Accesses == 0)
{
e.Accepted = false;
return;
}
e.Accepted = string.IsNullOrEmpty(_vm.SearchFilter) || fileItem.Name.Contains(_vm.SearchFilter);
}
public async Task <IActionResult> Applications()
{
var user = await GetCurrentUserAsync();
var model = new ApplicationsViewModel(user);
var applications = await _userService.ViewGrantedAppsAsync(await _appsContainer.AccessToken(), user.Id);
var taskList = new List <Task>();
foreach (var app in applications.Items)
{
async Task AddApp()
{
var appInfo = await _developerApiService.AppInfoAsync(app.AppID);
model.Apps.Add(appInfo.App);
}
taskList.Add(AddApp());
}
await Task.WhenAll(taskList);
model.Apps = model.Apps.OrderBy(t => t.AppCreateTime).ToList();
return(View(model));
}
public async Task <ApplicationsViewModel> GetApplicationsViewModel(string selectedTab, string searchTerm, string sortColumn, string sortOrder)
{
var pendingApplications = await _applyApiClient.GetOversightsPending(searchTerm, sortColumn, sortOrder);
var completedApplications = await _applyApiClient.GetOversightsCompleted(searchTerm, sortColumn, sortOrder);
var pendingAppealApplications = await _applyApiClient.GetPendingAppealOutcomes(searchTerm, sortColumn, sortOrder);
var completedAppealApplications = await _applyApiClient.GetCompletedAppealOutcomesCompleted(searchTerm, sortColumn, sortOrder);
var result = new ApplicationsViewModel
{
ApplicationDetails = pendingApplications,
ApplicationCount = pendingApplications.Reviews.Count,
OverallOutcomeDetails = completedApplications,
OverallOutcomeCount = completedApplications.Reviews.Count,
PendingAppealsDetails = pendingAppealApplications,
AppealsCount = pendingAppealApplications.Reviews.Count,
CompleteAppealsDetails = completedAppealApplications,
AppealsOutcomeCount = completedAppealApplications.Reviews.Count,
SelectedTab = selectedTab,
SearchTerm = searchTerm,
SortColumn = sortColumn,
SortOrder = sortOrder
};
return(result);
}
public async Task <ActionResult> Index()
{
//create viewmodel to fill with data to pass to the view
ApplicationsViewModel viewModel = new ApplicationsViewModel();
var userId = User.Identity.GetUserId();
var userRoles = await UserManager.GetRolesAsync(userId);
var applications = db.Applications.Include(o => o.ApplicationStatu).Include(o => o.OpenPosition);
var stringToCheck = "Manager";
var stringToCheck2 = "Employee";
if (userRoles.Any(stringToCheck.Contains))
{
viewModel.Applications = applications.ToList().Where(o => o.OpenPosition.Location.ManagerId == userId).ToList();
return(View(viewModel.Applications));
}
else if (userRoles.Any(stringToCheck2.Contains))
{
viewModel.Applications = applications.ToList().Where(o => o.UserId == userId).ToList();
return(View(viewModel.Applications));
}
else //if admin
{
viewModel.Applications = applications.ToList();
return(View(applications.ToList()));
}
}
public ActionResult ApplicationForm()
{
// get all of intervention types
var interventionTypes = _interventionTypeAppService.getAllInterventionTypes();
// get all applications
var applications = _applicationsAppService.getAllApplications().ToList();
// get all property ownerships
var propertyOwnerships = _propertyOwnershipAppService.getAllPropertyOwnerships();
// populate yes no drop down list
var yesOrNo = new List <string>
{
"True",
"False"
};
var fullNameList = new List <string>();
foreach (var application in applications)
{
if (!String.IsNullOrWhiteSpace(application.fullName))
{
fullNameList.Add(application.fullName);
}
}
var fullNameArray = fullNameList.Distinct().ToArray();
var applicationsViewModel = new ApplicationsViewModel()
{
fullNameArray = fullNameArray,
buildingOutput = new GetBuildingsOutput(),
PropertyOwnerShips = propertyOwnerships,
YesOrNo = new SelectList(yesOrNo),
InterventionTypes = interventionTypes
};
return(View("ApplicationForm", applicationsViewModel));
}
public async Task Orchestrator_builds_overview_viewmodel_from_api()
{
var expectedApplicationsPending = GetApplicationsPending();
_apiClient.Setup(x => x.GetOversightsPending()).ReturnsAsync(expectedApplicationsPending);
_apiClient.Setup(x => x.GetOversightsCompleted()).ReturnsAsync(GetApplicationsDone());
_configuration.Setup(x => x.EsfaAdminServicesBaseUrl).Returns(_dashboardAddress);
var actualViewModel = await _orchestrator.GetApplicationsViewModel();
var expectedViewModel = new ApplicationsViewModel
{
ApplicationDetails = GetApplicationsPending(), OverallOutcomeDetails = GetApplicationsDone()
};
expectedViewModel.ApplicationCount = expectedViewModel.ApplicationDetails.Reviews.Count;
expectedViewModel.OverallOutcomeCount = expectedViewModel.OverallOutcomeDetails.Reviews.Count;
Assert.AreEqual(actualViewModel.ApplicationCount, expectedViewModel.ApplicationCount);
Assert.AreEqual(actualViewModel.OverallOutcomeCount, expectedViewModel.OverallOutcomeCount);
Assert.AreEqual(actualViewModel.ApplicationDetails.Reviews.Count, expectedViewModel.ApplicationCount);
Assert.AreEqual(actualViewModel.OverallOutcomeDetails.Reviews.Count, expectedViewModel.OverallOutcomeCount);
Assert.AreEqual(actualViewModel.ApplicationDetails.Reviews.First().ApplicationId,
expectedViewModel.ApplicationDetails.Reviews.First().ApplicationId);
Assert.AreEqual(actualViewModel.OverallOutcomeDetails.Reviews.First().Ukprn,
expectedViewModel.OverallOutcomeDetails.Reviews.First().Ukprn);
}
public ActionResult EditApplication(int appId)
{
var yesOrNo = new List <string>
{
"True",
"False"
};
var getApplicationInput = new GetApplicationsInput()
{
Id = appId
};
// get application according to givin application Id
var application = _applicationsAppService.GetApplicationById(getApplicationInput);
// get the list of buildings
var buildings = _buildingsAppService.getAllBuildings();
// get the list of building units
var buildingUnits = _buildingUnitsAppService.getAllBuildingUnits();
var buildingUnitsByBuildingId = from BU in buildingUnits where BU.BuildingId == application.buildingId select BU;
// get building information by buildingId in application
var getBuildingInput = new GetBuidlingsInput()
{
Id = application.buildingId
};
// get the building information by BuildingId
var building = _buildingsAppService.getBuildingsById(getBuildingInput);
// get the information of spicific building unit
var getBuildingUnitInput = new GetBuildingUnitsInput()
{
Id = application.buildingUnitId
};
var buildingUnit = _buildingUnitsAppService.GetBuildingUnitsById(getBuildingUnitInput);
// get list of propertyOwnerships
var propertyOwnerships = _propertyOwnershipAppService.getAllPropertyOwnerships();
// get list of interventionTypes
var interventionTypes = _interventionTypeAppService.getAllInterventionTypes();
// get list of restorationTypes
var restorationType = _restorationTypeAppService.getAllResorationTypes();
var ApplicationViewModel = new ApplicationsViewModel()
{
applicationsOutput = application,
Buildings = buildings,
BuildingUnits = buildingUnitsByBuildingId,
buildingOutput = building,
YesOrNo = new SelectList(yesOrNo),
PropertyOwnerShips = propertyOwnerships,
BuildingUnit = buildingUnit,
InterventionTypes = interventionTypes,
RestorationTypes = restorationType
};
return(View("_EditApplicationsModal", ApplicationViewModel));
}
public async Task <IActionResult> Applications()
{
var user = await GetCurrentUserAsync();
var token = await _appsContainer.AccessToken();
var model = new ApplicationsViewModel(user)
{
Grants = (await _userService.ViewGrantedAppsAsync(token, user.Id)).Items
};
var appsBag = new ConcurrentBag <App>();
await model.Grants.ForEachInThreadsPool(async grant =>
{
try
{
var appInfo = await _developerApiService.AppInfoAsync(grant.AppId);
appsBag.Add(appInfo.App);
}
catch (AiurUnexpectedResponse e) when(e.Code == ErrorType.NotFound)
{
}
});
model.Apps = appsBag.OrderBy(app =>
model.Grants.Single(grant => grant.AppId == app.AppId).GrantTime).ToList();
return(View(model));
}
public async Task <IActionResult> Applications()
{
var user = await GetCurrentUserAsync();
var token = await _appsContainer.AccessToken();
var model = new ApplicationsViewModel(user)
{
Grants = (await _userService.ViewGrantedAppsAsync(token, user.Id)).Items
};
var taskList = new List <Task>();
foreach (var app in model.Grants)
{
async Task AddApp()
{
var appInfo = await _developerApiService.AppInfoAsync(app.AppID);
model.Apps.Add(appInfo.App);
}
taskList.Add(AddApp());
}
await Task.WhenAll(taskList);
model.Apps = model.Apps.OrderBy(app =>
model.Grants.Single(grant => grant.AppID == app.AppId).GrantTime).ToList();
return(View(model));
}
public ActionResult Index()
{
var applicationsViewModel = new ApplicationsViewModel();
var applications = _applicationService.GetApplications();
applicationsViewModel.AddApplications(applications);
return(View(applicationsViewModel));
}
public async Task <IActionResult> GetAll()
{
var applicationsViewModel = new ApplicationsViewModel {
Applications = await _marketingProvider.Applications.AllAsync()
};
return(View(applicationsViewModel));
}
public ActionResult UploadFileModal(int applicationId)
{
var UploadFileViewModel = new ApplicationsViewModel()
{
ApplicationId = applicationId
};
return(View("_UploadFileView", UploadFileViewModel));
}
public async Task GetApplications_returns_view_with_expected_viewmodel()
{
var applicationsPending = new PendingOversightReviews
{
Reviews = new List <PendingOversightReview> {
new PendingOversightReview {
ApplicationId = _applicationDetailsApplicationId
}
}
};
var applicationsDone = new CompletedOversightReviews
{
Reviews = new List <CompletedOversightReview> {
new CompletedOversightReview {
Ukprn = _ukprnOfCompletedOversightApplication
}
}
};
var PendingAppealapplications = new PendingAppealOutcomes
{
Reviews = new List <PendingAppealOutcome> {
new PendingAppealOutcome {
ApplicationId = _applicationDetailsApplicationId
}
}
};
var CompletedAppealapplications = new CompletedAppealOutcomes
{
Reviews = new List <CompletedAppealOutcome> {
new CompletedAppealOutcome {
Ukprn = _ukprnOfCompletedOversightApplication
}
}
};
var viewModel = new ApplicationsViewModel {
ApplicationDetails = applicationsPending, ApplicationCount = 1, OverallOutcomeDetails = applicationsDone, OverallOutcomeCount = 1, PendingAppealsDetails = PendingAppealapplications, AppealsCount = 1, CompleteAppealsDetails = CompletedAppealapplications, AppealsOutcomeCount = 1
};
_oversightOrchestrator.Setup(x => x.GetApplicationsViewModel(null, null, null, null)).ReturnsAsync(viewModel);
var result = await _controller.Applications(null, null, null, null) as ViewResult;
var actualViewModel = result?.Model as ApplicationsViewModel;
Assert.That(result, Is.Not.Null);
Assert.That(actualViewModel, Is.Not.Null);
Assert.That(actualViewModel, Is.SameAs(viewModel));
Assert.AreEqual(_applicationDetailsApplicationId, actualViewModel.ApplicationDetails.Reviews.FirstOrDefault().ApplicationId);
Assert.AreEqual(_ukprnOfCompletedOversightApplication, actualViewModel.OverallOutcomeDetails.Reviews.FirstOrDefault().Ukprn);
Assert.AreEqual(_applicationDetailsApplicationId, actualViewModel.PendingAppealsDetails.Reviews.FirstOrDefault().ApplicationId);
Assert.AreEqual(_ukprnOfCompletedOversightApplication, actualViewModel.CompleteAppealsDetails.Reviews.FirstOrDefault().Ukprn);
}
public IActionResult PendingApplications()
{
var model = new ApplicationsViewModel()
{
Applications = _application.GetPendingApplications()
/* Get all applications that are still in the application approval process*/
};
return(View(model));
}
public IActionResult SupervisorViewApplications()
{
var model = new ApplicationsViewModel()
{
Applications = _application.GetApplicationsForSupervisor(Convert.ToInt16(User.Claims.ElementAt(0).Value))
/* Use user claim defined in startup and login, which has the user id to get all applications */
};
return(View("AssignedApplications", model));
}
// GET: Applications
public ActionResult Test()
{
var buildingUnitContents = _buildingUnitContentsAppService.getAllBuildingUnitContents().ToList();
var applicationViewModel = new ApplicationsViewModel()
{
BuildingUnitContents = buildingUnitContents
};
return(View("Test", applicationViewModel));
}
public IActionResult Index()
{
List <RegisteredApplication> apps = _context.Applications.ToList();
ApplicationsViewModel apvm = new ApplicationsViewModel()
{
Applications = apps
};
return(View(apvm));
}
public IActionResult PGCViewApplications()
{
var model = new ApplicationsViewModel()
{
Applications = _application.GetPGCReviewApplications()
/* Get all applications that have been reviewed by the supervisor and PGC */
};
return(View("AssignedApplications", model));
}
public IActionResult IndexAdmin()
{
var applications = _applicationData.GetAll();
var model = new ApplicationsViewModel();
model.Applications = applications;
model.UserType = UserType.Admin;
return(View(model));
}
// GET: Applications
public ActionResult Index()
{
var applications = _applicationsAppService.getAllApplications();
var applicationsViewModel = new ApplicationsViewModel()
{
Applications = applications
};
return(View("Applications", applicationsViewModel));
}
public IActionResult IndexUser()
{
var email = User.FindFirst("emails").Value;
var applications = _applicationData.GetUserApplications(email);
var model = new ApplicationsViewModel();
model.Applications = applications;
model.UserType = UserType.User;
return(View(model));
}
public ActionResult ApplicationForm()
{
// get list of building unit content
var buildingUnitContents = _buildingUnitContentsAppService.getAllBuildingUnitContents();
// get the list of building uses
var buildingUses = _buildingUsesAppService.getAllBuildingUses();
//get the list of buildingTypes
var buildingTypes = _buildingTypeAppService.getAllBuildingtype().ToList();
// get the list of neighborhoods
var neighborhoods = _neighborhoodAppService.GetAllNeighborhood().ToList();
// get all of buildings
var buildings = _buildingsAppService.getAllBuildings();
// get all of restoration types
var restorationTypes = _restorationTypeAppService.getAllResorationTypes();
// get all of intervention types
var interventionTypes = _interventionTypeAppService.getAllInterventionTypes();
// get all applications
var applications = _applicationsAppService.getAllApplications().ToList();
// get all property ownerships
var propertyOwnerships = _propertyOwnershipAppService.getAllPropertyOwnerships();
// populate yes no drop down list
var yesOrNo = new List <string>
{
"True",
"False"
};
var fullNameList = new List <string>();
foreach (var application in applications)
{
if (!String.IsNullOrWhiteSpace(application.fullName))
{
fullNameList.Add(application.fullName);
}
}
var fullNameArray = fullNameList.Distinct().ToArray();
var applicationsViewModel = new ApplicationsViewModel()
{
fullNameArray = fullNameArray,
buildingOutput = new GetBuildingsOutput(),
PropertyOwnerShips = propertyOwnerships,
YesOrNo = new SelectList(yesOrNo),
InterventionTypes = interventionTypes,
RestorationTypes = restorationTypes,
Applications = applications,
Buildings = buildings,
Building = new CreateBuildingsInput(),
Neighborhoods = neighborhoods,
BuildingTypes = buildingTypes,
BuildingUses = buildingUses,
BuildingUnitContents = buildingUnitContents
};
return(View("ApplicationForm", applicationsViewModel));
}
public AddAppManCoEmailViewModel(IList <Entities.Application> applications, IList <Entities.ManCo> manCos, IList <Entities.DocType> docTypes)
{
Applications = new ApplicationsViewModel();
Applications.AddApplications(applications);
ManCos = new ManCosViewModel();
ManCos.AddMancos(manCos);
DocTypes = new DocTypesViewModel();
DocTypes.AddDocTypes(docTypes);
}
public ActionResult DropDownList(int buildingId)
{
var buildingUnitsApp = _buildingUnitsAppService.getAllBuildingUnits();
var buildingUnits = (from BU in buildingUnitsApp where BU.BuildingId == buildingId select BU);
var DropDownListViewModel = new ApplicationsViewModel()
{
BuildingUnits = buildingUnits
};
return(PartialView("_DropDownListView", DropDownListViewModel));
}
public ActionResult ShowUploadedFiles(int applicationId)
{
var uploadedFiles = _uploadApplicationFilesAppService.GetAllUploadedApplicationFiles();
var applicationUploadedFiles = from UF in uploadedFiles where UF.applicationId == applicationId orderby UF.Id descending select UF;
var uploadedFilesViewModel = new ApplicationsViewModel()
{
uploadApplicationFilesOutputs = applicationUploadedFiles
};
return(PartialView("_UploadedFilesView", uploadedFilesViewModel));
}
public async Task <ApplicationsViewModel> GetApplicationsViewModel()
{
var result = new ApplicationsViewModel();
var pendingApplications = await _applyApiClient.GetOversightsPending();
var completedApplications = await _applyApiClient.GetOversightsCompleted();
result.ApplicationDetails = pendingApplications;
result.ApplicationCount = pendingApplications.Reviews.Count;
result.OverallOutcomeDetails = completedApplications;
result.OverallOutcomeCount = completedApplications.Reviews.Count;
return(result);
}
public ActionResult PopulateBuildingUnit(int BuildingUnitId)
{
var getBuildingUnitInput = new GetBuildingUnitsInput()
{
Id = BuildingUnitId
};
var buildingUnit = _buildingUnitsAppService.GetBuildingUnitsById(getBuildingUnitInput);
var applicationBuildingUnitViewModel = new ApplicationsViewModel()
{
BuildingUnit = buildingUnit
};
return(Json(applicationBuildingUnitViewModel, JsonRequestBehavior.AllowGet));
}
public async Task <IActionResult> CreditApply(ApplicationsViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var userId = _userManager.GetUserId(HttpContext.User);
var user = new Applications
{
ClientId = int.Parse(userId),
ApplicationDate = model.ApplicationDate,
Income = model.Income,
CreditRequested = model.CreditRequested
};
db.Application.Add(user);
await db.SaveChangesAsync();
}
return(View(model));
}
public ActionResult PopulateApplicationForm(int buildingId)
{
//instantiate object GetBuidlingsInput to get the building entity with given id
var getBuildingInput = new GetBuidlingsInput()
{
Id = buildingId
};
// retrieve the building with givin id
var building = _buildingsAppService.getBuildingsById(getBuildingInput);
// declare viewmodel object to pass data to view
var applicationViewModel = new ApplicationsViewModel()
{
buildingOutput = building
};
return(Json(applicationViewModel, JsonRequestBehavior.AllowGet));
// return View("ApplicationForm", applicationViewModel);
}
public List <ApplicationsViewModel> GetApplicationsViewModel(List <ApplicationInfo> applications, HashSet <string> selectedAppIds)
{
var applicationsViewModel = new List <ApplicationsViewModel>();
if (applications == null || applications.Count == 0)
{
return(applicationsViewModel);
}
var appsByTeam = applications.GroupBy(app => app.OrganizationName).ToDictionary(g => g.Key, g => g.ToList());
foreach (var item in appsByTeam.OrderBy(kvp => kvp.Key))
{
applicationsViewModel.Add(ApplicationsViewModel.Create(item.Key, item.Value, selectedAppIds));
}
return(applicationsViewModel);
}
public ActionResult CreateApplication(CreateApplicationsInput model)
{
var application = new CreateApplicationsInput();
application.phoneNumber1 = model.phoneNumber1;
application.fullName = model.fullName;
application.phoneNumber2 = model.phoneNumber2;
application.isThereFundingOrPreviousRestoration = model.isThereFundingOrPreviousRestoration;
application.isThereInterestedRepairingEntity = model.isThereInterestedRepairingEntity;
application.housingSince = model.housingSince;
application.previousRestorationSource = model.previousRestorationSource;
application.interestedRepairingEntityName = model.interestedRepairingEntityName;
application.PropertyOwnerShipId = Convert.ToInt32(Request["PropertyOwnerShip"]);
application.otherOwnershipType = model.otherOwnershipType;
application.interventionTypeId = Convert.ToInt32(Request["interventionTypeName"]);
application.otherRestorationType = model.otherRestorationType;
application.propertyStatusDescription = model.propertyStatusDescription;
application.requiredRestoration = model.requiredRestoration;
application.buildingId = Convert.ToInt32(Request["BuildingId2"]);
// application.buildingUnitId = Convert.ToInt32(Request["buildingUnitId"]);
application.buildingUnitId = Convert.ToInt32(Request["dropDownBuildingUnitApp"]);
// ==== get of restoration types which it is multi select drop down list ======
var restorationTypes = Request["example-getting-started"];
string[] restorationTypesSplited = restorationTypes.Split(',');
byte[] restorationTypesArray = new byte[restorationTypesSplited.Length];
for (var i = 0; i < restorationTypesArray.Length; i++)
{
restorationTypesArray[i] = Convert.ToByte(restorationTypesSplited[i]);
}
application.restorationTypeIds = restorationTypesArray;
// ====== end of RestorationTypes
_applicationsAppService.Create(application);
// ==== get list of applications ==============
var applications = _applicationsAppService.getAllApplications();
var applicationsViewModel = new ApplicationsViewModel()
{
Applications = applications
};
return(View("Applications", applicationsViewModel));
}
