public void SetValue(object value)
{
var type = EntityColumnInfo.PropertyInfo.PropertyType;
if (value != null && value.GetType() != type)
{
value = UtilMethods.ChangeType2(value, type);
}
this.EntityColumnInfo.PropertyInfo.SetValue(EntityValue, value);
}
private void Init()
{
if (datas.Count == 1)
{
var data = datas.First();
isDates = data is ReportableDateType;
if (data is ReportableDateType)
{
var type = UtilMethods.ChangeType2(data, typeof(ReportableDateType));
switch (type)
{
case ReportableDateType.MonthsInLast1years:
dates.AddRange(GetMonths(1));
break;
case ReportableDateType.MonthsInLast3years:
dates.AddRange(GetMonths(3));
break;
case ReportableDateType.MonthsInLast10years:
dates.AddRange(GetMonths(10));
break;
case ReportableDateType.years1:
dates.AddRange(GetYears(1));
break;
case ReportableDateType.years3:
dates.AddRange(GetYears(3));
break;
case ReportableDateType.years10:
dates.AddRange(GetYears(10));
break;
default:
break;
}
}
}
}
private List <DiffLogTableInfo> GetDiffTableBySql(long?identity)
{
List <SugarParameter> parameters = new List <SugarParameter>();
List <DiffLogTableInfo> result = new List <DiffLogTableInfo>();
var whereSql = string.Empty;
List <IConditionalModel> cons = new List <IConditionalModel>();
if (identity != null && identity > 0 && GetIdentityKeys().HasValue())
{
var fieldName = GetIdentityKeys().Last();
cons.Add(new ConditionalModel()
{
ConditionalType = ConditionalType.Equal, FieldName = fieldName, FieldValue = identity.ToString()
});
}
else
{
foreach (var item in this.EntityInfo.Columns.Where(it => it.IsIgnore == false && GetPrimaryKeys().Any(pk => pk.Equals(it.DbColumnName, StringComparison.CurrentCultureIgnoreCase))))
{
var fielddName = item.DbColumnName;
var filedObject = this.EntityInfo.Columns.FirstOrDefault(it => it.PropertyName == item.PropertyName).PropertyInfo.GetValue(this.InsertObjs.Last(), null);
var fieldValue = filedObject.ObjToString();
if (filedObject != null && filedObject.GetType() != typeof(string) && this.Context.CurrentConnectionConfig.DbType == DbType.PostgreSQL)
{
cons.Add(new ConditionalModel()
{
ConditionalType = ConditionalType.Equal, FieldName = fielddName, FieldValue = fieldValue, FieldValueConvertFunc = it => UtilMethods.ChangeType2(it, filedObject.GetType())
});
}
else
{
cons.Add(new ConditionalModel()
{
ConditionalType = ConditionalType.Equal, FieldName = fielddName, FieldValue = fieldValue
});
}
}
}
Check.Exception(cons.IsNullOrEmpty(), "Insertable.EnableDiffLogEvent need primary key");
var sqlable = this.SqlBuilder.ConditionalModelToSql(cons);
whereSql = sqlable.Key;
parameters.AddRange(sqlable.Value);
var dt = this.Context.Queryable <T>().Where(whereSql).AddParameters(parameters).ToDataTable();
if (dt.Rows != null && dt.Rows.Count > 0)
{
foreach (DataRow row in dt.Rows)
{
DiffLogTableInfo item = new DiffLogTableInfo();
item.TableDescription = this.EntityInfo.TableDescription;
item.TableName = this.EntityInfo.DbTableName;
item.Columns = new List <DiffLogColumnInfo>();
foreach (DataColumn col in dt.Columns)
{
DiffLogColumnInfo addItem = new DiffLogColumnInfo();
addItem.Value = row[col.ColumnName];
addItem.ColumnName = col.ColumnName;
addItem.ColumnDescription = this.EntityInfo.Columns.Where(it => it.DbColumnName != null).First(it => it.DbColumnName.Equals(col.ColumnName, StringComparison.CurrentCultureIgnoreCase)).ColumnDescription;
item.Columns.Add(addItem);
}
result.Add(item);
}
return(result);
}
else
{
DiffLogTableInfo diffTable = new DiffLogTableInfo();
diffTable.TableName = this.EntityInfo.DbTableName;
diffTable.TableDescription = this.EntityInfo.TableDescription;
diffTable.Columns = this.EntityInfo.Columns.Where(it => it.IsIgnore == false).Select(it => new DiffLogColumnInfo()
{
ColumnDescription = it.ColumnDescription,
ColumnName = it.DbColumnName,
Value = it.PropertyInfo.GetValue(this.InsertObjs.Last(), null)
}).ToList();
return(new List <DiffLogTableInfo>()
{
diffTable
});
}
}
public ConstantExpressionResolve(ExpressionParameter parameter) : base(parameter)
{
var expression = base.Expression as ConstantExpression;
var isLeft = parameter.IsLeft;
object value = ExpressionTool.GetValue(expression.Value, this.Context);
if (this.Context.TableEnumIsString == true &&
value != null &&
value.IsInt() &&
base.BaseParameter?.OppsiteExpression != null)
{
if (base.BaseParameter?.OppsiteExpression is UnaryExpression)
{
var oppsiteExpression = base.BaseParameter?.OppsiteExpression as UnaryExpression;
var oppsiteValue = oppsiteExpression.Operand;
if (oppsiteValue.Type.IsEnum())
{
value = UtilMethods.ChangeType2(value, oppsiteValue.Type).ToString();
}
}
}
var baseParameter = parameter.BaseParameter;
baseParameter.ChildExpression = expression;
var isSetTempData = baseParameter.CommonTempData.HasValue() && baseParameter.CommonTempData.Equals(CommonTempDataType.Result);
switch (parameter.Context.ResolveType)
{
case ResolveExpressType.SelectSingle:
case ResolveExpressType.Update:
case ResolveExpressType.SelectMultiple:
baseParameter.CommonTempData = value;
break;
case ResolveExpressType.WhereSingle:
case ResolveExpressType.WhereMultiple:
if (isSetTempData)
{
baseParameter.CommonTempData = value;
}
else
{
var parentIsBinary = parameter.BaseParameter.CurrentExpression is BinaryExpression;
var parentIsRoot = parameter.BaseParameter.CurrentExpression is LambdaExpression;
var isBool = value != null && value.GetType() == UtilConstants.BoolType;
if (parentIsRoot && isBool)
{
this.Context.Result.Append(value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False());
break;
}
if (parentIsBinary && isBool)
{
var isLogicOperator =
parameter.BaseExpression.NodeType == ExpressionType.And ||
parameter.BaseExpression.NodeType == ExpressionType.AndAlso ||
parameter.BaseExpression.NodeType == ExpressionType.Or ||
parameter.BaseExpression.NodeType == ExpressionType.OrElse;
if (isLogicOperator)
{
AppendMember(parameter, isLeft, (value.ObjToBool() ? this.Context.DbMehtods.True() : this.Context.DbMehtods.False()));
break;
}
}
if (value == null && parentIsBinary)
{
parameter.BaseParameter.ValueIsNull = true;
value = this.Context.DbMehtods.Null();
}
AppendValue(parameter, isLeft, value);
}
break;
case ResolveExpressType.FieldSingle:
case ResolveExpressType.FieldMultiple:
default:
break;
}
}
