void executor_SaveApplicationData(WfExecutorDataContext dataContext)
{
if (Scene.Current.SceneID == "First_Default")
{
var process = dataContext.CurrentProcess;
var properties = this.propertyForm.Properties;
var imgProStr = properties.GetValue("Image", "");
if (imgProStr != "")
{
ImageProperty imgPro = JSONSerializerExecute.Deserialize <ImageProperty>(imgProStr);
if (imgPro.Changed)
{
ImagePropertyAdapter.Instance.UpdateWithContent(imgPro);
properties.SetValue("Image", JSONSerializerExecute.Serialize(imgPro));
}
}
var deltaData = MaterialControl.GetCommonDeltaMaterials();
MaterialAdapter.Instance.SaveCommonDeltaMaterials(deltaData);
//DynamicFormDataAdapter.Instance.Update(this.ViewData.Data);
this.ViewData.Data.Properties = properties;
process.RootProcess.Context["appData"] = SerializationHelper.SerializeObjectToString(this.ViewData.Data, SerializationFormatterType.Binary);
}
}
public void JsonToCreateTransitionParams()
{
Dictionary <string, object> jsonTemplate = new Dictionary <string, object>();
jsonTemplate["Key"] = "T1";
jsonTemplate["Name"] = "Transition1";
jsonTemplate["Condition"] = "Amount > 4000";
jsonTemplate["DefaultSelect"] = true;
Dictionary <string, object>[] variableDicts = new Dictionary <string, object> [1];
variableDicts[0] = new Dictionary <string, object>();
variableDicts[0]["Key"] = "V1";
variableDicts[0]["OriginalType"] = DataType.Int;
variableDicts[0]["OriginalValue"] = 10;
jsonTemplate["Variables"] = variableDicts;
string json = JSONSerializerExecute.Serialize(new Dictionary <string, object>[] { jsonTemplate });
Console.WriteLine(json);
WfCreateTransitionParamCollection transitionParams = new WfCreateTransitionParamCollection(json);
Assert.AreEqual(1, transitionParams.Count);
Assert.AreEqual(jsonTemplate["Key"], transitionParams[0].Parameters["Key"]);
Assert.AreEqual(jsonTemplate["Name"], transitionParams[0].Parameters["Name"]);
Assert.AreEqual(jsonTemplate["Condition"], transitionParams[0].Parameters["Condition"]);
Assert.AreEqual(((Dictionary <string, object>[])jsonTemplate["Variables"]).Length,
((object[])transitionParams[0].Parameters["Variables"]).Length);
}
protected override string SaveClientState()
{
//JSONSerializerExecute.RegisterConverter(typeof(EditorParamsDefineConverter));
List <EnumTypePropertyDescription> enumDefinitions = CollectEnumDescriptions();
return(JSONSerializerExecute.Serialize(enumDefinitions));
}
public string GetActivityRelatedUsers(string activityID)
{
var activityInstance = WfClientContext.Current.CurrentActivity.Process.Activities[activityID];
if (activityInstance == null)
{
return(string.Empty);
}
if (activityInstance.Assignees.Count > 0)
{
WfConverterHelper.RegisterConverters();
var userList = activityInstance.Assignees.ToUsers();
return(JSONSerializerExecute.Serialize(userList));
}
WfAssigneeCollection candidates = activityInstance.Candidates.GetSelectedAssignees();
if (candidates.Count > 0)
{
WfConverterHelper.RegisterConverters();
IEnumerable <IUser> userList = candidates.ToUsers();
return(JSONSerializerExecute.Serialize(userList));
}
return(string.Empty);
}
public void ClientProcessWithWithActivityMatrixResourceDescriptorSerializationTest()
{
WfClientJsonConverterHelper.Instance.RegisterConverters();
WfClientProcessDescriptor processDesp = ProcessDescriptorHelper.CreateClientProcessWithActivityMatrixResourceDescriptor();
string data = JSONSerializerExecute.Serialize(processDesp);
Console.WriteLine(data);
WfClientProcessDescriptor deserialized = JSONSerializerExecute.Deserialize <WfClientProcessDescriptor>(data);
Assert.AreEqual(processDesp.Key, deserialized.Key);
Assert.AreEqual(processDesp.Activities.Count, deserialized.Activities.Count);
Assert.AreEqual(processDesp.InitialActivity.Key, deserialized.InitialActivity.Key);
Assert.AreEqual(processDesp.CompletedActivity.Key, deserialized.CompletedActivity.Key);
Assert.AreEqual(processDesp.InitialActivity.ToTransitions.Count, deserialized.InitialActivity.ToTransitions.Count);
Assert.AreEqual(processDesp.CancelEventReceivers.Count, deserialized.CancelEventReceivers.Count);
Assert.AreEqual(processDesp.CompletedActivity.GetFromTransitions().Count, deserialized.CompletedActivity.GetFromTransitions().Count);
Assert.IsNotNull(deserialized.Activities["N1"]);
Assert.IsTrue(deserialized.Activities["N1"].Resources.Count > 0);
Assert.IsTrue(deserialized.Activities["N1"].Resources[0] is WfClientActivityMatrixResourceDescriptor);
((WfClientActivityMatrixResourceDescriptor)processDesp.Activities["N1"].Resources[0]).AreSame((WfClientActivityMatrixResourceDescriptor)deserialized.Activities["N1"].Resources[0]);
}
private void RenderInitJson()
{
// 查找当前对象的权限定义
var permissionDefine = GetPermissionDefinitions(this.Object.SchemaType);
// 查找当前对象的权限
var aclMembers = AU.Adapters.AUAclAdapter.Instance.LoadByContainerID(this.Object.ID, DateTime.MinValue);
for (int i = 0; i < aclMembers.Count;)
{
if (aclMembers[i].Status == SchemaObjectStatus.Normal)
{
i++;
}
else
{
aclMembers.RemoveAt(i); // 剔除删除的
}
}
Debug.Assert((from acl in aclMembers where acl.Status == SchemaObjectStatus.Normal select acl).Count() == aclMembers.Count, "应该一致");
// 查出角色
var roles = PCService.Instance.LoadRoleDisplayItemsByIds((from r in aclMembers select r.MemberID).Distinct().ToArray());
this.postData.Value = JSONSerializerExecute.Serialize(new ContextData()
{
ContainerID = this.Object.ID, AclMembers = aclMembers, Permissions = permissionDefine, Roles = new RoleDisplayItemCollection(roles)
});
}
protected void bT_Click(object sender, EventArgs e)
{
var imgProStr = propertyGrid.Properties.GetValue("Image1", "");
if (imgProStr != "")
{
ImageProperty imgPro = JSONSerializerExecute.Deserialize <ImageProperty>(imgProStr);
if (imgPro.Changed)
{
ImagePropertyAdapter.Instance.UpdateWithContent(imgPro);
propertyGrid.Properties.SetValue("Image1", JSONSerializerExecute.Serialize(imgPro));
}
}
imgProStr = propertyGrid.Properties.GetValue("Image2", "");
if (imgProStr != "")
{
ImageProperty imgPro = JSONSerializerExecute.Deserialize <ImageProperty>(imgProStr);
if (imgPro.Changed)
{
ImagePropertyAdapter.Instance.UpdateWithContent(imgPro);
propertyGrid.Properties.SetValue("Image2", JSONSerializerExecute.Serialize(imgPro));
}
}
}
protected override string SaveClientState()
{
string result = null;
WfControlNextStep rejectStep = null;
if (WfClientContext.Current.CurrentActivity != null)
{
IWfActivity rejectActivity = null;
switch (RejectMode)
{
case WfRejectMode.RejectToDrafter:
rejectActivity = WfClientContext.Current.CurrentActivity.Process.RootProcess.InitialActivity;
break;
}
if (rejectActivity != null)
{
rejectStep = new WfControlNextStep(rejectActivity);
result = JSONSerializerExecute.Serialize(rejectStep);
}
}
return(result);
}
public void WfVariabledOfPrecessDescriptorConverterTest()
{
WfConverterHelper.RegisterConverters();
WfProcessDescriptor processDesp = (WfProcessDescriptor)WfProcessTestCommon.CreateSimpleProcessDescriptor();
//给流程中变量描述赋值
string guid = Guid.NewGuid().ToString();
WfVariableDescriptor variDesc = new WfVariableDescriptor(guid);
variDesc.Name = "yo";
variDesc.Description = "流程中变量的赋值";
variDesc.Enabled = true;
variDesc.OriginalType = DataType.String;
variDesc.OriginalValue = "原来的变量值";
processDesp.Variables.Add(variDesc);
string result = JSONSerializerExecute.Serialize(processDesp);
Console.WriteLine(result);
WfProcessDescriptor reProcessDesp = JSONSerializerExecute.Deserialize <WfProcessDescriptor>(result);
string reSerialized = JSONSerializerExecute.Serialize(reProcessDesp);
Assert.AreEqual(result, reSerialized);
Assert.AreEqual(processDesp.Variables[0].Name, reProcessDesp.Variables[0].Name);
Assert.AreEqual("流程中变量的赋值", reProcessDesp.Variables[0].Description);
Assert.AreEqual(true, reProcessDesp.Variables[0].Enabled);
Assert.AreEqual(processDesp.Variables[0].OriginalType, reProcessDesp.Variables[0].OriginalType);
}
protected void Page_Load(object sender, EventArgs e)
{
WfExternalUser extUser = new WfExternalUser();
hiddenExtUserTemplate.Value = JSONSerializerExecute.Serialize(extUser);
BindList(ddlGender, EnumItemDescriptionAttribute.GetDescriptionList(typeof(MCS.Library.SOA.DataObjects.Gender)));
}
protected void dataSourceMain_Selected(object sender, ObjectDataSourceStatusEventArgs e)
{
System.Data.DataView view = e.ReturnValue as System.Data.DataView;
if (view != null)
{
HashSet <string> parentIds = new HashSet <string>();
HashSet <string> deleteLimitIds = new HashSet <string>();
foreach (System.Data.DataRow row in view.Table.Rows)
{
string parentID = (string)row["ParentID"];
parentIds.Add(parentID);
}
this.containerPermissions = PC.Adapters.SCAclAdapter.Instance.LoadCurrentContainerAndPermissions(Util.CurrentUser.ID, parentIds);
foreach (System.Data.DataRow row in view.Table.Rows)
{
string parentID = (string)row["ParentID"];
if (this.IsDeleteEnabled(parentID))
{
deleteLimitIds.Add((string)row["ID"]);
}
}
this.deleteLimitList.Value = JSONSerializerExecute.Serialize(deleteLimitIds);
}
}
protected void LoadObject(string id)
{
JobBase result;
//根据ID获取任务对象
result = JobBaseAdapter.Instance.Load(w => w.AppendItem("job_id", id)).FirstOrDefault();// ETLJobAdapter.Instance.Load(id);
this.Data = result;
//给控件赋值
if (this.Data != null)
{
txt_JobName.Text = this.Data.Name;
txt_jobCategory.Text = this.Data.Category.ToString();
txt_JobDescription.Text = this.Data.Description.ToString();
ch_IsAuto.Checked = !this.Data.ISManual;
//etl任务
if (this.Data.JobType == JobType.ETLService)
{
//etl实体列表
List <EtlGridObj> etls = new List <EtlGridObj>();
var etlJob = ETLJobAdapter.Instance.Load(this.Data.JobID);
foreach (ETLEntity item in etlJob.ETLEntities)
{
etls.Add(new EtlGridObj()
{
ID = item.ID,
CodeName = item.Name,
Description = item.Description
});
}
gridEtl.InitialData = etls;
ch_IsIncrement.Checked = etlJob.IsIncrement;
//Where条件
ETLJob loadEtl = ETLJobAdapter.Instance.Load(this.Data.JobID);
conditions.Value = JSONSerializerExecute.Serialize(loadEtl.ETLWhereConditions);
}
//WebService任务
else
{
this.Data = InvokeWebServiceJobAdapter.Instance.Load(w => w.AppendItem("JOB_ID", this.Data.JobID)).FirstOrDefault();
invokingServiceGrid.InitialData = (this.Data as InvokeWebServiceJob).SvcOperationDefs;
}
//是否手动任务
if (!this.Data.ISManual)
{
//计划列表
List <ScheduleGridObj> schedules = new List <ScheduleGridObj>();
foreach (JobSchedule item in this.Data.Schedules)
{
schedules.Add(new ScheduleGridObj()
{
ID = item.ID,
Name = item.Name,
Description = item.Description
});
}
grid.InitialData = schedules;
}
}
}
private void serverConfirmButton_Click(object sender, EventArgs e)
{
try
{
if (this.processGrid != null)
{
List <WorkflowInfo> processInfoList = new List <WorkflowInfo>();
foreach (string key in this.processGrid.SelectedKeys)
{
IWfProcess process = WfRuntime.GetProcessByProcessID(key);
var processInfo = WorkflowInfo.ProcessAdapter(process);
processInfoList.Add(processInfo);
}
HtmlInputHidden resultData = (HtmlInputHidden)WebControlUtility.FindControlByID(this, "resultData", true);
if (resultData != null)
{
resultData.Value = JSONSerializerExecute.Serialize(processInfoList);
}
ScriptManager.RegisterClientScriptBlock(this.Page, this.GetType(), "Close",
string.Format("window.returnValue = $get('{0}').value; top.close()", resultData.ClientID),
true);
}
}
catch (System.Exception ex)
{
string errorScript = WebUtility.GetShowClientErrorScript(ex.Message, ex.StackTrace, "错误");
ScriptManager.RegisterClientScriptBlock(this.Page, this.GetType(), "ShowError",
"SubmitButton.resetAllStates();" + errorScript,
true);
}
}
private void ResponseError(int i, TextWriter output, string message, string stack)
{
message = JSONSerializerExecute.Serialize(message ?? string.Empty);
stack = JSONSerializerExecute.Serialize(stack ?? string.Empty);
output.WriteLine(Util.SurroundScriptBlock(string.Format("top.setError({0},{1},{2});", i.ToString(), message, stack)));
output.Flush();
}
public static string GetEventsListJson(int pageIndex, int pageSize, int totalCount, Dictionary <string, IEnumerable <AMSEvent> > eventsDict)
{
Dictionary <string, ArrayList> eventList = new Dictionary <string, ArrayList>();
foreach (KeyValuePair <string, IEnumerable <AMSEvent> > kp in eventsDict)
{
ArrayList list = new ArrayList();
foreach (AMSEvent eventData in kp.Value)
{
SimpleEventData simpleEventData = new SimpleEventData(eventData);
list.Add(simpleEventData);
}
eventList[kp.Key] = list;
}
var allData = new
{
pageIndex = pageIndex,
pageSize = pageSize,
totalCount = totalCount,
events = eventList
};
return(JSONSerializerExecute.Serialize(allData));
}
public void WfGroupResourceDescriptorConverterTest()
{
WfConverterHelper.RegisterConverters();
IUser user = (IUser)OguObjectSettings.GetConfig().Objects["requestor"].Object;
OguObjectCollection <IGroup> groupColl = user.MemberOf;
foreach (var group in groupColl)
{
WfGroupResourceDescriptor groupDesp = new WfGroupResourceDescriptor(group);
string result = JSONSerializerExecute.Serialize(groupDesp);
Console.WriteLine(result);
WfGroupResourceDescriptor deserializedGroupDesp = JSONSerializerExecute.Deserialize <WfGroupResourceDescriptor>(result);
string reSerialized = JSONSerializerExecute.Serialize(deserializedGroupDesp);
Assert.AreEqual(result, reSerialized);
ResourceConverterTest(groupDesp);
}
}
public override IDictionary <string, object> Serialize(object obj, JavaScriptSerializer serializer)
{
Dictionary <string, object> dictionary = new Dictionary <string, object>();
PropertyValue prop = (PropertyValue)obj;
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "name", prop.Definition.Name);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "displayName", prop.Definition.DisplayName);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "category", prop.Definition.Category);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "defaultValue", prop.Definition.DefaultValue);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "dataType", prop.Definition.DataType);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "description", prop.Definition.Description);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "readOnly", prop.Definition.ReadOnly);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "visible", prop.Definition.Visible);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "editorKey", prop.Definition.EditorKey);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "persisterKey", prop.Definition.PersisterKey);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "isRequired", prop.Definition.IsRequired);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "showTitle", prop.Definition.ShowTitle);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "editorParamsSettingsKey", prop.Definition.EditorParamsSettingsKey);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "editorParams", prop.Definition.EditorParams);
if (prop.Definition.Validators.Count > 0)
{
string jsonStr = JSONSerializerExecute.Serialize(prop.Definition.Validators);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "validators", jsonStr);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "clientVdtData", prop.Definition.GetPropertyValidator());
}
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "maxLength", prop.Definition.MaxLength);
DictionaryHelper.AddNonDefaultValue <string, object>(dictionary, "sortOrder", prop.Definition.SortOrder);
dictionary.Add("value", prop.StringValue);
return(dictionary);
}
public void WfBranchProcessTemplateDescriptorConverterTest()
{
WfConverterHelper.RegisterConverters();
WfBranchProcessTemplateDescriptor branchProcessTempDesp = new WfBranchProcessTemplateDescriptor(Guid.NewGuid().ToString());
branchProcessTempDesp.BlockingType = WfBranchProcessBlockingType.WaitAnyoneBranchProcessComplete;
branchProcessTempDesp.ExecuteSequence = WfBranchProcessExecuteSequence.Serial;
string result = JSONSerializerExecute.Serialize(branchProcessTempDesp);
Console.WriteLine(result);
WfBranchProcessTemplateDescriptor deserializedBranchProcTempDesp = JSONSerializerExecute.Deserialize <WfBranchProcessTemplateDescriptor>(result);
string reSerialized = JSONSerializerExecute.Serialize(deserializedBranchProcTempDesp);
Assert.AreEqual(result, reSerialized);
WfProcessDescriptor processDesp = (WfProcessDescriptor)WfProcessTestCommon.CreateSimpleProcessDescriptor();
processDesp.InitialActivity.BranchProcessTemplates.Add(branchProcessTempDesp);
string procResult = JSONSerializerExecute.Serialize(processDesp);
Console.WriteLine(procResult);
WfProcessDescriptor deserializedProcDesp = JSONSerializerExecute.Deserialize <WfProcessDescriptor>(procResult);
string procReSerialized = JSONSerializerExecute.Serialize(deserializedProcDesp);
Assert.AreEqual(procResult, procReSerialized);
}
protected void Page_Load(object sender, EventArgs e)
{
WfRelativeLinkDescriptor rlink = new WfRelativeLinkDescriptor("");
WfConverterHelper.RegisterConverters();
this.relativeLinkTemplate.Value = JSONSerializerExecute.Serialize(rlink);
}
public void WfExternalUserTest()
{
WfConverterHelper.RegisterConverters();
WfExternalUser externalUser = new WfExternalUser();
externalUser.Key = "user0";
externalUser.Name = "zLing";
externalUser.Gender = Gender.Female;
externalUser.Email = "*****@*****.**";
externalUser.MobilePhone = "13552630000";
externalUser.Phone = "0409987";
externalUser.Title = "programer";
string result = JSONSerializerExecute.Serialize(externalUser);
WfExternalUser deserializedUser = JSONSerializerExecute.Deserialize <WfExternalUser>(result);
string reSerialized = JSONSerializerExecute.Serialize(deserializedUser);
Assert.AreEqual(result, reSerialized);
//创建流程描述
IWfProcessDescriptor processDesp = WfProcessTestCommon.CreateSimpleProcessDescriptor();
processDesp.ExternalUsers.Add(externalUser); //作用于流程
processDesp.InitialActivity.ExternalUsers.Add(externalUser); //作用于节点
string procDesp = JSONSerializerExecute.Serialize(processDesp);
WfProcessDescriptor reProcessDesp = JSONSerializerExecute.Deserialize <WfProcessDescriptor>(procDesp);
string reuslt = JSONSerializerExecute.Serialize(reProcessDesp);
Assert.AreEqual(procDesp, reuslt);
Assert.AreEqual(processDesp.ExternalUsers[0].Name, processDesp.InitialActivity.ExternalUsers[0].Name);
}
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 void WfActivitySerilizeConverterTest()
{
WfConverterHelper.RegisterConverters();
WfActivityDescriptor normalAct = new WfActivityDescriptor("NormalActivity", WfActivityType.NormalActivity);
normalAct.Name = "Normal";
normalAct.CodeName = "Normal Activity";
WfServiceOperationDefinition enterSvcDef = new WfServiceInvokerFactory().SvcOpDef;
enterSvcDef.AddressDef.RequestMethod = WfServiceRequestMethod.Get;
enterSvcDef.OperationName = "StringTypeService";
enterSvcDef.RtnXmlStoreParamName = "EnterServiceRtnXml";
enterSvcDef.Params.Add(new WfServiceOperationParameter()
{
Name = "input",
Type = WfSvcOperationParameterType.String,
Value = "this is a get action!"
});
normalAct.EnterEventExecuteServices.Add(enterSvcDef);
string result = JSONSerializerExecute.Serialize(normalAct);
Console.WriteLine(result);
WfActivityDescriptor deserializedActDesp = JSONSerializerExecute.Deserialize <WfActivityDescriptor>(result);
string reSerialized = JSONSerializerExecute.Serialize(deserializedActDesp);
Assert.AreEqual(result, reSerialized);
}
protected void btnSave_Click(object sender, EventArgs e)
{
try
{
if (CurrentProcess != null)
{
this.propertyGrid.Properties.FillDictionary(CurrentProcess.ApplicationRuntimeParameters);
WfRuntime.ProcessContext.AffectedProcesses.AddOrReplace(CurrentProcess);
WfRuntime.PersistWorkflows();
PropertyValueCollection properties = ObjectToPropertiesHelper.ToProperties <string, object>(CurrentProcess.ApplicationRuntimeParameters);
responseData.Value = JSONSerializerExecute.Serialize(properties);
Page.ClientScript.RegisterStartupScript(this.GetType(), "notifyTop", "notifyTopWindowDataChange();", true);
}
}
catch (System.Exception ex)
{
responseData.Value = string.Empty;
Page.ClientScript.RegisterStartupScript(this.GetType(), "notifyTop", "notifyTopWindowDataChange();", true);
WebUtility.RegisterClientErrorMessage(ex);
}
}
protected void Page_Load(object sender, EventArgs e)
{
WfConverterHelper.RegisterConverters();
WfServiceOperationDefinition svcOpDef = new WfServiceOperationDefinition();
hiddenSvcOperationTemplate.Value = JSONSerializerExecute.Serialize(svcOpDef);
var dataTypeList = EnumItemDescriptionAttribute.GetDescriptionList(typeof(WfSvcOperationParameterType));
dataTypeDropDownList.DataSource = dataTypeList;
dataTypeDropDownList.DataTextField = "Name";
dataTypeDropDownList.DataValueField = "EnumValue";
dataTypeDropDownList.DataBind();
if (Request["hasRtn"] == "false")
{
this.trRtn.Style["display"] = "none";
}
if (!string.IsNullOrEmpty(Request["initPara"]))
{
var initData = new WfServiceOperationParameterCollection();
initData.Add(new WfServiceOperationParameter()
{
Name = Request["initPara"],
Type = WfSvcOperationParameterType.RuntimeParameter,
Value = ""
});
detailGrid.InitialData = initData;
}
}
public void WfTransitionJsonToCreateTransitionParams()
{
WfForwardTransitionDescriptor transition1 = new WfForwardTransitionDescriptor("T1");
transition1.Name = "Transition1";
transition1.Condition.Expression = "Amount > 4000";
transition1.Variables.Add(new WfVariableDescriptor("V1", "Shen Zheng"));
transition1.Variables.Add(new WfVariableDescriptor("Level", "10", DataType.Int));
WfForwardTransitionDescriptor transition2 = new WfForwardTransitionDescriptor("T2");
transition2.Name = "Transition2";
JSONSerializerExecute.RegisterConverter(typeof(EasyWfForwardTransitionDescriptorConverter));
JSONSerializerExecute.RegisterConverter(typeof(WfConditionDescriptorConverter));
JSONSerializerExecute.RegisterConverter(typeof(EasyWfVariableDescriptorConverter));
string json = JSONSerializerExecute.Serialize(new WfForwardTransitionDescriptor[] { transition1, transition2 });
Console.WriteLine(json);
WfCreateTransitionParamCollection transitionParams = new WfCreateTransitionParamCollection(json);
Assert.AreEqual(2, transitionParams.Count);
Assert.AreEqual(transition1.Key, transitionParams[0].Parameters["Key"]);
Assert.AreEqual(transition1.Name, transitionParams[0].Parameters["Name"]);
Assert.AreEqual(transition1.Condition.Expression, transitionParams[0].Parameters["Condition"]);
Assert.AreEqual(transition2.Key, transitionParams[1].Parameters["Key"]);
Assert.AreEqual(transition2.Name, transitionParams[1].Parameters["Name"]);
Assert.IsFalse(transitionParams[1].Parameters.ContainsKey("Condition"));
Assert.AreEqual(transition1.Variables.Count, ((Dictionary <string, object>[])transitionParams[0].Parameters["Variables"]).Length);
}
public void WfBranchProcessTransferParamsJsonTest()
{
WfConverterHelper.RegisterConverters();
IUser user = (IUser)OguObjectSettings.GetConfig().Objects[OguObject.requestor.ToString()].Object;
IWfBranchProcessTemplateDescriptor template = WfProcessTestCommon.CreateTemplate("Consign", user);
WfBranchProcessTransferParams data = new WfBranchProcessTransferParams(template);
data.BranchParams.Clear();
WfBranchProcessStartupParams bpsp = new WfBranchProcessStartupParams(user);
bpsp.Department = user.Parent;
bpsp.RelativeParams["RP"] = UuidHelper.NewUuidString();
bpsp.ApplicationRuntimeParameters["context"] = UuidHelper.NewUuidString();
bpsp.ResourceID = UuidHelper.NewUuidString();
bpsp.DefaultTaskTitle = UuidHelper.NewUuidString();
bpsp.StartupContext = UuidHelper.NewUuidString();
data.BranchParams.Add(bpsp);
string serilizedData = JSONSerializerExecute.Serialize(data);
Console.WriteLine(serilizedData);
WfBranchProcessTransferParams deserilizedData = JSONSerializerExecute.Deserialize <WfBranchProcessTransferParams>(serilizedData);
Assert.AreEqual(data.Template.Key, deserilizedData.Template.Key);
Assert.AreEqual(data.Template.BranchProcessKey, deserilizedData.Template.BranchProcessKey);
AssertBranchProcessStartupParams(data.BranchParams[0], deserilizedData.BranchParams[0]);
}
private static void DoInsert(HttpContext context)
{
string id = context.Request["id"];
string category = context.Request["category"];
string content = context.Request["content"];
if (string.IsNullOrEmpty(id) || string.IsNullOrEmpty(content))
{
return;
}
WfConverterHelper.RegisterConverters();
WfActivityDescriptor activityDesc = JSONSerializerExecute.Deserialize <WfActivityDescriptor>(content);
activityDesc.Key = id;
activityDesc.FromTransitions.Clear();
activityDesc.ToTransitions.Clear();
WfActivityTemplate template = new WfActivityTemplate()
{
ID = id,
Name = activityDesc.Name,
Category = activityDesc.ActivityType.ToString(),
CreateTime = DateTime.Now,
Content = JSONSerializerExecute.Serialize(activityDesc),
Available = true,
CreatorID = DeluxeIdentity.CurrentUser.ID,
CreatorName = DeluxeIdentity.CurrentUser.Name
};
WfActivityTemplateAdpter.Instance.Update(template);
OutputResult(context, true, activityDesc.Key);
}
protected void Page_Load(object sender, EventArgs e)
{
JSONSerializerExecute.RegisterConverter(typeof(WfParameterDescriptorConverter));
WfParameterDescriptor wfpd = new WfParameterDescriptor();
this.hiddenWfParameterTemplate.Value = JSONSerializerExecute.Serialize(wfpd);
}
public void OguApplicationCollectionSerializationTest()
{
JSONSerializerExecute.RegisterConverter(typeof(OguApplicationConverter));
ApplicationCollection originalApps = PermissionMechanismFactory.GetMechanism().GetAllApplications();
OguApplicationCollection apps = new OguApplicationCollection(originalApps);
CheckOguApplicationCollectionItems(apps);
//测试Set操作
for (int i = 0; i < apps.Count; i++)
{
apps[i] = originalApps[i];
}
CheckOguApplicationCollectionItems(apps);
string serializedData = JSONSerializerExecute.Serialize(apps);
Console.WriteLine(serializedData);
OguApplicationCollection deserializedData = JSONSerializerExecute.Deserialize <OguApplicationCollection>(serializedData);
for (int i = 0; i < apps.Count; i++)
{
ValidatePermissionObject(apps[i], deserializedData[i]);
}
}
public void Response()
{
HttpResponse response = HttpContext.Current.Response;
response.Write(string.Format("<script type=\"text/javascript\">top.document.getElementById(\"processResult\").value=\"{0}\";\ntop.document.getElementById(\"processResultButton\").click();</script>",
WebUtility.CheckScriptString(JSONSerializerExecute.Serialize(this), false)));
}
