Beispiel #1
0
        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());
        }
Beispiel #3
0
        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));
            });
        }
Beispiel #4
0
 public DeleteRequirementUseCase(
     ISecurityGateway securityGateway,
     IRequirementRepository requirementRepository)
 {
     _securityGateway       = securityGateway;
     _requirementRepository = requirementRepository;
 }
Beispiel #5
0
 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;
 }
Beispiel #7
0
        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);
        }
Beispiel #8
0
 public AddRequirementUseCase(
     ISecurityGateway securityGateway,
     IProjectRepository projectRepository,
     IRequirementRepository requirementRepository,
     IUserRepository userRepository)
 {
     _securityGateway       = securityGateway;
     _projectRepository     = projectRepository;
     _userRepository        = userRepository;
     _requirementRepository = requirementRepository;
 }
Beispiel #9
0
 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;
 }
Beispiel #10
0
        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();
        }
Beispiel #12
0
 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;
 }
Beispiel #13
0
        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;
 }
Beispiel #15
0
        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);
        }
Beispiel #16
0
 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;
 }
Beispiel #17
0
 public RequirementsController(IRequirementRepository requirementRepository)
 {
     _requirementRepository = requirementRepository;
 }
Beispiel #18
0
        public GraduationTracker()
        {
            var datacontext = new Data.DataStore();

            this.requirementRepository = new RequirementRepository(datacontext);
        }
Beispiel #19
0
 public GraduationTracker(IRequirementRepository requirementRepository, IDiplomaRepository diplomaRepository, IStudentRepository studentRepository)
 {
     _requirementRepository = requirementRepository;
     _diplomaRepository     = diplomaRepository;
     _studentRepository     = studentRepository;
 }
Beispiel #20
0
 public GraduationTracker()
 {
     RequirementRepository = new RequirementRepository();
 }
Beispiel #21
0
 public DiplomaRepository()
 {
     _requirementRepository = new RequirementRepository();
 }
Beispiel #22
0
 public RequirementsController(IRequirementRepository requirementRepository,
                               IUnitOfWork unitOfWork)
 {
     _requirementRepository = requirementRepository;
     _unitOfWork            = unitOfWork;
 }
Beispiel #23
0
 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);
        }