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);
}
