Exemple #1
0
        private static GenericOpinion PrepareOpinion(IWfActivity activity, WfClientOpinion opinion, IUser user)
        {
            GenericOpinion serverOpinion = null;

            if (opinion != null)
            {
                serverOpinion = opinion.ToGenericOpinion();
            }
            else
            {
                serverOpinion = new GenericOpinion()
                {
                    ID = UuidHelper.NewUuidString()
                }
            };

            serverOpinion.ProcessID  = activity.Process.ID;
            serverOpinion.ActivityID = activity.ID;
            serverOpinion.ResourceID = activity.Process.ResourceID;

            serverOpinion.IssuePerson  = user;
            serverOpinion.AppendPerson = user;

            return(serverOpinion);
        }
Exemple #2
0
        public WfClientOpinion ServerToClient(GenericOpinion server, ref WfClientOpinion client)
        {
            server.NullCheck("server");

            if (client == null)
            {
                client = new WfClientOpinion();
            }

            client.ID          = server.ID;
            client.ResourceID  = server.ResourceID;
            client.ActivityID  = server.ActivityID;
            client.ProcessID   = server.ProcessID;
            client.Content     = server.Content;
            client.OpinionType = server.OpinionType;
            client.LevelName   = server.LevelName;
            client.LevelDesp   = server.LevelDesp;
            client.IssueTime   = server.IssueDatetime;
            client.AppendTime  = server.AppendDatetime;
            client.ExtraData   = server.RawExtData;

            if (server.IssuePerson != null)
            {
                client.IssuePersonID   = server.IssuePerson.ID;
                client.IssuePersonName = server.IssuePerson.DisplayName;
            }

            if (server.AppendPerson != null)
            {
                client.AppendPersonID   = server.AppendPerson.ID;
                client.AppendPersonName = server.AppendPerson.DisplayName;
            }

            return(client);
        }
Exemple #3
0
        public GenericOpinion ClientToServer(WfClientOpinion client, ref GenericOpinion server)
        {
            client.NullCheck("client");

            if (server == null)
            {
                server = new GenericOpinion();
            }

            server.ID          = client.ID;
            server.ResourceID  = client.ResourceID;
            server.ActivityID  = client.ActivityID;
            server.ProcessID   = client.ProcessID;
            server.Content     = client.Content;
            server.OpinionType = client.OpinionType;
            server.LevelName   = client.LevelName;
            server.LevelDesp   = client.LevelDesp;
            server.IssuePerson = new OguUser(client.IssuePersonID)
            {
                Name = client.IssuePersonName, DisplayName = client.IssuePersonName
            };
            server.AppendPerson = new OguUser(client.AppendPersonID)
            {
                Name = client.AppendPersonName, DisplayName = client.AppendPersonName
            };
            server.IssueDatetime  = client.IssueTime;
            server.AppendDatetime = client.AppendTime;
            server.RawExtData     = client.ExtraData;

            return(server);
        }
        public void SimpleOpinionServerToClientTest()
        {
            GenericOpinion server = PrepareServerOpinion();

            WfClientOpinion client = null;

            WfClientOpinionConverter.Instance.ServerToClient(server, ref client);

            client.AreSame(server);
        }
        public void SimpleOpinionClientToServerTest()
        {
            WfClientOpinion client = PrepareClientOpinion();

            GenericOpinion server = null;

            WfClientOpinionConverter.Instance.ClientToServer(client, ref server);

            client.AreSame(server);
        }
        private static void SaveOpinion(WfClientOpinion client)
        {
            if (client != null)
            {
                GenericOpinion server = null;

                WfClientOpinionConverter.Instance.ClientToServer(client, ref server);

                GenericOpinionAdapter.Instance.Update(server);
            }
        }
        private static void SaveAbortOpinion(WfClientOpinion client)
        {
            if (client != null)
            {
                Dictionary <string, object> extraDataDict = new Dictionary <string, object>();

                extraDataDict["NextSteps"] = PrepareAbortProcessNextStepsString();

                client.FillExtraDataFromDictionary(extraDataDict);

                SaveOpinion(client);
            }
        }
        public void SimpleOpinionSerializationTest()
        {
            WfClientJsonConverterHelper.Instance.RegisterConverters();

            WfClientOpinion client = PrepareClientOpinion();

            string data = JSONSerializerExecute.Serialize(client);

            Console.WriteLine(data);

            WfClientOpinion deserializedOpinion = JSONSerializerExecute.Deserialize <WfClientOpinion>(data);

            client.AreSame(deserializedOpinion);
        }
        private static void SaveOpinion(WfClientOpinion client, IWfActivity currentActivity, WfTransferParams transferParams)
        {
            if (client != null)
            {
                WfTransitionDescriptorCollection nextTransitions = currentActivity.Descriptor.ToTransitions.GetAllCanTransitTransitions(true);

                Dictionary <string, object> extraDataDict = new Dictionary <string, object>();

                extraDataDict["NextSteps"] = PrepareNextStepsSelectorsString(nextTransitions, transferParams);

                client.FillExtraDataFromDictionary(extraDataDict);

                SaveOpinion(client);
            }
        }
