Exemple #1
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="repo">The current repository</param>
 /// <param name="paramService">The current param service</param>
 /// <param name="storage">The current storage manager</param>
 /// <param name="cache">The optional model cache</param>
 /// <param name="processor">The optional image processor</param>
 public MediaService(IMediaRepository repo, IParamService paramService, IStorage storage, IImageProcessor processor = null, ICache cache = null)
 {
     _repo         = repo;
     _paramService = paramService;
     _storage      = storage;
     _processor    = processor;
     _cache        = cache;
 }
Exemple #2
0
 public RoomService(IRepositoryWrapper repoWrapper, IMapper mapper, IParamService param,
                    ISieveProcessor sieveProcessor)
 {
     _repoWrapper    = repoWrapper;
     _mapper         = mapper;
     _param          = param;
     _sieveProcessor = sieveProcessor;
 }
Exemple #3
0
 public IssueTicketService(IRepositoryWrapper repoWrapper, IMapper mapper, ISieveProcessor sieveProcessor, IParamService paramService, IStudentService studentService)
 {
     _repoWrapper    = repoWrapper;
     _mapper         = mapper;
     _sieveProcessor = sieveProcessor;
     _paramService   = paramService;
     _studentService = studentService;
 }
 public ArchiveService(IArchiveRepository repo, IParamService paramService, IPostService postService)
 {
     base();
     this._repo         = repo;
     this._paramService = paramService;
     this._postService  = postService;
     return;
 }
 public RenewContractService(IRepositoryWrapper repoWrapper, IStudentService studentService, ISieveProcessor sieveProcessor, IParamService paramService, IStaffService staffService)
 {
     _repoWrapper    = repoWrapper;
     _studentService = studentService;
     _sieveProcessor = sieveProcessor;
     _paramService   = paramService;
     _staffService   = staffService;
 }
        public AutoAssignRoleService(IAPIService apiService, IDiscordPayloadFactory discordPayloadFactory, DiscordSocketClient client,
                                     IParamService paramService)
        {
            _apiService            = apiService;
            _discordPayloadFactory = discordPayloadFactory;
            _paramService          = paramService;

            client.UserJoined += UserJoinedGuild;
        }
Exemple #7
0
 public RoomTransferService(IRepositoryWrapper repoWrapper, IMapper mapper, ISieveProcessor sieveProcessor, IStudentService studentService, IParamService paramService, IUserService userService)
 {
     _repoWrapper    = repoWrapper;
     _mapper         = mapper;
     _sieveProcessor = sieveProcessor;
     _studentService = studentService;
     _paramService   = paramService;
     _userService    = userService;
 }
Exemple #8
0
 public EquipmentService(IRepositoryWrapper repoWrapper, IMapper mapper, IAdminService admin, IRoomService room,
                         IParamService param, ISieveProcessor sieveProcessor)
 {
     _repoWrapper    = repoWrapper;
     _mapper         = mapper;
     _admin          = admin;
     _room           = room;
     _param          = param;
     _sieveProcessor = sieveProcessor;
 }
Exemple #9
0
 public MediaService(IMediaRepository repo, IParamService paramService, IStorage storage, IImageProcessor processor = null, ICache cache = null)
 {
     base();
     this._repo         = repo;
     this._paramService = paramService;
     this._storage      = storage;
     this._processor    = processor;
     this._cache        = cache;
     return;
 }
Exemple #10
0
 public TestService(IFileRepo fileRepo,
                    IFunctionSettingsService functionSettings,
                    IPublishSettingsService pubSettingsService,
                    ILocalLogService localLogService,
                    IParamService paramService)
 {
     this._paramService       = paramService;
     this._localLogService    = localLogService;
     this._pubSettingsService = pubSettingsService;
     this._functionSettings   = functionSettings;
     this._fileRepo           = fileRepo;
 }
