public async Task<int> Count(CooperativeAttitudeFilter CooperativeAttitudeFilter)
{
try
{
int result = await UOW.CooperativeAttitudeRepository.Count(CooperativeAttitudeFilter);
return result;
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CooperativeAttitudeService));
}
return 0;
}
public async Task <int> Count(ActivityPriorityFilter ActivityPriorityFilter)
{
try
{
int result = await UOW.ActivityPriorityRepository.Count(ActivityPriorityFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(ActivityPriorityService));
}
return(0);
}
public async Task <int> Count(CustomerLeadSourceFilter CustomerLeadSourceFilter)
{
try
{
int result = await UOW.CustomerLeadSourceRepository.Count(CustomerLeadSourceFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerLeadSourceService));
}
return(0);
}
public async Task <int> Count(PotentialResultFilter PotentialResultFilter)
{
try
{
int result = await UOW.PotentialResultRepository.Count(PotentialResultFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(PotentialResultService));
}
return(0);
}
public async Task <int> Count(EmailTypeFilter EmailTypeFilter)
{
try
{
int result = await UOW.EmailTypeRepository.Count(EmailTypeFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(EmailTypeService));
}
return(0);
}
public async Task <int> Count(InfulenceLevelMarketFilter InfulenceLevelMarketFilter)
{
try
{
int result = await UOW.InfulenceLevelMarketRepository.Count(InfulenceLevelMarketFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(InfulenceLevelMarketService));
}
return(0);
}
public async Task <int> Count(KpiCriteriaGeneralFilter KpiCriteriaGeneralFilter)
{
try
{
int result = await UOW.KpiCriteriaGeneralRepository.Count(KpiCriteriaGeneralFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(KpiCriteriaGeneralService));
}
return(0);
}
public async Task <int> Count(SLATimeUnitFilter SLATimeUnitFilter)
{
try
{
int result = await UOW.SLATimeUnitRepository.Count(SLATimeUnitFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(SLATimeUnitService));
}
return(0);
}
public async Task <int> Count(RatingStatusFilter RatingStatusFilter)
{
try
{
int result = await UOW.RatingStatusRepository.Count(RatingStatusFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(RatingStatusService));
}
return(0);
}
public async Task <int> Count(UsedVariationFilter UsedVariationFilter)
{
try
{
int result = await UOW.UsedVariationRepository.Count(UsedVariationFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(UsedVariationService));
}
return(0);
}
public async Task <int> Count(OrderCategoryFilter OrderCategoryFilter)
{
try
{
int result = await UOW.OrderCategoryRepository.Count(OrderCategoryFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(OrderCategoryService));
}
return(0);
}
public async Task <int> Count(OpportunityEmailFilter OpportunityEmailFilter)
{
try
{
int result = await UOW.OpportunityEmailRepository.Count(OpportunityEmailFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(OpportunityEmailService));
}
return(0);
}
public async Task <int> Count(DistrictFilter DistrictFilter)
{
try
{
int result = await UOW.DistrictRepository.Count(DistrictFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex.InnerException, nameof(DistrictService));
if (ex.InnerException == null)
{
throw new MessageException(ex);
}
else
{
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(PermissionOperatorFilter PermissionOperatorFilter)
{
try
{
int result = await UOW.PermissionOperatorRepository.Count(PermissionOperatorFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(PermissionOperatorService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(PermissionOperatorService));
throw new MessageException(ex.InnerException);
};
}
}
public async Task <int> Count(UsedVariationFilter UsedVariationFilter)
{
try
{
int result = await UOW.UsedVariationRepository.Count(UsedVariationFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(UsedVariationService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(UsedVariationService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(TrackingFilter TrackingFilter)
{
try
{
int result = await UOW.TrackingRepository.Count(TrackingFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(TrackingService));
}
return(0);
}
public async Task <int> Count(CustomerSalesOrderPaymentHistoryFilter CustomerSalesOrderPaymentHistoryFilter)
{
try
{
int result = await UOW.CustomerSalesOrderPaymentHistoryRepository.Count(CustomerSalesOrderPaymentHistoryFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(CustomerSalesOrderPaymentHistoryService));
}
return(0);
}
public async Task <int> Count(LocationLogFilter LocationLogFilter)
{
try
{
LocationLogFilter.AppUserId = FilterBuilder.Merge(
LocationLogFilter.AppUserId,
new IdFilter
{
In = await FilterAppUser(AppUserService, CurrentContext)
});
int result = await UOW.LocationLogRepository.Count(LocationLogFilter);
return(result);
}
catch (Exception ex)
{
await Logging.CreateSystemLog(ex, nameof(LocationLogService));
}
return(0);
}
public async Task <int> Count(TicketGeneratedIdFilter TicketGeneratedIdFilter)
{
try
{
int result = await UOW.TicketGeneratedIdRepository.Count(TicketGeneratedIdFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(TicketGeneratedIdService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(TicketGeneratedIdService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(SLAAlertFRTMailFilter SLAAlertFRTMailFilter)
{
try
{
int result = await UOW.SLAAlertFRTMailRepository.Count(SLAAlertFRTMailFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(SLAAlertFRTMailService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(SLAAlertFRTMailService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(KnowledgeArticleFilter KnowledgeArticleFilter)
{
try
{
int result = await UOW.KnowledgeArticleRepository.Count(KnowledgeArticleFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(KnowledgeArticleService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(KnowledgeArticleService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(OrderQuoteContentFilter OrderQuoteContentFilter)
{
try
{
int result = await UOW.OrderQuoteContentRepository.Count(OrderQuoteContentFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(OrderQuoteContentService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(OrderQuoteContentService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(ContractPaymentHistoryFilter ContractPaymentHistoryFilter)
{
try
{
int result = await UOW.ContractPaymentHistoryRepository.Count(ContractPaymentHistoryFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(ContractPaymentHistoryService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(ContractPaymentHistoryService));
throw new MessageException(ex.InnerException);
}
}
}
public async Task <int> Count(RelationshipCustomerTypeFilter RelationshipCustomerTypeFilter)
{
try
{
int result = await UOW.RelationshipCustomerTypeRepository.Count(RelationshipCustomerTypeFilter);
return(result);
}
catch (Exception ex)
{
if (ex.InnerException == null)
{
await Logging.CreateSystemLog(ex, nameof(RelationshipCustomerTypeService));
throw new MessageException(ex);
}
else
{
await Logging.CreateSystemLog(ex.InnerException, nameof(RelationshipCustomerTypeService));
throw new MessageException(ex.InnerException);
}
}
}