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