Exemplo n.º 1
0
 /// <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);
 }
Exemplo n.º 2
0
        /// <summary>
        /// 审批流程实例
        /// </summary>
        /// <param name="SN">流程编号</param>
        /// <param name="DicDataFields">流程参数</param>
        /// <param name="ManagedUser">流程审批者</param>
        /// <param name="SharedUser">流程共同审批者</param>
        /// <param name="ActionName">流程动作</param>
        /// <param name="Platform">流程审批页面平台</param>
        public static void ApprovalProcessInstance(string SN, Dictionary <string, object> DicDataFields, string ApprovalUserInfoString)
        {
            Connection Connection = GetK2Connection();//创建K2 链接

            try
            {
                ApprovalUserInfo ApprovalUserInfo = ApprovalUserInfoString.ToObject <ApprovalUserInfo>();
                ImpersonateUser(Connection, ApprovalUserInfo.ApprovalUserId);

                //获取流程工作项
                SourceCode.Workflow.Client.WorklistItem wit = GetWorkListItemBySN(Connection, SN, ApprovalUserInfo.ManagedUser, ApprovalUserInfo.SharedUser, PLATFORM);

                BatchSetInstanceDataFields(wit, DicDataFields);

                //添加审批历史
                AddProcessInstanceApprovalHistory(wit, ApprovalUserInfo);

                //设置审批动作 (节点审批成功(任务自动完成))
                string ActionName = string.IsNullOrEmpty(ApprovalUserInfo.ActionName) ? ACTIONNAME : ApprovalUserInfo.ActionName;
                //执行审批动作
                wit.Actions[ActionName].Execute();
            }
            catch (Exception ex)
            {
                throw new K2Exception(ex.ToString());
            }
            finally
            {
                // 关闭连接
                if (Connection != null)
                {
                    Connection.Close();
                }
            }
        }
Exemplo n.º 3
0
 /// <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;
     }
 }
Exemplo n.º 4
0
        /// <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();
                }
            }
        }
Exemplo n.º 5
0
        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();
                }
            }
        }
Exemplo n.º 6
0
        /// <summary>
        /// 添加流程实例审批历史
        /// </summary>
        public static void AddProcessInstanceApprovalHistory(SourceCode.Workflow.Client.WorklistItem worklistItem, ApprovalUserInfo ApprovalUserInfo)
        {
            //获取流程审批历史
            string ApprovalResultXML     = GetInstanceDataFields(worklistItem, "ApprovalResult", true);
            string LastApprovalResultXML = GetInstanceDataFields(worklistItem, "LastApprovalResult", true);

            ApprovalResultXML     = XMLApproval.ToResultXML(ApprovalResultXML);
            LastApprovalResultXML = XMLApproval.ToResultXML(LastApprovalResultXML);

            XMLApproval xmlApproval = new XMLApproval();

            //增加一个审批记录
            xmlApproval.LoadFromXML(ApprovalResultXML);
            xmlApproval.AddApproval(ApprovalUserInfo.ApprovalUserName, ApprovalUserInfo.ApprovalUserId, ApprovalUserInfo.ComAuditText, ApprovalUserInfo.ComAuditComment, GetCurrentActivityName(worklistItem));
            SetInstanceDataFields(worklistItem, "ApprovalResult", xmlApproval.ToXML(), true);

            //设置最后审批历史记录
            xmlApproval.LoadFromXML(LastApprovalResultXML);
            xmlApproval.SetLastApproval(ApprovalUserInfo.ApprovalUserName, ApprovalUserInfo.ApprovalUserId, ApprovalUserInfo.ComAuditText, ApprovalUserInfo.ComAuditComment, GetCurrentActivityName(worklistItem));
            SetInstanceDataFields(worklistItem, "LastApprovalResult", xmlApproval.ToXML(), true);

            //设置审批结果
            SetInstanceDataFields(worklistItem, "ComAuditComment", ApprovalUserInfo.ComAuditComment, false);
            SetInstanceDataFields(worklistItem, "ComAuditResult", ApprovalUserInfo.ComAuditResult, false);
        }
Exemplo n.º 7
0
 /// <summary>
 /// 批量修改流程实例数据字段
 /// </summary>
 public static void BatchSetInstanceDataFields(SourceCode.Workflow.Client.WorklistItem worklistItem, Dictionary <string, object> DicDataFields)
 {
     foreach (var dic in DicDataFields)
     {
         worklistItem.ProcessInstance.DataFields[dic.Key].Value = dic.Value;
     }
 }
Exemplo n.º 8
0
        /// <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);
        }
