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