/// <summary>
/// Initializes a new instance of the <see cref="DocumentService"/> class.
/// </summary>
/// <param name="documentRepository">The document repository.</param>
/// <param name="elasticRepository">The ElasticSearch repository.</param>
public DocumentService(
IDocumentRepository documentRepository,
IElasticRepository elasticRepository)
{
this.documentRepository = documentRepository;
this.elasticRepository = elasticRepository;
}
public DocumentsModule()
{
this.RequiresAuthentication();
this.RequiresAnyClaim(new[] { "Users", "Admins" });
Get["/"] = param => { return(View["Views/Documents/Index.html"]); };
Get["/UserDocs/{id}"] = param => { return(GetUserDocs((Guid)param.id)); };
Get["/Add"] = param => { return(View["Views/Documents/Form.html"]); };
Post["/Add"] = param =>
{
string title = (string)param.Request.Form.Title;
string description = (string)param.Request.Form.Description;
Guid userId = (Guid)param.Request.Form.UserId;
using (IDocumentRepository ctx = Program.NinjectKernel.Get <IDocumentRepository>())
{
ctx.Add(new Document()
{
Title = title, Description = description
});
return(View["Views/Documents/Index.html"]);
}
};
}
public QCService()
{
_documentRepository = DI.CreateDocumentRepository();
_refreshDocumentRepository = DI.CreateDocumentRepository();
_generalRepository = DI.CreateGeneralrepository();
_refreshGeneralRepository = DI.CreateGeneralrepository();
}
public LuceneSiteIndexHandler(IContentRepository contentRepository
, IDocumentRepository documentRepository, IIndexingHandler indexingHandler)
{
_contentRepository = contentRepository;
_indexingHandler = indexingHandler;
_documentRepository = documentRepository;
}
public ProductApiController(IDocumentRepository _documentRepository,
ITypeOfTaskRepository _typeOfTaskRepository,
IFormatsNameRepository _formatsName,
IProductRepository _productRepository,
ITaskExecutorRepository _taskExecutorRepository,
IArticleRepository _articleRepository,
ICustomerSupplierRepository _customerSupplierRepository,
IMenuProductRepository _menuProduct,
ICostDetailRepository _costDetailRepository,
ITaskCenterRepository _taskCenterRepository)
{
typeOfTaskRepository = _typeOfTaskRepository;
documentRepository = _documentRepository;
productRepository = _productRepository;
taskExecutorRepository = _taskExecutorRepository;
articleRepository = _articleRepository;
customerSupplierRepository = _customerSupplierRepository;
menu = _menuProduct;
costDetailRepository = _costDetailRepository;
taskCenterRepository = _taskCenterRepository;
this.Disposables.Add(typeOfTaskRepository);
this.Disposables.Add(documentRepository);
this.Disposables.Add(productRepository);
this.Disposables.Add(taskExecutorRepository);
this.Disposables.Add(articleRepository);
this.Disposables.Add(customerSupplierRepository);
this.Disposables.Add(menu);
this.Disposables.Add(costDetailRepository);
this.Disposables.Add(taskCenterRepository);
}
/// <summary>
/// Handle the upload functionality.
/// </summary>
/// <param name="mailSettings"></param>
/// <param name="errorSettings"></param>
/// <param name="documentRepository"></param>
/// <param name="generalSettings"></param>
public UploadHelperFunctionsUtility(IOptions<MailSettings> mailSettings, IOptions<ErrorSettings> errorSettings, IDocumentRepository documentRepository, IOptions<GeneralSettings> generalSettings)
{
this.mailSettings = mailSettings.Value;
this.errorSettings = errorSettings.Value;
this.documentRepository = documentRepository;
this.generalSettings = generalSettings.Value;
}
public MongoDbRepositoryTests(ITestOutputHelper output)
{
var configuration = ConfigurationReader.GetConfig();
repo = new MongoRepository <Server, Guid>(configuration);
this.output = output;
}
public PupilService(IDocumentRepository documentRepository, IDataService dataService, IEstablishmentService schoolService, IAllocationYearConfig year)
{
_documentRepository = documentRepository;
_dataService = dataService;
_schoolService = schoolService;
_allocationYear = year.Value;
}
public DataController(IConfiguration configuration, IDocumentRepository documentRepository, IImageSignature imageSignature, ILoggerFactory logFactory)
{
_configuration = configuration;
_obj = new Data(documentRepository);
_imageSignature = imageSignature;
_logger = logFactory.CreateLogger <DataController>();
}
public MergeDocumentApplicationService(IFileShareProvider fileShareProvider, ILogManager logManager, IDocumentRepository documentRepository, IDocumentProvider documentProvider)
{
_fileShareProvider = fileShareProvider;
_logManager = logManager;
_documentRepository = documentRepository;
_documentProvider = documentProvider;
}
public DocumentProvision(IDocumentRepository docRepository,
IUserRepository userRepository,
IUploadHelperFunctions uploadHelperFunctions,
IOptions <GeneralSettings> generalSettings,
IOptions <DocumentSettings> documentSettings,
ICustomLogger customLogger,
IOptions <SearchSettings> searchSettings,
IConfigurationRoot configuration,
IHttpContextAccessor httpContextAccessor,
ISPOAuthorization spoAuthorization,
IOptions <LogTables> logTables, IOptions <ErrorSettings> errorSettings)
{
this.docRepository = docRepository;
this.uploadHelperFunctions = uploadHelperFunctions;
this.userRepository = userRepository;
this.generalSettings = generalSettings.Value;
this.documentSettings = documentSettings.Value;
this.customLogger = customLogger;
this.logTables = logTables.Value;
this.errorSettings = errorSettings.Value;
this.searchSettings = searchSettings.Value;
this.configuration = configuration;
this.httpContextAccessor = httpContextAccessor;
this.spoAuthorization = spoAuthorization;
}
private PublishedSnapshotService(ServiceContext serviceContext,
IPublishedContentTypeFactory publishedContentTypeFactory,
IScopeProvider scopeProvider,
ICacheProvider requestCache,
IEnumerable <IUrlSegmentProvider> segmentProviders,
IPublishedSnapshotAccessor publishedSnapshotAccessor, IVariationContextAccessor variationContextAccessor,
IDocumentRepository documentRepository, IMediaRepository mediaRepository, IMemberRepository memberRepository,
IDefaultCultureAccessor defaultCultureAccessor,
ILogger logger,
IGlobalSettings globalSettings,
ISiteDomainHelper siteDomainHelper,
PublishedContentTypeCache contentTypeCache,
MainDom mainDom,
bool testing, bool enableRepositoryEvents)
: base(publishedSnapshotAccessor, variationContextAccessor)
{
_routesCache = new RoutesCache();
_publishedContentTypeFactory = publishedContentTypeFactory;
_contentTypeCache = contentTypeCache
?? new PublishedContentTypeCache(serviceContext.ContentTypeService, serviceContext.MediaTypeService, serviceContext.MemberTypeService, publishedContentTypeFactory, logger);
_xmlStore = new XmlStore(serviceContext, scopeProvider, _routesCache,
_contentTypeCache, segmentProviders, publishedSnapshotAccessor, mainDom, testing, enableRepositoryEvents,
documentRepository, mediaRepository, memberRepository, globalSettings);
_domainService = serviceContext.DomainService;
_memberService = serviceContext.MemberService;
_mediaService = serviceContext.MediaService;
_userService = serviceContext.UserService;
_defaultCultureAccessor = defaultCultureAccessor;
_requestCache = requestCache;
_globalSettings = globalSettings;
_siteDomainHelper = siteDomainHelper;
}
public DocumentsController(
IDocumentRepository documentRepository,
ILogger <DocumentsController> logger)
{
this.documentRepository = documentRepository;
this.logger = logger;
}
public DocumentService( IDocumentRepository DocumentRepository )
{
if ( DocumentRepository == null ) {
throw new ArgumentNullException( "DocumentRepository" );
}
this.documentRepository = DocumentRepository;
}
public DocumentLogic(
IDocumentRepository documentRepository,
IEventBus eventBus)
{
this.eventBus = eventBus;
this.documentRepository = documentRepository;
}
public MailMessageRepository(ISPOAuthorization spoAuthorization,
IOptions <GeneralSettings> generalSettings, IDocumentRepository documentRepository)
{
this.spoAuthorization = spoAuthorization;
this.generalSettings = generalSettings.Value;
this.documentRepository = documentRepository;
}
public DocumentController(IDocumentRepository documentRepository, UserManager <ApplicationUser> userManager, IDavaRepository davaRepository, IMapper mapper)
{
_documentRepository = documentRepository;
_userManager = userManager;
_davaRepository = davaRepository;
_mapper = mapper;
}
public UpdateDocumentService(
INotifier notifier,
IDocumentRepository documentRepository)
: base(notifier)
{
_documentRepository = documentRepository;
}
public SharingService(IDocumentRepository documentRepo, IUserDocumentRepository userDocRepo, IUsersRepository userRepo, IMapper mapper)
{
_documentRepo = documentRepo ?? throw new ArgumentNullException(nameof(documentRepo));
_userDocumentRepo = userDocRepo ?? throw new ArgumentNullException(nameof(userDocRepo));
_userRepo = userRepo ?? throw new ArgumentNullException(nameof(userRepo));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public DocumentController(IDocumentRepository documentRepository, IWorkflowSchemeRepository workflowSchemeRepository, IEmployeeRepository employeeRepository, IMapper mapper)
{
_documentRepository = documentRepository;
_workflowSchemeRepository = workflowSchemeRepository;
_employeeRepository = employeeRepository;
_mapper = mapper;
}
protected override void Context()
{
DBContext = new PRToolsEntities();
TimeProvider = new TimeProvider();
DocumentRepository = new DocumentRepository(DBContext, TimeProvider);
_testConntection = new SqlConnection("Server=SULPYWIN7;Database=PRTools;Integrated Security=True;");
_testConntection.Open();
_transactionScope = new TransactionScope();
using (_transactionScope)
{
var sql =
@"SET IDENTITY_INSERT Customers ON
INSERT INTO Customers ([CustomerId], [CustomerTypeKey], [GooglePlacesURL], [ListName], [Name], [ParentCustomerId], [Phone], [TwitterHandle], [WebsiteURL])
VALUES ("+CustomerId+@", 'CorporateClient', 'googlePlacesURL', 'ListName', 'Name', 0, '555-555-5555', '@twitterhandle', 'www.website.com')
SET IDENTITY_INSERT Customers OFF
SET IDENTITY_INSERT CustomLocalizationFields ON
INSERT INTO CustomLocalizationFields ([CustomLocalizationFieldId], [FieldName])
VALUES (1, '"+SomeCustomField+@"')
SET IDENTITY_INSERT CustomLocalizationFields OFF
SET IDENTITY_INSERT CustomLocalizationFieldValues ON
INSERT INTO CustomLocalizationFieldValues ([CustomLocalizationFieldValueId], [FieldValue], [CustomerId], [CustomLocalizationFieldId])
VALUES (1, '"+SomeCustomFieldValue+@"', 5, 1)
SET IDENTITY_INSERT CustomLocalizationFieldValues OFF";
var command = new SqlCommand(sql, _testConntection);
command.ExecuteNonQuery();
}
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
OrganizationUnits = new OrganizationUnitRepository(context);
DocumentTypes = new DocumentTypeRepository(context);
Documents = new DocumentRepository(context);
}
public DocumentController(IConstantRepository ConstantParam, IDocumentRepository DocumentParam, IMinistryRepository MinistryParam)
{
ConstantRepository = ConstantParam;
DocumentRepository = DocumentParam;
MinistryRepository = MinistryParam;
ViewBag.Supervisor = false;
int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]);
if (memberID > 0)
{
if (MembershipRepositroy.IsUser(memberID))
{
user user = MembershipRepositroy.GetUserByID(memberID);
if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access
{
ViewBag.Supervisor = true;
}
if (user.role.Name == "WebMaster") //creator access
{
ViewBag.Supervisor2 = true;
}
if ((user.role.Name == "Officer") || (user.role.Name == "FinanceLead")) //creator access
{
ViewBag.Supervisor3 = true;
}
}
}
}
public SendDocumentNotificationCommandHandler(
IEntityRepository entityRepository,
IDocumentRepository documentRepository)
{
this.entityRepository = entityRepository;
this.documentRepository = documentRepository;
}
protected override void Context()
{
MockAuthorizationService = MockRepository.GenerateStub<IAuthorizationService>();
MockDocumentRepository = MockRepository.GenerateStub<IDocumentRepository>();
MockCustomerRepository = MockRepository.GenerateStub<ICustomerRepository>();
//DocumentService = new DocumentService(MockAuthorizationService, MockDocumentRepository, MockCustomerRepository);
}
public DocumentCommandHandler(
IDocumentRepository documentRepository,
IDataStore dataStore)
{
_documentRepository = documentRepository;
_dataStore = dataStore;
}
public AssignmentService(IAssignmentRepository assignmentRepository, IActivityRepository activityRepository,
IDocumentRepository documentRepository)
{
if (assignmentRepository == null)
{
throw new ArgumentNullException(nameof(assignmentRepository));
}
_assignmentRepository = assignmentRepository;
if (activityRepository == null)
{
throw new ArgumentNullException(nameof(activityRepository));
}
_activityRepository = activityRepository;
if (documentRepository == null)
{
throw new ArgumentNullException(nameof(documentRepository));
}
_documentRepository = documentRepository;
listAttachments = new List <System.Net.Mail.Attachment>();
listUsers = new List <string>();
listUsersCC = new List <string>();
email = new EmailHelper("", "", "", "");
}
public DocumentCommandHandler(IDocumentRepository documentRepository, IStoreRepository storeRepository, IUnitOfWork unitOfWork, ILogger logger)
{
_documentRepository = documentRepository;
_storeRepository = storeRepository;
_unitOfWork = unitOfWork;
_logger = logger;
}
private readonly IDocumentTypeRepository _documentTypeRepository; //文档类型仓储
#endregion Fields
#region Constructors
public DocumentAppService(IDocumentQuery documentQuery, IDocumentRepository documentRepository,
IDocumentTypeRepository documentTypeRepository)
{
_documentQuery = documentQuery;
_documentRepository = documentRepository;
_documentTypeRepository = documentTypeRepository;
}
public DocumentSlugExistsConstraint( IDocumentRepository DocumentRepository )
{
if ( DocumentRepository == null ) {
throw new ArgumentNullException( "DocumentRepository" );
}
this.documentRepository = DocumentRepository;
}
protected override void Context()
{
DbContext = new PRToolsEntities();
DocumentRepository = new DocumentRepository(DbContext, new TimeProvider());
_transactionScope = new TransactionScope();
using (_transactionScope)
{
TestCustomer = new Customer
{
CustomerType = DbContext.CustomerTypes.FirstOrDefault(),
GooglePlacesURL = "GooglePlacesURL",
TwitterHandle = "TwitterHandle",
WebsiteURL = "WebsiteURL",
ListName = "ListName",
Name = "Name",
ParentCustomerId = 0,
Phone = "555-555-5555",
};
DbContext.Customers.AddObject(TestCustomer);
TestDocument = new Document
{
Title = "TestTitle",
Body = "This is a test body",
CreatedByUsername = "******",
CreatedDate = new DateTime(2011, 1, 1),
};
DbContext.Documents.AddObject(TestDocument);
DbContext.SaveChanges();
}
}
public DocumentAppService(
IProjectRepository projectRepository,
IDocumentRepository documentRepository,
IDocumentSourceFactory documentStoreFactory,
IDistributedCache <LanguageConfig> languageCache,
IDistributedCache <DocumentResourceDto> resourceCache,
IDistributedCache <DocumentUpdateInfo> documentUpdateCache,
IHostEnvironment hostEnvironment,
IDocumentFullSearch documentFullSearch,
IOptions <DocsElasticSearchOptions> docsElasticSearchOptions,
IConfiguration configuration)
{
_projectRepository = projectRepository;
_documentRepository = documentRepository;
_documentStoreFactory = documentStoreFactory;
LanguageCache = languageCache;
ResourceCache = resourceCache;
DocumentUpdateCache = documentUpdateCache;
HostEnvironment = hostEnvironment;
_documentFullSearch = documentFullSearch;
_configuration = configuration;
_docsElasticSearchOptions = docsElasticSearchOptions.Value;
_cacheTimeout = GetCacheTimeout();
_documentResourceAbsoluteExpiration = GetDocumentResourceAbsoluteExpirationTimeout();
_documentResourceSlidingExpiration = GetDocumentResourceSlidingExpirationTimeout();
}
public DocumentController(IDocumentRepository docRepo, IHostingEnvironment hosting, ILogger <DocumentController> logger)
{
_documentRepository = docRepo;
_hostingEnvironment = hosting;
_rootPath = _hostingEnvironment.ContentRootPath;
_logger = logger;
}
public SafetyDeclarationManager(DataContext context, ISafetyDeclarationRepository safetyDeclarationRepository,
IDocumentRepository documentRepository)
{
_context = context;
_safetyDeclarationRepository = safetyDeclarationRepository;
_documentRepository = documentRepository;
}
public SolutionsController(
IDocumentRepository documentRepository,
ILogger <SolutionsController> logger)
{
_documentRepository = documentRepository;
_logger = logger;
}
public DocumentService(IDocumentRepository documentRepository, ICustomerRepository customerRepository, IUnitOfWork uow
, IEmployeeRepository employeeRepository)
: this(documentRepository, uow)
{
this._customerRepository = customerRepository;
_employeeRepository = employeeRepository;
}
public DocumentSaver(IAuthorizationService authorizationService, AbstractValidator<Document> validator,
IDocumentRepository documentRepository)
{
_authorizationService = authorizationService;
_validator = validator;
_documentRepository = documentRepository;
}
private static async Task CreatePeople(IDocumentRepository repository)
{
await SavePerson(repository, "John", "Smith");
await SavePerson(repository, "Tom", "Bar");
await SavePerson(repository, "Jess", "Bar");
await SavePerson(repository, "Foo", "Bar");
System.Console.WriteLine("");
}
public DocumentService(IDocumentRepository documentRepository)
{
if (documentRepository == null)
{
throw new ArgumentNullException("documentRepository");
}
_documentRepository = documentRepository;
}
public DocumentService(IDocumentRepository documentRepository, IFileService fileService, IUserService userService,
IAdministrationService administrationService)
{
_documentRepository = documentRepository;
_administrationService = administrationService;
_fileService = fileService;
_userService = userService;
}
public AddedDocumentsService(IPeninsulaLog log, IDocumentRepository documentRepository, IUserForAuditingRepository userForAuditingRepository, ISiteStructureElementRepository siteRepository, IDocumentTypeRepository documentTypeRepository)
{
_log = log;
_documentRepository = documentRepository;
_userForAuditingRepository = userForAuditingRepository;
_siteRepository = siteRepository;
_documentTypeRepository = documentTypeRepository;
}
public TaskCenterController(ITaskCenterRepository _tskExDataRep,
IDocumentRepository _docDataRep)
{
taskCenterRepository = _tskExDataRep;
documentRepository = _docDataRep;
this.Disposables.Add(taskCenterRepository);
}
public EventStore(IDocumentRepository <EventDocument> eventRepository,
IEventDocumentFactory eventDocumentFactory,
IVersionService versionService)
{
_eventRepository = eventRepository;
_eventDocumentFactory = eventDocumentFactory;
_versionService = versionService;
}
public DocumentService(
IDocumentRepository DocumentRepository,
IDocumentImageRepository documentImageRepository
)
{
_documentRepository = DocumentRepository;
_documentImageRepository = documentImageRepository;
}
public QuerlyDemo(ILogger<QuerlyDemo> logger, IBus bus,
IDocumentRepository documents)
{
_logger = logger;
_bus = bus;
_documents = documents;
_bus.SetupEndPoint("querlydemo", "querlydemo", ExchangeType.topic);
}
public BrowseController(IStructureRepository structureRepository,
IDocumentRepository documentRepository)
: base(false)
{
_structureRepository = structureRepository;
_documentRepository = documentRepository;
_document = new Document(_documentRepository);
}
public AddStockIssueNoteLineItemCommandHandler(ICostCentreRepository costCenterRepository, IUserRepository userRepository,
IDocumentRepository documentRepository, IDocumentFactory documentFactory, IProductRepository productRepository)
{
_costCenterRepository = costCenterRepository;
_userRepository = userRepository;
_documentFactory = documentFactory;
_documentRepository = documentRepository;
_productRepository = productRepository;
}
public DocumentController(IAuthorizationService authorizationService, IDocumentRepository documentRepository,
ICustomerRepository customerRepository, IDocumentSaver documentSaver,
IMappingEngine mappingEngine)
{
_authorizationService = authorizationService;
_documentRepository = documentRepository;
_customerRepository = customerRepository;
_documentSaver = documentSaver;
_mappingEngine = mappingEngine;
}
public CreateStockIssueNoteCommandHandler(ICostCentreRepository costCenterRepository,
IUserRepository userRepository,
IDocumentRepository documentRepository,
IDocumentFactory documentFactory)
{
_costCenterRepository = costCenterRepository;
_userRepository = userRepository;
_documentFactory = documentFactory;
_documentRepository = documentRepository;
}
public EntriesAppService(IRecipientRepository recipientRepository,
IDocumentRepository documentRepository,
IRepository<MergeField> mergeFieldsRepository,
IRepository<FillRequestReadModel> fillRequestReadModelRepository)
{
_mergeFieldsRepository = mergeFieldsRepository;
_documentRepository = documentRepository;
_recipientRepository = recipientRepository;
_fillRequestReadModelRepository = fillRequestReadModelRepository;
}
public UploadHelperFunctions(ISPOAuthorization spoAuthorization, IOptions<ErrorSettings> errorSettings, IUserRepository userRepositoy,
IDocumentRepository documentRepository, IOptions<DocumentSettings> documentSettings, IUploadHelperFunctionsUtility uploadHelperFunctionsUtility)
{
this.spoAuthorization = spoAuthorization;
this.errorSettings = errorSettings.Value;
this.documentRepository = documentRepository;
this.documentSettings = documentSettings.Value;
this.uploadHelperFunctionsUtility = uploadHelperFunctionsUtility;
this.userRepositoy = userRepositoy;
}
protected override void Context()
{
base.Context();
AuthorizationService = MockRepository.GenerateStub<IAuthorizationService>();
Validator = MockRepository.GenerateStub<AbstractValidator<Document>>();
DocumentRepository = MockRepository.GenerateStub<IDocumentRepository>();
MappingEngine = MockRepository.GenerateStub<IMappingEngine>();
DocumentSaver = new DocumentSaver(AuthorizationService, Validator, DocumentRepository);
}
public DocumentController( IDocumentRepository DocumentRepository, IDocumentService DocumentService )
{
if ( DocumentRepository == null ) {
throw new ArgumentNullException( "DocumentRepository" );
}
if ( DocumentService == null ) {
throw new ArgumentNullException( "DocumentService" );
}
this.documentRepository = DocumentRepository;
this.documentService = DocumentService;
}
public ConfigurationController(IDocumentRepository documentRepository,
IStructureRepository structureRepository)
: base(true)
{
_documentRepository = documentRepository;
_structureRepository = structureRepository;
_document = new Document(_documentRepository);
_structure = new Structure(_structureRepository);
_user = new User();
}
public DocumentsAppService(IDocumentRepository documentRepository,
PdfToImageService pdfToImageService,
IRepository<Image> imageRepository,
IDocumentEntryRepository entryRepository,
IRevisionRepository revisionRepository
)
{
_revisionRepository = revisionRepository;
_imageRepository = imageRepository;
_pdfToImageService = pdfToImageService;
_documentRepository = documentRepository;
_entryRepository = entryRepository;
}
public DataManager(IDocumentTypeRepository documentTypeRepository,
IDocumentRepository documentRepository,
IFileRepository fileRepository,
IOrganizationListRepository organizationListRepository,
IVehicleTypeRepository vehicleTypeRepository,
ICarRepository carRepository)
{
this.documentRepository = documentRepository;
this.documentTypeRepository = documentTypeRepository;
this.fileRepository = fileRepository;
this.organizationListRepository = organizationListRepository;
this.vehicleTypeRepository = vehicleTypeRepository;
this.carRepository = carRepository;
}
/// <summary>
/// Constructor where all the required dependencies are injected
/// </summary>
/// <param name="errorSettings"></param>
/// <param name="documentSettings"></param>
/// <param name="spoAuthorization"></param>
/// <param name="matterCenterServiceFunctions"></param>
/// <param name="documentRepositoy"></param>
public DocumentController(IOptions<ErrorSettings> errorSettings,
IOptions<DocumentSettings> documentSettings,
ISPOAuthorization spoAuthorization,
IMatterCenterServiceFunctions matterCenterServiceFunctions,
IDocumentRepository documentRepositoy,
ICustomLogger customLogger, IOptions<LogTables> logTables
)
{
this.errorSettings = errorSettings.Value;
this.documentSettings = documentSettings.Value;
this.spoAuthorization = spoAuthorization;
this.matterCenterServiceFunctions = matterCenterServiceFunctions;
this.documentRepositoy = documentRepositoy;
this.customLogger = customLogger;
this.logTables = logTables.Value;
}
/// <summary>
/// DcouemtsController Constructor where all the required dependencies are injected
/// </summary>
/// <remarks></remarks> ///
/// <param name="errorSettings"></param>
/// <param name="documentSettings"></param>
/// <param name="matterCenterServiceFunctions"></param>
/// <param name="documentRepositoy"></param>
/// <param name="customLogger"></param>
/// <param name="logTables"></param>
/// <param name="documentProvision"></param>
/// <param name="generalSettings"></param>
public DocumentController(IOptions<ErrorSettings> errorSettings,
IOptions<DocumentSettings> documentSettings,
IMatterCenterServiceFunctions matterCenterServiceFunctions,
IDocumentRepository documentRepositoy,
ICustomLogger customLogger, IOptions<LogTables> logTables, IDocumentProvision documentProvision,
IOptions<GeneralSettings> generalSettings
)
{
this.errorSettings = errorSettings.Value;
this.documentSettings = documentSettings.Value;
this.matterCenterServiceFunctions = matterCenterServiceFunctions;
this.documentRepositoy = documentRepositoy;
this.customLogger = customLogger;
this.logTables = logTables.Value;
this.documentProvision = documentProvision;
this.generalSettings = generalSettings.Value;
}
public ApplicationDetailsService(IApplicationRepository applicationRepository, IBankAgencyRepository bankAgencyRepository, IApplicantRepository applicantRepository,
IEmploymentRepository employmentRepository, IAddressRepository addressRepository, IContactRepository contactRepository,
IBankAccountRepository bankAccountRepository, IBankCardRepository bankCardRepository, INoteRepository noteRepository, IDocumentRepository documentRepository,
IReasonRepository reasonRepository, IActionLogRepository actionLogRepository)
{
_applicationRepository = applicationRepository;
_bankAgencyRepository = bankAgencyRepository;
_applicantRepository = applicantRepository;
_employmentRepository = employmentRepository;
_addressRepository = addressRepository;
_contactRepository = contactRepository;
_bankAccountRepository = bankAccountRepository;
_bankCardRepository = bankCardRepository;
_noteRepository = noteRepository;
_documentRepository = documentRepository;
_reasonRepository = reasonRepository;
_actionLogRepository = actionLogRepository;
}
public DocumentProvision(IDocumentRepository docRepository,
IUserRepository userRepository,
IUploadHelperFunctions uploadHelperFunctions,
IOptions<GeneralSettings> generalSettings,
IOptions<DocumentSettings> documentSettings,
ICustomLogger customLogger,
IOptions<SearchSettings> searchSettings,
IConfigurationRoot configuration,
IHttpContextAccessor httpContextAccessor,
IOptions<LogTables> logTables, IOptions<ErrorSettings> errorSettings)
{
this.docRepository = docRepository;
this.uploadHelperFunctions = uploadHelperFunctions;
this.userRepository = userRepository;
this.generalSettings = generalSettings.Value;
this.documentSettings = documentSettings.Value;
this.customLogger = customLogger;
this.logTables = logTables.Value;
this.errorSettings = errorSettings.Value;
this.searchSettings = searchSettings.Value;
this.configuration = configuration;
this.httpContextAccessor = httpContextAccessor;
}