Exemple #11
0
        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="repo">The main repository</param>
        /// <param name="cache">The optional model cache</param>
        public PageService(IPageRepository repo, IContentFactory factory, ISiteService siteService, IParamService paramService, ICache cache = null)
        {
            _repo         = repo;
            _factory      = factory;
            _siteService  = siteService;
            _paramService = paramService;

            if ((int)App.CacheLevel > 2)
            {
                _cache = cache;
            }
        }
 public CommandProcessorService(ILocalLogService logService,
                                IKuduLogService kuduLogService, IKuduFileService fileService,
                                IPublishSettingsService publishSettingsService,
                                IParamService paramService,
                                ITestService testService)
 {
     this._paramService      = paramService;
     _testService            = testService;
     _logService             = logService;
     _kuduLogService         = kuduLogService;
     _fileService            = fileService;
     _publishSettingsService = publishSettingsService;
 }
 public PageService(IPageRepository repo, IContentFactory factory, ISiteService siteService, IParamService paramService, IMediaService mediaService, ICache cache = null, ISearch search = null)
 {
     base();
     this._repo         = repo;
     this._factory      = factory;
     this._siteService  = siteService;
     this._paramService = paramService;
     this._mediaService = mediaService;
     this._search       = search;
     if (App.get_CacheLevel() > 2)
     {
         this._cache = cache;
     }
     return;
 }
 /// <summary>
 /// Dependency injection
 /// </summary>
 /// <param name="resourceService">provides all services except authorization</param>
 /// <param name="scenarioService">check for stale scenario data</param>
 /// <param name="scenarioGroupService">provides authorization</param>
 /// <param name="docuService">provides documentary information</param>
 /// <param name="paramService">provides param data</param>
 public ResourceController(IResourceServiceFacade resourceService,
     IScenarioService scenarioService,
     IScenarioGroupService scenarioGroupService,
     IDocuService docuService,
     IParamService paramService)
 {
     if (resourceService == null)
     {
         throw new ArgumentNullException("resourceService");
     }
     _ResourceService = resourceService;
     _ScenarioService = scenarioService;
     _ScenarioGroupService = scenarioGroupService;
     _DocuService = docuService;
     _ParamService = paramService;
 }
        /// <summary>
        /// Default constructor.
        /// </summary>
        /// <param name="repo">The main repository</param>
        /// <param name="factory">The content factory</param>
        /// <param name="siteService">The site service</param>
        /// <param name="pageService">The page service</param>
        /// <param name="paramService">The param service</param>
        /// <param name="mediaService">The media service</param>
        /// <param name="cache">The optional model cache</param>
        /// <param name="search">The optional search service</param>
        public PostService(IPostRepository repo, IContentFactory factory, ISiteService siteService, IPageService pageService,
                           IParamService paramService, IMediaService mediaService, ICache cache = null, ISearch search = null)
        {
            _repo         = repo;
            _factory      = factory;
            _siteService  = siteService;
            _pageService  = pageService;
            _paramService = paramService;
            _mediaService = mediaService;
            _search       = search;

            if ((int)App.CacheLevel > 2)
            {
                _cache = cache;
            }
        }
Exemple #16
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="api">The current api</param>
 public Config(IApi api)
 {
     _service = api.Params;
 }
Exemple #17
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="paramService">The current param service</param>
 public Config(IParamService paramService)
 {
     _service = paramService;
 }
