/// <summary>
/// 验证某个用户是否有访问WorkItem的权限
/// </summary>
/// <param name="WorkItem">工作项</param>
/// <param name="UserValidator">用户ID</param>
/// <param name="AgencyManager">委托关系</param>
/// <returns>如果具备权限，那么返回true；否则返回false。</returns>
public static bool ValidateWorkItemAuth(WorkItem.WorkItem WorkItem, UserValidator UserValidator, WorkItem.IAgencyManager AgencyManager)
{
if (UserValidator.ValidateAdministrator())
{// 判定当前用户是否超级管理员
return(true);
}
else if (WorkItem.Participant == UserValidator.UserID ||
WorkItem.Forwarder == UserValidator.UserID ||
WorkItem.Delegant == UserValidator.UserID ||
WorkItem.Finisher == UserValidator.UserID)
{// 判定当前用户是否和当前工作任务相关
return(true);
}
else if (UserValidator.ValidateWFInsView(WorkItem.WorkflowCode, WorkItem.Participant))
{// 判定当前用户是否可以查看指定流程模板的组织
return(true);
}
// 已经不允许设置委托发起
//else if (
// WorkItem.Participant == WorkItem.Originator &&
// AgencyManager.CheckOriginateAgency(WorkItem.Participant, UserValidator.UserID, WorkItem.WorkflowCode))
//{
// // 如果当前用户跟工作项的参与者是委托关系，也有权限
// return true;
//}
return(false);
}
///// <summary>
///// 验证锁定。如果打开即需要锁定，那么尝试锁定，并返回尝试结果；否则，检查是否有被其他工作项锁定，如果有则返回false，否则返回true。
///// </summary>
///// <param name="Enviroment"></param>
///// <param name="Message"></param>
///// <returns></returns>
//public static bool ValidateLockLevel(SheetEnviroment Enviroment, ref string Message)
//{
// return ValidateLockLevel(Enviroment.Engine,
// Enviroment.UserValidator,
// Enviroment.WorkflowActivity,
// Enviroment.WorkItem,
// ref Message);
//}
/// <summary>
///
/// </summary>
/// <param name="Engine"></param>
/// <param name="UserValidator"></param>
/// <param name="WorkflowActivity"></param>
/// <param name="WorkItem"></param>
/// <param name="Message"></param>
/// <returns></returns>
public static bool ValidateLockLevel(IEngine Engine, UserValidator UserValidator,
Activity WorkflowActivity, WorkItem.WorkItem WorkItem, ref string Message)
{
WorkflowTemplate.ParticipativeActivity task = WorkflowActivity as WorkflowTemplate.ParticipativeActivity;
if (task != null && task.LockPolicy == OThinker.H3.WorkflowTemplate.LockPolicy.Open)
{
return(TryLock(Engine, UserValidator, WorkflowActivity, WorkItem, ref Message));
}
else if (!WorkItem.IsLocked)
{
// 没有被其他任何人锁定
return(true);
}
else
{
string locker = Engine.WorkItemManager.GetLocker(WorkItem.InstanceId, WorkItem.TokenId);
string lockerFullName = Engine.Organization.GetName(locker);
Message = string.Format(
Configs.Global.ResourceManager.GetString("SheetUtility_LockedBy"),
lockerFullName);
if (task.LockLevel == WorkflowTemplate.LockLevel.Mono) // 禁止多人编辑表单
{
return(false);
}
else // 当多人编辑表单时，只是给出提示
{
return(true);
}
}
}
public void OnUpdated(IEngine Engine, WorkItem.WorkItem WorkItem)
{
string url = Engine.SettingManager.GetCustomSetting("HttpPostUpdatedURL");
if (!string.IsNullOrEmpty(url))
{
Engine.LogWriter.Write("EventHandler OnUpdated " + WorkItem.ObjectID);
hh.GetWebRequest(url + "/" + WorkItem.ObjectID);
}
}
public string GetViewSheetUrl(
WorkItem.WorkItem WorkItem,
BizSheet Sheet,
SheetMode SheetMode,
bool IsMobile)
{
string baseUrl = GetSheetBaseUrl(SheetMode.View, IsMobile, Sheet);
baseUrl += SheetEnviroment.Param_Mode + "=" + SheetMode + "&";
baseUrl += SheetEnviroment.Param_WorkItemID + "=" + WorkItem.WorkItemID + "&";
return(baseUrl);
}
/// <summary>
/// 获取待办任务的链接地址
/// </summary>
/// <param name="WorkItem"></param>
/// <param name="Sheet"></param>
/// <param name="IsMobile"></param>
/// <returns></returns>
public string GetWorkSheetUrl(
WorkItem.WorkItem WorkItem,
BizSheet Sheet,
bool IsMobile)
{
if (WorkItem == null)
{
return(null);
}
string baseUrl = string.Empty;
baseUrl = GetSheetBaseUrl(SheetMode.Work, IsMobile, Sheet);
baseUrl += SheetEnviroment.Param_Mode + "=" + SheetMode.Work + "&";
if (WorkItem != null)
{
baseUrl += SheetEnviroment.Param_WorkItemID + "=" + WorkItem.WorkItemID + "&";
}
return(baseUrl);
}
private void AppendComment(WorkItem.WorkItem Item, OThinker.Data.BoolMatchValue Approval, string Comment)
{
WorkflowTemplate.PublishedWorkflowTemplate workflow = GetWorkflowTemplate(Item.WorkflowCode, Item.WorkflowVersion);
// 审批字段
string approvalDataItem = null;
if (workflow != null)
{
PublishedWorkflowTemplate workflowTemplate = this.Engine.WorkflowManager.GetPublishedTemplate(Item.WorkflowCode, Item.WorkflowVersion);
OThinker.H3.DataModel.BizObjectSchema schema = GetSchema(workflowTemplate.BizObjectSchemaCode);
approvalDataItem = workflow.GetDefaultCommentDataItem(schema, Item.ActivityCode);
}
if (approvalDataItem != null)
{
// 创建审批
//TODO:此处待修改，Item.BizObjectId不存在,通过 OT_InstanceContext获取
Instance.InstanceContext InstanceContext = this.Engine.InstanceManager.GetInstanceContext(Item.InstanceId);
string BizObjectId = InstanceContext == null ? string.Empty : InstanceContext.BizObjectId;
Data.Comment comment = new Data.Comment();
comment.Activity = Item.ActivityCode;
comment.Approval = Approval;
comment.CreatedTime = System.DateTime.Now;
comment.DataField = approvalDataItem;
comment.InstanceId = Item.InstanceId;
comment.OUName = this.Engine.Organization.GetName(this.Engine.Organization.GetParent(Item.Participant));
comment.Text = Comment;
comment.TokenId = Item.TokenId;
comment.UserID = Item.Participant;
comment.UserName = Item.ParticipantName;
//comment.BizObjectId = Item.BizObjectId;
comment.BizObjectId = BizObjectId;
comment.BizObjectSchemaCode = Item.WorkflowCode;
this.Engine.BizObjectManager.AddComment(comment);
}
}
/// <summary>
/// 创建一个新的流程实例
/// </summary>
/// <param name="Engine">引擎实例对象</param>
/// <param name="BizObjectId">业务对象ID</param>
/// <param name="Workflow">流程模板</param>
/// <param name="Schema">数据模型结构</param>
/// <param name="InstanceId">流程实例ID</param>
/// <param name="Originator">发起人</param>
/// <param name="OriginatedJob">发起人使用的角色</param>
/// <param name="InstanceName">流程实例名称</param>
/// <param name="Priority">紧急程度</param>
/// <param name="OriginatingInstance">发起流程的事件接口</param>
/// <param name="ParameterTable">发起流程的参数表</param>
/// <param name="Request">HttpRequest</param>
/// <param name="WorkItemId">返回工作任务ID</param>
/// <param name="ErrorMessage">错误消息</param>
/// <param name="FinishStartActivity">是否结束第一个活动</param>
/// <returns>返回创建流程是否成功</returns>
public static bool OriginateInstance(
IEngine Engine,
string BizObjectId,
WorkflowTemplate.PublishedWorkflowTemplate Workflow,
DataModel.BizObjectSchema Schema,
ref string InstanceId,
string Originator,
string OriginatedJob,
string InstanceName,
Instance.PriorityType Priority,
EventHandler <OriginateInstanceEventArgs> OriginatingInstance,
Dictionary <string, object> ParameterTable,
System.Web.HttpRequest Request,
ref string WorkItemId,
ref string ErrorMessage,
bool FinishStartActivity)
{
if (Workflow == null)
{
ErrorMessage = Configs.Global.ResourceManager.GetString("SheetUtility_WorkflowNotExist");
return(false);
}
// 创建流程实例
InstanceId = AppUtility.Engine.InstanceManager.CreateInstance(
BizObjectId,
Workflow.WorkflowCode,
Workflow.WorkflowVersion,
InstanceId,
InstanceName,
Originator,
OriginatedJob,
false,
Instance.InstanceContext.UnspecifiedID,
null,
Instance.Token.UnspecifiedID);
// 设置紧急程度为普通
OThinker.H3.Messages.MessageEmergencyType emergency = Messages.MessageEmergencyType.Normal;
// 如果是发起后需要用户填写表单的模式，则紧急程度为高
if (Workflow.StartWithSheet)
{
emergency = OThinker.H3.Messages.MessageEmergencyType.High;
}
// 解析流程参数
System.Collections.Generic.Dictionary <string, object> instanceParams = ParameterTable;
if (instanceParams == null)
{
instanceParams = new Dictionary <string, object>();
}
// Http Request Parameters
ParseRequestParams(Request, Workflow, Schema, instanceParams);
// 调用发起事件
OriginateInstanceEventArgs originateArgs = new OriginateInstanceEventArgs(InstanceId, instanceParams);
if (OriginatingInstance != null)
{
OriginatingInstance(OriginatingInstance, originateArgs);
}
WorkItemId = Guid.NewGuid().ToString().ToLower();
// 启动流程的消息
OThinker.H3.Messages.StartInstanceMessage startInstanceMessage
= new OThinker.H3.Messages.StartInstanceMessage(
emergency,
InstanceId,
WorkItemId,
originateArgs == null ? null : originateArgs.InstanceParameterTable.Count == 0 ? null : originateArgs.InstanceParameterTable,
Priority,
false,
OThinker.H3.Instance.Token.UnspecifiedID,
null);
Engine.InstanceManager.SendMessage(startInstanceMessage);
if (!Workflow.StartWithSheet)
{
// 返回工作项为空
WorkItemId = H3.WorkItem.WorkItem.NullWorkItemID;
return(true);
}
// 查找新创建的工作项
string[] jobs = null;
for (int triedTimes = 0; triedTimes < 30; triedTimes++)
{
System.Threading.Thread.Sleep(500);
if (AppUtility.Engine.WorkItemManager.GetWorkItem(WorkItemId) != null)
{
WorkItem.WorkItem item = AppUtility.Engine.WorkItemManager.GetWorkItem(WorkItemId);
jobs = new string[] { item.WorkItemID };
break;
}
}
if (jobs == null || jobs.Length == 0)
{
ErrorMessage = Configs.Global.ResourceManager.GetString("SheetUtility_OriginateFailed");
WorkItemId = OThinker.H3.WorkItem.WorkItem.NullWorkItemID;
return(false);
}
else
{
// 返回新创建的工作项
WorkItemId = jobs[0];
if (FinishStartActivity)
{
OThinker.H3.WorkItem.WorkItem item = Engine.WorkItemManager.GetWorkItem(WorkItemId);
// 结束掉第一个活动
Engine.WorkItemManager.FinishWorkItem(
WorkItemId,
Originator,
Request.Browser.IsMobileDevice ? WorkItem.AccessPoint.Mobile : WorkItem.AccessPoint.Web,
OriginatedJob,
OThinker.Data.BoolMatchValue.Unspecified,
null,
null,
WorkItem.ActionEventType.Forward,
WorkItem.WorkItem.UnspecifiedActionButtonType);
OThinker.H3.Messages.AsyncEndMessage endMessage = new Messages.AsyncEndMessage(
Messages.MessageEmergencyType.Normal,
InstanceId,
item.ActivityCode,
item.TokenId,
OThinker.Data.BoolMatchValue.Unspecified,
false,
OThinker.Data.BoolMatchValue.Unspecified,
true,
null);
Engine.InstanceManager.SendMessage(endMessage);
}
return(true);
}
}
///// <summary>
///// 验证锁定级别
///// </summary>
///// <param name="Enviroment"></param>
///// <param name="Message"></param>
///// <returns></returns>
//public static bool TryLock(SheetEnviroment Enviroment, ref string Message)
//{
// return TryLock(Enviroment.Engine, Enviroment.UserValidator, Enviroment.WorkflowActivity, Enviroment.WorkItem, ref Message);
//}
/// <summary>
/// 尝试锁定表单
/// </summary>
/// <param name="Engine"></param>
/// <param name="UserValidator"></param>
/// <param name="WorkflowActivity"></param>
/// <param name="WorkItem"></param>
/// <param name="Message"></param>
/// <returns></returns>
public static bool TryLock(IEngine Engine,
UserValidator UserValidator,
Activity WorkflowActivity,
WorkItem.WorkItem WorkItem,
ref string Message)
{
WorkItem.LockResult result = OThinker.H3.WorkItem.LockResult.Success;
// 解析锁定的策略
bool cancelOther = false;
bool onlyWarning = false;
WorkflowTemplate.ParticipativeActivity task = (WorkflowTemplate.ParticipativeActivity)WorkflowActivity;
if (task != null)
{
switch (task.LockLevel)
{
case WorkflowTemplate.LockLevel.Warning:
onlyWarning = true;
cancelOther = false;
break;
case WorkflowTemplate.LockLevel.Mono:
onlyWarning = false;
cancelOther = false;
break;
case OThinker.H3.WorkflowTemplate.LockLevel.CancelOthers:
// 需要单独锁定
onlyWarning = false;
cancelOther = true;
break;
default:
throw new NotImplementedException();
}
}
if (WorkItem.IsLocking)
{
// 已经执行过了锁定
result = H3.WorkItem.LockResult.LockedAlready;
}
else if (WorkItem.IsLocked)
{
// 已经被锁定了
result = H3.WorkItem.LockResult.LockedByOther;
}
else
{
// 需要单独锁定
result = Engine.WorkItemManager.LockActivity(WorkItem.WorkItemID, UserValidator.UserID, cancelOther);
}
switch (result)
{
case OThinker.H3.WorkItem.LockResult.NoNeed:
case OThinker.H3.WorkItem.LockResult.LockedAlready:
return(true);
case OThinker.H3.WorkItem.LockResult.Success:
WorkItem.IsLocking = true;
Message = Configs.Global.ResourceManager.GetString("SheetUtility_LockSucceed");
return(true);
case OThinker.H3.WorkItem.LockResult.LockedByOther:
// 找到当前的所有正在进行操作的用户
string locker = Engine.WorkItemManager.GetLocker(WorkItem.InstanceId, WorkItem.TokenId);
// 生成提示
Message = string.Format(
Configs.Global.ResourceManager.GetString("SheetUtility_LockedBy"),
Engine.Organization.GetName(locker)
//Engine.Organization.GetFullName(locker)
);
// 如果锁定级别是提示，那么仍然返回true，表示验证成功；否则返回false，表示验证失败
if (onlyWarning)
{
return(true);
}
else
{
return(false);
}
default:
throw new NotImplementedException();
}
}
/// <summary>
/// 验证权限
/// </summary>
/// <param name="UserValidator"></param>
/// <param name="SheetDataType"></param>
/// <param name="IsOriginateMode"></param>
/// <param name="SchemaCode"></param>
/// <param name="BizObject"></param>
/// <param name="SheetMode"></param>
/// <param name="WorkflowCode"></param>
/// <param name="WorkItem"></param>
/// <param name="InstanceContext"></param>
/// <returns></returns>
public static bool ValidateAuthorization(
UserValidator UserValidator,
SheetDataType SheetDataType,
bool IsOriginateMode,
string SchemaCode,
DataModel.BizObject BizObject,
SheetMode SheetMode,
string WorkflowCode,
WorkItem.WorkItem WorkItem,
WorkItem.CirculateItem CirculateItem,
Instance.InstanceContext InstanceContext)
{
if (UserValidator.ValidateAdministrator())
{
return(true);
}
// 业务对象表单
else if (SheetDataType == SheetDataType.BizObject)
{
if (IsOriginateMode)
{
return(UserValidator.ValidateBizObjectAdd(SchemaCode, null, UserValidator.UserID));
}
else
{
if (UserValidator.ValidateOrgAdmin(BizObject.OwnerId))
{
return(true);
}
return(UserValidator.ValidateBizObjectAdmin(SchemaCode, null, BizObject.OwnerId));
}
}
else
{
switch (SheetMode)
{
case SheetMode.Originate:
return(UserValidator.ValidateCreateInstance(WorkflowCode));
case SheetMode.View:
case SheetMode.Print:
if (WorkItem != null &&
ValidateWorkItemAuth(WorkItem, UserValidator, UserValidator.Engine.AgencyManager))
{
return(true);
}
else if (CirculateItem != null && ValidateCirculateItemAuth(CirculateItem, UserValidator))
{
return(true);
}
else if (UserValidator.ValidateWFInsView(WorkflowCode, InstanceContext.Originator))
{
// 是否允许查看这个流程模板的所有实例
return(true);
}
else
{
// 判定用户是否参与过流程实例
string[] workItems = UserValidator.Engine.Query.QueryWorkItems(
new string[] { InstanceContext.InstanceId },
new string[] { UserValidator.UserID },
DateTime.Now.AddYears(-100),
DateTime.Now.AddDays(1),
H3.WorkItem.WorkItemState.Unspecified,
OThinker.H3.WorkItem.WorkItem.NullWorkItemID);
if (workItems != null && workItems.Length > 0)
{
return(true);
}
return(false);
}
case SheetMode.Work:
if (WorkItem != null)
{
return(ValidateWorkItemAuth(WorkItem, UserValidator, UserValidator.Engine.AgencyManager));
}
else
{
return(ValidateCirculateItemAuth(CirculateItem, UserValidator));
}
default:
throw new NotImplementedException();
}
}
}
public JsonResult ImportSimulation(string SquenceNo, string WorkflowCode)
{
return(ExecuteFunctionRun(() => {
ActionResult result = new ActionResult(false, "");
DataModel.BizObjectSchema Schema = null;
OThinker.H3.WorkflowTemplate.WorkflowClause Clause = null;
EditSimulationViewModel model = new EditSimulationViewModel();
model.WorkflowCode = WorkflowCode;
if (!string.IsNullOrEmpty(WorkflowCode))
{
Clause = this.Engine.WorkflowManager.GetClause(WorkflowCode);
}
if (Clause != null)
{
Schema = this.Engine.BizObjectManager.GetPublishedSchema(Clause.BizSchemaCode);
}
string[] conditions = null;
string seqCondition = OThinker.H3.Instance.InstanceContext.TableName + "." + OThinker.H3.Instance.InstanceContext.PropertyName_SequenceNo + " ='" + SquenceNo + "'";
conditions = OThinker.Data.ArrayConvertor <string> .AddToArray(conditions, seqCondition);
DataTable dt = this.Engine.Query.QueryInstance(conditions, 0, 1);
if (dt != null && dt.Rows.Count > 0)
{
string InstanceId = dt.Rows[0][1] + string.Empty;
InstanceContext context = this.Engine.InstanceManager.GetInstanceContext(InstanceId);
if (context != null)
{
if (context.WorkflowCode == WorkflowCode)
{
InstanceData dataitems = new InstanceData(this.Engine, InstanceId, this.UserValidator.UserID);
Dictionary <string, object> valuetable = dataitems.BizObject.ValueTable;
OThinker.Organization.User Originator = this.Engine.Organization.GetUnit(context.Originator) as OThinker.Organization.User;
if (Originator != null)
{
model.Originator = new { ObjectID = Originator.ObjectID, Name = Originator.Name };
}
string[] workitemIds = this.Engine.Query.QueryWorkItems(InstanceId, -1, WorkItem.WorkItemType.Unspecified, WorkItem.WorkItemState.Unspecified, OThinker.Data.BoolMatchValue.Unspecified);
if (workitemIds != null || workitemIds.Length > 0)
{
foreach (string workitemId in workitemIds)
{
WorkItem.WorkItem workItem = this.Engine.WorkItemManager.GetWorkItem(workitemId);
if (!valuetable.ContainsKey(workItem.ActivityCode))
{
valuetable.Add(workItem.ActivityCode, workItem.Participant);
}
}
}
model.WorkflowName = context.InstanceName;
ShowDataItems(WorkflowCode, Schema, null, valuetable, model);
}
else
{
result.Message = "Simulation.EditSimulation_Mssg1";
return Json(result, JsonRequestBehavior.AllowGet);
}
}
}
else
{
result.Message = "Simulation.EditSimulation_Mssg2";
return Json(result, JsonRequestBehavior.AllowGet);
}
result.Success = true;
result.Extend = model;
result.Message = "msgGlobalString.ImportSucceed";
return Json(result, JsonRequestBehavior.AllowGet);
}));
}
/// <summary>
/// 批量拒绝
/// </summary>
/// <param name="WorkItemIDs"></param>
/// <param name="CommentText"></param>
/// <returns></returns>
private string ReturnWorkItems(string[] WorkItemIDs, string CommentText)
{
string errors = null;
foreach (string itemId in WorkItemIDs)
{
WorkItem.WorkItem item = this.Engine.WorkItemManager.GetWorkItem(itemId);
if (item == null || !item.IsUnfinished)
{
continue;
}
if (item.BatchProcessing == false)
{
errors += item.DisplayName + ";";
continue;
}
WorkflowTemplate.PublishedWorkflowTemplate workflow = GetWorkflowTemplate(item.WorkflowCode, item.WorkflowVersion);
// 添加意见
this.AppendComment(item, OThinker.Data.BoolMatchValue.True, CommentText);
// 结束工作项
this.Engine.WorkItemManager.FinishWorkItem(
item.ObjectID,
this.UserValidator.UserID,
H3.WorkItem.AccessPoint.ExternalSystem,
//null,
null,
OThinker.Data.BoolMatchValue.False,
CommentText,
null,
H3.WorkItem.ActionEventType.Backward,
(int)SheetButtonType.Return);
// 准备触发后面Activity的消息
OThinker.H3.Messages.ActivateActivityMessage activateMessage
= new OThinker.H3.Messages.ActivateActivityMessage(
OThinker.H3.Messages.MessageEmergencyType.Normal,
item.InstanceId,
workflow.StartActivityCode,
OThinker.H3.Instance.Token.UnspecifiedID,
null,
new int[] { item.TokenId },
false,
H3.WorkItem.ActionEventType.Backward);
// 通知该Activity已经完成
OThinker.H3.Messages.AsyncEndMessage endMessage =
new OThinker.H3.Messages.AsyncEndMessage(
OThinker.H3.Messages.MessageEmergencyType.Normal,
item.InstanceId,
item.ActivityCode,
item.TokenId,
OThinker.Data.BoolMatchValue.False,
true,
OThinker.Data.BoolMatchValue.False,
false,
activateMessage);
this.Engine.InstanceManager.SendMessage(endMessage);
}
return(errors);
}
public InstanceData GetInstanceData(WorkItem.WorkItem CurrentWorkItem)
{
InstanceData InstanceData = new InstanceData(this.Engine, CurrentWorkItem.InstanceId, this.UserValidator.UserID);
return(InstanceData);
}
public BizSheet GetWorkItemSheet(WorkItem.WorkItem CurrentWorkItem)
{
BizSheet workItemSheet = this.Engine.BizSheetManager.GetBizSheetByCode(CurrentWorkItem.SheetCode);
return(workItemSheet);
}
public JsonResult WorkItemDetail(string paramString)
{
return(ExecuteFunctionRun(() =>
{
ActionResult result = new ActionResult(false, "");
Dictionary <string, string> dicParams = JsonConvert.DeserializeObject <Dictionary <string, string> >(paramString);
string strMode = string.Empty, WorkItemID = string.Empty, strIsMobile = string.Empty,
state = string.Empty;
Dictionary <string, string> dicOtherParams = new Dictionary <string, string>();
//读取URL参数
foreach (string key in dicParams.Keys)
{
if (key == Param_Mode)
{
strMode = dicParams[key]; continue;
}
if (key == Param_WorkItemID)
{
WorkItemID = dicParams[key]; continue;
}
if (key == Param_IsMobile)
{
strIsMobile = dicParams[key]; continue;
}
if (key == "state")
{
state = dicParams["state"]; continue;
}
dicOtherParams.Add(key, dicParams[key]);
}
//Work、View。。。
SheetMode Mode = this.GetSheetMode(strMode, WorkItemID);
//WorkItem
WorkItem.WorkItem CurrentWorkItem = this.GetCurrentWorkItem(WorkItemID);
//获取工作任务的表单对象
BizSheet WorkItemSheet = this.GetWorkItemSheet(CurrentWorkItem);
bool IsMobile = this.IsMobile(strIsMobile, state);
// 解析Url地址
if (Mode == SheetMode.Work)
{
url = this.GetWorkSheetUrl(CurrentWorkItem, WorkItemSheet, IsMobile);
}
else
{
url = this.GetViewSheetUrl(CurrentWorkItem, WorkItemSheet, Mode, IsMobile);
}
// 将其中的数据参数做转换
InstanceData InstanceData = this.GetInstanceData(CurrentWorkItem);
if (url.Contains(OThinker.H3.Math.Variant.VariablePrefix.ToString()))
{
url = InstanceData.ParseText(url);
}
// 处理缓存
DateTime t = DateTime.Now;
DateTime.TryParse(InstanceData.BizObject[OThinker.Organization.Unit.PropertyName_ModifiedTime] + string.Empty, out t);
url += "&T=" + t.ToString("HHmmss") + WorkItemID.Substring(0, 8);
if (Mode == SheetMode.Print)
{
url += "Print";
}
result.Success = true;
result.Message = url;
return Json(result);
}));
}
/// <summary>
/// 打开流程表单
/// </summary>
/// <param name="paramString"></param>
/// <returns></returns>
public JsonResult InstanceSheets(string paramString)
{
return(ExecuteFunctionRun(() =>
{
ActionResult result = new ActionResult(false, "");
Dictionary <string, string> dicParams = JsonConvert.DeserializeObject <Dictionary <string, string> >(paramString);
bool isMobile = false;
foreach (string key in dicParams.Keys)
{
if (key == Param_InstanceId)
{
InstanceID = dicParams[key]; continue;
}
if (key == Param_IsMobile)
{
bool.TryParse(dicParams[key], out isMobile);
IsMobile = isMobile;
continue;
}
}
if (InstanceContext == null)
{
result.Message = "InstanceSheets_InstanceNotExist";
return Json(result, JsonRequestBehavior.AllowGet);
}
// 获取流程模板信息
WorkflowTemplate.PublishedWorkflowTemplate workflow = this.Engine.WorkflowManager.GetPublishedTemplate(InstanceContext.WorkflowCode, InstanceContext.WorkflowVersion);
if (workflow == null)
{
result.Message = "InstanceSheets_WorkflowNotExist";
return Json(result, JsonRequestBehavior.AllowGet);
}
//WorkflowVersion,InstanceID,UserID
DataTable dtWorkItem = this.GetItemTable(InstanceID);
string activity, sheetCode;
Dictionary <string, string> sheetWorkItemIds = new Dictionary <string, string>();
//当前用户参与过流程时，则打开参与过的流程表单，否则打开系统流程表单
if (dtWorkItem != null && dtWorkItem.Rows.Count > 0)
{
foreach (DataRow row in dtWorkItem.Rows)
{
activity = row[WorkItem.WorkItem.PropertyName_ActivityCode] + string.Empty;
sheetCode = this.GetSheetCodeByActivity(((WorkflowTemplate.ClientActivity)workflow.GetActivityByCode(activity)));
if (!sheetWorkItemIds.ContainsKey(sheetCode))
{
sheetWorkItemIds.Add(sheetCode, row[WorkItem.WorkItem.PropertyName_ObjectID].ToString());
}
}
}
else
{ // 管理员，未参与过流程
foreach (WorkflowTemplate.Activity act in workflow.Activities)
{
if (act is WorkflowTemplate.ClientActivity)
{
sheetCode = this.GetSheetCodeByActivity(((WorkflowTemplate.ClientActivity)act));
if (!string.IsNullOrEmpty(sheetCode) && !sheetWorkItemIds.ContainsKey(sheetCode))
{
sheetWorkItemIds.Add(sheetCode, string.Empty);
}
}
}
}
if (sheetWorkItemIds.Count == 0)
{
Instance.InstanceContext instanceContext = InstanceContext;
if (instanceContext != null)
{
// 未参与过流程，并且未设置默认表单，那么再获取默认表单
Sheet.BizSheet[] sheets = this.Engine.BizSheetManager.GetBizSheetBySchemaCode(instanceContext.BizObjectSchemaCode);
if (sheets != null && sheets.Length > 0)
{
foreach (Sheet.BizSheet sheet in sheets)
{
if (!string.IsNullOrEmpty(sheet.SheetCode) && !sheetWorkItemIds.ContainsKey(sheet.SheetCode))
{
sheetWorkItemIds.Add(sheet.SheetCode, string.Empty);
}
}
}
}
}
WorkItem.WorkItem workItem = null;
WorkItem.CirculateItem circulateItem = null;
string url, workItemId;
List <ListUrl> ListUrl = new List <ListUrl>();
foreach (string key in sheetWorkItemIds.Keys)
{
Sheet.BizSheet sheet = this.Engine.BizSheetManager.GetBizSheetByCode(key);
workItemId = sheetWorkItemIds[key];
if (workItemId == string.Empty)
{
url = this.GetViewSheetUrl(
sheet,
InstanceID,
SheetMode.View,
IsMobile);
}
else
{
workItem = this.Engine.WorkItemManager.GetWorkItem(workItemId);
if (workItem != null)
{
url = this.GetViewSheetUrl(
workItem,
sheet,
SheetMode.View,
this.IsMobile);
}
else
{
circulateItem = this.Engine.WorkItemManager.GetCirculateItem(workItemId);
if (circulateItem == null)
{
continue;
}
url = this.GetViewSheetUrl(
circulateItem,
sheet,
SheetMode.View,
this.IsMobile);
}
}
// 处理缓存
DateTime t = DateTime.Now;
url += "&T=" + t.ToString("HHmmss");
//只有一个表单直接跳转打开
if (sheetWorkItemIds.Count == 1)
{
result.Success = true;
result.Message = url;
result.Extend = "Redirect";
return Json(result, JsonRequestBehavior.AllowGet);
}
else //多个表单在界面上呈现连接选择打开
{
ListUrl.Add(new ListUrl
{
Title = "InstanceSheets_Sheet",
Text = string.Format("{0}[{1}]", sheet.DisplayName, key),
Url = url
});
}
}
result.Success = true;
result.Message = "MultiSheets";
result.Extend = ListUrl;
return Json(result, JsonRequestBehavior.AllowGet);
}));
}
