public IActionResult EditForm(int editId)
{
ApplicationResponse movieToEdit = _moviesdb.Movies.FirstOrDefault(s => s.MovieId == editId);
ViewBag.movieToEdit = movieToEdit;
return(View("EditForm"));
}
public IActionResult EditMovie(int movieid)
{
//IQueryable<ApplicationResponse> queryablemovies = context.Movies.Where(t => t.MovieID == appResponse.MovieID);
ApplicationResponse movie = context.Movies.Where(cl => cl.MovieID == movieid).First();
return(View("EditMovie", movie));
}
public async Task <IActionResult> Edit(int id, [Bind("ApplicationResponseID,Category,Title,Year,Director,Rating,Edited,Lent_To,Notes")] ApplicationResponse applicationResponse)
{
if (id != applicationResponse.ApplicationResponseID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(applicationResponse);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ApplicationResponseExists(applicationResponse.ApplicationResponseID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(applicationResponse));
}
public SequenceViewModel(ApplicationResponse application, Organisation organisation, Sequence sequence,
List <Section> sections, List <ApplySection> applySections, string backAction, string backController, string backOrganisationId)
: base(backAction, backController, backOrganisationId)
{
ApplicationId = application.Id;
ApplicationReference = application.ApplyData.Apply.ReferenceNumber;
StandardName = application.ApplyData.Apply.StandardName;
StandardCode = application.ApplyData.Apply.StandardCode;
StandardReference = application.ApplyData.Apply.StandardReference;
ReviewStatus = application.ReviewStatus;
FinancialReviewStatus = application.FinancialReviewStatus;
FinancialDueDate = application.FinancialGrade?.FinancialDueDate;
LegalName = organisation.OrganisationData.LegalName;
TradingName = organisation.OrganisationData.TradingName;
ProviderName = organisation.OrganisationData.ProviderName;
Ukprn = organisation.EndPointAssessorUkprn;
CompanyNumber = organisation.OrganisationData.CompanyNumber;
OrganisationName = organisation.EndPointAssessorName;
ApplySections = GetRequiredApplySections(applySections);
Sections = GetRequiredSections(applySections, sections);
SequenceNo = sequence.SequenceNo;
Status = sequence.Status;
ContactName = application.ContactName;
ContactEmail = application.ContactEmail;
}
public IActionResult Remove(ApplicationResponse appResponse)
{
context.Applications.Remove(appResponse);
context.SaveChanges();
return(View("Waitlist", context.Applications));
}
private void AssertQuestions(ApplicationResponse response)
{
foreach (var questionTester in _questionTesters)
{
AssertAnswerQuestion(questionTester.Id, FormatIds[questionTester.Id], questionTester.Value, response);
}
}
private async Task <string> ApplicationStandardStatus(ApplicationResponse application, string iFateReferenceNumber, List <string> versions)
{
var validApplicationStatuses = new string[] { ApplicationStatus.InProgress };
var validApplicationSequenceStatuses = new string[] { ApplicationSequenceStatus.Draft };
var org = await _orgApiClient.GetEpaOrganisation(application.OrganisationId.ToString());
var standards = await _orgApiClient.GetAppliedStandardVersionsForEPAO(org?.OrganisationId, iFateReferenceNumber);
var matchingStandards = standards.Where(x => x.ApplicationId != application.Id &&
versions.Contains(x.Version));
if (matchingStandards.Any(x => x.ApprovedStatus == ApprovedStatus.Approved))
{
return(ApplicationStatus.Approved);
}
else
{
var inProgressApplications = matchingStandards.Where(x => x.ApprovedStatus == ApprovedStatus.ApplyInProgress &&
validApplicationStatuses.Contains(x.ApplicationStatus));
foreach (var app in inProgressApplications)
{
var sequence = app.ApplyData.Sequences?.FirstOrDefault(seq => seq.IsActive && seq.SequenceNo == ApplyConst.STANDARD_SEQUENCE_NO);
if (sequence != null && validApplicationSequenceStatuses.Contains(sequence.Status))
{
return(sequence.Status);
}
}
}
return(string.Empty);
}
private static void AssertResume(string fileName, string value, ApplicationResponse response)
{
var cv = response.ApplicationAnswer.Files.CV;
Assert.AreEqual(fileName, cv.Filename);
Assert.AreEqual(value, cv.Value);
}
public ApplicationResponse GetResponseAPI()
{
var result = new ApplicationResponse();
result.AddErro(Mensagens);
return(result);
}
public async Task WhenTheEmployerUnderstandsAndConfirmsTheDeclaration()
{
var application = _fixture.Create <IncentiveApplicationDto>();
application.BankDetailsRequired = true;
var response = new ApplicationResponse {
Application = application
};
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath($"/accounts/{_testData.AccountId}/applications/{_testData.ApplicationId}")
.WithParam("includeApprenticeships", new ExactMatcher("False"))
.UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/json")
.WithBody(JsonConvert.SerializeObject(response)));
var url = $"{_testData.HashedAccountId}/apply/declaration/{_testData.ApplicationId}/";
var formData = new KeyValuePair <string, string>();
_continueNavigationResponse = await _testContext.WebsiteClient.PostFormAsync(url, formData);
}
public IActionResult EditDone(ApplicationResponse movie)
{
//IQueryable<ApplicationResponse> queryablemovies = context.Movies.Where(t => t.MovieID == movieid);
//ApplicationResponse appResponse = context.Movies.Where(cl => cl.MovieID == movieid).First();
//foreach (var movie in queryablemovies)
//{
if (ModelState.IsValid || movie.Title == "Independence Day")
{
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Category = movie.Category;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Title = movie.Title;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Director = movie.Director;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Year = movie.Year;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Rating = movie.Rating;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Edited = movie.Edited;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Lent = movie.Lent;
context.Movies.Where(cl => cl.MovieID == movie.MovieID).FirstOrDefault().Notes = movie.Notes;
context.SaveChanges();
return(View("MovieList", context.Movies));
}
else
{
return(View());
}
//}
}
public AmendApprenticeSelectionSteps(TestContext testContext) : base(testContext)
{
_testContext = testContext;
_hashingService = _testContext.HashingService;
_data = new TestData.Account.WithInitialApplicationForASingleEntity();
_getApplicationResponse = _data.GetApplicationResponseWithFirstTwoApprenticesSelected;
_testContext.AddOrReplaceClaim(EmployerClaimTypes.Account, _data.HashedAccountId);
}
public IActionResult Delete(string moviename)
{
ApplicationResponse appResponse = _context.ApplicationResponses.Where(y => y.Title == moviename).FirstOrDefault();
_context.ApplicationResponses.Remove(appResponse);
_context.SaveChanges();
return(RedirectToAction("MoviesList"));
}
//update page
public IActionResult Update(string moviename)
{
ApplicationResponse appResponse = _context.ApplicationResponses
.Where(y => y.Title == moviename).FirstOrDefault();
_context.SaveChanges();
return(View(appResponse));
}
public IActionResult AddMovies(ApplicationResponse appResponse)
{
TempStorage.AddApplication(appResponse);
_DbContext.ApplicationResponses.Add(appResponse);
_DbContext.SaveChanges();
return(View("MovieConfirmation", appResponse));
}
public IActionResult MovieCollection(int id)
{
ApplicationResponse Movie = context.Movies.Where(x => x.MovieId == id).FirstOrDefault();
ViewData["id"] = id;
return(View("EditMovie", Movie));
}
public override async Task GetApplications(ApplicationRequest request, IServerStreamWriter <ApplicationResponse> responseStream, ServerCallContext context)
{
var totalTimes = new Dictionary <int, TimeSpan>();
var startTimes = new Dictionary <int, DateTimeOffset>();
// 요청받은 기간 내의 activity만 가져온다.
var activities = from activity in _db.GetActivities()
where activity.Time >= request.Range.Start.ToDateTime() && activity.Time <= request.Range.End.ToDateTime()
where activity.Action == ActionType.Focus || activity.Action == ActionType.Blur
orderby activity.Time
select activity;
Application applicationNow = null;
await foreach (var activity in activities)
{
var application = await _db.GetAsync <Application>(activity.ApplicationId);
switch (activity.Action)
{
case ActionType.Focus:
applicationNow = application;
break;
case ActionType.Blur:
if (applicationNow == null)
{
continue;
}
if (startTimes.ContainsKey(applicationNow.Id))
{
if (!totalTimes.ContainsKey(applicationNow.Id))
{
totalTimes[applicationNow.Id] = TimeSpan.Zero;
}
totalTimes[applicationNow.Id] += activity.Time - startTimes[applicationNow.Id];
startTimes.Remove(applicationNow.Id);
}
break;
default:
continue;
}
}
foreach (var i in totalTimes)
{
var response = new ApplicationResponse()
{
Application = (await _db.GetAsync <Application>(i.Key)).ToRpc(),
TotalTime = Duration.FromTimeSpan(i.Value)
};
await responseStream.WriteAsync(response);
}
}
public IActionResult Waitlist(int movieid)
{
ApplicationResponse Movie = context.Applications.Where(m => m.MovieId == movieid).FirstOrDefault();
context.Applications.Remove(Movie);
context.SaveChanges();
return(View("Edit", Movie));
}
public WithdrawalDateCheckViewModel(ApplicationResponse application, Organisation organisation, Sequence sequence,
List <Section> sections, List <ApplySection> applySections, string backAction, string backController, string backOrganisationId,
int currentVersionIndex)
: base(application, organisation, sequence, sections, applySections, backAction, backController, backOrganisationId)
{
RequestedWithdrawalDate = GetWithdrawalDate(Sections);
CurrentVersionIndex = currentVersionIndex;
Versions = application.ApplyData.Apply.Versions;
}
public async Task WhenTheEmployerSuppliedEmploymentStartDatesFallIntoNextPhaseWindow()
{
var response = new ApplicationResponse
{
Application = new IncentiveApplicationDto
{
AccountLegalEntityId = _data.AccountLegalEntityId,
NewAgreementRequired = true,
Apprenticeships = new IncentiveApplicationApprenticeshipDto[0]
}
};
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath(x => x.Contains($"accounts/{_data.AccountId}/applications"))
.WithParam("includeApprenticeships")
.UsingGet()
)
.RespondWith(
Response.Create()
.WithBody(JsonConvert.SerializeObject(response))
.WithStatusCode(HttpStatusCode.OK));
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath(x => x.Contains($"accounts/{_data.AccountId}/applications"))
.UsingPatch()
)
.RespondWith(
Response.Create()
.WithBody(JsonConvert.SerializeObject(_data.ApplicationResponse))
.WithStatusCode(HttpStatusCode.OK));
var apprenticeships = _data.Apprentices.ToApprenticeshipModel(_hashingService).ToArray();
var values = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("AccountId", _data.HashedAccountId),
new KeyValuePair <string, string>("AccountLegalEntityId", _data.HashedAccountLegalEntityId),
new KeyValuePair <string, string>("ApplicationId", _data.ApplicationId.ToString()),
new KeyValuePair <string, string>("ApprenticeshipIds", apprenticeships[0].Id),
new KeyValuePair <string, string>("EmploymentStartDateDays", "1"),
new KeyValuePair <string, string>("EmploymentStartDateMonths", "9"),
new KeyValuePair <string, string>("EmploymentStartDateYears", "2021"),
new KeyValuePair <string, string>("ApprenticeshipIds", apprenticeships[1].Id),
new KeyValuePair <string, string>("EmploymentStartDateDays", "1"),
new KeyValuePair <string, string>("EmploymentStartDateMonths", "10"),
new KeyValuePair <string, string>("EmploymentStartDateYears", "2021")
};
var url = $"{_data.HashedAccountId}/apply/{_data.ApplicationId}/join-organisation";
_response = await _testContext.WebsiteClient.PostFormAsync(url, values.ToArray());
}
public IActionResult AddRestaurant(ApplicationResponse appResponse)
{
if (ModelState.IsValid)
{
TempStorage.AddApplication(appResponse);
return(View("ConfirmationPage", appResponse));
}
return(View(appResponse));
}
public IActionResult Application(ApplicationResponse appResponse)
{
if (ModelState.IsValid)
{
context.Applications.Add(appResponse);
context.SaveChanges();
}
return(View("Confirmation", appResponse));
}
public IActionResult MovieForm(ApplicationResponse AppResponse)
{
if (ModelState.IsValid)
{
context.Movies.Add(AppResponse);
context.SaveChanges();
}
return(View());
}
public IActionResult MovieList(ApplicationResponse appResponse)
{
IQueryable <ApplicationResponse> queryablemovies = context.Movies.Where(t => t.MovieID == appResponse.MovieID);
foreach (var x in queryablemovies)
{
context.Movies.Remove(x);
}
context.SaveChanges();
return(View("MovieList", context.Movies));
}
public async Task <IActionResult> Create([Bind("ApplicationResponseID,Category,Title,Year,Director,Rating,Edited,Lent_To,Notes")] ApplicationResponse applicationResponse)
{
if (ModelState.IsValid)
{
_context.Add(applicationResponse);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(applicationResponse));
}
private static Task <TResponse> Errors(IEnumerable <ValidationFailure> failures)
{
var response = new ApplicationResponse();
foreach (var failure in failures)
{
response.AddError(failure.ErrorMessage);
}
return(Task.FromResult(response as TResponse));
}
private static void OutputResult <T>(string description, ApplicationResponse <T> result)
{
var obj = new
{
DEMO_STEP = description,
Response = result
};
var json = JsonConvert.SerializeObject(obj, Formatting.Indented);
Trace.TraceInformation(json);
}
public IActionResult FilmSubmission(ApplicationResponse applicationResponse)
{
if (ModelState.IsValid)
{
TempStorage.AddApplication(applicationResponse);
return(View("Confirmation", applicationResponse));
}
else
{
return(View());
}
}
/// <summary>
/// Gets the branch to check for updates.
/// </summary>
/// <param name="info">The application information.</param>
/// <returns>The branch to check for updates, or <c>null</c> otherwise.</returns>
private static ApplicationBranchResponse GetBranch(ApplicationResponse info)
{
var branchName = VersionInfo.GetCurrentBranchName();
if (branchName == null)
return null;
if (IsStandardBranch(branchName))
{
// Current branch is either master or dev - take the user's setting instead
branchName = GetBranchName(App.AssemblyStorage.AssemblySettings.UpdateChannel);
}
return info.ApplicationBranches.FirstOrDefault(b => b.Name == branchName);
}
private void SetupServiceMocks(ApplicationResponse applicationResponse)
{
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath($"/accounts/{_testData.AccountId}/applications/{_testData.ApplicationId}")
.UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/json")
.WithBody(JsonConvert.SerializeObject(applicationResponse,
TestHelper.DefaultSerialiserSettings)));
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath($"/accounts/{_testData.AccountId}/applications/{_testData.ApplicationId}/accountlegalentity")
.UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithHeader("Content-Type", "application/json")
.WithBody(_testData.AccountLegalEntityId.ToString()));
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath($"/accounts/{_testData.AccountId}/legalentities/{_testData.AccountLegalEntityId}")
.UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithBody(JsonConvert.SerializeObject(_testData.LegalEntity, TestHelper.DefaultSerialiserSettings)));
_testContext.EmployerIncentivesApi.MockServer
.Given(
Request
.Create()
.WithPath($"/accounts/{_testData.AccountId}/legalentities")
.UsingGet()
)
.RespondWith(
Response.Create()
.WithStatusCode(HttpStatusCode.OK)
.WithBody(JsonConvert.SerializeObject(_testData.LegalEntities, TestHelper.DefaultSerialiserSettings)));
}
private static string Serialize(ApplicationResponse response)
{
var serializer = new XmlSerializer(typeof(ApplicationResponse));
var buffer = new StringBuilder();
using (var writer = new StringWriter(buffer))
{
serializer.Serialize(writer, response);
}
return(buffer.ToString());
}
/// <summary>
/// Dispatch a response to the other sessions.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
/// <param name="req"></param>
public void ShareApplicationOutput(ApplicationInstanceBase sender, ApplicationResponse e, HttpRequest req)
{
//### verify if application exist
if (applications.ContainsKey(sender.Info.UniqueApplicationName))
{
//### Session manager cointains all instances
SessionManager session = applications[sender.Info.UniqueApplicationName];
foreach (var item in session.SessionList)
{
//### Skip the sender
if (item.Value.ApplicationId != sender.ApplicationId)
{
item.Value.OnNewShareResponse(sender, e, req);
}
}
}
}
/// <summary>
/// This Events is triggered every time one session share a response.
/// Requiere ResponseMode = Share
/// </summary>
/// <param name="sender"></param>
/// <param name="response"></param>
/// <param name="req"></param>
public override void OnNewShareResponse(ApplicationInstanceBase sender, ApplicationResponse response, ApplicationRequest req)
{
}
