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