/// ---------------------------------------------------------------------
/// <summary>
/// Constructor
/// </summary>
/// ---------------------------------------------------------------------
public WebHelpers()
{
var conndirection = Convert.ToInt32(Resources.CONN_DIRECTION);
string server, database, userid, password;
ConnectionHelpers.ConnStringParameters(conndirection, out server, out database, out userid, out password);
_periodRepository = new PeriodRepository(conndirection, server, database, userid, password);
}
public ClassPeriodController(IGenericRepository genericRepository,
IMapper<CreateModel, ClassPeriod> createModelToClassPeriodMapper,
IMapper<ClassPeriod, IndexModel> classPeriodToIndexModelMapper, IPeriodRepository periodRepo)
{
_genericRepository = genericRepository;
_createModelToClassPeriodMapper = createModelToClassPeriodMapper;
_classPeriodToIndexModelMapper = classPeriodToIndexModelMapper;
_periodRepo = periodRepo;
}
public UnitIndexService(
IUnitIndexRepository unitIndexRep,
IPeriodRepository periodRep,
IPMSAdminService ipmsAdminService,
IPeriodManagerService periodChecker
)
{
this.periodRep = periodRep;
this.pmsAdminService = ipmsAdminService;
this.periodChecker = periodChecker;
this.unitIndexRep = unitIndexRep;
}
public CalculatorEngine(IPolicyRepository policyRep,
IPeriodRepository periodRep,
ICalculationRepository calcRep,
IJobIndexPointRepository jipRep,
IEmployeeRepository empRep, ICalculationDataProviderFactory calculationDataProviderFactory, ICalculationExceptionRepository calcExpRep)
{
this.policyRep = policyRep;
this.periodRep = periodRep;
this.empRep = empRep;
this.calcRep = calcRep;
this.jipRep = jipRep;
this.calculationDataProviderFactory = calculationDataProviderFactory;
this.calcExpRep = calcExpRep;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (contractorRepository != null)
{
contractorRepository.Dispose();
contractorRepository = null;
}
if (contractRepository != null)
{
contractRepository.Dispose();
contractRepository = null;
}
if (periodRepository != null)
{
periodRepository.Dispose();
periodRepository = null;
}
if (requirementRepository != null)
{
requirementRepository.Dispose();
requirementRepository = null;
}
if (presentationRepository != null)
{
presentationRepository.Dispose();
presentationRepository = null;
}
if (presentationServices != null)
{
presentationServices.Dispose();
presentationServices = null;
}
//documentFileService.Dispose();
if (workflowMessageService != null)
{
workflowMessageService.Dispose();
workflowMessageService = null;
}
}
base.Dispose(disposing);
}
public JobService(
IJobRepository jobRep,
IPeriodRepository periodRep,
IPMSAdminService pmsAdminService,
IJobIndexRepository jobIndexRep,
IPeriodManagerService periodChecker
)
{
this.periodRep = periodRep;
this.pmsAdminService = pmsAdminService;
this.jobIndexRep = jobIndexRep;
this.periodChecker = periodChecker;
this.jobRep = jobRep;
}
public ForecastSummaryRepository(
UserConnection userConnection,
IForecastSheetRepository sheetRepository,
IPeriodRepository periodRepository,
IForecastColumnRepository columnRepository)
{
userConnection.CheckArgumentNull(nameof(userConnection));
sheetRepository.CheckArgumentNull(nameof(sheetRepository));
periodRepository.CheckArgumentNull(nameof(periodRepository));
columnRepository.CheckArgumentNull(nameof(columnRepository));
UserConnection = userConnection;
SheetRepository = sheetRepository;
PeriodRepository = periodRepository;
ColumnRepository = columnRepository;
}
public ForecastProvider(IForecastSheetRepository sheetRepository, IForecastColumnRepository columnRepository,
IPeriodRepository periodRepository, IEntityInForecastCellRepository entityInForecastCellRepository,
IForecastHierarchyRowDataRepository hierarchyRowDataRepository)
{
sheetRepository.CheckArgumentNull(nameof(sheetRepository));
columnRepository.CheckArgumentNull(nameof(columnRepository));
periodRepository.CheckArgumentNull(nameof(periodRepository));
entityInForecastCellRepository.CheckArgumentNull(nameof(entityInForecastCellRepository));
hierarchyRowDataRepository.CheckArgumentNull(nameof(hierarchyRowDataRepository));
SheetRepository = sheetRepository;
ColumnRepository = columnRepository;
PeriodRepository = periodRepository;
EntityInForecastCellRepository = entityInForecastCellRepository;
ForecastHierarchyRowDataRepository = hierarchyRowDataRepository;
}
public ProjectServices(IProjectRepository projectRepository, ISectionRepository sectionRepository,
IStudentRepository studentRepository, ITextDocumentServices textDocumentServices, IMajorRepository majorRepository, IClassRepository classRepository, IPeriodRepository periodRepository, ISectionProjectRepository sectionProjectRepository)
{
_projectRepository = projectRepository;
_sectionRepository = sectionRepository;
_studentRepository = studentRepository;
_textDocumentServices = textDocumentServices;
_majorRepository = majorRepository;
_classRepository = classRepository;
_periodRepository = periodRepository;
_sectionProjectRepository = sectionProjectRepository;
_periods.Add(1);
_periods.Add(2);
_periods.Add(3);
_periods.Add(5);
}
public PeriodService(
IPeriodRepository periodRep,
IUnitIndexRepository unitIndexRepository,
IJobIndexRepository jobIndexRepository,
IPeriodManagerService periodManagerService,
IJobIndexServiceFactory jobIndexServiceFactory,
IUnitIndexServiceFactory unitIndexServiceFactory
)
{
this.periodRep = periodRep;
this.periodManagerService = periodManagerService;
this.jobIndexServiceFactory = jobIndexServiceFactory;
this.unitIndexServiceFactory = unitIndexServiceFactory;
this.unitIndexRepository = unitIndexRepository;
this.jobIndexRepository = jobIndexRepository;
}
public static void Activate(IPeriodRepository periodRep, Period period)
{
lock (lockObject)
{
bool isActivePeriod = periodRep.GetAll().Any(p => p.Id != period.Id && p.Active);
if (!isActivePeriod)
{
period.Activate();
}
else
{
throw new PeriodException((int)ApiExceptionCode.CouldNotActivatePeriodWhileExistsAnotherActivePeriod
, ApiExceptionCode.CouldNotActivatePeriodWhileExistsAnotherActivePeriod.DisplayName);
}
}
}
public UnitService(
IUnitRepository unitRep,
IPeriodRepository periodRep,
IUnitIndexRepository unitIndexRep
, IPMSAdminService ipmsAdminService,
IPeriodManagerService periodChecker,
IUnitInquiryConfiguratorService configuratorService,
IEmployeeRepository employeeRepository)
{
this.periodRep = periodRep;
this.ipmsAdminService = ipmsAdminService;
this.unitRep = unitRep;
this.unitIndexRep = unitIndexRep;
this.periodChecker = periodChecker;
_configuratorService = configuratorService;
_employeeRepository = employeeRepository;
}
public CustomerRequirementsController(IContractorRepository contractorRepo,
IContractRepository contractRepo,
IPeriodRepository periodRepo,
IRequirementRepository requirementRepo,
IPresentationRepository presentationRepo,
IPresentationServices presentationServ,
IDocumentFileService documentFileServ,
IWorkflowMessageService workflowMessageServ)
{
contractorRepository = contractorRepo;
contractRepository = contractRepo;
periodRepository = periodRepo;
requirementRepository = requirementRepo;
presentationRepository = presentationRepo;
presentationServices = presentationServ;
documentFileService = documentFileServ;
workflowMessageService = workflowMessageServ;
}
public JobPositionService(IJobPositionRepository jobPositionRep,
IPeriodRepository periodRep,
IJobRepository jobRepository,
IUnitRepository unitRep,
IPMSAdminService pmsAdminService,
IJobPositionInquiryConfiguratorService configuratorService,
IEmployeeRepository employeeRepository,
IPeriodManagerService periodChecker)
{
this.periodRep = periodRep;
this.jobRepository = jobRepository;
this.unitRep = unitRep;
this.pmsAdminService = pmsAdminService;
this.configuratorService = configuratorService;
this.employeeRepository = employeeRepository;
this.periodChecker = periodChecker;
this.jobPositionRep = jobPositionRep;
}
public WasteStatisticService(IWasteStatisticRepository repository, IIdentityRepository identityRepository, IPeriodRepository periodRepository)
{
if (repository == null)
{
throw new ArgumentNullException("repository");
}
if (identityRepository == null)
{
throw new ArgumentNullException("identityRepository");
}
if (periodRepository == null)
{
throw new ArgumentNullException("periodRepository");
}
this._repository = repository;
this._identityRepository = identityRepository;
this._periodRepository = periodRepository;
}
public EmployeeServiceFacade(IEmployeeRepository employeeRep,
IMapper <Employee, EmployeeDTOWithActions> employeeDTOWithActionsMapper,
IMapper <Employee, EmployeeDTO> employeeDTOMapper,
IEmployeeService employeeService,
IPeriodRepository periodRep,
IJobPositionRepository jobPositionRep,
IJobRepository jobRep,
IPMSAdminService converter)
{
this.employeeRep = employeeRep;
this.employeeDTOWithActionsMapper = employeeDTOWithActionsMapper;
this.employeeDTOMapper = employeeDTOMapper;
this.employeeService = employeeService;
this.periodRep = periodRep;
this.jobPositionRep = jobPositionRep;
this.jobRep = jobRep;
this.converter = converter;
}
public PatientApplicationService(IClock clock,
IMapper <Pathway, PathwayInfo> pathwayToPathwayInfoMapper,
IMapper <CompletedEvent, EventHistoryLogInfo> completedEventToEventHistoryLogInfoMapper,
IMapper <ListInputInfo, ListInput> listInputInfoToListInputMapper,
ICompletedEventRepository completedEventRepository,
IEventMilestoneRepository eventMilestoneRepository,
IPathwayRepository pathwayRepository,
IPeriodRepository periodRepository)
{
_clock = clock;
_pathwayToPathwayInfoMapper = pathwayToPathwayInfoMapper;
_completedEventRepository = completedEventRepository;
_pathwayRepository = pathwayRepository;
_periodRepository = periodRepository;
_eventMilestoneRepository = eventMilestoneRepository;
_completedEventToEventHistoryLogInfoMapper = completedEventToEventHistoryLogInfoMapper;
_listInputInfoToListInputMapper = listInputInfoToListInputMapper;
}
public RequirementsController(IRequirementRepository requirementRepo,
IPresentationRepository presentationRepo,
IDocumentFileService documentFileServ,
ICustomerAuditorRespository customerAuditorRespo,
IContractorRepository contractorRepo,
IPresentationServices presentationServ,
IWorkflowMessageService workflowMessageServ,
IDocumentationBusinessTypeRepository documentationBusinessTypeRepo,
IPeriodRepository periodRepo,
IEntityTypeRepository entityTypeRepo)
{
requirementRepository = requirementRepo;
presentationRepository = presentationRepo;
documentFileService = documentFileServ;
customerAuditorRespository = customerAuditorRespo;
contractorRepository = contractorRepo;
presentationServices = presentationServ;
workflowMessageService = workflowMessageServ;
documentationBusinessTypeRepository = documentationBusinessTypeRepo;
periodRepository = periodRepo;
entityTypeRepository = entityTypeRepo;
}
public CalculationServiceFacade(ICalculationService calculationService,
IMapper <CalculationWithPolicyAndPeriod, CalculationDTO> calculationMapper,
IMapper <CalculationWithPolicyAndPeriod, CalculationBriefDTOWithAction> calculationBriefMapper,
IMapper <EmployeeCalculationException, CalculationExceptionBriefDTOWithAction> calculationExceptionBriefMapper,
IMapper <EmployeeCalculationException, CalculationExceptionDTO> calculationExceptionMapper,
IMapper <CalculationStateReport, CalculationStateWithRunSummaryDTO> calculationStateReportMapper,
ICalculationRepository calculationRep, IPeriodRepository PeriodRep, IPolicyRepository PolicyRep,
IEmployeeRepository employeeRep,
ICalculationExceptionRepository calculationExpRepository,
ICalculationEngineService calcEngineService)
{
this.calculationService = calculationService;
this.calculationMapper = calculationMapper;
this.calculationBriefMapper = calculationBriefMapper;
this.calculationExceptionBriefMapper = calculationExceptionBriefMapper;
this.calculationExceptionMapper = calculationExceptionMapper;
this.calculationRep = calculationRep;
this.calculationStateReportMapper = calculationStateReportMapper;
this.PeriodRep = PeriodRep;
this.PolicyRep = PolicyRep;
this.employeeRep = employeeRep;
this.calculationExpRepository = calculationExpRepository;
this.calcEngineService = calcEngineService;
}
public GetPeriodQueryHandler(IValidator <GetPeriodQueryRequest> requestValidator, IPeriodRepository periodRepository, IMapper mapper)
{
_requestValidator = requestValidator ?? throw new ArgumentNullException(nameof(requestValidator));
_periodRepository = periodRepository ?? throw new ArgumentNullException(nameof(periodRepository));
_mapper = mapper ?? throw new ArgumentNullException(nameof(mapper));
}
public PeriodService(IPeriodRepository periodRepository)
{
_periodRepository = periodRepository;
}
public JobPositionListCommandHandler(IPeriodRepository periodRepository, IMapper mapper)
{
_periodRepository = periodRepository;
_mapper = mapper;
}
public ProjectServices(IProjectRepository projectRepository, IMajorRepository majorRepository, IClassRepository classRepository, IPeriodRepository periodRepository, ISectionProjectRepository sectionProjectRepository)
{
_projectRepository = projectRepository;
_majorRepository = majorRepository;
_classRepository = classRepository;
_periodRepository = periodRepository;
_sectionProjectRepository = sectionProjectRepository;
}
public GetPeriodsQueryHandler(IPeriodRepository periodRepository, IMapper mapper)
{
_periodRepository = periodRepository;
_mapper = mapper;
}
public WeatherForecastController(ILogger <WeatherForecastController> logger, IPeriodRepository periodRepository)
{
_logger = logger;
_periodRepository = periodRepository;
}
public PeriodsServices(IPeriodRepository periodsRepository)
{
_periodsRepository = periodsRepository;
}
public PeriodService(IPeriodRepository periodRepository, IUnitOfWork unitOfWork)
{
this._periodRepository = periodRepository;
this._unitOfWork = unitOfWork;
}
public PeriodService(IMapper mapper, IBaseRepository <Period> baseRepository, IPeriodRepository periodRepository)
{
_mapper = mapper;
_baseRepository = baseRepository;
_periodRepository = periodRepository;
}
public GetPeriodQueryHandler(IValidator <GetPeriodQueryRequest> requestValidator, IPeriodRepository periodRepository)
{
_requestValidator = requestValidator;
_periodRepository = periodRepository;
}
public JournalingService(IPeriodRepository periodRepository)
{
_activePeriod = periodRepository.GetActivePeriod();
}
public CalculationEngineService(ICalculationService service, IPeriodService periodService, IPeriodRepository p)
{
this.service = service;
this.periodService = periodService;
}
public ClassPeriodController(IGenericRepository genericRepository,
IMapper <CreateModel, ClassPeriod> createModelToClassPeriodMapper,
IMapper <ClassPeriod, IndexModel> classPeriodToIndexModelMapper, IPeriodRepository periodRepo)
{
_genericRepository = genericRepository;
_createModelToClassPeriodMapper = createModelToClassPeriodMapper;
_classPeriodToIndexModelMapper = classPeriodToIndexModelMapper;
_periodRepo = periodRepo;
}
public ClaimService(IClaimRepository claimRep, IPeriodRepository periodRep, IPMSSecurityService securityService)
{
this.claimRep = claimRep;
this.periodRep = periodRep;
this.securityService = securityService;
}