Exemplo n.º 9
0
        /// <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;
            }
        }
Exemplo n.º 10
0
        /// <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();
            }
        }
Exemplo n.º 11
0
        /// <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();
            }
        }
Exemplo n.º 12
0
 //修改流程实例数据字段
 public static void SetInstanceDataFields(SourceCode.Workflow.Client.WorklistItem worklistItem, string fieldName, string fieldValue, bool isXMLField)
 {
     if (worklistItem != null)
     {
         if (isXMLField)
         {
             worklistItem.ProcessInstance.XmlFields[fieldName].Value = fieldValue;
         }
         else
         {
             worklistItem.ProcessInstance.DataFields[fieldName].Value = fieldValue;
         }
     }
 }
Exemplo n.º 13
0
 public static WorklistItem FromApi(K2API.WorklistItem wli)
 {
     return(new WorklistItem {
         AllocatedUser = wli.AllocatedUser,
         Data = wli.Data,
         ID = (long)wli.ID,
         SerialNumber = wli.SerialNumber,
         Status = (WorklistStatus)wli.Status,
         Actions = ActionCollection.FromApi(wli.Actions),
         ActivityInstanceDestination = ActivityInstanceDestination.FromApi(wli.ActivityInstanceDestination),
         EventInstance = EventInstance.FromApi(wli.EventInstance),
         ProcessInstance = ProcessInstance.FromApi(wli.ProcessInstance)
     });
 }
Exemplo n.º 14
0
 public void ToApi(SourceCode.Workflow.Client.WorklistItem wli)
 {
     if (this.ActivityInstanceDestination != null)
     {
         this.ActivityInstanceDestination.ToApi(wli.ActivityInstanceDestination);
     }
     if (this.EventInstance != null)
     {
         this.EventInstance.ToApi(wli.EventInstance);
     }
     if (this.ProcessInstance != null)
     {
         this.ProcessInstance.ToApi(wli.ProcessInstance);
     }
 }
Exemplo n.º 15
0
 /// <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;
     }
 }
Exemplo n.º 16
0
        /// <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();
                    }
                }
            }
        }
Exemplo n.º 17
0
        private Domain.K2.WorklistItem ConvertTaskObject(K2.WorklistItem wli)
        {
            var actions = new List <string>();

            for (int i = 0; i < wli.Actions.Count; i++)
            {
                actions.Add(wli.Actions[i].Name);
            }

            return(new Domain.K2.WorklistItem()
            {
                ActInstDestName = wli.ActivityInstanceDestination.Name,
                Actions = actions,
                SerialNumber = wli.SerialNumber,
                AllocatedUser = wli.AllocatedUser
            });
        }
Exemplo n.º 18
0
        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();
                }
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// 获取流程实例数据字段
        /// </summary>
        /// <param name="oK2Connection"></param>
        /// <param name="sn"></param>
        /// <param name="fieldName"></param>
        /// <param name="isXMLField"></param>
        /// <param name="managedUser"></param>
        /// <param name="sharedUser"></param>
        /// <returns></returns>
        public static string GetInstanceDataFields(SourceCode.Workflow.Client.WorklistItem worklistItem, string fieldName, bool isXMLField)
        {
            string retValue = "";

            if (worklistItem != null)
            {
                if (isXMLField)
                {
                    retValue = worklistItem.ProcessInstance.XmlFields[fieldName].Value.ToString();
                }
                else
                {
                    retValue = worklistItem.ProcessInstance.DataFields[fieldName].Value.ToString();
                }
            }

            return(retValue);
        }
Exemplo n.º 20
0
        /// <summary>
        /// Call and execute worklist item's action
        /// </summary>
        /// <param name="serialNumber">The worklist item's serial number</param>
        /// <param name="action">The worklist item's action name</param>
        /// <param name="synchronous">The execution by synchronus or asynchronous</param>
        /// <param name="allowNonBatch">The allow non batch</param>
        /// <param name="item">The worklist item</param>
        /// <param name="sharedUser">The shared users</param>
        /// <param name="managedUser">The manager user</param>
        private void ExecuteAction(string serialNumber, string action, bool synchronous, bool allowNonBatch, Cores.WorklistItem item, string sharedUser, string managedUser)
        {
            string text = action.ToUpperInvariant();

            if (text.StartsWith("A:") || text.StartsWith("ACTION:"))
            {
                action = RemovePrefix(action);
            }
            else
            {
                if (text.StartsWith("R:") || text.StartsWith("REDIRECT:"))
                {
                    this.Redirect(serialNumber, RemovePrefix(action));
                    return;
                }
                if (text.StartsWith("D:") || text.StartsWith("DELEGATE:"))
                {
                    this.DelegateWorklistItem(serialNumber, RemovePrefix(action));
                    return;
                }
            }
            using (Connection workflowClient = this.GetWorkflowClient()) {
                K2.WorklistItem worklistItem = this.OpenWorklistItem(workflowClient, serialNumber, sharedUser, managedUser);

                K2.Action newAction = worklistItem.Actions[action];

                if (newAction == null)
                {
                    throw new InvalidOperationException(string.Format("Not Found", action));
                }

                if (!newAction.Batchable && !allowNonBatch)
                {
                    throw new InvalidOperationException(string.Format("Not Batchable", action));
                }

                if (item != null)
                {
                    item.ToApi(worklistItem);
                }

                newAction.Execute(synchronous);
            }
        }
