public Task <ProjectManagerCounts> GetCounts(IOrganizationProjectManager principal)
{
return(Repository.Queryable()
.Where(x => x.ProjectManagerId == principal.ProjectManagerId && x.OrganizationId == principal.OrganizationId)
.ProjectTo <ProjectManagerCounts>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <TimeEntryResult> UpdateTimeEntry(IOrganizationProjectManager co, Guid entryId, TimeEntryInput input)
{
_logger.LogInformation(GetLogMessage("Entry: {0}"), entryId);
var retVal = new TimeEntryResult()
{
TimeEntryId = entryId
};
var entry = await Repository.FirstOrDefaultAsync(x => x.Id == entryId);
if (entry.Status == TimeStatus.Logged)
{
if (input.MinutesDuration.HasValue && input.MinutesDuration.Value > 0)
{
input.EndDate = input.StartDate.AddMinutes(input.MinutesDuration.Value);
}
entry.InjectFrom(input);
retVal = await UpdateTimeEntry(entry);
}
else
{
retVal.ErrorMessage = "You can only update time entry in the logged state";
}
return(retVal);
}
public Task <PackedList <T> > GetStories <T>(IOrganizationProjectManager pm, StoryFilters filters
) where T : ProjectManagerStoryOutput
{
return(Repository.Queryable().ForOrganizationProjectManager(pm)
.ApplyWhereFilters(filters)
.PaginateProjection <Story, T>(filters, ProjectionMapping));
}
public Task <T> GetOrganization <T>(IOrganizationProjectManager principal) where T : ProjectManagerOrganizationOutput
{
return(Repository.Queryable()
.Where(x => x.ProjectManagerId == principal.ProjectManagerId && x.OrganizationId == principal.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <ProjectResult> CreateProject(IOrganizationProjectManager pm, ProjectInput input)
{
input.ProjectManagerOrganizationId = pm.OrganizationId;
input.ProjectManagerId = pm.OrganizationId;
return(CreateProject(input));
}
public DashboardController(IWidgetManager widgetManager, IProjectManagerService pmService,
IOrganizationProjectManager projectManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_projectManager = projectManager;
_widgetManager = widgetManager;
}
public async Task <StoryResult> CreateStory(
IOrganizationProjectManager pm,
CreateStoryInput input
)
{
return(await CreateStoryInternal(input, pm.OrganizationId));
}
public AccountManagerController(IServiceProvider serviceProvider,
IOrganizationAccountManagerService accountManagerService,
IOrganizationProjectManager projectManager) : base(serviceProvider)
{
_accountManagerService = accountManagerService;
_projectManager = projectManager;
}
public static IQueryable <T> ForOrganizationProjectManager <T>(this IQueryable <T> entities,
IOrganizationProjectManager pm) where T : FixedPriceProposal
{
return(entities.Where(x =>
x.Project.AccountManagerId == pm.ProjectManagerId &&
x.Project.ProjectManagerOrganizationId == pm.OrganizationId));
}
public static IQueryable <ProjectInvoice> ForOrganizationProjectManager(this IQueryable <ProjectInvoice> entities,
IOrganizationProjectManager pm)
{
return(entities.Where(x =>
x.ProjectManagerId == pm.ProjectManagerId &&
x.ProviderOrganizationId == pm.OrganizationId));
}
public Task <StoryTemplateOutput> GetStoryTemplate(IOrganizationProjectManager pm, Guid templateId)
{
return(Repository.Queryable()
.Where(x => x.ProviderOrganizationId == pm.OrganizationId && x.Id == templateId)
.ProjectTo <StoryTemplateOutput>(ProjectionMapping)
.FirstAsync());
}
public async Task <T> GetTimeEntry <T>(IOrganizationProjectManager pm, Guid entryId) where T : ProjectManagerTimeEntryOutput
{
return(await Repository.Queryable()
.FindById(entryId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <StoryResult> DeleteStory(IOrganizationProjectManager pm, Guid storyId
)
{
_logger.LogInformation(GetLogMessage("Story: {0}"), storyId);
return(DeleteStoryInternal(storyId));
}
public async Task <TimeEntryResult> SaveAndApprove(IOrganizationProjectManager pm, Guid entryId, TimeEntryInput input)
{
var entry = await UpdateTimeEntry(pm, entryId, input);
var entry2 = await Approve(pm, new[] { entryId });
return(entry2);
}
public async Task <bool> CreateStoryComment(IOrganizationProjectManager projectManager, Guid storyId,
CommentInput input)
{
var story = await _storyRepository.Queryable().ForOrganizationProjectManager(projectManager)
.FindById(storyId).FirstAsync();
return(await CreateStoryComment(story, input, projectManager.OrganizationId));
}
public CustomerController(
IOrganizationProjectManager projectManager,
IOrganizationCustomerService customerService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_projectManager = projectManager;
_customerService = customerService;
}
public async Task <TimeEntryResult> Approve(IOrganizationProjectManager pm, Guid[] entries)
{
var entriesToApprove = await Repository.Queryable()
.ForOrganizationProjectManager(pm)
.Where(x => entries.Contains(x.Id)).ToListAsync();
return(await Approve(entriesToApprove));
}
public OrganizationController(
IOrganizationProjectManager projectManager,
IOrganizationProjectManagerService projectManagerService,
IServiceProvider provider) : base(provider)
{
_projectManager = projectManager;
_projectManagerService = projectManagerService;
}
public StoryTemplateController(
IStoryTemplateService storyTemplateService,
IOrganizationProjectManager projectManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_storyTemplateService = storyTemplateService;
_projectManager = projectManager;
}
public static IQueryable <TimeEntry> ForOrganizationProjectManager(this IQueryable <TimeEntry> entities,
IOrganizationProjectManager pm)
{
return(entities.Where(x =>
x.ProjectManagerId == pm.ProjectManagerId &&
x.ProviderOrganizationId == pm.OrganizationId &&
x.Status == TimeStatus.Logged));
}
public async Task <bool> Delete(IOrganizationProjectManager pm, Guid templateId)
{
var template = await Repository.Queryable()
.Where(x => x.ProviderOrganizationId == pm.OrganizationId && x.Id == templateId)
.FirstAsync();
return(await Delete(template));
}
public StoryController(
ICommentService commentService,
IStoryService storyService, IOrganizationProjectManager projectManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_commentService = commentService;
_projectManager = projectManager;
_storyService = storyService;
}
public Task <PackedList <T> > GetCandidates <T>(IOrganizationProjectManager organizationProjectManager, CommonFilters filters)
where T : ProjectManagerCandidateOutput
{
return(Repository.Queryable()
.ForOrganizationProjectManager(organizationProjectManager)
.Where(x => x.Status == CandidateStatus.Qualified)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Candidate, T>(filters, ProjectionMapping));
}
public async Task <StoryTemplateOutput> Create(IOrganizationProjectManager pm, StoryTemplateInput input)
{
var template = new StoryTemplate()
{
ProviderOrganizationId = pm.OrganizationId
}.InjectFrom(input) as StoryTemplate;
return(await Create(template));
}
public Task <TimeEntryResult> DeleteTimeEntry(IOrganizationProjectManager pm, Guid entryId)
{
var entry = Repository
.FirstOrDefault(x => x.Id == entryId &&
x.ProjectManagerId == pm.ProjectManagerId &&
x.ProviderOrganizationId == pm.OrganizationId);
return(DeleteTimeEntry(entry));
}
public Task <List <T> > GetStories <T>(IOrganizationProjectManager pm, Guid?[] uniqueStoryIds)
where T : ProjectManagerStoryOutput
{
return(Repository.Queryable()
.ForOrganizationProjectManager(pm)
.Where(x => uniqueStoryIds.Contains(x.Id))
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <PackedList <T> > GetProjects <T>(IOrganizationProjectManager pm, ProjectFilters filters)
where T : ProjectManagerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationProjectManager(pm)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Project, T>(filters, ProjectionMapping));
}
public Task <List <T> > GetProjects <T>(IOrganizationProjectManager pm, Guid[] uniqueProjectIds) where T : ProjectManagerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationProjectManager(pm)
.Where(x => uniqueProjectIds.Contains(x.Id))
.OrderByDescending(x => x.Updated)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <T> GetProject <T>(IOrganizationProjectManager organizationProjectManager, Guid projectId)
where T : ProjectManagerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationProjectManager(organizationProjectManager)
.FindById(projectId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> GetStory <T>(IOrganizationProjectManager pm, Guid storyId)
where T : ProjectManagerStoryOutput
{
return(Repository.Queryable()
.ForOrganizationProjectManager(pm)
.FindById(storyId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
