private DbCommandTree HandleDeleteCommand(DbDeleteCommandTree deleteCommand)
{
var setClauses = new List <DbModificationClause>();
var table = (EntityType)deleteCommand.Target.VariableType.EdmType;
if (table.Properties.All(p => p.Name != Constants.IS_DELETED_COLUMN_NAME))
{
return(deleteCommand);
}
var now = m_DateTimeProvider.GetUtcNow();
setClauses.Add(DbExpressionBuilder.SetClause(
deleteCommand.Target.VariableType.Variable(deleteCommand.Target.VariableName).Property(Constants.IS_DELETED_COLUMN_NAME),
DbExpression.FromBoolean(true)));
setClauses.Add(DbExpressionBuilder.SetClause(
deleteCommand.Target.VariableType.Variable(deleteCommand.Target.VariableName).Property(Constants.DELETED_COLUMN_NAME),
DbExpression.FromDateTime(now)));
return(new DbUpdateCommandTree(
deleteCommand.MetadataWorkspace,
deleteCommand.DataSpace,
deleteCommand.Target,
deleteCommand.Predicate,
setClauses.AsReadOnly(), null));
}
private DbCommandTree HandleInsertCommand(DbInsertCommandTree insertCommand)
{
var userId = GetActiveUserId();
var now = _operationClock().Now;
var updates = new List <KeyValuePair <Predicate <DbSetClause>, DbExpression> >
{
new(clause => MatchPropertyName(clause, ObjectOwnerIdColumnName), userId),
new(clause => MatchPropertyName(clause, LastChangedByUserIdColumnName), userId),
new(clause => MatchPropertyName(clause, LastChangedColumnName), DbExpression.FromDateTime(now))
};
private static string BuildSqlForTruncateTime(DateTime dateTime, SqlVersion sqlVersion)
{
var builder = new StringBuilder();
var sqlGenerator = new SqlGenerator(sqlVersion);
var functionExpression = EdmFunctions.TruncateTime(
DbExpression.FromDateTime(dateTime));
var sqlFragment = SqlFunctionCallHandler.GenerateFunctionCallSql(
sqlGenerator, functionExpression);
using (var sqlWriter = new SqlWriter(builder))
{
sqlFragment.WriteSql(sqlWriter, sqlGenerator);
}
return(builder.ToString());
}
private static DbCommandTree HandleDeleteCommand(DbDeleteCommandTree deleteCommand)
{
var setClauses = new List <DbModificationClause>();
var table = (EntityType)deleteCommand.Target.VariableType.EdmType;
if (table.Properties.All(p => p.Name != IsDeletedColumnName))
{
return(deleteCommand);
}
setClauses.Add(DbExpressionBuilder.SetClause(
deleteCommand.Target.VariableType.Variable(deleteCommand.Target.VariableName).Property(IsDeletedColumnName),
//DbExpression.FromBoolean(true)));
DbExpression.FromDateTime(DateTime.Now)));
return(new DbUpdateCommandTree(
deleteCommand.MetadataWorkspace,
deleteCommand.DataSpace,
deleteCommand.Target,
deleteCommand.Predicate,
setClauses.AsReadOnly(), null));
}
private static DbCommandTree HandleUpdateCommand(DbUpdateCommandTree updateCommand)
{
var now = DateTime.Now;
var setClauses = updateCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(ModifiedColumnName, DbExpression.FromDateTime(now)))
.Select(clause => clause.UpdateIfMatch(IsActiveColumnName, true))
.Select(clause => clause.UpdateIfMatch(IsDeletedColumnName, false))
.ToList();
return(new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
setClauses.AsReadOnly(), null));
}
private static DbCommandTree HandleInsertCommand(DbInsertCommandTree insertCommand)
{
var now = DateTime.Now;
var setClauses = insertCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(CreatedColumnName, DbExpression.FromDateTime(now)))
.Select(clause => clause.UpdateIfMatch(ModifiedColumnName, DbExpression.FromDateTime(now)))
.Select(clause => clause.UpdateIfMatch(IsActiveColumnName, true))
.Select(clause => clause.UpdateIfMatch(IsDeletedColumnName, false))
.ToList();
return(new DbInsertCommandTree(
insertCommand.MetadataWorkspace,
insertCommand.DataSpace,
insertCommand.Target,
setClauses.AsReadOnly(),
insertCommand.Returning));
}
private static DbCommandTree HandleUpdateCommand(DbUpdateCommandTree updateCommand)
{
var now = DateTime.UtcNow;
var setClauses = updateCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(ModifiedColumnName, DbExpression.FromDateTime(now)))
.ToList();
//Removing Created column as it should never be allowed to be modified
setClauses.RemoveAll(clause => clause.IsFor(CreatedColumnName));
return(new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
setClauses.AsReadOnly(), null));
}
protected override Expression VisitConstant(ConstantExpression node)
{
var expression = base.VisitConstant(node);
var type = node.Type;
if (IsNullableType(type))
{
var genericArgs = type.GetGenericArguments();
if ((genericArgs != null) && (genericArgs.Length == 1))
{
type = genericArgs[0];
}
}
if (type == typeof(byte[]))
{
MapExpressionToDbExpression(expression, DbExpression.FromBinary((byte[])node.Value));
}
else if (type == typeof(bool))
{
MapExpressionToDbExpression(expression, DbExpression.FromBoolean((bool?)node.Value));
}
else if (type == typeof(byte))
{
MapExpressionToDbExpression(expression, DbExpression.FromByte((byte?)node.Value));
}
else if (type == typeof(DateTime))
{
MapExpressionToDbExpression(expression, DbExpression.FromDateTime((DateTime?)node.Value));
}
else if (type == typeof(DateTimeOffset))
{
MapExpressionToDbExpression(expression, DbExpression.FromDateTimeOffset((DateTimeOffset?)node.Value));
}
else if (type == typeof(decimal))
{
MapExpressionToDbExpression(expression, DbExpression.FromDecimal((decimal?)node.Value));
}
else if (type == typeof(double))
{
MapExpressionToDbExpression(expression, DbExpression.FromDouble((double?)node.Value));
}
else if (type == typeof(Guid))
{
MapExpressionToDbExpression(expression, DbExpression.FromGuid((Guid?)node.Value));
}
else if (type == typeof(Int16))
{
MapExpressionToDbExpression(expression, DbExpression.FromInt16((Int16?)node.Value));
}
else if (type == typeof(Int32))
{
MapExpressionToDbExpression(expression, DbExpression.FromInt32((Int32?)node.Value));
}
else if (type.IsEnum)
{
MapExpressionToDbExpression(expression, DbExpression.FromInt32((Int32)node.Value));
}
else if (type == typeof(Int64))
{
MapExpressionToDbExpression(expression, DbExpression.FromInt64((Int64?)node.Value));
}
else if (type == typeof(float))
{
MapExpressionToDbExpression(expression, DbExpression.FromSingle((float?)node.Value));
}
else if (type == typeof(string))
{
MapExpressionToDbExpression(expression, DbExpression.FromString((string)node.Value));
}
else
{
throw new NotImplementedException(string.Format("Unhandled Type of {0} for Constant value {1} in LambdaToDbExpressionVisitor.VisitConstant", node.Type.Name, node.Value ?? "null"));
}
return(expression);
}
private static DbCommandTree HandleUpdateCommand(DbUpdateCommandTree updateCommand, DateTime dateTime)
{
var setClauses = updateCommand.SetClauses
.Where(clause => !clause.IsFor(CreatedColumnName))
.Select(clause => clause.UpdateIfMatch(ModifiedColumnName, DbExpression.FromDateTime(dateTime)))
.ToList();
return(new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
setClauses.AsReadOnly(), null));
}
public void TreeCreated(DbCommandTreeInterceptionContext interceptionContext)
{
if (interceptionContext.OriginalResult.DataSpace != DataSpace.SSpace)
{
return;
}
var lastChange = DateTime.Now;
var lastChangeBy = HttpContext.Current.User.Identity.Name;
var insertCommand = interceptionContext.Result as DbInsertCommandTree;
var updateCommand = interceptionContext.OriginalResult as DbUpdateCommandTree;
if (insertCommand != null)
{
var setClauses = insertCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(LastChangeColumnName, DbExpression.FromDateTime(lastChange)))
.Select(clause => clause.UpdateIfMatch(LastChangeByColumnName, DbExpression.FromString(lastChangeBy)))
.ToList();
interceptionContext.Result = new DbInsertCommandTree(insertCommand.MetadataWorkspace, insertCommand.DataSpace, insertCommand.Target, setClauses.AsReadOnly(), insertCommand.Returning);
}
else if (updateCommand != null)
{
var setClauses = updateCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(LastChangeColumnName, DbExpression.FromDateTime(lastChange)))
.Select(clause => clause.UpdateIfMatch(LastChangeByColumnName, DbExpression.FromString(lastChangeBy)))
.ToList();
interceptionContext.Result = new DbUpdateCommandTree(updateCommand.MetadataWorkspace, updateCommand.DataSpace, updateCommand.Target, updateCommand.Predicate, setClauses.AsReadOnly(), null);
}
}
private DbCommandTree HandleUpdateCommand(DbUpdateCommandTree updateCommand)
{
var target = updateCommand.Target;
var variableType = target.VariableType;
var entityType = (EntityType)variableType.EdmType;
if (entityType.Properties.All(p => p.Name != Constants.CREATED_COLUMN_NAME && p.Name != Constants.MODIFIED_COLUMN_NAME))
{
return(updateCommand);
}
var now = m_DateTimeProvider.GetUtcNow();
var setClauses = updateCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(Constants.MODIFIED_COLUMN_NAME, DbExpression.FromDateTime(now)))
.ToList();
return(new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
setClauses.AsReadOnly(),
updateCommand.Returning));
}
private static DbCommandTree HandleUpdateCommand(DbUpdateCommandTree updateCommand, string updateDateColumnName)
{
var now = DateTime.UtcNow;
var setClauses = updateCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(updateDateColumnName, DbExpression.FromDateTime(now)))
.ToList();
return(new DbUpdateCommandTree(
updateCommand.MetadataWorkspace,
updateCommand.DataSpace,
updateCommand.Target,
updateCommand.Predicate,
setClauses.AsReadOnly(), null));
}
private static DbCommandTree HandleInsertCommand(DbInsertCommandTree insertCommand, string createDateColumnName, string updateDateColumnName)
{
var now = DateTime.UtcNow;
var setClauses = insertCommand.SetClauses
.Select(clause => clause.UpdateIfMatch(createDateColumnName, DbExpression.FromDateTime(now)))
.Select(clause => clause.UpdateIfMatch(updateDateColumnName, DbExpression.FromDateTime(now)))
.ToList();
return(new DbInsertCommandTree(
insertCommand.MetadataWorkspace,
insertCommand.DataSpace,
insertCommand.Target,
setClauses.AsReadOnly(),
insertCommand.Returning));
}