Exemple #10
0
        public static WfClientProcess Save(WfClientSaveParameters parameters)
        {
            IWfProcess process = WfRuntime.GetProcessByProcessID(parameters.ProcessID);

            IWfActivity activity = process.CurrentActivity;

            WfSaveDataExecutor executor = new WfSaveDataExecutor(activity, activity);

            WfClientOpinion opinion = parameters.CurrentOpinion;

            GenericOpinion serverOpinion = PrepareOpinion(process.CurrentActivity, parameters.CurrentOpinion, DeluxeIdentity.CurrentUser);

            executor.PrepareApplicationData += dataContext => GenericOpinionAdapter.Instance.Update(serverOpinion);

            return(GetClientProcess(executor.Execute()));
        }
Exemple #11
0
        private static void FillPersonInfo(WfClientOpinion opinion, WfClientUser user, WfClientUser delegateUser)
        {
            if (delegateUser == null)
            {
                delegateUser = user;
            }

            if (user != null)
            {
                opinion.IssuePersonID   = user.ID;
                opinion.IssuePersonName = user.DisplayName;

                opinion.AppendPersonID   = delegateUser.ID;
                opinion.AppendPersonName = delegateUser.DisplayName;
            }
        }
Exemple #12
0
        public List <WfClientOpinion> ServerToClient(GenericOpinionCollection server)
        {
            server.NullCheck("server");

            List <WfClientOpinion> client = new List <WfClientOpinion>();

            foreach (GenericOpinion opinion in server)
            {
                WfClientOpinion clientOpinion = null;

                ServerToClient(opinion, ref clientOpinion);

                client.Add(clientOpinion);
            }

            return(client);
        }
Exemple #13
0
        /// <summary>
        /// 生成活动相关的意见
        /// </summary>
        /// <param name="originalActivity"></param>
        /// <param name="user"></param>
        /// <param name="delegateUser"></param>
        /// <param name="content"></param>
        /// <param name="extraData"></param>
        /// <returns></returns>
        public WfClientOpinion GenerateOpinionFromActivity(IWfActivity originalActivity, WfClientUser user, WfClientUser delegateUser, string content, string extraData)
        {
            WfClientOpinion opinion = new WfClientOpinion();

            if (originalActivity != null)
            {
                opinion.ResourceID = originalActivity.Process.ResourceID;
                opinion.ProcessID  = originalActivity.Process.ID;
                opinion.ActivityID = originalActivity.ID;

                IWfActivity rootActivity = originalActivity.OpinionRootActivity;

                if (rootActivity.Process.MainStream != null && rootActivity.MainStreamActivityKey.IsNotEmpty())
                {
                    opinion.LevelName = rootActivity.MainStreamActivityKey;
                }
                else
                {
                    if (string.IsNullOrEmpty(rootActivity.Descriptor.AssociatedActivityKey))
                    {
                        opinion.LevelName = rootActivity.Descriptor.Key;
                    }
                    else
                    {
                        opinion.LevelName = rootActivity.Descriptor.AssociatedActivityKey;
                    }
                }

                if (rootActivity.Process.MainStream != null)
                {
                    opinion.LevelDesp = rootActivity.Process.MainStream.Activities[opinion.LevelName].Name;
                }
                else
                {
                    opinion.LevelDesp = rootActivity.Descriptor.Process.Activities[opinion.LevelName].Name;
                }
            }

            opinion.Content   = content;
            opinion.ExtraData = extraData;

            FillPersonInfo(opinion, user, delegateUser);

            return(opinion);
        }
