protected override bool InternalExecute(ProcessExecutingContext context) { var schema = UserConnection.EntitySchemaManager.FindItemByUId(EntitySchemaId); var schemaUId = (schema != null) ? schema.UId : ((Select) new Select(UserConnection).Column("UId").From("SysSchema").Where("Id").IsEqual(Column.Parameter(EntitySchemaId))) .ExecuteScalar <Guid>(); var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysProcessLog"); esq.AddColumn(esq.RootSchema.PrimaryColumn.Name); esq.RowCount = 1; var filters = new EntitySchemaQueryFilterCollection(esq); var entitySchemaFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "[SysProcessEntity:SysProcess].EntitySchemaUId", schemaUId); filters.Add(entitySchemaFilter); var entityFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "[SysProcessEntity:SysProcess].EntityId", RecordId); filters.Add(entityFilter); var processFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "[SysSchema:Id:SysSchema].UId", Owner.SchemaUId); filters.Add(processFilter); if (ProcessStatusId != Guid.Empty) { var processStatusFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Status", ProcessStatusId); filters.Add(processStatusFilter); } filters.LogicalOperation = LogicalOperationStrict.And; esq.Filters.Add(filters); var rows = esq.GetEntityCollection(UserConnection); Result = rows.Count > 0; return(true); }
private EntitySchemaQueryFilterCollection GetEsqSummaryGroupFilter(FilterConfig filterConfig, EntitySchemaColumn referenceColumn, EntitySchemaQuery esq) { string referenceSchemaGroupColumnName = $"{referenceColumn.Name}.{filterConfig.GroupColumnPath}"; _groupColumn = esq.AddColumn(referenceSchemaGroupColumnName); var records = filterConfig.RecordIds?.ToList() ?? new List <Guid>(); var recordsGroup = new EntitySchemaQueryFilterCollection(esq); var filterGroup = new EntitySchemaQueryFilterCollection(esq); recordsGroup.LogicalOperation = LogicalOperationStrict.Or; filterGroup.LogicalOperation = LogicalOperationStrict.And; if (records.Contains(Guid.Empty)) { records.Remove(Guid.Empty); recordsGroup.Add(esq.CreateIsNullFilter(referenceSchemaGroupColumnName)); } if (records.IsNotEmpty()) { recordsGroup.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, referenceSchemaGroupColumnName, records.Cast <object>().ToArray())); } filterGroup.Add(recordsGroup); AddHierarchyFilter(filterConfig, referenceColumn, esq); return(recordsGroup); }
private DayInCalendar GetCalendarDayInner(IEnumerable <Guid> calendarIds, DateTime date, IEnumerable <Guid> ignoredIds) { object[] calendarsIdObjects = calendarIds.Select(id => (object)id).ToArray(); var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "DayInCalendar"); esq = AddAllDayInCalendarColumns(esq); esq.RowCount = 1; esq.AddColumn("Calendar.Depth").OrderByDesc(0); esq.AddColumn("Date").OrderByDesc(1); esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Calendar", calendarsIdObjects)); esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "DayOfWeek.Number", GetDayOfWeekNumber(date))); var dateFilterCollection = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); dateFilterCollection.Add(esq.CreateFilterWithParameters(FilterComparisonType.IsNull, "Date")); dateFilterCollection.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Date", date.Date)); esq.Filters.Add(dateFilterCollection); if (ignoredIds != null && ignoredIds.Any()) { esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.NotEqual, "Id", ignoredIds.Select(i => (object)i))); } return((DayInCalendar)esq.GetEntityCollection(UserConnection).SingleOrDefault()); }
/// <summary> /// Returns query for the queue object schema. /// </summary> /// <returns>Instance of the type <see cref="EntitySchemaQuery"/> type.</returns> protected virtual EntitySchemaQuery GetQueueEntitySchemaQuery() { var esq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "Queue") { UseAdminRights = false, CanReadUncommitedData = true, IgnoreDisplayValues = true }; esq.PrimaryQueryColumn.IsAlwaysSelect = true; esq.AddColumn("Name"); EntitySchemaQueryColumn frequency = esq.AddColumn("[QueueUpdateFrequency:Id:QueueUpdateFrequency].Frequency"); frequency.Name = "Frequency"; esq.AddColumn("FilterEditData"); EntitySchemaQueryFilterCollection esqFilters = esq.Filters; IEntitySchemaQueryFilterItem isManuallyFillingFilterItem = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "IsManuallyFilling", false); esqFilters.Add(isManuallyFillingFilterItem); IEntitySchemaQueryFilterItem statusIsInitialFilterItem = esq.CreateFilterWithParameters(FilterComparisonType.NotEqual, "Status.IsInitial", true); esqFilters.Add(statusIsInitialFilterItem); IEntitySchemaQueryFilterItem statusIsFinalFilterItem = esq.CreateFilterWithParameters(FilterComparisonType.NotEqual, "Status.IsFinal", true); esqFilters.Add(statusIsFinalFilterItem); return(esq); }
public int GetContactIdByName(string code) { var result = -1; var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "UsrPeriodicalPublication") { PrimaryQueryColumn = { IsAlwaysSelect = true } }; var esqFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "UsrCodeString", code); esq.Filters.Add(esqFilter); var entities = esq.GetEntityCollection(UserConnection); if (entities.Count > 0) { var esqIs = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "UsrIssuesEdition"); esqIs.AddColumn("Id"); var id = entities.First().PrimaryColumnValue; var subQueryFilter1 = new EntitySchemaQueryFilterCollection(esqIs, LogicalOperationStrict.And); subQueryFilter1.Add(esqIs.CreateFilterWithParameters(FilterComparisonType.Equal, "UsrCodeColumn", id)); subQueryFilter1.Add(esqIs.CreateFilterWithParameters(FilterComparisonType.Equal, "UsrReleaseStatus", UsrPublicationConstants.InProgress)); esqIs.Filters.Add(subQueryFilter1); var entitiesIs = esqIs.GetEntityCollection(UserConnection); return(entitiesIs.Count); } return(result); }
protected virtual IEnumerable <Entity> GetServiceObjects() { var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "ServiceObject"); esq.AddAllSchemaColumns(); IEntitySchemaQueryFilterItem isActiveFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "ServicePact.Status.IsActive", true); IEntitySchemaQueryFilterItem notExpiredFilter = esq.CreateFilterWithParameters( FilterComparisonType.GreaterOrEqual, "ServicePact.EndDate", UserConnection.CurrentUser.GetCurrentDateTime()); var relationFilterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); if (_request.ContactId != Guid.Empty) { relationFilterGroup.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And) { esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Contact", _request.ContactId), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Type", ServiceObjectConstants.ContactTypeId) }); } if (_request.AccountId != Guid.Empty) { relationFilterGroup.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And) { esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Account", _request.AccountId), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Type", ServiceObjectConstants.AccountTypeId) }); } if (_contact != null && _contact.AccountId != Guid.Empty) { relationFilterGroup.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And) { esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Account", _contact.AccountId), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Type", ServiceObjectConstants.AccountTypeId) }); } if (_contact != null && _contact.AccountId != Guid.Empty && _contact.DepartmentId != Guid.Empty) { relationFilterGroup.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And) { esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Department", _contact.DepartmentId), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Account", _contact.AccountId), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Type", ServiceObjectConstants.DepartmentTypeId) }); } esq.Filters.Add(isActiveFilter); esq.Filters.Add(notExpiredFilter); esq.Filters.Add(relationFilterGroup); return(esq.GetEntityCollection(UserConnection)); }
/// <summary> /// ########## ####### ###### ## ####### #######. /// </summary> /// <param name="request">######, ######## ######### #########.</param> /// <returns>####### ###### ## ####### #######.</returns> public virtual SocialAccount FindSocialAccount(SocialNetworkServiceRequest request) { Log.Debug("FindSocialAccount"); EntitySchema socialAccountSchema = UserConnection.EntitySchemaManager.GetInstanceByName("SocialAccount"); EntitySchemaQuery esq = new EntitySchemaQuery(socialAccountSchema); esq.PrimaryQueryColumn.IsAlwaysSelect = true; esq.AddColumn("AccessToken"); esq.AddColumn("ConsumerKey"); esq.AddColumn("Login"); esq.AddColumn("Name"); esq.AddColumn("Public").OrderByAsc(); esq.AddColumn("SocialId"); esq.AddColumn("Type"); esq.AddColumn("User"); EntitySchemaQueryFilterCollection filters = esq.Filters; filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Type", request.Type)); filters.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or, esq.CreateFilterWithParameters(FilterComparisonType.Equal, "User", request.User), esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Public", true))); // esq.Cache = UserConnection.WorkspaceCache.WithLocalCaching // esq.CacheItemName EntityCollection socialAccounts = esq.GetEntityCollection(UserConnection); foreach (SocialAccount socialAccount in socialAccounts) { return(socialAccount); } return(null); }
protected virtual void AddFilters(EntitySchemaQuery esq, IEnumerable <Guid> periodIds) { esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, SheetColumnName, ForecastSheet.Id)); var filterGroup = new EntitySchemaQueryFilterCollection(esq); filterGroup.LogicalOperation = LogicalOperationStrict.Or; filterGroup.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, PeriodColumnName, periodIds.Cast <object>())); filterGroup.Add(esq.CreateIsNullFilter(PeriodColumnName)); esq.Filters.Add(filterGroup); }
protected virtual void AddColumnFilters(EntitySchemaQuery esq, IEnumerable <Guid> columnIds) { if (columnIds.IsNullOrEmpty()) { return; } var filterGroup = new EntitySchemaQueryFilterCollection(esq); filterGroup.LogicalOperation = LogicalOperationStrict.Or; filterGroup.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, ForecastColumnName, columnIds.Cast <object>())); filterGroup.Add(esq.CreateIsNullFilter(ForecastColumnName)); esq.Filters.Add(filterGroup); }
/// <summary> /// <see cref="IRuleRelationModel.GetEntityRelation(MatchCollection, UserConnection)"/> /// </summary> public virtual IEnumerable <Guid> GetEntityRelation(MatchCollection matchCollection, UserConnection userConnection) { List <Guid> result = new List <Guid>(); if (matchCollection.Count == 0) { return(result); } EntitySchema schema = userConnection.EntitySchemaManager.GetInstanceByUId(EntitySchemaSearchUId); EntitySchemaColumn searchColumnName = schema.Columns.GetByUId(EntitySchemaSearchColumnUId); EntitySchemaQuery esq = new EntitySchemaQuery(userConnection.EntitySchemaManager, schema.Name); esq.PrimaryQueryColumn.IsAlwaysSelect = true; var filterGroupNumber = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); foreach (var item in matchCollection) { filterGroupNumber.Add(esq.CreateFilterWithParameters( FilterComparisonType.Equal, searchColumnName.Name, item.ToString() )); } esq.Filters.Add(filterGroupNumber); var entityCollection = esq.GetEntityCollection(userConnection); foreach (var item in entityCollection) { result.Add(item.GetTypedColumnValue <Guid>(esq.PrimaryQueryColumn.Name)); } return(result); }
/// <summary> /// Gets the filters to search contacts by phone numbers. /// </summary> /// <param name="esq">The entity schema query that searches for contact communication.</param> /// <param name="phones">The phone numbers.</param> /// <returns>The group of filters, that filters contact communications by the given phone numbers.</returns> public EntitySchemaQueryFilterCollection GetSearchContactFilters(EntitySchemaQuery esq, List <string> phones) { if (phones == null || !phones.Any()) { return(null); } IEnumerable <string> validPhones = phones .Select(PreprocessPhone) .Where(StringUtilities.IsNotNullOrWhiteSpace) .ToList(); if (!validPhones.Any()) { return(null); } var filterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); foreach (string number in validPhones) { FilterComparisonType comparisonType = number.Length <= _internalNumberLength ? FilterComparisonType.Equal : FilterComparisonType.StartWith; filterGroup.Add(esq.CreateFilterWithParameters(comparisonType, "[ContactCommunication:Contact:Id].SearchNumber", number)); } return(filterGroup); }
private EntityCollection GetEntitiesCollectionByContactList(IEnumerable <Guid> contacts, EntitySchema entitySchema, CmpgnUpdObjElEntity entitySettings, out string contactColumnAlias) { var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, EntityName) { UseAdminRights = false, IgnoreDisplayValues = GlobalAppSettings.FeatureIgnoreDisplayValuesInDataUserTasks }; esq.AddAllSchemaColumns(); var contactColumnName = entitySettings.ContactColumnPath; if (string.IsNullOrEmpty(contactColumnName)) { contactColumnAlias = null; return(default(EntityCollection)); } if (!esq.Columns.Any(x => x.Name == contactColumnName)) { contactColumnAlias = esq.AddColumn(contactColumnName).Name; } else { contactColumnAlias = contactColumnName; } var filterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); foreach (var contactId in contacts) { var filter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, contactColumnName, contactId); filterGroup.Add(filter); } esq.Filters.Add(filterGroup); return(esq.GetEntityCollection(UserConnection)); }
private void AddContactsDynamicGroupFilters( IDictionary <string, Guid> localFolderUIds, UserConnection userConnection, EntitySchemaQueryFilterCollection filters) { if (!localFolderUIds.Any()) { return; } EntitySchemaManager entitySchemaManager = userConnection.EntitySchemaManager; var foldersEsq = new EntitySchemaQuery(entitySchemaManager, "ContactFolder"); string searchDataColumnName = foldersEsq.AddColumn("SearchData").Name; string[] folderIdsStrArray = (from folderId in localFolderUIds.Values select folderId.ToString()).ToArray(); foldersEsq.Filters.Add(foldersEsq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Id", folderIdsStrArray)); EntityCollection folderEntities = foldersEsq.GetEntityCollection(userConnection); foreach (Entity folderEntity in folderEntities) { byte[] data = folderEntity.GetBytesValue(searchDataColumnName); string serializedFilters = Encoding.UTF8.GetString(data, 0, data.Length); EntitySchema entitySchema = entitySchemaManager.GetInstanceByName("Contact"); var dataSourceFilters = Json.Deserialize <Terrasoft.Nui.ServiceModel.DataContract.Filters>(serializedFilters); IEntitySchemaQueryFilterItem esqFilters = dataSourceFilters.BuildEsqFilter(entitySchema.UId, userConnection); if (esqFilters != null) { filters.Add(esqFilters); } } }
/// <summary> /// Get collection of entities using provided filters. /// </summary> /// <param name="sourceEntityName">Name of entity for loading.</param> /// <param name="columnList">List of columns to be loaded.</param> /// <param name="filterCollection">Dictionary, containing column name as a key and value for filtering as a value.</param> /// <returns><see cref="EntityCollection"/>.</returns> public virtual EntityCollection GetItems(string sourceEntityName, IEnumerable <string> columnList, EntityCollectionMappingHandlerFilterGroup filterCollection = null) { var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, sourceEntityName); esq.PrimaryQueryColumn.IsAlwaysSelect = true; foreach (var columnName in columnList) { var name = esq.AddColumn(columnName); } if (filterCollection != null) { var filterGroup = new EntitySchemaQueryFilterCollection(esq, filterCollection.LogicalOperation); foreach (var filterItem in filterCollection.Filters) { var innerFilterGroup = new EntitySchemaQueryFilterCollection(esq, filterItem.LogicalOperation); foreach (var filterItemValue in filterItem.Values) { var filterComparisonType = filterItem.ComparisonType; if (filterItemValue == null) { filterComparisonType = FilterComparisonType.IsNull; } innerFilterGroup.Add(esq.CreateFilterWithParameters(filterComparisonType, filterItem.ColumnPath, filterItemValue)); } filterGroup.Add(innerFilterGroup); } esq.Filters.Add(filterGroup); } return(esq.GetEntityCollection(UserConnection)); }
private void FindImportEntityDuplicate(EntitySchemaQuery esq, List <Entity> entities, ImportParameters parameters, IEnumerable <ImportColumn> keyColumns, Func <ColumnExpression, object> columnValueAction) { var mainFilterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); esq.Filters.Add(mainFilterGroup); var importColumns = keyColumns.ToList(); var keyColumnsCount = importColumns.Count(); foreach (var importEntity in parameters.Entities) { var columnsExpressions = GetKeyColumnsValues(parameters, importEntity, importColumns); if (!columnsExpressions.Any()) { continue; } var filters = GetKeyColumnsFilters(esq, columnsExpressions, columnValueAction); mainFilterGroup.Add(filters); var parametersCount = mainFilterGroup.Count * keyColumnsCount; if (parametersCount >= MaxQueryParametersCount) { AddEntitiesRange(esq, entities); esq.ResetSelectQuery(); mainFilterGroup.Clear(); } } if (mainFilterGroup.Any()) { AddEntitiesRange(esq, entities); } }
private static Dictionary <Guid, ModuleData> GetSysModuleEntities() { var list = new Dictionary <Guid, ModuleData>(); var sysModuleESQ = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysModule"); sysModuleESQ.PrimaryQueryColumn.IsAlwaysSelect = true; var schemaUIdColumnName = sysModuleESQ.AddColumn("SysModuleEntity.SysEntitySchemaUId").Name; sysModuleESQ.AddColumn("CardSchemaUId"); sysModuleESQ.AddColumn("SectionSchemaUId"); sysModuleESQ.AddColumn("Caption"); var folderModeCodeColumnName = sysModuleESQ.AddColumn("FolderMode.Code").Name; var orFilterCollection = new EntitySchemaQueryFilterCollection(sysModuleESQ, LogicalOperationStrict.Or); orFilterCollection.Add(sysModuleESQ.CreateIsNotNullFilter("CardSchemaUId")); orFilterCollection.Add(sysModuleESQ.CreateIsNotNullFilter("SectionSchemaUId")); sysModuleESQ.Filters.Add(orFilterCollection); var entityCollection = sysModuleESQ.GetEntityCollection(UserConnection); foreach (var entity in entityCollection) { var module = new ModuleData(); var schemaUId = entity.GetTypedColumnValue <Guid>(schemaUIdColumnName); var cardSchemaUId = entity.GetTypedColumnValue <Guid>("CardSchemaUId"); var sectionSchemaUId = entity.GetTypedColumnValue <Guid>("SectionSchemaUId"); var folderModeCode = entity.GetTypedColumnValue <string>(folderModeCodeColumnName); module.ModuleCaption = entity.GetTypedColumnValue <string>("Caption"); if (cardSchemaUId != null && cardSchemaUId != Guid.Empty) { module.CommandsList.Add("create"); } if (sectionSchemaUId != null && sectionSchemaUId != Guid.Empty) { module.CommandsList.Add("goto"); module.CommandsList.Add("search"); } if (folderModeCode != "None") { module.HasFolder = true; } if (!list.ContainsKey(schemaUId)) { list.Add(schemaUId, module); } } return(list); }
/// <summary> /// <see cref="IRuleRelationModel.GetEntityRelation(MatchCollection, UserConnection)"/> /// </summary> public override IEnumerable <Guid> GetEntityRelation(MatchCollection matchCollection, UserConnection userConnection) { EntitySchemaQuery esq = new EntitySchemaQuery(userConnection.EntitySchemaManager, _schemaName); esq.AddColumn(_communicationTypeColumnPath); esq.AddColumn(_numberColumnPath); var idColumn = esq.PrimaryQueryColumn.IsAlwaysSelect = true; esq.Filters.Add(esq.CreateFilterWithParameters( FilterComparisonType.Equal, _communicationTypeColumnPath, Terrasoft.Configuration.CommunicationTypeConsts.EmailId )); var filterGroupType = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); filterGroupType.Add(esq.CreateFilterWithParameters( FilterComparisonType.NotEqual, "Type", _typeFilter )); filterGroupType.Add(esq.CreateFilterWithParameters( FilterComparisonType.IsNull, "Type" )); esq.Filters.Add(filterGroupType); var filterGroupNumber = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); foreach (var item in matchCollection) { filterGroupNumber.Add(esq.CreateFilterWithParameters( FilterComparisonType.Equal, _numberColumnPath, item.ToString() )); } esq.Filters.Add(filterGroupNumber); if (_schemaName == "Contact") { AddContactByUserFilter(esq, userConnection); } var entityCollection = esq.GetEntityCollection(userConnection); return(entityCollection.Select(item => item.GetTypedColumnValue <Guid>(esq.PrimaryQueryColumn.Name)).ToList()); }
private void ApplyCreatedByOrIsSharedFilter(EntitySchemaQuery esq) { var fullFilterCollection = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); fullFilterCollection.Add(esq.CreateFilterWithParameters( FilterComparisonType.Equal, "CreatedBy", UserConnection.CurrentUser.ContactId )); fullFilterCollection.Add( esq.CreateFilterWithParameters( FilterComparisonType.Equal, "IsShared", true ) ); esq.Filters.Add(fullFilterCollection); }
/// <summary> /// Add filter by user subscription feed. /// </summary> /// <param name="messageQuery">Instance <see cref="EntitySchemaQuery" /></param> /// <param name="readOptions">Reading options <see cref="EsnReadMessageOptions" />.</param> protected virtual void AddFeedFilter(EntitySchemaQuery messageQuery, EsnReadMessageOptions readOptions) { messageQuery.Filters.Add(messageQuery.CreateIsNullFilter("Parent")); if (readOptions.OffsetDate != default(DateTime)) { messageQuery.Filters.Add( messageQuery.CreateFilterWithParameters( FilterComparisonType.Less, GetSortedColumnName(readOptions.SortedBy), readOptions.OffsetDate )); } var feedFilter = new EntitySchemaQueryFilterCollection(messageQuery); var subscriptionFilter = new EntitySchemaQueryFilterCollection(messageQuery); subscriptionFilter.LogicalOperation = LogicalOperationStrict.Or; var userId = UserConnection.CurrentUser.Id; subscriptionFilter.Add( messageQuery.CreateFilterWithParameters( FilterComparisonType.Equal, "[SocialSubscription:EntityId:EntityId].[SysUserInRole:SysRole:SysAdminUnit].SysUser", userId )); subscriptionFilter.Add( messageQuery.CreateFilterWithParameters( FilterComparisonType.Equal, "[SocialSubscription:EntityId:EntityId].SysAdminUnit", userId )); feedFilter.Add(subscriptionFilter); var unsubscriptionFilter = new EntitySchemaQueryFilterCollection(messageQuery); unsubscriptionFilter.IsNot = true; unsubscriptionFilter.Add( messageQuery.CreateFilterWithParameters( FilterComparisonType.Equal, "[SocialUnsubscription:EntityId:EntityId].SysAdminUnit", userId )); feedFilter.Add(unsubscriptionFilter); messageQuery.Filters.Add(feedFilter); }
/// <summary> /// Returns allowed activity results. /// </summary> /// <param name="userConnection">User connection.</param> /// <param name="activityId">ID of the activity.</param> /// <returns>Allowed values of the activity result.</returns> public static string GetAllowedActivityResults(UserConnection userConnection, Guid activityId) { var select = (Select) new Select(userConnection) .Column("AllowedResult") .From("Activity") .Where("Id").IsEqual(Column.Parameter(activityId)); var allowedResult = select.ExecuteScalar <string>(); if (string.IsNullOrEmpty(allowedResult)) { return("[]"); } EntitySchemaManager entitySchemaManager = userConnection.EntitySchemaManager; EntitySchema entitySchema = entitySchemaManager.GetInstanceByName("ActivityResult"); var esq = new EntitySchemaQuery(entitySchemaManager, entitySchema.Name) { UseAdminRights = false }; esq.PrimaryQueryColumn.IsAlwaysSelect = true; string columnName = entitySchema.GetPrimaryDisplayColumnName(); esq.AddColumn(columnName); esq.AddColumn("Category"); EntitySchemaQueryFilterCollection filters = esq.Filters; var allowedResultIds = ServiceStackTextHelper.Deserialize <string[]>(allowedResult); var columnParameters = new object[allowedResultIds.Length]; for (int i = 0; i < allowedResultIds.Length; i++) { var resultId = new Guid(allowedResultIds[i]); columnParameters[i] = resultId; } filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Id", columnParameters)); EntityCollection entityCollection = esq.GetEntityCollection(userConnection); bool isFirstItem = true; var sb = new StringBuilder("["); foreach (Entity entity in entityCollection) { if (!isFirstItem) { sb.Append(","); } else { isFirstItem = false; } sb.AppendFormat("{{\"resultId\":\"{0}\",\"caption\":\"{1}\",\"categoryId\":\"{2}\"}}", entity.GetTypedColumnValue <Guid>("Id"), entity.GetTypedColumnValue <string>(columnName), entity.GetTypedColumnValue <Guid>("CategoryId")); } sb.Append("]"); return(sb.ToString()); }
/// <summary> /// Adds esq detail phone filter. /// </summary> /// <param name="esq"><see cref="EntitySchemaQuery"/> esq.</param> /// <param name="filterComparisonType"><see cref="FilterComparisonType"/> filterComparisonType.</param> private void ApplyDetailPhoneFilter(EntitySchemaQuery esq, FilterComparisonType filterComparisonType) { EntitySchemaQueryFilterCollection esqFilters = new EntitySchemaQueryFilterCollection(esq); Guid phoneTypeId = new Guid(CommunicationTypeConsts.CommunicationPhoneId); Guid smsTypeId = new Guid(CommunicationTypeConsts.CommunicationSmsId); esqFilters.Add(esq.CreateFilterWithParameters(filterComparisonType, "[ComTypebyCommunication:CommunicationType:CommunicationType].[Communication:Id:Communication].Id", phoneTypeId, smsTypeId)); esq.Filters.Add(esqFilters); }
/// <summary> /// Creates child entity filters. /// </summary> /// <param name="esq">Entity schema query.</param> /// <param name="importEntity">Import entity.</param> /// <param name="destination">Import column destination.</param> /// <param name="valueForSave">Value for save.</param> /// <returns>Child entity filters.</returns> private EntitySchemaQueryFilterCollection CreateChildEntityFilters(EntitySchemaQuery esq, ImportEntity importEntity, Dictionary <string, object> keyColumnsValues) { EntitySchemaQueryFilterCollection filters = new EntitySchemaQueryFilterCollection(esq); foreach (KeyValuePair <string, object> keyColumnValue in keyColumnsValues) { IEntitySchemaQueryFilterItem filterItem = esq.CreateFilterWithParameters(FilterComparisonType.Equal, keyColumnValue.Key, keyColumnValue.Value); filters.Add(filterItem); } return(filters); }
private void AddExportFiltersBySettings(SyncContext context, EntitySchemaQuery esq) { UserConnection userConnection = context.UserConnection; esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "CreatedBy", userConnection.CurrentUser.ContactId)); if (UserSettings.ExportContactsAll) { return; } var contactTypeFilters = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); if (UserSettings.ExportContactsEmployers) { contactTypeFilters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Type", ExchangeConsts.ContactEmployeeTypeId)); } if (UserSettings.ExportContactsCustomers) { contactTypeFilters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Type", ExchangeConsts.ContactCustomerTypeId)); } if (UserSettings.ExportContactsOwner) { contactTypeFilters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, "Owner", userConnection.CurrentUser.ContactId)); } if (UserSettings.ExportContactsFromGroups) { AddContactsDynamicGroupFilters(UserSettings.LocalFolderUIds, userConnection, contactTypeFilters); } if (!contactTypeFilters.Any()) { esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, false, esq.RootSchema.PrimaryColumn.Name, Guid.Empty)); return; } esq.Filters.Add(contactTypeFilters); }
/// <summary> /// Retuns query object to the scheme. /// </summary> /// <param name="schemaName">Schema name of entity.</param> /// <param name="columnsName">Collection of column names.</param> /// <returns>Query object to the scheme.</returns> private EntitySchemaQuery GetEntitySchemaQuery(string schemaName, List <string> columnsName) { var query = new EntitySchemaQuery(_userConnection.EntitySchemaManager, schemaName); query.UseAdminRights = _useAdminRights; var filtersGroup = new EntitySchemaQueryFilterCollection(query, LogicalOperationStrict.Or); foreach (string columnName in columnsName) { filtersGroup.Add(query.CreateFilterWithParameters(FilterComparisonType.Equal, columnName, RecordId)); } query.Filters.Add(filtersGroup); return(query); }
/// <summary> /// Recursively applies filters to ESQ. /// </summary> private static void ApplyFilters( EntitySchemaQuery esq, EntitySchemaQueryFilterCollection rootFilter, QueryFilterCollection filters) { rootFilter.IsNot = filters.Negative; // apply filters foreach (var filter in filters.Filters) { rootFilter.Add(ConvertFilter(esq, filter)); } // recursively apply nested filters foreach (var filterCollection in filters.ChildFilters) { var group = new EntitySchemaQueryFilterCollection(esq, filterCollection.LogicalOperation); ApplyFilters(esq, group, filterCollection); rootFilter.Add(group); } }
/// <summary> /// Applies and return entity schema query modifiedOn filter collection. /// </summary> /// <param name="esq"><see cref="EntitySchemaQuery"/> esq.</param> /// <returns><see cref="EntitySchemaQueryFilterCollection"/> entity schema query modifiedOn filter collection.</returns> protected override EntitySchemaQueryFilterCollection ApplyModifiedOnFilters(EntitySchemaQuery esq) { EntitySchemaQueryFilterCollection esqFilters = base.ApplyModifiedOnFilters(esq); string parentSchemaName = GetParentSchemaName(esq.RootSchema); var parentSchema = _userConnection.EntitySchemaManager.FindInstanceByName(parentSchemaName); var modifiedOnColumn = parentSchema.ModifiedOnColumn; if (modifiedOnColumn != null) { string modifiedOnColumnPath = string.Format("{0}.{1}", parentSchemaName, modifiedOnColumn.Name); esqFilters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Between, modifiedOnColumnPath, _fromSqlDateTimeMacro, _toSqlDateTimeMacro)); } return(esqFilters); }
/// <summary> /// Set filters for select query. /// </summary> protected virtual void SetFiltersByDate(EntitySchemaQuery esq, DateTime startDate, DateTime endDate) { var dateFilterGroup = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.Or); for (var date = startDate.Date; date.Date <= endDate.Date; date = date.AddDays(1)) { dateFilterGroup.Add(new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And) { esq.CreateFilter(FilterComparisonType.Equal, EntityDateColumn.Name, EntitySchemaQueryMacrosType.Month, date.Month), esq.CreateFilter(FilterComparisonType.Equal, EntityDateColumn.Name, EntitySchemaQueryMacrosType.DayOfMonth, date.Day) }); } esq.Filters.Add(dateFilterGroup); }
/// <summary> /// Gets key columns filters. /// </summary> /// <param name="esq">Entity schema query.</param> /// <param name="columnsExpressions">Columns keyColumnExpressions.</param> /// <param name="columnValueAction">Column value action.</param> /// <returns>Key columns filters.</returns> private EntitySchemaQueryFilterCollection GetKeyColumnsFilters(EntitySchemaQuery esq, List <ColumnExpression> columnsExpressions, Func <ColumnExpression, object> columnValueAction) { var filters = new EntitySchemaQueryFilterCollection(esq); foreach (var columnExpression in columnsExpressions) { var keyColumnFilter = esq.CreateFilterWithParameters( columnExpression.ComparisonType, columnExpression.ColumnValueName, columnValueAction(columnExpression)); filters.Add(keyColumnFilter); } return(filters); }
private static EntitySchemaQueryFilterCollection GetAccountCommunicationTypeFilter(EntitySchemaQuery entitySchemaQuery, Guid rootMacrosId) { var result = new EntitySchemaQueryFilterCollection( entitySchemaQuery, LogicalOperationStrict.Or); foreach (var commTypeId in GetAccountCommunicationTypeListByNodeId(rootMacrosId)) { var filter = entitySchemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal, "CommunicationType.Id", commTypeId); result.Add(filter); } return(result); }
public SmtpSettings LoadSettingsByEmail(string email) { var mailAddress = new MailAddress(email); var esq = new EntitySchemaQuery(_userConnection.EntitySchemaManager, "MailboxSyncSettings"); esq.AddColumn("UserName"); esq.AddColumn("UserPassword"); esq.AddColumn("MailServer.SMTPServerAddress"); esq.AddColumn("MailServer.SMTPPort"); esq.AddColumn("MailServer.UseSSLforSending"); esq.AddColumn("MailServer.SMTPServerTimeout"); var listFilter = new EntitySchemaQueryFilterCollection(esq, LogicalOperationStrict.And); listFilter.Add(esq.CreateFilterWithParameters(FilterComparisonType.Contain, "UserName", mailAddress.User)); listFilter.Add(esq.CreateFilterWithParameters(FilterComparisonType.Contain, "MailServer.SMTPServerAddress", mailAddress.Host)); esq.Filters.Add(listFilter); var col = esq.GetEntityCollection(_userConnection); if (col.Count == 0) { return(null); } var entity = col[0]; var result = new SmtpSettings { Host = entity.GetTypedColumnValue <string>("MailServer_SMTPServerAddress"), Port = entity.GetTypedColumnValue <int>("MailServer_SMTPPort"), UserName = entity.GetTypedColumnValue <string>("UserName"), UserPassword = entity.GetTypedColumnValue <string>("UserPassword"), UseSSL = entity.GetTypedColumnValue <bool>("MailServer_UseSSLforSending"), ServerTimeout = entity.GetTypedColumnValue <int>("MailServer_SMTPServerTimeout") }; return(result); }