public void Setup()
{
LogHelper.ConfigureConsoleLogger();
_department = new Department
{
Name = "Department",
Id = Guid.NewGuid()
};
_departmentRepo = Substitute.For <IGuidKeyedRepository <Department> >();
_branch = new BranchOffice
{
Name = "Branch Office",
Id = Guid.NewGuid()
};
_branchRepo = Substitute.For <IGuidKeyedRepository <BranchOffice> >();
_position = new Position
{
Name = "Position",
Id = Guid.NewGuid()
};
_positionRepo = Substitute.For <IGuidKeyedRepository <Position> >();
}
public UserService(IGuidKeyedRepository<User> userRepository,
ICurrentUserNameProvider currentUserIdProvider,
INewService newService)
{
this.userRepository = userRepository;
this.currentUserNameProvider = currentUserIdProvider;
this.newService = newService;
}
public InspectionCompletionHandler(IServiceProvider services,
IGuidKeyedRepository <Inspection> inspectionRepo,
ILogger <InspectionCompletionHandler> logger
)
{
_inspectionRepo = inspectionRepo;
_services = services;
_logger = logger;
}
public NewService(IGuidKeyedRepository<New> newRepository,
ICurrentUserProvider currentUserProvider,
ICurrentUserNameProvider currentUserNameProvider,
IGuidKeyedRepository<User> userRepository)
{
this.newRepository = newRepository;
this.currentUserNameProvider = currentUserNameProvider;
this.userRepository = userRepository;
}
public BranchOfficeService(
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <BranchOffice> repository,
ILogger <BranchOfficeService> logger
)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
}
public TenantService(
ITenantAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Tenant> repository,
ILogger <TenantService> logger,
ITenantSlugProvider slugProvider
)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
}
public static async Task ValidateRequiredEntityReference <TParent, TChild>(
TParent referringEntity, IGuidKeyedRepository <TChild> referenceRepository, Guid childId)
where TParent : IGuidIdentity, ITenantEntity where TChild : class, IGuidIdentity, ITenantEntity
{
if (childId == Guid.Empty)
{
throw GetMissingRequiredReferenceException <TParent, TChild>(referringEntity, childId);
}
await ValidateOptionalEntityReference(referringEntity, referenceRepository, childId);
}
internal InspectionServiceImpl(
IAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Inspection> repository,
IGuidKeyedRepository <Employee> employeeRepository,
ILogger <BaseService <Inspection> > logger)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
_employeeRepository = employeeRepository;
}
public TestServiceImpl(
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Test> repository,
IGuidKeyedRepository <Inspection> inspectionRepository,
ILogger <TestServiceImpl> logger)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
_inspectionRepository = inspectionRepository;
}
public BaseService(
IAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <TEntity> repository,
ILogger <BaseService <TEntity> > logger)
{
_logger = logger;
Repository = repository;
_tenantAccessChecker = tenantAccessChecker;
_tenantContext = tenantContext;
}
private ITestService GetTestServiceInstance(
IGuidKeyedRepository <Test> repository,
IGuidKeyedRepository <Inspection> inspectionRepo)
{
return(new TestService(
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
repository,
inspectionRepo,
Substitute.For <ILoggerFactory>()));
}
public TestService(
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Test> repository,
IGuidKeyedRepository <Inspection> inspectionRepository,
ILoggerFactory logFactory)
{
_serviceImpl = new TestServiceImpl(tenantAccessChecker, tenantContext, repository, inspectionRepository, logFactory.CreateLogger <TestServiceImpl>());
_repository = repository;
_inspectionRepository = inspectionRepository;
}
public PositionService(
IGuidKeyedRepository <BranchOffice> branchOfficeRepository,
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Position> repository,
ILogger <PositionService> logger
)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
// this is needed for validation of Position model
_branchOfficeRepository = branchOfficeRepository;
}
public void Setup()
{
LogHelper.ConfigureConsoleLogger();
_repository = Substitute.For <IGuidKeyedRepository <BranchOffice> >();
_serviceUnderTest = new BranchOfficeService(
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
_repository,
Substitute.For <ILogger <BranchOfficeService> >()
);
}
private IInspectionService GetServiceInstance(
IGuidKeyedRepository <Inspection> repository,
IGuidKeyedRepository <Test> testRepository,
IGuidKeyedRepository <Employee> employeeRepository)
{
return(new InspectionService(
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
repository,
testRepository,
employeeRepository,
Substitute.For <IInspectionCompletionEventHandler>(),
Substitute.For <ILoggerFactory>()));
}
private IEmployeeService GetEmployeeService(
IGuidKeyedRepository <BranchOffice> branchRepo, IGuidKeyedRepository <Department> deptRepo, IGuidKeyedRepository <Employee> repository,
IGuidKeyedRepository <Position> positionRepo)
{
return(new EmployeeService(
branchRepo,
deptRepo,
positionRepo,
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
repository,
Substitute.For <ILogger <EmployeeService> >()
));
}
public InspectionService(
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Inspection> repository,
IGuidKeyedRepository <Test> testRepository,
IGuidKeyedRepository <Employee> employeeRepository,
IInspectionCompletionEventHandler completionHandler,
ILoggerFactory loggerFactory)
{
_serviceImpl = new InspectionServiceImpl(
tenantAccessChecker, tenantContext, repository, employeeRepository, loggerFactory.CreateLogger <BaseService <Inspection> >());
_completionHandler = completionHandler;
_repository = repository;
_testRepository = testRepository;
}
public EmployeeService(
IGuidKeyedRepository <BranchOffice> branchOfficeRepository,
IGuidKeyedRepository <Department> departmentRepository,
IGuidKeyedRepository <Position> positionRepository,
ITenantEntityAccessChecker tenantAccessChecker,
IAccessScopeFilter tenantContext,
IGuidKeyedRepository <Employee> repository,
ILogger <EmployeeService> logger
)
: base(tenantAccessChecker, tenantContext, repository, logger)
{
// this is needed for validation of Position model
_branchOfficeRepository = branchOfficeRepository;
_positionRepository = positionRepository;
_departmentRepository = departmentRepository;
}
public void Setup()
{
LogHelper.ConfigureConsoleLogger();
_branch = new BranchOffice
{
Name = "Branch Office",
Id = Guid.NewGuid()
};
_branchOfficeRepository = Substitute.For <IGuidKeyedRepository <BranchOffice> >();
_deptRepo = Substitute.For <IGuidKeyedRepository <Department> >();
_deptRepo.Query().Returns((new Department[0]).AsEntityAsyncQueryable());
_serviceUnderTest = new DepartmentService(
_branchOfficeRepository,
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
_deptRepo,
Substitute.For <ILogger <DepartmentService> >()
);
}
public void Setup()
{
LogHelper.ConfigureConsoleLogger();
_branchOfficeRepo = Substitute.For <IGuidKeyedRepository <BranchOffice> >();
_branch = new BranchOffice
{
Name = "Branch office",
Id = Guid.NewGuid()
};
_branchOfficeRepo.SetupRepositoryWithEntity(_branch);
_repository = Substitute.For <IGuidKeyedRepository <Position> >();
_repository.Query().Returns((new Position[0]).AsEntityAsyncQueryable());
_serviceUnderTest = new PositionService(
_branchOfficeRepo,
Substitute.For <ITenantEntityAccessChecker>(),
Substitute.For <IAccessScopeFilter>(),
_repository,
Substitute.For <ILogger <PositionService> >()
);
}
public static async Task ValidateOptionalEntityReference <TParent, TChild>(
TParent referringEntity, IGuidKeyedRepository <TChild> referenceRepository, Guid childId)
where TParent : IGuidIdentity, ITenantEntity where TChild : class, IGuidIdentity, ITenantEntity
{
if (childId == Guid.Empty)
{
return;
}
var child = await referenceRepository.GetAsync(childId);
if (child == null || child.TenantId != referringEntity.TenantId)
{
throw GetModelValidationException <TParent, TChild>(referringEntity, childId);
}
//catch (UnauthorizedAccessException ex)
//{
// throw GetModelValidationException<TParent, TChild>(referringEntity, childId, ex);
//}
//catch (ItemNotFoundException ex)
//{
// throw GetModelValidationException<TParent, TChild>(referringEntity, childId, ex);
//}
}
public CurrentUserProvider(IGuidKeyedRepository<User> userRepository)
{
this.userRepository = userRepository;
}
