protected override bool InternalExecute(ProcessExecutingContext context)
{
if (EntityCollection == null || EntityCollection.Count == 0)
{
return(true);
}
EntitySchema entitySchema = EntityCollection.Schema;
if (string.IsNullOrEmpty(DataSourceFilters) || entitySchema == null)
{
return(true);
}
DataSourceFilterCollection dataSourceFilters =
ProcessUserTaskUtilities.ConvertToProcessDataSourceFilterCollection(
UserConnection, entitySchema, this, DataSourceFilters);
if (dataSourceFilters == null || dataSourceFilters.Count == 0)
{
return(true);
}
var dataSourceFiltersIsNot = new DataSourceFilterCollection(dataSourceFilters)
{
LogicalOperation = LogicalOperationStrict.And,
IsEnabled = true
};
var linqConverter = new DataSourceFilterLinqConverter(UserConnection);
IQueryable <Entity> resultQuery = linqConverter.BuildQuery(EntityCollection, dataSourceFiltersIsNot);
EntityCollection.RemoveRange(resultQuery.ToArray());
return(true);
}
public EntityCollection Collect()
{
var entitySchemaManager = _userConnection.EntitySchemaManager;
var mailboxES = entitySchemaManager.GetInstanceByName("MailboxSyncSettings");
var mailboxESQ = new EntitySchemaQuery(entitySchemaManager, mailboxES.Name);
var IdColumn = mailboxESQ.AddColumn(mailboxES.GetPrimaryColumnName());
var nameColumnName = mailboxESQ.AddColumn("UserName").Name;
var isDefaultColumnName = mailboxESQ.AddColumn("IsDefault").Name;
var sysAdminIdColumnName = mailboxESQ.AddColumn("SysAdminUnit.Id").Name;
var sysAdminNameColumnName = mailboxESQ.AddColumn("SysAdminUnit.Name").Name;
var contactNameColumnName = mailboxESQ.AddColumn("SysAdminUnit.Contact.Name").Name;
var contactIdColumnName = mailboxESQ.AddColumn("SysAdminUnit.Contact.Id").Name;
mailboxESQ.Filters.Clear();
#if !NETSTANDARD2_0 // TODO #CRM-44434
DataSourceFilterCollection filterCollection = new DataSourceFilterCollection()
{
LogicalOperation = LogicalOperationStrict.Or
};
var mailboxFilterGroug = filterCollection.ToEntitySchemaQueryFilterCollection(mailboxESQ);
mailboxFilterGroug.Add(mailboxESQ.CreateFilterWithParameters(FilterComparisonType.Equal, "SysAdminUnit.Contact.Id", _contactId));
mailboxFilterGroug.Add(mailboxESQ.CreateFilterWithParameters(FilterComparisonType.Equal, "IsShared", true));
mailboxESQ.Filters.Add(mailboxFilterGroug);
#endif
var mailboxCollection = mailboxESQ.GetEntityCollection(_userConnection);
return(mailboxCollection);
}
/// <summary>
/// Initializes the specified EntitySchemaQuery filters.
/// </summary>
/// <param name="userConnection">User connection.</param>
/// <param name="processActivity">Process activity.</param>
/// <param name="entitySchema">Entity schema.</param>
/// <param name="esq">Instance of the EntitySchemaQuery class.</param>
/// <param name="dataSourceFilters">Serialized filters.</param>
public static void SpecifyESQFilters(UserConnection userConnection, ProcessActivity processActivity,
EntitySchema entitySchema, EntitySchemaQuery esq, string dataSourceFilters)
{
userConnection.CheckArgumentNull("userConnection");
processActivity.CheckArgumentNull("processActivity");
entitySchema.CheckArgumentNull("entitySchema");
esq.CheckArgumentNull("esq");
if (string.IsNullOrEmpty(dataSourceFilters))
{
return;
}
IEntitySchemaQueryFilterItem esqFilter;
var userConnectionArgument = new ConstructorArgument("userConnection", userConnection);
var processDataContractFilterConverter = ClassFactory
.Get <IProcessDataContractFilterConverter>(userConnectionArgument);
if (processDataContractFilterConverter.GetIsDataContractFilter(dataSourceFilters))
{
ServiceConfig.Initialize();
esqFilter = processDataContractFilterConverter.ConvertToEntitySchemaQueryFilterItem(esq,
processActivity.Owner, dataSourceFilters);
}
else
{
DataSourceFilterCollection filterCollection = ConvertToProcessDataSourceFilterCollection(userConnection,
entitySchema, processActivity, dataSourceFilters);
esqFilter = filterCollection.ToEntitySchemaQueryFilterCollection(esq);
}
esq.Filters.Add(esqFilter);
}
private static bool IsAnyLeftExpressionNullOrEmpty(DataSourceFilterCollection filterCollection)
{
bool result = false;
if (filterCollection == null)
{
return(result);
}
result = filterCollection.Any(fi => fi.IsAnyLeftExpressionNullOrEmpty());
return(result);
}
public virtual IQueryable <Entity> CreateQuery()
{
DataSourceFilterCollection filterCollection = null;
if (!string.IsNullOrEmpty(DataSourceFilters))
{
filterCollection = ProcessUserTaskUtilities.ConvertToProcessDataSourceFilterCollection(
UserConnection, SamplingEntityCollection.Schema, this, DataSourceFilters);
}
var linqConvertor = new DataSourceFilterLinqConverter(UserConnection);
return(linqConvertor.BuildQuery(SamplingEntityCollection, filterCollection));
}
public virtual void UpdateFiltersRightExprMetaDataByParameterValue(Process process, DataSourceFilterCollection filters)
{
foreach (var filter in filters)
{
if (filter is DataSourceFilterCollection)
{
UpdateFiltersRightExprMetaDataByParameterValue(process, (DataSourceFilterCollection)filter);
continue;
}
var dataSourcefilter = (DataSourceFilter)filter;
if (dataSourcefilter.RightExpression == null)
{
continue;
}
if (dataSourcefilter.RightExpression.Type == DataSourceFilterExpressionType.Custom)
{
dataSourcefilter.RightExpression.Type = DataSourceFilterExpressionType.Parameter;
if (dataSourcefilter.RightExpression.Parameters.Count == 2)
{
var parameters = dataSourcefilter.RightExpression.Parameters;
var metaPath = parameters[1].Value;
parameters[1].Value = process.GetParameterValueByMetaPath((string)metaPath);
parameters.RemoveAt(0);
}
if (dataSourcefilter.SubFilters != null && dataSourcefilter.SubFilters.Count > 0)
{
UpdateFiltersRightExprMetaDataByParameterValue(process, dataSourcefilter.SubFilters);
}
}
}
}
protected override bool InternalExecute(ProcessExecutingContext context)
{
EntitySchema entitySchema = EntityCollection.Schema;
if (entitySchema == null)
{
return(true);
}
DataSourceFilterCollection filters = null;
if (!string.IsNullOrEmpty(DataSourceFilters))
{
filters = ProcessUserTaskUtilities.ConvertToProcessDataSourceFilterCollection(
UserConnection, entitySchema, this, DataSourceFilters);
}
var orderByInfo = new Dictionary <string, OrderDirectionStrict>(8);
if (OrderInfo != null &&
(ProcessReadDataResultType)ResultType == ProcessReadDataResultType.Entity && OrderInfo.Length > 0)
{
string[] orders = OrderInfo.Split(',');
orders = orders.OrderBy(item => {
var items = item.Split(':');
if (items.Length == 3)
{
return(items[2]);
}
return(null);
}).ToArray();
string[,] orderInfoWithZeroPosition = new string[orders.Length, 2];
int index = -1;
for (int i = 0; i < orders.Length; i++)
{
string[] order = orders[i].Split(':');
if (order.Length != 3)
{
continue;
}
EntitySchemaColumn column = entitySchema.Columns.FindByName(order[0]);
if (column == null)
{
continue;
}
var orderDirection = (OrderDirection)Enum.Parse(typeof(OrderDirection), order[1]);
if (orderDirection == OrderDirection.None)
{
continue;
}
OrderDirectionStrict orderDirectionStrict = orderDirection == OrderDirection.Descending ?
OrderDirectionStrict.Descending : OrderDirectionStrict.Ascending;
if (order[2].Trim() != "0")
{
orderByInfo.Add(order[0], orderDirectionStrict);
}
else
{
index++;
orderInfoWithZeroPosition[index, 0] = order[0];
orderInfoWithZeroPosition[index, 1] = order[1];
}
}
while (index > -1)
{
var orderDirection = (OrderDirection)Enum.Parse(typeof(OrderDirection),
orderInfoWithZeroPosition[index, 1]);
OrderDirectionStrict orderDirectionStrict;
if (orderDirection == OrderDirection.None || orderDirection == OrderDirection.Ascending)
{
orderDirectionStrict = OrderDirectionStrict.Ascending;
}
else
{
orderDirectionStrict = OrderDirectionStrict.Descending;
}
orderByInfo.Add(orderInfoWithZeroPosition[index, 0], orderDirectionStrict);
index--;
}
}
var linqConverter = new DataSourceFilterLinqConverter(UserConnection);
switch ((ProcessReadDataResultType)ResultType)
{
case ProcessReadDataResultType.Entity:
IQueryable <Entity> resultQuery = ReadSomeTopRecords ?
linqConverter.BuildQuery(EntityCollection, filters, orderByInfo, NumberOfRecords)
: resultQuery = linqConverter.BuildQuery(EntityCollection, filters, orderByInfo);
var resultEntityCollection = new EntityCollection(UserConnection, EntityCollection.Schema);
foreach (Entity entity in resultQuery)
{
resultEntityCollection.Add(entity);
}
ResultRowsCount = resultEntityCollection.Count;
ResultEntityCollection = resultEntityCollection;
if (resultEntityCollection.Count > 0)
{
ResultEntity = resultEntityCollection.First.Value;
}
break;
case ProcessReadDataResultType.Function:
var aggregationType = (AggregationTypeStrict)FunctionType;
object result = linqConverter.ExecuteQuery(EntityCollection, filters, AggregationColumnName, aggregationType);
ResultRowsCount = 1;
switch (aggregationType)
{
case AggregationTypeStrict.Count:
ResultCount = (int)result;
break;
case AggregationTypeStrict.Avg:
case AggregationTypeStrict.Sum:
case AggregationTypeStrict.Max:
case AggregationTypeStrict.Min:
Type columnValueType = EntityCollection.Schema.Columns.GetByName(AggregationColumnName).DataValueType.ValueType;
if (columnValueType == typeof(DateTime))
{
ResultDateTimeFunction = (DateTime)result;
}
else
{
ResultFloatFunction = Convert.ToDecimal(result);
}
break;
}
break;
}
return(true);
}
