public Task <AgencyOwnerCounts> GetCounts(IAgencyOwner agencyOwner)
{
return(Repository.Queryable()
.Where(x => x.Id == agencyOwner.OrganizationId)
.ProjectTo <AgencyOwnerCounts>(ProjectionMapping)
.FirstAsync());
}
public Task <T> GetWorkOrder <T>(IAgencyOwner agencyOwner, Guid orderId) where T : ProviderWorkOrderOutput
{
return(Repository.Queryable().Where(x =>
x.AccountManagerOrganizationId == agencyOwner.OrganizationId && x.Id == orderId && x.Status != OrderStatus.Draft)
.ProjectTo <T>(ProjectionMapping)
.FirstAsync());
}
public async Task <T> GetTimeEntry <T>(IAgencyOwner ao, Guid entryId) where T : ProviderAgencyOwnerTimeEntryOutput
{
return(await Repository.Queryable()
.FindById(entryId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public AccountManagerController(IServiceProvider serviceProvider,
IOrganizationAccountManagerService accountManagerService,
IAgencyOwner agencyOwner) : base(serviceProvider)
{
_accountManagerService = accountManagerService;
_agencyOwner = agencyOwner;
}
public async Task <OrganizationSkillOutput> Add(IAgencyOwner agencyOwner, Guid skillId, OrganizationSkillInput input)
{
_logger.LogInformation(GetLogMessage("Skill: {0}"), skillId);
var x1 = await Repository.Queryable()
.Where(x => x.OrganizationId == agencyOwner.OrganizationId && x.SkillId == skillId)
.FirstOrDefaultAsync();
if (x1 == null)
{
var entity = new OrganizationSkill()
{
Created = DateTimeOffset.UtcNow,
ObjectState = ObjectState.Added,
OrganizationId = agencyOwner.OrganizationId,
SkillId = skillId
}.InjectFrom(input) as OrganizationSkill;
var result = await Repository.InsertAsync(entity, true);
if (result > 0)
{
}
}
var output = await Repository.Queryable()
.Where(x => x.OrganizationId == agencyOwner.OrganizationId && x.SkillId == skillId)
.ProjectTo <OrganizationSkillOutput>(this.ProjectionMapping)
.FirstAsync();
return(output);
}
public SkillController(IServiceProvider serviceProvider,
IAgencyOwner agencyOwner,
IOrganizationSkillService organizationSkillService) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_organizationSkillService = organizationSkillService;
}
public async Task <string> GetStripeUrl(IAgencyOwner agencyOwner, bool isRecursive = false)
{
_logger.LogInformation(GetLogMessage("Getting Stripe Url for agency owner: {Customer}"), agencyOwner.CustomerId);
var theClient = await _organizationCustomerRepository.Queryable()
.Include(x => x.Organization)
.ThenInclude(x => x.OrganizationFinancialAccount)
.Where(x =>
x.OrganizationId == agencyOwner.OrganizationId && x.CustomerId == agencyOwner.CustomerId && x.Organization.OrganizationFinancialAccount != null)
.FirstOrDefaultAsync();
if (theClient == null)
{
throw new ApplicationException("Please enable stripe account for this Organization");
}
var result = new LoginLinkService().Create(theClient.Organization.OrganizationFinancialAccount.FinancialAccountId,
new LoginLinkCreateOptions()
{
RedirectUrl = _appSettings.Urls.Flow
});
_logger.LogDebug(GetLogMessage("{Url}"), result.Url);
return(result.Url);
}
public async Task <OrganizationPersonResult> AddExistingPerson(IAgencyOwner agencyOwner, AddExistingPersonInput input)
{
_logger.LogInformation(GetLogMessage("Organization: {0}; Email: {1}"), agencyOwner.OrganizationId, input.EmailAddress);
var retVal = new OrganizationPersonResult()
{
OrganizationId = agencyOwner.OrganizationId
};
var foundPerson = await _accountManager.FindByEmailAsync(input.EmailAddress);
if (foundPerson != null)
{
_logger.LogDebug(GetLogMessage("Person Found: {0}"), foundPerson.Id);
var orgPersonInput = new OrganizationPersonInput()
{
PersonId = foundPerson.Id
}.InjectFrom(input) as OrganizationPersonInput;
retVal = await Create(orgPersonInput, agencyOwner.OrganizationId);
_logger.LogDebug(GetLogMessage("Person Result: {@result}"), retVal);
}
else
{
_logger.LogWarning(GetLogMessage("User does not exist"));
}
return(retVal);
}
public WidgetController(IWidgetManager widgetManager,
IAgencyOwner agencyOwner,
IServiceProvider provider) : base(provider)
{
_widgetManager = widgetManager;
_agencyOwner = agencyOwner;
}
public PeopleController(IOrganizationPersonService organizationPersonService,
IAgencyOwner agencyOwner,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_organizationPersonService = organizationPersonService;
}
public PositionController(IServiceProvider serviceProvider,
IAgencyOwner agencyOwner,
IPositionService positionService) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_positionService = positionService;
}
public Task <T> GetOrganization <T>(IAgencyOwner ao) where T : OrganizationOutput
{
return(Repository.Queryable()
.Where(x => x.Id == ao.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> Update <T>(IAgencyOwner agencyOwner,
OrganizationMarketerInput input)
where T : OrganizationMarketerOutput
{
input.OrganizationId = agencyOwner.OrganizationId;
return(Update <T>(input));
}
public Task <StoryTemplateOutput> GetStoryTemplate(IAgencyOwner ao, Guid templateId)
{
return(Repository.Queryable()
.Where(x => x.ProviderOrganizationId == ao.OrganizationId && x.Id == templateId)
.ProjectTo <StoryTemplateOutput>(ProjectionMapping)
.FirstAsync());
}
public FinancialAccountController(IServiceProvider serviceProvider,
IStripeService stripeService,
IAgencyOwner agencyOwner, IFinancialAccountService financialAccount) : base(serviceProvider)
{
_stripeService = stripeService;
_agencyOwner = agencyOwner;
_financialAccountService = financialAccount;
}
public WorkOrderController(
IAgencyOwner agencyOwner,
IWorkOrderService workOrderService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_workOrderService = workOrderService;
}
public StoryTemplateController(
IStoryTemplateService storyTemplateService,
IAgencyOwner agencyOwner,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_storyTemplateService = storyTemplateService;
_agencyOwner = agencyOwner;
}
public Task <List <T> > GetCustomers <T>(IAgencyOwner agencyOwner) where T : OrganizationCustomerOutput
{
return(_customerAccountRepo.Queryable()
.Where(x => x.AccountManagerOrganizationId == agencyOwner.OrganizationId)
.Select(x => x.OrganizationCustomer)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <PackedList <T> > GetTimeEntries <T>(IAgencyOwner ao, TimeMatrixFilters filters)
where T : ProviderAgencyOwnerTimeEntryOutput
{
return(Repository.Queryable()
.ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.PaginateProjection <TimeEntry, T>(filters, ProjectionMapping));
}
public async Task <bool> Delete(IAgencyOwner ao, Guid templateId)
{
var template = await Repository.Queryable()
.Where(x => x.ProviderOrganizationId == ao.OrganizationId && x.Id == templateId)
.FirstAsync();
return(await Delete(template));
}
public CustomerController(
IAgencyOwner agencyOwner,
IOrganizationCustomerService customerService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_customerService = customerService;
}
public ContractorController(
IOrganizationContractorService contractorService,
IAgencyOwner agencyOwner,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_contractorService = contractorService;
_agencyOwner = agencyOwner;
}
public Task <T> Create <T>(IAgencyOwner ao, OrganizationMarketerInput input)
where T : OrganizationMarketerOutput
{
_logger.LogInformation(GetLogMessage("ao creating org marketer"));
input.OrganizationId = ao.OrganizationId;
return(Create <T>(input));
}
public async Task <List <OrganizationPayoutIntentOutput> > GetPending(IAgencyOwner principal, PayoutFilters filters)
{
var payouts = await _organizationPayoutIntents.Queryable()
.Where(x => x.OrganizationId == principal.OrganizationId && string.IsNullOrWhiteSpace(x.InvoiceTransferId))
.ProjectTo <OrganizationPayoutIntentOutput>(ProjectionMapping).ToListAsync();
return(payouts);
}
public async Task <TimeEntryResult> Approve(IAgencyOwner ao, Guid[] entries)
{
var entriesToApprove = await Repository.Queryable()
.ForAgencyOwner(ao)
.Where(x => entries.Contains(x.Id)).ToListAsync();
return(await Approve(entriesToApprove));
}
public Task <TimeEntryResult> DeleteTimeEntry(IAgencyOwner ao, Guid entryId)
{
var entry = Repository
.FirstOrDefault(x => x.Id == entryId &&
x.ProviderOrganizationId == ao.OrganizationId);
return(DeleteTimeEntry(entry));
}
public Task <PackedList <T> > GetWorkOrders <T>(IAgencyOwner agencyOwner, WorkOrderFilters filters) where T : ProviderWorkOrderOutput
{
return(Repository.Queryable()
.ApplyWhereFilters(filters)
.Where(x => agencyOwner.OrganizationId == x.AccountManagerOrganizationId &&
x.Status != OrderStatus.Draft)
.PaginateProjection <WorkOrder, T>(filters, ProjectionMapping));
}
public async Task <T> UpdateWorkOrder <T>(IAgencyOwner agencyOwner, Guid orderId, UpdateWorkOrderInput input)
where T : ProviderWorkOrderOutput
{
var workOrder = await Repository.Queryable()
.Where(x => x.AccountManagerOrganizationId == agencyOwner.OrganizationId && x.Id == orderId)
.FirstAsync();
return(await UpdateWorkOrder <T>(workOrder, input));
}
public Task <List <OrganizationBonusIntentOutput> > GetBonusIntents(IAgencyOwner person)
{
return(Repository
.Queryable()
.Include(x => x.Organization)
.Where(x => x.OrganizationId == person.OrganizationId && x.Organization.CustomerId == person.CustomerId)
.ProjectTo <OrganizationBonusIntentOutput>(ProjectionMapping)
.ToListAsync());
}
public RecruiterController(
IServiceProvider serviceProvider,
IAgencyOwner agencyOwner,
IOrganizationRecruiterService recruiterService
) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_recruiterService = recruiterService;
}
