public async Task <Result> InsertOrganisation(ScopeOptions scope, OrganisationEdit organisation)
{
var validator = new OrganisationValidator(_context, true, organisation.Id);
var result = validator.Validate(organisation).GetResult();
if (!result.Success)
{
return(result);
}
//Only for super admins
if (!scope.IgnoreScope)
{
return(new Result());
}
var entity = MapModelToEntity(organisation);
await _context.Organisation.AddAsync(entity);
await _context.SaveChangesAsync();
organisation.Id = entity.Id;
result.Tag = organisation;
return(result);
}
public async Task Get()
{
var organisation = new OrganisationEdit()
{
Id = Guid.NewGuid(),
Name = "organisation_1",
Config = new Config()
};
var service = new Mock <IOrganisationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
service.Setup(c => c.GetOrganisation(It.IsAny <ScopeOptions>(), It.Is <Guid>(m => m == organisation.Id.Value)))
.ReturnsAsync(organisation);
var controller = new OrganisationsController(authService.Object, service.Object, null);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var result = await controller.Get(organisation.Id.Value);
var okResult = Assert.IsType <OkObjectResult>(result);
var returnValue = Assert.IsType <OrganisationEdit>(okResult.Value);
Assert.Same(organisation, returnValue);
}
public async Task <Result> UpdateOrganisation(ScopeOptions scope, OrganisationEdit organisation)
{
var validator = new OrganisationValidator(_context, false, organisation.Id);
var result = validator.Validate(organisation).GetResult();
if (!result.Success)
{
return(result);
}
//Only organisation scope
if (scope.Scope == Scope.Branch || scope.Scope == Scope.User)
{
return(new Result());
}
var entity = await ScopeQuery
.GetOrganisationEntityQuery(_context, scope)
.FirstOrDefaultAsync(o => o.Id == organisation.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(organisation, entity);
await _context.SaveChangesAsync();
return(result);
}
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);
}
}
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));
}
private OrganisationEntity MapModelToEntity(OrganisationEdit model, OrganisationEntity enity = null)
{
if (enity == null)
{
enity = new OrganisationEntity();
}
enity.Name = model.Name;
enity.ApplicationIds = model.ApplicationIds;
enity.Config = model.Config;
return(enity);
}
public async Task <Result> SendImportCommissionUnknownCommissionTypesEmail(
string environment,
OrganisationEdit organisation,
UserEdit user,
Company company,
CommissionStatementEdit statement,
CommissionStatementTemplateEdit template,
List <string> unknownCommissionTypes,
Attachment attachment)
{
var result = new Result();
var response = await _email
.To(_options.Emails.CommissionImportAlerts.To)
.Subject("One Advisor - ALERT: Unknown Commission Types Found")
.UsingTemplate(ImportUnknownCommissionTypes.Template,
new
{
Environment = environment,
OrganisationName = organisation.Name,
UserFirstName = user.FirstName,
UserLastName = user.LastName,
Username = user.UserName,
UserEmail = user.Email,
CompanyName = company.Name,
StatementDate = statement.Date.Value.ToLongDateString(),
StatementStatus = statement.Processed.Value ? "Processed" : "Processing",
StatementTemplateName = template.Name,
CommissionTypes = unknownCommissionTypes
}
)
.Attach(new FluentEmail.Core.Models.Attachment()
{
Filename = attachment.FileName,
ContentType = attachment.ContentType,
Data = attachment.Data
})
.SendAsync();
result.Success = response.Successful;
if (!result.Success)
{
result.Errors = response.ErrorMessages;
return(result);
}
return(result);
}
public async Task Update()
{
var organisation = new OrganisationEdit()
{
Id = Guid.NewGuid(),
Name = "organisation_1",
Config = new Config()
};
var service = new Mock <IOrganisationService>();
var authService = TestHelper.MockAuthenticationService(Scope.Branch);
var result = new Result()
{
Success = true
};
ScopeOptions options = null;
OrganisationEdit updated = null;
service.Setup(c => c.UpdateOrganisation(It.IsAny <ScopeOptions>(), It.Is <OrganisationEdit>(m => m == organisation)))
.Callback((ScopeOptions o, OrganisationEdit u) =>
{
updated = u;
options = o;
})
.ReturnsAsync(result);
var controller = new OrganisationsController(authService.Object, service.Object, null);
controller.ControllerContext = TestHelper.GetControllerContext(new ClaimsPrincipal());
var actual = await controller.Update(organisation.Id.Value, organisation);
Assert.Same(organisation, updated);
Assert.Equal(Scope.Branch, options.Scope);
var okResult = Assert.IsType <OkObjectResult>(actual);
var returnValue = Assert.IsType <Result>(okResult.Value);
Assert.Same(result, returnValue);
}
public async Task UpdateOrganisation()
{
var options = TestHelper.GetDbContext("UpdateOrganisation");
TestHelper.InsertApplications(options);
var company1 = TestHelper.InsertCompany(options);
var company2 = TestHelper.InsertCompany(options);
var config1 = new Config()
{
CompanyIds = new List <Guid>()
{
company1.Id
},
VATRegistered = false,
VATRegistrationDate = null
};
var config2 = new Config()
{
CompanyIds = new List <Guid>()
{
company1.Id
},
VATRegistered = false,
VATRegistrationDate = null
};
//Given
var org1 = new OrganisationEntity {
Id = Guid.NewGuid(), Name = "Org 1", Config = config1, ApplicationIds = new List <Guid>()
{
Application.CLIENT_ID
}
};
var org2 = new OrganisationEntity {
Id = Guid.NewGuid(), Name = "Org 2", Config = config2, ApplicationIds = new List <Guid>()
{
Application.CLIENT_ID
}
};
using (var context = new DataContext(options))
{
context.Organisation.Add(org1);
context.Organisation.Add(org2);
context.SaveChanges();
}
var user1 = TestHelper.InsertUserDetailed(options, org2);
var config2Updated = new Config()
{
CompanyIds = new List <Guid>()
{
company2.Id
},
VATRegistered = true,
VATRegistrationDate = DateTime.Now,
};
var organisation = new OrganisationEdit()
{
Id = org2.Id,
Name = "Org 2 Updated",
ApplicationIds = new List <Guid>()
{
Application.CLIENT_ID, Application.COMMISSION_ID
},
Config = config2Updated
};
using (var context = new DataContext(options))
{
var service = new OrganisationService(context);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.UpdateOrganisation(scope, organisation);
//Then
Assert.True(result.Success);
var actual = await context.Organisation.FindAsync(organisation.Id);
Assert.Equal(organisation.Name, actual.Name);
Assert.Equal(2, organisation.ApplicationIds.Count());
Assert.Contains(Application.CLIENT_ID, organisation.ApplicationIds);
Assert.Contains(Application.COMMISSION_ID, organisation.ApplicationIds);
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
organisation.Id = org1.Id;
result = await service.UpdateOrganisation(scope, organisation);
//Then
Assert.False(result.Success);
}
}
