public PurchaseQuotationSettingService(IUnitOfWorkForService unitOfWork)
{
this.db = new ApplicationDbContext();
_unitOfWork = unitOfWork;
_PurchaseQuotationSettingRepository = new Repository <PurchaseQuotationSetting>(db);
PurchaseQuotationSettingRepository = new RepositoryQuery <PurchaseQuotationSetting>(_PurchaseQuotationSettingRepository);
}
private async Task <Dictionary <string, double> > GetUserCountByProjectIdsAsync(ICollection <Stack> stacks, AppFilter sf, DateTime utcStart, DateTime utcEnd)
{
var scopedCacheClient = new ScopedCacheClient(_cache, $"Project:user-count:{utcStart.Floor(TimeSpan.FromMinutes(15)).Ticks}-{utcEnd.Floor(TimeSpan.FromMinutes(15)).Ticks}");
var projectIds = stacks.Select(s => s.ProjectId).Distinct().ToList();
var cachedTotals = await scopedCacheClient.GetAllAsync <double>(projectIds);
var totals = cachedTotals.Where(kvp => kvp.Value.HasValue).ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Value);
if (totals.Count == projectIds.Count)
{
return(totals);
}
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(utcStart, utcEnd, (PersistentEvent e) => e.Date).Index(utcStart, utcEnd);
var projects = cachedTotals.Where(kvp => !kvp.Value.HasValue).Select(kvp => new Project {
Id = kvp.Key, OrganizationId = stacks.FirstOrDefault(s => s.ProjectId == kvp.Key)?.OrganizationId
}).ToList();
var countResult = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(projects.BuildFilter()).AggregationsExpression("terms:(project_id cardinality:user)"));
// Cache all projects that have more than 10 users for 5 minutes.
var projectTerms = countResult.Aggregations.Terms <string>("terms_project_id").Buckets;
var aggregations = projectTerms.ToDictionary(t => t.Key, t => t.Aggregations.Cardinality("cardinality_user").Value.GetValueOrDefault());
await scopedCacheClient.SetAllAsync(aggregations.Where(t => t.Value >= 10).ToDictionary(k => k.Key, v => v.Value), TimeSpan.FromMinutes(5));
totals.AddRange(aggregations);
return(totals);
}
Persistence.Table.Empresa table) Data_Table(Entities.Table.Empresa entity)
{
var mockDatabase = GetDatabaseMock();
var mockCommandBuilder = new Moq.Mock <ISqlCommandBuilder>();
var repositoryQuery = new RepositoryQuery <Entities.Table.Empresa, Persistence.Table.Empresa>(
new Entities.Reader.Empresa(mockDatabase.mockSyntaxSign.Object),
new Persistence.Mapper.Empresa(),
mockDatabase.mockSyntaxSign.Object,
mockCommandBuilder.Object,
mockDatabase.mockCreator.Object);
var queryUnique = new Persistence.Query.Empresa(repositoryQuery);
var repositoryTable = new RepositoryTable <Entities.Table.Empresa, Persistence.Table.Empresa>(
new Entities.Reader.Empresa(mockDatabase.mockSyntaxSign.Object),
new Persistence.Mapper.Empresa(),
mockDatabase.mockSyntaxSign.Object,
mockCommandBuilder.Object,
mockDatabase.mockCreator.Object);
var table = new Persistence.Table.Empresa(entity,
repositoryTable,
queryUnique);
return(mockDatabase, table);
}
public Task <long> RemoveAllAsync(string organizationId, string clientIpAddress, DateTime?utcStart, DateTime?utcEnd, CommandOptionsDescriptor <PersistentEvent> options = null)
{
if (String.IsNullOrEmpty(organizationId))
{
throw new ArgumentNullException(nameof(organizationId));
}
var query = new RepositoryQuery <PersistentEvent>().Organization(organizationId);
if (utcStart.HasValue && utcEnd.HasValue)
{
query = query.DateRange(utcStart, utcEnd, InferField(e => e.Date)).Index(utcStart, utcEnd);
}
else if (utcEnd.HasValue)
{
query = query.ElasticFilter(Query <PersistentEvent> .DateRange(r => r.Field(e => e.Date).LessThan(utcEnd)));
}
else if (utcStart.HasValue)
{
query = query.ElasticFilter(Query <PersistentEvent> .DateRange(r => r.Field(e => e.Date).GreaterThan(utcStart)));
}
if (!String.IsNullOrEmpty(clientIpAddress))
{
query = query.FieldEquals(EventIndex.Alias.IpAddress, clientIpAddress);
}
return(RemoveAllAsync(q => query, options));
}
private IRepositoryQuery GetSystemFilterQuery(IQueryVisitorContext context)
{
var builderContext = context as IQueryBuilderContext;
var systemFilter = builderContext?.Source.GetSystemFilter();
var systemFilterQuery = systemFilter?.GetQuery().Clone();
if (systemFilterQuery == null)
{
systemFilterQuery = new RepositoryQuery <Stack>();
foreach (var range in builderContext?.Source.GetDateRanges() ?? Enumerable.Empty <DateRange>())
{
systemFilterQuery.DateRange(range.StartDate, range.EndDate, range.Field, range.TimeZone);
}
}
if (!systemFilterQuery.HasAppFilter())
{
systemFilterQuery.AppFilter(builderContext?.Source.GetAppFilter());
}
foreach (var range in systemFilterQuery.GetDateRanges() ?? Enumerable.Empty <DateRange>())
{
if (range.Field == _inferredEventDateField || range.Field == "date")
{
range.Field = _inferredStackLastOccurrenceField;
}
}
return(systemFilterQuery);
}
private async Task <List <ViewOrganization> > PopulateOrganizationStatsAsync(List <ViewOrganization> viewOrganizations)
{
if (viewOrganizations.Count <= 0)
{
return(viewOrganizations);
}
int maximumRetentionDays = _options.MaximumRetentionDays;
var organizations = viewOrganizations.Select(o => new Organization {
Id = o.Id, CreatedUtc = o.CreatedUtc, RetentionDays = o.RetentionDays
}).ToList();
var sf = new AppFilter(organizations);
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(sf).DateRange(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow, (PersistentEvent e) => e.Date).Index(organizations.GetRetentionUtcCutoff(maximumRetentionDays), SystemClock.UtcNow);
var result = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).AggregationsExpression($"terms:(organization_id~{viewOrganizations.Count} cardinality:stack_id)"));
foreach (var organization in viewOrganizations)
{
var organizationStats = result.Aggregations.Terms <string>("terms_organization_id")?.Buckets.FirstOrDefault(t => t.Key == organization.Id);
organization.EventCount = organizationStats?.Total ?? 0;
organization.StackCount = (long?)organizationStats?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0;
organization.ProjectCount = await _projectRepository.GetCountByOrganizationIdAsync(organization.Id);
}
return(viewOrganizations);
}
public ReasonService(IUnitOfWorkForService unitOfWork)
{
this.db = new ApplicationDbContext();
_unitOfWork = unitOfWork;
_ReasonRepository = new Repository <Reason>(db);
ReasonRepository = new RepositoryQuery <Reason>(_ReasonRepository);
}
public virtual RepositoryQuery <TEntity> Query()
{
var repositoryGetFluentHelper =
new RepositoryQuery <TEntity>(this);
return(repositoryGetFluentHelper);
}
protected async Task <ActionResult <CountResult> > GetCountImplAsync(ExceptionlessSystemFilter sf, TimeInfo ti, string filter = null, string aggregations = null)
{
var pr = await _validator.ValidateQueryAsync(filter);
if (!pr.IsValid)
{
return(BadRequest(pr.Message));
}
var far = await _validator.ValidateAggregationsAsync(aggregations);
if (!far.IsValid)
{
return(BadRequest(far.Message));
}
sf.UsesPremiumFeatures = pr.UsesPremiumFeatures || far.UsesPremiumFeatures;
var query = new RepositoryQuery <TModel>()
.SystemFilter(ShouldApplySystemFilter(sf, filter) ? sf : null)
.DateRange(ti.Range.UtcStart, ti.Range.UtcEnd, ti.Field)
.Index(ti.Range.UtcStart, ti.Range.UtcEnd);
CountResult result;
try {
result = await _repository.CountBySearchAsync(query, filter, aggregations);
} catch (Exception ex) {
using (_logger.BeginScope(new ExceptionlessState().Property("Search Filter", new { SystemFilter = sf, UserFilter = filter, Time = ti, Aggregations = aggregations }).Tag("Search").Identity(CurrentUser.EmailAddress).Property("User", CurrentUser).SetHttpContext(HttpContext)))
_logger.LogError(ex, "An error has occurred. Please check your filter or aggregations.");
return(BadRequest("An error has occurred. Please check your search filter."));
}
return(Ok(result));
}
private async Task <List <ViewProject> > PopulateProjectStatsAsync(List <ViewProject> viewProjects)
{
if (viewProjects.Count <= 0)
{
return(viewProjects);
}
var organizations = await _organizationRepository.GetByIdsAsync(viewProjects.Select(p => p.OrganizationId).ToArray(), o => o.Cache());
var projects = viewProjects.Select(p => new Project {
Id = p.Id, CreatedUtc = p.CreatedUtc, OrganizationId = p.OrganizationId
}).ToList();
var sf = new ExceptionlessSystemFilter(projects, organizations);
var systemFilter = new RepositoryQuery <PersistentEvent>().SystemFilter(sf).DateRange(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow, (PersistentEvent e) => e.Date).Index(organizations.GetRetentionUtcCutoff(), SystemClock.UtcNow);
var result = await _eventRepository.CountBySearchAsync(systemFilter, null, $"terms:(project_id~{viewProjects.Count} cardinality:stack_id)");
foreach (var project in viewProjects)
{
var term = result.Aggregations.Terms <string>("terms_project_id")?.Buckets.FirstOrDefault(t => t.Key == project.Id);
project.EventCount = term?.Total ?? 0;
project.StackCount = (long)(term?.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0);
}
return(viewProjects);
}
public PurchaseOrderLineService(IUnitOfWorkForService unitOfWork)
{
this.db = new ApplicationDbContext();
_unitOfWork = unitOfWork;
_PurchaseOrderLineRepository = new Repository <PurchaseOrderLine>(db);
PurchaseOrderLineRepository = new RepositoryQuery <PurchaseOrderLine>(_PurchaseOrderLineRepository);
}
public DocumentTypeService(IUnitOfWorkForService unitOfWork)
{
this.db = new ApplicationDbContext();
_unitOfWork = unitOfWork;
_DocumentTypeRepository = new Repository <DocumentType>(db);
DocumentTypeRepository = new RepositoryQuery <DocumentType>(_DocumentTypeRepository);
}
/// <summary>
/// GetUserTasks
/// </summary>
/// <returns></returns>
public List <UserTask> GetUserTasks(ContextEnum contextId, string assignedTo, DateTime?fromDate, DateTime?toDate, bool activeTasks)
{
RepositoryQuery <UserTask> userTasks = eCollabroDbContext.Repository <UserTask>().Query().Include(inc => inc.UserMembership).Include(inc => inc.UserMembership1).Filter(qry => qry.SiteId.Equals(UserContextDetails.SiteId));
if (contextId != 0)
{
userTasks = userTasks.Filter(qry => qry.ContextId.Equals((int)contextId));
}
if (!string.IsNullOrEmpty(assignedTo))
{
userTasks = userTasks.Filter(qry => qry.UserMembership.UserName.Equals(assignedTo));
}
if (fromDate.HasValue)
{
DateTime dtFrom = fromDate.Value.ToUniversalTime();
userTasks.Filter(qry => qry.CreatedOn >= dtFrom);
}
if (toDate.HasValue)
{
DateTime dtTo = toDate.Value.ToUniversalTime();
userTasks.Filter(qry => qry.CreatedOn <= dtTo);
}
if (activeTasks)
{
userTasks.Filter(qry => qry.IsActive);
}
SecurityManager securityManager = new SecurityManager();
if ((securityManager.CheckSiteCollectionAdmin(UserContextDetails.UserId) || securityManager.CheckSiteAdmin(UserContextDetails.UserId, UserContextDetails.SiteId)))
{
return(userTasks.Get().ToList());
}
else
{
List <FeaturePermissionResult> userFeaturePermissionResults = eCollabroDbContext.ExtendedRepository().SecurityRepository.GetUserPermissions(UserContextDetails.SiteId, UserContextDetails.UserId).Where(qry => qry.ContentPermissionId.Equals((int)PermissionEnum.ApproveContent)).ToList();
List <int> contentContexts = new List <int>();
if (userFeaturePermissionResults.Count > 0)
{
foreach (FeaturePermissionResult featurePermissionResult in userFeaturePermissionResults)
{
ContextEnum context = GetContextForFeature((FeatureEnum)featurePermissionResult.FeatureId);
if (context != ContextEnum.None)
{
contentContexts.Add((int)context);
}
}
}
if (contentContexts.Count > 0)
{
userTasks = userTasks.Filter(qry => contentContexts.Contains(qry.ContextId) || (qry.AssignedUserId == UserContextDetails.UserId));
}
else
{
userTasks = userTasks.Filter(qry => qry.AssignedUserId.HasValue && qry.AssignedUserId == UserContextDetails.UserId);
}
return(userTasks.Get().ToList());
}
}
//RepositoryQuery<ProductUidHeaderDimension> productdimensionRepository;
public ProductUidHeaderService(IUnitOfWorkForService unitOfWork)
{
_unitOfWork = unitOfWork;
_productRepository = new Repository <ProductUidHeader>(db);
//_productdimensionRepository = new Repository<ProductUidHeaderDimension>(db);
productRepository = new RepositoryQuery <ProductUidHeader>(_productRepository);
// productdimensionRepository = new RepositoryQuery<ProductUidHeaderDimension>(_productdimensionRepository);
}
//RepositoryQuery<PersonProductUidDimension> productdimensionRepository;
public PersonProductUidService(IUnitOfWorkForService unitOfWork)
{
_unitOfWork = unitOfWork;
_productRepository = new Repository <PersonProductUid>(db);
//_productdimensionRepository = new Repository<PersonProductUidDimension>(db);
productRepository = new RepositoryQuery <PersonProductUid>(_productRepository);
// productdimensionRepository = new RepositoryQuery<PersonProductUidDimension>(_productdimensionRepository);
}
public Task <FindResults <Project> > GetByFilterAsync(AppFilter systemFilter, string userFilter, string sort, CommandOptionsDescriptor <Project> options = null)
{
IRepositoryQuery <Project> query = new RepositoryQuery <Project>()
.AppFilter(systemFilter)
.FilterExpression(userFilter);
query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortAscending(p => p.Name.Suffix("keyword"));
return(FindAsync(q => query, options));
}
public Task <FindResults <Stack> > GetByFilterAsync(ExceptionlessSystemFilter systemFilter, string userFilter, string sort, string field, DateTime utcStart, DateTime utcEnd, CommandOptionsDescriptor <Stack> options = null)
{
IRepositoryQuery <Stack> query = new RepositoryQuery <Stack>()
.DateRange(utcStart, utcEnd, field ?? ElasticType.GetFieldName(s => s.LastOccurrence))
.SystemFilter(systemFilter)
.FilterExpression(userFilter);
query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortDescending(s => s.LastOccurrence);
return(FindAsync(q => query, options));
}
public async Task GetByCompanyAsync()
{
Log.MinimumLevel = LogLevel.Trace;
var employee1 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 19, companyId: EmployeeGenerator.DefaultCompanyId), o => o.ImmediateConsistency());
var employee2 = await _employeeRepository.AddAsync(EmployeeGenerator.Generate(age: 20), o => o.ImmediateConsistency());
var results = await _employeeRepository.GetAllByCompanyAsync(employee1.CompanyId);
Assert.Equal(1, results.Total);
Assert.Equal(employee1, results.Documents.First());
results = await _employeeRepository.GetAllByCompanyAsync(employee2.CompanyId);
Assert.Equal(1, results.Total);
Assert.Equal(employee2, results.Documents.First());
results = await _employeeRepository.GetAllByCompaniesWithFieldEqualsAsync(new string[] { employee1.CompanyId });
Assert.Equal(1, results.Total);
results = await _employeeRepository.GetAllByCompaniesWithFieldEqualsAsync(new string[] { employee1.CompanyId, employee2.CompanyId });
Assert.Equal(2, results.Total);
Assert.Equal(1, await _employeeRepository.GetCountByCompanyAsync(employee1.CompanyId));
await _employeeRepository.RemoveAsync(employee1, o => o.Cache().ImmediateConsistency());
var result = await _employeeRepository.FindAsync(q => q.FieldCondition(e => e.Age, ComparisonOperator.Equals, 12));
Assert.Empty(result.Documents);
var query = new RepositoryQuery <Employee>();
query.FieldEquals(e => e.Age, 12);
result = await _employeeRepository.FindAsync(q => query);
Assert.Empty(result.Documents);
Assert.Equal(1, await _employeeRepository.CountAsync());
Assert.Equal(0, await _employeeRepository.GetCountByCompanyAsync(employee1.CompanyId));
query = new RepositoryQuery <Employee>();
query.FieldEquals(e => e.Name, null);
result = await _employeeRepository.FindAsync(q => query);
Assert.Single(result.Documents);
query = new RepositoryQuery <Employee>();
query.FieldNotEquals(e => e.Name, null);
result = await _employeeRepository.FindAsync(q => query);
Assert.Empty(result.Documents);
}
public static IRepositoryQuery <T> Configure <T>(this RepositoryQueryDescriptor <T> configure) where T : class
{
IRepositoryQuery <T> o = new RepositoryQuery <T>();
if (configure != null)
{
o = configure(o);
}
return(o);
}
public Task <FindResults <PersistentEvent> > GetByFilterAsync(AppFilter systemFilter, string userFilter, string sort, string field, DateTime utcStart, DateTime utcEnd, CommandOptionsDescriptor <PersistentEvent> options = null)
{
IRepositoryQuery <PersistentEvent> query = new RepositoryQuery <PersistentEvent>()
.DateRange(utcStart, utcEnd, field ?? InferField(e => e.Date))
.Index(utcStart, utcEnd)
.AppFilter(systemFilter)
.FilterExpression(userFilter);
query = !String.IsNullOrEmpty(sort) ? query.SortExpression(sort) : query.SortDescending(e => e.Date);
return(FindAsync(q => query, options));
}
public static IRepositoryQuery Configure(this RepositoryQueryDescriptor configure)
{
IRepositoryQuery o = new RepositoryQuery();
if (configure != null)
{
o = configure(o);
}
return(o);
}
private async Task <bool> SendSummaryNotificationAsync(Project project, SummaryNotification data)
{
var userIds = project.NotificationSettings.Where(n => n.Value.SendDailySummary).Select(n => n.Key).ToList();
if (userIds.Count == 0)
{
_logger.Info().Project(project.Id).Message("Project \"{0}\" has no users to send summary to.", project.Name).Write();
return(false);
}
var results = await _userRepository.GetByIdsAsync(userIds, o => o.Cache()).AnyContext();
var users = results.Where(u => u.IsEmailAddressVerified && u.EmailNotificationsEnabled && u.OrganizationIds.Contains(project.OrganizationId)).ToList();
if (users.Count == 0)
{
_logger.Info().Project(project.Id).Message("Project \"{0}\" has no users to send summary to.", project.Name);
return(false);
}
// TODO: What should we do about suspended organizations.
var organization = await _organizationRepository.GetByIdAsync(project.OrganizationId, o => o.Cache()).AnyContext();
if (organization == null)
{
_logger.Info().Project(project.Id).Message("The organization \"{0}\" for project \"{1}\" may have been deleted. No summaries will be sent.", project.OrganizationId, project.Name);
return(false);
}
_logger.Info("Sending daily summary: users={0} project={1}", users.Count, project.Id);
var sf = new ExceptionlessSystemFilter(project, organization);
var systemFilter = new RepositoryQuery <PersistentEvent>().SystemFilter(sf).DateRange(data.UtcStartTime, data.UtcEndTime, (PersistentEvent e) => e.Date).Index(data.UtcStartTime, data.UtcEndTime);
var result = await _eventRepository.CountBySearchAsync(systemFilter, $"{EventIndexType.Alias.Type}:{Event.KnownTypes.Error}", "terms:(is_first_occurrence @include:true) cardinality:stack_id").AnyContext();
bool hasSubmittedEvents = result.Total > 0;
if (!hasSubmittedEvents)
{
hasSubmittedEvents = await _eventRepository.GetCountByProjectIdAsync(project.Id, true).AnyContext() > 0;
}
double newTotal = result.Aggregations.Terms <double>("terms_is_first_occurrence")?.Buckets.FirstOrDefault()?.Total ?? 0;
double uniqueTotal = result.Aggregations.Cardinality("cardinality_stack_id")?.Value ?? 0;
bool isFreePlan = organization.PlanId == BillingManager.FreePlan.Id;
foreach (var user in users)
{
_logger.Info().Project(project.Id).Message("Queueing \"{0}\" daily summary email ({1}-{2}) for user {3}.", project.Name, data.UtcStartTime, data.UtcEndTime, user.EmailAddress);
await _mailer.SendProjectDailySummaryAsync(user, project, data.UtcStartTime, hasSubmittedEvents, result.Total, uniqueTotal, newTotal, isFreePlan).AnyContext();
}
_logger.Info().Project(project.Id).Message("Done sending daily summary: users={0} project={1} events={2}", users.Count, project.Name, result.Total);
return(true);
}
public void ShouldGetEagerlyWithMultipleNestingLevels()
{
// arrange
RepositoryQuery<QueryTest> query = new RepositoryQuery<QueryTest>(m_session.Object);
// act
query.With(x => x.ChildObj.GrandchildObj).Result();
// assert
m_criteria.Verify(x => x.SetFetchMode("ChildObj.GrandchildObj", FetchMode.Eager));
m_criteria.Verify(x => x.UniqueResult<QueryTest>());
}
public void ShouldGetById()
{
// arrange
RepositoryQuery<QueryTest> query = new RepositoryQuery<QueryTest>(m_session.Object);
// act
query.ById(1).Result();
// assert
m_criteria.Verify(x => x.Add(It.IsAny<ICriterion>()));
m_criteria.Verify(x => x.UniqueResult<QueryTest>());
}
private async Task <ICollection <StackSummaryModel> > GetStackSummariesAsync(ICollection <Stack> stacks, AppFilter eventSystemFilter, TimeInfo ti)
{
if (stacks.Count == 0)
{
return(new List <StackSummaryModel>());
}
var systemFilter = new RepositoryQuery <PersistentEvent>().AppFilter(eventSystemFilter).DateRange(ti.Range.UtcStart, ti.Range.UtcEnd, (PersistentEvent e) => e.Date).Index(ti.Range.UtcStart, ti.Range.UtcEnd);
var stackTerms = await _eventRepository.CountAsync(q => q.SystemFilter(systemFilter).FilterExpression(String.Join(" OR ", stacks.Select(r => $"stack:{r.Id}"))).AggregationsExpression($"terms:(stack_id~{stacks.Count} cardinality:user sum:count~1 min:date max:date)"));
return(await GetStackSummariesAsync(stacks, stackTerms.Aggregations.Terms <string>("terms_stack_id").Buckets, eventSystemFilter, ti));
}
protected virtual IRepositoryQuery ConfigureQuery(IRepositoryQuery query)
{
if (query == null)
{
query = new RepositoryQuery <T>();
}
if (DefaultExcludes.Count > 0 && query.GetExcludes().Count == 0)
{
query.Exclude(DefaultExcludes);
}
return(query);
}
protected virtual IRepositoryQuery ConfigureQuery(IRepositoryQuery <T> query)
{
if (query == null)
{
query = new RepositoryQuery <T>();
}
if (_defaultExcludes.Count > 0 && query.GetExcludes().Count == 0)
{
query.Exclude(_defaultExcludes.Select(e => e.Value));
}
return(query);
}
public async Task BuildAsync <T>(QueryBuilderContext <T> ctx) where T : class, new()
{
var options = ctx.Options.GetElasticTypeSettings();
if (options.HasParent == false)
{
return;
}
var parentQuery = ctx.Source.GetParentQuery();
bool hasIds = ctx.Source.GetIds().Count > 0;
// even if no parent query has been set, run it through to get soft delete filter
if (options.ParentSupportsSoftDeletes && hasIds == false && parentQuery == null)
{
parentQuery = new RepositoryQuery();
}
if (parentQuery == null)
{
return;
}
var parentType = options.ChildType.GetParentIndexType();
if (parentType == null)
{
throw new ApplicationException("ParentIndexTypeName on child index type must match the name of the parent type.");
}
var parentOptions = new CommandOptions().ElasticType(parentType);
var parentContext = new QueryBuilderContext <object>(parentQuery, parentOptions, null, ctx, ContextType.Parent);
await _queryBuilder.BuildAsync(parentContext).AnyContext();
if ((parentContext.Query == null || ((IQueryContainer)parentContext.Query).IsConditionless) &&
(parentContext.Filter == null || ((IQueryContainer)parentContext.Filter).IsConditionless))
{
return;
}
ctx.Filter &= new HasParentQuery {
Type = parentType.Name,
Query = new BoolQuery {
Must = new QueryContainer[] { parentContext.Query },
Filter = new QueryContainer[] { parentContext.Filter },
}
};
}
public static IEnumerable <Model> AsEnumerable <Entity, Model>(this RepositoryQuery <Entity> query)
where Model : class
where Entity : class
{
var results = query.Get().AsEnumerable <Entity>();
var models = new List <Model>();
foreach (var result in results)
{
models.Add(Mapper.Map <Model>(result));
}
return(models);
}
public static async Task <List <Model> > ToListAsync <Entity, Model>(this RepositoryQuery <Entity> query)
where Model : class
where Entity : class
{
var results = await query.Get().ToListAsync();
var models = new List <Model>();
foreach (var result in results)
{
models.Add(Mapper.Map <Model>(result));
}
return(models);
}
public async Task <BillingPlanStats> GetBillingPlanStatsAsync()
{
var query = new RepositoryQuery <Organization>().Include(o => o.PlanId, o => o.IsSuspended, o => o.BillingPrice, o => o.BillingStatus)
.SortDescending((Organization o) => o.PlanId);
var results = (await FindAsync(query).AnyContext()).Documents;
var smallOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.SmallPlan.Id) && o.BillingPrice > 0).ToList();
var mediumOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.MediumPlan.Id) && o.BillingPrice > 0).ToList();
var largeOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.LargePlan.Id) && o.BillingPrice > 0).ToList();
decimal monthlyTotalPaid = smallOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice)
+ mediumOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice)
+ largeOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice);
var smallYearlyOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.SmallYearlyPlan.Id) && o.BillingPrice > 0).ToList();
var mediumYearlyOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.MediumYearlyPlan.Id) && o.BillingPrice > 0).ToList();
var largeYearlyOrganizations = results.Where(o => String.Equals(o.PlanId, _plans.LargeYearlyPlan.Id) && o.BillingPrice > 0).ToList();
decimal yearlyTotalPaid = smallYearlyOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice)
+ mediumYearlyOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice)
+ largeYearlyOrganizations.Where(o => !o.IsSuspended && o.BillingStatus == BillingStatus.Active).Sum(o => o.BillingPrice);
return(new BillingPlanStats {
SmallTotal = smallOrganizations.Count,
SmallYearlyTotal = smallYearlyOrganizations.Count,
MediumTotal = mediumOrganizations.Count,
MediumYearlyTotal = mediumYearlyOrganizations.Count,
LargeTotal = largeOrganizations.Count,
LargeYearlyTotal = largeYearlyOrganizations.Count,
MonthlyTotal = monthlyTotalPaid + (yearlyTotalPaid / 12),
YearlyTotal = (monthlyTotalPaid * 12) + yearlyTotalPaid,
MonthlyTotalAccounts = smallOrganizations.Count + mediumOrganizations.Count + largeOrganizations.Count,
YearlyTotalAccounts = smallYearlyOrganizations.Count + mediumYearlyOrganizations.Count + largeYearlyOrganizations.Count,
FreeAccounts = results.Count(o => String.Equals(o.PlanId, _plans.FreePlan.Id)),
PaidAccounts = results.Count(o => !String.Equals(o.PlanId, _plans.FreePlan.Id) && o.BillingPrice > 0),
FreeloaderAccounts = results.Count(o => !String.Equals(o.PlanId, _plans.FreePlan.Id) && o.BillingPrice <= 0),
SuspendedAccounts = results.Count(o => o.IsSuspended),
});
}
public IRepositoryQuery <EmployeeDTO> Get()
{
RepositoryQuery <EmployeeDTO> piEmployee = _employeeRepository
.Query()
.Include(c => c.Photo, c => c.StandPhoto, c => c.Address, c => c.ContactPerson,
c => c.ContactPerson.Address)
.Include(c => c.Education, c => c.Experience, c => c.Hawala, c => c.InsuranceProcess,
c => c.RequiredDocuments)
.Include(c => c.Agency, c => c.Agent)
.Filter(a => !string.IsNullOrEmpty(a.FirstName))
.OrderBy(q => q.OrderByDescending(c => c.Id));
if (_includeChilds)
{
piEmployee = piEmployee.Include(
c => c.CurrentComplain, c => c.CurrentComplain.Remarks, c => c.Complains,
c => c.Visa, c => c.Visa.Condition,
c => c.Visa.Sponsor, c => c.Visa.Sponsor.Address,
c => c.LabourProcess, c => c.EmbassyProcess, c => c.FlightProcess,
c => c.Visa.Agent, c => c.Visa.Agent.Address);
}
return(piEmployee);
}
public static RepositoryQuery All(this IOrganizationService service, string entityname)
{
var rq = new RepositoryQuery(service, entityname);
return rq;
}
