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);
}
}
/// <summary>
/// 将ClientState字符串的信息加载到ClientState中
/// </summary>
/// <remarks>
/// 将ClientState字符串的信息加载到ClientState中
/// </remarks>
/// <param name="clientState">ClientState字符串</param>
protected override void LoadClientState(string clientState)
{
if (clientState == null || clientState == "null")
{
return;
}
object[] foArray = JSONSerializerExecute.Deserialize <object[]>(clientState);
if (null != foArray && foArray.Length > 0)
{
OguDataCollection <IOguObject> objs =
(OguDataCollection <IOguObject>)JSONSerializerExecute.DeserializeObject(foArray[0], typeof(OguDataCollection <IOguObject>));
this._selectedOuUserData = objs;
if (foArray.Length > 1 && null != foArray[1])
{
this.Text = foArray[1].ToString();
}
else
{
this.Text = "";
}
}
else
{
this.SelectedOuUserData = new OguDataCollection <IOguObject>();
}
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
EditorParamsDefine paDefine = new EditorParamsDefine();
foreach (KeyValuePair <string, object> item in dictionary)
{
if (string.Compare(item.Key, "serverControlProperties", true) == 0)
{
string strServerControlProperties = DictionaryHelper.GetValue(dictionary, "serverControlProperties", string.Empty);
if (strServerControlProperties.IsNotEmpty())
{
List <ControlPropertyDefine> desControlProperties = JSONSerializerExecute.Deserialize <List <ControlPropertyDefine> >(strServerControlProperties);
desControlProperties.ForEach(pcd =>
{
paDefine.ServerControlProperties.Add(pcd);
});
}
}
else
{
paDefine.Add(item.Key, item.Value != null ? item.Value.ToString() : string.Empty);
}
}
return(paDefine);
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
ClientGridColumn column = new ClientGridColumn();
column.DataField = DictionaryHelper.GetValue(dictionary, "dataField", string.Empty);
column.HeaderText = DictionaryHelper.GetValue(dictionary, "headerText", string.Empty);
column.HeaderTips = DictionaryHelper.GetValue(dictionary, "headerTips", string.Empty);
column.HeaderTipsStyle = DictionaryHelper.GetValue(dictionary, "headerTipsStyle", "{color:Red}");
column.SortExpression = DictionaryHelper.GetValue(dictionary, "sortExpression", string.Empty);
column.SelectColumn = DictionaryHelper.GetValue(dictionary, "selectColumn", false);
column.ShowSelectAll = DictionaryHelper.GetValue(dictionary, "showSelectAll", false);
column.DataType = DictionaryHelper.GetValue(dictionary, "dataType", DataType.String);
column.MaxLength = DictionaryHelper.GetValue(dictionary, "maxLength", 0);
column.FormatString = DictionaryHelper.GetValue(dictionary, "formatString", string.Empty);
column.EditorStyle = DictionaryHelper.GetValue(dictionary, "editorStyle", string.Empty);
column.EditorTooltips = DictionaryHelper.GetValue(dictionary, "editorTooltips", string.Empty);
column.EditorReadOnly = DictionaryHelper.GetValue(dictionary, "editorReadOnly", false);
column.EditorEnabled = DictionaryHelper.GetValue(dictionary, "editorEnabled", true);
column.Visible = DictionaryHelper.GetValue(dictionary, "visible", true);
column.IsDynamicColumn = DictionaryHelper.GetValue(dictionary, "isDynamicColumn", false);
column.AutoBindingValidation = DictionaryHelper.GetValue(dictionary, "autoBindingValidation", false);
column.IsFixedLine = DictionaryHelper.GetValue(dictionary, "isFixedLine", false);
column.IsStatistic = DictionaryHelper.GetValue(dictionary, "isStatistic", false);
if (dictionary.ContainsKey("editTemplate"))
{
column.EditTemplate = JSONSerializerExecute.Deserialize <ClientGridColumnEditTemplate>(dictionary["editTemplate"]);
}
return(column);
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
WfClientUserOperationLog log = new WfClientUserOperationLog();
log.ID = dictionary.GetValue("id", 0);
log.ResourceID = dictionary.GetValue("resourceID", string.Empty);
log.ProcessID = dictionary.GetValue("processID", string.Empty);
log.ActivityID = dictionary.GetValue("activityID", string.Empty);
log.ActivityName = dictionary.GetValue("activityName", string.Empty);
log.Subject = dictionary.GetValue("subject", string.Empty);
log.ApplicationName = dictionary.GetValue("applicationName", string.Empty);
log.ProgramName = dictionary.GetValue("programName", string.Empty);
log.OperationName = dictionary.GetValue("operationName", string.Empty);
log.OperationDescription = dictionary.GetValue("operationDescription", string.Empty);
log.OperationType = dictionary.GetValue("operationType", WfClientOperationType.Update);
log.OperationDateTime = dictionary.GetValue("operationDateTime", new Nullable <DateTime>());
log.CorrelationID = dictionary.GetValue("correlationID", string.Empty);
log.HttpContextString = dictionary.GetValue("httpContextString", string.Empty);
log.Operator = JSONSerializerExecute.Deserialize <WfClientUser>(dictionary.GetValue("operator", (object)null));
log.RealUser = JSONSerializerExecute.Deserialize <WfClientUser>(dictionary.GetValue("realUser", (object)null));
log.TopDepartment = JSONSerializerExecute.Deserialize <WfClientOrganization>(dictionary.GetValue("topDepartment", (object)null));
return(log);
}
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));
}
}
}
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]);
}
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 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);
}
/// <summary>
/// 加载ClientState
/// </summary>
/// <param name="clientState">序列化后的clientState</param>
/// <remarks>加载ClientState</remarks>
protected override void LoadClientState(string clientState)
{
base.LoadClientState(clientState);
object[] foArray = JSONSerializerExecute.Deserialize <object[]>(clientState);
if (foArray != null && foArray.Length > 0)
{
//已选择列表的Items
if (foArray[0] != null && foArray.Length > 0)
{
this.selectedItems = (SelectItemCollection)JSONSerializerExecute.DeserializeObject(foArray[0], typeof(SelectItemCollection));
}
//待选择列表的Items
if (foArray[1] != null && foArray.Length > 1)
{
this.candidateItems = (SelectItemCollection)JSONSerializerExecute.DeserializeObject(foArray[1], typeof(SelectItemCollection));
}
//按钮的Items
if (foArray[2] != null && foArray.Length > 2)
{
this.buttonItems = (ButtonItemCollection)JSONSerializerExecute.DeserializeObject(foArray[2], typeof(ButtonItemCollection));
}
//deltaItems
if (foArray[3] != null && foArray.Length > 3)
{
this.deltaItems = (DeltaItemCollection)JSONSerializerExecute.DeserializeObject(foArray[3], typeof(DeltaItemCollection));
}
}
}
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 override void LoadClientState(string clientState)
{
if (string.IsNullOrEmpty(clientState) == false)
{
this.Properties.CopyFrom(JSONSerializerExecute.Deserialize <PropertyValueCollection>(clientState));
}
}
public override void Write(T currentProperty, PersisterContext <T> context)
{
string value = currentProperty.StringValue;
EditorParamsDefine paraDefine = null;
if (currentProperty.Definition.EditorParams.IsNotEmpty())
{
base.Register();
paraDefine = JSONSerializerExecute.Deserialize <EditorParamsDefine>(currentProperty.Definition.EditorParams);
}
if (value.IsNotEmpty())
{
if (string.Compare(currentProperty.StringValue, currentProperty.Definition.DefaultValue, true) != 0)
{
if (paraDefine.ContainsKey("TagPropertyName") == true)
{
currentProperty.StringValue = PwdCalculate("", string.Format("{0},{1}", context.Properties[paraDefine["TagPropertyName"]].StringValue, value));
}
else
{
currentProperty.StringValue = PwdCalculate("", value);
}
}
}
}
/// <summary>
///反序列化MultiMaterialList
/// </summary>
/// <param name="dictionary">对象类型</param>
/// <param name="type">对象类型</param>
/// <param name="serializer">JS序列化器</param>
/// <returns>反序列化出的对象</returns>
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
MultiMaterialList multiMaterialList = new MultiMaterialList();
object materialList;
if (dictionary.TryGetValue("materials", out materialList))
{
ArrayList materials = (ArrayList)materialList;
for (int i = 0; i < materials.Count; i++)
{
multiMaterialList.Materials.Add(JSONSerializerExecute.Deserialize <Material>(materials[i]));
}
}
object deltaMaterialList;
if (dictionary.TryGetValue("deltaMaterials", out deltaMaterialList))
{
multiMaterialList.DeltaMaterials = JSONSerializerExecute.Deserialize <DeltaMaterialList>(deltaMaterialList);
}
return(multiMaterialList);
}
protected void DoOverridePostData(object sender, MCS.Web.WebControls.PostProgressDoPostedDataEventArgs e)
{
// 先保存当前数据
try
{
ProcessProgress pg = ProcessProgress.Current;
pg.CurrentStep = pg.MaxStep = 1;
pg.MinStep = 0;
var aclMembers = JSONSerializerExecute.Deserialize <SCAclMemberCollection>(e.Steps[0]);
bool all = e.Steps[1].Equals("all");
bool inheritRight = e.Steps[2].Equals("inherit");
var obj = DbUtil.GetEffectiveObject(e.ClientExtraPostedData, null);
InnerDoSave(aclMembers, obj, inheritRight);
AU.Operations.Facade.InstanceWithPermissions.ReplaceAclRecursively((ISCAclContainer)obj, all);
pg.Output.WriteLine("完毕");
}
catch (Exception ex)
{
ProcessProgress.Current.Output.WriteLine(ex.ToString());
ProcessProgress.Current.StatusText = "错误";
ProcessProgress.Current.Response();
}
e.Result.CloseWindow = false;
e.Result.ProcessLog = ProcessProgress.Current.GetDefaultOutput();
}
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);
}
private void tree_GetChildrenData(DeluxeTreeNode parentNode, DeluxeTreeNodeCollection result, string callBackContext)
{
ServiceBrokerContext.Current.SaveContextStates();
try
{
InnerTreeContext context = JSONSerializerExecute.Deserialize <InnerTreeContext>(callBackContext);
if (context.ShowDeletedObjects)
{
ServiceBrokerContext.Current.UseLocalCache = false;
ServiceBrokerContext.Current.ListObjectCondition = ListObjectMask.All;
}
else
{
ServiceBrokerContext.Current.ListObjectCondition = ListObjectMask.Common;
}
OguObjectCollection <IOguObject> parents = UserOUControlSettings.GetConfig().UserOUControlQuery.GetObjects(((IOguObject)parentNode.ExtendedData).ID);
//; OguMechanismFactory.GetMechanism().GetObjects<IOguObject>(
// SearchOUIDType.Guid, ((IOguObject)parentNode.ExtendedData).ID);
BindChildren(result, OnGetChildren(parents[0]), context.MultiSelect, context.ListMask, context.SelectMask);
}
finally
{
ServiceBrokerContext.Current.RestoreSavedStates();
}
}
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);
}
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 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]);
}
public void UpdateUserImage()
{
var userImagePropName = "PhotoKey";
SCUser user = SCObjectGenerator.PrepareUserObject();
SCObjectOperations.Instance.AddUser(user, SCOrganization.GetRoot());
ImageProperty image = ImageGenerator.PrepareImage();
image.ResourceID = user.ID;
Assert.IsTrue(CanSerialize(image));
SCObjectOperations.Instance.UpdateObjectImageProperty(user, userImagePropName, image);
SCUser userLoad = (SCUser)SchemaObjectAdapter.Instance.Load(user.ID);
Assert.IsNotNull(userLoad);
var imageLoad = JSONSerializerExecute.Deserialize <ImageProperty>(userLoad.Properties[userImagePropName].StringValue);
MaterialContentCollection mcc = MaterialContentAdapter.Instance.Load(builder => builder.AppendItem("CONTENT_ID", imageLoad.ID));
Assert.AreEqual(image.Name, imageLoad.Name);
Assert.IsNotNull(mcc);
Assert.AreEqual(1, mcc.Count);
Assert.AreEqual(image.Content.ContentData.Length, mcc[0].ContentData.Length);
SCObjectOperations.Instance.UpdateObjectImageProperty(user, userImagePropName, null);
userLoad = (SCUser)SchemaObjectAdapter.Instance.Load(user.ID);
Assert.AreEqual("", userLoad.Properties[userImagePropName].StringValue);
}
/// <summary>
/// 将所提供的字典转换为<see cref="SchemaDefine"/>类型的对象。
/// </summary>
/// <param name="dictionary">作为名称/值对存储的属性数据的 <see cref="T:System.Collections.Generic.IDictionary^2"/> 实例。</param>
/// <param name="type">所生成对象的类型。</param>
/// <param name="serializer"><see cref="System.Web.Script.Serialization.JavaScriptSerializer"/>实例。</param>
/// <returns>反序列化的对象。</returns>
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
SchemaDefine schemaDefine = new SchemaDefine();
schemaDefine.Name = DictionaryHelper.GetValue(dictionary, "name", string.Empty);
schemaDefine.SnapshotTable = DictionaryHelper.GetValue(dictionary, "snapshotTable", string.Empty);
schemaDefine.Category = DictionaryHelper.GetValue(dictionary, "category", string.Empty);
schemaDefine.SortOrder = DictionaryHelper.GetValue(dictionary, "sortOrder", 0xFFFF);
if (dictionary.ContainsKey("properties"))
{
SchemaPropertyDefineCollection properties = JSONSerializerExecute.Deserialize <SchemaPropertyDefineCollection>(dictionary["properties"]);
schemaDefine.Properties.Clear();
schemaDefine.Properties.CopyFrom(properties);
}
if (dictionary.ContainsKey("tabs"))
{
SchemaTabDefineColleciton tabs = JSONSerializerExecute.Deserialize <SchemaTabDefineColleciton>(dictionary["Tabs"]);
schemaDefine.Tabs.Clear();
schemaDefine.Tabs.CopyFrom(tabs);
}
return(schemaDefine);
}
protected override void LoadClientState(string clientState)
{
if (string.IsNullOrEmpty(clientState) == false)
{
this.imgProp = JSONSerializerExecute.Deserialize <ImageProperty>(clientState);
}
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
WfClientProcessStartupParams startupParams = new WfClientProcessStartupParams();
startupParams.AutoStartInitialActivity = dictionary.GetValue("autoStartInitialActivity", true);
startupParams.AutoCommit = dictionary.GetValue("autoCommit", false);
startupParams.CheckStartProcessUserPermission = dictionary.GetValue("checkStartProcessUserPermission", true);
startupParams.DefaultTaskTitle = dictionary.GetValue("defaultTaskTitle", string.Empty);
startupParams.DefaultUrl = dictionary.GetValue("defaultUrl", string.Empty);
startupParams.ProcessDescriptorKey = dictionary.GetValue("processDescriptorKey", string.Empty);
startupParams.RelativeID = dictionary.GetValue("relativeID", string.Empty);
startupParams.RelativeURL = dictionary.GetValue("relativeURL", string.Empty);
startupParams.ResourceID = dictionary.GetValue("resourceID", string.Empty);
startupParams.RuntimeProcessName = dictionary.GetValue("runtimeProcessName", string.Empty);
startupParams.AutoPersist = dictionary.GetValue("autoPersist", true);
startupParams.Creator = JSONSerializerExecute.Deserialize <WfClientUser>(dictionary.GetValue("creator", (object)null));
startupParams.Department = JSONSerializerExecute.Deserialize <WfClientOrganization>(dictionary.GetValue("department", (object)null));
startupParams.Opinion = JSONSerializerExecute.Deserialize <WfClientOpinion>(dictionary.GetValue("opinion", (object)null));
JSONSerializerExecute.FillDeserializedCollection(dictionary.GetValue("assignees", (object)null), startupParams.Assignees);
JSONSerializerExecute.FillDeserializedDictionary(dictionary, "applicationRuntimeParameters", startupParams.ApplicationRuntimeParameters);
JSONSerializerExecute.FillDeserializedDictionary(dictionary, "processContext", startupParams.ProcessContext);
return(startupParams);
}
/// <summary>
/// 从数据库得到对象的图片
/// </summary>
/// <param name="id"></param>
/// <param name="propertyName"></param>
/// <param name="timePoint"></param>
/// <returns></returns>
public SchemaObjectPhoto LoadObjectPhoto(string id, string propertyName, DateTime timePoint)
{
SchemaObjectPhoto result = null;
SchemaObjectBase obj = SchemaObjectAdapter.Instance.Load(id, timePoint);
if (obj != null)
{
if (obj.Properties.ContainsKey(propertyName))
{
ImageProperty imgInfo = JSONSerializerExecute.Deserialize <ImageProperty>(obj.Properties[propertyName].StringValue);
if (imgInfo != null)
{
MaterialContent mc = MaterialContentAdapter.Instance.Load(builder => builder.AppendItem("CONTENT_ID", imgInfo.ID)).FirstOrDefault();
if (mc != null)
{
result = new SchemaObjectPhoto()
{
ImageInfo = imgInfo, ContentData = mc.ContentData
}
}
;
}
}
}
return(result);
}
public bool ValidateInstance(string jsonData, out string errorMsg)
{
errorMsg = "";
bool result = false;
ValidationResults validateResult = new ValidationResults();
try
{
//反序列化
DEEntityInstance resultInstance = JSONSerializerExecute.Deserialize <DEEntityInstanceBase>(jsonData) as DEEntityInstance;
validateResult = resultInstance.Validate();
if (validateResult.IsValid())
{
result = true;
}
else
{
//错误信息格式 json格式
errorMsg = "[";
foreach (var rst in validateResult)
{
errorMsg += string.Format("{{{0}}},", rst.Message.ToString());
}
errorMsg = errorMsg.TrimEnd(',') + "]";
}
}
catch (Exception e)
{
errorMsg = string.Format("[{{'ErrorMsg':'{0}'}}]", e.Message);
}
return(result);
}
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);
}
public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
{
PropertyDefine pd = new PropertyDefine();
pd.Name = DictionaryHelper.GetValue(dictionary, "name", string.Empty);
pd.DisplayName = DictionaryHelper.GetValue(dictionary, "displayName", string.Empty);
pd.Category = DictionaryHelper.GetValue(dictionary, "category", string.Empty);
pd.DefaultValue = DictionaryHelper.GetValue(dictionary, "defaultValue", string.Empty);
pd.DataType = DictionaryHelper.GetValue(dictionary, "dataType", PropertyDataType.String);
pd.Description = DictionaryHelper.GetValue(dictionary, "description", string.Empty);
pd.ReadOnly = DictionaryHelper.GetValue(dictionary, "readOnly", false);
pd.Visible = DictionaryHelper.GetValue(dictionary, "visible", true);
pd.EditorKey = DictionaryHelper.GetValue(dictionary, "editorKey", string.Empty);
pd.PersisterKey = DictionaryHelper.GetValue(dictionary, "persisterKey", string.Empty);
pd.EditorParamsSettingsKey = DictionaryHelper.GetValue(dictionary, "editorParamsSettingsKey", string.Empty);
pd.EditorParams = DictionaryHelper.GetValue(dictionary, "editorParams", string.Empty);
pd.SortOrder = DictionaryHelper.GetValue(dictionary, "sortOrder", 0xFFFF);
pd.MaxLength = DictionaryHelper.GetValue(dictionary, "maxLength", 0xFFFF);
pd.IsRequired = DictionaryHelper.GetValue(dictionary, "isRequired", false);
pd.ShowTitle = DictionaryHelper.GetValue(dictionary, "showTitle", true);
if (dictionary.ContainsKey("validators") == true)
{
PropertyValidatorDescriptorCollection validators = JSONSerializerExecute.Deserialize <PropertyValidatorDescriptorCollection>(dictionary["validators"]);
pd.Validators.Clear();
pd.Validators.CopyFrom(validators);
}
PropertyValue pv = new PropertyValue(pd);
pv.StringValue = DictionaryHelper.GetValue(dictionary, "value", (string)null);
return(pv);
}
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]);
}
}
//---------------------------------我就素那无耻的分割线---------------------------------//
#region ClientState
/// <summary>
/// 加载ClientState
/// </summary>
/// <remarks>
/// 加载ClientState
/// ClientState中保存的是一个长度为3的一维数组
/// 第一个为选中项目的索引值，如果没有选中则为-1
/// 第二个为选中项目的文本，或者输入的文本
/// 第三个是Items
/// </remarks>
/// <param name="clientState">序列化后的clientState</param>
protected override void LoadClientState(string clientState)
{
base.LoadClientState(clientState);
object[] foArray = JSONSerializerExecute.Deserialize <object[]>(clientState);
if (null != foArray && foArray.Length > 0)
{
this.SelectedIndex = Convert.ToInt32(foArray[0]);
if (foArray.Length > 1 && null != foArray[1])
{
this.Text = foArray[1].ToString();
}
else
{
this.Text = "";
}
if (foArray.Length > 2 && null != foArray[2])
{
this.items = (ListItemCollection)JSONSerializerExecute.DeserializeObject(foArray[2], typeof(ListItemCollection));
}
else
{
this.items = new ListItemCollection();
}
}
else
{
this.SelectedIndex = -1;
this.Text = "";
this.items = new ListItemCollection();
}
}
