/// <summary>
/// 为标准的返回XML结构创建错误信息节点并赋值
/// </summary>
/// <param name="strNodeName">节点名称</param>
/// <param name="strResult">节点值</param>
/// <returns>Boolean true成功,false失败</returns>
public Boolean setErrorNodeChild(String strNodeName, String strResult)
{
try
{
if (!createErrorInfoNode())
{
throw new Exception("ReturnDoc.setErrorNodeChild.创建返回节点时发生错误");
}
XmlNode nod_Temp = m_doc_Self.SelectSingleNode(Common.XDOC_ROOT + Common.BAR + Common.XDOC_ERRORINFO);
if (nod_Temp == null)
{
throw new Exception("ReturnDoc.setErrorNodeChild.获取错误根节点时发生错误");
}
XmlNode nod_Child = m_doc_Self.SelectSingleNode(
Common.XDOC_ROOT + Common.BAR +
Common.XDOC_ERRORINFO + Common.BAR + strNodeName);
if (nod_Child == null)
{
XmlFun.CreateDocNode(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_ERRORINFO, strNodeName, strResult);
}
else
{
nod_Child.InnerText = strResult;
}
return(true);
}
catch (Exception e)
{
return(false);
}
}
public static string OrgReturnNode(string subNodeName, string sNodeName, OleDbDataReader rst)
{
XmlDocument doc = XmlFun.CreateNewDoc("<" + subNodeName + "/>");
XmlElement el_row = null;
XmlElement elem = null;
while (rst.Read()) // 循环获取记录集的值
{
el_row = doc.CreateElement(sNodeName);
for (int i = 0; i < rst.FieldCount; i++)
{
string strFieldName = rst.GetName(i).ToUpper();
string sValue = rst[i].ToString();
elem = doc.CreateElement(strFieldName);
elem.InnerText = sValue;
el_row.AppendChild(elem);
}
doc.DocumentElement.AppendChild(el_row);
}
el_row = null;
elem = null;
return(doc.InnerXml);
}
/// <summary>
/// 获得字典条目列表
/// </summary>
/// <param name="Request"></param>
/// <param name="Response"></param>
/// <returns></returns>
public string QryDicDataList(HttpRequest Request, HttpResponse Response)
{
string strXML = Request["txtXML"];
string strDicName = XmlFun.getNodeValue(strXML, "//QUERYCONDITION/@dicname");
return(Dic.dicDataList(strXML, strDicName));
}
/// <summary>
/// 获得解析好的T-SQL查询Where语句
/// </summary>
/// <returns>解析好的T-SQL查询Where语句</returns>
public string getConditions()
{
XmlElement ele_Conditions = XmlFun.getElement(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_QUERYCONDITION);
if (ele_Conditions == null)
{
return(null);
}
return(parseConditions(ele_Conditions));
}
/// <summary>
/// 将查询返回的结果集拼装成需要的 XML 的结构
/// </summary>
/// <param name="rst">返回的结果集</param>
/// <param name="strListName">QUERY 子节点下的节点名称</param>
/// <returns>是否成功</returns>
public Boolean getQueryInfo(OleDbDataReader rst, string strListName)
{
string listXml = OrgReturnNode(Common.XDOC_QUERYINFO, strListName, rst);
if (XmlFun.setNodeDOM(this.m_doc_Self, Common.XDOC_ROOT, listXml))
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// 将标准的添加操作XmlElement对象转化为T-SQL语句
/// </summary>
/// <param name="eleSQL">业务操作型 XmlElement 对象</param>
/// <returns>T-SQL语句</returns>
private static string parseInsert(XmlElement eleSQL)
{
XmlNodeList it_Temp = eleSQL.ChildNodes;
string str_FieldList = ""; /// 字段列表
string str_ValueList = ""; /// 字段值列表
string str_TableName = eleSQL.Name; /// 表名
for (int k = 0; k < it_Temp.Count; k++)
{
XmlNode ele_Field = it_Temp[k];
String str_State = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_STATE);
String str_FieldName = ele_Field.Name;
String str_FieldValue = ele_Field.InnerText;
if (General.empty(str_State))
{
continue;
}
if (str_State.Equals(Common.ST_NORMAL))
{
str_FieldList += str_FieldName + Common.COMMA;
string str_DataType = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_DATATYPE);
if (General.empty(str_DataType))
{
continue;
}
int int_DataType = Convert.ToInt32(str_DataType);
str_ValueList += General.converType(int_DataType, str_FieldValue, str_FieldName) + Common.COMMA;
} /// if(str_State.equals(Common.DT_STRING))
} /// for~~~~~~~
if (General.empty(str_FieldList))
{
return(null);
}
return(Common.INSERT + str_TableName + Common.SPACE +
General.addBracket(str_FieldList.Substring(0, str_FieldList.Length - 1)) +
Common.S_VALUES +
General.addBracket(str_ValueList.Substring(0, str_ValueList.Length - 1)));
}
public static string test()
{
try
{
string strXML = "<root><a></a></root>";
XmlDocument doc = XmlFun.CreateNewDoc(strXML);
setAttributeValue(doc, "//a", "sv", "1");
CreateDocNode(doc, "root/a", "a1", "heihei");
return(doc.InnerXml);
}
catch (Exception e)
{
return(e.Message);
}
}
/// <summary>
/// 通过传入的 XML 结构，组织返回 Delete 类型的 SQL 语句
/// </summary>
/// <param name="eleSQL">业务操作型 XmlElement 对象</param>
/// <returns>T-SQL语句</returns>
private static string parseDelete(XmlElement eleSQL)
{
XmlNodeList it_Temp = eleSQL.ChildNodes;
string str_WhereList = ""; /// 条件列表
string str_TableName = eleSQL.Name; // 表名
for (int k = 0; k < it_Temp.Count; k++)
{
XmlNode ele_Field = it_Temp[k];
string str_State = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_STATE);
string str_FieldName = ele_Field.Name;
string str_FieldValue = ele_Field.InnerText;
if (General.empty(str_State))
{
continue;
}
int int_State = Convert.ToInt32(str_State);
String str_DataType;
int int_DataType;
switch (int_State)
{
case Common.IST_QUERY:
str_DataType = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_DATATYPE);
int_DataType = General.empty(str_DataType) ? Convert.ToInt32(Common.DT_STRING) : Convert.ToInt32(str_DataType);
if (int_DataType != Common.IDT_BINARY)
{
str_WhereList += str_FieldName + Common.EQUAL + General.converType(int_DataType, str_FieldValue, str_FieldName) + Common.S_AND;
} /// if (int_DataType==Common.IDT_BINARY)
break;
} /// switch ~~~~~~~~~~
} /// for~~~~~~~~
if (!General.empty(str_WhereList))
{
str_WhereList = Common.S_WHERE + str_WhereList.Substring(0, str_WhereList.Length - 5);
}
return(Common.DELETE + str_TableName + str_WhereList);
}
/// <summary>
/// 设置数据节点下指定节点的内容
/// </summary>
/// <param name="strNodeName">节点名称</param>
/// <param name="strValue">待设置的节点内容</param>
/// <returns>是否设置成功</returns>
public Boolean setDataValue(string strNodeName, string strValue)
{
try
{
if (!strNodeName.StartsWith(Common.BAR2))
{
strNodeName = Common.XDOC_ROOT + Common.BAR + Common.XDOC_DATAINFO + Common.BAR + strNodeName;
}
XmlFun.setNodeValue(m_doc_Self, strNodeName, strValue);
return(true);
}
catch (Exception e)
{
return(false);
}
}
/// <summary>
/// 根据xml初始化构造函数
/// </summary>
/// <param name="strXML">查询型的xml字符串</param>
public QueryDoc(string strXML)
{
m_doc_Self = new XmlDocument();
m_doc_Self.LoadXml(strXML);
XmlElement ele_Condition = this.getCondition();
string str_Return = XmlFun.getAttributValue(ele_Condition, Common.XML_PROP_RECORDSPERPAGE);
int int_PageSize = str_Return == null ? 10 : Convert.ToInt32(str_Return);
setIntPageSize(int_PageSize);
/// 获得当前待查询页码
str_Return = XmlFun.getAttributValue(ele_Condition, Common.XML_PROP_CURRENTPAGENUM);
int int_CurrentPage = str_Return == null ? 1 : Convert.ToInt32(str_Return);
setIntCurrentPage(int_CurrentPage);
}
/// <summary>
/// 创建标准XML结构的错误信息跟节点
/// </summary>
/// <returns>Boolean true成功,false失败</returns>
public Boolean createErrorInfoNode()
{
try
{
XmlNodeList nodeList = m_doc_Self.SelectNodes(Common.XDOC_ROOT + Common.BAR + Common.XDOC_ERRORINFO);
int int_Size = nodeList.Count;
if (int_Size == 0)
{
XmlFun.CreateDocNode(m_doc_Self, Common.XDOC_ROOT, Common.XDOC_ERRORINFO);
}
return(true);
}
catch (Exception e)
{
}
return(false);
}
/// <summary>
/// 统一处理标准的业务操作型XML文档，将文档分析称T-SQL封装到DataStorage类中作为一个事务执行
/// </summary>
/// <param name="strXML">标准业务操作型XML文档</param>
/// <returns>标准 XML 返回文档字符串</returns>
public static string dealWithXml(string strXML)
{
/// 创建执行对象
DataStorage obj_Storage = new DataStorage();
ReturnDoc obj_ReturnDoc = new ReturnDoc();
try
{
XmlDocument obj_Doc = XmlFun.CreateNewDoc(strXML);
XmlNodeList nodeLst = obj_Doc.SelectNodes("//*[@operation][@operation!='']");
for (int i = 0; i < nodeLst.Count; i++)
{
XmlElement ele_Temp = (XmlElement)nodeLst.Item(i);
// 创建插入数据的XML
string str_SQL = SQLAnalyse.analyseXMLSQL(ele_Temp);
obj_Storage.addSQL(str_SQL);
}
/// 执行
string str_Return = obj_Storage.runSQL();
if (!General.empty(str_Return))
{
obj_ReturnDoc.addErrorResult(Common.RT_FUNCERROR);
obj_ReturnDoc.setFuncErrorInfo(str_Return);
}
else
{
obj_ReturnDoc.addErrorResult(Common.RT_SUCCESS);
}
}
catch (Exception e)
{
obj_ReturnDoc.addErrorResult(Common.RT_FUNCERROR);
obj_ReturnDoc.setFuncErrorInfo(e.Message);
}
return(obj_ReturnDoc.getXml());
}
public Boolean createQueryInfoNode()
{
try
{
XmlNode node = XmlFun.getNode(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_QUERYINFO);
if (node == null)
{
XmlFun.CreateDocNode(m_doc_Self, Common.XDOC_ROOT, Common.XDOC_QUERYINFO, "");
}
return(true);
}
catch (Exception e)
{
return(false);
}
return(false);
}
/// <summary>
/// 向查询返回数据节点中，添加属性
/// * 在本函数中，如果原来已经存在同名节点，则会删除原节点
/// 例如：<EFSFRAME>
/// <QUERYINFO> <-- PropInfo
/// </QUERYINFO>
/// </EFSFRAME>
/// </summary>
/// <param name="strPropName">属性名称</param>
/// <param name="strPropValue">属性值</param>
/// <returns>是否成功</returns>
public Boolean addPropToQueryInfo(String strPropName, String strPropValue)
{
try
{
XmlElement ele_Query = XmlFun.getElement(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_QUERYINFO);
if (ele_Query == null)
{
XmlFun.CreateDocNode(m_doc_Self, Common.XDOC_ROOT, Common.XDOC_QUERYINFO, "");
}
ele_Query = XmlFun.getElement(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_QUERYINFO);
ele_Query.SetAttribute(strPropName, strPropValue);
return(true);
}
catch (Exception e)
{
return(false);
}
}
/// <summary>
/// 获得数据节点下指定节点的内容
/// </summary>
/// <param name="strNodeName">节点名称</param>
/// <returns>数据节点下指定节点的内容</returns>
public string getDataValue(string strNodeName)
{
return(XmlFun.getNodeValue(m_doc_Self,
Common.XDOC_ROOT + Common.BAR +
Common.XDOC_DATAINFO + Common.BAR + strNodeName));
}
/// <summary>
/// 根据 XML 文档解析得到T-SQL查询Where语句
/// </summary>
/// <param name="ele">XmlElement节点对象</param>
/// <returns>解析好的T-SQL查询Where语句</returns>
private string parseConditions(XmlElement ele)
{
XmlNodeList it_Condition = ele.SelectNodes(Common.BAR2 + Common.XDOC_CONDITION);
XmlNodeList it_Conditions = ele.SelectNodes(Common.BAR2 + Common.XDOC_CONDITIONS);
string str_Where = "";
string str_Type = "";
for (int k = 0; k < it_Condition.Count; k++)
{
if (k > 0)
{
str_Type = XmlFun.getNodeValue(it_Conditions.Item(k - 1), Common.XDOC_TYPE);
str_Type = General.empty(str_Type) ? "" : str_Type.Trim().ToUpper();
}
/// 获得查询节点
if (!General.empty(str_Where))
{
if (General.empty(str_Type))
{
throw new Exception("QueryDoc.parseConditions.77.未提供类型");
}
str_Where += Common.SPACE + str_Type + Common.SPACE;
}
XmlNode ele_Condition = it_Condition.Item(k);
string str_Alias = XmlFun.getAttributValue(ele_Condition, Common.XML_PROP_ALIAS);
string str_DataType = XmlFun.getAttributValue(ele_Condition, Common.XML_PROP_DATATYPE);
int int_DataType = General.empty(str_DataType) ? 0 : Convert.ToInt32(str_DataType);
string str_FieldName = XmlFun.getNodeValue(ele_Condition, Common.XDOC_FIELDNAME);
str_FieldName = General.empty(str_Alias) ? str_FieldName : str_Alias + Common.DOT + str_FieldName;
/// +
/// 如果是查询出生日期，则获得该字典的 sv 属性，用来确定是否是按照年龄来查询的
/// 如果是 AGERANGE 则说明是按照年龄来查询
/// 如果是 空，则说明是按照出生日期来查询
string str_Sv = XmlFun.getNodeValue(ele_Condition, Common.XDOC_FIELDNAME + Common.BAR + "@" + Common.XML_PROP_SV);
string str_Operation = XmlFun.getNodeValue(ele_Condition, Common.XDOC_OPERATION);
string str_DataValue = XmlFun.getNodeValue(ele_Condition, Common.XDOC_VALUE);
str_Operation = str_Operation.Trim().ToUpper();
/// 单独处理日期类型的字段
if (int_DataType == 3)
{
/// 按年龄来进行查询
if (str_Sv.Equals(Common.XML_AGERANGE))
{
str_Where += General.opYearDate(str_FieldName, str_DataValue, str_Operation);
}
else
{
str_Where += General.opDate(str_FieldName, str_DataValue, str_Operation);
}
}
else
{
if (int_DataType == Common.IDT_BINARY)
{
throw new Exception("QueryDoc.parseConditions.函数不能处理二进制类型的数据");
}
if (str_Operation.ToUpper().Equals("NOT IN") || str_Operation.ToUpper().Equals("IS") || str_Operation.ToUpper().Equals("IS NOT"))
{
str_Where += str_FieldName + Common.SPACE +
str_Operation + Common.SPACE +
str_DataValue;
}
else
{
str_Where += str_FieldName + Common.SPACE +
str_Operation + Common.SPACE +
General.converType(int_DataType, str_DataValue, str_FieldName);
}
}
}
return(str_Where);
}
public static Boolean setNodeValue(string strXML, string nodePath, int i, string sValue)
{
XmlDocument doc = XmlFun.CreateNewDoc(strXML);
return(setNodeValue(doc, nodePath, i, sValue));
}
public string getErrorValue(string strNodeName)
{
return(XmlFun.getNodeValue(m_doc_Self,
Common.XDOC_ROOT + Common.BAR +
Common.XDOC_ERRORINFO + Common.BAR + strNodeName));
}
public ReturnDoc()
{
m_doc_Self = XmlFun.getDefaultDoc();
}
public XmlNode getQueryInfoNode()
{
return(XmlFun.getNode(m_doc_Self,
Common.XDOC_ROOT + Common.BAR + Common.XDOC_QUERYINFO));
}
public static string getAttributValue(string strXML, string nodePath, int i, string svName)
{
XmlDocument doc = XmlFun.CreateNewDoc(strXML);
return(getAttributValue(doc, nodePath, i, svName));
}
/// <summary>
/// 在文档数据节点下添加一个 SQL 脚本的子节点
/// 例如：<EFSFRAME>
/// <DATAINFO>
/// <SQLSCRIPT operation="5"/> * 将该节点添加到文档根节点中
/// </DATAINFO>
/// </EFSFRAME>
/// </summary>
/// <param name="strSQL">待插入节点的 SQL 语句</param>
/// <returns>是否成功</returns>
public Boolean addSQLScript(string strSQL)
{
return(XmlFun.CreateDocNode(m_doc_Self, Common.XDOC_ROOT + Common.BAR + Common.XDOC_DATAINFO, Common.XDOC_SQLSCRIPT, strSQL));
}
public DataDoc()
{
m_doc_Self = XmlFun.getDefaultDoc();
}
public XmlNode getDataNode(string strNodeName, int i)
{
return(XmlFun.getNode(m_doc_Self,
Common.XDOC_ROOT + Common.BAR +
Common.XDOC_DATAINFO + Common.BAR + strNodeName, i));
}
/// <summary>
/// 通过传入的 XML 结构，组织返回 UPDATE 类型的 SQL 语句
/// </summary>
/// <param name="eleSQL">业务操作型 XmlElement 对象</param>
/// <returns>T-SQL语句</returns>
private static String parseUpdate(XmlElement eleSQL)
{
XmlNodeList it_Temp = eleSQL.ChildNodes;
string str_EditList = ""; /// 字段值列表
string str_WhereList = ""; /// 条件列表
string str_TableName = eleSQL.Name; // 表名
for (int k = 0; k < it_Temp.Count; k++)
{
XmlNode ele_Field = it_Temp[k];
string str_State = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_STATE);
string str_FieldName = ele_Field.Name;
string str_FieldValue = ele_Field.InnerText;
if (General.empty(str_State))
{
continue;
}
int int_State = Convert.ToInt32(str_State);
string str_DataType;
int int_DataType;
str_DataType = XmlFun.getAttributValue(ele_Field, Common.XML_PROP_DATATYPE);
int_DataType = General.empty(str_DataType) ? Convert.ToInt32(Common.DT_STRING) : Convert.ToInt32(str_DataType);
switch (int_State)
{
case Common.IST_NORMAL:
str_EditList += str_FieldName + Common.EQUAL + General.converType(int_DataType, str_FieldValue, str_FieldName) + Common.COMMA;
break;
case Common.IST_QUERY:
if (int_DataType == Common.IDT_BINARY)
{
throw new Exception("查询字句中不能以二进制流字段类型作为查询字句的内容!");
}
str_WhereList += str_FieldName + Common.EQUAL + General.converType(int_DataType, str_FieldValue, str_FieldName) + Common.S_AND;
break;
} /// switch (int_State)
} /// for~~~~~~~~~~
if (General.empty(str_EditList))
{
return(null);
}
if (!General.empty(str_WhereList))
{
str_WhereList = Common.S_WHERE + str_WhereList.Substring(0, str_WhereList.Length - 5);
}
return(Common.UPDATE + str_TableName +
Common.S_SET + str_EditList.Substring(0, str_EditList.Length - 1) +
str_WhereList);
}
