private void SetContactSchemaUid()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager");
var contact = manager.FindItemByName("Contact");
contactSchemaUId = Column.Parameter(contact.UId);
}
private static string ResolveExpressionType(QueryColumnExpression expression,
Dictionary <string, EntitySchema> tableAliases)
{
switch (expression.ExpressionType)
{
case QueryColumnExpressionType.SourceColumnAlias:
return(ResolveSourceColumnAliasType(expression, tableAliases));
case QueryColumnExpressionType.SubSelect:
Dictionary <string, EntitySchema> subSelectTableAliases = GetTableSchemas(expression.SubSelect);
return(ResolveExpressionType(expression.SubSelect.Columns.FirstOrDefault(), subSelectTableAliases));
case QueryColumnExpressionType.Function:
return(ResolveFunctionColumnType(expression, tableAliases));
case QueryColumnExpressionType.Const:
switch (expression.ConstValue)
{
case int _:
case decimal _:
case double _:
return(NumericType);
case bool _:
return(BooleanType);
default:
return(UnknownType);
}
default:
return(UnknownType);
}
}
/// <summary>
/// Uppdates current step and set next step to null for finalized campaign.
/// </summary>
/// <param name="campaignId">Unique identifier of campaign.</param>
/// <param name="userConnection">User connection.</param>
private void SetGoalForCampaignStep(Guid campaignId, UserConnection userConnection)
{
Guid goalCampaignStepId = GetFirstCampainStepByType(campaignId, CampaignConsts.GoalCampaignStepTypeId,
userConnection);
Guid exitCampaignStepId = GetFirstCampainStepByType(campaignId, CampaignConsts.ExitCampaignStepTypeId,
userConnection);
QueryColumnExpression nullParameter =
Column.Parameter(DBNull.Value, new GuidDataValueType(UserConnection.DataValueTypeManager));
QueryCase queryCase = new QueryCase();
QueryCondition queryCondition = new QueryCondition(QueryConditionType.Equal)
{
LeftExpression = new QueryColumnExpression("CurrentStepId")
};
queryCondition.RightExpressions.Add(Column.Parameter(goalCampaignStepId));
queryCase.AddWhenItem(queryCondition, Column.Parameter(goalCampaignStepId));
queryCondition = new QueryCondition(QueryConditionType.Equal)
{
LeftExpression = new QueryColumnExpression("NextStepId")
};
queryCondition.RightExpressions.Add(Column.Parameter(goalCampaignStepId));
queryCase.AddWhenItem(queryCondition, Column.Parameter(goalCampaignStepId));
queryCase.ElseExpression = new QueryColumnExpression(Column.Parameter(exitCampaignStepId));
var update = new Update(userConnection, "CampaignTarget")
.Set("CurrentStepId", new QueryColumnExpression(queryCase))
.Set("NextStepId", nullParameter)
.Where("CampaignId").IsEqual(Column.Parameter(campaignId)) as Update;
update.Execute();
}
private int LoadData(Select select, Action <DataTable> onChunkLoaded, string selectExpression = null)
{
select.CheckArgumentNull("selectQuery");
onChunkLoaded.CheckArgumentNull("onChunkLoaded");
int chunkSize = _config.ChunkSize;
int maxRecordsCount = _config.MaxRecordsCount;
int minRecordsCount = _config.MinRecordsCount;
QueryColumnExpression idExpression = GetSelectIdColumnExpression(select, selectExpression);
var lastValueParameter = new QueryParameter("IdLastValue", null);
var pageableSelectCondition = new PageableSelectCondition {
LastValueParameter = lastValueParameter,
LeftExpression = idExpression,
OrderByItem = new OrderByItem(idExpression, OrderDirectionStrict.Ascending)
};
var options = new PageableSelectOptions(pageableSelectCondition, chunkSize, PageableSelectDirection.First);
Select pageableSelect = select.ToPageable(options);
bool hasRecords = true;
int totalRecordsCount = 0;
bool useMaxRecordsLimit = maxRecordsCount > 0;
using (DBExecutor dbExecutor = _userConnection.EnsureDBConnection(QueryKind.Limited)) {
while (hasRecords && (!useMaxRecordsLimit || totalRecordsCount < maxRecordsCount))
{
hasRecords = false;
using (IDataReader dr = pageableSelect.ExecuteReader(dbExecutor)) {
var dataTable = new DataTable();
dataTable.Load(dr);
int recordsCount = dataTable.Rows.Count;
totalRecordsCount += recordsCount;
if (totalRecordsCount < minRecordsCount && recordsCount < chunkSize)
{
throw new NotEnoughDataForTrainingException(
$"There's not enough data for upload. Minimal number: {minRecordsCount}," +
$" Current: {totalRecordsCount}");
}
if (recordsCount == 0)
{
continue;
}
hasRecords = true;
if (useMaxRecordsLimit && totalRecordsCount >= maxRecordsCount)
{
SendNotification("LocalizableStrings.RecordCountExceedsLimitMessage.Value");
}
DataRow lastRow = dataTable.Rows[recordsCount - 1];
string rowId = lastRow["Id"]?.ToString();
if (string.IsNullOrEmpty(rowId))
{
throw new Exception("Rowset can't contain a record with empty Id");
}
onChunkLoaded(dataTable);
lastValueParameter.Value = new Guid(rowId);
options.Direction = PageableSelectDirection.Next;
AddOrderByItemsConditions(select, options, lastRow);
pageableSelect = select.ToPageable(options);
}
}
}
return(totalRecordsCount);
}
private void SetAccountSchemaUid()
{
var manager = UserConnection.GetSchemaManager("EntitySchemaManager");
var account = manager.FindItemByName("Account");
accountSchemaUId = Column.Parameter(account.UId);
}
private static string ResolveSourceColumnAliasType(QueryColumnExpression expression,
Dictionary <string, EntitySchema> tableAliases)
{
var schema = FindSchemaOfColumn(expression, tableAliases);
return(schema == null ? UnknownType : ResolveSourceColumnType(schema, expression.SourceColumnAlias));
}
private Select GetChangedTranslationsSelect(List <ISysCultureInfo> sysCulturesInfo)
{
Select select =
new Select(UserConnection)
.Column(TranslationModifiedOnColumnName)
.Column(TranslationKeyColumnName)
.From(TranslationSchemaName);
QueryColumnExpression isTranslationChangedParameter = Column.Parameter(true);
bool isConditionAdded = false;
foreach (ISysCultureInfo sysCultureInfo in sysCulturesInfo)
{
string isChangedColumnName = sysCultureInfo.IsChangedColumnName;
select
.Column(sysCultureInfo.TranslationColumnName)
.Column(isChangedColumnName);
if (isConditionAdded)
{
select.Or(isChangedColumnName).IsEqual(isTranslationChangedParameter);
}
else
{
select.Where(isChangedColumnName).IsEqual(isTranslationChangedParameter);
isConditionAdded = true;
}
}
return(select);
}
private static void ReplaceFiltersWithPrimaryFieldCondition(Select select, Guid entityId,
QueryColumnExpression idExpression)
{
select.Condition.Clear();
select.Top(1).Where(idExpression.SourceAlias, idExpression.SourceColumnAlias)
.IsEqual(Column.Parameter(entityId));
}
private EntitySchemaColumn ResolveSchemaColumn(QueryColumnExpression expression,
Dictionary <string, EntitySchema> tableAliases)
{
switch (expression.ExpressionType)
{
case QueryColumnExpressionType.SourceColumnAlias: {
EntitySchema schema = FindSchemaOfColumn(expression, tableAliases);
EntitySchemaColumn column = schema?.Columns.FindByColumnValueName(expression.SourceColumnAlias);
return(column);
}
case QueryColumnExpressionType.SubSelect:
Dictionary <string, EntitySchema> subSelectTableAliases = GetTableSchemas(expression.SubSelect);
return(ResolveSchemaColumn(expression.SubSelect.Columns.First(), subSelectTableAliases));
case QueryColumnExpressionType.Function:
if (expression.Function is AggregationQueryFunction aggregationFunction)
{
return(ResolveSchemaColumn(aggregationFunction.Expression, tableAliases));
}
return(null);
default:
return(null);
}
}
/// <summary>
/// Adds given "DateDiff" column to query columns collection.
/// </summary>
/// <param name="select">Source <see cref="Select"/> to add column.</param>
/// <param name="interval">
/// Is the part of start date and end date that specifies the type of boundary crossed.
/// </param>
/// <param name="startDateExpression">Start date expression.</param>
/// <param name="endDateExpression">End date expression.</param>
/// <returns>Modified <paramref name="select"/> with newly added column.</returns>
public static Select DateDiff(this Select select, DateDiffQueryFunctionInterval interval,
object startDateExpression, object endDateExpression)
{
QueryColumnExpression startDate = AsQueryColumnExpression(startDateExpression);
QueryColumnExpression endDate = AsQueryColumnExpression(endDateExpression);
return(AddColumn(select, Func.DateDiff(interval, startDate, endDate)));
}
private IsNullQueryFunction GetLczColumnQueryFunction(string lczTableName, string lczTableColumnName,
string mainTableName, string mainTableColumnName)
{
QueryColumnExpression lczTableColumnExpression = Column.SourceColumn(lczTableName, lczTableColumnName);
QueryColumnExpression mainTableColumnExpression = Column.SourceColumn(mainTableName, mainTableColumnName);
return(Func.IsNull(lczTableColumnExpression, mainTableColumnExpression));
}
private static QueryColumnExpression FindColumnByName(Select select, string queryColumnAlias)
{
QueryColumnExpressionCollection columns = select.Columns;
QueryColumnExpression column = columns.FindByAlias(queryColumnAlias) ?? columns.Find(
expression => expression.SourceColumnAlias == queryColumnAlias && expression.Alias.IsNullOrEmpty());
return(column);
}
public static int IncCampaignRecipietCount(Guid campaignId, int count, UserConnection userConnection)
{
var update = new Update(userConnection, "Campaign")
.Set("TargetTotal", QueryColumnExpression.Add(new QueryColumnExpression("TargetTotal"),
Column.Parameter(count)))
.Where("Id").IsEqual(Column.Parameter(campaignId)) as Update;
return(update.Execute());
}
private void AddIdsFilters(Select select, Guid rootObjectUId, string filterData,
QueryColumnExpression idExpression)
{
select.Condition.Clear();
var subSelect = CreateIdsSelect(filterData, rootObjectUId);
select.Top(1).Where(idExpression.SourceAlias, idExpression.SourceColumnAlias)
.IsEqual(Column.SubSelect(subSelect));
}
/// <summary>
/// ########## ######### CASE ## ######### ########### ##########.
/// </summary>
/// <param name="conditionForCaseExpression">########, #############
/// # ##### ##### ####### WHEN.</param>
/// <param name="expressionForThenInCase">#########, ####### #####
/// ######### # ##### THEN.</param>
/// <param name="expressionForElseInCase">#########, ####### #####
/// ######### # ##### ELSE.</param>
/// <returns>######### CASE.</returns>
private QueryCase GenerateCaseForLicQuery(QueryColumnExpression conditionForCaseExpression,
QueryColumnExpression expressionForThenInCase, QueryColumnExpression expressionForElseInCase)
{
var queryCase = new QueryCase();
QueryCondition queryCondition = CreateQueryCondition(conditionForCaseExpression);
queryCase.AddWhenItem(queryCondition, expressionForThenInCase);
queryCase.SetElseExpression(expressionForElseInCase);
return(queryCase);
}
/// <summary>
/// ####### ####### ### CASE, # ####### ########### c######## ############
/// ######### ## ######### #######.
/// </summary>
/// <param name="columnExpression">########, ############# # ##### #####
/// #########.</param>
/// <returns>####### ######## ######### ######### ## #########
/// #######.</returns>
private QueryCondition CreateQueryCondition(QueryColumnExpression columnExpression)
{
var queryCondition = new QueryCondition(QueryConditionType.Greater)
{
LeftExpression = columnExpression
};
queryCondition.IsEqual(Column.Const(1));
return(queryCondition);
}
private void UpdateOrderProduct(Guid orderId)
{
QueryColumnExpression totalAmount =
(Column.SourceColumn("Quantity") * Column.SourceColumn("PrimaryPrice")).Block() -
((Column.SourceColumn("PrimaryPrice") * Column.SourceColumn("DiscountPercent") /
Column.Parameter(100)).Block() * Column.SourceColumn("Quantity")).Block();
Update update = new Update(UserConnection, "OrderProduct").
Set("TotalAmount", totalAmount).
Where("OrderId").IsEqual(Column.Parameter(orderId)) as Update;
update.Execute();
}
private static QueryColumnExpression GetColumnByName(Select select, string queryColumnAlias)
{
QueryColumnExpression column = FindColumnByName(select, queryColumnAlias);
if (column == null)
{
string message = $"Select expression does not contain column with alias '{queryColumnAlias}'. It must "
+ "present as it is used in ORDER BY clause.";
throw new InvalidTrainSetQueryException(message);
}
return(column);
}
private static EntitySchema FindSchemaOfColumn(QueryColumnExpression expression,
Dictionary <string, EntitySchema> tableAliases)
{
if (tableAliases.TryGetValue(expression.SourceAlias ?? string.Empty, out EntitySchema schema))
{
return(schema);
}
if (tableAliases.Count == 1)
{
return(tableAliases.Values.First());
}
return(null);
}
private QueryColumnExpression GetSelectIdColumnExpression(Select select, string selectExpression = null)
{
QueryColumnExpression idExpression = FindColumnByName(select, PrimaryQueryColumnName);
if (idExpression == null)
{
string message = "Select expression doesn't contain {0} column. Expression: {1}";
throw new InvalidTrainSetQueryException(string.Format(message, PrimaryQueryColumnName,
selectExpression ?? select.GetSqlText()));
}
idExpression.Alias = PrimaryQueryColumnName;
return(idExpression);
}
private static void AddOrderByItemsConditions(Select select, PageableSelectOptions options, DataRow lastRow)
{
options.OrderByItemsConditions.Clear();
foreach (OrderByItem orderByItem in select.OrderByItems)
{
string queryColumnAlias = orderByItem.Expression.SourceColumnAlias;
QueryColumnExpression column = GetColumnByName(select, queryColumnAlias);
column.Alias = queryColumnAlias;
object value = lastRow[queryColumnAlias];
QueryParameter orderByParameter = new QueryParameter(queryColumnAlias, value);
options.AddCondition(column, orderByItem, orderByParameter);
}
}
private PageableSelectOptions GetPageableOptions(ReadingOptions readingOptions)
{
var idExpression = new QueryColumnExpression(_portalMessageFileAlias, "Id");
idExpression.Alias = _portalMessageFileIdAlias;
var lastValueParameter = new QueryParameter("IdLastValue", readingOptions.LastValue);
var pageableSelectCondition = new PageableSelectCondition {
LastValueParameter = lastValueParameter,
LeftExpression = idExpression,
OrderByItem = new OrderByItem(idExpression, OrderDirectionStrict.Ascending)
};
return(new PageableSelectOptions(pageableSelectCondition, readingOptions.RowCount, PageableSelectDirection.Next));
}
/// <summary>
/// Sets ContactId from active SysAdminUnit it as ReceiverId column.
/// </summary>
/// <param name="select"></param>
private void SetReceiverIdFromActiveEmployees(Select select)
{
const string receiverColumnAlias = "ReceiverId";
QueryColumnExpression receiverColumn = select.Columns.FindByAlias(receiverColumnAlias);
select.CrossJoin("SysAdminUnit").As("sau");
int receiverIndex = select.Columns.IndexOf(receiverColumn);
receiverColumn = Column.SourceColumn("sau", "ContactId");
receiverColumn.Alias = receiverColumnAlias;
select.Columns[receiverIndex] = receiverColumn;
select.And("sau", "Active").IsEqual(Column.Parameter(true));
select.And("sau", "ContactId").Not().IsNull();
select.And("sau", "ConnectionType").IsNotEqual(Column.Parameter(UserType.SSP));
}
private SerializableExpression MapLeftExpression(QueryColumnExpression sourceColumnExpression)
{
if (sourceColumnExpression == null)
{
return(null);
}
var leftExpression = new SerializableExpression();
leftExpression.ExpressionType = sourceColumnExpression.ExpressionType;
if (sourceColumnExpression.Function != null)
{
leftExpression.Function = MapQueryFunction(sourceColumnExpression.Function);
}
leftExpression.SourceColumnAlias = sourceColumnExpression.SourceColumnAlias;
leftExpression.SourceAlias = sourceColumnExpression.SourceAlias;
leftExpression.Alias = sourceColumnExpression.Alias;
return(leftExpression);
}
/// <summary>
/// Updates Email data (audience count, last sending time).
/// </summary>
/// <param name="bulkEmailId">Unique Id of Email</param>
/// <param name="dateIn">Time of Email Sending</param>
/// <param name="isError">Flag whether error during sending occured</param>
private void UpdateBulkEmailData(Guid bulkEmailId, DateTime dateIn, bool isError = false)
{
var count = 1;
var update = new Update(_userConnection, "BulkEmail")
.Set("StartDate", Column.Parameter(dateIn))
.Set("SendStartDate", Column.Parameter(dateIn))
.Set("SendDueDate", Column.Parameter(dateIn))
.Set("RecipientCount", QueryColumnExpression.Add(new QueryColumnExpression("RecipientCount"),
Column.Parameter(count)));
if (isError)
{
update.Set("CommonErrorCount", QueryColumnExpression.Add(new QueryColumnExpression("CommonErrorCount"),
Column.Parameter(count)));
}
update.Where("Id").IsEqual(Column.Parameter(bulkEmailId));
(update as Update).Execute();
}
public static Guid AddProcessEntryPoint(UserConnection userConnection, Guid entitySchemaUId, Guid entityId,
Guid processElementUId)
{
if (entitySchemaUId == Guid.Empty || entityId == Guid.Empty)
{
return(Guid.Empty);
}
Guid entryPointId = Guid.NewGuid();
DataValueType guidDataValueType = userConnection.DataValueTypeManager.GetInstanceByName("Guid");
var idParameter = new QueryParameter("Id", entryPointId, guidDataValueType);
var entitySchemaUIdParameter = new QueryParameter("EntitySchemaUId", entitySchemaUId, guidDataValueType);
var entityIdParameter = new QueryParameter("EntityId", entityId, guidDataValueType);
var processElementIdParameter = new QueryParameter("processElementId", processElementUId,
guidDataValueType);
var currentDateTimeParameter = new QueryParameter("CurrentDateTime", userConnection.CurrentUser
.GetCurrentDateTime(), "DateTime");
var currentUserContactIdParameter = new QueryParameter(userConnection.CurrentUser.ContactId);
var isActiveParameter = new QueryParameter("isActive", true, "Boolean");
var entryPointInsert = new Insert(userConnection)
.Into("EntryPoint")
.Set("Id", idParameter)
.Set("CreatedOn", currentDateTimeParameter)
.Set("CreatedById", currentUserContactIdParameter)
.Set("ModifiedOn", currentDateTimeParameter)
.Set("ModifiedById", currentUserContactIdParameter)
.Set("EntitySchemaUId", entitySchemaUIdParameter)
.Set("EntityId", entityIdParameter)
.Set("SysProcessElementDataId", processElementIdParameter)
.Set("IsActive", isActiveParameter);
entryPointInsert.Execute();
string entitySchemaName = userConnection.EntitySchemaManager.GetItemByUId(entitySchemaUId).Name;
QueryColumnExpression columnExpression = Column.SqlText(userConnection.DBEngine
.GetBitwiseOperationSqlText("ProcessListeners", BitwiseOperation.Or,
((int)EntityChangeType.Updated).ToString(CultureInfo.InvariantCulture)));
var update =
new Update(userConnection, entitySchemaName)
.Set("ProcessListeners", columnExpression)
.Where("Id")
.IsEqual(entityIdParameter);
update.Execute();
return(entryPointId);
}
public static void DeactivateProcessEntryPoint(UserConnection userConnection, Guid entryPointId,
Guid entitySchemaUId, Guid entityId)
{
if (entitySchemaUId == Guid.Empty)
{
return;
}
DataValueType guidDataValueType = userConnection.DataValueTypeManager.GetInstanceByName("Guid");
var currentDateTimeParameter = new QueryParameter("CurrentDateTime",
userConnection.CurrentUser.GetCurrentDateTime(), "DateTime");
var currentUserContactIdParameter = new QueryParameter("ContactId", userConnection.CurrentUser.ContactId,
guidDataValueType);
var entryPointUpdate = new Update(userConnection, "EntryPoint")
.Set("ModifiedOn", currentDateTimeParameter)
.Set("ModifiedById", currentUserContactIdParameter)
.Set("IsActive", new QueryParameter("isActive", false, "Boolean"))
.Where("Id").IsEqual(new QueryParameter("Id", entryPointId, guidDataValueType));
entryPointUpdate.Execute();
string entitySchemaName = userConnection.EntitySchemaManager.GetItemByUId(entitySchemaUId).Name;
var entityIdParameter = new QueryParameter("EntityId", entityId, guidDataValueType);
var processListenersSelect =
new Select(userConnection)
.Column("Id")
.From("SysEntityCommonPrcEl")
.Where("RecordId").IsEqual(entityIdParameter)
.And("RecordChangeType").IsEqual(Column.Parameter(EntityChangeType.Updated));
var select =
new Select(userConnection)
.Column("Id")
.From("EntryPoint")
.Where("EntityId").IsEqual(entityIdParameter)
.And("IsActive").IsEqual(Column.Parameter(true))
.Union(processListenersSelect);
var columnExpression = new QueryColumnExpression(ArithmeticOperation.Subtraction,
Column.SourceColumn("ProcessListeners"), Column.Parameter((int)EntityChangeType.Updated));
var update =
new Update(userConnection, entitySchemaName)
.Set("ProcessListeners", columnExpression)
.Where("Id").IsEqual(entityIdParameter)
.And().Not().Exists(select);
update.Execute();
}
public int ExcludeFromCampaign(Guid campaignId, Guid[] campaignTargetIds)
{
Guid exitFromCampaignId = GetFirstCampainStepByType(campaignId, CampaignConsts.ExitCampaignStepTypeId,
UserConnection);
QueryColumnExpression nullParameter =
Column.Parameter(DBNull.Value, new GuidDataValueType(UserConnection.DataValueTypeManager));
if (exitFromCampaignId.IsEmpty())
{
return(0);
}
var excludeQuery = new Update(UserConnection, "CampaignTarget")
.Set("NextStepId", nullParameter)
.Set("CurrentStepId", Column.Const(exitFromCampaignId))
.Where("Id").In(Column.Parameters(campaignTargetIds))
.And("CurrentStepId").Not().IsEqual(Column.Const(exitFromCampaignId));
return(excludeQuery.Execute());
}
private static string ResolveFunctionColumnType(QueryColumnExpression expression,
Dictionary <string, EntitySchema> tableAliases)
{
switch (expression.Function)
{
case DateDiffQueryFunction _:
case DataLengthQueryFunction _:
case DatePartQueryFunction _:
case LengthQueryFunction _:
return(NumericType);
case CurrentDateTimeQueryFunction _:
case DateAddQueryFunction _:
return(DateTimeType);
case ConcatQueryFunction _:
case SubstringQueryFunction _:
case TrimQueryFunction _:
case UpperQueryFunction _:
return(TextType);
case CoalesceQueryFunction coalesce:
return(ResolveExpressionType(coalesce.Expressions.FirstOrDefault(), tableAliases));
case AggregationQueryFunction aggregate:
return(ResolveAggregationFunctionType(aggregate, tableAliases));
case IsNullQueryFunction isNull:
var checkExpressionType = ResolveExpressionType(isNull.CheckExpression, tableAliases);
if (checkExpressionType.IsNullOrEmpty() || checkExpressionType == UnknownType)
{
return(ResolveExpressionType(isNull.ReplacementExpression, tableAliases));
}
return(checkExpressionType);
case CastQueryFunction castFunction
when _typeMapping.TryGetValue(castFunction.CastType.ValueType, out string typeMapping):
return(typeMapping);
default:
return(UnknownType);
}
}
private void UpdateConditions(QueryCondition conditions)
{
if (conditions.Count > 0)
{
foreach (QueryCondition condition in conditions)
{
UpdateConditions(condition);
}
}
else
{
QueryColumnExpression leftExpression = conditions.LeftExpression;
if (leftExpression != null)
{
SetParameterValueTimeZoneOffset(leftExpression.Parameter);
var datePartFunction = leftExpression.Function as DatePartQueryFunction;
if (datePartFunction != null)
{
datePartFunction.UtcOffset = TimeZoneOffset;
}
}
if (conditions.RightExpressions != null)
{
foreach (QueryColumnExpression expression in conditions.RightExpressions)
{
SetParameterValueTimeZoneOffset(expression.Parameter);
object function = expression.Function;
if (function != null)
{
var expressionProperty = function.GetType().GetProperty("Expression");
if (expressionProperty != null)
{
var functionExpression = (QueryColumnExpression)expressionProperty.GetValue(function, null);
if (functionExpression != null)
{
SetParameterValueTimeZoneOffset(functionExpression.Parameter);
}
}
}
}
}
}
}
