public async Task Test_Passing_Null_Who_Throws_Exception() { // ARRANGE IOrganisation organisation = Create.Organisation(); Mock <ILogger <IOrganisationService> > loggerMock = MockFactory.CreateLoggerMock <IOrganisationService>(); DbContextOptions <DataContext> dbOptions = TestUtils.DbContextOptionsInMemory <CreateAsyncTests>( nameof(this.Test_Passing_Valid_Values)); await using DataContext dataContext = new DataContext(dbOptions); IVirtualBridgeData data = MockFactory.CreateVirtualBridgeData( dataContext); IOrganisationService service = new OrganisationService( loggerMock.Object, data); // ACT await service.CreateAsync( who : null !, auditEvent : EAuditEvent.OrganisationMaintenance, organisation : organisation) .ConfigureAwait(false); }
public async Task <IActionResult> UploadLogo(Guid organisationId) { var scope = AuthenticationService.GetScope(User); var organisation = await OrganisationService.GetOrganisation(scope, organisationId); if (organisation == null) { return(NotFound()); } var file = Request.Form.Files.FirstOrDefault(); if (file == null) { return(BadRequest()); } var result = new Result(true); using (var stream = file.OpenReadStream()) { //Upload the file var path = new OrganisationLogoFilePath(organisationId, file.FileName); //file.FileName = stored as meta var storageName = await FileStorageService.AddFileAsync(path, stream); //Update the organisation organisation.Config.Branding.LogoStorageName = storageName; await OrganisationService.UpdateOrganisation(scope, organisation); result.Tag = storageName; } return(Ok(result)); }
public new virtual void SetUp() { base.SetUp(); FormsAuthenticationService.GetLoggedInOrganisationId().Returns(OrganisationId); OrganisationsServiceAgent.Get(OrganisationId).Returns(_organisationFromServiceAgent); _result = OrganisationService.Get(); }
// GET: Organisation public ActionResult Index(Guid id) { var orgService = new OrganisationService(); var model = orgService.GetOrganisation(id); return(View(model.data)); }
public BatchController(BatchService batchService, OrganisationService organisationService, DepartmentService departmentService, CampaignService campaignService) { this.batchService = batchService; this.organisationService = organisationService; this.departmentService = departmentService; this.campaignService = campaignService; }
/// <summary> /// Returns a list of application questions that are applicable to an application /// based on the application lines and items linked to the application /// </summary> /// <param name="applicationId">Guid for the application to check</param> /// <returns>A simplified array of application questions and application line ids that are applicable</returns> public List <ApplicationQuestionsAndLines> GetApplicableApplicationQuestions(Guid applicationId) { // 1. Prepare query, start with application line QueryExpression query = new QueryExpression(defra_applicationline.EntityLogicalName); query.ColumnSet.AddColumns(defra_applicationline.Fields.defra_applicationlineId); query.Criteria.AddCondition(defra_applicationline.Fields.StateCode, ConditionOperator.Equal, (int)defra_applicationlineState.Active); query.Criteria.AddCondition(defra_applicationline.Fields.defra_applicationId, ConditionOperator.Equal, applicationId); // 2. Link to Item LinkEntity linkItem = query.AddLink(defra_item.EntityLogicalName, defra_item.Fields.defra_itemId, defra_item.Fields.defra_itemId); linkItem.LinkCriteria.AddCondition(defra_item.Fields.StateCode, ConditionOperator.Equal, (int)defra_itemState.Active); // 3. Link to Item Application Question linker table LinkEntity linkItemApplicationQuestion = linkItem.AddLink(defra_item_application_question.EntityLogicalName, defra_item.Fields.defra_itemId, defra_item_application_question.Fields.defra_itemid); linkItemApplicationQuestion.LinkCriteria.AddCondition(defra_item_application_question.Fields.StateCode, ConditionOperator.Equal, (int)defra_item_application_questionState.Active); linkItemApplicationQuestion.Columns.AddColumns(defra_item_application_question.Fields.defra_scope); linkItemApplicationQuestion.EntityAlias = "linker"; // 4. Link to Application Question LinkEntity linkQuestion = linkItemApplicationQuestion.AddLink( defra_applicationquestion.EntityLogicalName, defra_item_application_question.Fields.defra_applicationquestionid, defra_applicationquestion.Fields.defra_applicationquestionId); linkQuestion.EntityAlias = "question"; linkQuestion.Columns.AddColumns(defra_applicationquestion.Fields.defra_applicationquestionId); linkQuestion.LinkCriteria.AddCondition(defra_applicationquestion.Fields.StateCode, ConditionOperator.Equal, (int)defra_applicationquestionState.Active); // Talk to CRM, get results EntityCollection resultEntities = OrganisationService.RetrieveMultiple(query); // No results if (resultEntities?.Entities == null || resultEntities.Entities.Count < 1) { return(null); } // Return simple model result string scopeAttributeName = $"{linkItemApplicationQuestion.EntityAlias}.{defra_item_application_question.Fields.defra_scope}"; string questionIdAttributeName = $"{linkQuestion.EntityAlias}.{defra_applicationquestion.Fields.defra_applicationquestionId}"; return(resultEntities.Entities.Select(entity => new ApplicationQuestionsAndLines { ApplicationLineId = entity.GetAttributeId(defra_applicationline.Fields.defra_applicationlineId), ApplicationQuestionId = entity.GetAliasedAttributeId(questionIdAttributeName), Scope = entity.GetAliasedOptionSetValue(scopeAttributeName), }).ToList()); }
public new virtual void SetUp() { base.SetUp(); ApplicationService.GetByOrganisationId().Returns(_applicationsFromService); OrganisationService.Get().Returns(_organisationFromService); LabelCollectionRetriever.Get("DashboardPage").Returns(_labelsFromCollectionRetriever); _result = DashboardViewModelGetter.Get(); }
public async Task <IActionResult> Index(string filters = null) { var scope = AuthenticationService.GetScope(User, User.IsSuperAdmin()); var queryOptions = new OrganisationQueryOptions(scope, filters); var pagedItems = await OrganisationService.GetOrganisations(queryOptions); return(Ok(pagedItems)); }
public static OrganisationController CreateOrganisationController() { var unitOfWork = new UnitOfWork(); var service = new OrganisationService(unitOfWork, new OrganisationViewModelToOrganisationConverter(unitOfWork), new OrganisationToOrganisationDtoConverter()); return(new OrganisationController(service)); }
public AddOrganisationManualConfirmController( IDataRepository dataRepository, OrganisationService organisationService, RegistrationRepository registrationRepository) { this.dataRepository = dataRepository; this.organisationService = organisationService; this.registrationRepository = registrationRepository; }
public async Task InsertOrganisation() { var options = TestHelper.GetDbContext("InsertOrganisation"); TestHelper.InsertApplications(options); var company1 = TestHelper.InsertCompany(options); var config1 = new Config() { CompanyIds = new List <Guid>() { company1.Id }, VATRegistered = true, VATRegistrationDate = DateTime.Now, }; //Given var organisation = new OrganisationEdit() { Name = "Organsation 1", ApplicationIds = new List <Guid>() { Application.CLIENT_ID }, Config = config1 }; using (var context = new DataContext(options)) { var service = new OrganisationService(context); //When var scope = TestHelper.GetScopeOptions(Guid.NewGuid()); scope.IgnoreScope = true; var result = await service.InsertOrganisation(scope, organisation); //Then Assert.True(result.Success); var actual = await context.Organisation.FindAsync(((OrganisationEdit)result.Tag).Id); Assert.Equal(organisation.Name, actual.Name); Assert.Single(actual.ApplicationIds); Assert.Equal(organisation.ApplicationIds.Single(), actual.ApplicationIds.Single()); Assert.Equal(organisation.Config.VATRegistered, actual.Config.VATRegistered); Assert.Equal(organisation.Config.VATRegistrationDate, actual.Config.VATRegistrationDate); Assert.Single(actual.Config.CompanyIds); Assert.Equal(organisation.Config.CompanyIds.Single(), actual.Config.CompanyIds.Single()); //Scope check scope = TestHelper.GetScopeOptions(Guid.NewGuid()); result = await service.InsertOrganisation(scope, organisation); Assert.False(result.Success); } }
/// <summary> /// Returns a list of task definitions that apply to an application /// </summary> /// <param name="applicationId">Application Guid</param> /// <param name="filterByTaskTypeIds">Task Types to filter by</param> /// <returns>List of defra_applicationtaskdefinition ids </returns> public List <ApplicationTaskAndDefinitionId> GetApplicationTaskIdsLinkedToApplication(Guid applicationId, params Guid[] filterByTaskTypeIds) { TracingService.Trace($"GetApplicationTaskIdsLinkedToApplication({applicationId}, {filterByTaskTypeIds}) Start..."); // Select defra_applicationtask records var query = new QueryExpression(defra_applicationtask.EntityLogicalName); query.ColumnSet.AddColumns(defra_applicationtask.Fields.defra_applicationtaskId, defra_applicationtask.Fields.defra_applicationtaskdefinitionid); query.Criteria.AddCondition(defra_applicationtask.Fields.StateCode, ConditionOperator.Equal, (int)defra_applicationtaskState.Active); query.Criteria.AddCondition(defra_applicationtask.Fields.defra_applicationid, ConditionOperator.Equal, applicationId); // Link to defra_applicationtaskdefinition var linkToTaskDefinition = query.AddLink( defra_applicationtaskdefinition.EntityLogicalName, defra_applicationtask.Fields.defra_applicationtaskdefinitionid, defra_applicationtaskdefinition.Fields.defra_applicationtaskdefinitionId); linkToTaskDefinition.LinkCriteria.AddCondition( defra_applicationtaskdefinition.Fields.StateCode, ConditionOperator.Equal, (int)defra_applicationtaskdefinitionState.Active); // Filter by specific Task Types (e.g. duly making checklist) if (filterByTaskTypeIds != null && filterByTaskTypeIds.Length > 0) { var filterByTaskType = new FilterExpression(); linkToTaskDefinition.LinkCriteria.AddFilter(filterByTaskType); filterByTaskType.FilterOperator = LogicalOperator.Or; foreach (Guid taskTypeId in filterByTaskTypeIds) { filterByTaskType.AddCondition(defra_tasktype.Fields.defra_tasktypeId, ConditionOperator.Equal, taskTypeId); } } // Query CRM EntityCollection entityCollectionResult = OrganisationService.RetrieveMultiple(query); List <ApplicationTaskAndDefinitionId> retVal = null; // Return a list of defra_applicationtaskdefinition ids if (entityCollectionResult?.Entities != null) { TracingService.Trace($"GetApplicationTaskIdsLinkedToApplication() Returning data"); retVal = entityCollectionResult.Entities .Select(e => new ApplicationTaskAndDefinitionId { ApplicationTaskId = e.GetAttributeIdOrDefault(defra_applicationtask.Fields.defra_applicationtaskId), ApplicationTaskDefinitionId = e.GetAttributeIdOrDefault(defra_applicationtask.Fields.defra_applicationtaskdefinitionid) }).ToList(); } retVal?.ForEach(t => TracingService.Trace($"GetApplicationTaskIdsLinkedToApplication - ApplicationTaskId={t.ApplicationTaskId}, ApplicationTaskDefinitionId={t.ApplicationTaskDefinitionId}")); TracingService.Trace("GetApplicationTaskIdsLinkedToApplication() Done"); return(retVal); }
public void Setup() { _mockOrganisationRepository = new Mock <IOrganisationRepository>(); _mockUnitOfWork = new MockUnitOfWork { OrganisationRepository = _mockOrganisationRepository.Object }; _organisationService = new OrganisationService(_mockUnitOfWork); }
public AddOrganisationFoundController( IDataRepository dataRepository, ICompaniesHouseAPI companiesHouseApi, OrganisationService organisationService, RegistrationRepository registrationRepository) { this.dataRepository = dataRepository; this.companiesHouseApi = companiesHouseApi; this.organisationService = organisationService; this.registrationRepository = registrationRepository; }
/// <summary> /// Creates an application document record /// </summary> /// <param name="fileName"></param> /// <param name="source"></param> /// <param name="applicationId"></param> /// <param name="documentName"></param> /// <param name="documentLink"></param> /// <param name="caseId"></param> /// <param name="emailId"></param> /// <param name="createdById"></param> /// <param name="owningUserId"></param> /// <param name="owningTeamId"></param> /// <returns></returns> public Guid CreateApplicationDocument( string documentName, string documentLink, string fileName, defra_ApplicationDocumentSource source, Guid?applicationId, Guid?caseId, Guid?emailId, Guid?createdById, Guid?owningUserId, Guid?owningTeamId) { TracingService.Trace($"CreateApplicationDocument() documentName={documentName}, documentLink={documentLink}, fileName={fileName}, source={source}, applicationId={applicationId}, caseId={caseId}, emailId={emailId}, owningUserId={owningUserId}, owningTeamId={owningTeamId}"); // Prep the entity Entity appDocumentEntity = new Entity(defra_applicationdocument.EntityLogicalName); if (applicationId.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_applicationid, new EntityReference(defra_application.EntityLogicalName, applicationId.Value)); } if (caseId.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_caseid, new EntityReference(Incident.EntityLogicalName, caseId.Value)); } if (emailId.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_emailid, new EntityReference(Email.EntityLogicalName, emailId.Value)); } if (createdById.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.CreatedBy, new EntityReference(Incident.EntityLogicalName, createdById.Value)); appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.CreatedOnBehalfBy, new EntityReference(Incident.EntityLogicalName, createdById.Value)); } if (owningUserId.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.OwnerId, new EntityReference(SystemUser.EntityLogicalName, owningUserId.Value)); } else if (owningTeamId.HasValue) { appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.OwnerId, new EntityReference(Team.EntityLogicalName, owningTeamId.Value)); } appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_name, documentName); appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_filename, fileName); appDocumentEntity.Attributes.Add(defra_applicationdocument.Fields.defra_url, documentLink); // Get CRM to Create record return(OrganisationService.Create(appDocumentEntity)); }
/// <summary> /// Sets the status for any entity /// </summary> /// <param name="entityReference">The entity ref that will change status</param> /// <param name="state">New state</param> /// <param name="status">New status</param> protected void SetStatusAndState(EntityReference entityReference, int state, int status) { SetStateRequest request = new SetStateRequest { State = new OptionSetValue((int)state), Status = new OptionSetValue((int)status), EntityMoniker = entityReference }; OrganisationService.Execute(request); }
public void Test_GetAvailableCollectionTypes_NoCollectionFound() { var dbContextOptions = GetContextOptions(); var service = new OrganisationService(dbContextOptions); SetupData(dbContextOptions); var result = service.GetAvailableCollectionTypesAsync(99999).Result; result.Should().NotBeNull(); result.Count().Should().Be(0); }
public void Test_GetAvailableCollections_NotFound_Ukprn() { var dbContextOptions = GetContextOptions(); var service = new OrganisationService(dbContextOptions); SetupData(dbContextOptions); var result = service.GetAvailableCollectionsAsync(99999, "ILR").Result.ToList(); result.Should().NotBeNull(); result.Count.Should().Be(0); }
/// <summary> /// Deactivates a defra_applicationtask record /// </summary> /// <param name="applicationTaskIdGuid">defra_applicationtask id</param> public void DeactivateApplicationTask(Guid applicationTaskIdGuid) { TracingService.Trace($"GetApplicationTaskIdsLinkedToApplication({applicationTaskIdGuid})"); var state = new SetStateRequest { State = new OptionSetValue((int)defra_applicationtaskState.Inactive), Status = new OptionSetValue((int)defra_applicationtask_StatusCode.Inactive), EntityMoniker = new EntityReference(defra_applicationtask.EntityLogicalName, applicationTaskIdGuid) }; OrganisationService.Execute(state); }
public async Task <IActionResult> Get(Guid organisationId) { var scope = AuthenticationService.GetScope(User, User.IsSuperAdmin()); var model = await OrganisationService.GetOrganisation(scope, organisationId); if (model == null) { return(NotFound()); } return(Ok(model)); }
public async Task <IActionResult> Insert([FromBody] OrganisationEdit organisation) { var scope = AuthenticationService.GetScope(User, User.IsSuperAdmin()); var result = await OrganisationService.InsertOrganisation(scope, organisation); if (!result.Success) { return(BadRequest(result.ValidationFailures)); } return(Ok(result)); }
public void Test_GetCollection_Success() { var dbContextOptions = GetContextOptions(); var service = new OrganisationService(dbContextOptions); SetupData(dbContextOptions); var result = service.GetCollectionAsync(1000, "test coll").Result; result.Should().NotBeNull(); result.CollectionType.Should().Be("ILR"); result.IsOpen.Should().Be(true); result.CollectionTitle.Should().Be("test coll"); }
public void Test_GetAvailableCollectionTypes_Success() { var dbContextOptions = GetContextOptions(); var service = new OrganisationService(dbContextOptions); SetupData(dbContextOptions); var result = service.GetAvailableCollectionTypesAsync(1000).Result.ToList(); result.Should().NotBeNull(); result.Count.Should().Be(1); result[0].Description.Should().Be("ILR collection"); result[0].Type.Should().Be("ILR"); }
private async Task LoadApiInfo(bool rethrowException = true) { try { if (string.IsNullOrEmpty(Settings.Default.ApiUrl) || string.IsNullOrEmpty(txtAuthorization.Text)) { return; } tsProgress.Visible = true; _logger.Write("Retriving organisations"); var service = new OrganisationService(txtUrl.Text); var result = await service.Get(txtAuthorization.Text); try { cbOrganisations.BeginUpdate(); cbOrganisations.Items.Clear(); cbOrganisations.Items.AddRange(result.Cast <object>().ToArray()); if (cbOrganisations.Items.Count > 0) { cbOrganisations.SelectedIndex = 0; } _logger.Write($"{cbOrganisations.Items.Count} organisation retrived"); } finally { cbOrganisations.EndUpdate(); } } catch (Exception) { _logger.Write("Fail to load organisations"); if (rethrowException) { throw; } } finally { tsProgress.Visible = false; } }
private void UpdateButtonOrganisationHome_Click(object sender, EventArgs e) { string email = VolunteerEmailTextBox.Text; if (VolunteerNameTextBox.Text == "") { MessageBox.Show("Please enter a Organisation name!"); } else if (VoluunteerPasswordTextBox.Text == "") { MessageBox.Show("This can not be empty!"); } else if (VolunteerConfirmPasswordTextBox.Text == "") { MessageBox.Show("This can not be empty!"); } else { if (email.Contains("@gmail.com") || email.Contains("@outlook.com") || email.Contains("@yahoo.com")) { if (VolunteerConfirmPasswordTextBox.Text != VoluunteerPasswordTextBox.Text) { MessageBox.Show("Passwords need to be matched"); } else { OrganisationService organisationService = new OrganisationService(); int result = organisationService.UpdateExistingOrganisation(VolunteerEmailTextBox.Text, VoluunteerPasswordTextBox.Text, VolunteerNameTextBox.Text); if (result == 1) { MessageBox.Show("Volunteer organisation Updated"); Login login = new Login(); login.Show(); this.Hide(); } else { MessageBox.Show("Update Failed"); } } } else { MessageBox.Show("Invalid email"); } } }
public async Task Test_Passing_Valid_Values() { // ARRANGE IWho who = Create.Who(); IOrganisation organisation = Create.Organisation(); Mock <ILogger <IOrganisationService> > loggerMock = MockFactory.CreateLoggerMock <IOrganisationService>(); Mock <IOrganisationRepository> organisationRepositoryMock = MockFactory.CreateRepositoryMock <IOrganisationRepository>(); organisationRepositoryMock.Setup(x => x.CreateAsync( who, It.IsAny <AuditHeaderWithAuditDetails>(), organisation)) .Returns(Task.CompletedTask); DbContextOptions <DataContext> dbOptions = TestUtils.DbContextOptionsInMemory <CreateAsyncTests>( nameof(this.Test_Passing_Valid_Values)); await using DataContext dataContext = new DataContext(dbOptions); IVirtualBridgeData data = MockFactory.CreateVirtualBridgeData( dataContext, organisationRepository: organisationRepositoryMock.Object); IOrganisationService service = new OrganisationService( loggerMock.Object, data); // ACT await service.CreateAsync( who : who, auditEvent : EAuditEvent.OrganisationMaintenance, organisation : organisation) .ConfigureAwait(false); // ASSERT organisationRepositoryMock.Verify( x => x.CreateAsync( who, It.IsAny <IAuditHeaderWithAuditDetails>(), organisation), Times.Once); }
public static List <SelectListItem> GetOrganisationSelectList() { var organisationService = new OrganisationService(); var listOfOrgs = new List <SelectListItem>(); listOfOrgs = organisationService.GetAllActive().Select(y => new SelectListItem() { Text = y.Name, Value = y.Id.ToString() }).ToList(); listOfOrgs.Insert(0, new SelectListItem { Text = "", Value = "" }); return(listOfOrgs); }
public new virtual void SetUp() { base.SetUp(); FormsAuthenticationService.GetLoggedInOrganisationId().Returns(InvalidOrganisationId); OrganisationsServiceAgent.Get(InvalidOrganisationId) .Returns(x => { throw new ItemNotFoundException(); }); try { OrganisationService.Get(); } catch (OrganisationIdNotValidException ex) { _exception = ex; } }
public void Test_With_Valid_Values() { // ARRANGE IMock <ILogger <IOrganisationService> > loggerMock = MockFactory.CreateLoggerMock <IOrganisationService>(); IMock <IVirtualBridgeData> dataMock = new Mock <IVirtualBridgeData>(MockBehavior.Strict); // ACT _ = new OrganisationService( logger: loggerMock.Object, data: dataMock.Object); // ASSERT Assert.IsTrue(true); }
private async Task SendZeroEntriesEmail( ScopeOptions scope, Guid commissionStatementId, CommissionStatementTemplateEdit template, Attachment attachment) { var organisation = await OrganisationService.GetOrganisation(scope, scope.OrganisationId); var user = await UserService.GetUser(scope, scope.UserId); var statement = await CommissionStatementService.GetCommissionStatement(scope, commissionStatementId); var company = await DirectoryLookupService.GetCompany(statement.CompanyId.Value); await EmailService.SendImportCommissionZeroEntriesEmail(Utils.GetEnvironment(), organisation, user, company, statement, template, attachment); }
public virtual void SetUp() { OrganisationService = new OrganisationService(new OrganisationRepository()); }
public virtual void SetUp() { OrganisationRepository = MockRepository.GenerateMock<IOrganisationRepository>(); OrganisationService = new OrganisationService(OrganisationRepository); }