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); }