private void Validator(CommonDataType type)
{
if (type.BaseType == EDataBaseType.Timestamp)
{
if (this.Entity.DataContext.DatabaseType == EDatabaseType.MySql)
{
Write("System.ComponentModel.DataAnnotations.MySqlTimestamp");
}
else
{
Write("System.ComponentModel.DataAnnotations.Timestamp");
}
}
else
{
WriteValidator(type.Validators.OfType <RequiredValidator>().FirstOrDefault());
WriteValidator(type.Validators.OfType <CompareValidator>().FirstOrDefault());
var max = type.GetType().GetProperty("MaxValue");
var min = type.GetType().GetProperty("MinValue");
if (max != null && min != null)
{
WriteValidator(type.Validators.OfType <RangeValidator>().FirstOrDefault(), type, max.GetValue(type), min.GetValue(type));
}
if (type.BaseType == EDataBaseType.String)
{
var strtype = type as StringType;
if (strtype.MaxLength.HasValue)
{
WriteValidator(type.Validators.OfType <MaxLengthValidator>().FirstOrDefault(), strtype.MaxLength.Value);
}
if (strtype.MinLength.HasValue)
{
WriteValidator(type.Validators.OfType <MinLengthValidator>().FirstOrDefault(), strtype.MinLength.Value);
}
foreach (var item in type.Validators)
{
switch (item.ValidatorType)
{
case EValidatorType.CreditCard:
case EValidatorType.Url:
case EValidatorType.EmailAddress:
case EValidatorType.Phone:
WriteValidator(item);
break;
case EValidatorType.RegularExpression:
WriteValidator((RegularExpressionValidator)item);
break;
}
}
}
}
}
private void WriteValidator(RangeValidator validator, CommonDataType type, object max1, object min1)
{
if (max1 != null || min1 != null)
{
Type datatype = Type.GetType($"System.{type.BaseType}");
string maxstr = max1 != null?max1.ToString() : datatype.GetField("MaxValue").GetValue(null).ToString();
string minstr = min1 != null?min1.ToString() : datatype.GetField("MinValue").GetValue(null).ToString();
validator = validator ?? new RangeValidator();
WriteValidator(validator, $"typeof(System.{type.BaseType})", $"\"{minstr}\"", $"\"{maxstr}\"");
}
}
/// <summary>
/// 设置子元素
/// </summary>
protected override void SetChildElements()
{
FormPanel control = (FormPanel)this.ControlHost.Content;
foreach (var child in this.ControlHost.Children)
{
var c = child.Content;
dynamic dc = c;
string classStr = string.Empty;
#region IsEnable
if (c.ExistProperty("IsEnable"))
{
if (!dc.IsEnable)
{
classStr += "disabled ";
}
}
#endregion
#region ValidatorMember
bool isValidatorRequired = false;
string controlName = child.Content.GetType().Name;
string validatorFullName = string.Empty;
if (child.Content.Bindings.Count > 0)
{
var bindValue = (from t in child.Content.Bindings where t.Path != null && t.Property != null && t.Property.ToLower() == "value" select t).FirstOrDefault();
if (bindValue != null)
{
validatorFullName = bindValue.Path;
bool isBindNavigatorMember = control.bindNavigatorMember(this.ScreenDefinition, validatorFullName);
if (isBindNavigatorMember)
{
var validatorMember = (from t in child.Content.Bindings where t.Path != null && t.Property != null && t.Property.ToLower() == "validatormember" select t).FirstOrDefault();
if (validatorMember != null)
{
validatorFullName = validatorMember.Path;
}
}
}
}
List <Model.Core.Definitions.Entities.ValidatorBase> listValidators = new List <Model.Core.Definitions.Entities.ValidatorBase>();
EDataBaseType baseType = EDataBaseType.String;
CommonDataType dataTypeContent = null;
control.GetValidators(this.ScreenDefinition, validatorFullName, ref listValidators, ref baseType, ref dataTypeContent);
foreach (var validator in listValidators)
{
if (validator.ValidatorType == Model.Core.Definitions.Entities.EValidatorType.Required)
{
isValidatorRequired = true;
}
break;
}
if (isValidatorRequired)
{
classStr += "required ";
}
#endregion
this.HtmlWriter.AddAttribute("dojoType", "Controls/ContentPane");
this.HtmlWriter.AddAttribute("label", child.Title);
if (!string.IsNullOrEmpty(classStr))
{
this.HtmlWriter.AddAttribute("class", classStr);
}
FormAttach formAttach = (FormAttach)child.AttachObject;
if (formAttach.ColumnSpan > 1)
{
this.HtmlWriter.AddAttribute("colspan", formAttach.ColumnSpan.ToString().ToLower());
}
if (formAttach.CollapsedTitle)
{
this.HtmlWriter.AddAttribute("spanLabel", "true");
}
this.HtmlWriter.RenderBeginTag("div");
var builder = child.GetBuilder(this.IsPreview, this.ScreenDefinition, this.Compile, this.ProjectDocument, this.PermissionData, this.HtmlWriter);
builder.Parent = this;
builder.Build();
this.HtmlWriter.RenderEndTag();
}
}
public static string GetView(bool skipMain, long dataIndex, string templateSuffix, bool showSaveDetail, CommonRefType dataRefTypeId, long dataRefId, CommonDataType dataTypeId, string dataValueName, bool enableRefTypeId, bool enableRefId, bool enableDataTypeId, bool showRefType, bool showRefId, bool showDataType, bool showItemHeader, bool showItemEdit, bool showItemAppend, string itemAddName, string itemEditName, string itemAppendName, bool isPublic)
{
long id = 0;
long pageNo = 1;
long itemsPerPage = UtilsGeneric.DefaultItemsPerPage;
#region Save View
string configToken;
string htmlSaveView = GetSaveView(showSaveDetail, id, pageNo, itemsPerPage, dataIndex, templateSuffix, (long)dataRefTypeId, dataRefId, (long)dataTypeId, dataValueName, enableRefTypeId, enableRefId, enableDataTypeId, showRefType, showRefId, showDataType, showItemHeader, showItemEdit, showItemAppend, itemAddName, itemEditName, itemAppendName, isPublic, out configToken);
#endregion
#region List View
string htmlListView = GetListView(pageNo, itemsPerPage, dataIndex, templateSuffix, configToken);
#endregion
string html = "";
if (skipMain == false)
{
var templateData = new TemplateData
{
SaveExpand = (id == 0) ? "true" : "false",
SaveDetail = htmlSaveView,
//ListExpand = (id == 0) ? "false" : "true",
ListDetail = htmlListView,
};
string message = "";
html = templateData.GetFilled(templateSuffix, UtilsGeneric.Validate, UtilsGeneric.ThrowException, out message);
}
else
{
html = htmlSaveView + htmlListView;
}
return html;
}
public override string CreateObjectValue(DataContext sourceDataContext, DataContext targetDataContext, CommonDataType dataType, object value)
{
if (value == null || value == DBNull.Value)
{
return("NULL");
}
switch (dataType)
{
case CommonDataType.Decimal:
case CommonDataType.Double:
case CommonDataType.Float:
case CommonDataType.Integer8:
case CommonDataType.Integer16:
case CommonDataType.Integer24:
case CommonDataType.Integer32:
case CommonDataType.Integer64:
case CommonDataType.Numeric:
case CommonDataType.Real:
return(value.ToString());
default:
return(string.Format("'{0}'", EscapeString(sourceDataContext, targetDataContext, value)));
}
}
/// <summary>
/// 生成返回验证器
/// </summary>
/// <param name="childItems"></param>
/// <param name="fullName"></param>
/// <param name="listValidators"></param>
/// <param name="baseType"></param>
/// <param name="dataTypeContent"></param>
private static void BuildMemberValidators(MemberBase[] childItems, string fullName, bool isParent, ref List <Model.Core.Definitions.Entities.ValidatorBase> listValidators, ref EDataBaseType baseType, ref CommonDataType dataTypeContent)
{
string path = fullName;
if (isParent && fullName.Split('.').Length == 4)
{
path = fullName.Replace("." + fullName.Split('.')[3], "");
}
var dataMember = (from t in childItems where t.FullName == path select t).FirstOrDefault();
if (dataMember != null)
{
if (dataMember.MemberType == EMemberType.NavigateMember)
{
var _NavigateMember = dataMember as NavigateMember;
if (_NavigateMember.Children.Count() > 0)
{
BuildMemberValidators(_NavigateMember.Children, fullName, false, ref listValidators, ref baseType, ref dataTypeContent);
}
}
else
{
BuildMemberValidatorsContent(dataMember, ref listValidators, ref baseType, ref dataTypeContent);
}
}
}
/// <summary>
/// 获取验证器
/// </summary>
/// <param name="controlBase"></param>
/// <param name="screenDef"></param>
/// <returns></returns>
private static string BuildValidators(this ControlBase controlBase, ScreenDefinition screenDef, string validatorFullName)
{
StringBuilder result = new StringBuilder();
StringBuilder sbValidator = new StringBuilder();
List <Model.Core.Definitions.Entities.ValidatorBase> listValidators = new List <Model.Core.Definitions.Entities.ValidatorBase>();
EDataBaseType baseType = EDataBaseType.String;
CommonDataType dataTypeContent = null;
GetValidators(controlBase, screenDef, validatorFullName, ref listValidators, ref baseType, ref dataTypeContent);
string dataTypeName = BuildCommonMethod.GetTypeName(baseType);
if (listValidators.Count > 0 && dataTypeContent != null)
{
string defaultValue = string.Empty, maxValue = string.Empty, minValue = string.Empty, maxLength = string.Empty, minLength = string.Empty;
BuildCommonMethod.GetDataTypeValue(dataTypeContent, ref defaultValue, ref maxValue, ref minValue, ref maxLength, ref minLength);
foreach (var validator in listValidators)
{
string validatorType = validator.ValidatorType.ToString().ToLower();
if (validator.ValidatorType == Model.Core.Definitions.Entities.EValidatorType.Phone)
{
validatorType = "tel";
}
else if (validator.ValidatorType == Model.Core.Definitions.Entities.EValidatorType.EmailAddress)
{
validatorType = "email";
}
else if (validator.ValidatorType == Model.Core.Definitions.Entities.EValidatorType.RegularExpression)
{
validatorType = "regexp";
}
else if (dataTypeName == "date" && validator.ValidatorType == Model.Core.Definitions.Entities.EValidatorType.Range)
{
validatorType = "daterange";
}
if (validator.ValidatorType != Model.Core.Definitions.Entities.EValidatorType.Compare)
{
sbValidator.Append("" + validatorType + ":{");
sbValidator.AppendFormat("message:'{0}'", validator.ErrorMessage);
switch (validator.ValidatorType)
{
case Model.Core.Definitions.Entities.EValidatorType.MinLength:
if (dataTypeName == "string")
{
sbValidator.AppendFormat(",min:{0}", minLength);
}
break;
case Model.Core.Definitions.Entities.EValidatorType.MaxLength:
if (dataTypeName == "string")
{
sbValidator.AppendFormat(",max:{0}", maxLength);
}
break;
case Model.Core.Definitions.Entities.EValidatorType.Range:
if (dataTypeName == "number")
{
sbValidator.AppendFormat(",min:{0}", minValue);
sbValidator.AppendFormat(",max:{0}", maxValue);
}
else if (dataTypeName == "date")
{
if (minValue != null)
{
DateTime dtMin = Convert.ToDateTime(minValue);
sbValidator.AppendFormat(",min:'{0}'", dtMin.ToString("yyyy-MM-dd"));
}
if (maxValue != null)
{
DateTime dtMax = Convert.ToDateTime(maxValue);
sbValidator.AppendFormat(",max:'{0}'", dtMax.ToString("yyyy-MM-dd"));
}
}
break;
case Model.Core.Definitions.Entities.EValidatorType.RegularExpression:
var cValidator = validator as Model.Core.Definitions.Entities.Validators.RegularExpressionValidator;
sbValidator.AppendFormat(",pattern:'{0}'", cValidator.Pattern.Replace(@"\", @"\\"));
break;
}
sbValidator.Append("},");
}
}
}
string _sbValidator = sbValidator.ToString().Length > 0 ? sbValidator.ToString().Substring(0, sbValidator.ToString().Length - 1) : "";
if (!string.IsNullOrEmpty(_sbValidator))
{
result.Append("validators:{");
result.Append(_sbValidator);
result.Append("},");
}
return(result.ToString());
}
/// <summary>
/// 返回所有验证
/// </summary>
/// <param name="controlBase"></param>
/// <param name="screenDef"></param>
/// <param name="validatorFullName"></param>
/// <param name="dataTypeName"></param>
/// <param name="dataTypeContent"></param>
/// <returns></returns>
public static void GetValidators(this ControlBase controlBase, ScreenDefinition screenDef, string validatorFullName, ref List <Model.Core.Definitions.Entities.ValidatorBase> listValidators, ref EDataBaseType baseType, ref CommonDataType dataTypeContent)
{
if (!string.IsNullOrEmpty(validatorFullName))
{
//验证成员来自 1/绑定数据集中的数据项. 2/属性
string datasetName = validatorFullName.Split('.')[0];
var pathLength = validatorFullName.Split('.').Length;
if (pathLength == 1)
{
//属性
var dataDataSet = (from t in screenDef.Children where t.MemberType == EMemberType.Property && t.Name == datasetName select t).FirstOrDefault();
if (dataDataSet != null)
{
BuildMemberValidatorsContent(dataDataSet, ref listValidators, ref baseType, ref dataTypeContent);
}
}
else
{
//绑定数据集中的数据项
var dataDataSet = (from t in screenDef.Children where (t.MemberType == EMemberType.DataSet || t.MemberType == EMemberType.Objects) && t.Name == datasetName select t).FirstOrDefault();
if (dataDataSet != null)
{
var childItems = (from t in dataDataSet.Children
where t.MemberType == EMemberType.CurrentItem || t.MemberType == EMemberType.SelectedItem
select t.Children).FirstOrDefault();
if (childItems != null)
{
BuildMemberValidators(childItems, validatorFullName, true, ref listValidators, ref baseType, ref dataTypeContent);
}
}
}
}
}
/// <summary>
/// 生成返回验证器
/// </summary>
/// <param name="mb"></param>
/// <param name="listValidators"></param>
/// <param name="baseType"></param>
/// <param name="dataTypeContent"></param>
private static void BuildMemberValidatorsContent(MemberBase mb, ref List <Model.Core.Definitions.Entities.ValidatorBase> listValidators, ref EDataBaseType baseType, ref CommonDataType dataTypeContent)
{
switch (mb.MemberType)
{
case EMemberType.PrimaryMember:
var _PrimaryMember = mb as PrimaryMember;
if (_PrimaryMember.Content != null)
{
dataTypeContent = _PrimaryMember.Content as CommonDataType;
baseType = dataTypeContent.BaseType;
listValidators = dataTypeContent.Validators;
}
break;
case EMemberType.CommonMember:
var _CommonMember = mb as CommonMember;
if (_CommonMember.Content != null)
{
dataTypeContent = _CommonMember.Content as CommonDataType;
baseType = dataTypeContent.BaseType;
listValidators = dataTypeContent.Validators;
}
break;
case EMemberType.DataMember:
var _DataMember = mb as DataMember;
if (_DataMember.Content != null)
{
dataTypeContent = _DataMember.Content as CommonDataType;
baseType = dataTypeContent.BaseType;
listValidators = dataTypeContent.Validators;
}
break;
case EMemberType.CalculateMember:
var _CalculateMember = mb as CalculateMember;
if (_CalculateMember.Content != null)
{
dataTypeContent = _CalculateMember.Content as CommonDataType;
baseType = dataTypeContent.BaseType;
listValidators = dataTypeContent.Validators;
}
break;
case EMemberType.Property:
var _PropertyMember = mb as Property;
if (_PropertyMember.Content != null)
{
dataTypeContent = _PropertyMember.Content as CommonDataType;
baseType = dataTypeContent.BaseType;
listValidators = dataTypeContent.Validators;
}
break;
}
}
/// <summary>
/// 获取数据类型返回的值
/// </summary>
/// <param name="dataType"></param>
/// <param name="defaultValue"></param>
/// <param name="maxValue"></param>
/// <param name="minValue"></param>
/// <param name="maxLength"></param>
/// <param name="minLength"></param>
public static void GetDataTypeValue(CommonDataType dataType, ref string defaultValue, ref string maxValue, ref string minValue, ref string maxLength, ref string minLength)
{
switch (dataType.BaseType)
{
case EDataBaseType.Int16:
var Int16 = dataType as Int16Type;
defaultValue = Int16.DefaultValue;
maxValue = Int16.MaxValue.ToString();
minValue = Int16.MinValue.ToString();
break;
case EDataBaseType.Int32:
var Int32 = dataType as Int32Type;
defaultValue = Int32.DefaultValue;
maxValue = Int32.MaxValue.ToString();
minValue = Int32.MinValue.ToString();
break;
case EDataBaseType.Int64:
var Int64 = dataType as Int64Type;
defaultValue = Int64.DefaultValue;
maxValue = Int64.MaxValue.ToString();
minValue = Int64.MinValue.ToString();
break;
case EDataBaseType.Byte:
var Byte = dataType as ByteType;
defaultValue = Byte.DefaultValue;
maxValue = Byte.MaxValue.ToString();
minValue = Byte.MinValue.ToString();
break;
case EDataBaseType.Single:
var Single = dataType as SingleType;
defaultValue = Single.DefaultValue;
maxValue = Single.MaxValue.ToString();
minValue = Single.MinValue.ToString();
break;
case EDataBaseType.Double:
var Double = dataType as DoubleType;
defaultValue = Double.DefaultValue;
maxValue = Double.MaxValue.ToString();
minValue = Double.MinValue.ToString();
break;
case EDataBaseType.Decimal:
var Decimal = dataType as DecimalType;
defaultValue = Decimal.DefaultValue;
maxValue = Decimal.MaxValue.ToString();
minValue = Decimal.MinValue.ToString();
break;
case EDataBaseType.TimeSpan:
var TimeSpan = dataType as TimeSpanType;
defaultValue = TimeSpan.DefaultValue;
maxValue = TimeSpan.MaxValue.ToString();
minValue = TimeSpan.MinValue.ToString();
break;
case EDataBaseType.DateTime:
var DateTime = dataType as DateTimeType;
defaultValue = DateTime.DefaultValue;
maxValue = DateTime.MaxValue.ToString();
minValue = DateTime.MinValue.ToString();
break;
case EDataBaseType.DateTimeOffset:
var DateTimeOffset = dataType as DateTimeOffsetType;
defaultValue = DateTimeOffset.DefaultValue;
maxValue = DateTimeOffset.MaxValue.ToString();
minValue = DateTimeOffset.MinValue.ToString();
break;
case EDataBaseType.Binary:
var Binary = dataType as BinaryType;
break;
case EDataBaseType.Boolean:
var Boolean = dataType as BooleanType;
defaultValue = Boolean.DefaultValue;
break;
case EDataBaseType.String:
var String = dataType as StringType;
defaultValue = String.DefaultValue;
maxLength = String.MaxLength.ToString();
minLength = String.MinLength.ToString();
break;
case EDataBaseType.Guid:
var Guid = dataType as GuidType;
break;
case EDataBaseType.Timestamp:
var Timestamp = dataType as TimestampType;
break;
}
}
public abstract string CreateObjectValue(DataContext sourceDataContext, DataContext targetDataContext, CommonDataType dataType, object value);