Exemplo n.º 21
0
        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();
                }
            }
        }
Exemplo n.º 22
0
        public List <string> GetSharedUsers(string sn)
        {
            List <string> destUsers = new List <string>();

            K2.WorklistItem wItem = null;
            try
            {
                wItem = _client.GetWorklistItem(sn);

                if (wItem == null)
                {
                    throw new System.InvalidOperationException(string.Format("Not Found", sn));
                }

                var delegateUsers = wItem.DelegatedUsers;

                if (delegateUsers != null && delegateUsers.Count > 0)
                {
                    foreach (K2.Destination dest in delegateUsers)
                    {
                        if (dest.Name.IsCaseInsensitiveEqual(_userAccount))
                        {
                            continue;
                        }

                        var criteria = K2Service.Cores.SecurityLabelUtils.GetNameWithoutLabel(dest.Name).ToLower();

                        destUsers.Add(criteria);
                    }
                }
                wItem.Release();

                return(destUsers);
            }
            catch (Exception)
            {
                return(destUsers);
            }
        }
Exemplo n.º 23
0
        /// <summary>
        /// Delegate or shared worklist to other users
        /// </summary>
        /// <param name="serialNumber">The serial number</param>
        /// <param name="destinations">The other users</param>
        public void Share(string serialNumber, IList <string> destinations)
        {
            try
            {
                K2.WorklistItem worklistItem = GetWorklistItem(serialNumber);
                if (worklistItem == null)
                {
                    throw new InvalidOperationException(string.Format("Not Found", serialNumber));
                }

                if (destinations == null || destinations.Count == 0)
                {
                    throw new InvalidOperationException(string.Format("Destination users is null or empty"));
                }

                var destinationUsers = new K2.Destinations();
                foreach (string dest in destinations)
                {
                    K2.Destination destination = new K2.Destination();
                    foreach (K2.Action action in worklistItem.Actions)
                    {
                        if (action != null)
                        {
                            destination.AllowedActions.Add(action.Name);
                        }
                    }
                    destination.Name            = dest;
                    destination.DestinationType = DestinationType.User;
                    destinationUsers.Add(destination);
                }

                worklistItem.Delegate(destinationUsers);
            }
            catch (Exception ex)
            {
            }
        }
Exemplo n.º 24
0
        /// <summary>
        /// 挂起
        /// </summary>
        /// <param name="sn"></param>
        /// <param name="sourceUser"></param>
        /// <param name="second"></param>
        public static void SleepWorkListItem(string sn, string sourceUser, int second)
        {
            using (Connection conn = new Connection())
            {
                try
                {
                    ConnectionSetup conSetup = GetConnectionSetup();
                    conn.Open(conSetup);
                    conn.ImpersonateUser(sourceUser);

                    SourceCode.Workflow.Client.WorklistItem listItem = conn.OpenWorklistItem(sn);
                    listItem.Sleep(true, second);
                }
                catch
                {
                    // TODO: throw?
                    throw;
                }
                finally
                {
                    try
                    {
                        conn.RevertUser();
                    }
                    catch
                    {
                        throw;
                    }

                    if (conn != null)
                    {
                        conn.Close();
                    }
                }
            }
        }