Exemple #18
0
 public RoomsAndEquipmentTypesService(IParamService paramService, ISieveProcessor sieveProcessor, IRepositoryWrapper repoWrapper)
 {
     _paramService   = paramService;
     _sieveProcessor = sieveProcessor;
     _repoWrapper    = repoWrapper;
 }
 public SpamDetectorConfig(IParamService paramService)
 {
     _service = paramService;
 }
 public static void Delete(this IParamService service, Param model)
 {
     service.DeleteAsync(model).GetAwaiter().GetResult();
 }
 public static void Delete(this IParamService service, Guid id)
 {
     service.DeleteAsync(id).GetAwaiter().GetResult();
 }
 public static Param GetByKey(this IParamService service, string key)
 {
     return(service.GetByKeyAsync(key).GetAwaiter().GetResult());
 }
 public static Param GetById(this IParamService service, Guid id)
 {
     return(service.GetByIdAsync(id).GetAwaiter().GetResult());
 }
 public static IEnumerable <Param> GetAll(this IParamService service)
 {
     return(service.GetAllAsync().GetAwaiter().GetResult());
 }
 public SpamDetectorConfig(IApi api)
 {
     _service = api.Params;
 }
        public void SetUp()
        {
            _mockCategoryRepository = new Mock<IRepositoryAsync<Category>>();
            _mockClassificationRepository = new Mock<IRepositoryAsync<Classification>>();
            _mockFlowRepository = new Mock<IRepositoryAsync<Flow>>();
            _mockFlowPropertyRepository = new Mock<IRepositoryAsync<FlowProperty>>();
            _mockFlowTypeRepository = new Mock<IRepositoryAsync<FlowType>>();
            _mockFragmentRepository = new Mock<IRepositoryAsync<Fragment>>();
            _mockFragmentFlowRepository = new Mock<IRepositoryAsync<FragmentFlow>>();
            _mockFragmentStageRepository = new Mock<IRepositoryAsync<FragmentStage>>();
            _mockImpactCategoryRepository = new Mock<IRepositoryAsync<ImpactCategory>>();
            _mockLCIAMethodRepository = new Mock<IRepositoryAsync<LCIAMethod>>();
            _mockNodeCacheRepository = new Mock<IRepositoryAsync<NodeCache>>();
            _mockProcessRepository = new Mock<IRepositoryAsync<Process>>();
            _mockProcessFlowRepository = new Mock<IRepositoryAsync<ProcessFlow>>();
            _mockScenarioRepository = new Mock<IRepositoryAsync<Scenario>>();
            _mockScenarioGroupRepository = new Mock<IRepositoryAsync<ScenarioGroup>>();
            _mockFragmentNodeProcessRepository = new Mock<IRepositoryAsync<FragmentNodeProcess>>();
            _mockFragmentNodeFragmentRepository = new Mock<IRepositoryAsync<FragmentNodeFragment>>();
            _mockFlowFlowPropertyRepository = new Mock<IRepositoryAsync<FlowFlowProperty>>();
            _mockDependencyParamRepository = new Mock<IRepositoryAsync<DependencyParam>>();
            _mockFlowPropertyParamRepository = new Mock<IRepositoryAsync<FlowPropertyParam>>();
            _mockParamRepository = new Mock<IRepositoryAsync<Param>>();
            _mockScoreCacheRepository = new Mock<IRepositoryAsync<ScoreCache>>();
            _mockProcessSubstitutionRepository = new Mock<IRepositoryAsync<ProcessSubstitution>>();
            _mockFragmentSubstitutionRepository = new Mock<IRepositoryAsync<FragmentSubstitution>>();
            _mockBackgroundSubstitutionRepository = new Mock<IRepositoryAsync<BackgroundSubstitution>>();
            _mockBackgroundRepository = new Mock<IRepositoryAsync<Background>>();
            _mockProcessEmissionParamRepository = new Mock<IRepositoryAsync<ProcessEmissionParam>>();
            _mockFlowPropertyEmissionRepository = new Mock<IRepositoryAsync<FlowPropertyEmission>>();
            _mockProcessDissipationRepository = new Mock<IRepositoryAsync<ProcessDissipation>>();
            _mockProcessDissipationParamRepository = new Mock<IRepositoryAsync<ProcessDissipationParam>>();
            _mockLCIARepository = new Mock<IRepositoryAsync<LCIA>>();
            _mockCharacterizationParamRepository = new Mock<IRepositoryAsync<CharacterizationParam>>();
            _mockUnitOfWork = new Mock<IUnitOfWork>();

            //we do need to pass a mock repository to all these services as the ResourceController
            //expects the resource facade to be passed to it.  In turn the resource facade takes these
            //service types and methods.
            _flowTypeService = new FlowTypeService(_mockFlowTypeRepository.Object);
            //_categoryService = new CategoryService(_mockCategoryRepository.Object);
            //_classificationService = new ClassificationService(_mockClassificationRepository.Object);
            _fragmentService = new FragmentService(_mockFragmentRepository.Object);
            _fragmentFlowService = new FragmentFlowService(_mockFragmentFlowRepository.Object);
            //_fragmentStageService = new FragmentStageService(_mockFragmentStageRepository.Object);
            _flowService = new FlowService(_mockFlowRepository.Object);
            _flowPropertyService = new FlowPropertyService(_mockFlowPropertyRepository.Object);
            _impactCategoryService = new ImpactCategoryService(_mockImpactCategoryRepository.Object);
            _lciaMethodService = new LCIAMethodService(_mockLCIAMethodRepository.Object);
            _processService = new ProcessService(_mockProcessRepository.Object);
            _processFlowService = new ProcessFlowService(_mockProcessFlowRepository.Object);
            _scenarioService = new ScenarioService(_mockScenarioRepository.Object);
            _scenarioGroupService = new ScenarioGroupService(_mockScenarioGroupRepository.Object);
            _nodeCacheService = new NodeCacheService(_mockNodeCacheRepository.Object);
            //_fragmentNodeProcessService = new FragmentNodeProcessService(_mockFragmentNodeProcessRepository.Object);
            //_fragmentNodeFragmentService = new FragmentNodeFragmentService(_mockFragmentNodeFragmentRepository.Object);
            _flowFlowPropertyService = new FlowFlowPropertyService(_mockFlowFlowPropertyRepository.Object);
            //_dependencyParamService = new DependencyParamService(_mockDependencyParamRepository.Object);
            //_flowPropertyParamService = new FlowPropertyParamService(_mockFlowPropertyParamRepository.Object);
            //_flowPropertyParamService = new FlowPropertyParamService(_mockFlowPropertyParamRepository.Object);
            _paramService = new ParamService(_mockParamRepository.Object);
            _scoreCacheService = new ScoreCacheService(_mockScoreCacheRepository.Object);
            //_processSubstitutionService = new ProcessSubstitutionService(_mockProcessSubstitutionRepository.Object);
            //_fragmentSubstitutionService = new FragmentSubstitutionService(_mockFragmentSubstitutionRepository.Object);
            //_backgroundSubstitutionService = new BackgroundSubstitutionService(_mockBackgroundSubstitutionRepository.Object);
            //_backgroundService = new BackgroundService(_mockBackgroundRepository.Object);
            //_processEmissionParamService = new ProcessEmissionParamService(_mockProcessEmissionParamRepository.Object);
            //_flowPropertyEmissionService = new FlowPropertyEmissionService(_mockFlowPropertyEmissionRepository.Object);
            _processDissipationService = new ProcessDissipationService(_mockProcessDissipationRepository.Object);
            //_processDissipationParamService = new ProcessDissipationParamService(_mockProcessDissipationParamRepository.Object);
            _lciaService = new LCIAService(_mockLCIARepository.Object);
            //_characterizationParamService = new CharacterizationParamService(_mockCharacterizationParamRepository.Object);
            _unitOfWork = _mockUnitOfWork.Object;

            //methods that resource service facade is dependent on.
            _fragmentTraversalV2 = new FragmentTraversalV2(
                _fragmentFlowService,
                _nodeCacheService,
                _processFlowService,
                _flowFlowPropertyService);

            _lciaComputation = new LCIAComputationV2(_processFlowService,
                //_processEmissionParamService,
            _lciaMethodService,
            _flowService,
                //_flowFlowPropertyService,
                //_flowPropertyParamService,
                //_flowPropertyEmissionService,
            _processDissipationService,
                //_processDissipationParamService,
            _lciaService);
            //_characterizationParamService,
            //_paramService);

            _fragmentLCIAComputation = new FragmentLCIAComputation(_fragmentTraversalV2,
                _lciaComputation,
                _fragmentFlowService,
                _scoreCacheService,
                _nodeCacheService,
            //_fragmentNodeProcessService,
            //_processSubstitutionService,
            //_fragmentNodeFragmentService,
            //_fragmentSubstitutionService,
                _lciaMethodService,
                _fragmentService,
                _scenarioService,
                _processFlowService,
            _unitOfWork);

            _resourceServiceFacade = new ResourceServiceFacade(
                               _fragmentService,
                               _fragmentFlowService,
                               _fragmentStageService,
                               _fragmentLCIAComputation,
                               _flowService,
                               _flowPropertyService,
                               _flowTypeService,
                               _impactCategoryService,
                               _lciaComputation,
                               _lciaMethodService,
                               _processService,
                               _processFlowService,
                               _scenarioService,
                               _paramService,
                               _flowFlowPropertyService,
                               _lciaService,
                               _cacheManager);

            _docuService = new DocuService();
            _cacheManager = new CacheManager(
                _scenarioService,
                _unitOfWork,
                _fragmentService,
                _fragmentLCIAComputation,
                _nodeCacheService,
                _scoreCacheService,
                _scenarioGroupService);

            _resourceController = new ResourceController(_resourceServiceFacade, _scenarioService, _scenarioGroupService, _docuService, _paramService);
        }
Exemple #27
0
 public Config(IParamService paramService)
 {
     base();
     this._service = paramService;
     return;
 }
Exemple #28
0
 public Config(IApi api)
 {
     base();
     this._service = api.get_Params();
     return;
 }
Exemple #29
0
 /// <summary>
 /// Default constructor.
 /// </summary>
 /// <param name="repo">The main repository</param>
 /// <param name="paramService">The param service</param>
 /// <param name="postService">The post service</param>
 public ArchiveService(IArchiveRepository repo, IParamService paramService, IPostService postService)
 {
     _repo         = repo;
     _paramService = paramService;
     _postService  = postService;
 }
Exemple #30
0
 public ParamsController(IParamService paramService)
 {
     _paramService = paramService;
 }
Exemple #31
0
 public MoneyTransactionService(IRepositoryWrapper repoWrapper, IStudentService studentService, IParamService paramService)
 {
     _repoWrapper    = repoWrapper;
     _studentService = studentService;
     _paramService   = paramService;
 }
 public ParamSessionService(IHttpContextAccessor httpContextAccessor, IParamService paramService)
 {
     _httpContextAccessor = httpContextAccessor;
     _paramService        = paramService;
 }