public void SimpleProcessWithMainStreamSerializationTest()
{
WfClientJsonConverterHelper.Instance.RegisterConverters();
WfClientUser[] users = new WfClientUser[] { Consts.Users["Requestor"] };
IWfProcess process = ProcessHelper.CreateFreeStepsProcessInstance(users.ToOguObjects <WfClientUser, IUser>().ToArray());
WfClientProcess client = null;
WfClientProcessConverter.InstanceAllInfo.ServerToClient(process, ref client);
Assert.IsNotNull(client.InitialActivity);
Assert.IsNotNull(client.CompletedActivity);
Assert.IsNotNull(client.MainStream);
Assert.IsTrue(client.ApplicationRuntimeParameters.Count > 0);
string data = JSONSerializerExecute.Serialize(client);
Console.WriteLine(data);
WfClientProcess deserializedProcess = JSONSerializerExecute.Deserialize <WfClientProcess>(data);
Assert.IsNotNull(deserializedProcess.InitialActivity);
Assert.IsNotNull(deserializedProcess.CompletedActivity);
Assert.IsNotNull(deserializedProcess.MainStream);
Assert.IsTrue(deserializedProcess.ApplicationRuntimeParameters.Count > 0);
Assert.AreEqual(deserializedProcess.InitialActivity.ID, deserializedProcess.CurrentActivity.ID);
}
public WfClientProcess ServerToClient(IWfProcess process, ref WfClientProcess client)
{
WfClientProcessDescriptor clientDescriptor = null;
WfClientProcessDescriptor clientMainStream = null;
if ((this._Filter & WfClientProcessInfoFilter.Descriptor) != WfClientProcessInfoFilter.InstanceOnly)
{
WfClientProcessDescriptorConverter.Instance.ServerToClient((WfProcessDescriptor)process.Descriptor, ref clientDescriptor);
}
if ((this._Filter & WfClientProcessInfoFilter.MainStream) != WfClientProcessInfoFilter.InstanceOnly)
{
WfClientProcessDescriptorConverter.Instance.ServerToClient((WfProcessDescriptor)process.MainStream, ref clientMainStream);
}
if (client == null)
{
client = new WfClientProcess(clientDescriptor, clientMainStream);
}
WfClientProcessInfoBaseConverter.Instance.ServerToClient(process, client);
ServerActivitiesToClient(process, client);
if ((this._Filter & WfClientProcessInfoFilter.BindActivityDescriptors) != WfClientProcessInfoFilter.InstanceOnly)
{
client.NormalizeActivities();
}
return(client);
}
public void StartWorkflowWithoutPersist()
{
WfClientProcessDescriptor processDesp = OperationHelper.PrepareSimpleProcess();
WfClientProcessStartupParams clientStartupParams = ProcessRuntimeHelper.PrepareClientProcessStartupParams(processDesp.Key);
clientStartupParams.AutoPersist = false;
WfClientProcessInfo processInfo = WfClientProcessRuntimeServiceProxy.Instance.StartWorkflow(clientStartupParams);
processInfo.Output();
AssertStartedProcess(processInfo, clientStartupParams);
try
{
WfClientProcess process = WfClientProcessRuntimeServiceProxy.Instance.GetProcessByID(processInfo.ID, Consts.Users["Requestor"]);
}
catch (WfClientChannelException ex)
{
if (ex.Message.IndexOf("不能找到") == -1)
{
throw ex;
}
}
}
public void ClearTenantProcessInstanceDataTest()
{
WfClientProcessQueryCondition condition = new WfClientProcessQueryCondition();
condition.BeginStartTime = DateTime.Now.AddHours(-1);
condition.EndStartTime = DateTime.Now.AddHours(1);
condition.ProcessCreatorID = Consts.Users["Requestor"].ID;
TenantContext.Current.DoActions("Test2", () =>
{
WfClientProcessInfo process = OperationHelper.PrepareSimpleProcessInstance();
WfClientProcess processLoaded = WfClientProcessRuntimeServiceProxy.Instance.GetProcessByID(process.ID, Consts.Users["Requestor"]);
Assert.IsNotNull(processLoaded);
WfClientProcessRuntimeServiceProxy.Instance.ClearTenantProcessInstanceData("Test2");
try
{
processLoaded = WfClientProcessRuntimeServiceProxy.Instance.GetProcessByID(process.ID, Consts.Users["Requestor"]);
Assert.Fail("流程已经被删除，加载流程不能成功");
}
catch (System.Exception)
{
}
});
}
public List <WfClientProcess> GetProcessesByResourceID(string resourceID, WfClientUser user, WfClientProcessInfoFilter filter)
{
resourceID.CheckStringIsNullOrEmpty("resourceID");
OperationContext.Current.FillContextToOguServiceContext();
WfProcessCollection processes = WfRuntime.GetProcessByResourceID(resourceID).SortByUserRelativity((IUser)user.ToOguObject());
WfClientProcessConverter converter = new WfClientProcessConverter(filter);
List <WfClientProcess> result = new List <WfClientProcess>();
foreach (IWfProcess process in processes)
{
WfClientProcess client = null;
converter.ServerToClient(process, ref client);
client.AuthorizationInfo = WfClientProcessInfoBaseConverter.Instance.GetAuthorizationInfo(process, process.CurrentActivity, user);
if ((filter & WfClientProcessInfoFilter.CurrentOpinion) == WfClientProcessInfoFilter.CurrentOpinion)
{
client.FillCurrentOpinion(process.CurrentActivity, user);
}
result.Add(client);
}
return(result);
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
WfClientProcess process = (WfClientProcess)base.Deserialize(dictionary, type, serializer);
JSONSerializerExecute.FillDeserializedCollection(dictionary.GetValue("activities", (object)null), process.Activities);
process.NormalizeActivities();
return(process);
}
public void GetProcessByAcvtivityIDTest()
{
WfClientProcessInfo processInfo = OperationHelper.PreapreProcessWithConditionLinesInstance();
WfClientProcess process = WfClientProcessRuntimeServiceProxy.Instance.GetProcessByActivityID(processInfo.CurrentActivity.ID, Consts.Users["Requestor"]);
Assert.AreEqual(processInfo.ID, processInfo.ID);
Assert.AreEqual(processInfo.Status, processInfo.Status);
Assert.AreEqual(processInfo.CurrentActivity.DescriptorKey, process.CurrentActivity.Descriptor.Key);
}
private static void ServerActivitiesToClient(IWfProcess server, WfClientProcess client)
{
foreach (IWfActivity activity in server.Activities)
{
WfClientActivity clientActivity = null;
WfClientActivityConverter.WithoutDescriptorInstance.ServerToClient(activity, ref clientActivity);
client.Activities.Add(clientActivity);
}
}
private static void ServerActivitiesToClient(IWfProcess server, WfClientProcess client)
{
foreach (IWfActivity activity in server.Activities)
{
WfClientActivity clientActivity = null;
WfClientActivityConverter.WithoutDescriptorInstance.ServerToClient(activity, ref clientActivity);
client.Activities.Add(clientActivity);
}
}
public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
{
IDictionary <string, object> dictionary = base.Serialize(obj, serializer);
WfClientProcess process = (WfClientProcess)obj;
dictionary.AddNonDefaultValue("descriptor", process.Descriptor);
dictionary.AddNonDefaultValue("mainStream", process.MainStream);
dictionary.AddNonDefaultValue("activities", process.Activities);
return(dictionary);
}
public void SimpleProcessSortedActivitiesTest()
{
WfClientProcessDescriptor clientProcessDesp = ProcessDescriptorHelper.CreateClientProcessWithConditionLines();
IWfProcess process = ProcessHelper.CreateProcessInstance(clientProcessDesp);
WfClientProcess client = null;
WfClientProcessConverter.InstanceWithoutActivityBindings.ServerToClient(process, ref client);
client.NormalizeActivities();
WfClientActivityCollection sortedActivities = client.GetSortedActivities();
foreach (WfClientActivity act in sortedActivities)
{
Console.WriteLine(act.Descriptor.Key);
}
}
public WfClientProcess GetProcessByID(string processID, WfClientUser user, WfClientProcessInfoFilter filter)
{
processID.CheckStringIsNullOrEmpty("processID");
OperationContext.Current.FillContextToOguServiceContext();
IWfProcess process = WfRuntime.GetProcessByProcessID(processID);
WfClientProcess client = null;
new WfClientProcessConverter(filter).ServerToClient(process, ref client);
client.AuthorizationInfo = WfClientProcessInfoBaseConverter.Instance.GetAuthorizationInfo(process, process.CurrentActivity, user);
if ((filter & WfClientProcessInfoFilter.CurrentOpinion) == WfClientProcessInfoFilter.CurrentOpinion)
{
client.FillCurrentOpinion(process.CurrentActivity, user);
}
return(client);
}
public void SimpleProcessServerInstanceToClientTest()
{
WfClientUser[] users = new WfClientUser[] { Consts.Users["Requestor"] };
IWfProcessDescriptor processDesp = ProcessHelper.CreateFreeStepsProcess(users.ToOguObjects <WfClientUser, IUser>().ToArray());
WfProcessStartupParams startupParams = ProcessHelper.GetInstanceOfWfProcessStartupParams(processDesp);
IWfProcess process = WfRuntime.StartWorkflow(startupParams);
process.Context["Context"] = "This is a context";
WfClientProcess client = null;
WfClientProcessConverter.Instance.ServerToClient(process, ref client);
Console.WriteLine(client.InitialActivity.ID);
Console.WriteLine(client.CompletedActivity.ID);
Console.WriteLine(client.Descriptor.Url);
Assert.AreEqual(startupParams.DefaultUrl, client.Descriptor.Url);
Assert.AreEqual(process.Context["Context"], client.ProcessContext["Context"]);
}
public WfClientProcess ServerToClient(IWfProcess process, ref WfClientProcess client)
{
WfClientProcessDescriptor clientDescriptor = null;
WfClientProcessDescriptor clientMainStream = null;
if ((this._Filter & WfClientProcessInfoFilter.Descriptor) != WfClientProcessInfoFilter.InstanceOnly)
WfClientProcessDescriptorConverter.Instance.ServerToClient((WfProcessDescriptor)process.Descriptor, ref clientDescriptor);
if ((this._Filter & WfClientProcessInfoFilter.MainStream) != WfClientProcessInfoFilter.InstanceOnly)
WfClientProcessDescriptorConverter.Instance.ServerToClient((WfProcessDescriptor)process.MainStream, ref clientMainStream);
if (client == null)
client = new WfClientProcess(clientDescriptor, clientMainStream);
WfClientProcessInfoBaseConverter.Instance.ServerToClient(process, client);
ServerActivitiesToClient(process, client);
if ((this._Filter & WfClientProcessInfoFilter.BindActivityDescriptors) != WfClientProcessInfoFilter.InstanceOnly)
client.NormalizeActivities();
return client;
}
public static WfClientProcess DynamicProcessMoveto(WfClientDynamicProcessMovetoParameters parameters)
{
IWfProcess process = WfRuntime.GetProcessByActivityID(parameters.ActivityID);
IWfActivity activity = process.CurrentActivity;
if (parameters.MovetoActivityDescriptor != null)
{
WfActivityDescriptorCreateParams createParams = new WfActivityDescriptorCreateParams();
createParams = new WfActivityDescriptorCreateParams();
createParams.Users = new OguDataCollection <IUser>();
createParams.Name = parameters.MovetoActivityDescriptor.ActivityName;
foreach (WfClientUserResourceDescriptorParameters userResource in parameters.MovetoActivityDescriptor.UserResourceList)
{
createParams.Users.Add(userResource.User);
}
WfAddActivityExecutor executor = new WfAddActivityExecutor(activity, activity, createParams);
executor.Execute();
}
//工作流流向下一个节点
WfClientMovetoParameters movetoParameters = new WfClientMovetoParameters()
{
ProcessID = process.ID,
ActivityID = activity.ID,
ResourceID = process.ResourceID,
Comment = parameters.Comment
};
WfClientProcess clientProcess = WfClientProxy.Moveto(movetoParameters);
return(clientProcess);
}
public static WfClientProcess GetClientProcess(IWfProcess process)
{
process.NullCheck("process");
WfClientProcess clientProcess = new WfClientProcess()
{
ProcessID = process.ID,
ProcessStatus = process.Status.ToString(),
Activities = new List <WfClientActivity>(),
ResourceID = process.ResourceID
};
if (process.Status == WfProcessStatus.Completed)
{
clientProcess.ProcessStatusString = "已完成";
}
else
if (process.Status == WfProcessStatus.Aborted)
{
clientProcess.ProcessStatusString = "已驳回";
}
clientProcess.UISwitches.FillByProcess(process, process.CurrentActivity.ID, DeluxeIdentity.CurrentUser);
GenericOpinionCollection opinions = GenericOpinionAdapter.Instance.Load(
builder => builder.AppendItem("RESOURCE_ID", process.ResourceID));
clientProcess.CurrentOpinion = GetUserActivityOpinion(opinions, process.CurrentActivity, DeluxeIdentity.CurrentUser);
WfMainStreamActivityDescriptorCollection activityCollection = process.GetMainStreamActivities(false);
foreach (var item in activityCollection)
{
IWfActivity activity = item.Activity.Instance;
WfClientActivity clientActivity = new WfClientActivity()
{
ActivityID = item.Activity.Instance.ID,
ActivityName = item.Activity.Name,
ActivityStatus = item.Activity.Instance.Status.ToString(),
IsActive = (item.Activity.Instance.Status == WfActivityStatus.Running),
Approvers = (item.Activity.Instance.Candidates.Count > 0 ? item.Activity.Instance.Candidates[0].User.Name : ""),
ApproverCount = item.Activity.Instance.Candidates.Count,
ActivityScene = item.Activity.Scene,
StartTime = item.Activity.Instance.StartTime
};
if (item.Activity.Instance.Candidates.Count > 1)
{
clientActivity.Approvers += "...";
}
clientActivity.ApproverList = string.Join(",", item.Activity.Instance.Candidates.Select(a => a.User.Name).ToArray());
if (item.Activity.Instance.Status == WfActivityStatus.Running)
{
clientProcess.CurrentActivity = clientActivity;
}
else if (item.Activity.Instance.Status == WfActivityStatus.Completed || item.Activity.Instance.Status == WfActivityStatus.Aborted)
{
var opinion = opinions.Where(o => o.ActivityID == clientActivity.ActivityID).FirstOrDefault();
if (opinion != null)
{
clientActivity.Comment = opinion.Content;
clientActivity.Action = opinion.OpinionType;
clientActivity.Approver = opinion.IssuePerson.DisplayName;
clientActivity.ApprovalTime = opinion.IssueDatetime;
clientActivity.ApprovalElapsedTime = FormatElapsedTime(opinion.IssueDatetime - activity.StartTime);
}
}
clientProcess.Activities.Add(clientActivity);
}
foreach (GenericOpinion go in opinions)
{
WfClientActivity parentActivity = clientProcess.Activities.Where(a => a.ActivityID == go.ActivityID).FirstOrDefault();
if (parentActivity != null)
{
WfClientActivityHistory history = new WfClientActivityHistory()
{
ID = go.ID,
ActivityID = go.ActivityID,
ActivityName = parentActivity.ActivityName,
Action = go.OpinionType,
Comment = go.Content,
Approver = go.IssuePerson.DisplayName,
ApprovalType = parentActivity.ApprovalType,
ApprovalTime = go.IssueDatetime,
ApprovalElapsedTime = FormatElapsedTime(go.IssueDatetime - parentActivity.StartTime)
};
clientProcess.ActivityHistories.Add(history);
}
}
clientProcess.ActivityHistories = clientProcess.ActivityHistories.OrderBy(a => a.ApprovalTime).ToList();
foreach (string key in process.ApplicationRuntimeParameters.Keys)
{
clientProcess.ProcessParameters.Add(key, process.ApplicationRuntimeParameters[key]);
}
return(clientProcess);
}