Exemple #14
0
        public static void AreSame(this WfClientOpinion expected, GenericOpinion actual)
        {
            Assert.AreEqual(expected.ID, actual.ID);
            Assert.AreEqual(expected.ResourceID, actual.ResourceID);
            Assert.AreEqual(expected.ActivityID, actual.ActivityID);
            Assert.AreEqual(expected.ProcessID, actual.ProcessID);
            Assert.AreEqual(expected.LevelName, actual.LevelName);
            Assert.AreEqual(expected.LevelDesp, actual.LevelDesp);
            Assert.AreEqual(expected.OpinionType, actual.OpinionType);
            Assert.AreEqual(expected.IssueTime, actual.IssueDatetime);
            Assert.AreEqual(expected.AppendTime, actual.AppendDatetime);

            Assert.AreEqual(expected.IssuePersonID, actual.IssuePerson.ID);
            Assert.AreEqual(expected.IssuePersonName, actual.IssuePerson.DisplayName);

            Assert.AreEqual(expected.AppendPersonID, actual.AppendPerson.ID);
            Assert.AreEqual(expected.AppendPersonName, actual.AppendPerson.DisplayName);

            Assert.AreEqual(expected.ExtraData, actual.RawExtData);
        }
Exemple #15
0
        /// <summary>
        /// 得到在当前活动的意见信息
        /// </summary>
        /// <param name="originalActivity"></param>
        /// <param name="user"></param>
        /// <returns></returns>
        public WfClientOpinion GetUserActivityOpinion(IWfActivity originalActivity, WfClientUser user)
        {
            WfClientOpinion opinion = null;

            if (originalActivity != null && user != null)
            {
                WhereSqlClauseBuilder builder = new WhereSqlClauseBuilder();

                builder.AppendItem("ACTIVITY_ID", originalActivity.ID);
                builder.AppendItem("ISSUE_PERSON_ID", user.ID);

                GenericOpinion serverOpinion = GenericOpinionAdapter.Instance.LoadByBuilder(builder).FirstOrDefault();

                if (serverOpinion != null)
                {
                    WfClientOpinionConverter.Instance.ServerToClient(serverOpinion, ref opinion);
                }
            }

            return(opinion);
        }
        public void ClientOpinionExtraDataTest()
        {
            WfClientOpinion client = PrepareClientOpinion();

            WfClientNextStepCollection nextSteps = WfClientNextStepTest.PrepareNextSteps();

            WfClientNextStep expectedNextStep = nextSteps.GetSelectedStep();

            Dictionary <string, object> extraData = new Dictionary <string, object>();

            XElement root = new XElement("NextSteps");

            nextSteps.ToXElement(root);
            extraData["NextSteps"] = root.ToString();

            client.FillExtraDataFromDictionary(extraData);

            Console.WriteLine("意见结果:{0}", client.GetNextSteps().GetSelectedStep().GetDescription());

            WfClientNextStepTest.AreSame(expectedNextStep, client.GetNextSteps().GetSelectedStep());
        }
        private static WfClientOpinion PrepareClientOpinion()
        {
            WfClientOpinion opinion = new WfClientOpinion();

            opinion.ID = UuidHelper.NewUuidString();
            opinion.ResourceID = UuidHelper.NewUuidString();
            opinion.ActivityID = UuidHelper.NewUuidString();
            opinion.ProcessID = UuidHelper.NewUuidString();
            opinion.LevelName = "TestLevelName";
            opinion.LevelDesp = "LevelDesp";
            opinion.OpinionType = "OpinionType";
            opinion.IssueTime = new DateTime(2014, 10, 9, 0, 0, 0, DateTimeKind.Local);
            opinion.AppendTime = new DateTime(2014, 10, 10, 0, 0, 0, DateTimeKind.Local);
            opinion.Content = "Hello world";
            opinion.IssuePersonID = UuidHelper.NewUuidString();
            opinion.IssuePersonName = "Shen Zheng";
            opinion.AppendPersonID = UuidHelper.NewUuidString();
            opinion.AppendPersonName = "Shen Rong";
            opinion.ExtraData = "Extra Data";

            return opinion;
        }
		public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
		{
			WfClientOpinion opinion = new WfClientOpinion();

			opinion.ID = dictionary.GetValue("id", string.Empty);
			opinion.ResourceID = dictionary.GetValue("resourceID", string.Empty);
			opinion.ActivityID = dictionary.GetValue("activityID", string.Empty);
			opinion.ProcessID = dictionary.GetValue("processID", string.Empty);
			opinion.Content = dictionary.GetValue("content", string.Empty);
			opinion.OpinionType = dictionary.GetValue("opinionType", string.Empty);
			opinion.LevelName = dictionary.GetValue("levelName", string.Empty);
			opinion.LevelDesp = dictionary.GetValue("levelDesp", string.Empty);
			opinion.IssueTime = dictionary.GetValue("issueTime", DateTime.MinValue);
			opinion.AppendTime = dictionary.GetValue("appendTime", DateTime.MinValue);
			opinion.IssuePersonID = dictionary.GetValue("issuePersonID", string.Empty);
			opinion.IssuePersonName = dictionary.GetValue("issuePersonName", string.Empty);
			opinion.AppendPersonID = dictionary.GetValue("appendPersonID", string.Empty);
			opinion.AppendPersonName = dictionary.GetValue("appendPersonName", string.Empty);
			opinion.ExtraData = dictionary.GetValue("extraData", string.Empty);

			return opinion;
		}
