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);
}
