public Task <StoryTemplateOutput> GetStoryTemplate(IOrganizationAccountManager am, Guid templateId)
{
return(Repository.Queryable()
.Where(x => x.ProviderOrganizationId == am.OrganizationId && x.Id == templateId)
.ProjectTo <StoryTemplateOutput>(ProjectionMapping)
.FirstAsync());
}
public static IQueryable <Contract> ForOrganizationAccountManager(this IQueryable <Contract> entities,
IOrganizationAccountManager am)
{
return(entities.Where(x =>
x.AccountManagerId == am.AccountManagerId &&
x.ContractorOrganizationId == am.OrganizationId));
}
public async Task <T> GetTimeEntry <T>(IOrganizationAccountManager am, Guid entryId) where T : AccountManagerTimeEntryOutput
{
return(await Repository.Queryable()
.FindById(entryId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <StoryResult> CreateStory(
IOrganizationAccountManager organizationAccountManager,
CreateStoryInput input
)
{
return(CreateStoryInternal(input, organizationAccountManager.OrganizationId));
}
public static IQueryable <TimeEntry> ForOrganizationAccountManager(this IQueryable <TimeEntry> entities,
IOrganizationAccountManager am)
{
return(entities.Where(x =>
x.AccountManagerId == am.AccountManagerId &&
x.ProviderOrganizationId == am.OrganizationId));
}
public Task <PackedList <T> > GetStories <T>(IOrganizationAccountManager am, StoryFilters filters
) where T : AccountManagerStoryOutput
{
return(Repository.Queryable().ForOrganizationAccountManager(am)
.ApplyWhereFilters(filters)
.PaginateProjection <Story, T>(filters, ProjectionMapping));
}
public InvoiceController(IProjectInvoiceService invoiceService, IOrganizationAccountManager accountManager,
IServiceProvider serviceProvider) : base(
serviceProvider)
{
_accountManager = accountManager;
_invoiceService = invoiceService;
}
public async Task <T> GetOrganization <T>(IOrganizationAccountManager am) where T : AccountManagerOrganizationOutput
{
return(await Repository.Queryable()
.Where(x => x.AccountManagerId == am.AccountManagerId && x.OrganizationId == am.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <AccountManagerCounts> GetCounts(IOrganizationAccountManager am)
{
return(Repository.Queryable()
.Where(x => x.AccountManagerId == am.AccountManagerId && x.OrganizationId == am.OrganizationId)
.ProjectTo <AccountManagerCounts>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public AccountManagerController(IServiceProvider serviceProvider,
IOrganizationAccountManagerService accountManagerService,
IOrganizationAccountManager accountManager) : base(serviceProvider)
{
_accountManagerService = accountManagerService;
_accountManager = accountManager;
}
public Task <T> GetWorkOrder <T>(IOrganizationAccountManager accountManager, Guid orderId) where T : ProviderWorkOrderOutput
{
return(Repository.Queryable().Where(x =>
x.AccountManagerId == accountManager.AccountManagerId && x.AccountManagerOrganizationId == accountManager.OrganizationId && x.Id == orderId && x.Status != OrderStatus.Draft)
.ProjectTo <T>(ProjectionMapping)
.FirstAsync());
}
public static IQueryable <T> ForOrganizationAccountManager <T>(this IQueryable <T> entities,
IOrganizationAccountManager am) where T : FixedPriceProposal
{
return(entities.Where(x =>
x.Project.AccountManagerId == am.AccountManagerId &&
x.Project.AccountManagerOrganizationId == am.OrganizationId));
}
public Task <CustomerAccount> GetAccount(IOrganizationAccountManager am, int accountId)
{
return(Repository.Queryable()
.ForOrganizationAccountManager(am)
.Where(x => x.Number == accountId)
.FirstOrDefaultAsync());
}
public async Task <CustomerAccountResult> LinkOrganizationCustomer(IOrganizationAccountManager am, LinkCustomerInput input)
{
input.AccountManagerId = am.AccountManagerId;
input.AccountManagerOrganizationId = am.OrganizationId;
return(await Link(input));
}
public ContractorController(
IOrganizationContractorService contractorService,
IOrganizationAccountManager accountManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_contractorService = contractorService;
_accountManager = accountManager;
}
public Task <T> GetProject <T>(IOrganizationAccountManager am, Guid projectId) where T : AccountManagerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationAccountManager(am)
.FindById(projectId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <PackedList <T> > GetLeads <T>(IOrganizationAccountManager am, CommonFilters filters) where T : AccountManagerLeadOutput
{
return(await Repository.Queryable()
.ForOrganizationAccountManager(am)
.Where(x => x.Status == LeadStatus.Qualified)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Lead, T>(filters, ProjectionMapping));
}
public async Task <bool> Delete(IOrganizationAccountManager am, Guid templateId)
{
var template = await Repository.Queryable()
.Where(x => x.ProviderOrganizationId == am.OrganizationId && x.Id == templateId)
.FirstAsync();
return(await Delete(template));
}
public ProjectManagerController(
IOrganizationAccountManager accountManager,
IOrganizationProjectManagerService projectManagerService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_accountManager = accountManager;
_projectManagerService = projectManagerService;
}
public CustomerController(
IOrganizationAccountManager accountManager,
IOrganizationCustomerService customerService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_organizationAccountManager = accountManager;
_customerService = customerService;
}
public Task <PackedList <T> > GetFixedPriceProposals <T>(IOrganizationAccountManager am, ProposalFilters filters
) where T : AccountManagerFixedPriceProposalOutput
{
return(Repository.Queryable()
.ForOrganizationAccountManager(am)
.ApplyWhereFilters(filters)
.PaginateProjection <FixedPriceProposal, T>(filters, ProjectionMapping));
}
public async Task <bool> CreateStoryComment(IOrganizationAccountManager accountManager, Guid storyId,
CommentInput input)
{
var story = await _storyRepository.Queryable().ForOrganizationAccountManager(accountManager)
.FindById(storyId).FirstAsync();
return(await CreateStoryComment(story, input, accountManager.OrganizationId));
}
public StoryTemplateController(
IStoryTemplateService storyTemplateService,
IOrganizationAccountManager accountManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_storyTemplateService = storyTemplateService;
_accountManager = accountManager;
}
public async Task <LeadResult> DeleteLead(IOrganizationAccountManager am, Guid leadId)
{
var lead = await Repository.Queryable()
.ForOrganizationAccountManager(am)
.Where(x => x.Id == leadId).FirstAsync();
return(await DeleteLead(lead.Id));
}
public WorkOrderController(
IOrganizationAccountManager accountManager,
IWorkOrderService workOrderService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_accountManager = accountManager;
_workOrderService = workOrderService;
}
public Task <ContractResult> CreateContract(
IOrganizationAccountManager am,
ContractInput model)
{
_logger.LogInformation(GetLogMessage("Creating contract as AM"));
model.ContractorOrganizationId = am.OrganizationId;
return(CreateContract(model));
}
public ProposalController(IProposalService proposalService,
IOrganizationAccountManager accountManager,
IProposalPDFService proposalPdfService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_proposalService = proposalService;
_accountManager = accountManager;
_proposalPdfService = proposalPdfService;
}
public async Task <InvoiceResult> SendInvoice(IOrganizationAccountManager am, string invoiceId)
{
var invoice = await Repository.Queryable()
.ForOrganizationAccountManager(am)
.Where(x => x.InvoiceId == invoiceId)
.FirstOrDefaultAsync();
return(await SendInvoice(invoice.InvoiceId));
}
public LeadController(
ICommentService commentService,
ILeadService leadService, IOrganizationAccountManager accountManager,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_commentService = commentService;
_accountManager = accountManager;
_leadService = leadService;
}
public Task <PackedList <T> > GetWorkOrders <T>(IOrganizationAccountManager accountManager, WorkOrderFilters filters) where T : ProviderWorkOrderOutput
{
return(Repository.Queryable()
.ApplyWhereFilters(filters)
.Where(x => x.AccountManagerId == accountManager.AccountManagerId &&
x.AccountManagerOrganizationId == accountManager.OrganizationId &&
x.Status != OrderStatus.Draft)
.PaginateProjection <WorkOrder, T>(filters, ProjectionMapping));
}