Exemplo n.º 25
0
        /// <summary>
        /// 任务移交
        /// </summary>
        /// <param name="sn">任务SN</param>
        /// <param name="sourceUser">源用户</param>
        /// <param name="targetUser">目标用户</param>
        public static void RedirectWorkListItem(string sn, string sourceUser, string targetUser)
        {
            using (Connection conn = new Connection())
            {
                try
                {
                    ConnectionSetup conSetup = GetConnectionSetup();
                    conn.Open(conSetup);
                    conn.ImpersonateUser(sourceUser);

                    SourceCode.Workflow.Client.WorklistItem listItem = conn.OpenWorklistItem(sn);
                    listItem.Redirect(targetUser);
                }
                catch (Exception ex)
                {
                    // TODO: throw?
                    throw ex;
                }
                finally
                {
                    try
                    {
                        conn.RevertUser();
                    }
                    catch
                    {
                        throw;
                    }

                    if (conn != null)
                    {
                        conn.Close();
                    }
                }
            }
        }
Exemplo n.º 26
0
        public static void Redirect(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();
                listItem.Redirect(targetUser);
                DBManager.AddWorkListLog(_CurrentUser, targetUser, listItem.SerialNumber, listItem.ProcessInstance.ID, listItem.ActivityInstanceDestination.ID, "Redirect", _CurrentUser);
            }
            catch (Exception ex)
            {
                // TODO: throw?
                throw ex;
            }
            finally
            {
                try
                {
                    con.RevertUser();
                }
                catch
                {
                    throw;
                }

                if (con != null)
                {
                    con.Close();
                }
            }
        }
Exemplo n.º 27
0
 /// <summary>
 /// 获取当前流程实例节点名称
 /// </summary>
 /// <param name="worklistItem"></param>
 /// <returns></returns>
 public static string GetCurrentActivityName(SourceCode.Workflow.Client.WorklistItem worklistItem)
 {
     return(worklistItem.ActivityInstanceDestination.Name);
 }
Exemplo n.º 28
0
        /// <summary>
        /// 委托代办
        /// </summary>
        /// <param name="sn"></param>
        /// <param name="sourceUser"></param>
        /// <param name="targetUser"></param>
        public static string DelegateWorkListItem(string sn, string sourceUser, string targetUser)
        {
            using (Connection conn = new Connection())
            {
                string result             = "";
                bool   ContainsTargetUser = false;
                try
                {
                    string          targetUserSL = SecurityLabelName + ":" + targetUser;
                    ConnectionSetup conSetup     = GetConnectionSetup();
                    conn.Open(conSetup);
                    conn.ImpersonateUser(sourceUser);

                    SourceCode.Workflow.Client.WorklistItem listItem = conn.OpenWorklistItem(sn);

                    //重置任务状态为Available,只有Available状态下的任务才有权限代理
                    listItem.Release();
                    //判断该任务是否已经代理给targetUser
                    foreach (Destination destuser in listItem.DelegatedUsers)
                    {
                        if (destuser.Name.Equals(targetUserSL, StringComparison.InvariantCultureIgnoreCase))
                        {
                            ContainsTargetUser = true;
                            result             = "任务不能重复代理给[" + targetUser + "]";
                            break;
                        }
                    }
                    if (!ContainsTargetUser)
                    {
                        //如果该任务是其它人代理给sourceUser的,则sourceUser不能再次代理给targetUser,即禁止传递代理
                        DataTable DelegationLog = K2DBHelper.GetDelegationsLog(listItem.SerialNumber).Tables[0];
                        foreach (DataRow dr in DelegationLog.Rows)
                        {
                            if (sourceUser.Equals(dr["ToUser"].ToString(), StringComparison.InvariantCultureIgnoreCase))
                            {
                                ContainsTargetUser = true;
                                result             = "该任务由[" + dr["FromUser"].ToString() + "]代理给[" + sourceUser + "]";
                                break;
                            }
                        }
                    }
                    if (!ContainsTargetUser)
                    {
                        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 = targetUserSL;
                        //代理任务
                        listItem.Delegate(dest);

                        //Todo:给代理人邮件

                        //Todo:添加代理历史记录
                        int parentProcInstID = K2DBHelper.GetRootParentsID(listItem.ProcessInstance.ID);
                        K2DBHelper.AddDelegationsLog(listItem.ProcessInstance.ID, parentProcInstID, sn, sourceUser, targetUser, sourceUser);
                        result = "任务代理成功";
                    }
                    return(result);
                }
                catch
                {
                    // TODO: throw?
                    throw;
                }
                finally
                {
                    try
                    {
                        conn.RevertUser();
                    }
                    catch
                    {
                        throw;
                    }

                    if (conn != null)
                    {
                        conn.Close();
                    }
                }
            }
        }
Exemplo n.º 29
0
 /// <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)
 {
     K2.WorklistItem worklistItem = OpenWorklistItem(con, serialNumber, sharedUser, managedUser, true);
     return(worklistItem);
 }