public async Task <ContractorChartOutput> GetProviderChartData(IOrganizationContractor contractor, TimeMatrixFilters filters, ChartParams chartParams) { var result = await _matrixService.GetComposedOutput(contractor, filters); var status = result.Matrix.ToStatusData <ContractorTimeMatrixOutput, ContractorChartDataItem>(). FillMissingDays(chartParams.DateBreakdown, filters). TopLevelGrouping(chartParams.DateBreakdown). SecondLevelGrouping(chartParams.DateBreakdown); var projs = result.Matrix.ToProjData <ContractorTimeMatrixOutput, ContractorProjectOutput, ContractorChartDataItem>(result.Projects). FillMissingDays(chartParams.DateBreakdown, filters). TopLevelGrouping(chartParams.DateBreakdown). SecondLevelGrouping(chartParams.DateBreakdown); return(new ContractorChartOutput { Proj = projs, Status = status, CurrentBreakdown = "status", CurrentDateRange = chartParams.DateBreakdown == DateBreakdown.ByMonth ? "m0" : "w0", DateRanges = GetDateRange(chartParams.DateBreakdown, projs), Breakdowns = new Dictionary <string, string> { { "proj", "By Project" }, { "status", "By Status" } } }); }
public DashboardController(IWidgetManager widgetManager, IOrganizationContractor contractor, IServiceProvider provider) : base(provider) { _widgetManager = widgetManager; _contractor = contractor; }
public async Task <T> GetTimeEntry <T>(IOrganizationContractor contractor, Guid entryId) where T : ContractorTimeEntryOutput { return(await Repository.Queryable() .FindById(entryId) .ProjectTo <T>(ProjectionMapping) .FirstOrDefaultAsync()); }
public Task <ContractorCounts> GetCounts(IOrganizationContractor principal) { return(Repository.Queryable() .Where(x => x.ContractorId == principal.ContractorId && x.OrganizationId == principal.OrganizationId) .ProjectTo <ContractorCounts>(ProjectionMapping) .FirstOrDefaultAsync()); }
public Task <PackedList <T> > GetStories <T>(IOrganizationContractor co, StoryFilters filters) where T : ContractorStoryOutput { return(Repository.Queryable().ForOrganizationContractor(co) .ApplyWhereFilters(filters) .PaginateProjection <Story, T>(filters, ProjectionMapping)); }
public static IQueryable<Project> ForOrganizationContractor(this IQueryable<Project> entities, IOrganizationContractor co) { return entities .Where(s => s.Contracts.Any(q => q.ContractorOrganizationId == co.OrganizationId && q.ContractorId == co.ContractorId)); }
public Task <StoryResult> DeleteStory(IOrganizationContractor co, Guid storyId ) { _logger.LogInformation(GetLogMessage("Story: {0}"), storyId); return(DeleteStoryInternal(storyId)); }
public OrganizationController(IOrganizationContractor contractor, IOrganizationContractorService contractorService, IServiceProvider provider) : base(provider) { _contractor = contractor; _contractorService = contractorService; }
public Task <T> GetOrganization <T>(IOrganizationContractor principal) where T : ContractorOrganizationOutput { return(Repository.Queryable() .Where(x => x.ContractorId == principal.ContractorId && x.OrganizationId == principal.OrganizationId) .ProjectTo <T>(ProjectionMapping) .FirstOrDefaultAsync()); }
public static IQueryable <T> ForOrganizationContractor <T>(this IQueryable <T> entities, IOrganizationContractor co) where T : FixedPriceProposal { return(entities .Where(s => s.Project.Contracts.Any(q => q.ContractorOrganizationId == co.OrganizationId && q.ContractorId == co.ContractorId))); }
public Task <T> GetProject <T>(IOrganizationContractor co, Guid projectId) where T : ContractorProjectOutput, new() { return(Repository.Queryable() .ForOrganizationContractor(co) .FindById(projectId) .ProjectTo <T>(ProjectionMapping) .FirstOrDefaultAsync()); }
public Task <bool> DoesContractAlreadyExist(IOrganizationContractor co, IOrganizationCustomer cu, Guid projectId) { return(Repository.Queryable() .ForOrganizationCustomer(cu) .ForOrganizationContractor(co) .FindById(projectId) .AnyAsync()); }
public Task <PackedList <T> > GetProjects <T>(IOrganizationContractor co, ProjectFilters filters) where T : ContractorProjectOutput, new() { return(Repository.Queryable() .ForOrganizationContractor(co) .ApplyWhereFilters(filters) .OrderByDescending(x => x.Updated) .PaginateProjection <Project, T>(filters, ProjectionMapping)); }
public async Task <bool> CreateStoryComment(IOrganizationContractor contractor, Guid storyId, CommentInput input) { var story = await _storyRepository.Queryable().ForOrganizationContractor(contractor) .FindById(storyId).FirstAsync(); return(await CreateStoryComment(story, input, contractor.OrganizationId)); }
public Task <List <T> > GetStories <T>(IOrganizationContractor co, Guid?[] uniqueStoryIds) where T : ContractorStoryOutput { return(Repository.Queryable() .ForOrganizationContractor(co) .Where(x => uniqueStoryIds.Contains(x.Id)) .ProjectTo <T>(ProjectionMapping) .ToListAsync()); }
public ContractController( ICommentService commentService, IContractService contractService, IOrganizationContractor contractor, IServiceProvider provider) : base(provider) { _commentService = commentService; _contractService = contractService; _contractor = contractor; }
public StoryController( ICommentService commentService, IStoryService storyService, IOrganizationContractor contractor, IServiceProvider provider) : base(provider) { _commentService = commentService; _contractor = contractor; _storyService = storyService; }
public Task <T> GetStory <T>(IOrganizationContractor co, Guid storyId) where T : ContractorStoryOutput { return(Repository.Queryable() .ForOrganizationContractor(co) .FindById(storyId) .ProjectTo <T>(ProjectionMapping) .FirstOrDefaultAsync()); }
public Task <List <T> > GetProjects <T>(IOrganizationContractor co, Guid[] uniqueProjectIds) where T : ContractorProjectOutput, new() { return(Repository.Queryable() .ForOrganizationContractor(co) .Where(x => uniqueProjectIds.Contains(x.Id)) .OrderByDescending(x => x.Updated) .ProjectTo <T>(ProjectionMapping) .ToListAsync()); }
public ProjectController( ICommentService commentService, IServiceProvider serviceProvider, IOrganizationContractor contractor, IProjectService projectService) : base(serviceProvider) { _commentService = commentService; _contractor = contractor; _projectService = projectService; }
public Task <TimeEntryResult> DeleteTimeEntry(IOrganizationContractor co, Guid entryId) { var entry = Repository .FirstOrDefault(x => x.Id == entryId && x.ContractorId == co.ContractorId && x.ProviderOrganizationId == co.OrganizationId); return(DeleteTimeEntry(entry)); }
public TimeController(ITimeEntryService service, ITimeMatrixService timeMatrix, IOrganizationContractor contractor, IServiceProvider provider, IChartService chartService) : base(provider) { _contractor = contractor; _timeService = service; _timeMatrix = timeMatrix; _chartService = chartService; }
public async Task <ContractResult> RestartContract(IOrganizationContractor co, Guid contractId) { _logger.LogInformation(GetLogMessage("CO: {0}; Contract: {1}"), co.OrganizationId, contractId); var contract = await Repository.Queryable().ForOrganizationContractor(co) .FindById(contractId) .FirstAsync(); return(await RestartContract(contract)); }
public async Task <bool> CreateContractComment(IOrganizationContractor contractor, Guid contractId, CommentInput input) { var contract = await _contractRepository.Queryable() .Include(x => x.Comments) .ForOrganizationContractor(contractor) .FindById(contractId) .FirstAsync(); return(await CreateContractComment(contract, input, contractor.OrganizationId)); }
public async Task <bool> CreateProjectComment(IOrganizationContractor contractor, Guid projectId, CommentInput input) { var project = await _projectRepository .Queryable() .ForOrganizationContractor(contractor) .FindById(projectId) .FirstAsync(); return(await CreateProjectComment(project, input, contractor.OrganizationId)); }
public Task <T> GetContract <T>(IOrganizationContractor co, Guid contractId) where T : ContractorContractOutput { var contract = Repository.Queryable() .ForOrganizationContractor(co) .FindById(contractId) .ProjectTo <T>(ProjectionMapping) .FirstOrDefaultAsync(); return(contract); }
public async Task <TimeEntryResult> TrackHalfDay(IOrganizationContractor contractor, DayTimeTrackingModel model) { var entry = new TimeEntry { StartDate = model.StartDateTime, EndDate = model.StartDateTime.AddMinutes(240), ContractId = model.ContractId }.InjectFrom(model) as TimeEntry; return(await TrackTime(entry, model.StoryId, model.CompleteStory)); }
public async Task <ContractorTimeMatrixComposedOutput> GetComposedOutput(IOrganizationContractor co, TimeMatrixFilters filters) { filters.ContractorId = co.ContractorId; filters.ProviderOrganizationId = co.OrganizationId; var matrix = await _context.TimeMatrix.ApplyWhereFilters(filters) .ProjectTo <ContractorTimeMatrixOutput>(_mapperConfiguration) .ToListAsync(); var uniqueProjectIds = matrix.Select(x => x.ProjectId).Distinct().ToArray(); var uniqueContractIds = matrix.Select(x => x.ContractId).Distinct().ToArray(); var uniqueContractorIds = matrix.Select(x => x.ContractorId).Distinct().ToArray(); var uniqueAccountManagerIds = matrix.Select(x => x.AccountManagerId).Distinct().ToArray(); var uniqueProjectManagerIds = matrix.Select(x => x.MarketerId).Distinct().ToArray(); var uniqueRecruiterIds = matrix.Select(x => x.RecruiterId).Distinct().ToArray(); var uniqueCustomerIds = matrix.Select(x => x.CustomerId).Distinct().ToArray(); var uniqueStoryIds = matrix .Where(x => x.StoryId != null).Select(x => x.StoryId).Distinct().ToArray(); var projectTask = _projectService.GetProjects <ContractorProjectOutput>(co, uniqueProjectIds); var contractsTask = _contractService.GetContracts <ContractorContractOutput>(co, uniqueContractIds); var accountManagers = _accountManagerService.GetForOrganization <ContractorOrganizationAccountManagerOutput>( co.OrganizationId, uniqueAccountManagerIds); var contractors = _contractorService.GetForOrganization <OrganizationContractorOutput>(co.OrganizationId, uniqueContractorIds); var projectManagers = _projectManagerService.GetForOrganization <ContractorOrganizationProjectManagerOutput>( co.OrganizationId, uniqueProjectManagerIds); var customers = _customerService.GetForOrganization <ContractorOrganizationCustomerOutput>(co.OrganizationId, uniqueCustomerIds); var stories = _storyService.GetStories <ContractorStoryOutput>(co, uniqueStoryIds); Task.WaitAll(projectTask, contractsTask, accountManagers, contractors, projectManagers, customers); return(new ContractorTimeMatrixComposedOutput { Matrix = matrix, Projects = projectTask.Result, Contracts = contractsTask.Result, AccountManagers = accountManagers.Result, Contractors = contractors.Result, ProjectManagers = projectManagers.Result, Customers = customers.Result, Stories = stories.Result }); }
public async Task <ContractResult> PauseContract(IOrganizationContractor co, Guid contractId) { _logger.LogInformation(GetLogMessage("Co: {0}; Contract: {1}"), co.OrganizationId, contractId); var contract = await Repository .Queryable() .ForOrganizationContractor(co) .FindById(contractId) .FirstOrDefaultAsync(); contract.ContractorPauseDate = DateTimeOffset.UtcNow; return(await PauseContract(contract)); }
public async Task <ContractResult> EndContract(IOrganizationContractor co, Guid contractId) { _logger.LogTrace(GetLogMessage($@"Ending Contract: {contractId}")); var contract = await Repository.Queryable() .Include(x => x.TimeEntries) .ForOrganizationContractor(co) .FindById(contractId) .FirstOrDefaultAsync(); contract.ContractorEndDate = DateTimeOffset.UtcNow; return(await EndContract(contract)); }