/// <summary>
/// 连接描述, 含数据源名称和连接串，数据源名称允许数据层扩展为同时操作多个数据来源（注意：镜像数据库或同一数据库的wcf读取模式，应使用同一数据源名称）
/// </summary>
/// <param name="DatasourceName">数据源名称</param>
/// <param name="connstring">连接串</param>
public ConnInfo(string DatasourceName, string connstring, EDataBaseType DatabaseType, string connName)
{
name = connName;
conn = connstring;
databaseType = DatabaseType;
datasourceName = DatasourceName;
}
public static string GetTypeNameByIon(EDataBaseType baseType)
{
switch (baseType)
{
case EDataBaseType.Int16:
case EDataBaseType.Int32:
case EDataBaseType.Int64:
case EDataBaseType.Byte:
case EDataBaseType.Single:
case EDataBaseType.Double:
case EDataBaseType.Decimal:
return("number");
case EDataBaseType.Boolean:
return("boolean");
case EDataBaseType.String:
case EDataBaseType.Guid:
case EDataBaseType.Timestamp:
return("string");
case EDataBaseType.TimeSpan:
case EDataBaseType.DateTime:
case EDataBaseType.DateTimeOffset:
case EDataBaseType.Binary:
return("any");
}
return("");
}
public static string GenerateValueExpression(EDataBaseType datatype, string value, bool isArray)
{
if (value.StartsWith("@") && value.Length > 2)
{
return(value.Substring(1));
}
if (!isArray)
{
if (VerificationValue(datatype, value))
{
switch (datatype)
{
case EDataBaseType.String:
return("@\"" + value + "\"");
case EDataBaseType.Guid:
case EDataBaseType.DateTime:
case EDataBaseType.DateTimeOffset:
case EDataBaseType.TimeSpan:
return("System." + datatype.ToString() + ".Parse(\"" + value + "\")");
case EDataBaseType.Int16:
case EDataBaseType.Int32:
case EDataBaseType.Int64:
case EDataBaseType.Double:
case EDataBaseType.Single:
case EDataBaseType.Byte:
case EDataBaseType.Boolean:
case EDataBaseType.Decimal:
return(value);
}
}
}
else
{
switch (datatype)
{
case EDataBaseType.String:
return("new string[] { " + value + " } ");
case EDataBaseType.Guid:
case EDataBaseType.DateTime:
case EDataBaseType.DateTimeOffset:
case EDataBaseType.TimeSpan:
var values = value.Split(',').Where(a => VerificationValue(datatype, a)).Select(a => "System." + datatype.ToString() + ".Parse(" + a + ")").ToArray();
return("new " + "System." + datatype.ToString() + "[] { " + string.Join(",", values) + " } ");
case EDataBaseType.Int16:
case EDataBaseType.Int32:
case EDataBaseType.Int64:
case EDataBaseType.Double:
case EDataBaseType.Single:
case EDataBaseType.Byte:
case EDataBaseType.Boolean:
case EDataBaseType.Decimal:
return("new " + "System." + datatype.ToString() + "[] { " + value + " } ");
}
}
return("");
}
/// <summary>
/// 连接描述, 含数据源名称和连接串，数据源名称允许数据层扩展为同时操作多个数据来源（注意：镜像数据库或同一数据库的wcf读取模式，应使用同一数据源名称）
/// </summary>
/// <param name="DatasourceName">数据源名称</param>
/// <param name="connstring">连接串</param>
public ConnInfo(string DatasourceName, string connstring, string IP, EDataBaseType DatabaseType)
{
name = "连接";
conn = connstring;
ip = IP;
databaseType = DatabaseType;
datasourceName = DatasourceName;
}
public static string GetRightExpression(EDataBaseType dataType, EValueType valueType, string value, List <string> parameters, bool isarray)
{
switch (valueType)
{
case EValueType.Const:
return(DataTypeMetadata.GenerateValueExpression(dataType, value, false));
case EValueType.Parameter:
parameters.Add(value);
return(value);
case EValueType.Property:
return("item." + value);
}
throw UtilityException.NotSupported("不支持查询值类型");
}
public DataService()
{
DataTable dt;
string sql;
//通过全局唯一用户名传递
#region ----- 初始化可用数据源 -----
if (connManage == null)
{
foreach (ConnectionStringSettings item in ConfigurationManager.ConnectionStrings)
{
string[] ss = item.Name.Split('_');
if (ss[0] == "管理数据源")
{
EDataBaseType dbtype = dbhelper.getDBType(ss[1]);
connManage = new ConnInfo(ss[0], item.ConnectionString, dbtype, ss[2]);
}
}
}
applicationid = DataService.users[OperationContext.Current.ServiceSecurityContext.PrimaryIdentity.Name].appID;
if (conns == null)
{
conns = new List <ConnInfo>();
sql = string.Format("select connname,datasourcename,databasetype,connectionstring from connections where applicationid='{0}'", applicationid);
dt = connManage.getDataTable(sql);
foreach (DataRow dr in dt.Rows)
{
string connstring = dr["connectionstring"].ToString();
string datasourcename = dr["datasourcename"].ToString();
EDataBaseType dbtype = (EDataBaseType)int.Parse(dr["databasetype"].ToString());
string connname = dr["connname"].ToString();
if (!string.IsNullOrWhiteSpace(connstring) && !string.IsNullOrWhiteSpace(datasourcename))
{
conns.Add(new ConnInfo(datasourcename, connstring, dbtype, connname));
}
}
}
#endregion
}
private static bool VerificationValue(EDataBaseType datatype, string value)
{
switch (datatype)
{
case EDataBaseType.Guid:
case EDataBaseType.DateTime:
case EDataBaseType.DateTimeOffset:
case EDataBaseType.TimeSpan:
case EDataBaseType.Int16:
case EDataBaseType.Int32:
case EDataBaseType.Int64:
case EDataBaseType.Double:
case EDataBaseType.Single:
case EDataBaseType.Byte:
case EDataBaseType.Boolean:
case EDataBaseType.Decimal:
if (string.IsNullOrEmpty(value))
{
return(false);
}
break;
}
switch (datatype)
{
case EDataBaseType.Guid:
Guid value1;
return(Guid.TryParse(value, out value1));
case EDataBaseType.DateTime:
DateTime value2;
return(DateTime.TryParse(value, out value2));
case EDataBaseType.DateTimeOffset:
DateTimeOffset value3;
return(DateTimeOffset.TryParse(value, out value3));
case EDataBaseType.TimeSpan:
TimeSpan value4;
return(TimeSpan.TryParse(value, out value4));
}
return(true);
}
public FunctionInfo(EDataBaseType returnType, string template)
{
this.Template = template;
this.ReturnType = returnType;
}
/// <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();
}
}
/// <summary>
/// 建立数据库连接
/// </summary>
public DataBase(EDataBaseType dbType, string strConnStr)
{
CP_ConnectionType = dbType;
CP_ConnectionString = strConnStr;
}
private void ProcessExpression(string name, EFunction function, string parameter, out string expression, out EDataBaseType expressionDataType)
{
expression = "item." + name;
expressionDataType = QueryMetadata.GetLeftDataType(Data.Entity, name);
if (QueryMetadata.Functions.ContainsKey(function))
{
var functionInfo = QueryMetadata.Functions[function];
expression = string.Format(functionInfo.Template, expression, parameter);
expressionDataType = functionInfo.ReturnType;
}
}
/// <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;
}
}
