public static void CreateJobPosition(IJobPositionRepository jobPositionRepository, string name, string dictionaryName)
{
var jobPosition = new JobPosition(jobPositionRepository.GetNextId(), name, dictionaryName);
jobPositionRepository.Add(jobPosition);
JobPositions.Add(jobPosition);
}
public SearchInterviewsValidator(IJobPositionRepository jobPositionRepository, ITeamRepository teamRepository)
{
Guard.AgainstNullArgument(nameof(jobPositionRepository), jobPositionRepository);
Guard.AgainstNullArgument(nameof(teamRepository), teamRepository);
RuleFor(s => s.JobPositionId)
.MustAsync((id, token) => jobPositionRepository.Exists(id.Value))
.When(s => s.JobPositionId.HasValue)
.WithMessage(s => $"Должности с Id '{s.JobPositionId}' не существует.");
RuleFor(s => s.TeamId)
.MustAsync((id, token) => teamRepository.Exists(id.Value))
.When(s => s.TeamId.HasValue)
.WithMessage(s => $"Команды с Id '{s.JobPositionId}' не существует.");
RuleFor(s => s.FromCorrectAnswersCount)
.Must(number => number > 0)
.When(s => s.FromCorrectAnswersCount.HasValue)
.WithMessage("{PropertyName} не может быть меньше нуля.");
RuleFor(s => s.ToCorrectAnswersCount)
.Must(number => number > 0)
.When(s => s.FromCorrectAnswersCount.HasValue)
.WithMessage("{PropertyName} не может быть меньше нуля.");
}
public PeriodManagerService(
IPeriodRepository periodRep,
IEmployeeRepository employeeRepository,
ICalculationRepository calcRep,
IJobPositionRepository jobPositionRep,
IJobIndexPointRepository jobIndexPointRep,
IInquiryJobIndexPointRepository inquiryJobIndexPointRep,
IInquiryUnitIndexPointRepository inquiryUnitIndexPointRep,
IClaimRepository claimRep,
IEventPublisher publisher,
IInquiryConfiguratorService inquiryConfiguratorService,
IPeriodBasicDataCopierService periodCopierService
,
IEmployeePointManagerService employeePointManagerService
)
{
this.periodRep = periodRep;
this.employeeRepository = employeeRepository;
this.inquiryConfiguratorService = inquiryConfiguratorService;
this.periodCopierService = periodCopierService;
this.publisher = publisher;
this.calcRep = calcRep;
this.jobIndexPointRep = jobIndexPointRep;
this.jobPositionRep = jobPositionRep;
this.inquiryJobIndexPointRep = inquiryJobIndexPointRep;
this.claimRep = claimRep;
this.inquiryUnitIndexPointRep = inquiryUnitIndexPointRep;
this.employeePointManagerService = employeePointManagerService;
}
public CreateCommandHandler(IJobPositionRepository repository, IUnitOfWork unitOfWork, IMapper mapper, IAuthenticatedUserService authenticatedUser)
{
_repository = repository;
_unitOfWork = unitOfWork;
_mapper = mapper;
_authenticatedUser = authenticatedUser;
}
public VacancyValidator(IJobPositionRepository jobPositionRepository, ITeamRepository teamRepository)
{
RuleFor(m => m.Form).NotNull().WithMessage(Messages.NotNull)
.SetValidator(new FormValidator());
RuleFor(m => m.Status).Null()
.WithMessage("Нельзя задавать статус вакансии.");
RuleFor(m => m.JobPositionId).NotNull()
.WithMessage(Messages.NotNull)
.DependentRules(() =>
{
RuleFor(m => m.JobPositionId.Value)
.MustAsync((id, token) => jobPositionRepository.Exists(id))
.WithMessage("Должности с Id '{PropertyValue}' не существует.");
});
RuleFor(m => m.TeamId).NotNull()
.WithMessage(Messages.NotNull)
.DependentRules(() =>
{
RuleFor(m => m.TeamId.Value)
.MustAsync((id, token) => teamRepository.Exists(id))
.WithMessage("Команды с Id '{PropertyValue}' не существует.");
});
;
RuleFor(m => m.JobsNumber).NotNull()
.WithMessage(Messages.NotNull);
}
public PeriodServiceFacade(IPeriodService periodService,
IMapper <Period, PeriodDescriptionDTO> periodDescriptionMapper,
IMapper <Period, PeriodDTOWithAction> periodDTOWithActionsMapper,
IMapper <Period, PeriodDTO> periodDTOMapper,
IMapper <InquiryInitializingProgress, PeriodStateWithIntializeInquirySummaryDTO>
periodInitializeInquiryStateReportMapper,
IMapper <BasicDataCopyingProgress, PeriodStateWithCopyingSummaryDTO> periodCopyingStateReportMapper,
IPeriodRepository periodRep, IPeriodEngineService periodEngine, IEmployeeRepository employeeRepository,
IJobPositionRepository jobPositionRepository, IUnitRepository unitRepository,
IJobIndexPointRepository jobIndexPointRepository, ICalculationRepository calculationRepository, IJobIndexRepository jobIndexRepository)
{
this.periodService = periodService;
this.periodDescriptionMapper = periodDescriptionMapper;
this.periodDTOWithActionsMapper = periodDTOWithActionsMapper;
this.periodDTOMapper = periodDTOMapper;
this.periodInitializeInquiryStateReportMapper = periodInitializeInquiryStateReportMapper;
this.periodCopyingStateReportMapper = periodCopyingStateReportMapper;
this.periodRep = periodRep;
this.periodEngine = periodEngine;
this.employeeRepository = employeeRepository;
this.jobPositionRepository = jobPositionRepository;
this.unitRepository = unitRepository;
this.jobIndexPointRepository = jobIndexPointRepository;
this.calculationRepository = calculationRepository;
this.jobIndexRepository = jobIndexRepository;
}
public JobPositionFacadeService(IMapper <JobPosition, JobPositionDTOWithActions> jobPositionWithActionMapper,
IMapper <JobPosition, JobPositionDTO> jobPositionMapper,
IJobPositionService jobPositionService,
IJobPositionRepository jobPositionRep)
{
this.jobPositionWithActionMapper = jobPositionWithActionMapper;
this.jobPositionMapper = jobPositionMapper;
this.jobPositionService = jobPositionService;
this.jobPositionRep = jobPositionRep;
}
public UpdateJobPositionHandler(
IJobPositionRepository jobPositionRepository,
IUnitOfWork unitOfWork)
{
Guard.AgainstNullArgument(nameof(jobPositionRepository), jobPositionRepository);
Guard.AgainstNullArgument(nameof(unitOfWork), unitOfWork);
_jobPositionRepository = jobPositionRepository;
_unitOfWork = unitOfWork;
}
public static JobPosition CreateJobPosition(IJobPositionRepository jobPositionRepository, PMSAdmin.Domain.Model.JobPositions.JobPosition adminJobPosition, JobPosition parent, Job job, Unit unit, Dictionary <string, List <string> > indexValues)
{
var jobPosition = new JobPosition(Period,
new SharedJobPosition(new SharedJobPositionId(adminJobPosition.Id.Id), adminJobPosition.Name,
adminJobPosition.DictionaryName), parent, job, unit);
jobPositionRepository.Add(jobPosition);
JobPositions.Add(jobPosition, indexValues);
return(jobPosition);
}
public InquiryServiceFacade(IInquiryService inquiryService,
IMapper <InquirySubjectWithJobPosition, InquirySubjectDTO> inquiySubjectMapper,
IJobIndexRepository jobIndexRep, IJobPositionRepository jobPositionRepository, IEmployeeRepository employeeRepository, IInquiryJobIndexPointRepository inquiryJobIndexPointRepository)
{
this.inquiryService = inquiryService;
this.inquiySubjectMapper = inquiySubjectMapper;
this.jobIndexRep = jobIndexRep;
this.jobPositionRepository = jobPositionRepository;
this.employeeRepository = employeeRepository;
this.inquiryJobIndexPointRepository = inquiryJobIndexPointRepository;
}
public EmployeeService(IEmployeeRepository employeeRep, IPeriodRepository periodRep, IPMSAdminService converter,
IJobPositionRepository jobPositionRep, IPeriodManagerService periodChecker, IJobIndexPointRepository jobIndexPointRepository, ICalculationRepository calculationRepository)
{
this.employeeRep = employeeRep;
this.periodRep = periodRep;
this.converter = converter;
this.jobPositionRep = jobPositionRep;
this.periodChecker = periodChecker;
this.jobIndexPointRepository = jobIndexPointRepository;
this.calculationRepository = calculationRepository;
}
public InquiryJobIndexPointCreatorService(IJobPositionRepository jobPositionRep,
IJobRepository jobRep,
IJobIndexRepository jobIndexRep,
IInquiryJobIndexPointRepository inquiryJobIndexPointRep, IEventPublisher publisher)
{
this.jobPositionRep = jobPositionRep;
this.jobRep = jobRep;
this.jobIndexRep = jobIndexRep;
this.inquiryJobIndexPointRep = inquiryJobIndexPointRep;
this.publisher = publisher;
}
public GetJobPositionValidator(IJobPositionRepository jobPositionRepository)
{
RuleFor(g => g.JobPositionId)
.NotNull()
.WithMessage(Messages.NotNull)
.DependentRules(() =>
{
RuleFor(g => g.JobPositionId)
.MustAsync((id, token) => jobPositionRepository.Exists(id.Value))
.WithMessage(g => $"Должности с Id '{g.JobPositionId}' не существует.");
});
}
public JobPositionService(
IMapper mapper,
ILogger <JobPositionService> logger,
IJobPositionRepository jobPositionRepository,
IStringLocalizer <JobPositionService> stringLocalizer,
ApplicationDbContext context)
{
_mapper = mapper;
_logger = logger;
_jobPositionRepository = jobPositionRepository;
_stringLocalizer = stringLocalizer;
_context = context;
}
public JobPositionController(
UserManager <ApplicationUser> userManager,
ApplicationDbContext context,
IJobPositionRepository jobPositionRepository,
IMapper mapper,
IJobPositionService jobPositionService,
IStringLocalizer <JobPositionController> stringLocalizer)
{
_userManager = userManager;
_context = context;
_jobPositionRepository = jobPositionRepository;
_mapper = mapper;
_jobPositionService = jobPositionService;
_stringLocalizer = stringLocalizer;
}
public CreateJobPositionValidator(IJobPositionRepository jobPositionRepository)
{
RuleFor(p => p.JobPosition).NotNull()
.DependentRules(() =>
{
RuleFor(p => p.JobPosition.Id).Null();
RuleFor(p => p.JobPosition).SetValidator(new JobPositionValidator())
.DependentRules(() =>
{
RuleFor(c => c.JobPosition.Title)
.MustAsync(async(title, token) => !(await jobPositionRepository.Exists(title)))
.WithMessage("Нельзя добавить должность с таким же именем.");
});
});
}
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 PeriodJobPositionServiceFacade(IJobPositionService jobPositionService,
IMapper <JobPosition, JobPositionInPeriodAssignmentDTO> jobPositionAssignmentMapper,
IMapper <JobPosition, JobPositionInPeriodDTOWithActions> jobPositionInPeriodDTOWithActionsMapper,
IMapper <JobPosition, JobPositionInPeriodDTO> jobPositionInPeriodDTOMapper,
IJobPositionRepository jobPositionRep,
IEmployeeRepository employeeRep,
IUnitRepository unitRepository,
IJobRepository jobRepository)
{
this.jobPositionService = jobPositionService;
this.jobPositionAssignmentMapper = jobPositionAssignmentMapper;
this.jobPositionInPeriodDTOWithActionsMapper = jobPositionInPeriodDTOWithActionsMapper;
this.jobPositionInPeriodDTOMapper = jobPositionInPeriodDTOMapper;
this.jobPositionRep = jobPositionRep;
this.employeeRep = employeeRep;
_unitRepository = unitRepository;
_jobRepository = jobRepository;
}
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 PeriodJobServiceFacade(IJobService jobService,
IJobIndexService jobIndexService,
IFilterMapper <Job, JobInPeriodDTOWithActions> jobInPeriodDTOWithActionsMapper,
IFilterMapper <Job, JobInPeriodDTO> jobInPeriodDTOMapper,
IMapper <JobCustomField, CustomFieldDTO> jobCustomFieldMapper,
IMapper <AbstractJobIndex, AbstractIndexInPeriodDTO> jobIndexInPeriodMapper,
IJobRepository jobRep,
IJobPositionRepository jobPositionRep
)
{
this.jobService = jobService;
this.jobIndexService = jobIndexService;
this.jobInPeriodDTOWithActionsMapper = jobInPeriodDTOWithActionsMapper;
this.jobInPeriodDTOMapper = jobInPeriodDTOMapper;
this.jobCustomFieldMapper = jobCustomFieldMapper;
this.jobIndexInPeriodMapper = jobIndexInPeriodMapper;
this.jobRep = jobRep;
this.jobPositionRep = jobPositionRep;
}
public InquiryService(IJobPositionInquiryConfiguratorService configurator,
IEmployeeRepository employeeRep,
IInquiryJobIndexPointRepository inquiryJobIndexPointRep,
IJobPositionRepository jobPositionRep,
IJobRepository jobRep,
IJobIndexRepository jobIndexRep,
IInquiryJobIndexPointService inquiryJobIndexPointService,
IInquiryJobIndexPointRepository inquiryJobIndexPointRepository,
IPeriodManagerService periodChecker
)
{
this.configurator = configurator;
this.employeeRep = employeeRep;
this.inquiryJobIndexPointRep = inquiryJobIndexPointRep;
this.jobPositionRep = jobPositionRep;
this.jobRep = jobRep;
this.jobIndexRep = jobIndexRep;
this.inquiryJobIndexPointService = inquiryJobIndexPointService;
this.inquiryJobIndexPointRepository = inquiryJobIndexPointRepository;
this.periodChecker = periodChecker;
}
public RepositoryWrapper(
CoreContext repositoryContext,
IUserRepository userRepository,
IUndergraduateRepository undergraduateRepository,
IRoleRepository roleRepository,
IEmployeeRepository employeeRepository,
IGraduateRepository graduateRepository,
IUJournalRepository uJournalRepository,
IGJournalRepository gJournalRepository,
IAcademicDegreeRepository degreeRepository,
IAcademicRankRepository rankRepository,
IJobPositionRepository positionRepository,
IDepartmentRepository departmentRepository,
ISpecialtyRepository specialtyRepository,
IExamRepository examRepository,
IWorkPlanRepository workPlanRepository,
IEducationPhaseRepository educationPhases
)
{
this._dbContext = repositoryContext;
this._userRepository = userRepository;
this._undergraduateRepository = undergraduateRepository;
this._roleRepository = roleRepository;
this._employeeRepository = employeeRepository;
this._graduateRepository = graduateRepository;
this._uJournalRepository = uJournalRepository;
this._gJournalRepository = gJournalRepository;
this._degreeRepository = degreeRepository;
this._rankRepository = rankRepository;
this._positionRepository = positionRepository;
this._departmentRepository = departmentRepository;
this._specialtyRepository = specialtyRepository;
this._examRepository = examRepository;
this._workPlanRepository = workPlanRepository;
this._educationPhases = educationPhases;
}
public UpdateJobPositionValidator(IJobPositionRepository jobPositionRepository)
{
RuleFor(u => u.JobPosition).NotNull()
.DependentRules(() =>
{
RuleFor(u => u.JobPosition.Id)
.NotNull()
.WithMessage(Messages.NotNull)
.DependentRules(() =>
{
RuleFor(u => u.JobPosition.Id)
.MustAsync((id, token) => jobPositionRepository.Exists(id.Value))
.WithMessage("Должности с Id '{PropertyValue}' не существуют.");
});
RuleFor(u => u.JobPosition).SetValidator(new JobPositionValidator())
.DependentRules(() =>
{
RuleFor(u => u.JobPosition)
.MustAsync(async(jobPosition, token) => !(await jobPositionRepository.Exists(jobPosition.Title, jobPosition.Id)))
.WithMessage(u => $"Должность с таким названием '{u.JobPosition.Title}' уже существует.");
});
});
}
public UnitInquiryConfiguratorService(IUnitRepository unitRep, IJobPositionRepository jobPositionRepository, IJobPositionInquiryConfiguratorService jobPositionInquiryConfiguratorService)
{
this._unitRep = unitRep;
_jobPositionRepository = jobPositionRepository;
_jobPositionInquiryConfiguratorService = jobPositionInquiryConfiguratorService;
}
public JobPositionController(IJobPositionRepository jobPositionRepository)
{
_jobPositionRepository = jobPositionRepository;
}
public JobPositionService(IJobPositionRepository jobPositionRepository, IUnitOfWork unitOfWork)
{
this.jobPositionRepository = jobPositionRepository;
this.unitOfWork = unitOfWork;
}
public GetAllQueryHandler(IJobPositionRepository repository)
{
_repository = repository;
}
public JobPositionListCommandHandler(IJobPositionRepository jobPositionRepository, IMapper mapper)
{
_jobPositionRepository = jobPositionRepository;
_mapper = mapper;
}
public JobPositionService(IJobPositionRepository jobPositionRep)
{
this.jobPositionRep = jobPositionRep;
}
public SearchJobPositionsHandler(IJobPositionRepository jobPositionRepository)
{
Guard.AgainstNullArgument(nameof(jobPositionRepository), jobPositionRepository);
_jobPositionRepository = jobPositionRepository;
}
public JobPositionInquiryConfiguratorService(IJobPositionRepository jobPositionRep)
{
this.jobPositionRep = jobPositionRep;
}
public AddEmployeeCommandHandler(IEmployeesRepository employeesRepository, IJobPositionRepository positionRepository, IEmployeeJPRepository employeeJpRepository)
{
this.employeesRepository = employeesRepository;
this.positionRepository = positionRepository;
this.employeeJpRepository = employeeJpRepository;
}
