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