public RequirementsController(IRequirementRepository requirementRepository,
IRequirementActivityRepository requirementActivityRepository,
IRequirementDocumentRepository requirementDocumentRepository,
IRequirementTechnologyMapRepository requirementTechnologyMapRepository,
IRequirementCategoryRepository requirementCategoryRepository,
ITechnologyRepository technologyRepository,
IUserRepository userRepository,
ICRMContactRepository crmContactRepository,
ICRMLeadSourceRepository crmLeadSourceRepository,
IRequirementService requirementService,
EmailComposerService emailComposerService,
IUnitOfWork unitOfWork)
{
_requirementRepository = requirementRepository;
_requirementActivityRepository = requirementActivityRepository;
_requirementDocumentRepository = requirementDocumentRepository;
_requirementTechnologyMapRepository = requirementTechnologyMapRepository;
_requirementCategoryRepository = requirementCategoryRepository;
_requirementService = requirementService;
_technologyRepository = technologyRepository;
_userRepository = userRepository;
_crmContactRepository = crmContactRepository;
_crmLeadSourceRepository = crmLeadSourceRepository;
_unitOfWork = unitOfWork;
_emailComposerService = emailComposerService;
}
public ProductBacklogQuery(
IProjectRepository projectsRepository,
IRequirementRepository requirementsRepository)
{
Field <ListGraphType <ProjectType> >(
"projects",
resolve: context => projectsRepository.GetAll()
);
Field <ProjectType>(
"project",
arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> >
{
Name = "id"
}),
resolve: context =>
{
var id = context.GetArgument <int>("id");
return(projectsRepository.GetById(id));
}
);
Field <ListGraphType <RequirementType> >(
"requirements",
resolve: context => requirementsRepository.GetAll());
}
public ProjectType(
IDataLoaderContextAccessor dataLoaderAccessor,
IRequirementRepository requirementRepository,
IProjectRepository projectRepository)
{
Field(x => x.Id);
Field(x => x.Title);
Field(x => x.Description);
Field(x => x.RepositoryUrl);
Field(x => x.ProjectUrl);
Field(x => x.CreatedAt);
Field <ProjectTypeEnumType>(nameof(ProjectModel.Type));
Field <ProjectType>(
nameof(ProjectModel.ParentProject),
resolve: context => context.Source.ParentProjectId.HasValue ? projectRepository.GetById(context.Source.ParentProjectId.Value) : null);
Field <ListGraphType <ProjectType> >(
nameof(ProjectModel.Subprojects),
resolve: context => projectRepository.GetSubprojects(context.Source.Id));
Field <ListGraphType <RequirementType> >(
nameof(ProjectModel.Requirements),
resolve: context =>
{
var loader = dataLoaderAccessor.Context.GetOrAddCollectionBatchLoader <int, RequirementModel>(
"GetRequirementsByProjectId", requirementRepository.GetForProjects);
return(loader.LoadAsync(context.Source.Id));
});
}
public DeleteRequirementUseCase(
ISecurityGateway securityGateway,
IRequirementRepository requirementRepository)
{
_securityGateway = securityGateway;
_requirementRepository = requirementRepository;
}
public TenderModule(ITenderRepository tenderRepository, IEmployeeRepository employeeRepository, IRequirementRepository requirementRepository, IWorkhourRepository workhourRepository, IGroupRepository groupRepository)
{
_tenderRepository = tenderRepository;
_employeeRepository = employeeRepository;
_requirementRepository = requirementRepository;
_workhourRepository = workhourRepository;
_groupRepository = groupRepository;
}
public RMSDashboardController(IRequirementRepository requirementRepository,
IRequirementCategoryRepository requirementCategoryRepository,
ICRMLeadSourceRepository crmLeadSourceRepository,
IUnitOfWork unitOfWork)
{
_requirementRepository = requirementRepository;
_requirementCategoryRepository = requirementCategoryRepository;
_crmLeadSourceRepository = crmLeadSourceRepository;
_unitOfWork = unitOfWork;
}
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;
}
if (entityTypeRepository != null)
{
entityTypeRepository.Dispose();
entityTypeRepository = null;
}
}
base.Dispose(disposing);
}
public AddRequirementUseCase(
ISecurityGateway securityGateway,
IProjectRepository projectRepository,
IRequirementRepository requirementRepository,
IUserRepository userRepository)
{
_securityGateway = securityGateway;
_projectRepository = projectRepository;
_userRepository = userRepository;
_requirementRepository = requirementRepository;
}
public HtmlExportActivity
(
ITimeService timeService, IHtmlExportPluginConfiguration htmlExportPluginConfiguration,
IHtmlExportService htmlExportService, IRequirementRepository requirementRepository, IRepositoryStorage repositoryStorage, IBoundary boundary
)
: base(timeService, htmlExportPluginConfiguration)
{
this.htmlExportService = htmlExportService;
this.requirementRepository = requirementRepository;
this.repositoryStorage = repositoryStorage;
this.boundary = boundary;
outputPath = htmlExportPluginConfiguration.OutputPath;
}
public StudentStandingService(IRequirementRepository requirementRepository, IStudentRepository studentRepository)
{
_standingRules = new List <IStandingRule>()
{
new RemedialRule(),
new AverageRule(),
new MagnaCumLaudeRule(),
new SumaCumLaudeRule()
};
_requirementRepository = requirementRepository;
_studetnRepository = studentRepository;
}
/// <summary>
/// Initializes a new instance of the AddSeniorVM class.
/// </summary>
public AddSeniorVM(INavigationService navService,
IPersonRepository _people,
IAppointmentRepository _appts,
IRequirementRepository _reqs,
IAppointmentRequirementsRepository _apptReqs)
{
_personRepo = _people;
_appointmentRepo = _appts;
_requirementRepo = _reqs;
_apptRequirementRepo = _apptReqs;
NavigationService = navService;
Refresh();
}
public RequirementService(
IRequirementRepository repository,
IProjectService projectService,
IRequirementCharacteristicsService requirementCharacteristicsService,
ICharacteristicsService characteristicsService,
IRequirementRequestForChangesService requestService,
IRequirementVersionsService versionService,
IUnitOfWork unit) : base(repository, unit)
{
requirementRepository = repository;
this.requirementCharacteristicsService = requirementCharacteristicsService;
this.characteristicsService = characteristicsService;
this.projectService = projectService;
this.requestService = requestService;
this.versionService = versionService;
}
public RequirementService(IRequirementTechnologyMapRepository requirementTechnologyMapRepository,
IRequirementActivityRepository requirementActivityRepository,
IRequirementDocumentRepository requirementDocumentRepository,
IRequirementRepository requirementRepository,
ISettingsService settingsService,
IUserRepository userRepository,
IUnitOfWork unitOfWork)
{
_requirementTechnologyMapRepository = requirementTechnologyMapRepository;
_requirementActivityRepository = requirementActivityRepository;
_requirementDocumentRepository = requirementDocumentRepository;
_requirementRepository = requirementRepository;
_settingsService = settingsService;
_userRepository = userRepository;
_unitOfWork = unitOfWork;
}
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;
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
if (presentationRepository != null)
{
presentationRepository.Dispose();
presentationRepository = null;
}
//documentFileService.Dispose();
if (requirementRepository != null)
{
requirementRepository.Dispose();
requirementRepository = null;
}
}
base.Dispose(disposing);
}
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 RequirementsController(IRequirementRepository requirementRepository)
{
_requirementRepository = requirementRepository;
}
public GraduationTracker()
{
var datacontext = new Data.DataStore();
this.requirementRepository = new RequirementRepository(datacontext);
}
public GraduationTracker(IRequirementRepository requirementRepository, IDiplomaRepository diplomaRepository, IStudentRepository studentRepository)
{
_requirementRepository = requirementRepository;
_diplomaRepository = diplomaRepository;
_studentRepository = studentRepository;
}
public GraduationTracker()
{
RequirementRepository = new RequirementRepository();
}
public DiplomaRepository()
{
_requirementRepository = new RequirementRepository();
}
public RequirementsController(IRequirementRepository requirementRepository,
IUnitOfWork unitOfWork)
{
_requirementRepository = requirementRepository;
_unitOfWork = unitOfWork;
}
public PresentationsController(IPresentationRepository presentationRepo, IDocumentFileService documentFileServ, IRequirementRepository requirementRepo)
{
presentationRepository = presentationRepo;
documentFileService = documentFileServ;
requirementRepository = requirementRepo;
}
public RequirementService(IRequirementRepository requirementRepository, IUnitOfWork unitOfWork)
{
_requirementRepository = requirementRepository;
_unitOfWork = unitOfWork;
}
public GraduationTracker(IRequirementRepository requirement, IStudent student, IDiploma diploma)
{
_reqRepo = requirement;
_student = student;
_diploma = diploma;
}
public void Setup()
{
_mockDbSettings.Setup(x => x.ConnectionString).Returns("TestConnectionString");
_mockContext.Setup(x => x.Applications).Returns(_mockDbSet.Object);
_mockContext.Setup(x => x.SaveChanges()).Returns(1);
_mockRequirementMapper.Setup(x => x.Map(It.IsAny<Requirement>(), It.IsAny<Requirement>())).Returns(true);
_requirementRepository = new RequirementRepository(_mockContext.Object, _mockRequirementMapper.Object);
}
