/// <summary>
/// 是否通过空值验证
/// </summary>
/// <param name="field"></param>
/// <param name="value"></param>
/// <returns></returns>
public static bool PassNullValue(IDataFieldModel field, object value)
{
if (field.CanbeNull())
{
return(true);
}
if (IsDbNullValue(value))
{
return(false);
}
var x = field.GetDataIdRefence();
if (x != null)
{
if (value is long)
{
return(IsValidId((long)value));
}
if (value is long?)
{
return(IsValidId((long?)value));
}
}
return(true);
}
private static bool IsNullableFieldForBooleanOrNum(IDataFieldModel f)
{
if (f == null)
{
return(false);
}
return(f.CanbeNull() && (f.FieldDbType == System.Data.DbType.Boolean || DataValueParase.IsNumberType(f.GetClrType()) != NumberType.Unkown));
}
/// <summary>
/// 获取数据库值转换接口
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static IDbValueConvertor GetDbValueConvertor(this IDataFieldModel field)
{
Type v = DataModelHelper.GetExtendProerty_DbFieldValueConvertType(field.InnerExtend);
if (v != null)
{
return(v.CreateObject() as IDbValueConvertor);
}
return(null);
}
/// <summary>
/// 对新增和修改的检测
/// 1、是否可为空
/// 2、字符长度
/// 3、数字范围
/// </summary>
/// <param name="datamoudle"></param>
/// <param name="f"></param>
/// <param name="v"></param>
/// <param name="errs"></param>
private void CheckAddOrUpdateFieldValue(
IDataModel datamoudle,
IDataFieldModel f,
object v,
IList <DataModalFieldException> errs)
{
if (!DataValueParase.PassNullValue(f, v))
{
errs.Add(ErrorCreateHelper.CreateFieldIsNullError(f.Name, f.Title));
return;
}
if (f.FieldDbType == System.Data.DbType.String)
{
//字符是否超出最大长度
int mx = f.GetFieldSize();
//等于int.maxvalue则不限制字符大小
if (mx != int.MaxValue)
{
mx = mx * 2; //字符类型在数据库存储均使用nvarchar类型(Unicode:每个字符占两字节)
string vv = (string)v;
if (!string.IsNullOrEmpty(vv))
{
int sl = System.Text.Encoding.Unicode.GetByteCount(vv);
if (sl > mx)
{
errs.Add(ErrorCreateHelper.CreateFieldValueOutOfRangeError(f.Name, f.Title, mx));
return;
}
}
}
}
else
{
//数字是否超出范围
Type fieldType = f.GetClrType();
//数字是否超出范围
NumberType nt = DataValueParase.IsNumberType(fieldType);
if ((nt != NumberType.Unkown) || (fieldType == typeof(DateTime) || fieldType == typeof(TimeSpan)))
{
string exp = f.GetMinMaxExpress();
if (!string.IsNullOrWhiteSpace(exp) && !DataValueParase.IsDbNullValue(v))
{
if (!MinMaxValueHelper.ValueIsInRangle(exp, v))
{
errs.Add(ErrorCreateHelper.CreateFieldValueOutOfRangeError(f.Name, f.Title, exp));
return;
}
}
}
}
}
/// <summary>
/// 生成删除数据的Sql表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="deleteItem"></param>
/// <param name="paramet"></param>
/// <returns></returns>
internal static string GetDeleteSql <T>(
T deleteItem,
out IEnumerable <IDataParamet> paramet)
{
paramet = null;
if (deleteItem == null)
{
throw new ObjectIsNullException(LocalResource.DeleteItem);
}
StringBuilder wheresql = new StringBuilder();
List <IDataParamet> paramets = new List <IDataParamet>();
IDataModel model = typeof(T).GetDataModel();
string namehz = GetIdKeyStringValues(deleteItem, model);
int c = 0;
foreach (var k in model.PrimaryKeys)
{
IDataFieldModel f = model.Fields[k.Name];
DataParamet p = AppendParamet(paramets, namehz, f, deleteItem);
if (c == 0)
{
wheresql.Append(string.Format("[{0}]={1}", f.Name, p.Name));
}
else
{
wheresql.Append(string.Format(" AND [{0}]={1}", f.Name, p.Name));
}
c++;
}
if (wheresql.Length == 0) //没有任何主键信息
{
throw new NotFoundPrimaryKeyException(typeof(T));
}
paramet = paramets.ToArray();
string sdf = model.GetSoftDeleteFieldName();
if (!string.IsNullOrEmpty(sdf))
{
return(string.Format("UPDATE {0} SET {1}=1 WHERE {2}",
MsSqlServerHelper.GetFeildNameInSqlExpress(model.Name),
MsSqlServerHelper.GetFeildNameInSqlExpress(sdf),
wheresql.ToString()));
}
else
{
return(string.Format("DELETE {0} WHERE {1}", GetFeildNameInSqlExpress(model.Name), wheresql.ToString()));
}
}
/// <summary>
/// 获取数据data的字段值
/// <para>如果数据data实现接口IDataRowReader,则返回Item[name]</para>
/// </summary>
/// <param name="field"></param>
/// <param name="data">要获取字段值的数据</param>
/// <returns></returns>
public static object GetModelFieldValue(this IDataFieldModel field, object data)
{
if (data is IDataRowReader)
{
IDataRowReader r = data as IDataRowReader;
return(r[field.Name]);
}
PropertyDescriptor pd = DataModelHelper.GetExtendProerty_PropertyDescription(field.InnerExtend);
if (pd != null)
{
return(pd.GetValue(data));
}
throw new ObjectIsNullException(LocalResource.FieldPropertyDescriptor);
}
/// <summary>
/// 设置数据data的字段值为fieldvalue
/// <para>如果data实现接口IDataRowSetter,则调用IDataRowSetter.SetFieldValue</para>
/// </summary>
/// <param name="field"></param>
/// <param name="data">要设置值的数据</param>
/// <param name="fieldvalue">要设置为的字段值</param>
public static void SetModelFieldValue(this IDataFieldModel field, object data, object fieldvalue)
{
if (data is IDataRowSetter)
{
IDataRowSetter s = data as IDataRowSetter;
s.SetFieldValue(field.Name, fieldvalue);
return;
}
PropertyDescriptor pd = DataModelHelper.GetExtendProerty_PropertyDescription(field.InnerExtend);
if (pd != null)
{
pd.SetValue(data, fieldvalue);
}
else
{
throw new ObjectIsNullException(LocalResource.FieldPropertyDescriptor);
}
}
/// <summary>
/// 将字段值从数据库格式转换为本机格式
/// </summary>
/// <param name="field">字段信息</param>
/// <param name="value">字段值</param>
/// <returns></returns>
public static object ConvertFieldValueFromDbValue(IDataFieldModel field, object value)
{
if (field != null)
{
var c = field.GetDbValueConvertor();
if (c != null)
{
return(c.ParseValueFromDbValue(value, field.GetClrType()));
}
else
{
if (value != null && value is IDbValueConvertor)
{
return(((IDbValueConvertor)value).ParseValueFromDbValue(value, value.GetType()));
}
}
}
return(value);
}
/// <summary>
/// 是否忽略检查字段
/// </summary>
/// <param name="field"></param>
/// <param name="rangle"></param>
/// <param name="ranglefieldnames"></param>
/// <returns></returns>
private bool IsIgnoreCheckField(
IDataFieldModel field,
FieldSelectRange rangle,
IEnumerable <string> ranglefieldnames)
{
if (field == null)
{
return(true);
}
if (field.IsRowVersion())
{
return(true);
}
if (field.IsSoftDeleteField())
{
return(true);
}
if (field.GetDbGeneratedDefine() != null)
{
return(true);
}
switch (rangle)
{
case FieldSelectRange.IgnoreFields: //忽略指定的字段
{
//指定字段是否是忽略的字段
return(ranglefieldnames != null && ranglefieldnames.FirstOrDefault(f => string.Equals(f, field.Name, StringComparison.OrdinalIgnoreCase)) != null);
}
case FieldSelectRange.OnlyFields: //仅检测指定的字段
{
//指定的字段是否在指定字段中
//如果不在则返回true,否则返回false
if (ranglefieldnames == null)
{
return(true);
}
return(ranglefieldnames.FirstOrDefault(f => string.Equals(f, field.Name, StringComparison.OrdinalIgnoreCase)) == null);
}
}
return(false);
}
/// <summary>
/// 字段值转换为数据库格式
/// </summary>
/// <param name="field">字段信息</param>
/// <param name="value">字段值</param>
/// <returns></returns>
public static object ConvertFieldValueToDbValue(IDataFieldModel field, object value)
{
if (field != null)
{
var c = field.GetDbValueConvertor();
if (c != null)
{
return(c.FormateValueToDbValue(value));
}
else
{
Type clr = field.GetClrType();
if (clr.FindInterface(typeof(IDbValueConvertor)))
{
IDbValueConvertor xx = clr.CreateObject() as IDbValueConvertor;
return(xx.FormateValueToDbValue(value));
}
}
}
return(value);
}
/// <summary>
/// 获取字段模型的值是否可为NULL
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static bool CanbeNull(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_CanbeNull(field.InnerExtend));
}
/// <summary>
/// 获取字段最大值和最小值限制表达式
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static string GetMinMaxExpress(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_MinMaxExpress(field.InnerExtend));
}
/// <summary>
/// 获取字段的缺省值
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static string GetDefaultValue(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_DefaultValue(field.InnerExtend));
}
/// <summary>
/// 获取字段对Id的引用信息
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static IDataIdRefence GetDataIdRefence(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProerty_DataIdRefence(field.InnerExtend));
}
/// <summary>
/// 判断字段模型是否是索引
/// </summary>
/// <param name="field"></param>
/// <returns>如果该字段模型是索引则返回索引信息,否则返回null</returns>
public static IDataModelFieldIndex IsIndexKey(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_IndexKey(field.InnerExtend));
}
/// <summary>
/// 获取字段的数据大小:返回0标识没有设置
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static int GetFieldSize(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_MaxLength(field.InnerExtend));
}
/// <summary>
/// 获取字段标识的自动增长属性
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static IDbGeneratedDefine GetDbGeneratedDefine(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProperty_DbGeneratedDefine(field.InnerExtend));
}
/// <summary>
/// 生成修改数据的Sql表达式
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="updateItem"></param>
/// <param name="updaterange"></param>
/// <param name="updatefields"></param>
/// <param name="paramet"></param>
/// <returns></returns>
internal static string GetUpdateSql <T>(
T updateItem,
FieldSelectRange updaterange,
IEnumerable <string> updatefields,
out IEnumerable <IDataParamet> paramet)
where T : class
{
paramet = null;
if (updateItem == null)
{
throw new ObjectIsNullException(LocalResource.UpdateItem);
}
StringBuilder wheresql = new StringBuilder();
StringBuilder setsql = new StringBuilder();
List <IDataParamet> paramets = new List <IDataParamet>();
IDataModel model = typeof(T).GetDataModel();
string namehz = GetIdKeyStringValues(updateItem, model);
int c = 0;
foreach (var k in model.PrimaryKeys)
{
IDataFieldModel f = model.Fields[k.Name];
DataParamet p = AppendParamet(paramets, namehz, f, updateItem);
if (c == 0)
{
wheresql.Append(string.Format("[{0}]={1}", f.Name, p.Name));
}
else
{
wheresql.Append(string.Format(" AND [{0}]={1}", f.Name, p.Name));
}
c++;
}
if (wheresql.Length == 0) //没有任何主键信息
{
throw new NotFoundPrimaryKeyException(typeof(T));
}
IDataFieldModelCollection fields = model.Fields;
c = 0;
foreach (var f in fields)
{
if (f.IsRowVersion())
{
continue;
}
if (f.GetDbGeneratedDefine() != null)
{
continue;
}
if (f.IsPrimaryKey() != null)
{
continue;
}
switch (updaterange)
{
case FieldSelectRange.All: break;
case FieldSelectRange.OnlyFields:
{
if (updatefields == null)
{
continue;
}
if (updatefields.FirstOrDefault(
ff => string.Equals(ff, f.Name, StringComparison.OrdinalIgnoreCase)) == null)
{
continue;
}
break;
}
case FieldSelectRange.IgnoreFields:
{
if (updatefields != null)
{
if (updatefields.FirstOrDefault(
ff => string.Equals(ff, f.Name, StringComparison.OrdinalIgnoreCase)) != null)
{
continue;
}
}
break;
}
}
DataParamet p = AppendParamet(paramets, namehz, f, updateItem);
if (c == 0)
{
setsql.AppendLine(string.Format("[{0}]={1}", f.Name, p.Name));
}
else
{
setsql.AppendLine(string.Format(",[{0}]={1}", f.Name, p.Name));
}
c++;
}
if (setsql.Length == 0)
{
return(null);
}
paramet = paramets.ToArray();
return(string.Format("UPDATE [{0}] SET {1} WHERE {2}", model.Name, setsql.ToString(), wheresql.ToString()));
}
/// <summary>
/// 获取字段模型的Clr数据类型
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static Type GetClrType(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProerty_ClrType(field.InnerExtend));
}
/// <summary>
/// 添加参数到paramets中去
/// </summary>
/// <param name="paramets">参数集合,返回的参数将添加到该集合中,如果不为空的话</param>
/// <param name="ft">参数后缀,可为为null</param>
/// <param name="field">字段信息</param>
/// <param name="value">行值</param>
/// <returns></returns>
private static DataParamet AppendParamet(List <IDataParamet> paramets, string parhz, IDataFieldModel field, object rowvalue)
{
object value = field.GetModelFieldValue(rowvalue);
value = ConvertFieldValueToDbValue(field, value);
DataParamet p = new DataParamet()
{
Name = GenerateParametName(field.Name, parhz),
Value = value,
ValueType = field.GetClrType()
};
int s = field.GetFieldSize();
if (s > 0)
{
p.ValueSize = s;
}
if (paramets != null)
{
paramets.Add(p);
}
return(p);
}
/// <summary>
/// 指示该字段是否是行版本
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static bool IsRowVersion(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProerty_RowVersion(field.InnerExtend));
}
/// <summary>
/// 指示该字段是否是软删除字段
/// </summary>
/// <param name="field"></param>
/// <returns></returns>
public static bool IsSoftDeleteField(this IDataFieldModel field)
{
return(DataModelHelper.GetExtendProerty_IsSoftDeleteField(field.InnerExtend));
}
/// <summary>
/// 创建字段定义的SQL
/// </summary>
/// <param name="field">字段模型</param>
/// <param name="tablesourcename">表名称</param>
/// <param name="stringcollatename">字符排序</param>
/// <returns></returns>
private static string CreateTableFieldSql(
IDataFieldModel field,
string tablesourcename,
string stringcollatename)
{
StringBuilder xx = new StringBuilder();
//添加 "[fieldname]"
xx.Append(MsSqlServerHelper.GetFeildNameInSqlExpress(field.Name));
if (field.IsRowVersion())
{
xx.Append(" [timestamp] NULL");
}
else
{
//添加 " [dbtype]" -> "[fieldname] [dbtype]"
xx.AppendFormat(" [{0}]", DbTypeToSqlDbType(field.FieldDbType).ToString().ToLower());
switch (field.FieldDbType)
{
case System.Data.DbType.AnsiString:
case System.Data.DbType.String:
{
int size = field.GetFieldSize();
if (size <= 0)
{
size = 50;
}
if (size == int.MaxValue)
{
xx.AppendFormat("(max) COLLATE {0}", stringcollatename);
}
else
{
xx.AppendFormat("({0}) COLLATE {1}", size, stringcollatename);
}
//添加 "(size) COLLATE ....." -> "[fieldname] [dbtype](size) COLLATE...."
break;
}
case System.Data.DbType.Decimal:
{
int l = 18;
int dot = 4;
var d = field.GetDecimalDefine();
if (d != null)
{
l = d.DecimalLength;
dot = d.DotLength;
if (l <= 0)
{
l = 18;
}
if (dot < 0)
{
dot = 0;
}
}
//添加 "(length,dotlength)" -> "[fieldname] [dbtype](length,dotlength)"
xx.AppendFormat("({0},{1})", l, dot);
break;
}
case System.Data.DbType.Int16:
case System.Data.DbType.Int32:
case System.Data.DbType.Int64:
{
var g = field.GetDbGeneratedDefine();
if (g != null)
{
//添加 " IDENTITY(start,step)" -> "[fieldname] [dbtype]IDENTITY(start,step)"
xx.AppendFormat(" IDENTITY({0},{1})", g.StartValue, g.Step);
}
break;
}
}
if (field.CanbeNull())
{
xx.Append(" NULL");
}
else
{
xx.Append(" NOT NULL");
}
string defaultvalue = field.GetDefaultValue();
if (!string.IsNullOrEmpty(defaultvalue))
{
xx.AppendFormat(" CONSTRAINT [DF_{0}_{1}_defaultvalue] DEFAULT ({2})", tablesourcename, field.Name, defaultvalue);
}
}
return(xx.ToString());
}