Exemple #19
0
        private static WfClientOpinion GetUserActivityOpinion(GenericOpinionCollection opinions, IWfActivity originalActivity, IUser user)
        {
            WfClientOpinion opinion = null;

            GenericOpinion serverOpinion = opinions.Find(o =>
                                                         string.Compare(o.ActivityID, originalActivity.ID, true) == 0 &&
                                                         string.Compare(o.IssuePerson.ID, user.ID, true) == 0);

            if (serverOpinion != null)
            {
                opinion = new WfClientOpinion(serverOpinion);
            }
            else
            {
                opinion = new WfClientOpinion()
                {
                    ID = UuidHelper.NewUuidString()
                }
            };

            return(opinion);
        }
        private static WfClientOpinion PrepareClientOpinion()
        {
            WfClientOpinion opinion = new WfClientOpinion();

            opinion.ID               = UuidHelper.NewUuidString();
            opinion.ResourceID       = UuidHelper.NewUuidString();
            opinion.ActivityID       = UuidHelper.NewUuidString();
            opinion.ProcessID        = UuidHelper.NewUuidString();
            opinion.LevelName        = "TestLevelName";
            opinion.LevelDesp        = "LevelDesp";
            opinion.OpinionType      = "OpinionType";
            opinion.IssueTime        = new DateTime(2014, 10, 9, 0, 0, 0, DateTimeKind.Local);
            opinion.AppendTime       = new DateTime(2014, 10, 10, 0, 0, 0, DateTimeKind.Local);
            opinion.Content          = "Hello world";
            opinion.IssuePersonID    = UuidHelper.NewUuidString();
            opinion.IssuePersonName  = "Shen Zheng";
            opinion.AppendPersonID   = UuidHelper.NewUuidString();
            opinion.AppendPersonName = "Shen Rong";
            opinion.ExtraData        = "Extra Data";

            return(opinion);
        }
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfClientOpinion opinion = new WfClientOpinion();

            opinion.ID               = dictionary.GetValue("id", string.Empty);
            opinion.ResourceID       = dictionary.GetValue("resourceID", string.Empty);
            opinion.ActivityID       = dictionary.GetValue("activityID", string.Empty);
            opinion.ProcessID        = dictionary.GetValue("processID", string.Empty);
            opinion.Content          = dictionary.GetValue("content", string.Empty);
            opinion.OpinionType      = dictionary.GetValue("opinionType", string.Empty);
            opinion.LevelName        = dictionary.GetValue("levelName", string.Empty);
            opinion.LevelDesp        = dictionary.GetValue("levelDesp", string.Empty);
            opinion.IssueTime        = dictionary.GetValue("issueTime", DateTime.MinValue);
            opinion.AppendTime       = dictionary.GetValue("appendTime", DateTime.MinValue);
            opinion.IssuePersonID    = dictionary.GetValue("issuePersonID", string.Empty);
            opinion.IssuePersonName  = dictionary.GetValue("issuePersonName", string.Empty);
            opinion.AppendPersonID   = dictionary.GetValue("appendPersonID", string.Empty);
            opinion.AppendPersonName = dictionary.GetValue("appendPersonName", string.Empty);
            opinion.ExtraData        = dictionary.GetValue("extraData", string.Empty);

            return(opinion);
        }
        public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            WfClientOpinion opinion = (WfClientOpinion)obj;

            Dictionary <string, object> dictionary = new Dictionary <string, object>();

            dictionary.AddNonDefaultValue("id", opinion.ID);
            dictionary.AddNonDefaultValue("resourceID", opinion.ResourceID);
            dictionary.AddNonDefaultValue("activityID", opinion.ActivityID);
            dictionary.AddNonDefaultValue("processID", opinion.ProcessID);
            dictionary.AddNonDefaultValue("content", opinion.Content);
            dictionary.AddNonDefaultValue("opinionType", opinion.OpinionType);
            dictionary.AddNonDefaultValue("levelName", opinion.LevelName);
            dictionary.AddNonDefaultValue("levelDesp", opinion.LevelDesp);
            dictionary.AddNonDefaultValue("issueTime", opinion.IssueTime);
            dictionary.AddNonDefaultValue("appendTime", opinion.AppendTime);
            dictionary.AddNonDefaultValue("issuePersonID", opinion.IssuePersonID);
            dictionary.AddNonDefaultValue("issuePersonName", opinion.IssuePersonName);
            dictionary.AddNonDefaultValue("appendPersonID", opinion.AppendPersonID);
            dictionary.AddNonDefaultValue("appendPersonName", opinion.AppendPersonName);
            dictionary.AddNonDefaultValue("extraData", opinion.ExtraData);

            return(dictionary);
        }
        private static void SaveOpinion(WfClientOpinion client)
        {
            if (client != null)
            {
                GenericOpinion server = null;

                WfClientOpinionConverter.Instance.ClientToServer(client, ref server);

                GenericOpinionAdapter.Instance.Update(server);
            }
        }
        private static void SaveOpinion(WfClientOpinion client, IWfActivity currentActivity, WfTransferParams transferParams)
        {
            if (client != null)
            {
                WfTransitionDescriptorCollection nextTransitions = currentActivity.Descriptor.ToTransitions.GetAllCanTransitTransitions(true);

                Dictionary<string, object> extraDataDict = new Dictionary<string, object>();

                extraDataDict["NextSteps"] = PrepareNextStepsSelectorsString(nextTransitions, transferParams);

                client.FillExtraDataFromDictionary(extraDataDict);

                SaveOpinion(client);
            }
        }
        private static void SaveAbortOpinion(WfClientOpinion client)
        {
            if (client != null)
            {
                Dictionary<string, object> extraDataDict = new Dictionary<string, object>();

                extraDataDict["NextSteps"] = PrepareAbortProcessNextStepsString();

                client.FillExtraDataFromDictionary(extraDataDict);

                SaveOpinion(client);
            }
        }
        public WfClientProcessInfo StartWorkflowAndMoveTo(WfClientProcessStartupParams clientStartupParams, WfClientTransferParams clientTransferParams, WfClientRuntimeContext runtimeContext)
        {
            if (clientStartupParams == null)
            {
                throw new ApplicationException(Translator.Translate(Define.DefaultCulture, "流程的启动参数不能为空"));
            }

            //设置标准参数,优先使用外部参数
            if (!clientStartupParams.ApplicationRuntimeParameters.ContainsKey("ProcessRequestor"))
            {
                clientStartupParams.ApplicationRuntimeParameters["ProcessRequestor"] = clientStartupParams.Creator;
            }

            OperationContext.Current.FillContextToOguServiceContext();

            WfProcessStartupParams startupParams = null;

            WfClientProcessStartupParamsConverter.Instance.ClientToServer(clientStartupParams, ref startupParams);

            WfTransferParams transferParams = null;

            if (clientTransferParams != null)
            {
                WfClientTransferParamsConverter.Instance.ClientToServer(clientTransferParams, null, ref transferParams);

                MergeTransferParams(transferParams, runtimeContext);
            }

            IWfProcess process = null;

            DoPrincipalAction(startupParams.Creator, () =>
            {
                WfStartWorkflowExecutor executor = new WfStartWorkflowExecutor(null, startupParams, transferParams);

                executor.AfterModifyWorkflow += (dataContext =>
                {
                    dataContext.CurrentProcess.GenerateCandidatesFromResources();
                    clientStartupParams.ProcessContext.ForEach(kp => dataContext.CurrentProcess.Context[kp.Key] = kp.Value);

                    WfClientProcessInfoBaseConverter.Instance.FillOpinionInfoByProcessByActivity(
                        clientStartupParams.Opinion,
                        dataContext.CurrentProcess.InitialActivity,
                        clientStartupParams.Creator,
                        clientStartupParams.Creator);
                });

                WfClientOpinion opinion = clientStartupParams.Opinion;

                if (opinion == null)
                {
                    opinion = runtimeContext.Opinion;
                }

                executor.SaveApplicationData += (dataContext) => SaveOpinion(opinion, dataContext.CurrentProcess.InitialActivity, executor.TransferParams);

                if (clientStartupParams.AutoPersist)
                {
                    process = executor.Execute();
                }
                else
                {
                    process = executor.ExecuteNotPersist();
                }
            });

            return(process.ToClientProcessInfo(clientStartupParams.Creator).FillCurrentOpinion(process.CurrentActivity, clientStartupParams.Creator));
        }
        public static void AreSame(this WfClientOpinion expected, WfClientOpinion actual)
        {
            Assert.AreEqual(expected.ID, actual.ID);
            Assert.AreEqual(expected.ResourceID, actual.ResourceID);
            Assert.AreEqual(expected.ActivityID, actual.ActivityID);
            Assert.AreEqual(expected.ProcessID, actual.ProcessID);
            Assert.AreEqual(expected.LevelName, actual.LevelName);
            Assert.AreEqual(expected.LevelDesp, actual.LevelDesp);
            Assert.AreEqual(expected.OpinionType, actual.OpinionType);
            Assert.AreEqual(expected.IssueTime, actual.IssueTime);
            Assert.AreEqual(expected.AppendTime, actual.AppendTime);

            Assert.AreEqual(expected.IssuePersonID, actual.IssuePersonID);
            Assert.AreEqual(expected.IssuePersonName, actual.IssuePersonName);

            Assert.AreEqual(expected.AppendPersonID, actual.AppendPersonID);
            Assert.AreEqual(expected.AppendPersonName, actual.AppendPersonName);

            Assert.AreEqual(expected.ExtraData, actual.ExtraData);
        }
        /// <summary>
        /// 把当前环节的信息填充到意见当中
        /// </summary>
        /// <param name="opinion"></param>
        /// <param name="originalActivity"></param>
        /// <param name="user"></param>
        /// <param name="delegatedUser"></param>
        public void FillOpinionInfoByProcessByActivity(WfClientOpinion opinion, IWfActivity originalActivity, WfClientUser user, WfClientUser delegatedUser)
        {
            if (opinion != null && originalActivity != null)
            {
                if (opinion.ID.IsNullOrEmpty())
                    opinion.ID = UuidHelper.NewUuidString();

                opinion.ResourceID = originalActivity.Process.ResourceID;
                opinion.ProcessID = originalActivity.Process.ID;
                opinion.ActivityID = originalActivity.ID;

                IWfActivity rootActivity = originalActivity.OpinionRootActivity;

                if (rootActivity.Process.MainStream != null && rootActivity.MainStreamActivityKey.IsNotEmpty())
                {
                    opinion.LevelName = rootActivity.MainStreamActivityKey;
                }
                else
                {
                    if (string.IsNullOrEmpty(rootActivity.Descriptor.AssociatedActivityKey))
                        opinion.LevelName = rootActivity.Descriptor.Key;
                    else
                        opinion.LevelName = rootActivity.Descriptor.AssociatedActivityKey;
                }

                if (rootActivity.Process.MainStream != null)
                    opinion.LevelDesp = rootActivity.Process.MainStream.Activities[opinion.LevelName].Name;
                else
                    opinion.LevelDesp = rootActivity.Descriptor.Process.Activities[opinion.LevelName].Name;

                if (user != null)
                {
                    opinion.IssuePersonID = user.ID;
                    opinion.IssuePersonName = user.DisplayName;

                    if (originalActivity != null)
                    {
                        IUser delegator = originalActivity.Assignees.FindDelegator((IUser)user.ToOguObject());

                        opinion.IssuePersonID = delegator.ID;
                        opinion.IssuePersonName = delegator.DisplayName;
                    }

                    if (delegatedUser == null)
                        delegatedUser = user;

                    opinion.AppendPersonID = delegatedUser.ID;
                    opinion.AppendPersonName = delegatedUser.DisplayName;
                }
            }
        }
