public async Task <T> GetOrganization <T>(IOrganizationCustomer principal) where T : CustomerOrganizationOutput
{
return(await Repository.Queryable()
.Where(x => x.CustomerId == principal.CustomerId && x.OrganizationId == principal.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <BuyerAccountOutput> GetBuyerAccount(IOrganizationCustomer customer)
{
_logger.LogInformation(GetLogMessage("For customer: {0}; and organization: {1}"), customer.CustomerId, customer.OrganizationId);
var y = await Repository
.Queryable()
.Include(x => x.OrganizationBuyerAccount)
.Where(x => x.OrganizationBuyerAccount.Id == customer.OrganizationId)
.ProjectTo <BuyerAccountOutput>(ProjectionMapping)
.FirstOrDefaultAsync();
if (y == null)
{
_logger.LogInformation(GetLogMessage("No buyer account was found, creating one..."));
var result = await PushCustomer(customer.OrganizationId, customer.CustomerId);
_logger.LogDebug(GetLogMessage("{0} records updated in database"), result);
if (result > 0)
{
return(await GetBuyerAccount(customer));
}
}
else
{
_logger.LogDebug(GetLogMessage("Buyer account found: {0}"), y.Id);
}
return(y);
}
public Task <CustomerCounts> GetCounts(IOrganizationCustomer principal)
{
return(Repository.Queryable()
.Where(x => x.CustomerId == principal.CustomerId && x.OrganizationId == principal.OrganizationId)
.ProjectTo <CustomerCounts>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <string> GetAuthUrl(IOrganizationCustomer customer)
{
_logger.LogInformation(GetLogMessage("Getting Auth Url for customer {Customer}"), customer);
var theCustomer = _organizationCustomerRepository.Queryable()
.Include(x => x.Organization)
.ThenInclude(x => x.OrganizationBuyerAccount)
.Include(x => x.Customer)
.ThenInclude(x => x.Person)
.ThenInclude(x => x.ApplicationUser)
.First(x =>
x.OrganizationId == customer.OrganizationId && x.CustomerId == customer.CustomerId);
var dict = new Dictionary <string, string>
{
{ "client_id", _stripeSettings.ClientId },
{ "redirect_uri", _stripeSettings.RedirectUri },
{ "scope", "read_write" },
{ "response_type", "code" },
{ "state", customer.OrganizationId.ToString() },
{ "stripe_user[email]", theCustomer.Customer.Person.ApplicationUser.Email },
{ "stripe_user[first_name]", theCustomer.Customer.Person.FirstName },
{ "stripe_user[last_name]", theCustomer.Customer.Person.LastName },
{ "stripe_user[country]", theCustomer.Customer.Person.Iso2 },
{ "stripe_user[business_name]", theCustomer.Organization.Name },
{ "stripe_user[business_type]", "company" },
// {"suggested_capabilities[]","card_payments,transfers,tax_reporting_us_1099_k" }
};
var url = $"https://connect.stripe.com/express/oauth/authorize{BuildQuerystring(dict)}";
_logger.LogDebug(GetLogMessage("{Url}"), url);
return(Task.FromResult(url));
}
public Task <PackedList <T> > GetStories <T>(IOrganizationCustomer cu, StoryFilters filters)
where T : CustomerStoryOutput
{
return(Repository.Queryable().ForOrganizationCustomer(cu)
.ApplyWhereFilters(filters)
.PaginateProjection <Story, T>(filters, ProjectionMapping));
}
public RetainerController(
IOrganizationCustomer customer,
IServiceProvider serviceProvider, IRetainerService retainerService) : base(serviceProvider)
{
_customer = customer;
_retainerService = retainerService;
}
public async Task <T> GetTimeEntry <T>(IOrganizationCustomer customer, Guid entryId) where T : CustomerTimeEntryOutput
{
return(await Repository.Queryable()
.FindById(entryId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> GetOrganization <T>(IOrganizationCustomer cu) where T : CustomerOrganizationOutput
{
return(Repository.Queryable()
.Where(x => x.Id == cu.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> GetWorkOrder <T>(IOrganizationCustomer customer, Guid orderId) where T : BuyerWorkOrderOutput
{
return(Repository.Queryable().Where(x =>
x.CustomerId == customer.CustomerId && x.CustomerOrganizationId == customer.OrganizationId && x.Id == orderId)
.ProjectTo <T>(ProjectionMapping)
.FirstAsync());
}
public async Task <RetainerResult> SetupRetainer(IOrganizationCustomer customer, Guid projectId,
CreateRetainerOptions options)
{
_logger.LogInformation(GetLogMessage("Customer:{0}; Project:{1}"), customer.CustomerId, projectId);
var retVal = new RetainerResult();
var project = await _projects.Queryable()
.ForOrganizationCustomer(customer)
.Include(x => x.CustomerAccount)
.Where(x => x.Id == projectId)
.FirstAsync();
var retainer = new ProjectRetainerIntent()
{
AccountManagerId = project.CustomerAccount.AccountManagerId,
ProviderOrganizationId = project.CustomerAccount.AccountManagerOrganizationId,
CustomerId = project.CustomerAccount.CustomerId,
CustomerOrganizationId = project.CustomerAccount.CustomerOrganizationId,
ProjectId = projectId,
TopOffAmount = options.TopOffAmount,
CurrentBalance = 0
};
var records = await Repository.InsertAsync(retainer, true);
if (records > 0)
{
retVal.Succeeded = true;
retVal.RetainerId = projectId;
}
return(retVal);
}
public BalanceController(IServiceProvider serviceProvider,
IOrganizationCustomer customer,
ICustomerBalanceService balanceService) : base(serviceProvider)
{
_customer = customer;
_balanceService = balanceService;
}
public InvoiceController(IProjectInvoiceService invoiceService,
IOrganizationCustomer customer,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_invoiceService = invoiceService;
_customer = customer;
}
public static IQueryable <TimeEntry> ForOrganizationCustomer(this IQueryable <TimeEntry> entities,
IOrganizationCustomer cu)
{
return(entities.Where(x =>
x.CustomerId == cu.CustomerId &&
x.CustomerOrganizationId == cu.OrganizationId));
}
public Task <T> GetProject <T>(IOrganizationCustomer organizationCustomer, Guid projectId) where T : CustomerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationCustomer(organizationCustomer)
.FindById(projectId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <bool> CreateAccountComment(IOrganizationCustomer customer, int accountId, CommentInput input)
{
var account = await _accountRepository.Queryable().ForOrganizationCustomer(customer)
.Where(x => x.BuyerNumber == accountId)
.FirstAsync();
return(await CreateAccountComment(account, input, customer.OrganizationId));
}
public Task <bool> DoesContractAlreadyExist(IOrganizationContractor co, IOrganizationCustomer cu, Guid projectId)
{
return(Repository.Queryable()
.ForOrganizationCustomer(cu)
.ForOrganizationContractor(co)
.FindById(projectId)
.AnyAsync());
}
public Task <PackedList <T> > GetFixedPriceProposals <T>(IOrganizationCustomer cu, ProposalFilters filters
) where T : CustomerFixedPriceProposalOutput
{
return(Repository.Queryable()
.ForOrganizationCustomer(cu)
.ApplyWhereFilters(filters)
.PaginateProjection <FixedPriceProposal, T>(filters, ProjectionMapping));
}
public Task <T> GetProposal <T>(IOrganizationCustomer cu, Guid proposalId) where T : CustomerFixedPriceProposalOutput
{
return(Repository.Queryable()
.ForOrganizationCustomer(cu)
.FindById(proposalId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <bool> CreateStoryComment(IOrganizationCustomer customer, Guid storyId, CommentInput input)
{
var story = await _storyRepository.Queryable().ForOrganizationCustomer(customer)
.FindById(storyId).FirstAsync();
return(await CreateStoryComment(story, input, customer.OrganizationId));
}
public BuyerAccountController(
IServiceProvider serviceProvider,
IBuyerAccountService buyerService,
IOrganizationCustomer customer) : base(serviceProvider)
{
_buyerService = buyerService;
_customer = customer;
}
public Task <RetainerOutput> GetRetainer(IOrganizationCustomer customer, Guid retainerId)
{
return(Repository.Queryable().Where(x => x.CustomerId == customer.CustomerId &&
x.CustomerOrganizationId == customer.OrganizationId &&
x.ProjectId == retainerId)
.ProjectTo <RetainerOutput>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <PackedList <T> > GetWorkOrders <T>(IOrganizationCustomer customer, WorkOrderFilters filters) where T : BuyerWorkOrderOutput
{
return(Repository.Queryable()
.ApplyWhereFilters(filters)
.Where(x => x.CustomerId == customer.CustomerId &&
x.CustomerOrganizationId == customer.OrganizationId)
.PaginateProjection <WorkOrder, T>(filters, ProjectionMapping));
}
public WorkOrderController(
IOrganizationCustomer customer,
IWorkOrderService workOrderService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_customer = customer;
_workOrderService = workOrderService;
}
public StoryController(
IStoryService storyService,
IOrganizationCustomer customer,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_customer = customer;
_storyService = storyService;
}
public Task <List <T> > GetStories <T>(IOrganizationCustomer cu, Guid?[] uniqueStoryIds)
where T : CustomerStoryOutput
{
return(Repository.Queryable()
.ForOrganizationCustomer(cu)
.Where(x => uniqueStoryIds.Contains(x.Id))
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <T> GetStory <T>(IOrganizationCustomer cu, Guid storyId)
where T : CustomerStoryOutput
{
return(Repository.Queryable()
.FindById(storyId)
.ForOrganizationCustomer(cu)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public TimeController(IServiceProvider serviceProvider,
IOrganizationCustomer orgCustomer,
ITimeMatrixService timeService,
IChartService chartService) : base(serviceProvider)
{
_orgCustomer = orgCustomer;
_timeService = timeService;
_chartService = chartService;
}
public async Task <T> UpdateWorkOrder <T>(IOrganizationCustomer customer, Guid orderId, UpdateWorkOrderInput input)
where T : BuyerWorkOrderOutput
{
var workOrder = await Repository.Queryable()
.Where(x => x.CustomerId == customer.CustomerId && x.Id == orderId)
.FirstAsync();
return(await UpdateWorkOrder <T>(workOrder, input));
}
public async Task <ContractResult> RestartContract(IOrganizationCustomer cu, Guid contractId)
{
_logger.LogInformation(GetLogMessage("CU: {0}; Contract: {1}"), cu.OrganizationId, contractId);
var contract = await Repository.Queryable().ForOrganizationCustomer(cu)
.FindById(contractId)
.FirstAsync();
return(await RestartContract(contract));
}
public Task <List <T> > GetProjects <T>(IOrganizationCustomer cu, Guid[] uniqueProjectIds) where T : CustomerProjectOutput, new()
{
return(Repository.Queryable()
.ForOrganizationCustomer(cu)
.Where(x => uniqueProjectIds.Contains(x.Id))
.OrderByDescending(x => x.Updated)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
