/// <inheritdoc />
public async Task DownloadApplicationLogsAsync(ApplicationDetails application, string targetDirectory)
{
application.ArgumentNotNull("application");
targetDirectory.ArgumentNotNullOrEmpty("targetDirectory");
await DownloadApplicationLogsAsync(application.ApplicationId, application.User, targetDirectory);
}
public void Before_each_test()
{
_applicationDetails = new ApplicationDetails
{
UKPRN = 10001234,
UkrlpLookupDetails = new ProviderDetails
{
ProviderName = "Provider Legal Name",
ContactDetails = new List <ProviderContact>
{
new ProviderContact
{
ContactType = "L",
ContactWebsiteAddress = "www.myweb.com",
ContactAddress = new ContactAddress
{
Address1 = "Address line 1",
Address2 = "Address line 2",
Address3 = "Address line 3",
Address4 = "Address line 4",
Town = "Town",
PostCode = "TS1 1ST"
}
}
},
ProviderAliases = new List <ProviderAlias>
{
new ProviderAlias {
Alias = "Provider alias"
}
}
},
CompanySummary = new CompaniesHouseSummary()
};
}
private ModerationOutcomeViewModel CreateModerationOutcomeViewModel(ApplicationDetails applicationDetails, GetOversightReviewResponse oversightReview)
{
var result = new ModerationOutcomeViewModel
{
ModerationReviewStatus = applicationDetails.ModerationReviewStatus,
ModerationOutcomeMadeOn = applicationDetails.ModerationOutcomeMadeOn,
ModeratedBy = applicationDetails.ModeratedBy,
ModerationComments = applicationDetails.ModerationComments
};
if (oversightReview?.ModerationApproved != null)
{
if (applicationDetails.ModerationReviewStatus == ModerationReviewStatus.Pass)
{
result.GovernanceOutcome = oversightReview.ModerationApproved.Value
? PassFailStatus.Passed
: PassFailStatus.Failed;
}
else if (applicationDetails.ModerationReviewStatus == ModerationReviewStatus.Fail)
{
result.GovernanceOutcome = oversightReview.ModerationApproved.Value
? PassFailStatus.Failed
: PassFailStatus.Passed;
}
}
return(result);
}
public ApplicationDetails GetSubscriberContext(ClaimsPrincipal userContext)
{
ClaimsIdentity claims = new ClaimsIdentity(userContext.Claims);
if (claims.Claims.Count() > 0)
{
ApplicationDetails transaction = new ApplicationDetails
{
AppId = int.Parse(claims.Claims.Where(c => c.Type == ClaimTypes.PrimarySid).First().Value),
AppUid = Guid.Parse(claims.Claims.Where(c => c.Type == ClaimTypes.SerialNumber).First().Value),
AppDescription = claims.Claims.Where(c => c.Type == ClaimTypes.UserData).First().Value,
Owner = (Owner)int.Parse(claims.Claims.Where(c => c.Type == ClaimTypes.Role).First().Value),
AccountStatus = (AccountStatus)int.Parse(claims.Claims.Where(c => c.Type == "AccountStatus").First().Value),
};
if (transaction.AppId == 0)
{
throw new OperationCanceledException();
}
return(transaction);
}
return(null);
}
public override void Initialize(IApplicationContext applicationContext)
{
base.Initialize(applicationContext);
ConnectionString = this.ApplicationContext.GetProperty("DatabaseConnectionString") as string;
SqlCommand AppCommand = new SqlCommand();
SqlConnection conn = new SqlConnection(ConnectionString);
conn.Open();
AppCommand.Connection = conn;
AppCommand.CommandText = "select * from bts_application";
try
{
SqlDataReader myReader = null;
myReader = AppCommand.ExecuteReader();
while (myReader.Read())
{
ApplicationDetails temp = new ApplicationDetails();
temp.nID = myReader["nID"].ToString();
temp.nvcName = myReader["nvcName"].ToString();
temp.nvcDescription = myReader["nvcDescription"].ToString();
temp.isSystem = StrToBool(myReader["isSystem"].ToString());
temp.isDefault = StrToBool(myReader["isDefault"].ToString());
temp.DateModified = ObjectToDateTime(myReader["DateModified"], DateTime.Now);
appDetails.Add(temp);
}
conn.Close();
applicationContext.SetProperty("SelectedApps", appDetails);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public void GetApplicationsAvailableToCentreByCategory_returns_expected_values()
{
// Given
const int centreId = 101;
int? categoryId = null;
var expectedFirstApplication = new ApplicationDetails
{
ApplicationId = 1,
ApplicationName = "Entry Level - Win XP, Office 2003/07 OLD",
PLAssess = false,
DiagAssess = false,
CourseTopicId = 3,
CategoryName = "Office 2007",
CourseTopic = "Microsoft Office",
};
// When
var result = courseDataService.GetApplicationsAvailableToCentreByCategory(centreId, categoryId).ToList();
// Then
using (new AssertionScope())
{
result.Should().HaveCount(61);
result.First().Should().BeEquivalentTo(expectedFirstApplication);
}
}
public void GetApplicationsByBrandId_returns_expected_values()
{
// Given
const int brandId = 1;
var expectedFirstApplication = new ApplicationDetails()
{
ApplicationId = 1,
ApplicationName = "Entry Level - Win XP, Office 2003/07 OLD",
PLAssess = false,
DiagAssess = false,
CourseTopicId = 3,
CategoryName = "Office 2007",
CourseTopic = "Microsoft Office",
CreatedDate = new DateTime(2015, 9, 7, 12, 18, 11, 810),
};
// When
var result = courseDataService.GetApplicationsByBrandId(brandId).ToList();
// Then
using (new AssertionScope())
{
result.Should().HaveCount(50);
result.First().Should().BeEquivalentTo(expectedFirstApplication);
}
}
public void ListApplicationContainers()
{
string testAppId = "testAppId";
string testAppAttemptId = "testAppAttemptId";
ApplicationGetResult appResult = new ApplicationGetResult();
appResult.ApplicationId = testAppId;
ApplicationDetails app = new ApplicationDetails(appResult);
ApplicationAttemptGetResult appAttemptResult = new ApplicationAttemptGetResult();
appAttemptResult.ApplicationAttemptId = testAppAttemptId;
ApplicationAttemptDetails appAttemptDetails = new ApplicationAttemptDetails(appAttemptResult, app);
var containers = RunMockedRestCall(
m => m.ListApplicationContainersAsync(testAppId, testAppAttemptId),
GetContainerListResult(),
c => c.ListApplicationContainersAsync(appAttemptDetails));
foreach (var container in containers)
{
Assert.IsTrue(container.ParentApplicationAttempt.ApplicationAttemptId == testAppAttemptId);
Assert.IsTrue(container.ParentApplicationAttempt.ParentApplication.ApplicationId == testAppId);
}
}
public void LoadData(object param = null)
{
try
{
// Load data for each of the workspaces
Settings.LoadData();
Trovesaurus.LoadData();
GetMoreMods.LoadData();
MyMods.LoadData();
ModderTools.LoadData();
_dataLoaded = true;
// Process saved Trove URI to handle case when Trove URI link clicked before application was fully loaded
if (!string.IsNullOrEmpty(_savedTroveUri))
{
ProcessTroveUri(_savedTroveUri);
}
// Process a URI from the command line args if there are any
var args = ApplicationDetails.GetTroveUri();
if (!string.IsNullOrEmpty(args))
{
ProcessTroveUri(args);
}
}
catch (Exception ex) { log.Error("Error loading main window data", ex); }
finally { _dataLoaded = true; }
}
private static void CreateCharityCommissionQuestionAnswers(ApplicationDetails applicationDetails, List <PreambleAnswer> questions)
{
var trusteeManualEntryRequired = string.Empty;
if (applicationDetails.CharitySummary != null && applicationDetails.CharitySummary.TrusteeManualEntryRequired)
{
trusteeManualEntryRequired = applicationDetails.CharitySummary.TrusteeManualEntryRequired.ToString().ToUpper();
}
questions.Add(new PreambleAnswer
{
QuestionId = RoatpPreambleQuestionIdConstants.CharityCommissionTrusteeManualEntry,
Value = trusteeManualEntryRequired
});
questions.Add(new PreambleAnswer
{
QuestionId = RoatpPreambleQuestionIdConstants.CharityCommissionCharityName,
Value = applicationDetails.CharitySummary?.Name
});
var incorporationDate = string.Empty;
if (applicationDetails.CharitySummary != null && applicationDetails.CharitySummary.RegistrationDate.HasValue)
{
incorporationDate = applicationDetails.CharitySummary.RegistrationDate.Value.ToString();
}
questions.Add(new PreambleAnswer
{
QuestionId = RoatpPreambleQuestionIdConstants.CharityCommissionRegistrationDate,
Value = incorporationDate
});
}
public void CheckForUpdates(bool update = false)
{
try
{
if (update || lastUpdateCheck < DateTime.Now.AddMinutes(-29.5))
{
var updateAvailable = ApplicationDetails.UpdateAvailable();
lastUpdateCheck = DateTime.Now;
if (update)
{
if (updateAvailable)
{
UpdateApplication();
}
else
{
log.Info("No new application updates available");
}
}
else if (updateAvailable)
{
Action updateApp = UpdateApplication;
MainWindowViewModel.Instance.ViewCommandManager.InvokeLoaded("ShowTrayTip", "New application update available: please quit and restart the application to receive the update", updateApp);
}
}
}
catch (Exception ex) { log.Error("Error checking for updates", ex); }
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var appSettings = new AppSettings();
Configuration.Bind("AppSettings", appSettings);
services.AddSingleton(appSettings);
var applicationDetails = new ApplicationDetails
{
ApplicationName = appSettings.Name,
Environment = appSettings.Environment,
Version = appSettings.Version
};
services.AddSingleton <ErrorHandlingSettings>();
services.AddSingleton <CorrelationIdSettings>();
services.AddSingleton(applicationDetails);
Log.Logger = new LoggerConfiguration().ReadFrom.Configuration(Configuration).CreateLogger();
services.AddLogging(loggingBuilder => loggingBuilder.AddSerilog(dispose: true));
// AutomMapper configuration
var mapperConfig = new MapperConfigurationExpression();
mapperConfig.ConfigureAutoMapper();
services.ConfigureBusinessServices(Configuration, mapperConfig);
Mapper.Initialize(mapperConfig);
services.AddSingleton(Mapper.Instance);
services.AddCors(x => x.AddPolicy("AllowAnyOrigin", y =>
{
y.AllowAnyOrigin();
y.AllowAnyMethod();
y.AllowAnyHeader();
}));
services.Configure <IISOptions>(x => x.AutomaticAuthentication = true);
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
services.AddSwaggerGen(x =>
{
x.SwaggerDoc("v1", new Info
{
Title = "My League REST services",
Version = "v1",
Description = "A REST service with commands to manage a sports league.",
Contact = new Contact
{
Name = "Chad Wescott",
Email = "*****@*****.**"
}
});
x.EnableAnnotations();
var xmlFile = $"{Assembly.GetExecutingAssembly().GetName().Name}.xml";
var xmlPath = Path.Combine(AppContext.BaseDirectory, xmlFile);
x.IncludeXmlComments(xmlPath);
});
}
public FilterableApplicationSelectListItemViewModel(ApplicationDetails details, int?selectedApplicationId = null)
{
ApplicationId = details.ApplicationId;
ApplicationName = details.ApplicationName;
Category = details.CategoryName;
Topic = details.CourseTopic;
Selected = details.ApplicationId == selectedApplicationId;
}
public SetCourseDetailsViewModel(ApplicationDetails application)
{
ApplicationId = application.ApplicationId;
ApplicationName = application.ApplicationName;
PostLearningAssessment = application.PLAssess;
DiagAssess = application.DiagAssess;
IsAssessed = true;
}
public async Task Applications_starts_a_new_application_if_no_applications_for_that_user()
{
_apiClient.Setup(x => x.GetApplications(It.IsAny <Guid>(), It.IsAny <bool>())).ReturnsAsync(new List <Domain.Entities.Apply>());
var applicationDetails = new ApplicationDetails
{
UKPRN = 10002000,
UkrlpLookupDetails = new ProviderDetails
{
ProviderName = "Provider name",
ContactDetails = new List <ProviderContact>
{
new ProviderContact
{
ContactType = "L",
ContactAddress = new ContactAddress
{
Address1 = "Address line 1",
PostCode = "PS1 1ST"
}
}
},
VerificationDetails = new List <VerificationDetails>
{
new VerificationDetails
{
VerificationAuthority = VerificationAuthorities.SoleTraderPartnershipAuthority,
PrimaryVerificationSource = true
}
}
},
ApplicationRoute = new ApplicationRoute
{
Id = 1
},
RoatpRegisterStatus = new OrganisationRegisterStatus
{
ProviderTypeId = 1
}
};
_sessionService.Setup(x => x.Get <ApplicationDetails>(It.IsAny <string>())).Returns(applicationDetails);
var applicationId = Guid.NewGuid();
var qnaResponse = new StartQnaApplicationResponse
{
ApplicationId = applicationId
};
_qnaApiClient.Setup(x => x.StartApplication(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(qnaResponse).Verifiable();
_apiClient.Setup(x => x.StartApplication(It.IsAny <StartApplicationRequest>())).ReturnsAsync(applicationId).Verifiable();
await _controller.Applications();
_qnaApiClient.VerifyAll();
_apiClient.VerifyAll();
}
public void UpdateApplication()
{
try
{
log.Info("Updating application to latest version");
ApplicationDetails.UpdateApplication();
}
catch (Exception ex) { log.Error("Error updating application", ex); }
}
public Application EditApplication(int id, string url, ApplicationDetails appDetails, LoggedInUserDetails user)
{
//TODO Check whether user has access to application
// Check whether organisation is active
if (!user.Organization.IsActive)
{
throw new BaseException("Your organization is inactive. Please check if your organization has approved Legal Officer. For more details contact DataLinker administrator.");
}
// Check whether user has access to application
var application = _security.CheckAccessToApplication(user, id);
var originalIsIntroducedAsIndustryGood = application.IsIntroducedAsIndustryGood;
// Check for the duplication of the name
if (IsApplicationExistsForThisOrganization(appDetails.Name, application.Name, user))
{
throw new BaseException("Application name already in use.");
}
// Setup application details
application.Name = appDetails.Name;
application.Description = appDetails.Description;
application.IsIntroducedAsIndustryGood = appDetails.IsIntroducedAsIndustryGood;
application.UpdatedAt = GetDate;
application.UpdatedBy = user.ID.Value;
// Setup industry good settings
if (!appDetails.IsIntroducedAsIndustryGood && application.IsVerifiedAsIndustryGood)
{
application.IsVerifiedAsIndustryGood = false;
}
// Check whether verification requred
var isVerificationRequired = !originalIsIntroducedAsIndustryGood && appDetails.IsIntroducedAsIndustryGood;
// Setup application if it's marked as industry good
if (isVerificationRequired)
{
// Deactivate service for verification process
application.IsActive = false;
}
// Save changes
_applications.Update(application);
// Check whether notification for verification is required
if (isVerificationRequired)
{
// Send notification to admin about new verification request
_notifications.Admin.NewIndustryGoodApplicationInBackground(url, application.OrganizationID);
}
return(application);
}
public void ShouldFailEditApplicationForNotOrganizationMember()
{
controller.LoggedInUser = new LoggedInUserDetails(user)
{
Organization = new LoggedInOrganization(otherOrganization)
};
var model = new ApplicationDetails(activeService);
controller.Edit(activeService.ID, model);
}
public void ShouldFailEditApplicationIfOrganizationIsNotActive()
{
organization.IsActive = false;
controller.LoggedInUser = new LoggedInUserDetails(user)
{
Organization = new LoggedInOrganization(organization)
};
var model = new ApplicationDetails(activeService);
controller.Edit(activeService.ID, model);
}
protected SecurityTokenResult GetSubscribersToken(ApplicationDetails appAuth)
{
try
{
SecurityKey = new SymmetricSecurityKey(Encoding.Default.GetBytes(ConfigGlobal.GetValue("Application", "AppSecretKey")));
TokenHandler = new JwtSecurityTokenHandler();
if (appAuth != null &&
appAuth.AppId > 0)
{
///Criamos uma identidade
ClaimsIdentity claimsIdentity = new ClaimsIdentity();
///Claim de acesso
Collection <Claim> claims = new Collection <Claim>
{
new Claim(ClaimTypes.PrimarySid, appAuth.AppId.ToString()),
new Claim(ClaimTypes.SerialNumber, appAuth.AppUid.ToString()),
new Claim(ClaimTypes.UserData, appAuth.AppDescription.ToString()),
new Claim(ClaimTypes.Role, ((int)appAuth.Owner).ToString()),
new Claim("AccountStatus", ((int)appAuth.AccountStatus).ToString()),
};
///Configura os Token
var tokenDescriptor = new SecurityTokenDescriptor
{
Issuer = ConfigGlobal.GetValue("Application", "Issuer"),
Subject = claimsIdentity,
SigningCredentials = new SigningCredentials(SecurityKey, SecurityAlgorithms.HmacSha256, SecurityAlgorithms.Sha256Digest)
};
///Gera o Token e retorna a string
SecurityToken token = TokenHandler.CreateToken(tokenDescriptor);
var tokenString = TokenHandler.WriteToken(token);
///Retorna
return(new SecurityTokenResult
{
Create = DateTime.UtcNow,
Token = tokenString,
Expires = DateTime.UtcNow.AddHours(1),
});
}
else
{
return(null);
}
}
catch
{
return(null);
}
}
public void ShouldFailEditApplicationIfApplicationNameAlreadyInUse()
{
controller.LoggedInUser = new LoggedInUserDetails(user)
{
Organization = new LoggedInOrganization(organization)
};
var model = new ApplicationDetails(activeService);
model.Name = notActiveService.Name;
controller.Edit(activeService.ID, model);
}
public void ShouldReturnNotFoundWhenEditNotExistingApplication()
{
controller.LoggedInUser = new LoggedInUserDetails(user)
{
Organization = new LoggedInOrganization(organization)
};
var model = new ApplicationDetails(new Application());
var result = (HttpStatusCodeResult)controller.Edit(0, model);
Assert.IsTrue(result.StatusCode == (int)HttpStatusCode.NotFound);
}
public void ShouldAllowAdminEditApplication()
{
controller.LoggedInUser = new LoggedInUserDetails(sysAdmin)
{
Organization = new LoggedInOrganization(organization)
};
var model = new ApplicationDetails(activeService);
controller.Edit(activeService.ID, model);
appService.Verify(i => i.Update(It.IsAny <Application>()));
}
private FinancialHealthOutcomeViewModel CreateFinancialHealthOutcomeViewModel(
ApplicationDetails applicationDetails)
{
return(new FinancialHealthOutcomeViewModel
{
FinancialReviewStatus = applicationDetails.FinancialReviewStatus,
FinancialGradeAwarded = applicationDetails.FinancialGradeAwarded,
FinancialHealthAssessedOn = applicationDetails.FinancialHealthAssessedOn,
FinancialHealthAssessedBy = applicationDetails.FinancialHealthAssessedBy,
FinancialHealthComments = applicationDetails.FinancialHealthComments,
FinancialHealthExternalComments = applicationDetails.FinancialHealthExternalComments
});
}
public void SetApplicationAndResetModels(ApplicationDetails application)
{
if (Application == application)
{
return;
}
Application = application;
CourseDetailsData = null;
CourseOptionsData = null;
CourseContentData = null;
SectionContentData = null;
}
public async Task <ApplicationDetails> UpdateApplicationFeatureAsync <TFeatureValue>(
ClientContext context, ApplicationDetails applicationDetails,
Expression <Func <ApplicationFeatures, TFeatureValue> > feature, TFeatureValue value)
{
await Configure.AwaitFalse();
var member = feature.Body as MemberExpression;
if (member == null)
{
throw new ArgumentException($"Expression '{feature}' does not refer to a property.", nameof(feature));
}
var property = member.Member as PropertyInfo;
if (property == null)
{
throw new ArgumentException($"Expression '{feature}' does not refer to a property.", nameof(feature));
}
var originalValue = property.GetValue(applicationDetails.Features);
if (value.Equals(originalValue))
{
return(applicationDetails);
}
var jsonProperty = property.GetCustomAttribute <JsonPropertyAttribute>();
var featureType = jsonProperty?.PropertyName ?? _resolver.GetResolvedPropertyName(property.Name);
var featureValue = typeof(TFeatureValue) == typeof(bool)
? ((bool)(object)value ? "yes" : "no")
: value.ToString();
var uriBuilder = new AppleDeveloperRequestUriBuilder(
new RestUri(this.UrlProvider.UpdateApplicationUrl, new { platform = applicationDetails.Platform }));
uriBuilder.AddQueryValues(new Dictionary <string, string> {
{ "teamId", applicationDetails.TeamId },
{ "displayId", applicationDetails.Id },
{ "featureType", featureType },
{ "featureValue", featureValue }
});
var request = RestRequest.Post(uriBuilder.ToUri());
var response = await this.SendAsync <Result <ApplicationDetails> >(context, request);
this.CheckResultForErrors(response.Content);
property.SetValue(applicationDetails.Features, value);
return(applicationDetails);
}
private static void CreateLevyEmployerQuestionAnswers(ApplicationDetails applicationDetails, List <PreambleAnswer> questions)
{
var levyPayingEmployer = string.Empty;
if (applicationDetails.LevyPayingEmployer == "Y")
{
levyPayingEmployer = "TRUE";
}
questions.Add(new PreambleAnswer
{
QuestionId = RoatpPreambleQuestionIdConstants.LevyPayingEmployer,
Value = levyPayingEmployer
});
}
public async Task Application_status_updated_and_register_not_updated_for_a_successful_already_active_or_fitness_for_funding_appeal_and_gateway_fail(string status)
{
var application = new ApplicationDetails
{
ApplicationId = _applicationId, GatewayReviewStatus = GatewayReviewStatus.Fail
};
_applicationApiClient.Setup(x => x.GetApplicationDetails(_applicationId)).ReturnsAsync(application);
await _orchestrator.RecordAppeal(_applicationId, status, UserId, UserName, InternalComments, ExternalComments);
_applicationApiClient.Verify(x => x.RecordAppeal(It.Is <RecordAppealOutcomeCommand>(y => y.ApplicationId == _applicationId)), Times.Once);
_roatpRegisterApiClient.Verify(x => x.UpdateApplicationDeterminedDate(It.Is <UpdateOrganisationApplicationDeterminedDateRequest>(y => y.OrganisationId == _registerStatus.OrganisationId)), Times.Never);
}
public void GetApplicationDetails()
{
string testAppId = "testAppId";
ApplicationGetResult appResult = new ApplicationGetResult();
appResult.ApplicationId = testAppId;
ApplicationDetails app = RunMockedRestCall(
m => m.GetApplicationDetailsAsync(testAppId),
appResult,
c => c.GetApplicationDetailsAsync(testAppId));
Assert.IsTrue(app.ApplicationId == testAppId);
}
public static ApplicationDetails GetApplicationDetailsViewModel(string applicationID)
{
ApplicationDetails applicationDetails = null;
try
{
using (_certonaService = new CertonaServiceClient())
{
try
{
UserDTO user = FormsAuthenticationWrapper.User;
var appDetailRequest = new GetApplicationDetailsRequest {
ApplicationID = applicationID, User = user
};
var appDetailResponse = _certonaService.GetApplicationDetails(appDetailRequest);
if (appDetailResponse.Success && appDetailResponse.ApplicationDetails != null)
{
applicationDetails = new ApplicationDetails
{
Name = appDetailResponse.ApplicationDetails.Name,
Description = appDetailResponse.ApplicationDetails.Description,
ApplicationID = applicationID,
URL = HtmlExtensions.UrlPrependHttp(appDetailResponse.ApplicationDetails.ApplicationURL),
Classifications = appDetailResponse.ApplicationDetails.Classifications
};
}
}
catch (TimeoutException exception)
{
_certonaService.Abort();
throw;
}
catch (CommunicationException exception)
{
_certonaService.Abort();
throw;
}
}
}
catch (Exception ex)
{
}
return(applicationDetails);
}
public ActionResult ApplicationDetails(ApplicationDetails applicationDetails)
{
ApplicationDetails model = _applicationDetailsService.UpdateApplicationDetails(applicationDetails);
return Json(new{Success = model.UpdateSuccess, ApplicationDetails = model});
}
public ApplicationDetails UpdateApplicationDetails(ApplicationDetails model)
{
ApplicationDetailsValidator applicationDetailsValidator = new ApplicationDetailsValidator(_bankAgencyRepository);
//validate the form data
ValidationResult validationResult = applicationDetailsValidator.Validate(model);
model.UpdateSuccess = true;
//if it's invalid prepare the error list to be handled on frontend side
if(!validationResult.IsValid)
{
if(validationResult.Errors != null && validationResult.Errors.Count > 0)
{
model.NumberOfErrors = validationResult.Errors.Count;
model.UpdateSuccess = false;
model.Errors = new List<ValidationFailure>();
List<string> sections = new List<string>();
for (int index = 0; index < validationResult.Errors.Count; index++)
{
ValidationFailure failure = validationResult.Errors[index];
//we need to know which sections have any errors so on the frontend we can mark them as red
GetSectionName(failure.PropertyName, sections);
model.Errors.Add(failure);
}
model.SectionsWithErrors = sections;
}
return model;
}
//Updates section
//Update Applicant
_applicantRepository.UpdateApplicant(model.Applicant);
//Update Application
_applicationRepository.UpdateApplication(model.Application);
//Update Employment
_employmentRepository.UpdateEmployment(model.Employment);
//Update Address
_addressRepository.UpdateAddress(model.Address);
//Update Contacts
List<Contact> contacts = new List<Contact>();
contacts.Add(model.HomePhone);
contacts.Add(model.EmailAddress);
contacts.Add(model.MobilePhone);
_contactRepository.UpdateContacts(contacts, model.Applicant.ApplicantId, model.Application.ApplicationId);
//Update Bank Account
_bankAccountRepository.UpdateBankAccount(model.BankAccount);
//Update Bank Card
_bankCardRepository.UpdateBankCard(model.BankCard);
return model;
}
