public object Print(HttpContext context)
{
string data = context.Request["data"];
ExecuteBcfMethodParam param = JsonConvert.DeserializeObject <ExecuteBcfMethodParam>(data);
BillService service = new BillService();
return(service.Print(param));
}
private object BatchMethod(HttpContext context)
{
string data = context.Request["data"];
BillService service = new BillService();
ExecuteBcfMethodParam param = JsonConvert.DeserializeObject <ExecuteBcfMethodParam>(data);
return(service.BatchExecBcfMethod1(param));
}
public object BatchExportAllData(HttpContext context)
{
string data = context.Request["data"];
//MDictionary<string, string> dic = new MDictionary<string, string>();
//if (!string.IsNullOrEmpty(data))
//{
// dic = JsonConvert.DeserializeObject<MDictionary<string, string>>(data);
//}
//string handle = dic["handle"];
//string progId = dic["progId"];
//List<object[]> batchParams = new List<object[]>() { new object[] { "RJ180527011" } };
ExecuteBcfMethodParam param = JsonConvert.DeserializeObject <ExecuteBcfMethodParam>(data);
BillService service = new BillService();
return(service.ExportAllData1(param.Handle, param.ProgId, ""));
}
private object processRequsetExecuteMethod(HttpContext context)
{
string data = context.Request["data"];
//MDictionary<string, string> meta = new MDictionary<string, string>();
//if (!string.IsNullOrEmpty(data))
//{
// meta = JsonConvert.DeserializeObject<MDictionary<string, string>>(data);
//}
BillService service = new BillService();
ExecuteBcfMethodParam param = JsonConvert.DeserializeObject <ExecuteBcfMethodParam>(data);
//return service.ExecuteMethod(ns, cn, ay, method, meta);
//ExecuteBcfMethodParam param = new ExecuteBcfMethodParam()
//{
// ProgId = context.Request.Form["ProgId"],
// MethodName = context.Request.Form["MethodName"],
// MethodParam = JsonConvert.DeserializeObject<string[]>(context.Request.Form["MethodParam"])
//};
return(service.ExecuteBcfMethod1(param));
}
/// <summary>
/// 同步数据到子站点
/// </summary>
protected virtual void CallSynchroData()
{
if (this.DataSet.Tables.Contains(LibFuncPermission.SynchroDataSettingTableName) == false || CrossSiteHelper.ExistAxpSyncDataInfo == false ||
CrossSiteHelper.ExistLinkSiteTable == false)
{
return;
}
if (this.IsCrossSiteCall)
{
return; //本身已经是跨站点调用的不通过业务的数据变更触发数据同步，而是由跨站调用集中处理
}
BcfSyncConfig syncConfig = this.Template.FuncPermission.SyncConfig; //同步配置
DataTable syncDt = this.DataSet.Tables[LibFuncPermission.SynchroDataSettingTableName];
syncDt.AcceptChanges();
CrossSiteHelper.UpdateSyncDataSetting(syncDt);
List <string> siteIdList = new List <string>();
DataRow[] syncRows = syncDt.Select(string.Format("ISSYNCTO = 1"));
if (syncRows != null && syncRows.Length > 0)
{
foreach (DataRow row in syncRows)
{
siteIdList.Add(LibSysUtils.ToString(row["SITEID"]));
}
}
else
{
return;//因为同步配置会在获取到Dataset时就填充好（上一层用户配置或者默认的可向其同步的子站点）， 如果从DataSet的同步信息从表配置中未筛选到同步信息行，则说明不需要同步了。
}
LibSyncDataOpType opType = LibSyncDataOpType.Modify;
//同步数据到站点
Dictionary <string, LinkSiteInfo> linkSites = CrossSiteHelper.GetLinkSites(siteIdList.ToArray(), true);
if (linkSites != null && linkSites.Count > 0)
{
DataRow masterRow = this.DataSet.Tables[0].Rows[0];
Dictionary <string, object> mainRowPks = new Dictionary <string, object>();
string internalId = LibSysUtils.ToString(masterRow["INTERNALID"]);
if (masterRow.RowState == DataRowState.Added || this.BillAction == BillAction.Delete)
{
foreach (DataColumn column in this.DataSet.Tables[0].PrimaryKey)
{
mainRowPks[column.ColumnName] = masterRow[column.ColumnName];
}
if (this.BillAction == BillAction.Delete)
{
opType = LibSyncDataOpType.Delete;
}
else
{
opType = LibSyncDataOpType.AddNew;
}
}
else
{
foreach (DataColumn column in this.DataSet.Tables[0].PrimaryKey)
{
mainRowPks[column.ColumnName] = masterRow[column.ColumnName, DataRowVersion.Original];
}
opType = LibSyncDataOpType.Modify;
}
//移除虚表
List <string> toRemoveTable = new List <string>();
//子表或子子表中删除行的信息
Dictionary <string, LibChangeRecord> subDeleteChanges = DataSetManager.GetChangeRecord(this.DataSet);
if (subDeleteChanges != null && subDeleteChanges.Count > 0)
{
//只保留子表的删除行信息
foreach (string tableName in subDeleteChanges.Keys)
{
if (tableName == this.DataSet.Tables[0].TableName)
{
subDeleteChanges[tableName].Remove.Clear();
}
subDeleteChanges[tableName].Add.Clear();
subDeleteChanges[tableName].Modif.Clear();
}
}
DataSet toSendDataset = this.DataSet.Copy();
foreach (DataTable dt in toSendDataset.Tables)
{
if (dt.ExtendedProperties.ContainsKey(TableProperty.IsVirtual) && (bool)dt.ExtendedProperties[TableProperty.IsVirtual])
{
toRemoveTable.Add(dt.TableName);
}
if (dt.TableName.Equals(this.DataSet.Tables[0].TableName) == false && syncConfig != null && syncConfig.NonSyncSubTables.Contains(dt.TableName))
{
//非主表且是不需要同步的子表,则清空其中的数据
dt.Clear();
if (subDeleteChanges.Keys.Contains(dt.TableName))
{
subDeleteChanges.Remove(dt.TableName);
}
}
}
toRemoveTable.ForEach(tableName => { toSendDataset.Tables.Remove(tableName); });
toSendDataset.AcceptChanges();
//存在可访问的从站，则合并获取从站的系统消息数据
ExecuteBcfMethodParam callParams = new ExecuteBcfMethodParam()
{
ProgId = this.ProgId,
MethodName = "SynchroData",
MethodParam = ExecuteBcfMethodParam.ConvertMethodParams(new object[] { this.BillAction, mainRowPks, subDeleteChanges, this.ExtendBcfParam, toSendDataset }),
TimeoutMillSecs = 30000, //设置超时时间，单位毫秒
IsSynchroDataCall = true
};
try
{
//阻塞模式调用远程方法
Dictionary <string, ExecuteBcfMethodResult> dicRets = CrossSiteHelper.CrossSiteBcfCall(this.Handle.Handle, linkSites.Keys.ToList(), callParams, this.DataAccess);
if (dicRets == null || dicRets.Keys.Count == 0)
{
return;
}
string retStr = string.Empty;
string syncInfo = string.Empty;
foreach (string key in dicRets.Keys)
{
syncInfo = string.Empty;
if (dicRets[key] != null && dicRets[key].Messages != null && dicRets[key].Messages.Count > 0)
{
dicRets[key].Messages.ForEach(msg =>
{
syncInfo += msg.Message + "\r\n";
msg.Message = string.Format("同步到站点:{0},消息:{1}", linkSites[key].ShortName, msg.Message);
this.ManagerMessage.AddMessage(msg);
});
}
CrossSiteHelper.AddSyncDataRecord(new SyncDataInfo()
{
ProgId = this.ProgId,
InternalId = internalId,
BillNo = (mainRowPks.Count > 0) ? Convert.ToString(mainRowPks.Values.First()) : "",
UserId = this.Handle.UserId,
SiteId = key,
SyncTime = DateTime.Now,
SyncOp = opType,
SyncState = dicRets[key].Messages.HasError() ? LibSyncDataState.SyncError : LibSyncDataState.Synced,
SyncInfo = syncInfo
});
}
}
catch (Exception exp)
{
LibCommUtils.AddOutput(@"Error\CrossSiteCall", string.Format("CallSynchroData error:{0}\r\nStacktrace:{1}", exp.Message, exp.StackTrace));
this.ManagerMessage.AddMessage(LibMessageKind.SysException, string.Format("同步数据到站点异常：{0}", exp.Message));
}
}
}
/// <summary>
/// 向多个目标站点发起跨站Bcf方法调用请求。
/// 此方法执行时将方法请求放入消息队列，放入成功即返回。
/// 如果返回的字符串为空表示放入成功，否则表示错误提示。
/// 如果参数有误会抛出异常
/// </summary>
/// <param name="handle">当前用户的标识Handle</param>
/// <param name="linkSiteIds">目标站点代码列表</param>
/// <param name="callParams">包含SSO令牌信息、请求方法、请求参数等callParams</param>
/// <returns>如果返回的字符串为空表示放入队列成功，否则表示错误提示。</returns>
public static string CrossSiteBcfCallQueue(string handle, List <string> linkSiteIds, ExecuteBcfMethodParam callParams)
{
return(string.Empty);
}
/// <summary>
/// 向多个目标站点发起跨站Bcf方法调用请求。
/// 此方法执行时会阻塞
/// 如果有向多个站点请求执行，会同时（并发线程）向多个站点发起请求，请求完毕后再汇总执行结果返回
/// 如果参数有误会抛出异常
/// </summary>
/// <param name="handle">当前用户的标识Handle</param>
/// <param name="linkSiteIds">目标站点代码列表</param>
/// <param name="callParams">包含SSO令牌信息、请求方法、请求参数等callParams</param>
/// <param name="dataAccess">可选参数：数据库访问器。如果调用时使用了数据库事务，需要将开启了事务的数据库访问器传递进来，避免在本方法中查询数据库时因事务锁表而死锁。</param>
/// <returns>返回执行结果字典，键值为目标站点Id，值为执行结果</returns>
public static Dictionary <string, ExecuteBcfMethodResult> CrossSiteBcfCall(string handle, List <string> linkSiteIds, ExecuteBcfMethodParam callParams, LibDataAccess dataAccess = null)
{
if (string.IsNullOrEmpty(handle) || linkSiteIds == null || linkSiteIds.Count == 0 || callParams == null)
{
throw new ArgumentNullException("handle、linkSiteIds、callParams", "检查参数时发现有空参数。");
}
LibHandle libHandle = LibHandleCache.Default.GetCurrentHandle(handle) as LibHandle;
if (libHandle == null)
{
throw new Exception("该账户未登录。");
}
callParams.IsCrossSiteCall = true;
callParams.UserId = libHandle.UserId;
callParams.Token = GetToken(libHandle, 30 * 1000, dataAccess);
if (string.IsNullOrEmpty(callParams.Token))
{
throw new Exception("获取跨站访问令牌信息失败。");
}
Dictionary <string, string> urls = GetSiteUrls(linkSiteIds);
if (urls == null || urls.Count == 0)
{
throw new Exception("查找到的站点Url为空。");
}
Dictionary <string, ExecuteBcfMethodResult> dicResults = new Dictionary <string, ExecuteBcfMethodResult>();
string errorInfo = string.Empty;
List <Task> tasks = new List <Task>();
foreach (string siteId in urls.Keys)
{
var url = urls[siteId];
if (string.IsNullOrEmpty(url))
{
continue;
}
url = string.Format("{0}/billSvc/invorkBcf", url);
var task = Task.Factory.StartNew(() =>
{
try
{
var sendObj = new { param = callParams };//参数名必须一致
dynamic ret = LibNetUtils.HttpPostCall <dynamic>(url, sendObj, out errorInfo, callParams.TimeoutMillSecs);
if (ret != null)
{
ExecuteBcfMethodResult result = JsonConvert.DeserializeObject <ExecuteBcfMethodResult>((string)ret.ExecuteBcfMethodResult);
lock (dicResults)
{
dicResults.Add(siteId, result);
}
}
else if (string.IsNullOrEmpty(errorInfo) == false)
{
ExecuteBcfMethodResult result = new ExecuteBcfMethodResult();
result.Messages.Add(new LibMessage()
{
MessageKind = LibMessageKind.Error,
Message = string.Format("执行跨站请求出现异常:{0}", errorInfo)
});
lock (dicResults)
{
dicResults.Add(siteId, result);
}
}
}
catch (Exception exp)
{
LibCommUtils.AddOutput(@"Error\CrossSiteCall", string.Format("CheckSSOLoginState error:{0}\r\nStacktrace:{1}", exp.Message, exp.StackTrace));
ExecuteBcfMethodResult result = new ExecuteBcfMethodResult();
result.Messages.Add(new LibMessage()
{
MessageKind = LibMessageKind.Error,
Message = string.Format("执行跨站请求出现异常:{0}", exp.Message)
});
lock (dicResults)
{
dicResults.Add(siteId, result);
}
}
});
tasks.Add(task);
}
//循环检查等待所有task都执行完毕
int waitMillSecs = callParams.TimeoutMillSecs + 1000;//多等一秒
int waitCount = 0;
//等待超时时间到来，或者全部已经执行完毕
while (waitCount < waitMillSecs)
{
bool isAllFinished = tasks.All(t =>
{
return(t.IsCompleted);
});
if (isAllFinished)
{
break;
}
waitCount += 100;
Thread.Sleep(100);
}
return(dicResults);
}
