public SchoolDistrictManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
PropertyRepository = repositories.Obtain<IPropertyRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
SubjectRepository = repositories.Obtain<ISubjectRepository>();
PriorityRepository = repositories.Obtain<IPriorityRepository>();
FulfillmentStatusRepository = repositories.Obtain<IFulfillmentStatusRepository>();
ProviderRepository = repositories.Obtain<IProviderRepository>();
SchoolRepository = repositories.Obtain<ISchoolRepository>();
PrivateHealthDataViewEventRepository = repositories.Obtain<IPrivateHealthDataViewEventRepository>();
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public SchoolDistrictManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
PropertyRepository = repositories.Obtain <IPropertyRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
SubjectRepository = repositories.Obtain <ISubjectRepository>();
PriorityRepository = repositories.Obtain <IPriorityRepository>();
FulfillmentStatusRepository = repositories.Obtain <IFulfillmentStatusRepository>();
ProviderRepository = repositories.Obtain <IProviderRepository>();
SchoolRepository = repositories.Obtain <ISchoolRepository>();
PrivateHealthDataViewEventRepository = repositories.Obtain <IPrivateHealthDataViewEventRepository>();
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public void Register(IRepositoryContainer container)
{
foreach (var registerSubProcess in _registerSubProcessesChain)
{
registerSubProcess.Invoke(container);
}
}
private void InitializeEducationContainer()
{
MockRepositoryContainer = MockRepository.GenerateMock <IRepositoryContainer>();
MockRepositoryContainer.Expect(m => m.Obtain <IUserRepository>()).Return(MockUserRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ISchoolRepository>()).Return(MockSchoolRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IRoleRepository>()).Return(MockRoleRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IUserRoleRepository>()).Return(MockUserRoleRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IProviderRepository>()).Return(MockProviderRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IProgramRepository>()).Return(MockProgramRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ICustomDataOriginRepository>()).Return(MockCustomDataOriginRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ICustomFieldCategoryRepository>()).Return(MockCustomFieldCategoryRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ICustomFieldValueRepository>()).Return(MockCustomFieldValueRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ICustomFieldTypeRepository>()).Return(MockCustomFieldTypeRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ICustomFieldRepository>()).Return(MockCustomFieldRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IStudentRepository>()).Return(MockStudentRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IPropertyRepository>()).Return(MockPropertyRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceTypeRepository>()).Return(MockServiceTypeRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ISubjectRepository>()).Return(MockSubjectRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IPriorityRepository>()).Return(MockPriorityRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IFulfillmentStatusRepository>()).Return(MockFulfillmentStatusRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IStudentAssignedOfferingRepository>()).Return(MockStudentAssignedOfferingRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceOfferingRepository>()).Return(MockServiceOfferingRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceAttendanceRepository>()).Return(MockServiceAttendanceRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceTypeCategoryRepository>()).Return(MockCategoryRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceRequestRepository>()).Return(MockServiceRequestRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IServiceRequestFulfillmentRepository>()).Return(MockServiceRequestFulfillmentRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IUserAccessChangeEventRepository>()).Return(MockUserAccessChangeEventRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IEulaAgreementRepository>()).Return(MockEulaAgreementRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IEulaAcceptanceRepository>()).Return(MockEulaAcceptanceRepository);
MockRepositoryContainer.Expect(m => m.Obtain <IPrivateHealthDataViewEventRepository>()).Return(MockPrivateHealthDataViewEventRepository);
MockRepositoryContainer.Expect(m => m.Obtain <ILoginEventRepository>()).Return(MockLoginEventRepository);
}
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
CustomDataOriginRepository = repositories.Obtain <ICustomDataOriginRepository>();
CustomFieldCategoryRepository = repositories.Obtain <ICustomFieldCategoryRepository>();
CustomFieldRepository = repositories.Obtain <ICustomFieldRepository>();
CustomFieldTypeRepository = repositories.Obtain <ICustomFieldTypeRepository>();
CustomFieldValueRepository = repositories.Obtain <ICustomFieldValueRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName);
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
protected CustomFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
RepositoryContainer = repositories;
CustomDataOriginRepository = repositories.Obtain<ICustomDataOriginRepository>();
CustomFieldCategoryRepository = repositories.Obtain<ICustomFieldCategoryRepository>();
CustomFieldRepository = repositories.Obtain<ICustomFieldRepository>();
CustomFieldTypeRepository = repositories.Obtain<ICustomFieldTypeRepository>();
CustomFieldValueRepository = repositories.Obtain<ICustomFieldValueRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
DataFileBlobContainer = blobClient.CreateContainer(DataFileBlobContainerName);
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public AccountManager(IWindsorContainer windsorContainer, IEmailConfirmationManager emailConfirmationManager, IDataTableBinder dataTableBinder, IUserAuditor auditor)
{
if (windsorContainer == null)
{
throw new ArgumentNullException("windsorContainer");
}
if (emailConfirmationManager == null)
{
throw new ArgumentNullException("emailConfirmationManager");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
if (auditor == null)
{
throw new ArgumentNullException("auditor");
}
IRepositoryContainer repositoryContainer = windsorContainer.Resolve <IRepositoryContainer>();
UserRepository = repositoryContainer.Obtain <IUserRepository>();
SchoolRepository = repositoryContainer.Obtain <ISchoolRepository>();
ProviderRepository = repositoryContainer.Obtain <IProviderRepository>();
RoleRepository = repositoryContainer.Obtain <IRoleRepository>();
UserRoleRepository = repositoryContainer.Obtain <IUserRoleRepository>();
UserAccessChangeEventRepository = repositoryContainer.Obtain <IUserAccessChangeEventRepository>();
LoginEventRepository = repositoryContainer.Obtain <ILoginEventRepository>();
EulaAgreementRepository = repositoryContainer.Obtain <IEulaAgreementRepository>();
RepositoryContainer = repositoryContainer;
EmailConfirmationManager = emailConfirmationManager;
DataTableBinder = dataTableBinder;
Auditor = auditor;
}
public void InitializeTest()
{
_TestTransaction = new TransactionScope();
try
{
IRepositoryContainer educationContainer = MockRepository.GenerateMock <IRepositoryContainer>();
EducationDataContext = new EducationDataContext();
educationContainer.Expect(m => m.Obtain <IUserRepository>()).Return(new UserRepository(EducationDataContext));
educationContainer.Expect(m => m.Obtain <IEulaAgreementRepository>()).Return(new EulaAgreementRepository(EducationDataContext));
MockWindsorContainer = MockRepository.GenerateMock <IWindsorContainer>();
MockWindsorContainer.Expect(m => m.Resolve <IRepositoryContainer>()).Return(educationContainer);
AccountManager = new AccountManager(MockWindsorContainer, MockRepository.GenerateMock <IEmailConfirmationManager>(), new DataTableBinder(), new UserAuditor());
MockDependecyResolver = MockRepository.GenerateMock <IDependencyResolver>();
MockDependecyResolver.Expect(m => m.GetService(typeof(IAccountManager))).Return(AccountManager);
DependencyResolver.SetResolver(MockDependecyResolver);
}
catch (Exception)
{
_TestTransaction.Dispose();
_TestTransaction = null;
if (EducationDataContext != null)
{
EducationDataContext.Dispose();
EducationDataContext = null;
}
throw;
}
}
public ReliantRepositoryHandlerGFactory(
IRepositoryContainer<TDbContext> repositoryGFactory,
TDbContext dbContext
)
{
this.dbContext = dbContext;
this.repositoryGFactory = repositoryGFactory;
}
public SalesAggregate(
IRepositoryContainer repository,
IMapper mapper
)
{
_repository = repository;
_mapper = mapper;
}
public IndependentRepositoryHandlerGFactory(
IRepositoryContainer <TDbContext> repositoryGFactory,
Func <TDbContext> dbContextFactory
)
{
this.repositoryGFactory = repositoryGFactory;
this.dbContextFactory = dbContextFactory;
}
public static IRepositoryContainer GetRepository()
{
if (Repository == null)
{
Repository = CreateRepository();
}
return(Repository);
}
public UserService(IMapper mapper, ISystemClock systemClock, IPasswordService passwordService,
IJwtTokenService jwtTokenService, IRepositoryContainer respositoryContainer)
{
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
_systemClock = systemClock ?? throw new ArgumentNullException(nameof(systemClock));
_passwordService = passwordService ?? throw new ArgumentNullException(nameof(passwordService));
_jwtTokenService = jwtTokenService ?? throw new ArgumentNullException(nameof(jwtTokenService));
_repositoryContainer = respositoryContainer ?? throw new ArgumentNullException(nameof(respositoryContainer));
}
public AgreementManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
EulaAgreementRepository = repositories.Obtain <IEulaAgreementRepository>();
UserRepository = repositories.Obtain <IUserRepository>();
}
public AgreementManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
EulaAgreementRepository = repositories.Obtain<IEulaAgreementRepository>();
UserRepository = repositories.Obtain<IUserRepository>();
}
public WidgetManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
SchoolRepository = repositories.Obtain<ISchoolRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
ServiceRequestRepository = repositories.Obtain<IServiceRequestRepository>();
}
public WidgetManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
SchoolRepository = repositories.Obtain <ISchoolRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
ServiceRequestRepository = repositories.Obtain <IServiceRequestRepository>();
}
private RepositoryLocator()
{
this._ssContainer = new RepositoryContainer();
this._msContainer = new RepositoryContainer();
var ssRepositoryContainerRegister = new SqlServerRepositoryContainerRegister();
ssRepositoryContainerRegister.Register(this._ssContainer);
var msRepositoryContainerRegister = new MySqlRepositoryContainerRegister();
msRepositoryContainerRegister.Register(this._msContainer);
}
public ScheduledServiceManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
StudentAssignedOfferingRepository = repositories.Obtain <IStudentAssignedOfferingRepository>();
ServiceOfferingRepository = repositories.Obtain <IServiceOfferingRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
CategoryRepository = repositories.Obtain <IServiceTypeCategoryRepository>();
}
public ScheduledServiceManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>();
ServiceOfferingRepository = repositories.Obtain<IServiceOfferingRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
CategoryRepository = repositories.Obtain<IServiceTypeCategoryRepository>();
}
private static SchoolDistrictManager CreateTargetWithEmptyLookupLists()
{
IRepositoryContainer mockRepositoryContainer = MockRepository.GenerateMock <IRepositoryContainer>();
IStudentRepository mockStudentRepository = MockRepository.GenerateMock <IStudentRepository>();
IProviderRepository mockProviderRepository = MockRepository.GenerateMock <IProviderRepository>();
IDataTableBinder mockDataTableBinder = MockRepository.GenerateMock <IDataTableBinder>();
IUserAuditor mockUserAuditor = MockRepository.GenerateMock <IUserAuditor>();
mockStudentRepository.Expect(m => m.Items).Return(Enumerable.Empty <Student>().AsQueryable());
mockProviderRepository.Expect(m => m.Items).Return(Enumerable.Empty <Provider>().AsQueryable());
mockRepositoryContainer.Expect(m => m.Obtain <IProviderRepository>()).Return(mockProviderRepository);
mockRepositoryContainer.Expect(m => m.Obtain <IStudentRepository>()).Return(mockStudentRepository);
return(new SchoolDistrictManager(mockRepositoryContainer, mockDataTableBinder, mockUserAuditor));
}
public ReliantOrmHandlerGFactory(
IRepositoryContainer <TDbContext> repositoryGFactory,
IOrmContainer <TDbContext> ormGFactory,
IEntityMetaServiceContainer entityMetaServiceContainer,
IAuditVisitor auditVisitor,
TDbContext dbContext
)
{
this.dbContext = dbContext;
this.auditVisitor = auditVisitor;
this.repositoryGFactory = repositoryGFactory;
this.ormGFactory = ormGFactory;
this.entityMetaServiceContainer = entityMetaServiceContainer;
}
public ServiceRequestManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
ServiceRequestRepository = repositories.Obtain <IServiceRequestRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
SubjectRepository = repositories.Obtain <ISubjectRepository>();
PriorityRepository = repositories.Obtain <IPriorityRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
FulfillmentStatusRepository = repositories.Obtain <IFulfillmentStatusRepository>();
ServiceRequestFulfillmentRepository = repositories.Obtain <IServiceRequestFulfillmentRepository>();
}
public ServiceRequestManager(IRepositoryContainer repositories)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
RepositoryContainer = repositories;
ServiceRequestRepository = repositories.Obtain<IServiceRequestRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
SubjectRepository = repositories.Obtain<ISubjectRepository>();
PriorityRepository = repositories.Obtain<IPriorityRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
FulfillmentStatusRepository = repositories.Obtain<IFulfillmentStatusRepository>();
ServiceRequestFulfillmentRepository = repositories.Obtain<IServiceRequestFulfillmentRepository>();
}
public ServiceAttendanceManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
RepositoryContainer = repositories;
ServiceAttendanceRepository = repositories.Obtain<IServiceAttendanceRepository>();
StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>();
SubjectRepository = repositories.Obtain<ISubjectRepository>();
DataTableBinder = dataTableBinder;
}
public ServiceAttendanceManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
RepositoryContainer = repositories;
ServiceAttendanceRepository = repositories.Obtain <IServiceAttendanceRepository>();
StudentAssignedOfferingRepository = repositories.Obtain <IStudentAssignedOfferingRepository>();
SubjectRepository = repositories.Obtain <ISubjectRepository>();
DataTableBinder = dataTableBinder;
}
public ServiceOfferingManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
RepositoryContainer = repositories;
ProviderRepository = repositories.Obtain<IProviderRepository>();
ServiceTypeRepository = repositories.Obtain<IServiceTypeRepository>();
StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>();
ServiceOfferingRepository = repositories.Obtain<IServiceOfferingRepository>();
CategoryRepository = repositories.Obtain<IServiceTypeCategoryRepository>();
DataTableBinder = dataTableBinder;
}
/// <summary>
/// Open session for target
/// </summary>
/// <param name="sessionFatory"></param>
/// <param name="container"></param>
public static void OpenSession(ISessionFactory sessionFatory, IRepositoryContainer container)
{
Expect.IsNotNull(sessionFatory, nameof(sessionFatory));
Expect.IsNotNull(container, nameof(container));
var repositories = container.Repositories
.Where(r => r != null && r.Session == null)
.ToArray();
if (repositories.Length > 0)
{
var session = sessionFatory.OpenSession();
foreach (var repos in repositories)
{
repos.Session = session;
}
}
}
public ServiceOfferingManager(IRepositoryContainer repositories, IDataTableBinder dataTableBinder)
{
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
if (dataTableBinder == null)
{
throw new ArgumentNullException("dataTableBinder");
}
RepositoryContainer = repositories;
ProviderRepository = repositories.Obtain <IProviderRepository>();
ServiceTypeRepository = repositories.Obtain <IServiceTypeRepository>();
StudentAssignedOfferingRepository = repositories.Obtain <IStudentAssignedOfferingRepository>();
ServiceOfferingRepository = repositories.Obtain <IServiceOfferingRepository>();
CategoryRepository = repositories.Obtain <IServiceTypeCategoryRepository>();
DataTableBinder = dataTableBinder;
}
/// <summary>
/// Close session
/// </summary>
/// <param name="container"></param>
public static void CloseSession(IRepositoryContainer container)
{
Expect.IsNotNull(container, nameof(container));
var repositories = container.Repositories
.Where(r => r != null && r.Session != null)
.ToArray();
var sessions = repositories.Select(r => r.Session).Distinct().ToArray();
foreach (var session in sessions)
{
session.Dispose();
}
foreach (var repos in repositories)
{
repos.Session = null;
}
}
protected BaseFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
{
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
BlobClient = blobClient;
RepositoryContainer = repositories;
ServiceOfferingRepository = repositories.Obtain<IServiceOfferingRepository>();
StudentRepository = repositories.Obtain<IStudentRepository>();
StudentAssignedOfferingRepository = repositories.Obtain<IStudentAssignedOfferingRepository>();
SubjectRepository = repositories.Obtain<ISubjectRepository>();
ServiceAttendanceRepository = repositories.Obtain<IServiceAttendanceRepository>();
}
protected BaseFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
{
if (blobClient == null)
{
throw new ArgumentNullException("blobClient");
}
if (repositories == null)
{
throw new ArgumentNullException("repositories");
}
BlobClient = blobClient;
RepositoryContainer = repositories;
ServiceOfferingRepository = repositories.Obtain <IServiceOfferingRepository>();
StudentRepository = repositories.Obtain <IStudentRepository>();
StudentAssignedOfferingRepository = repositories.Obtain <IStudentAssignedOfferingRepository>();
SubjectRepository = repositories.Obtain <ISubjectRepository>();
ServiceAttendanceRepository = repositories.Obtain <IServiceAttendanceRepository>();
}
public BattleLogRepository(IRepositoryContainer container)
{
this.container = container;
}
public MapLogRepository(IRepositoryContainer container)
{
this.container = container;
}
public HomeController(ILogger <HomeController> logger, IRepositoryContainer repositories, ISiteInfo siteInfo)
{
_logger = logger;
_repositories = repositories;
_settings = siteInfo.Settings;
}
public CountryRepository(IRepositoryContainer container)
{
this.container = container;
}
public ChatMessageRepository(IRepositoryContainer container)
{
this.container = container;
}
public ServiceOfferingFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
: base(blobClient, repositories)
{
}
public ServiceAttendanceFileProcessor(IBlobClient blobClient, IRepositoryContainer repositories)
: base(blobClient, repositories)
{
}
protected override void RegisterTaRepositories(IRepositoryContainer container)
{
container.Register<ITaskRepository>(db => new MsTaskRepository(db));
container.Register<ITaskJobRepository>(db => new MsTaskJobRepository(db));
}
protected override void RegisterUbRepositories(IRepositoryContainer container)
{
container.Register<IUserLogRepository>(db => new MsUserLogRepository(db));
}
public InvitationCodeRepository(IRepositoryContainer container)
{
this.container = container;
}
public DataContainer( ITvDB tvDb, IRepositoryContainer repositories, ISettings settings )
{
TvDB = tvDb;
Repositories = repositories;
Settings = settings;
}
public FeedBackController()
{
this._repository = new RepositoryContainer();
}
protected abstract void RegisterUbRepositories(IRepositoryContainer container);
public PublicFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
: base(repositories, blobClient, dataTableBinder, auditor)
{
}
public CountryDiplomaciesRepository(IRepositoryContainer container)
{
this.container = container;
}
protected RepositoryBasedController(RepositorySize size = RepositorySize.Medium, string repositoryKey = "common")
{
_repository = RepositorySesssion.GetRepository(size, repositoryKey);
}
public Repository(IRepositoryProcedure _RepositoryProcedure, IEntityContainer entityContainer, IRepositoryContainer repositoryContainer)
{
_StoredProcedure = _RepositoryProcedure;
_entityContainer = entityContainer;
_repositoryContainer = repositoryContainer;
}
public PalettesController(NeedleWork2016Context context, IRepositoryContainer rep)
{
_context = context;
_repository = rep;
}
public PrivateHealthFieldManager(IRepositoryContainer repositories, IBlobClient blobClient, IDataTableBinder dataTableBinder, IUserAuditor auditor)
: base(repositories, blobClient, dataTableBinder, auditor)
{
ProviderRepository = repositories.Obtain<IProviderRepository>();
}
protected override void RegisterDevRepositories(IRepositoryContainer container)
{
container.Register<INodeRepository>(db => new MsNodeRepository(db));
container.Register<INodeHeartBeatRepository>(db => new MsNodeHeartBeatRepository(db));
}