public override void SetUp() { base.SetUp(); ProjectRepositoryHelper<Project>.ConfigureerProjectRepository(); ProjectRepository = IoC.Resolve<IProjectRepository>(); project = new Project("ProjectNaam", "ProjectOmschrijving"); }
public static IAmendmentStrategy PickStrategy(IProjectRepository repo, ProjectAmendments amendment) { IAmendmentStrategy strategy = null; switch (amendment.AmendmentStatusId) { case 10734: // Amended case (Int32)Enums.TIPAmendmentStatus.Amended: case (Int32)Enums.TIPAmendmentStatus.Adopted: strategy = new AmendedToSubmitted(repo, amendment); break; case 10736: // Approved case 1769: strategy = new ApprovalToSubmitted(repo, amendment); break; case 10740: // Proposed case 1767: strategy = new ProposedToAmended(repo, amendment); break; case 10742: // Submitted case 1770: strategy = new SubmittedToProposed(repo, amendment); break; default: Logger.Warn("Unknown TIP Amendment status " + amendment.AmendmentStatusId); break; } return strategy; }
/// <summary> /// Initializes a new instance of the <see cref="FeedController" /> class. /// </summary> /// <param name="blogRepository">The blog repository.</param> /// <param name="projectRepository">Project repository</param> /// <param name="siteConfig">Site configuration</param> /// <param name="urlShortener">URL shortener</param> public FeedController(IBlogRepository blogRepository, IProjectRepository projectRepository, ISiteConfiguration siteConfig, IUrlShortener urlShortener) { _blogRepository = blogRepository; _projectRepository = projectRepository; _siteConfig = siteConfig; _urlShortener = urlShortener; }
protected ProjectBaseController(ICurtinUserService lookupService, IProjectRepository projectRepository, IFieldOfResearchRepository fieldOfResearchRepository, ISocioEconomicObjectiveRepository socioEconomicObjectiveRepository) : base(lookupService) { ProjectRepository = projectRepository; FieldOfResearchRepository = fieldOfResearchRepository; SocioEconomicObjectiveRepository = socioEconomicObjectiveRepository; }
public ProjectController(IUserRepository userRepository, IProjectRepository projectRepository, OrganizationRepository organizationRepository, BillingManager billingManager, NotificationSender notificationSender) { _userRepository = userRepository; _projectRepository = projectRepository; _organizationRepository = organizationRepository; _billingManager = billingManager; _notificationSender = notificationSender; }
public StatsController(ErrorStatsHelper statsHelper, IOrganizationRepository organizationRepository, IErrorStackRepository errorStackRepository, IProjectRepository projectRepository, ICacheClient cacheClient) { _cacheClient = cacheClient; _statsHelper = statsHelper; _organizationRepository = organizationRepository; _errorStackRepository = errorStackRepository; _projectRepository = projectRepository; }
public RemoveProjectWorkItemHandler(IProjectRepository projectRepository, IEventRepository eventRepository, IStackRepository stackRepository, ITokenRepository tokenRepository, IWebHookRepository webHookRepository) { _projectRepository = projectRepository; _eventRepository = eventRepository; _stackRepository = stackRepository; _tokenRepository = tokenRepository; _webHookRepository = webHookRepository; }
public ProjectServices(IDbContextScopeFactory dbContextScopeFactory, IProjectRepository projectRepository) { if (dbContextScopeFactory == null) throw new ArgumentNullException("dbContextScopeFactory"); if (projectRepository == null) throw new ArgumentNullException("projectRepository"); _dbContextScopeFactory = dbContextScopeFactory; _projectRepository = projectRepository; }
public UserProjectRoleRelationLogic(IUserRepository userRepository, IUserProjectRoleRelationRepository userProjectRoleRelationRepository, IRoleRepository roleRepository, IProjectRepository projectRepository) { _userRepository = userRepository; _userProjectRoleRelationRepository = userProjectRoleRelationRepository; _roleRepository = roleRepository; _projectRepository = projectRepository; }
public void Init() { _taskRepository = Substitute.For<TaskRepository>(); _projectRepository = Substitute.For<IProjectRepository>(); _console = Substitute.For<IConsole>(); _addTaskCommand = new AddTaskCommand(_console, _taskRepository, _projectRepository, "secrets Eat more donuts."); }
/// <summary> /// Initializes a new instance of the ConfirmController class. /// </summary> public ConfirmController(IProjectRepository projectRepository, IDataCollectionRepository dataCollectionRepository, ICurtinUserService lookupService, IBus bus) : base(lookupService) { _projectRepository = projectRepository; _dataCollectionRepository = dataCollectionRepository; _bus = bus; }
private void AssertCreatedEnvironment(DeployEnvironment result, DeployProject project, string environmentName, List<DeployEnvironmentConfiguration> environmentComponentList, List<DeployEnvironmentConfiguration> environmentConfigurationList, IProjectRepository sut) { Assert.IsNotNull(result); Assert.IsNotNullOrEmpty(result.Id); Assert.AreEqual(project.Id, result.ProjectId); Assert.AreEqual(environmentName, result.EnvironmentName); AssertHelpers.AssertCreatedBaseDto(result, this.UserName); environmentComponentList = environmentComponentList ?? new List<DeployEnvironmentConfiguration>(); Assert.AreEqual(environmentComponentList.Count(), result.ComponentList.Count); foreach(var item in environmentComponentList) { var createdItem = result.ComponentList.SingleOrDefault(i=>i.ParentId == item.ParentId); AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Component); } environmentConfigurationList = environmentConfigurationList ?? new List<DeployEnvironmentConfiguration>(); Assert.AreEqual(environmentConfigurationList.Count(), result.ConfigurationList.Count); foreach (var item in environmentConfigurationList) { var createdItem = result.ConfigurationList.SingleOrDefault(i => i.ParentId == item.ParentId); AssertCreatedEnvironmentConfiguration(item, createdItem, project, result, EnumDeployStepParentType.Configuration); } var dbItem = sut.GetEnvironment(result.Id, result.ProjectId); AssertEnvironment(result, dbItem); var dbProject = sut.GetProject(project.Id); var dbProjectEnvironment = dbProject.EnvironmentList.SingleOrDefault(i => i.Id == result.Id); Assert.IsNotNull(dbProjectEnvironment); AssertEnvironment(result, dbProjectEnvironment); }
public static Stack ToProjectLocalTime(this Stack stack, IProjectRepository repository) { if (stack == null) return null; return stack.ToProjectLocalTime(repository.GetById(stack.ProjectId, true)); }
public StatusReportController(IStatusReportRepository repository, ITopicRepository topicRepository, IProjectRepository projectRepository, IResourceRepository resourceRepository, IStatusReportManager statusReportManager, ITagRepository tagRepository) { _repository = repository; _topicRepository = topicRepository; _projectRepository = projectRepository; _resourceRepository = resourceRepository; _tagRepository = tagRepository; _statusReportManager = statusReportManager; Mapper.CreateMap<StatusReport, StatusReportViewModel>() .ForMember(m => m.NumberOfStatusItems, opt => opt.ResolveUsing<NumberOfStatusItemsFormatter>()); Mapper.CreateMap<StatusItem, StatusReportItemViewModel>() .ForMember(m => m.TagsString, opt => { opt.MapFrom(src => String.Join(",", (from tag in src.Tags select tag.Name))); opt.NullSubstitute(String.Empty); } ); Mapper.CreateMap<StatusReportItemViewModel, StatusItem>(); Mapper.CreateMap<Project, ProjectViewModel>(); Mapper.CreateMap<Tag, TagViewModel>(); //.ForMember(m => m.StatusReportId, opt => opt.M); //.ForMember(dest => dest.ProjectLeadFullName, opt => opt.MapFrom(src => src.Project.Lead.FullName)) //.ForMember(dest => dest.ProjectTeamLeadFullName, opt => opt.MapFrom(src => src.Project.Team.Lead.FullName)); }
public FirstSetupRepo() { this.session = HibernateUtil.OpenSession(false); this.userRepo = new UserRepository(session); this.projectRepo = new ProjectRepository(session); this.certificateTypeRepo = new InspectorCertificateTypeRepository(session); this.seemTypeRepo = new SeamTypeRepository(session); this.permissionRepo = new PermissionRepository(session); this.roleRepo = new RoleRepository(session); this.categoryRepo = new CategoryRepository(session); this.jointOperationRepo = new JointOperationRepository(session); this.pipeTestsRepo = new PipeTestRepository(session); this.sizeTypeRepo = new MillPipeSizeTypeRepository(session); this.plateManRepo = new PlateManufacturerRepository(session); this.heatRepo = new HeatRepository(session); this.plateRepo = new PlateRepository(session); this.purchaseRepo = new PurchaseOrderRepository(session); this.railRepo = new RailcarRepository(session); this.pipeRepo = new PipeRepository(session); this.inspectorRepo = new InspectorRepository(session); this.pipeTestResultRepo = new PipeTestResultRepository(session); this.welderRepo = new WelderRepository(session); componentTypeRepo = new ComponentTypeRepository(session); componentRepo = new ComponentRepository(session); releaseRepo = new ReleaseNoteRepository(session); this.cannedMessageRepo = new CannedMessageRepository(session); }
public ProjectScreenshotService(IProjectRepository projectRepository, IMapper mapper, IFileUriProvider uriProvider, IFileSystem fileSystem) { _projectRepository = projectRepository; _uriProvider = uriProvider; _fileSystem = fileSystem; _mapper = mapper; }
public BuildPurgeRuleManager(IBuildPurgeRuleRepository buildPurgeRuleRepository, IProjectRepository projectRepository, ISystemSettings systemSettings, IDIFactory diFactory) { _buildPurgeRuleRepository = DIHelper.VerifyParameter(buildPurgeRuleRepository); _projectRepository = DIHelper.VerifyParameter(projectRepository); _systemSettings = DIHelper.VerifyParameter(systemSettings); _diFactory = DIHelper.VerifyParameter(diFactory); }
public ProjectLogic(IProjectRepository projectRepository, IUserProjectAssignmentRepository userProjectAssignmentRepository, IProjectSerialize serializer) { ProjectRepository = projectRepository; UserProjectAssignmentRepository = userProjectAssignmentRepository; Serializer = serializer; }
public ProjectListViewModel( IViewServiceRepository viewServices = null, ISettingsRepository settingsRepo = null, IProjectRepository projectRepo = null, IMessenger messenger = null ) : base( viewServices, settingsRepo, messenger ) { ProjectRepo = projectRepo ?? new ProjectRepository( Session ); Projects = new ObservableCollection<ProjectViewModel>( ProjectRepo.GetAll().OrderBy( p => p.Name ).Select( p => new ProjectViewModel( p ) ) ); var last = Settings.GetById( SettingKeys.LastProject ); CurrentProject = Projects.FirstOrDefault( p => p.Model.Id == last.Get<int>() ) ?? Projects.FirstOrDefault(); foreach( var proj in Projects ) { proj.CurrentChanged += Proj_CurrentChanged; } if( CurrentProject != null ) { CurrentProject.IsCurrent = true; } ProjectNames = new List<string>(); Validate( nameof( NewProjectName ) ).Check( () => !string.IsNullOrWhiteSpace( NewProjectName ) ).Message( Strings.ProjectMustHaveName ); Validate( nameof( NewProjectName ) ).Check( () => !ProjectNames.Contains( NewProjectName ) ).Message( Strings.ThisNameIsAlreadyUsed ); Reset(); }
public PaymentVoucherControllerTest() { validUser = A.Fake<IUserRepository>(); A.CallTo(() => validUser.CurrentUserId).Returns(1); A.CallTo(() => validUser.CurrentUserName).Returns("Valid User"); invalidUser = A.Fake<IUserRepository>(); A.CallTo(() => invalidUser.CurrentUserId).Returns(2); A.CallTo(() => invalidUser.CurrentUserName).Returns("Invalid User"); projectRepository = new MockProjectRepository(); paymentVoucherRepository = new MockPaymentVoucherRepository(); controller = new PaymentVoucherController(projectRepository, paymentVoucherRepository, validUser); //Create some test data //User 1 creates a project var firstProject = new Project(); firstProject.Name = "Owned Project"; firstProject.OwnerID = validUser.CurrentUserId; projectRepository.Create(firstProject); //User 2 creates a project var secondProject = new Project(); secondProject.Name = "Shared project"; secondProject.OwnerID = invalidUser.CurrentUserId; projectRepository.Create(secondProject); //User 2 invites user 1 to the project var acl = projectRepository.CreateCollaboration(secondProject.ID, "*****@*****.**"); //User 1 accepts projectRepository.AcceptCollaboration(acl.ID, validUser.CurrentUserId); }
public ConnectionController(IConnectionRepository dbConnectionRepository, IProjectRepository dbProjectRepository, IConnectionProviderRepository dbConnectionProviderRepository) { _dbConnectionRepository = dbConnectionRepository; _dbProjectRepository = dbProjectRepository; _dbConnectionProviderRepository = dbConnectionProviderRepository; }
public CompanyBusinessLogic(ICompanyRepository repository, IEmployeeRepository empRepository, IProjectRepository projectRepository, IPersonRepository personRepository) { _repository = repository; _empRepository = empRepository; _projectRepository = projectRepository; _personRepository = personRepository; }
public MasterController(ITicketService ticketService, IUserRepository userRepo, IProjectRepository projectRepo, ITicketRepository ticketRepo) { _ticketService = ticketService; _userRepo = userRepo; _projectRepo = projectRepo; _ticketRepo = ticketRepo; }
public ProjectController( IProjectView projectView, INewProjectView newProjectView, IProjectRepository projectRepository, IDealRepository dealRepository, INewProjectSupplyView newProjectSupplyView, INewProjectHardwareView newProjectHardwareView, IEditProjectSupplyView editProjectSupplyView, IEditProjectHardwareView editProjectHardwareView, INewProjectFrameView newProjectFrameView, IEditProjectHardwareSupplyView editProjectHardwareSupplyView, ILoadingView loadingView, ICatalogRepository catalogRepository, ITaskRepository taskRepository) { this.projectView = projectView; this.newProjectView = newProjectView; this.projectRepository = projectRepository; this.dealRepository = dealRepository; this.newProjectSupplyView = newProjectSupplyView; this.newProjectHardwareView = newProjectHardwareView; this.editProjectHardwareView = editProjectHardwareView; this.editProjectSupplyView = editProjectSupplyView; this.newProjectFrameView = newProjectFrameView; this.editProjectHardwareSupplyView = editProjectHardwareSupplyView; this.loadingView = loadingView; this.catalogRepository = catalogRepository; this.taskRepository = taskRepository; }
public static void GenerateDemoData( IIssueRepository issueRepository, IProjectRepository projectRepository, IAttachmentRepository attachmentRepository) { Project p = new Project("SHOP", "Webshop", "All issues related to the webshop."); projectRepository.Add(p); Issue i = new Issue(p, "Crash after payment", @"I have justed paid for two pairs of shoes - or rather I tried to. When I clicked 'Pay' all I got was a yellow error screen.", 3); issueRepository.Add(i); string errorReport = "This is an error report ..."; Attachment att = new Attachment(i, "Error report", "Error report from end user", Encoding.UTF8.GetBytes(errorReport), "text/plain"); attachmentRepository.Add(att); string logFile = "DEBUG 2014-01-22 15:45:07,610 166033ms [9] Log4NetTraceListener WriteLine - Executing OperationResult OperationResult: type=OK, statusCode=200."; att = new Attachment(i, "Logfile", "Logfile with server stack trace", Encoding.UTF8.GetBytes(logFile), "text/plain"); attachmentRepository.Add(att); i = new Issue(p, "Not calculating VAT correctly", @"When I add both shoes and socks it fails to calculate the VAT correctly.", 3); issueRepository.Add(i); i = new Issue(p, "General Failure?", @"When I press ctrl-P it says 'General failure reading harddisk'! Who is that General and why is he reading my hard disk?", 5); issueRepository.Add(i); }
static ProjectService() { ProjectService.unitOfWork = new UnitOfWork(); ProjectService.repository = RepositoryFactory.GetRepository<IProjectRepository, Project>(ProjectService.unitOfWork); }
public TaskController(IUnitOfWork unitOfWork, ITaskRepository taskRepository, IProjectRepository projectRepository, IDisposableCollection disposables) : base(disposables) { _taskRepository = taskRepository; _projectRepository = projectRepository; _unitOfWork = unitOfWork; }
public ThrottleBotsPlugin(ICacheClient cacheClient, IEventRepository eventRepository, IProjectRepository projectRepository, IMetricsClient metricsClient, IQueue<WorkItemData> workItemQueue) { _cacheClient = cacheClient; _metricsClient = metricsClient; _eventRepository = eventRepository; _projectRepository = projectRepository; _workItemQueue = workItemQueue; }
public MProjectController(IMProjectRepository repoMProject, ILogRepository repoLog, ICompanyRepository repoCompany,IContractorRepository repoContractor,IProjectRepository repoProject) : base(repoLog) { RepoMProject = repoMProject; RepoCompany = repoCompany; RepoContractor = repoContractor; RepoProject = repoProject; }
protected override void Context() { _projectHandler = Resolve<ProjectHandlers>(); _projectRepository = Resolve<IProjectRepository>(); _tenantContext = Resolve<ITenantContext>(); _tenantContext.SetTenantId(_tenant); }
public TasksController(ISolutionRepository solutionRepository, ITaskRepository repository, IMapper mapper, UserManager <DbUser> userManager, IProjectRepository projectRepository, ITaskBoardRepository taskBoardRepository, IWebHostEnvironment appEnvironment) { _taskBoardRepository = taskBoardRepository; _repository = repository; _mapper = mapper; _userManager = userManager; _projectRepository = projectRepository; _appEnvironment = appEnvironment; _solutionRepository = solutionRepository; }
public ProjectController(IProjectRepository repository, IMapper mapper) { this._mapper = mapper; this._repository = repository; }
public ListProjectTask(ILogger <ListProjectTask> logger, IProjectRepository projectRepository) { _logger = logger; _projectRepository = projectRepository; }
public ListProjectsLogic(ILogger logger, ICommandContext context, IProjectRepository projectRepository) : base(logger, context) { _projectRepository = projectRepository; }
public ProjectBl(IProjectRepository repo) { _repo = repo; }
public static Task <ProjectResource[]> FindByNamesOrIdsOrFail(this IProjectRepository repo, IEnumerable <string> namesOrIds) { return(repo.FindByNamesOrIdsOrFail(n => repo.FindByName(n), "Projects", "project", namesOrIds)); }
public StartController(UserManager <User> userManager, IMapper mapper, IProjectRepository projects) { _userManager = userManager; _mapper = mapper; _projects = projects; }
public TaskService(ITaskRepository taskRepository, IProjectRepository projectRepository, IMapper mapper) { _taskRepository = taskRepository; _projectRepository = projectRepository; _mapper = mapper; }
public ProjectController(IProjectRepository dbProjectRepository) { _dbProjectRepository = dbProjectRepository; }
public ProjectManager(IProjectRepository Projects, ISqlRepository sql) { _Projects = Projects; _sql = sql; }
public EventPipeline(IDependencyResolver dependencyResolver, IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IMetricsClient metricsClient, ILoggerFactory loggerFactory = null) : base(dependencyResolver, metricsClient, loggerFactory) { _organizationRepository = organizationRepository; _projectRepository = projectRepository; }
public ProjectController(IProjectRepository project) { _project = project; }
public GameToolsController(IProjectRepository projectRepository, IProjectService projectService, IUserRepository userRepository) : base(projectRepository, projectService, userRepository) { }
public static Task <ProjectResource> FindByNameOrIdOrFail(this IProjectRepository repo, string nameOrId) { return(repo.FindByNameOrIdOrFail(n => repo.FindByName(n), "Projects", "project", nameOrId)); }
public OrganizationController(IOrganizationRepository organizationRepository, IUserRepository userRepository, IProjectRepository projectRepository, BillingManager billingManager, ProjectController projectController, IMailer mailer) : base(organizationRepository) { _userRepository = userRepository; _projectRepository = projectRepository; _billingManager = billingManager; _projectController = projectController; _mailer = mailer; }
public RunProjectCmdHandler(IProjectRepository projectRepository) { _projectRepository = projectRepository; }
public AccountController(IMembershipProvider membership, IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IUserRepository userRepository, BillingManager billingManager, NotificationSender notificationSender, IMailer mailer, DataHelper dataHelper) { _membershipProvider = membership; _organizationRepository = organizationRepository; _projectRepository = projectRepository; _userRepository = userRepository; _billingManager = billingManager; _notificationSender = notificationSender; _mailer = mailer; _dataHelper = dataHelper; }
public WebHookController(IWebHookRepository repository, IProjectRepository projectRepository, BillingManager billingManager) : base(repository) { _projectRepository = projectRepository; _billingManager = billingManager; }
public DetailViewComponent(IProjectRepository projectRepository) { this.projectRepository = projectRepository; }
public ProjectsController(IProjectRepository projectRepository) { _projectRepository = projectRepository; }
public TokenController(ITokenRepository repository, IProjectRepository projectRepository, IMapper mapper, IQueryValidator validator, ILoggerFactory loggerFactory) : base(repository, mapper, validator, loggerFactory) { _projectRepository = projectRepository; }
protected async Task <IReadOnlyCollection <Organization> > GetSelectedOrganizationsAsync(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IStackRepository stackRepository, string filter = null) { var associatedOrganizationIds = GetAssociatedOrganizationIds(); if (associatedOrganizationIds.Count == 0) { return(EmptyOrganizations); } if (!String.IsNullOrEmpty(filter)) { var scope = GetFilterScopeVisitor.Run(filter); if (scope.IsScopable) { Organization organization = null; if (scope.OrganizationId != null) { organization = await organizationRepository.GetByIdAsync(scope.OrganizationId, o => o.Cache()); } else if (scope.ProjectId != null) { var project = await projectRepository.GetByIdAsync(scope.ProjectId, o => o.Cache()); if (project != null) { organization = await organizationRepository.GetByIdAsync(project.OrganizationId, o => o.Cache()); } } else if (scope.StackId != null) { var stack = await stackRepository.GetByIdAsync(scope.StackId, o => o.Cache()); if (stack != null) { organization = await organizationRepository.GetByIdAsync(stack.OrganizationId, o => o.Cache()); } } if (organization != null) { if (associatedOrganizationIds.Contains(organization.Id) || Request.IsGlobalAdmin()) { return new[] { organization } }
public EmployeeController(IUserRepository userRepo, IEmployeeRepository employeeRepo, IProjectRepository projectRepo, IProjectMemberRepository projectMemberRepo, AuthUtil authUtil) { _userRepo = userRepo; _employeeRepo = employeeRepo; _projectRepo = projectRepo; _projectMemberRepo = projectMemberRepo; this.authUtil = authUtil; }
public XGameApiController(IProjectRepository projectRepository) => ProjectRepository = projectRepository;
public EventPipeline(IDependencyResolver dependencyResolver, IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IAppStatsClient statsClient) : base(dependencyResolver) { _organizationRepository = organizationRepository; _projectRepository = projectRepository; _statsClient = statsClient; }
public AdminHomeController(ApplicationUserManager userManager, IUserRepository userRepository, IProjectRepository projectRepository) : base(userManager, userRepository) { ProjectRepository = projectRepository; }
public ProjectManager() { _repo = new ProjectRepository(); }
public StatsController(EventStatsHelper statsHelper, IOrganizationRepository organizationRepository, IStackRepository stackRepository, IProjectRepository projectRepository) { _statsHelper = statsHelper; _organizationRepository = organizationRepository; _stackRepository = stackRepository; _projectRepository = projectRepository; }
public ImportChangesetServices(IChangesetRepository changesetRepository, IUserRepository userRepository, IChangesetGateway changesetGateway, IProjectRepository projectRepository) { this.changesetRepository = changesetRepository; this.userRepository = userRepository; this.changesetGateway = changesetGateway; this.projectRepository = projectRepository; }
public BillingManager(IOrganizationRepository organizationRepository, IProjectRepository projectRepository, IUserRepository userRepository) { _organizationRepository = organizationRepository; _projectRepository = projectRepository; _userRepository = userRepository; }