Exemple #29
0
        /// <summary>
        /// 把当前环节的信息填充到意见当中
        /// </summary>
        /// <param name="opinion"></param>
        /// <param name="originalActivity"></param>
        /// <param name="user"></param>
        /// <param name="delegatedUser"></param>
        public void FillOpinionInfoByProcessByActivity(WfClientOpinion opinion, IWfActivity originalActivity, WfClientUser user, WfClientUser delegatedUser)
        {
            if (opinion != null && originalActivity != null)
            {
                if (opinion.ID.IsNullOrEmpty())
                {
                    opinion.ID = UuidHelper.NewUuidString();
                }

                opinion.ResourceID = originalActivity.Process.ResourceID;
                opinion.ProcessID  = originalActivity.Process.ID;
                opinion.ActivityID = originalActivity.ID;

                IWfActivity rootActivity = originalActivity.OpinionRootActivity;

                if (rootActivity.Process.MainStream != null && rootActivity.MainStreamActivityKey.IsNotEmpty())
                {
                    opinion.LevelName = rootActivity.MainStreamActivityKey;
                }
                else
                {
                    if (string.IsNullOrEmpty(rootActivity.Descriptor.AssociatedActivityKey))
                    {
                        opinion.LevelName = rootActivity.Descriptor.Key;
                    }
                    else
                    {
                        opinion.LevelName = rootActivity.Descriptor.AssociatedActivityKey;
                    }
                }

                if (rootActivity.Process.MainStream != null)
                {
                    opinion.LevelDesp = rootActivity.Process.MainStream.Activities[opinion.LevelName].Name;
                }
                else
                {
                    opinion.LevelDesp = rootActivity.Descriptor.Process.Activities[opinion.LevelName].Name;
                }

                if (user != null)
                {
                    opinion.IssuePersonID   = user.ID;
                    opinion.IssuePersonName = user.DisplayName;

                    if (originalActivity != null)
                    {
                        IUser delegator = originalActivity.Assignees.FindDelegator((IUser)user.ToOguObject());

                        opinion.IssuePersonID   = delegator.ID;
                        opinion.IssuePersonName = delegator.DisplayName;
                    }

                    if (delegatedUser == null)
                    {
                        delegatedUser = user;
                    }

                    opinion.AppendPersonID   = delegatedUser.ID;
                    opinion.AppendPersonName = delegatedUser.DisplayName;
                }
            }
        }