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); } } }
private void ApplyDateOffset(IEntitySchemaQueryFilterItem filterCollection) { var queryFilterCollection = filterCollection as EntitySchemaQueryFilterCollection; if (queryFilterCollection.Count == 0) { return; } int dateOffset = 0; DateTime serverDate = GetServerDateTime(); double todayMinutesPassed = serverDate.TimeOfDay.TotalMinutes; if (todayMinutesPassed < -TimeZoneOffset) { dateOffset = -1; } else if ((todayMinutesPassed + TimeZoneOffset) > MinutesInDay) { dateOffset = 1; } else { return; } var currentDate = serverDate.Date.AddDays(dateOffset); ApplyDateOffsetForDateMacrosFilters(currentDate, queryFilterCollection); }
internal Tuple <DataTable, string> GetContactsWithMinutesEsq(Guid ContactId) { const string tableName = "Activity"; EntitySchemaQuery esqResult = new EntitySchemaQuery(UserConnection.EntitySchemaManager, tableName); esqResult.AddColumn("Owner.Id"); esqResult.AddColumn("Owner.Name"); var durationInMinutes = esqResult.CreateAggregationFunction(AggregationTypeStrict.Sum, "DurationInMinutes"); durationInMinutes.Name = "DurationInMinutes"; esqResult.AddColumn(durationInMinutes); IEntitySchemaQueryFilterItem filterByContactId = esqResult.CreateFilterWithParameters(FilterComparisonType.Equal, "Owner.Id", ContactId); esqResult.Filters.Add(filterByContactId); Select select = esqResult.GetSelectQuery(UserConnection); select.BuildParametersAsValue = true; var entities = esqResult.GetEntityCollection(UserConnection); return(new Tuple <DataTable, string>(entities.ConvertToDataTable(), select.GetSqlText())); }
private IEnumerable <IReadOnlyDictionary <string, object> > GetContactAnniversaryData( UserConnection userConnection, Guid entitySchemaUId, IEntitySchemaQueryFilterItem filter) { var entitySchema = userConnection.EntitySchemaManager.GetInstanceByUId(entitySchemaUId); EntitySchemaQuery query = new EntitySchemaQuery(entitySchema); var dateColumn = query.AddColumn("Date"); var contactColumn = query.AddColumn("Contact"); var typeColumn = query.AddColumn("AnniversaryType"); var subQueryExpression = query.CreateSubEntitySchemaExpression("Contact.Id"); subQueryExpression.SubQuery.Filters.Add(filter); var subFilter = new EntitySchemaQueryFilter(FilterComparisonType.Exists); subFilter.RightExpressions.Add(subQueryExpression); query.Filters.Add(subFilter); EntityCollection collection = query.GetEntityCollection(userConnection); var result = new List <IReadOnlyDictionary <string, object> >(); foreach (var entity in collection) { var lookupContactColumn = entity.Schema.Columns.GetByName(contactColumn.Name); var lookupTypeColumn = entity.Schema.Columns.GetByName(typeColumn.Name); result.Add(new Dictionary <string, object> { ["Date"] = entity.GetTypedColumnValue <DateTime>(dateColumn.Name), ["ContactId"] = entity.GetColumnValue(lookupContactColumn.ColumnValueName), ["TypeName"] = entity.GetTypedColumnValue <string>(lookupTypeColumn.DisplayColumnValueName) }); } return(result); }
/// <summary> /// Creates rule criteria. /// </summary> /// <param name="serializedFilters">Serialized rule filters.</param> /// <param name="scoringObjectId">Unique identifier of score object.</param> /// <param name="userConnection">A <see cref="instance"/> of the current user connection.</param> /// <param name="generateQuery">True if requared query text; otherwise, false.</param> /// <returns></returns> public string CreateRuleCriteria(string serializedFilters, Guid scoringObjectId, UserConnection userConnection, bool generateQuery = false) { if (string.IsNullOrEmpty(serializedFilters)) { return(string.Empty); } EntitySchemaManager entitySchemaManager = userConnection.EntitySchemaManager; DataContract.Filters jsonFilters = Json.Deserialize <DataContract.Filters>(serializedFilters); EntitySchema scoringObjectSchema = entitySchemaManager.GetInstanceByUId(scoringObjectId); IEntitySchemaQueryFilterItem esqFilters = jsonFilters.BuildEsqFilter(scoringObjectSchema.UId, userConnection); var scoringObjectEsq = new EntitySchemaQuery(userConnection.EntitySchemaManager, scoringObjectSchema.Name); scoringObjectEsq.UseAdminRights = false; scoringObjectEsq.PrimaryQueryColumn.IsVisible = true; scoringObjectEsq.Filters.Add(esqFilters); Select scoringObjectSelect = scoringObjectEsq.GetSelectQuery(userConnection); if (generateQuery) { string query = scoringObjectSelect.GetSqlText(); return(query); } string serializedSelectQuery = SerializeSelectQuery(scoringObjectSelect); return(serializedSelectQuery); }
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="recordIds">###### ############### #######.</param> /// <param name="guids">###### ############### ######### #######.</param> private void RemoveUserInRoles(List <object> recordIds, List <Guid> guids) { SecurityException ex = null; EntitySchemaQuery schemaQuery = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysUserInRole"); schemaQuery.AddAllSchemaColumns(); IEntitySchemaQueryFilterItem primaryColumnFilter = schemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal, schemaQuery.RootSchema.PrimaryColumn.Name, recordIds); schemaQuery.Filters.Add(primaryColumnFilter); EntityCollection collection = schemaQuery.GetEntityCollection(UserConnection); foreach (Entity entity in collection.ToList()) { try { CheckCanRemoveUserFromRole(entity.GetTypedColumnValue <Guid>("SysRoleId")); entity.Delete(); guids.Add(entity.PrimaryColumnValue); } catch (SecurityException e) { ex = e; } } if (ex != null) { throw ex; } }
private Guid FindSysAdminUnitId(Guid contactId) { SysUserInfo currentUser = _userConnection.CurrentUser; if (currentUser.ContactId == contactId) { return(currentUser.Id); } EntitySchemaManager entitySchemaManager = _userConnection.EntitySchemaManager; var esq = new EntitySchemaQuery(entitySchemaManager, "SysAdminUnit") { UseAdminRights = false, IgnoreDisplayValues = true, CanReadUncommitedData = true }; EntitySchemaQueryColumn queryColumn = esq.AddColumn("Id"); IEntitySchemaQueryFilterItem queryFilterItem = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Contact", contactId); esq.Filters.Add(queryFilterItem); EntityCollection entities = esq.GetEntityCollection(_userConnection); if (entities.Count != 0) { Entity entity = entities.First.Value; return(entity.GetTypedColumnValue <Guid>(queryColumn.Name)); } return(Guid.Empty); }
private EntitySchemaQuery AddPeriodFilters(EntitySchemaQuery esq, string[] periods, string periodColumnPath) { string startDateColumnPath = "StartDate"; if (periodColumnPath == string.Empty) { periodColumnPath = "Id"; } else { startDateColumnPath = periodColumnPath + "." + startDateColumnPath; } if ((periods != null) && (periods.Length > 0)) { esq.Filters.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, periodColumnPath, periods)); } else { int year = DateTime.Now.Year; DateTime startDate = new DateTime(year, 1, 1); DateTime endDate = new DateTime(year, 12, 31); IEntitySchemaQueryFilterItem periodFilter = esq.CreateFilterWithParameters(FilterComparisonType.Between, startDateColumnPath, startDate, endDate); esq.Filters.Add(periodFilter); } return(esq); }
/// <summary> /// Add filter by entity id and options. /// </summary> /// <param name="messageQuery">Instance <see cref="EntitySchemaQuery" /></param> /// <param name="entityId">Entity message id.</param> /// <param name="readOptions">Reading options <see cref="EsnReadMessageOptions" />.</param> protected virtual void AddEntityMessageFilter(EntitySchemaQuery messageQuery, Guid entityId, EsnReadMessageOptions readOptions) { messageQuery.Filters.Add(messageQuery.CreateIsNullFilter("Parent")); messageQuery.Filters.Add( messageQuery.CreateFilterWithParameters(FilterComparisonType.Equal, "EntityId", entityId)); if (readOptions.OffsetDate != default(DateTime)) { var filterComparisonType = readOptions.OrderDirection == OrderDirection.Descending ? FilterComparisonType.Less : FilterComparisonType.Greater; messageQuery.Filters.Add( messageQuery.CreateFilterWithParameters( filterComparisonType, GetSortedColumnName(readOptions.SortedBy), readOptions.OffsetDate )); } if (readOptions.Filters != null) { IEntitySchemaQueryFilterItem esqFilters = readOptions.Filters.BuildEsqFilter(messageQuery.RootSchema.UId, UserConnection); messageQuery.Filters.Add(esqFilters); } }
private static void SafeSetAdminUnitFeatureState(UserConnection source, Guid featureId, int state, bool forAllUsers) { var schema = source.EntitySchemaManager.GetInstanceByName("AdminUnitFeatureState"); var esq = new EntitySchemaQuery(schema); esq.AddAllSchemaColumns(); IEntitySchemaQueryFilterItem featureFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Feature", featureId); esq.Filters.Add(featureFilter); if (!forAllUsers) { IEntitySchemaQueryFilterItem sauFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "SysAdminUnit", source.CurrentUser.Id); esq.Filters.Add(sauFilter); } var existRows = esq.GetEntityCollection(source); if (existRows.Count == 0) { var entity = schema.CreateEntity(source); entity.SetDefColumnValues(); entity.SetColumnValue("SysAdminUnitId", source.CurrentUser.Id); entity.SetColumnValue("FeatureId", featureId); existRows.Add(entity); } foreach (var sauFeatureState in existRows) { sauFeatureState.SetColumnValue("FeatureState", state); sauFeatureState.Save(); } }
/// <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); }
/// <summary> /// Returns query filter by "Type.Code" path. /// </summary> /// <param name="esq">Instance of <see cref="EntitySchemaQuery"/> type.</param> /// <returns>Query filter.</returns> protected IEntitySchemaQueryFilterItem GetFileCodeFilter(EntitySchemaQuery esq) { IEntitySchemaQueryFilterItem codeFilter = esq .CreateFilterWithParameters(FilterComparisonType.NotEqual, "Type.Code", "Link"); return(codeFilter); }
public virtual void CreateReminding() { if (ForecastId == Guid.Empty || CurrentUserContactId == Guid.Empty) { return; } string forecastName = string.Empty; var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "Forecast"); string columnName = esq.AddColumn("Name").Name; IEntitySchemaQueryFilterItem filter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, esq.RootSchema.GetPrimaryColumnName(), ForecastId); esq.Filters.Add(filter); EntityCollection entities = esq.GetEntityCollection(UserConnection); if (entities.Count > 0) { forecastName = entities[0].GetTypedColumnValue <string>(columnName); } Reminding reminding = new Reminding(UserConnection); reminding.SetDefColumnValues(); reminding.AuthorId = UserConnection.CurrentUser.ContactId; reminding.SourceId = RemindingConsts.RemindingSourceAuthorId; reminding.ContactId = CurrentUserContactId; reminding.RemindTime = DateTime.UtcNow; reminding.Description = string.Format(RemindingDescription, forecastName); reminding.SubjectCaption = RemindingSubjectCaption; reminding.SubjectId = ForecastId; reminding.SysEntitySchemaId = ForecastConsts.ForecastEntitySchemaUId; reminding.Save(); }
/// <summary> /// Returns query filter by primary column path. /// </summary> /// <param name="esq">Instance of <see cref="EntitySchemaQuery"/> type.</param> /// <param name="recordIds">Collection of entity records identifiers.</param> /// <returns>Query filter.</returns> protected IEntitySchemaQueryFilterItem GetFilePrimaryColumnFilter(EntitySchemaQuery esq, ICollection <Guid> recordIds) { IEntitySchemaQueryFilterItem idFilter = esq .CreateFilterWithParameters(FilterComparisonType.Equal, "Id", recordIds.Cast <object>().ToArray()); return(idFilter); }
public virtual Select ProcessDynamicFolder(Guid folderId) { var dataValueTypeManager = (DataValueTypeManager)UserConnection.AppManagerProvider.GetManager("DataValueTypeManager"); DataValueType dateTimeDataValueType = dataValueTypeManager.GetInstanceByName("DateTime"); DataValueType guidDataValueType = dataValueTypeManager.GetInstanceByName("Guid"); DataValueType intDataValueType = dataValueTypeManager.GetInstanceByName("Integer"); EntitySchema targetSchema = UserConnection.EntitySchemaManager.GetInstanceByUId(TargetSchemaUId); IEntitySchemaQueryFilterItem filters = CommonUtilities.GetFolderEsqFilters( UserConnection, folderId, TargetFolderSchemaUId, TargetSchemaUId, true); var esq = new EntitySchemaQuery(targetSchema); if (RootSchemaName.Equals("BulkEmail") || RootSchemaName.Equals("BulkEmailSplit")) { esq.AddColumn(RootSchemaRecordRId, intDataValueType).SetForcedQueryColumnValueAlias("RootSchemaRecordId"); esq.AddColumn("Email"); } else { esq.AddColumn(RootSchemaRecordId, guidDataValueType).SetForcedQueryColumnValueAlias("RootSchemaRecordId");; esq.AddColumn(DefResponseId, guidDataValueType); esq.AddColumn(true, dataValueTypeManager.GetInstanceByName("Boolean")); esq.AddColumn(UserConnection.CurrentUser.ContactId, guidDataValueType); esq.AddColumn(UserConnection.CurrentUser.ContactId, guidDataValueType); esq.AddColumn("Id").SetForcedQueryColumnValueAlias("ContactRecordId"); if (IsSetCampaignFirstStep == true && RootSchemaName == "Campaign") { var campaignFirstStepId = GetCampaignFirstStep(RootSchemaRecordId); esq.AddColumn(campaignFirstStepId, guidDataValueType).SetForcedQueryColumnValueAlias("CurrentStepId"); } } if (filters != null) { esq.Filters.Add(filters); } Select folderQuery = esq.GetSelectQuery(UserConnection); Select resultSelect; switch (RootSchemaName) { case "Event": resultSelect = GetContactInEventDynamicFolderProcessingQuery(folderQuery); break; case "BulkEmailSplit": case "BulkEmail": resultSelect = GetContactInBulkEmailDynamicFolderProcessingQuery(folderQuery); break; case "Campaign": resultSelect = GetContactInCampaignDynamicFolderProcessingQuery(folderQuery); break; default: resultSelect = null; break; } return(resultSelect); }
private void AddSettingsFilter(ColumnSettingsData settings, EntitySchemaQuery esq) { IEntitySchemaQueryFilterItem filterItem = settings.FilterData?.BuildEsqFilter( settings.FilterData.RootSchemaName, UserConnection); if (filterItem != null) { esq.Filters.Add(filterItem); } }
private bool AddKeyColumnsFilterToQuery(string joinPath, ColumnExpression columnExpression, EntitySchemaQuery esq) { IEntitySchemaQueryFilterItem filter = esq.CreateFilter(FilterComparisonType.Equal, $"{joinPath}.{columnExpression.BufferedColumnName}", columnExpression.ColumnValueName); esq.Filters.Add(filter); return(true); }
/// <summary> /// Returns queue object query with filtration. /// </summary> /// <param name="entitySchemaName">Queue object schema name.</param> /// <param name="filters">Queue object filters.</param> /// <returns>Queue object query with filtration</returns> protected Select GetQueueEntitySelectWithFilter(string entitySchemaName, ServiceDataContract.Filters filters) { EntitySchemaManager entitySchemaManager = _userConnection.EntitySchemaManager; var esq = new EntitySchemaQuery(entitySchemaManager, entitySchemaName); esq.PrimaryQueryColumn.IsAlwaysSelect = true; IEntitySchemaQueryFilterItem esqFilters = filters.BuildEsqFilter(entitySchemaName, _userConnection); esq.Filters.Add(esqFilters); return(esq.GetSelectQuery(_userConnection)); }
/// <summary> /// Returns list of <see cref="EmailAttachment"/> items. /// </summary> /// <param name="activityId">Activity record identifier.</param> /// <returns>List of attachments.</returns> protected List <EmailAttachment> GetAttachments(Guid activityId) { var activityFileEntitySchema = UserConnection.EntitySchemaManager.GetInstanceByName("ActivityFile"); EntitySchemaQuery activityFileESQ = GetFileESQ(activityFileEntitySchema.UId); IEntitySchemaQueryFilterItem activityFilter = activityFileESQ .CreateFilterWithParameters(FilterComparisonType.Equal, "Activity", activityId); activityFileESQ.Filters.Add(activityFilter); activityFileESQ.Filters.Add(GetFileCodeFilter(activityFileESQ)); return(GetEmailAttachments(activityFileESQ)); }
private IEnumerable <IReadOnlyDictionary <string, object> > GetNumberOfRecordsData( UserConnection userConnection, Guid entitySchemaUId, IEntitySchemaQueryFilterItem filter) { return(new[] { new Dictionary <string, object> { ["Count"] = GetRecordCount(userConnection, entitySchemaUId, filter) } }); }
private void AddDomainFilters(string domain, EntitySchemaQuery esq) { if (domain.IsNullOrEmpty() || domain.Length < MinDomainLength) { return; } _webAddressVariants.ForEach(webAddress => { IEntitySchemaQueryFilterItem filter = esq.CreateFilterWithParameters(FilterComparisonType.StartWith, "Number", string.Format(webAddress, domain)); esq.Filters.Add(filter); }); }
/// <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); }
/// <summary> /// ########## ########## ######### ###############. /// </summary> /// <returns>########## ############### # #######.</returns> private int GetSysAdminsCount() { var sysUserInRoleQuery = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysUserInRole"); EntitySchemaQueryColumn countColumn = sysUserInRoleQuery.AddColumn("Id"); countColumn.SummaryType = AggregationType.Count; IEntitySchemaQueryFilterItem roleFilter = sysUserInRoleQuery.CreateFilterWithParameters( FilterComparisonType.Equal, "SysRole", sysAdminsRoleId); sysUserInRoleQuery.Filters.Add(roleFilter); Entity summary = sysUserInRoleQuery.GetSummaryEntity(UserConnection); return(summary != null?summary.GetTypedColumnValue <int>(countColumn.Name) : 0); }
/// <summary> ///Returns entity schema query to get records srored in static folder /// </summary> /// <param name="objectName">Entity schema name</param> /// <param name="folderId">Unique id of the folder</param> /// <param name="userConnection">Connection</param> /// <param name="recordIdColumn">Column with record identifier</param> public static EntitySchemaQuery GetStaticFolderESQ(string objectName, Guid folderId, UserConnection userConnection, out EntitySchemaQueryColumn recordIdColumn) { var ESQ = new EntitySchemaQuery(userConnection.EntitySchemaManager, objectName + "InFolder"); ESQ.PrimaryQueryColumn.IsAlwaysSelect = true; recordIdColumn = ESQ.AddColumn(objectName); IEntitySchemaQueryFilterItem folderFilter = ESQ.CreateFilterWithParameters(FilterComparisonType.Equal, "Folder", folderId); ESQ.Filters.Add(folderFilter); ESQ.IsDistinct = true; return(ESQ); }
/// <summary> /// Remove user from all roles. /// </summary> /// <param name="userId">User Id.</param> private void RemoveUserInAllRoles(object userId) { var schemaQuery = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysUserInRole"); schemaQuery.AddAllSchemaColumns(); IEntitySchemaQueryFilterItem userFilter = schemaQuery.CreateFilterWithParameters(FilterComparisonType.Equal, "SysUser", userId); schemaQuery.Filters.Add(userFilter); EntityCollection collection = schemaQuery.GetEntityCollection(UserConnection); var roleIds = collection.Select(x => (object)x.GetTypedColumnValue <Guid>("SysRoleId")).ToList(); if (roleIds.Count > 0) { RemoveUserInRoles(userId, roleIds); } }
/// <summary> ///Returns entity schema query to get records srored in dynamic folder /// </summary> /// <param name="objectName">Entity schema name</param> /// <param name="searchData">Byte array which represent serialized search data for dynamic folder query</param> /// <param name="userConnection">Connection</param> /// <param name="recordIdColumn">Column with record identifier</param> public static EntitySchemaQuery GetDynamicFolderESQ(string objectName, byte[] searchData, UserConnection userConnection, out EntitySchemaQueryColumn recordIdColumn) { var ESQ = new EntitySchemaQuery(userConnection.EntitySchemaManager, objectName); recordIdColumn = ESQ.AddColumn(ESQ.RootSchema.GetPrimaryColumnName()); IEntitySchemaQueryFilterItem filters = CommonUtilities.ConvertClientFilterDataToEsqFilters(userConnection, searchData, ESQ.RootSchema.UId); CommonUtilities.DisableEmptyEntitySchemaQueryFilters(new [] { filters }); if (filters != null) { ESQ.Filters.Add(filters); } return(ESQ); }
public Guid GetForecastPeriodType(Guid forecastId) { EntitySchemaQuery forecastEsq = GetForecastSelectQuery(); IEntitySchemaQueryFilterItem forecastIdFilter = forecastEsq.CreateFilterWithParameters(FilterComparisonType.Equal, "Id", forecastId); forecastEsq.Filters.Add(forecastIdFilter); EntityCollection forecastEntity = forecastEsq.GetEntityCollection(_userConnection); Guid periodType = new Guid(); foreach (Entity itemValue in forecastEntity) { periodType = (Guid)itemValue.GetColumnValue("PeriodTypeId"); } return(periodType); }
public virtual IEnumerable <Guid> GetSysAdminUnitsInGroup(Guid sysAdminUnit) { var esq = new EntitySchemaQuery(UserConnection.EntitySchemaManager, "SysUserInRole"); esq.AddColumn("SysUser"); esq.AddColumn("SysRole"); IEntitySchemaQueryFilterItem filter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "SysRole", (object)sysAdminUnit); esq.Filters.Add(filter); EntityCollection result = esq.GetEntityCollection(UserConnection); IEnumerable <Guid> sysAdminUnitInGroup = result.Select(entity => entity.GetTypedColumnValue <Guid>("SysUserId")); return(sysAdminUnitInGroup); }
private EntitySchemaQuery GetCFSchemaDataEsq(EntitySchema modelRootSchema, string cfColumnPath, string filterData) { EntitySchema cfColumnSchema = modelRootSchema.GetSchemaColumnByPath(cfColumnPath).ReferenceSchema; var esq = new EntitySchemaQuery(cfColumnSchema); esq.PrimaryQueryColumn.IsAlwaysSelect = true; var converter = new FilterEditConverter(UserConnection); IEntitySchemaQueryFilterItem filter = converter.ConvertToEntitySchemaQueryFilterItem(esq, Owner, filterData); if (!filter.GetFilterInstances().IsEmpty()) { esq.Filters.Add(filter); } return(esq); }