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 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 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);
}
/// <summary>
/// Returns collection of the folder filters.
/// </summary>
/// <param name="userConnection">Instance of the <see cref="Terrasoft.Core.UserConnection"/>.</param>
/// <param name="recordId">Unique identifier of the folder.</param>
/// <param name="folderSchemaUId">Unique identifier of the folder schema.</param>
/// <param name="sourceSchemaName">Name of the source filters schema.</param>
/// <param name="disableEmptyFilters">Determines whether to disable empty filters or not.</param>
/// <returns><see cref="IEntitySchemaQueryFilterItem"/> filters collection.</returns>
public static IEntitySchemaQueryFilterItem GetFolderEsqFilters(
UserConnection userConnection, Guid recordId, Guid folderSchemaUId, string sourceSchemaName,
bool disableEmptyFilters = false)
{
byte[] searchData = GetFolderSearchData(userConnection, recordId, folderSchemaUId);
if (searchData?.IsEmpty() != false)
{
return(null);
}
var disableEmptyFilterBeforeBuildEsq = userConnection.GetIsFeatureEnabled("DisableEmptyFilterBeforeBuildEsq");
var filters = DeserializeFilters(searchData);
if (disableEmptyFilters && disableEmptyFilterBeforeBuildEsq)
{
DisableEmptyFilters(new[] { filters });
}
var selectQuery = new Terrasoft.Nui.ServiceModel.DataContract.SelectQuery {
RootSchemaName = sourceSchemaName,
Filters = filters
};
EntitySchemaQueryFilterCollection esqFilters = selectQuery.BuildEsq(userConnection).Filters;
if (disableEmptyFilters && !disableEmptyFilterBeforeBuildEsq)
{
DisableEmptyEntitySchemaQueryFilters(esqFilters);
}
return(esqFilters);
}
/// <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);
}
/// <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));
}
/// <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);
}
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));
}
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>
/// 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);
}
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);
}
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>
/// 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);
}
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);
}
}
/// <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);
}
protected override EntitySchemaQuery GetSummaryEsq(Sheet sheet, IEnumerable <Period> periodsInfo,
IEnumerable <ForecastColumn> filterColumns, FilterConfig filterConfig)
{
var esq = base.GetSummaryEsq(sheet, periodsInfo, filterColumns, filterConfig);
EntitySchemaColumn referenceColumn = sheet.GetEntityReferenceColumn(UserConnection);
EntitySchemaQueryFilterCollection
filterGroup = GetEsqSummaryGroupFilter(filterConfig, referenceColumn, esq);
esq.Filters.Add(filterGroup);
return(esq);
}
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);
}
public override EntitySchemaQueryFilterCollection GetDetailFilter(Entity entity, EntitySchemaQuery esq)
{
EntitySchemaQueryFilterCollection filtersGroup = base.GetDetailFilter(entity, esq);
Guid sheetId = entity.GetTypedColumnValue <Guid>("SheetId");
if (filtersGroup == null)
{
filtersGroup = new EntitySchemaQueryFilterCollection(esq);
}
filtersGroup.Add(esq.CreateFilterWithParameters(FilterComparisonType.Equal, "Sheet", sheetId));
return(filtersGroup);
}
/// <summary>
/// Searches for contacts in database by given phone numbers.
/// </summary>
/// <param name="phones">List of phone numbers to search by.</param>
/// <returns>Collection of ids of found contacts.</returns>
public IEnumerable <Guid> SearchByPhones(List <string> phones)
{
EntitySchemaQuery esq = GetEsqForContactSearch();
EntitySchemaQueryFilterCollection filters = PhoneNumberComparer.GetSearchContactFilters(esq, phones);
if (filters.IsNullOrEmpty())
{
return(new List <Guid>());
}
esq.Filters.Add(filters);
return(FindContacts(esq));
}
/// <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>
/// 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>
/// 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);
}
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>
/// 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 override EntitySchemaQueryFilterCollection GetDetailFilter(Entity entity, EntitySchemaQuery esq)
{
var productTypeId = entity.GetTypedColumnValue <Guid>("ProductTypeId");
if (productTypeId != null && productTypeId != Guid.Empty)
{
var filterValues = new object[] { productTypeId };
var resultFilter = esq.CreateFilterWithParameters(FilterComparisonType.Equal, "ProductType", filterValues);
var resultCollection = new EntitySchemaQueryFilterCollection(esq, resultFilter);
return(resultCollection);
}
else
{
return(null);
}
}
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());
}
