/// <summary>
/// 获取节点中心同源单点数据操作任务状态
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public string GetSameDataActionTaskStatusN(string req)
{
try
{
reqdata = this.AnaRequestData(req);
SSY_DATA_ACTION_TASK model = this.json.Deserialize <SSY_DATA_ACTION_TASK>(reqdata.reqdata);
string cols = "id|data_real_conn|action_sql|action_sql_params|action_status|execute_cnt|max_execute_cnt|remarks|timestampss";
string colTypes = "String|String|String|String|String|String|String|String|String";
string nodeDataAction = APPConfig.GetAPPConfig().GetConfigValue("xmldataPath", "") + "\\SSY_DATA_ACTION_TASK.xml";
System.Data.DataTable dtdataActionTask = Common.Utility.GetTableFromXml(cols, colTypes, nodeDataAction);
List <SSY_DATA_ACTION_TASK> dataActionTask = new List <SSY_DATA_ACTION_TASK>();
if (Utility.DtHasData(dtdataActionTask))
{
dataActionTask = UtilitysForT <SSY_DATA_ACTION_TASK> .GetListsObj(dtdataActionTask);
}
if (dataActionTask.Count > 0)
{
resdata = this.MakeResponseData("0", string.Empty, json.Serialize(dataActionTask), string.Empty);
}
else
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("noFindSameDataActionTaskStatu", this.i18nModuleCurrLang), string.Empty, string.Empty);
}
}
catch (Exception ex)
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("getSameDataActionTaskStatuErr", this.i18nModuleCurrLang) + ex.Message,
string.Empty, string.Empty);
}
return(json.Serialize(resdata));
}
/// <summary>
/// 获取全部系统字典
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public string GetFrameDictAll(string req)
{
try
{
reqdata = this.AnaRequestData(req);
Xxx.Entities.SSY_FRAME_DICT model = json.Deserialize <Xxx.Entities.SSY_FRAME_DICT>(reqdata.reqdata);
List <Xxx.Entities.SSY_FRAME_DICT> objResult = this._comSomebiz.GetFrameDictAll(model, base.envirObj.distManagerParam);
if (UtilitysForT <Xxx.Entities.SSY_FRAME_DICT> .ListHasData(objResult))
{
resdata = this.MakeResponseData("1", string.Empty, json.Serialize(objResult), string.Empty);
}
else
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("noFindData", this.i18nCommonCurrLang), string.Empty, string.Empty);
}
}
catch (Exception ex)
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("findDataErr", this.i18nCommonCurrLang) + ex.Message, string.Empty, string.Empty);
}
return(json.Serialize(resdata));
}
/// <summary>
/// 查询节点异常情况
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public string GetNodeErrorLogsN(string req)
{
try
{
reqdata = this.AnaRequestData(req);
SSY_NODE_ERRORS model = this.json.Deserialize <SSY_NODE_ERRORS>(reqdata.reqdata);
string cols = "id|url_addr|node_typs|error_desc|remarks|timestampss";
string colTypes = "String|String|String|String|String|String";
string useNodeErrorLog = APPConfig.GetAPPConfig().GetConfigValue("xmldataPath", "") + "\\SSY_NODE_ERRORS.xml";
System.Data.DataTable dtXmlNodeErrors = Common.Utility.GetTableFromXml(cols, colTypes, useNodeErrorLog);
List <SSY_NODE_ERRORS> nodeErrors = new List <SSY_NODE_ERRORS>();
if (Utility.DtHasData(dtXmlNodeErrors))
{
nodeErrors = UtilitysForT <SSY_NODE_ERRORS> .GetListsObj(dtXmlNodeErrors);
}
if (nodeErrors.Count > 0)
{
resdata = this.MakeResponseData("0", string.Empty, json.Serialize(nodeErrors), string.Empty);
}
else
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("noFindNodeErrorLog", this.i18nModuleCurrLang), string.Empty, string.Empty);
}
}
catch (Exception ex)
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("getNodeErrorLogErr", this.i18nModuleCurrLang) + ex.Message, string.Empty, string.Empty);
}
return(json.Serialize(resdata));
}
/// <summary>
/// 获取节点中心服务站点服务
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public SSY_ResponseResult <IEnumerable <SSY_SERVICESITE_SERVICES> > GetNodeServiceSiteService(SSY_SERVICESITE_SERVICES model)
{
string cols = "id|sitecode|servicecode|servicename|service_relaUrl|remarks|timestampss";
string colTypes = "String|String|String|String|String|String|String";
string serviceSiteServicePath = APPConfig.GetAPPConfig().GetConfigValue("xmldataPath", "") + "\\SSY_SERVICESITE_SERVICES.xml";
System.Data.DataTable dtserviceSiteService = Common.Utility.GetTableFromXml(cols, colTypes, serviceSiteServicePath);
List <SSY_SERVICESITE_SERVICES> serviceSiteServiceList = new List <SSY_SERVICESITE_SERVICES>();
if (Utility.DtHasData(dtserviceSiteService))
{
serviceSiteServiceList = UtilitysForT <SSY_SERVICESITE_SERVICES> .GetListsObj(dtserviceSiteService);
}
return(new SSY_ResponseResult <IEnumerable <SSY_SERVICESITE_SERVICES> >(serviceSiteServiceList));
}
/// <summary>
/// 获取单个业务服务名称
/// </summary>
/// <param name="serviceIden"></param>
/// <returns></returns>
private string _GetSingleBizSvc(string serviceIden)
{
string serviceName = string.Empty;
List <SSY_SERVICESITE_SERVICES> svcList = new List <SSY_SERVICESITE_SERVICES>();
SSY_SERVICESITE_SERVICES modeltemp = new SSY_SERVICESITE_SERVICES();
SSY_ResponseResult <IEnumerable <SSY_SERVICESITE_SERVICES> > resSvc = this.GetNodeServiceSiteService(modeltemp);
svcList = resSvc.Result.ToList <SSY_SERVICESITE_SERVICES>();
if (UtilitysForT <SSY_SERVICESITE_SERVICES> .ListHasData(svcList))
{
SSY_SERVICESITE_SERVICES svcTar = svcList.Find(delegate(SSY_SERVICESITE_SERVICES t) { return(t.Servicecode == serviceIden); });
serviceName = svcTar.Service_relaUrl;
}
return(serviceName);
}
/// <summary>
/// 获取某个字典
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public string GetDicts(string req)
{
try
{
reqdata = this.AnaRequestData(req);
QueryItemCollection[] objs = json.Deserialize <QueryItemCollection[]>(reqdata.reqdata);
string DOMAINNAMEIDEN = string.Empty;
string dicttype = string.Empty;
for (int i = 0; i < objs.Length; i++)
{
if (objs[i].queryItemKey.ToUpper() == "DOMAINNAMEIDEN".ToUpper())
{
DOMAINNAMEIDEN = objs[i].queryItemValue;
}
if (objs[i].queryItemKey.ToUpper() == "dicttype".ToUpper())
{
dicttype = objs[i].queryItemValue;
}
}
List <Xxx.Entities.SSY_BIZ_DICT> objResult = this._comSomebiz.GetDicts(DOMAINNAMEIDEN, BizCommon.GetDictType(dicttype), base.envirObj.distManagerParam);
if (UtilitysForT <Xxx.Entities.SSY_BIZ_DICT> .ListHasData(objResult))
{
resdata = this.MakeResponseData("1", string.Empty, json.Serialize(objResult), string.Empty);
}
else
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("noFindData", this.i18nCommonCurrLang), string.Empty, string.Empty);
}
}
catch (Exception ex)
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("findDataErr", this.i18nCommonCurrLang) + ex.Message, string.Empty, string.Empty);
}
return(json.Serialize(resdata));
}
/// <summary>
/// 获取系统字典(某个字典的全部字典项)
/// </summary>
/// <param name="req"></param>
/// <returns></returns>
public string GetFrameDictPager(string req)
{
try
{
reqdata = this.AnaRequestData(req);
QueryItemCollection[] objs = json.Deserialize <QueryItemCollection[]>(reqdata.reqdata);
SSY_PagingParam pager = null;
Xxx.Entities.SSY_FRAME_DICT model = null;
for (int i = 0; i < objs.Length; i++)
{
if (objs[i].queryItemKey.ToUpper() == "SSY_PagingParam".ToUpper())
{
pager = json.Deserialize <SSY_PagingParam>(objs[i].queryItemValue);
}
if (objs[i].queryItemKey.ToUpper() == "SSY_FRAME_DICT".ToUpper())
{
model = json.Deserialize <Xxx.Entities.SSY_FRAME_DICT>(objs[i].queryItemValue);
}
}
List <Xxx.Entities.SSY_FRAME_DICT> objResult = this._comSomebiz.GetFrameDictPager(model, base.envirObj.distManagerParam, pager);
if (UtilitysForT <Xxx.Entities.SSY_FRAME_DICT> .ListHasData(objResult))
{
resdata = this.MakeResponseData("1", string.Empty, json.Serialize(objResult), pager.TotalSize.ToString());
}
else
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("noFindData", this.i18nCommonCurrLang), string.Empty, string.Empty);
}
}
catch (Exception ex)
{
resdata = this.MakeResponseData("0", this.GetI18nLangItem("findDataErr", this.i18nCommonCurrLang) + ex.Message, string.Empty, string.Empty);
}
return(json.Serialize(resdata));
}
public override IMessage Invoke(IMessage msg)
{
#region 日志准备
List <string> opObjPerporty = UtilitysForT <SSY_LOGENTITY> .GetAllColumns(new SSY_LOGENTITY()); //要操作的属性名
List <string> opWherePerporty = new List <string>(); //where条件属性名
opWherePerporty.Add("LOGID");
List <string> mainProperty = new List <string>(); //主键属性名
mainProperty.Add("LOGID");
//string errStr = string.Empty;
List <string> errStr = new List <string>();
List <SSY_LOGENTITY> opList = new List <SSY_LOGENTITY>();
SSY_LOGENTITY logenti = null;
BizExectuteCommon recordLog = new BizExectuteCommon(ManagerSysEnvironment.GetSysEnvironmentSerialize()); //其他工厂记录日志也利用该公共方法
//日志固定部分
string USERNAMES = string.Empty;
if (FrameCommon.SysEnvironment.SysUserDict != null)
{
if (FrameCommon.SysEnvironment.SysUserDict.USERNAME != null)
{
USERNAMES = FrameCommon.SysEnvironment.SysUserDict.USERNAME.ToString();
}
}
string IPS = string.Empty;
if (!string.IsNullOrEmpty(FrameCommon.SysEnvironment.Ips))
{
IPS = FrameCommon.SysEnvironment.Ips;
}
string SYSTEMNAME = string.Empty;
if (!string.IsNullOrEmpty(FrameCommon.SysEnvironment.distManagerParam.DistributeDataNodes[0].Systemname))
{
SYSTEMNAME = FrameCommon.SysEnvironment.distManagerParam.DistributeDataNodes[0].Systemname;
}
#endregion
IMethodCallMessage mcall = (IMethodCallMessage)msg; //劫持方法，准备执行
var resResult = new ReturnMessage(new Exception(), mcall);
#region 获取必要参数
//distributeActionIden 分布式动作识别, 必须存在
//distributeDataNodes 分布式数据节点集合， 必须存在
//distributeDataNode 分布式数据节点参数， 必须存在
//distriActionSql 分布式操作sql集合，必须存在，包括sql正文和参数
//ddnmParams
//singleActionList 单点操作失败集合, out参数 非必须存在，传入空的参数即可
//TODO 检查必须的参数，若不存在不进行执行业务方法，返回执行异常
//获取分布式管理参数
DistributeDataNodeManagerParams distManagerParam = new DistributeDataNodeManagerParams();
for (int i = 0; i < mcall.InArgs.Length; i++)
{
if (mcall.GetInArgName(i).ToUpper() == "ddnmParams".ToUpper())
{
distManagerParam = ((DistributeDataNodeManagerParams)mcall.GetInArg(i));
//SYSTEMNAME = distManagerParam.DistributeDataNodes[0].Systemname;
break;
}
}
//获取分布式动作识别参数
DistributeActionIden distBAC = distManagerParam.DistributeActionIden;
//加载数据节点集合，然后根据节点数量及分布式动作识别初始化分布式数据节点及分布式事务处理
//数据节点集合由服务方法传入
//获取数据节点集合参数
List <SSY_DATANODE_ADDR> dataNodes = distManagerParam.DistributeDataNodes;
//获取数据节点参数
DistributeDataNode ddn = distManagerParam.DistributeDataNode;
//单点操作失败集合，最后要报告给节点中心，out参数
bool permitSingleDataOperation = false; //是否支持单点操作失败后进行报告
List <SSY_DATA_ACTION_TASK> data_action_task = new List <SSY_DATA_ACTION_TASK>();
for (int i = 0; i < mcall.InArgs.Length; i++)
{
if (mcall.GetInArgName(i).ToUpper() == "singleActionList".ToUpper())
{
permitSingleDataOperation = true;
data_action_task = mcall.GetInArg(i) as List <SSY_DATA_ACTION_TASK>;
break;
}
}
#endregion
if (distBAC == DistributeActionIden.Query)
{
//处理数据节点
//distManagerParam.DistributeDataNode
distManagerParam.DistributeDataNode.Connectionstring = string.Format(dataNodes[0].Data_conn, dataNodes[0].Url_addr,
dataNodes[0].Data_user, dataNodes[0].Data_password);
distManagerParam.DistributeDataNode.DbSchema = dataNodes[0].Data_schema;
//只执行一次即可
#region 执行业务方法
try
{
object objRv = mcall.MethodBase.Invoke(this.Target, mcall.Args);
#region 记录业务日志
//执行方法后记录正常业务日志，内容来自方法ListBizLog参数
//若要记录日志，要求该方法必须传入该参数，且名字必须为ListBizLog，内容为要记录的业务日志内容
SSY_LOGENTITY tempLog = null;
for (int i = 0; i < mcall.InArgs.Length; i++)
{
if (mcall.GetInArgName(i).ToUpper() == "ListBizLog".ToUpper())
{
List <SSY_LOGENTITY> dictBizLog = mcall.GetInArg(i) as List <SSY_LOGENTITY>;
for (int j = 0; j < dictBizLog.Count; j++)
{
//遍历记录业务日志
tempLog = dictBizLog[j] as SSY_LOGENTITY;
//获取日志控制,确定是否记录该类日志
if (recordLog.CheckIsRecord(tempLog.DOMAINNAME.ToString(), tempLog.OPTIONNAME.ToString(), distManagerParam))
{
tempLog.LOGID = recordLog.GetID(MakeIDType.YMDHMS_3, string.Empty, null, distManagerParam);
//业务直接使用业务端提交的数据，不在读取框架环境变量，因为登录时这部分数据滞后，导致不能记入日志
//tempLog.USERNAMES = USERNAMES;
//tempLog.IPS = IPS;
//tempLog.SYSTEMNAME = SYSTEMNAME;
opList.Add(tempLog);
}
}
if (opList.Count > 0)
{
//记录日志
bool flag = recordLog.OpBizObjectSingle <SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
}
break;
}
}
#endregion
resResult = new ReturnMessage(objRv, mcall.Args, mcall.Args.Length, mcall.LogicalCallContext, mcall);
}
catch (Exception ex)
{
Common.Utility.RecordLog("工厂 Query 模式发生异常！原因" + ex.Message + ex.Source, this.logpathForDebug, this.isLogpathForDebug);
#region 记录异常日志
if (ex.InnerException != null)
{
//获取日志控制,确定是否记录该类日志
if (recordLog.CheckIsRecord("ExceptionErr", "ExceptionErr", distManagerParam))
{
//处理异常类相关信息
string CLASSNAME = mcall.TypeName;
string METHORDNAME = mcall.MethodName;
//异常时这部分可没有内容
string TABLENAME = "";
string RECORDIDENCOLS = "";
string RECORDIDENCOLSVALUES = "";
string FUNCTIONNAME = "";
logenti = LogCommon.CreateLogDataEnt(LogTypeDomain.ExceptionErr, LogLevelOption.ExecptionErr, recordLog.GetSystemDateTime(distManagerParam),
CLASSNAME, METHORDNAME, LogAction.ExecptionErr, TABLENAME, RECORDIDENCOLS, RECORDIDENCOLSVALUES, USERNAMES, IPS, FUNCTIONNAME,
ex.InnerException.Message, SYSTEMNAME, "");
logenti.LOGID = recordLog.GetID(MakeIDType.YMDHMS_3, string.Empty, null, distManagerParam);
opList.Add(logenti);
if (opList.Count > 0)
{
//记录日志
bool flag = recordLog.OpBizObjectSingle <SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
}
}
resResult = new ReturnMessage(ex.InnerException, mcall);
}
#endregion
resResult = new ReturnMessage(ex, mcall);
}
#endregion
}
else if (distBAC == DistributeActionIden.SingleAction)
{
//数据节点有几个执行几次，单次提交，发现执行异常，将异常报告给节点中心，继续执行，直到完毕
for (int m = 0; m < dataNodes.Count; m++)
{
//ddn.DbFactoryName 数据库工厂取配置文件，目前不考虑同构不同种类的数据库
distManagerParam.DistributeDataNode.Connectionstring = string.Format(dataNodes[m].Data_conn, dataNodes[m].Url_addr, dataNodes[m].Data_user,
dataNodes[m].Data_password);
distManagerParam.DistributeDataNode.DbSchema = dataNodes[m].Data_schema;
#region 执行业务方法
try
{
object objRv = mcall.MethodBase.Invoke(this.Target, mcall.Args);
#region 记录业务日志
//执行方法后记录正常业务日志，内容来自方法ListBizLog参数
//若要记录日志，要求该方法必须传入该参数，且名字必须为ListBizLog，内容为要记录的业务日志内容
SSY_LOGENTITY tempLog = null;
for (int i = 0; i < mcall.InArgs.Length; i++)
{
if (mcall.GetInArgName(i).ToUpper() == "ListBizLog".ToUpper())
{
List <SSY_LOGENTITY> dictBizLog = mcall.GetInArg(i) as List <SSY_LOGENTITY>;
for (int j = 0; j < dictBizLog.Count; j++)
{
//遍历记录业务日志
tempLog = dictBizLog[j] as SSY_LOGENTITY;
//获取日志控制,确定是否记录该类日志
if (recordLog.CheckIsRecord(tempLog.DOMAINNAME.ToString(), tempLog.OPTIONNAME.ToString(), distManagerParam))
{
tempLog.LOGID = recordLog.GetID(MakeIDType.YMDHMS_3, string.Empty, null, distManagerParam);
//业务直接使用业务端提交的数据，不在读取框架环境变量，因为登录时这部分数据滞后，导致不能记入日志
//tempLog.USERNAMES = USERNAMES;
//tempLog.IPS = IPS;
//tempLog.SYSTEMNAME = SYSTEMNAME;
opList.Add(tempLog);
}
}
if (opList.Count > 0)
{
//记录日志
bool flag = recordLog.OpBizObjectSingle <SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
}
break;
}
}
#endregion
resResult = new ReturnMessage(objRv, mcall.Args, mcall.Args.Length, mcall.LogicalCallContext, mcall);
}
catch (Exception ex)
{
SSY_DATA_ACTION_TASK tempDataTask = null;
#region 记录异常日志
if (ex.InnerException != null)
{
//获取日志控制,确定是否记录该类日志
if (recordLog.CheckIsRecord("ExceptionErr", "ExceptionErr", distManagerParam))
{
//处理异常类相关信息
string CLASSNAME = mcall.TypeName;
string METHORDNAME = mcall.MethodName;
//异常时这部分可没有内容
string TABLENAME = "";
string RECORDIDENCOLS = "";
string RECORDIDENCOLSVALUES = "";
string FUNCTIONNAME = "";
logenti = LogCommon.CreateLogDataEnt(LogTypeDomain.ExceptionErr, LogLevelOption.ExecptionErr, recordLog.GetSystemDateTime(distManagerParam),
CLASSNAME, METHORDNAME, LogAction.ExecptionErr, TABLENAME, RECORDIDENCOLS, RECORDIDENCOLSVALUES, USERNAMES, IPS, FUNCTIONNAME,
ex.InnerException.Message, SYSTEMNAME, "");
logenti.LOGID = recordLog.GetID(MakeIDType.YMDHMS_3, string.Empty, null, distManagerParam);
opList.Add(logenti);
if (opList.Count > 0)
{
//记录日志
bool flag = recordLog.OpBizObjectSingle <SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
}
}
if (permitSingleDataOperation)
{
#region 获取失败操作sql
//获取失败记录，以便将任务报告给节点中心
//获取操作sql List<DistActionSql> DistriActionSqlParams
for (int task = 0; task < distManagerParam.DistriActionSqlParams.Count; task++)
{
tempDataTask = new SSY_DATA_ACTION_TASK();
tempDataTask.Action_sql = distManagerParam.DistriActionSqlParams[task].ActionSqlText;
string tempSqlParamSeq = string.Empty;
bool temddddd = JsonSerializer.Serialize(distManagerParam.DistriActionSqlParams[task].ActionSqlTextParams, out tempSqlParamSeq);
//保存sql参数序列化结果
tempDataTask.Action_sql_params = tempSqlParamSeq;
tempDataTask.Data_real_conn = ddn.Connectionstring;
data_action_task.Add(tempDataTask);
}
//执行完毕后，清除本次的sql记录
distManagerParam.DistriActionSqlParams.Clear();
//TODO 报告单点异常给节点中心，暂时不支持，后续扩展
#endregion
}
}
#endregion
continue; //继续执行
}
#endregion
}
}
else if (distBAC == DistributeActionIden.TransAction)
{
try
{
//分布式事务执行， 按数据节点数量执行，同步提交
using (var ts = new System.Transactions.TransactionScope(System.Transactions.TransactionScopeOption.Required, TimeSpan.FromHours(1)))
{
for (int m = 0; m < dataNodes.Count; m++)
{
//ddn.DbFactoryName 数据库工厂取配置文件，目前不考虑同构不同种类的数据库
distManagerParam.DistributeDataNode.Connectionstring = string.Format(dataNodes[m].Data_conn, dataNodes[m].Url_addr, dataNodes[m].Data_user,
dataNodes[m].Data_password);
distManagerParam.DistributeDataNode.DbSchema = dataNodes[m].Data_schema;
#region 执行业务方法
object objRv = mcall.MethodBase.Invoke(this.Target, mcall.Args);
#region 记录业务日志
//执行方法后记录正常业务日志，内容来自方法ListBizLog参数
//若要记录日志，要求该方法必须传入该参数，且名字必须为ListBizLog，内容为要记录的业务日志内容
SSY_LOGENTITY tempLog = null;
for (int i = 0; i < mcall.InArgs.Length; i++)
{
if (mcall.GetInArgName(i).ToUpper() == "ListBizLog".ToUpper())
{
List <SSY_LOGENTITY> dictBizLog = mcall.GetInArg(i) as List <SSY_LOGENTITY>;
for (int j = 0; j < dictBizLog.Count; j++)
{
//遍历记录业务日志
tempLog = dictBizLog[j] as SSY_LOGENTITY;
//获取日志控制,确定是否记录该类日志
if (recordLog.CheckIsRecord(tempLog.DOMAINNAME.ToString(), tempLog.OPTIONNAME.ToString(), distManagerParam))
{
tempLog.LOGID = recordLog.GetID(MakeIDType.YMDHMS_3, string.Empty, null, distManagerParam);
//业务直接使用业务端提交的数据，不在读取框架环境变量，因为登录时这部分数据滞后，导致不能记入日志
//tempLog.USERNAMES = USERNAMES;
//tempLog.IPS = IPS;
//tempLog.SYSTEMNAME = SYSTEMNAME;
opList.Add(tempLog);
}
}
//这里事物不能同时记录日志，需要放到业务方法提交完成后单独记录日志
if (opList.Count > 0)
{
//记录日志
bool flag = recordLog.OpBizObjectSingle <SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
}
break;
}
}
#endregion
resResult = new ReturnMessage(objRv, mcall.Args, mcall.Args.Length, mcall.LogicalCallContext, mcall);
#endregion
}
ts.Complete();
ts.Dispose();
}
//同时记录日志，因为日志记录去掉事物方式
////恢复事物默认标识
//distManagerParam.DistributeActionIden = DistributeActionIden.Query;
////启用事物日志需要独立记录，不能和业务操作混在一个事物里
//for (int m = 0; m < dataNodes.Count; m++)
//{
// //ddn.DbFactoryName 数据库工厂取配置文件，目前不考虑同构不同种类的数据库
// distManagerParam.DistributeDataNode.Connectionstring = string.Format(dataNodes[m].Data_conn, dataNodes[m].Url_addr, dataNodes[m].Data_user,
// dataNodes[m].Data_password);
// distManagerParam.DistributeDataNode.DbSchema = dataNodes[m].Data_schema;
// if (opList.Count > 0)
// {
// //记录日志
// bool flag = recordLog.OpBizObjectSingle<SSY_LOGENTITY>(opList, opObjPerporty, opWherePerporty, mainProperty, errStr, distManagerParam);
// }
//}
}
catch (Exception ex)
{
Common.Utility.RecordLog("工厂 TransAction 模式发生异常！原因" + ex.Message + ex.Source, this.logpathForDebug, this.isLogpathForDebug);
}
}
//最终返回结果,循环处理数据节点时，只返回最后一个执行成功的数据节点的执行情况
return(resResult);
}
