public async Task <OpportunityFilter> ToFilter(OpportunityFilter filter)
{
if (filter.OrFilter == null)
{
filter.OrFilter = new List <OpportunityFilter>();
}
if (CurrentContext.Filters == null || CurrentContext.Filters.Count == 0)
{
return(filter);
}
List <Organization> Organizations = await OrganizationService.List(new OrganizationFilter
{
Skip = 0,
Take = int.MaxValue,
Selects = OrganizationSelect.ALL,
OrderBy = OrganizationOrder.Id,
OrderType = OrderType.ASC
});
foreach (var currentFilter in CurrentContext.Filters)
{
OpportunityFilter subFilter = new OpportunityFilter();
filter.OrFilter.Add(subFilter);
List <FilterPermissionDefinition> FilterPermissionDefinitions = currentFilter.Value;
foreach (FilterPermissionDefinition FilterPermissionDefinition in FilterPermissionDefinitions)
{
if (FilterPermissionDefinition.Name == nameof(subFilter.AppUserId))
{
subFilter.AppUserId = FilterBuilder.Merge(subFilter.AppUserId, FilterPermissionDefinition.IdFilter);
}
}
}
return(filter);
}
private OpportunityFilter ConvertFilterOpportunity(Contact_OpportunityFilterDTO Contact_OpportunityFilterDTO)
{
OpportunityFilter OpportunityFilter = new OpportunityFilter();
OpportunityFilter.Selects = OpportunitySelect.ALL;
OpportunityFilter.Skip = Contact_OpportunityFilterDTO.Skip;
OpportunityFilter.Take = Contact_OpportunityFilterDTO.Take;
OpportunityFilter.OrderBy = Contact_OpportunityFilterDTO.OrderBy;
OpportunityFilter.OrderType = Contact_OpportunityFilterDTO.OrderType;
OpportunityFilter.Id = Contact_OpportunityFilterDTO.Id;
OpportunityFilter.Name = Contact_OpportunityFilterDTO.Name;
OpportunityFilter.CompanyId = Contact_OpportunityFilterDTO.CompanyId;
OpportunityFilter.CustomerLeadId = Contact_OpportunityFilterDTO.CustomerLeadId;
OpportunityFilter.ClosingDate = Contact_OpportunityFilterDTO.ClosingDate;
OpportunityFilter.SaleStageId = Contact_OpportunityFilterDTO.SaleStageId;
OpportunityFilter.ProbabilityId = Contact_OpportunityFilterDTO.ProbabilityId;
OpportunityFilter.PotentialResultId = Contact_OpportunityFilterDTO.PotentialResultId;
OpportunityFilter.LeadSourceId = Contact_OpportunityFilterDTO.LeadSourceId;
OpportunityFilter.AppUserId = Contact_OpportunityFilterDTO.AppUserId;
OpportunityFilter.CurrencyId = Contact_OpportunityFilterDTO.CurrencyId;
OpportunityFilter.Amount = Contact_OpportunityFilterDTO.Amount;
OpportunityFilter.ForecastAmount = Contact_OpportunityFilterDTO.ForecastAmount;
OpportunityFilter.Description = Contact_OpportunityFilterDTO.Description;
OpportunityFilter.OpportunityResultTypeId = Contact_OpportunityFilterDTO.OpportunityResultTypeId;
OpportunityFilter.CreatorId = Contact_OpportunityFilterDTO.CreatorId;
OpportunityFilter.ContactId = Contact_OpportunityFilterDTO.ContactId;
OpportunityFilter.CreatedAt = Contact_OpportunityFilterDTO.CreatedAt;
OpportunityFilter.UpdatedAt = Contact_OpportunityFilterDTO.UpdatedAt;
return(OpportunityFilter);
}
private OpportunityFilter ConvertFilterDTOToFilterEntity(OpportunityReport_OpportunityReportFilterDTO OpportunityReport_OpportunityReportFilterDTO)
{
OpportunityFilter OpportunityFilter = new OpportunityFilter();
OpportunityFilter.Selects = OpportunitySelect.ALL;
OpportunityFilter.Skip = 0;
OpportunityFilter.Take = OpportunityReport_OpportunityReportFilterDTO.Take;
OpportunityFilter.OrderType = OpportunityReport_OpportunityReportFilterDTO.OrderType;
OpportunityFilter.Name = OpportunityReport_OpportunityReportFilterDTO.OpportunityName;
OpportunityFilter.Amount = OpportunityReport_OpportunityReportFilterDTO.OpportunityAmount;
OpportunityFilter.CompanyId = OpportunityReport_OpportunityReportFilterDTO.OpportunityCompanyId;
OpportunityFilter.SaleStageId = OpportunityReport_OpportunityReportFilterDTO.OpportunitySaleStageId;
OpportunityFilter.ProbabilityId = OpportunityReport_OpportunityReportFilterDTO.OpportunityProbabilityId;
OpportunityFilter.ClosingDate = OpportunityReport_OpportunityReportFilterDTO.OpportunityClosingDate;
OpportunityFilter.CreatedAt = OpportunityReport_OpportunityReportFilterDTO.OpportunityCreatedAt;
return(OpportunityFilter);
}
public async Task <ActionResult <int> > CountOpportunity([FromBody] Contact_OpportunityFilterDTO Contact_OpportunityFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
OpportunityFilter OpportunityFilter = ConvertFilterOpportunity(Contact_OpportunityFilterDTO);
OpportunityFilter = await OpportunityService.ToFilter(OpportunityFilter);
int count = await OpportunityService.Count(OpportunityFilter);
return(count);
}
public async Task <bool> ValidateId(Opportunity Opportunity)
{
OpportunityFilter OpportunityFilter = new OpportunityFilter
{
Skip = 0,
Take = 10,
Id = new IdFilter {
Equal = Opportunity.Id
},
Selects = OpportunitySelect.Id
};
int count = await UOW.OpportunityRepository.Count(OpportunityFilter);
if (count == 0)
{
Opportunity.AddError(nameof(OpportunityValidator), nameof(Opportunity.Id), ErrorCode.IdNotExisted);
}
return(count == 1);
}
public async Task <ActionResult <List <ContractReport_OpportunityDTO> > > FilterListOpportunity([FromBody] ContractReport_OpportunityFilterDTO ContractReport_OpportunityFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
OpportunityFilter OpportunityFilter = new OpportunityFilter();
OpportunityFilter.Skip = 0;
OpportunityFilter.Take = 20;
OpportunityFilter.OrderBy = OpportunityOrder.Id;
OpportunityFilter.OrderType = OrderType.ASC;
OpportunityFilter.Selects = OpportunitySelect.ALL;
OpportunityFilter.Id = ContractReport_OpportunityFilterDTO.Id;
OpportunityFilter.Name = ContractReport_OpportunityFilterDTO.Name;
OpportunityFilter.CompanyId = ContractReport_OpportunityFilterDTO.CompanyId;
OpportunityFilter.CustomerLeadId = ContractReport_OpportunityFilterDTO.CustomerLeadId;
OpportunityFilter.ClosingDate = ContractReport_OpportunityFilterDTO.ClosingDate;
OpportunityFilter.SaleStageId = ContractReport_OpportunityFilterDTO.SaleStageId;
OpportunityFilter.ProbabilityId = ContractReport_OpportunityFilterDTO.ProbabilityId;
OpportunityFilter.PotentialResultId = ContractReport_OpportunityFilterDTO.PotentialResultId;
OpportunityFilter.LeadSourceId = ContractReport_OpportunityFilterDTO.LeadSourceId;
OpportunityFilter.AppUserId = ContractReport_OpportunityFilterDTO.AppUserId;
OpportunityFilter.Amount = ContractReport_OpportunityFilterDTO.Amount;
OpportunityFilter.ForecastAmount = ContractReport_OpportunityFilterDTO.ForecastAmount;
OpportunityFilter.Description = ContractReport_OpportunityFilterDTO.Description;
OpportunityFilter.CreatorId = ContractReport_OpportunityFilterDTO.CreatorId;
List <Opportunity> Opportunities = await OpportunityService.List(OpportunityFilter);
List <ContractReport_OpportunityDTO> ContractReport_OpportunityDTOs = Opportunities
.Select(x => new ContractReport_OpportunityDTO(x)).ToList();
return(ContractReport_OpportunityDTOs);
}
public async Task <ActionResult <List <Contact_OpportunityDTO> > > ListOpportunity([FromBody] Contact_OpportunityFilterDTO Contact_OpportunityFilterDTO)
{
if (UnAuthorization)
{
return(Forbid());
}
if (!ModelState.IsValid)
{
throw new BindException(ModelState);
}
OpportunityFilter OpportunityFilter = ConvertFilterOpportunity(Contact_OpportunityFilterDTO);
OpportunityFilter = await OpportunityService.ToFilter(OpportunityFilter);
List <Opportunity> Opportunities = await OpportunityService.List(OpportunityFilter);
List <Contact_OpportunityDTO> Contact_OpportunityDTOs = Opportunities
.Select(c => new Contact_OpportunityDTO(c)).ToList();
return(Contact_OpportunityDTOs);
}
public async Task <bool> ValidateOpportunity(CustomerLead CustomerLead)
{
if (CustomerLead.OpportunityId.HasValue == false)
{
CustomerLead.AddError(nameof(CustomerLeadValidator), nameof(CustomerLead.Opportunity), ErrorCode.OpportunityEmpty);
}
else
{
OpportunityFilter OpportunityFilter = new OpportunityFilter
{
Id = new IdFilter {
Equal = CustomerLead.OpportunityId
}
};
var count = await UOW.OpportunityRepository.Count(OpportunityFilter);
if (count == 0)
{
CustomerLead.AddError(nameof(CustomerLeadValidator), nameof(CustomerLead.Opportunity), ErrorCode.OpportunityNotExisted);
}
}
return(CustomerLead.IsValidated);
}
public async Task <List <Opportunity> > List(OpportunityFilter OpportunityFilter)
{
try
{
List <Opportunity> Opportunitys = await UOW.OpportunityRepository.List(OpportunityFilter);
return(Opportunitys);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(OpportunityService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(OpportunityService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(OpportunityFilter OpportunityFilter)
{
try
{
int result = await UOW.OpportunityRepository.Count(OpportunityFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(OpportunityService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(OpportunityService));
throw new MessageException(ex.InnerException);
}
}
}
