public Task <T> GetAgreement <T>(IProviderAgencyOwner principal, Guid recruitingAgencyId) where T : RecruitingAgreementOutput
{
return(Repository.Queryable().Where(x => x.ProviderOrganizationId == principal.OrganizationId && x.RecruitingOrganizationId == recruitingAgencyId)
.Where(x => x.Status != AgreementStatus.Rejected)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <AgreementResult> CreateAgreement(IProviderAgencyOwner principal,
Guid recruitingOrganizationId, RecruitingAgreementInput input)
{
_logger.LogInformation(GetLogMessage("Creating agreement as Provider Agency Owner: {0}"), principal.OrganizationId);
return(CreateAgreement(principal, recruitingOrganizationId));
}
public Task <T> GetLead <T>(IProviderAgencyOwner agencyOwner, Guid leadId) where T : AgencyOwnerLeadOutput
{
return(Repository.Queryable()
.Where(x => x.Id == leadId && x.ProviderOrganizationId == agencyOwner.OrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstAsync());
}
public RecruitingOrganizationController(IServiceProvider serviceProvider,
IRecruitingOrganizationService service,
IProviderAgencyOwner providerAgencyOwner) : base(serviceProvider)
{
_service = service;
_providerAgencyOwner = providerAgencyOwner;
}
public Task <PackedList <T> > GetStories <T>(IProviderAgencyOwner ao, StoryFilters filters
) where T : AgencyOwnerStoryOutput
{
return(Repository.Queryable().ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.PaginateProjection <Story, T>(filters, ProjectionMapping));
}
public async Task <AgreementResult> AcceptAgreement(IProviderAgencyOwner providerAgencyOwner,
Guid marketingOrganizationId)
{
_logger.LogInformation(GetLogMessage("Provider: {0}; Marketer: {1}"),
providerAgencyOwner.OrganizationId,
marketingOrganizationId);
var retVal = new AgreementResult()
{
MarketingOrganizationId = marketingOrganizationId,
ProviderOrganizationId = providerAgencyOwner.OrganizationId
};
var agreement = await Repository.Queryable()
.FirstOrDefaultAsync(x =>
x.ProviderOrganizationId == providerAgencyOwner.OrganizationId &&
x.MarketingOrganizationId == marketingOrganizationId);
if (agreement == null)
{
retVal.ErrorMessage = "No agreement found";
return(retVal);
}
if (agreement.Status != AgreementStatus.AwaitingApproval)
{
return new AgreementResult()
{
Succeeded = false,
}
}
;
agreement.Status = AgreementStatus.Approved;
agreement.ObjectState = ObjectState.Modified;
agreement.Updated = DateTimeOffset.UtcNow;
var result = Repository.InsertOrUpdateGraph(agreement, true);
_logger.LogDebug(GetLogMessage("{0} records updated in database"), result);
if (result > 0)
{
await Task.Run(() => RaiseEvent(new MarketingAgreementAccepted()
{
MarketingOrganizationId = marketingOrganizationId,
ProviderOganizationId = providerAgencyOwner.OrganizationId
}));
}
return(new AgreementResult()
{
Succeeded = result > 0,
MarketingOrganizationId = agreement.MarketingOrganizationId,
ProviderOrganizationId = agreement.ProviderOrganizationId
});
}
}
public Task <StoryResult> CreateStory(
IProviderAgencyOwner agencyOwner,
CreateStoryInput input
)
{
return(CreateStoryInternal(input, agencyOwner.OrganizationId));
}
public Task <CustomerAccount> GetAccount(IProviderAgencyOwner agencyOwner, int accountId)
{
return(Repository.Queryable()
.ForAgencyOwner(agencyOwner)
.Where(x => x.Number == accountId)
.FirstOrDefaultAsync());
}
public async Task <ProjectResult> DeleteProject(IProviderAgencyOwner agencyOwner, Guid projectId)
{
var retVal = new ProjectResult()
{
ProjectId = projectId
};
var project = await Repository.Queryable()
.Include(x => x.Stories)
.Include(x => x.Contracts)
.ThenInclude(x => x.TimeEntries)
.FirstAsync(x => x.Id == projectId);
project.Updated = DateTimeOffset.UtcNow;
project.UpdatedById = _userInfo.UserId;
project.ObjectState = ObjectState.Modified;
project.IsDeleted = true;
foreach (var contract in project.Contracts)
{
contract.Updated = DateTimeOffset.UtcNow;
contract.UpdatedById = _userInfo.UserId;
contract.IsDeleted = true;
contract.ObjectState = ObjectState.Modified;
foreach (var e in contract.TimeEntries)
{
e.Updated = DateTimeOffset.UtcNow;
e.UpdatedById = _userInfo.UserId;
e.IsDeleted = true;
e.ObjectState = ObjectState.Modified;
}
}
foreach (var story in project.Stories)
{
story.Updated = DateTimeOffset.UtcNow;
story.IsDeleted = true;
story.ObjectState = ObjectState.Modified;
}
var result = Repository.InsertOrUpdateGraph(project, true);
_logger.LogDebug(GetLogMessage("{0} results updated"), result);
if (result > 0)
{
retVal.Succeeded = true;
await Task.Run(() =>
{
RaiseEvent(new ProjectDeletedEvent()
{
ProjectId = project.Id
});
});
}
return(retVal);
}
public Task <List <T> > GetAgreements <T>(IProviderAgencyOwner providerAgencyOwner) where T : MarketingAgreementOutput
{
return(Repository.Queryable().Where(x => x.ProviderOrganizationId == providerAgencyOwner.OrganizationId)
.Where(x => x.Status != AgreementStatus.Rejected)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <PackedList <T> > GetFixedPriceProposals <T>(IProviderAgencyOwner ao, ProposalFilters filters) where T : AgencyOwnerFixedPriceProposalOutput
{
return(Repository.Queryable()
.ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.PaginateProjection <FixedPriceProposal, T>(filters, ProjectionMapping));
}
public Task <PackedList <T> > GetProviderContracts <T>(IProviderAgencyOwner ao, ContractFilters filters)
where T : AgencyOwnerProviderContractOutput
{
return(Repository.Queryable().ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.OrderByDescending(x => x.Updated)
.PaginateProjection <Contract, T>(filters, ProjectionMapping));
}
public async Task <bool> CreateLeadComment(IProviderAgencyOwner agencyOwner, Guid leadId, CommentInput input)
{
var lead = await _leadRepository.Queryable().ForAgencyOwner(agencyOwner)
.Where(x => x.Id == leadId)
.FirstAsync();
return(await CreateLeadComment(lead, input, agencyOwner.OrganizationId));
}
public async Task <LeadResult> DeleteLead(IProviderAgencyOwner agencyOwner, Guid leadId)
{
var lead = await Repository.Queryable()
.ForAgencyOwner(agencyOwner)
.Where(x => x.Id == leadId).FirstAsync();
return(await DeleteLead(lead.Id));
}
public async Task <ProjectResult> UpdateProject(IProviderAgencyOwner ao, Guid projectId, UpdateProjectInput model)
{
var entity = await Repository.Queryable().ForAgencyOwner(ao).FindById(projectId).FirstOrDefaultAsync();
entity.InjectFrom <NullableInjection>(model);
return(await UpdateProject(entity));
}
public Task <T> GetAccount <T>(IProviderAgencyOwner agencyOwner, int accountId) where T : AgencyOwnerCustomerAccountOutput
{
return(Repository.Queryable()
.ForAgencyOwner(agencyOwner)
.Where(x => x.Number == accountId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> GetProposal <T>(IProviderAgencyOwner ao, Guid proposalId) where T : AgencyOwnerFixedPriceProposalOutput
{
return(Repository.Queryable()
.ForAgencyOwner(ao)
.FindById(proposalId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <bool> CreateStoryComment(IProviderAgencyOwner agencyOwner, Guid storyId, CommentInput input)
{
var story = await _storyRepository.Queryable().ForAgencyOwner(agencyOwner)
.FindById(storyId).FirstAsync();
return(await CreateStoryComment(story, input, agencyOwner.OrganizationId));
}
public Task <PackedList <T> > GetInvoices <T>(IProviderAgencyOwner ao, InvoiceFilters filters)
where T : AgencyOwnerProjectInvoiceOutput, new()
{
return(Repository.Queryable()
.ForAgencyOwner(ao)
.ApplyWhereFilters(filters)
.PaginateProjection <ProjectInvoice, T>(filters, ProjectionMapping));
}
public MarketingOrganizationController(
IProviderAgencyOwner providerAgencyOwner,
IMarketingOrganizationService service,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_providerAgencyOwner = providerAgencyOwner;
_service = service;
}
public BillingCategoryController(
IProviderAgencyOwner agencyOwner,
IBillingCategoryService billingCategoryService,
IServiceProvider serviceProvider) : base(serviceProvider)
{
_agencyOwner = agencyOwner;
_billingCategoryService = billingCategoryService;
}
public async Task <bool> CreateCandidateComment(IProviderAgencyOwner agencyOwner, Guid candidateId, CommentInput input)
{
var candidate = await _candidateRepository.Queryable().ForAgencyOwner(agencyOwner)
.Where(x => x.Id == candidateId)
.FirstAsync();
return(await CreateCandidateComment(candidate, input, agencyOwner.OrganizationId));
}
public Task <T> GetProject <T>(IProviderAgencyOwner agencyOwner, Guid projectId) where T : AgencyOwnerProjectOutput, new()
{
return(Repository.Queryable()
.ForAgencyOwner(agencyOwner)
.FindById(projectId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <T> GetAgreement <T>(IProviderAgencyOwner providerAgencyOwner, Guid marketingOrganizationId) where T : MarketingAgreementOutput
{
return(Repository
.Queryable()
.Where(x => x.ProviderOrganizationId == providerAgencyOwner.OrganizationId && x.MarketingOrganizationId == marketingOrganizationId)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public async Task <InvoiceResult> SendInvoice(IProviderAgencyOwner agencyOwner, string invoiceId)
{
var invoice = await Repository.Queryable()
.ForAgencyOwner(agencyOwner)
.Where(x => x.InvoiceId == invoiceId)
.FirstOrDefaultAsync();
return(await SendInvoice(invoice.InvoiceId));
}
public Task <PackedList <T> > GetAccounts <T>(
IProviderAgencyOwner ao, CommonFilters filters)
where T : AgencyOwnerCustomerAccountOutput
{
return(Repository.Queryable()
.ForAgencyOwner(ao)
.OrderByDescending(x => x.Updated)
.PaginateProjection <CustomerAccount, T>(filters, ProjectionMapping));
}
public Task <T> GetProviderContract <T>(IProviderAgencyOwner agencyOwner, Guid contractId)
where T : AgencyOwnerProviderContractOutput
{
return(Repository.Queryable().ForAgencyOwner(agencyOwner)
.FindById(contractId)
.Include(a => a.TimeEntries).ThenInclude(x => x.Story)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}
public Task <List <T> > GetProjects <T>(IProviderAgencyOwner owner, Guid[] uniqueProjectIds) where T : AgencyOwnerProjectOutput, new()
{
return(Repository.Queryable()
.ForAgencyOwner(owner)
.Where(x => uniqueProjectIds.Contains(x.Id))
.OrderByDescending(x => x.Updated)
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <List <T> > GetStories <T>(IProviderAgencyOwner owner, Guid?[] uniqueStoryIds)
where T : AgencyOwnerStoryOutput
{
return(Repository.Queryable()
.ForAgencyOwner(owner)
.Where(x => uniqueStoryIds.Contains(x.Id))
.ProjectTo <T>(ProjectionMapping)
.ToListAsync());
}
public Task <T> GetStory <T>(IProviderAgencyOwner ao, Guid storyId)
where T : AgencyOwnerStoryOutput
{
return(Repository.Queryable()
.FindById(storyId)
.ForAgencyOwner(ao)
.ProjectTo <T>(ProjectionMapping)
.FirstOrDefaultAsync());
}