/// <summary>
/// 获取流程实例审批历史（转JSON）
/// </summary>
/// <param name="SN"></param>
/// <param name="ApprovalUserId"></param>
/// <returns></returns>
public static string GetProcessInstanceApprovalHistory(string SN, string ApprovalUserId)
{
Connection connection = GetK2Connection();
try
{
ImpersonateUser(connection, ApprovalUserId);
SourceCode.Workflow.Client.WorklistItem worklistItem = connection.OpenWorklistItem(SN);
string ApprovalResultXML = worklistItem.ProcessInstance.XmlFields["ApprovalResult"].Value;
if (ApprovalResultXML != null)
{
XMLApproval xmlApproval = new XMLApproval();
xmlApproval.LoadFromXML(ApprovalResultXML);
return(xmlApproval.mobj.ToJson());
}
return("");
}
catch (Exception ex)
{
throw new K2Exception(ex.ToString());
}
finally
{
// 关闭连接
if (connection != null)
{
connection.Close();
}
}
}
//add comments samples
public static void AddCommentsSamples()
{
using (Connection K2Conn = new Connection())
{
//dummy values for process instance ID and activity instance ID
int processInstanceId = 1;
int activityInstanceDestinationID = 10;
//adding a comment
//Add a Comment using the Connection class and the Process Instance's ID
IWorkflowComment comment = K2Conn.AddComment(processInstanceId, "Hello World");
//Add a Comment using the Connection class and the Worklist Item's SerialNumber
IWorkflowComment comment2 = K2Conn.AddComment("[_serialNo]", "Hello World");
//Add a Comment using the Connection class and the Process Instance's ID and Activity Instance Destination's ID
IWorkflowComment comment3 = K2Conn.AddComment(processInstanceId, activityInstanceDestinationID, "Hello World");
//Add a Comment using the Process Instance
ProcessInstance procinst = K2Conn.OpenProcessInstance(processInstanceId);
IWorkflowComment procInstComment = procinst.AddComment("Hello World");
//Add a Comment using the WorklistItem
WorklistItem worklistItem = K2Conn.OpenWorklistItem("[_serialNo]");
IWorkflowComment WLItemComment = worklistItem.AddComment("Hello World");
}
}
public static bool GetActivityDataField(string sn, string fieldName, string UserAccount, out string value)
{
using (Connection conn = new Connection())
{
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(UserAccount);
WorklistItem wlItem = conn.OpenWorklistItem(sn);
value = wlItem.ActivityInstanceDestination.DataFields[fieldName].Value.ToString();
return(true);
}
catch
{
value = "";
return(false);
}
finally
{
conn.Close();
}
}
}
/// <summary>
/// Delegate or shared worklist to the specific user
/// </summary>
/// <param name="serialNumber">The serial number</param>
/// <param name="destination">The specific user</param>
public void DelegateWorklistItem(string serialNumber, string destination)
{
try {
using (Connection workflowClient = this.GetWorkflowClient()) {
K2.WorklistItem worklistItem = workflowClient.OpenWorklistItem(serialNumber, null, false);
if (worklistItem == null)
{
throw new InvalidOperationException(string.Format("Not Found", serialNumber));
}
K2.Destination destination2 = new K2.Destination();
foreach (K2.Action action in worklistItem.Actions)
{
if (action != null)
{
destination2.AllowedActions.Add(action.Name);
}
}
destination2.Name = destination;
destination2.DestinationType = DestinationType.User;
worklistItem.Delegate(destination2);
}
} catch (UnauthorizedAccessException ex) {
throw ex;
} catch (SmartException ex) {
throw ex;
}
}
/// <summary>
/// 根据SN 获取流程工作项
/// </summary>
/// <param name="Connection">K2 链接</param>
/// <param name="sn">SN 流程编号</param>
/// <param name="ManagedUser">审批者</param>
/// <param name="SharedUser">共同审批者</param>
/// <param name="Platform">平台</param>
/// <returns></returns>
public static SourceCode.Workflow.Client.WorklistItem GetWorkListItemBySN(Connection Connection, string sn, string ManagedUser, string SharedUser, string Platform)
{
SourceCode.Workflow.Client.WorklistItem worklistItem = null;
//正常的
if ((string.IsNullOrEmpty(SharedUser)) && (ManagedUser == string.Empty))
{
worklistItem = Connection.OpenWorklistItem(sn, Platform);
}
if ((!string.IsNullOrEmpty(SharedUser)) && (ManagedUser == string.Empty))
{
worklistItem = Connection.OpenSharedWorklistItem(SharedUser, ManagedUser, sn);
}
if ((string.IsNullOrEmpty(SharedUser)) && (ManagedUser != string.Empty))
{
worklistItem = Connection.OpenManagedWorklistItem(ManagedUser, sn);
}
// 检查是否为委托的
if ((!string.IsNullOrEmpty(SharedUser)) && (ManagedUser != string.Empty))
{
worklistItem = Connection.OpenSharedWorklistItem(SharedUser, ManagedUser, sn);
}
return(worklistItem);
}
/// <summary>
/// 获取流程变量
/// </summary>
/// <param name="sn">流程SN</param>
/// <param name="FieldNames">要获取的变量的List</param>
/// <returns>变量的List</returns>
public static void GetProcessDataFields(string sn, string currentUser, CDataFields dataFields)
{
using (Connection conn = new Connection())
{
try
{
ConnectionSetup conSetup = GetConnectionSetup();
conn.Open(conSetup);
conn.ImpersonateUser(currentUser);
WorklistItem listItem = conn.OpenWorklistItem(sn);
GetDataFields(listItem, dataFields);
}
catch
{
throw;
}
finally
{
try
{
conn.RevertUser();
}
catch
{ }
if (conn != null)
{
conn.Close();
}
}
}
}
public static bool ApproveProcess(string sn, string action, string currentUser)
{
using (Connection conn = new Connection())
{
bool result = false;
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(currentUser);
WorklistItem wlItem = conn.OpenWorklistItem(sn);
wlItem.Actions[action].Execute();
result = true;
}
catch
{
throw;
}
finally
{
conn.Close();
}
return(result);
}
}
/// <summary>
/// 获取反加签处理人
/// </summary>
/// <param name="sn"></param>
/// <param name="Account"></param>
public static string GetBackToPreApproverUser(string sn, string Account)
{
using (Connection conn = new Connection())
{
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(Account);
WorklistItem wli = conn.OpenWorklistItem(sn);
string addApproversBy = wli.ActivityInstanceDestination.DataFields["AddApproversBy"].Value.ToString();
string[] arrPreApprovers = addApproversBy.Split(new string[] { ";" }, StringSplitOptions.RemoveEmptyEntries);
string lastPreApprover = arrPreApprovers[arrPreApprovers.Length - 1];
return(lastPreApprover);
}
catch
{
return("");
}
finally
{
conn.Close();
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sn"></param>
/// <param name="FieldNames"></param>
/// <returns></returns>
public static Dictionary <string, string> GetDataField(string sn, string[] FieldNames, string UserAccount)
{
using (Connection conn = new Connection())
{
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(UserAccount);
WorklistItem wlItem = wlItem = conn.OpenWorklistItem(sn);
Dictionary <string, string> dictionary = new Dictionary <string, string>();
foreach (string fieldName in FieldNames)
{
dictionary.Add(fieldName, wlItem.ProcessInstance.DataFields[fieldName].Value.ToString());
}
return(dictionary);
}
catch
{
throw;
}
finally
{
conn.Close();
}
}
}
/// <summary>
/// 加签
/// </summary>
/// <param name="sn"></param>
/// <param name="Account"></param>
/// <param name="nextUser"></param>
public static void ForwardToNextApprover(string sn, string Account, string nextUser)
{
using (Connection conn = new Connection())
{
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(Account);
WorklistItem wli = conn.OpenWorklistItem(sn);
string addApproversBy = wli.ActivityInstanceDestination.DataFields["AddApproversBy"].Value.ToString();
addApproversBy += Account + ";";
wli.ActivityInstanceDestination.DataFields["AddApproversBy"].Value = addApproversBy;
wli.Actions["更新"].Execute();
wli.Redirect(nextUser);
}
catch
{
throw;
}
finally
{
conn.Close();
}
}
}
/// <summary>
/// Sleep worklist item by Serial Number
/// </summary>
/// <param name="serialNumber">The Serial Number of worklist item</param>
/// <param name="hours">The durations in Hours</param>
public void SleepWorklistItem(string serialNumber, int hours, string sharedUser, string managedUser)
{
try {
using (Connection workflowClient = this.GetWorkflowClient()) {
K2.WorklistItem worklistItem = workflowClient.OpenWorklistItem(serialNumber, "ASP", false, false, managedUser, sharedUser);
if (worklistItem == null)
{
throw new InvalidOperationException(string.Format("Not Found", serialNumber));
}
var duration = GetCalulateSeconds(hours);
if (duration <= 0)
{
worklistItem.Sleep(false);
}
else
{
worklistItem.Sleep(true, duration);
}
}
} catch (SmartException ex) {
throw ex;
}
}
/// <summary>
/// Open a worklist item by serial number
/// </summary>
/// <param name="con">The worklist connection</param>
/// <param name="serialNumber">The serial number</param>
/// <param name="sharedUser">The shared user</param>
/// <param name="managedUser">The manager user</param>
/// <returns>The worklist item</returns>
public K2.WorklistItem OpenWorklistItem(Connection con, string serialNumber, string sharedUser, string managedUser, bool alloc)
{
K2.WorklistItem worklistItem = null;
if (sharedUser == string.Empty && managedUser == string.Empty)
{
worklistItem = con.OpenWorklistItem(serialNumber, "ASP", alloc);
}
if (sharedUser != string.Empty && managedUser == string.Empty)
{
worklistItem = con.OpenSharedWorklistItem(sharedUser, managedUser, serialNumber, "ASP", alloc);
}
if (sharedUser == string.Empty && managedUser != string.Empty)
{
worklistItem = con.OpenManagedWorklistItem(managedUser, serialNumber, "ASP", alloc);
}
if (sharedUser != string.Empty && managedUser != string.Empty)
{
worklistItem = con.OpenSharedWorklistItem(sharedUser, managedUser, serialNumber, "ASP", alloc);
}
if (worklistItem == null)
{
throw new InvalidOperationException(string.Format("Not Found", serialNumber));
}
return(worklistItem);
}
public static void Sleep(string sn, int second)
{
SourceCode.Workflow.Client.Connection con = new Connection();
try
{
ConnectionSetup conSetup = GetConnectionSetup();
con.Open(conSetup);
con.ImpersonateUser(_CurrentUser);
SourceCode.Workflow.Client.WorklistItem listItem = con.OpenWorklistItem(sn);
listItem.Sleep(true, second);
}
catch (Exception ex)
{
// TODO: throw?
throw ex;
}
finally
{
try
{
con.RevertUser();
}
catch
{
throw;
}
if (con != null)
{
con.Close();
}
}
}
//add attachments samples
public static void AddAttachmentsSamples()
{
using (Connection K2Conn = new Connection())
{
//dummy values for process instance ID and activity instance ID
int processInstanceId = 1;
int activityInstanceDestinationID = 10;
string fileName = "Report1.pdf";
//Add an Attachment using the Connection class and the Process Instance's ID
IWorkflowAttachment _attachment = K2Conn.AddAttachment(processInstanceId, fileName, GetFile("Report1.pdf"));
//Add an Attachment using the Connection class and the Worklist Item's SerialNumber
IWorkflowAttachment _attachment1 = K2Conn.AddAttachment("[_serialNo]", fileName, GetFile("Report1.pdf"));
//Add an Attachment using the Connection class and the Process Instance's ID and Activity Instance Destination's ID
IWorkflowAttachment _attachment2 = K2Conn.AddAttachment(processInstanceId, activityInstanceDestinationID, fileName, GetFile("Report1.pdf"));
//Add an Attachment using the Process Instance
ProcessInstance _processInstance = K2Conn.OpenProcessInstance(processInstanceId);
IWorkflowAttachment _attachment3 = _processInstance.AddAttachment(fileName, GetFile("Report1.pdf"));
//Add an Attachment using the WorklistItem
WorklistItem _worklistItem = K2Conn.OpenWorklistItem("[_serialNo]");
IWorkflowAttachment _attachment4 = _worklistItem.AddAttachment(fileName, GetFile("Report1.pdf"));
//Async exampe, where you create the attachment first and then upload the file
//Add an 'empty' attachment
IWorkflowAttachment _attachment5 = K2Conn.AddAttachment(processInstanceId, fileName, null);
//now upload the attachment's file.
//Note. You can only upload the file once and only for an 'empty' attachment.
//Note. This can be used for async purposes, to create the metadata first and secondly upload the file.
IAttachment attachmentWithContent = K2Conn.UploadAttachmentContent(_attachment.Id, GetFile("Report1.pdf"));
}
}
public void SetDecline(string serialNumber)
{
using (var wfConn = new Connection())
{
wfConn.Open(this.serverName, this.connectionString.ToString());
var wli = wfConn.OpenWorklistItem(serialNumber);
wli.Actions["Decline"].Execute();
}
}
internal void RedirectWorklistItem(string serialNumber, string userName)
{
try
{
OpenConnection();
WorklistItem item = _cnn.OpenWorklistItem(serialNumber, "ASP", false);
item.Redirect(userName);
CloseConnection();
}
catch (Exception ex)
{
throw ex;
}
finally
{
_cnn.Dispose();
}
}
public ResultModel ReAssign(string sn, int assignFrom, int assignTo, out string activityName, out string processCode, out int procInstID)
{
Connection k2Connect = null;
WorklistItem workList = null;
ResultModel jr = new ResultModel()
{
Code = ResultCode.Fail
};
activityName = string.Empty;
processCode = string.Empty;
procInstID = 0;
try
{
k2Connect = new Connection();
k2Connect.Open(ConfigurationManager.AppSettings["K2Server"], ConfigurationManager.AppSettings["K2LoginString"]);
k2Connect.ImpersonateUser(SecurityLable(assignFrom.ToString()));
workList = k2Connect.OpenWorklistItem(sn);
if (workList != null)
{
workList.Redirect(SecurityLable(assignTo.ToString()));
jr.Code = ResultCode.Sucess;
jr.Msg = "";
activityName = workList.ActivityInstanceDestination.Name;
processCode = workList.ProcessInstance.DataFields["ProcessCode"].Value.ToString();
procInstID = workList.ProcessInstance.ID;
}
}
catch (Exception ex)
{
jr.Msg = ex.Message;
}
finally
{
if (workList != null)
{
if (workList.Status == WorklistStatus.Open)
{
try
{
k2Connect.RevertUser();
workList.Release();
}
catch { }
}
}
if (k2Connect != null)
{
k2Connect.Close();
}
}
return(jr);
}
/// <summary>
/// Execute a worklist item's action by serial number
/// </summary>
/// <param name="serial">The serial number</param>
/// <param name="actionName">The worklist item's action name</param>
/// <param name="commonKey">The Common key data field</param>
/// <param name="comment">The worklist item's comment</param>
public void ExecuteWorklistItem(string serial, string actionName, IDictionary <string, object> dataFields)
{
if (dataFields == null)
{
dataFields = new Dictionary <string, object>();
}
using (Connection conn = GetWorkflowClient()) {
string sharedUser = GetSharedUsersBySerialNumber(serial);
string managedUser = GetFQN();
SourceCode.Workflow.Client.WorklistItem item = conn.OpenWorklistItem(serial, "ASP", false, false, managedUser, sharedUser);
if (item == null || item.Actions[actionName] == null)
{
return;
}
string commentKey = string.Empty, comment = string.Empty;
foreach (string key in _comments)
{
comment = dataFields.SingleOrDefault(p => p.Key == key).Value?.ToString();
dataFields.Remove(key);
if (!string.IsNullOrEmpty(comment))
{
break;
}
}
;
if (!string.IsNullOrEmpty(comment))
{
foreach (K2.DataField dataField in item.ProcessInstance.DataFields)
{
commentKey = _comments.SingleOrDefault(p => p == dataField.Name);
if (!string.IsNullOrEmpty(commentKey))
{
item.ProcessInstance.DataFields[commentKey].Value = comment;
break;
}
}
}
if (dataFields != null && dataFields.Count > 0)
{
List <string> keys = dataFields.Keys.ToList();
keys.ForEach((key) => {
item.ProcessInstance.DataFields[key].Value = dataFields[key];
});
}
item.Actions[actionName].Execute();
}
}
/// <summary>
/// To execute Worklist Item action by serial number and action name
/// </summary>
/// <param name="sn">The worklist item serial number</param>
/// <param name="actionName">The Action name</param>
public void ExecuteWorklistItem(string sn, string actionName, string sharedUser, string managedUser)
{
using (Connection conn = GetWorkflowClient())
{
K2.WorklistItem item = conn.OpenWorklistItem(sn, "ASP", false, false, managedUser, sharedUser);
if (item == null || item.Actions[actionName] == null)
{
return;
}
item.Actions[actionName].Execute();
}
}
private void RedirectWorklistItem()
{
string sn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.SerialNumber, true);
string fqn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.FQN, true);
using (Connection k2Con = this.ServiceBroker.K2Connection.GetWorkflowClientConnection())
{
WorklistItem wli = k2Con.OpenWorklistItem(sn);
wli.Redirect(fqn);
k2Con.Close();
}
}
/// <summary>
/// Share worlist item to some users by serial number
/// </summary>
/// <param name="serialNumber">The worklist item's serial number</param>
/// <param name="destination">The destination users</param>
public void Share(string serialNumber, string destination)
{
try {
using (Connection workflowClient = this.GetWorkflowClient()) {
K2.WorklistItem worklistItem = workflowClient.OpenWorklistItem(serialNumber, null, false);
if (worklistItem == null)
{
throw new InvalidOperationException(string.Format("Not Found", serialNumber));
}
worklistItem.Delegate(new K2.Destination(destination));
}
} catch (UnauthorizedAccessException ex) {
throw ex;
}
}
public ProcessBase(Connection conn, string sn)
{
//Get the WorklistItem object
WorklistItem wi = conn.OpenWorklistItem(sn);
//get the processing instance object
ProcessInstance pi = wi.ProcessInstance;
InitializeDataFields(pi.DataFields);
this._conn = conn;
this._sn = sn;
this.Actions = wi.Actions;
this.Folio = pi.Folio;
}
private void RedirectWorklistItem()
{
string sn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.SerialNumber, true);
string fqn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.FQN, true);
using (Connection k2Con = new Connection())
{
k2Con.Open(base.K2ClientConnectionSetup);
WorklistItem wli = k2Con.OpenWorklistItem(sn);
wli.Redirect(fqn);
k2Con.Close();
}
}
public ProcessBase(Connection conn, string sn)
{
//Get the WorklistItem object
WorklistItem wi = conn.OpenWorklistItem(sn);
//get the processing instance object
ProcessInstance pi = wi.ProcessInstance;
InitializeDataFields(pi.DataFields);
this._conn = conn;
this._sn = sn;
this.Actions = wi.Actions;
this.Folio = pi.Folio;
}
private void ReleaseWorklistItem()
{
string sn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.SerialNumber, true);
ServiceObject serviceObject = base.ServiceBroker.Service.ServiceObjects[0];
serviceObject.Properties.InitResultTable();
DataTable results = base.ServiceBroker.ServicePackage.ResultTable;
using (Connection k2Con = base.ServiceBroker.K2Connection.GetWorkflowClientConnection())
{
WorklistItem wli = k2Con.OpenWorklistItem(sn);
wli.Release();
k2Con.Close();
}
}
/// <summary>
/// 审批流程
/// </summary>
/// <param name="sn">流程SN,必选</param>
/// <param name="action">流程操作,为空则默认执行第0个操作</param>
/// <param name="folio">流程编码,可选</param>
/// <param name="dataFields">流程变量,必选</param>
public static void ExecuteProcess(string sn, string action, string folio, string currentUser, CDataFields dataFields)
{
using (Connection conn = new Connection())
{
try
{
ConnectionSetup conSetup = GetConnectionSetup();
conn.Open(conSetup);
conn.RevertUser();
conn.ImpersonateUser(currentUser);
SourceCode.Workflow.Client.WorklistItem listItem = conn.OpenWorklistItem(sn);
SetDataFields(listItem, dataFields);
if (!string.IsNullOrEmpty(folio))
{
listItem.ProcessInstance.Folio = folio;
}
if (!string.IsNullOrEmpty(action))
{
listItem.Actions[action].Execute();
}
else
{
listItem.Actions[0].Execute();
}
}
catch
{
// TODO: throw?
throw;
}
finally
{
try
{
conn.RevertUser();
}
catch
{ }
if (conn != null)
{
conn.Close();
}
}
}
}
public static void GetSCFProcessInfo(string sn, ref string FormID, ref string ProcessID, ref string activityName, ref string approveXML)
{
using (Connection conn = new Connection())
{
try
{
conn.Open(K2ServerName, GetConnString());
conn.RevertUser();
conn.ImpersonateUser(CurrentUser);
WorklistItem wlItem = conn.OpenWorklistItem(sn);
//edit by lee 2011-06-15
FormID = wlItem.ProcessInstance.Folio;
ProcessID = wlItem.ProcessInstance.ID.ToString();
//ProcessID = wlItem.ProcessInstance.DataFields["ProcessID"].Value.ToString();
//if (wlItem.ProcessInstance.DataFields["ApprovalXML"] != null)
// approveXML = wlItem.ProcessInstance.DataFields["ApprovalXML"].Value.ToString();
activityName = wlItem.ActivityInstanceDestination.Name;
//添加获取自定义流程XML方法
//foreach (DataField dataField in wlItem.ProcessInstance.DataFields)
//{
// if (dataField.Name == "ApprovalXML")
// {
// approveXML = dataField.Value.ToString();
// break;
// }
//}
if (wlItem.ProcessInstance.DataFields.Count > 0)
{
approveXML = wlItem.ProcessInstance.DataFields[0].Value.ToString();
}
else
{
approveXML = string.Empty;
}
}
catch
{
throw;
}
finally
{
conn.Close();
}
}
}
public static void Delegate(string sn, string targetUser)
{
SourceCode.Workflow.Client.Connection con = new Connection();
try
{
ConnectionSetup conSetup = GetConnectionSetup();
con.Open(conSetup);
con.ImpersonateUser(_CurrentUser);
SourceCode.Workflow.Client.WorklistItem listItem = con.OpenWorklistItem(sn);
listItem.Release();
Destination dest = new Destination();
dest.DestinationType = DestinationType.User;
for (int i = 0; i < listItem.Actions.Count; i++)
{
dest.AllowedActions.Add(listItem.Actions[i].Name);
}
dest.Name = targetUser;
listItem.Delegate(dest);
DBManager.AddWorkListLog(_CurrentUser, targetUser, listItem.SerialNumber, listItem.ProcessInstance.ID, listItem.ActivityInstanceDestination.ID, "Delegate", _CurrentUser);
}
catch (Exception ex)
{
// TODO: throw?
throw ex;
}
finally
{
try
{
con.RevertUser();
}
catch
{
throw;
}
if (con != null)
{
con.Close();
}
}
}
public virtual void Excute(string actionName)
{
//Get the WorklistItem object
WorklistItem wi = _conn.OpenWorklistItem(this._sn);
//get the processing instance object
ProcessInstance pi = wi.ProcessInstance;
foreach (KeyValuePair <string, object> pair in DataFields)
{
pi.DataFields[pair.Key].Value = pair.Value;
}
//determine the action object for the chosen item
SourceCode.Workflow.Client.Action action = wi.Actions[actionName];
//execute the action
action.Execute();
}
public static void Approve(string sn, string action, NameValueCollection dataFields)
{
SourceCode.Workflow.Client.Connection con = new Connection();
try
{
ConnectionSetup conSetup = GetConnectionSetup();
con.Open(conSetup);
con.ImpersonateUser(_CurrentUser);
SourceCode.Workflow.Client.WorklistItem listItem = con.OpenWorklistItem(sn);
listItem.Release();
if (dataFields != null)
{
for (int i = 0; i < dataFields.Count; i++)
{
string key = dataFields.GetKey(i).ToString();
string value = dataFields[key].ToString();
listItem.ProcessInstance.DataFields[key].Value = value;
}
}
listItem.Actions[action].Execute();
}
catch (Exception ex)
{
// TODO: throw?
throw ex;
}
finally
{
try
{
con.RevertUser();
}
catch
{ }
if (con != null)
{
con.Close();
}
}
}
internal DataTable LoadWorklistItem(string serialNumber)
{
if (string.IsNullOrEmpty(serialNumber))
{
throw new ArgumentException("Value must not be null or empty.", "serialNumer");
}
try
{
DataTable dt = GetResultTable();
DataRow row = dt.NewRow();
ConnectionSetup cnnSetup = new ConnectionSetup();
cnnSetup.ConnectionString = this._execSettings.ConnectionString;
using (Connection cnn = new Connection())
{
cnn.Open(cnnSetup);
if (this._execSettings.UseImpersonation)
{
cnn.ImpersonateUser(this._execSettings.ImpersonateUser);
}
WorklistItem item = cnn.OpenWorklistItem(serialNumber);
if (item != null)
{
PopulateDataRow(item, row);
dt.Rows.Add(row);
}
cnn.Close();
}
return(dt);
}
catch (Exception ex)
{
throw ex;
}
}
private void ReleaseWorklistItem()
{
string sn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.SerialNumber, true);
ServiceObject serviceObject = base.ServiceBroker.Service.ServiceObjects[0];
serviceObject.Properties.InitResultTable();
DataTable results = base.ServiceBroker.ServicePackage.ResultTable;
using (Connection k2Con = new Connection())
{
k2Con.Open(base.K2ClientConnectionSetup);
WorklistItem wli = k2Con.OpenWorklistItem(sn);
wli.Release();
k2Con.Close();
}
}
internal DataTable LoadWorklistItem(string serialNumber)
{
if (string.IsNullOrEmpty(serialNumber))
throw new ArgumentException("Value must not be null or empty.", "serialNumer");
try
{
DataTable dt = GetResultTable();
DataRow row = dt.NewRow();
ConnectionSetup cnnSetup = new ConnectionSetup();
cnnSetup.ConnectionString = this._execSettings.ConnectionString;
using (Connection cnn = new Connection())
{
cnn.Open(cnnSetup);
if (this._execSettings.UseImpersonation)
cnn.ImpersonateUser(this._execSettings.ImpersonateUser);
WorklistItem item = cnn.OpenWorklistItem(serialNumber);
if (item != null)
{
PopulateDataRow(item, row);
dt.Rows.Add(row);
}
cnn.Close();
}
return dt;
}
catch (Exception ex)
{
throw ex;
}
}
private void RedirectWorklistItem()
{
string sn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.SerialNumber, true);
string fqn = base.GetStringProperty(Constants.SOProperties.ClientWorklist.FQN, true);
using (Connection k2Con = new Connection())
{
k2Con.Open(base.K2ClientConnectionSetup);
WorklistItem wli = k2Con.OpenWorklistItem(sn);
wli.Redirect(fqn);
k2Con.Close();
}
}
public Boolean WorkItemAction(string serialno, string action)
{
//TODO - Move into K2 Helpers
Connection K2Conn = new Connection();
SCConnectionStringBuilder K2ConnString = new SCConnectionStringBuilder();
//Setup Connection String
K2ConnString.Host = "Win2012-K2";
K2ConnString.Integrated = false;
K2ConnString.UserID = "Sa4Demo\\Tberry";
K2ConnString.Password = "******";
K2ConnString.Port = 5252;
K2ConnString.WindowsDomain = "Sa4Demo";
K2ConnString.SecurityLabelName = "K2";
K2ConnString.Authenticate = true;
K2ConnString.IsPrimaryLogin = true;
K2Conn.Open("Win2012-K2", K2ConnString.ConnectionString);
SourceCode.Workflow.Client.WorklistItem worklistItem = K2Conn.OpenWorklistItem(serialno);
// action the workflow by executing the action
if (worklistItem.Actions.Count > 0)
{
worklistItem.Actions[action].Execute();
return (true);
}
else { return (false); }
}
public WorklistItem GetWorklistItemBySN(string serialNumber, String impersonateUser)
{
using (var k2Connection = new Connection())
{
ConnectionSetup k2Setup = new ConnectionSetup();
k2Setup.ConnectionString = Properties.Settings.Default.WorkflowServerConnectionString;
k2Connection.Open(k2Setup);
if (!String.IsNullOrEmpty(impersonateUser))
k2Connection.ImpersonateUser(impersonateUser);
return k2Connection.OpenWorklistItem(serialNumber);
}
}
internal DataTable LoadWorklistItem(string serialNumber)
{
ConnectionSetup connectSetup = new ConnectionSetup();
connectSetup.ConnectionString = _connectionString;
Connection cnn = new Connection();
DataTable dt = GetResultTable();
try
{
cnn.Open(connectSetup);
WorklistItem item = cnn.OpenWorklistItem(serialNumber);
DataRow row = dt.NewRow();
row["AllocatedUser"] = item.AllocatedUser;
row["Data"] = item.Data;
row["ID"] = item.ID;
row["Link"] = "<hyperlink><link>" + HttpUtility.HtmlEncode(item.Data) + "</link><display>Open</display></hyperlink>";
row["SerialNumber"] = item.SerialNumber;
row["Status"] = item.Status;
row["ActivityID"] = item.ActivityInstanceDestination.ActID;
row["ActivityInstanceID"] = item.ActivityInstanceDestination.ActInstID;
row["ActivityName"] = item.ActivityInstanceDestination.Name;
row["Priority"] = item.ActivityInstanceDestination.Priority;
row["StartDate"] = item.EventInstance.StartDate;
row["ActivityInstanceDestinationID"] = item.ActivityInstanceDestination.ID;
row["ProcessInstanceID"] = item.ProcessInstance.ID;
row["ProcessFullName"] = item.ProcessInstance.FullName;
row["ProcessName"] = item.ProcessInstance.Name;
row["Folio"] = item.ProcessInstance.Folio;
row["EventInstanceName"] = item.EventInstance.Name;
dt.Rows.Add(row);
return dt;
}
catch (Exception ex)
{
throw ex;
}
finally
{
cnn.Close();
cnn.Dispose();
}
}
public ResultModel ReAssign(string sn, int assignFrom, int assignTo, out string activityName, out string processCode, out int procInstID)
{
Connection k2Connect = null;
WorklistItem workList = null;
ResultModel jr = new ResultModel() { Code = ResultCode.Fail };
activityName = string.Empty;
processCode = string.Empty;
procInstID = 0;
try
{
k2Connect = new Connection();
k2Connect.Open(ConfigurationManager.AppSettings["K2Server"], ConfigurationManager.AppSettings["K2LoginString"]);
k2Connect.ImpersonateUser(SecurityLable(assignFrom.ToString()));
workList = k2Connect.OpenWorklistItem(sn);
if (workList != null )
{
workList.Redirect(SecurityLable(assignTo.ToString()));
jr.Code = ResultCode.Sucess;
jr.Msg = "";
activityName = workList.ActivityInstanceDestination.Name;
processCode = workList.ProcessInstance.DataFields["ProcessCode"].Value.ToString();
procInstID = workList.ProcessInstance.ID;
}
}
catch (Exception ex)
{
jr.Msg = ex.Message;
}
finally
{
if (workList != null)
{
if (workList.Status == WorklistStatus.Open)
{
try
{
k2Connect.RevertUser();
workList.Release();
}
catch { }
}
}
if (k2Connect != null)
k2Connect.Close();
}
return jr;
}
public ResultModel ApproveK2Process(string sn, int loginId, string actionString, string memo, Dictionary<string, string> dataFields, out string activityName, out string processCode, out int procInstID)
{
Connection k2Connect = null;
WorklistItem workList = null;
ResultModel jr = new ResultModel() { Code = ResultCode.Fail };
activityName = string.Empty;
processCode = string.Empty;
procInstID = 0;
try
{
k2Connect = new Connection();
k2Connect.Open(ConfigurationManager.AppSettings["K2Server"], ConfigurationManager.AppSettings["K2LoginString"]);
k2Connect.ImpersonateUser(SecurityLable(loginId.ToString()));
workList = k2Connect.OpenWorklistItem(sn);
if (workList != null)
{
#region 更新Datafield
if (dataFields != null && dataFields.Count > 0)
{
ProcessInstance CurrentProcessInst = workList.ProcessInstance;
//更新Datafields
foreach (string key in dataFields.Keys)
{
if (CurrentProcessInst.DataFields[key] != null)
{
if (CurrentProcessInst.DataFields[key].Value.ToString() != dataFields[key])
{
CurrentProcessInst.DataFields[key].Value = dataFields[key];
}
}
}
}
#endregion
#region 审批任务
//批量审批没有actionString，默认第一个操作
if (string.IsNullOrEmpty(actionString))
{
if (workList.Actions[0].Name == REJECTACTION)
{
workList.GotoActivity("流程未通过");
}
else if (workList.Actions[0].Name == UNDOACTION)
{
workList.GotoActivity("流程撤销");
}
else
{
workList.Actions[0].Execute();
}
}
else
{
//执行匹配的操作
if (actionString == UNDOACTION)
{
workList.GotoActivity("流程撤销");
}
else if (actionString == REJECTACTION)
{
workList.GotoActivity("流程未通过");
}
else
{
bool isExcute = false;
for (int i = 0; i < workList.Actions.Count; i++)
{
if (workList.Actions[i].Name == actionString)
{
workList.Actions[i].Execute();
isExcute = true;
break;
}
}
if (!isExcute)
{
jr.Code = ResultCode.Fail;
jr.Msg = string.Format("Action:{0}错误", actionString);
return jr;
}
}
}
#endregion
jr.Code = ResultCode.Sucess;
jr.Msg = "";
activityName = workList.ActivityInstanceDestination.Name;
processCode = workList.ProcessInstance.DataFields["ProcessCode"].Value.ToString();
procInstID = workList.ProcessInstance.ID;
}
}
catch (Exception ex)
{
jr.Msg = ex.Message;
}
finally
{
if (workList != null)
{
if (workList.Status == WorklistStatus.Open)
{
try
{
k2Connect.RevertUser();
workList.Release();
}
catch { }
}
}
if (k2Connect != null)
k2Connect.Close();
}
return jr;
}
/// <summary>
/// 审批流程
/// </summary>
/// <param name="userName"></param>
/// <param name="sn"></param>
/// <param name="actionString"></param>
/// <param name="memo"></param>
/// <param name="dataFields"></param>
public WorklistItem ApprovalProcess(string userName, string sn, string actionString, string memo, Dictionary<string, string> dataFields)
{
Connection k2Connection = new Connection();
try
{
k2Connection.Open(ConfigurationBase.Web.K2Server, ConfigurationBase.Web.K2LoginString);
k2Connection.ImpersonateUser(userName);
//根据SN打开工作项
WorklistItem workList = k2Connection.OpenWorklistItem(sn);
if (workList != null)
{
#region 更新Datafield
if (dataFields != null && dataFields.Count > 0)
{
ProcessInstance currentProcessInst = k2Connection.OpenProcessInstance(workList.ProcessInstance.ID);
//更新Datafields
foreach (string key in dataFields.Keys)
{
if (currentProcessInst.DataFields[key] != null)
{
if (currentProcessInst.DataFields[key].Value!= dataFields[key])
{
currentProcessInst.DataFields[key].Value = dataFields[key];
}
}
}
currentProcessInst.Update();
}
#endregion
#region 审批任务
//批量审批没有actionString，默认第一个操作
if (string.IsNullOrEmpty(actionString))
{
if (workList.Actions[0].Name == REJECTACTION)
{
workList.GotoActivity("流程未通过");
}
else if (workList.Actions[0].Name == UNDOACTION)
{
workList.GotoActivity("流程撤销");
}
else
{
workList.Actions[0].Execute();
}
}
else
{
//执行匹配的操作
if (actionString == UNDOACTION)
{
workList.GotoActivity("流程撤销");
}
else if (actionString == REJECTACTION)
{
workList.GotoActivity("流程未通过");
}
else
{
bool isExcuted = false;
for (int i = 0; i < workList.Actions.Count; i++)
{
if (workList.Actions[i].Name == actionString)
{
workList.Actions[i].Execute();
isExcuted = true;
break;
}
}
}
}
#endregion
}
return workList;
}
catch (Exception)
{
return null;
}
finally
{
if (k2Connection != null)
{
k2Connection.Close();
}
}
}
public WorklistItem GetWorklistItemBySN(string serialNumber, String impersonateUser)
{
// if the serial number is null or empty we do not want to do any of this
if (!string.IsNullOrEmpty(serialNumber))
{
using (var k2Connection = new Connection())
{
ConnectionSetup k2Setup = new ConnectionSetup();
k2Setup.ConnectionString = Properties.Settings.Default.WorkflowServerConnectionString;
k2Connection.Open(k2Setup);
if (!String.IsNullOrEmpty(impersonateUser))
k2Connection.ImpersonateUser(impersonateUser);
return k2Connection.OpenWorklistItem(serialNumber);
}
}
return null;
}
