Beispiel #1
0
        /// <summary>
        /// 生成空开始节点定义的JSON串
        /// </summary>
        /// <returns></returns>
        public static string GetEmptyInitialActivityDescriptorJsonString()
        {
            RegisterConverters();

            WfActivityDescriptor activityDesp = new WfActivityDescriptor(string.Empty, WfActivityType.InitialActivity);

            activityDesp.ActivityType = WfActivityType.InitialActivity;
            activityDesp.Name         = "申请";

            return(JSONSerializerExecute.Serialize(activityDesp));
        }
 public PropertyEditorControlBase()
     : base(true, HtmlTextWriterTag.Div)
 {
     JSONSerializerExecute.RegisterConverter(typeof(PropertyValueConverter));
     JSONSerializerExecute.RegisterConverter(typeof(EnumItemPropertyDescriptionConverter));
     JSONSerializerExecute.RegisterConverter(typeof(PropertyValidatorParameterDescriptorConverter));
     JSONSerializerExecute.RegisterConverter(typeof(PropertyValidatorDescriptorConverter));
     JSONSerializerExecute.RegisterConverter(typeof(EditorParamsDefineConverter));
     JSONSerializerExecute.RegisterConverter(typeof(ControlPropertyDefineConverter));
     //JSONSerializerExecute.RegisterConverter(typeof(ClientVdtDataConverter));
 }
Beispiel #3
0
        private JobBase CreateInvokingServiceJob()
        {
            WfConverterHelper.RegisterConverters();

            InvokeWebServiceJob newJob = new InvokeWebServiceJob();

            SetJobBaseInfo(newJob);
            newJob.SvcOperationDefs = JSONSerializerExecute.Deserialize <WfServiceOperationDefinitionCollection>(this.hdServiceDefinition.Value);

            return(newJob);
        }
        protected override void OnPreRender(EventArgs e)
        {
            Response.Cache.SetNoStore();
            JSONSerializerExecute.RegisterConverter(typeof(PropertyValueConverter));
            JSONSerializerExecute.RegisterConverter(typeof(UserSettingsConverter));
            JSONSerializerExecute.RegisterConverter(typeof(UserSettingsCategoryConverter));

            txtDataSource.Attributes.Add("style", "display:none;");
            btnSubmit.Attributes.Add("onclick", "updateHiddenText();");

            tree.Nodes.Clear();
            tree.OnNodeSelecting = "nodeClick";

            //根据当前登录的用户取得UserSettings的信息
            UserSettings objUserSettings = UserSettings.LoadSettings(DeluxeIdentity.CurrentUser.ID);

            RegisterEnumTypes(objUserSettings);

            DeluxeTreeNode rootNode = new DeluxeTreeNode(TreeRootText, TreeRootText)
            {
                NodeOpenImg  = "../images/computer.gif",
                NodeCloseImg = "../images/computer.gif",
                Expanded     = true
            };

            DeluxeTreeNode node;
            string         fsNodeText  = string.Empty;
            string         fsNodeValue = string.Empty;

            //循环添加二级结点
            for (int i = 0; i < objUserSettings.Categories.Count; i++)
            {
                fsNodeText  = objUserSettings.Categories[i].Description;
                fsNodeValue = objUserSettings.Categories[i].Name;
                node        = new DeluxeTreeNode(fsNodeText, fsNodeValue)
                {
                    NodeOpenImg  = "../images/accomplished.gif",
                    NodeCloseImg = "../images/accomplished.gif",
                    ExtendedData = objUserSettings.Categories[i].Description
                };
                rootNode.Nodes.Add(node);
            }

            tree.Nodes.Add(rootNode);
            if (!IsPostBack)
            {
                if (objUserSettings.Categories.Count != 0)
                {
                    txtDataSource.Text = JSONSerializerExecute.Serialize(objUserSettings);
                }
            }

            base.OnPreRender(e);
        }
Beispiel #5
0
        //protected override void InitDialogContent(Control container)
        //{
        //    this.rootContainer = container;

        //    base.InitDialogContent(container);

        //    container.Controls.Add(this.tree);

        //    HtmlForm form = (HtmlForm)WebControlUtility.FindParentControl(this, typeof(HtmlForm), true);

        //    if (form != null)
        //    {
        //        form.Style["width"] = "100%";
        //        form.Style["height"] = "100%";
        //    }

        //    this.Width = Unit.Percentage(100);
        //    this.Height = Unit.Percentage(100);
        //}

        //protected override void InitConfirmButton(HtmlInputButton confirmButton)
        //{
        //    base.InitConfirmButton(confirmButton);

        //    confirmButton.Attributes["treeControlID"] = tree.ClientID;
        //    confirmButton.Attributes["userControlID"] = this.ClientID;
        //    confirmButton.Attributes["multiSelect"] = this.MultiSelect.ToString().ToLower();
        //    confirmButton.Attributes["onclick"] = "onConfirmButtonClick();";
        //}

        /// <summary>
        /// 保存状态到客户端
        /// </summary>
        /// <returns>序列化后的JSON字符串</returns>
        protected override string SaveClientState()
        {
            if (this.Page.IsCallback == false)
            {
                return(JSONSerializerExecute.Serialize(new object[] { RootNodesData, this.selectedOuUserData }));
            }
            else
            {
                return(string.Empty);
            }
        }
 public static void RegisterConverters()
 {
     JSONSerializerExecute.RegisterConverter(typeof(WeChatBaseResponseConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatLoginRetInfoConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatGroupConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatFriendConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatRecentMessageConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatUploadFileRetInfoConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatAppMessageConverter));
     JSONSerializerExecute.RegisterConverter(typeof(WeChatSingleSendMessageRetInfoConverter));
 }
 private void RenderNextStepsInfo(WfControlNextStepCollection nextSteps)
 {
     if (Enabled)
     {
         WfMoveToControl.DoActionAfterRegisterContextConverter(() =>
                                                               Page.ClientScript.RegisterHiddenField(
                                                                   this.ClientID + "_data",
                                                                   JSONSerializerExecute.Serialize(nextSteps))
                                                               );
     }
 }
Beispiel #8
0
        protected override void OnPreRender(EventArgs e)
        {
            InitTreeNodes(WfApplicationAdapter.Instance.LoadAll());

            var initPropeties = new { Key = "Default", Name = "全局参数", Properties = WfGlobalParameters.LoadDefault().Properties };

            this.ClientScript.RegisterHiddenField("initProperties",
                                                  JSONSerializerExecute.Serialize(initPropeties));

            base.OnPreRender(e);
        }
Beispiel #9
0
        public void UpdateGlobalParameters(string key, string propertiesJson)
        {
            PropertyValueCollection properties = JSONSerializerExecute.Deserialize <PropertyValueCollection>(propertiesJson);

            WfGlobalParameters parameters = WfGlobalParameters.LoadProperties(key);

            parameters.Properties.Clear();
            parameters.Properties.CopyFrom(properties);

            parameters.Update();
        }
Beispiel #10
0
        private static object DeserializeJson(object originalValue, string json)
        {
            object result = originalValue;

            if (originalValue is UnknownSerializationType && json.IsNotEmpty())
            {
                ExceptionHelper.DoSilentAction(() => result = JSONSerializerExecute.DeserializeObject(json));
            }

            return(result);
        }
Beispiel #11
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfClientProcessInfo processInfo = (WfClientProcessInfo)base.Deserialize(dictionary, type, serializer);

            processInfo.CurrentActivity  = JSONSerializerExecute.Deserialize <WfClientActivity>(dictionary.GetValue("currentActivity", (WfClientActivity)null));
            processInfo.PreviousActivity = JSONSerializerExecute.Deserialize <WfClientActivity>(dictionary.GetValue("previousActivity", (WfClientActivity)null));

            JSONSerializerExecute.FillDeserializedCollection(dictionary.GetValue("nextActivities", (object)null), processInfo.NextActivities);

            return(processInfo);
        }
        /// <summary>
        /// 关闭并返回
        /// </summary>
        /// <param name="condition"></param>
        public void RegisterReturnValue(object condition)
        {
            var builder = ConditionMapping.GetWhereSqlClauseBuilder(condition);

            var result = JSONSerializerExecute.Serialize(builder);

            Page.ClientScript.RegisterStartupScript(Page.ClientScript.GetType(), "DeluxeSearchClientCloseDialog",
                                                    string.Format(
                                                        "window.returnValue = \"{0}\";top.close();",
                                                        WebUtility.CheckScriptString(result, false)), true);
        }
Beispiel #13
0
        /// <summary>
        /// 如果内部保存了Json,则返回反序列化的字典。否则直接返回Value
        /// </summary>
        /// <returns></returns>
        public object GetDeserializedValue()
        {
            object result = this._Value;

            if (this._ParamJsonValue.IsNotEmpty())
            {
                ExceptionHelper.DoSilentAction(() => result = JSONSerializerExecute.DeserializeObject(this._ParamJsonValue));
            }

            return(result);
        }
        /// <summary>
        /// 将ClenteState中的信息生成ClientState字符串
        /// </summary>
        /// <returns>ClientState字符串</returns>
        protected override string SaveClientState()
        {
            string result = string.Empty;

            if (this.SelectedData != null)
            {
                result = JSONSerializerExecute.SerializeWithType(this.SelectedData);
            }

            return(result);
        }
Beispiel #15
0
        protected void HandleOk(object sender, EventArgs e)
        {
            if (this.gridMain.SelectedKeys.Count > 0)
            {
                var rst = this.ParpareResult();

                var rstJson = JSONSerializerExecute.Serialize(rst);

                this.preScript.Text = Util.SurroundScriptBlock("finishDialog('" + rstJson + "')");
            }
        }
Beispiel #16
0
        /// <summary>
        /// 初始化树的上下文属性
        /// </summary>
        private void InitTreeContext()
        {
            InnerTreeContext context = new InnerTreeContext();

            context.MultiSelect        = this.MultiSelect;
            context.ListMask           = this.ListMask;
            context.SelectMask         = this.SelectMask;
            context.ShowDeletedObjects = this.ShowDeletedObjects;

            this.tree.CallBackContext = JSONSerializerExecute.Serialize(context);
        }
Beispiel #17
0
        public void WfRelativeLinkDespJSONTest()
        {
            WfConverterHelper.RegisterConverters();

            WfProcessDescriptor processDesp = (WfProcessDescriptor)WfProcessTestCommon.CreateSimpleProcessDescriptor();
            string result = JSONSerializerExecute.Serialize(processDesp);
            IWfProcessDescriptor procDesp = JSONSerializerExecute.Deserialize <WfProcessDescriptor>(result);

            Assert.AreEqual(processDesp.RelativeLinks[0].Name, procDesp.RelativeLinks[0].Name);
            Assert.AreEqual(processDesp.RelativeLinks[0].Url, procDesp.RelativeLinks[0].Url);
        }
Beispiel #18
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfClientActivityMatrixResourceDescriptor resource = (WfClientActivityMatrixResourceDescriptor)base.Deserialize(dictionary, type, serializer);

            resource.ExternalMatrixID = dictionary.GetValue("externalMatrixID", string.Empty);

            JSONSerializerExecute.FillDeserializedCollection(dictionary["definitions"], resource.PropertyDefinitions);
            JSONSerializerExecute.FillDeserializedCollection(dictionary["rows"], resource.Rows);

            return(resource);
        }
        protected virtual T GetObjectValue(PropertyValue pv)
        {
            T result = default(T);

            if (pv.StringValue.IsNotEmpty())
            {
                result = JSONSerializerExecute.Deserialize <T>(pv.StringValue);
            }

            return(result);
        }
Beispiel #20
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            SOARolePropertyRow row = new SOARolePropertyRow();

            row.RowNumber    = dictionary.GetValue("rowNumber", 0);
            row.Operator     = dictionary.GetValue("operator", string.Empty);
            row.OperatorType = dictionary.GetValue("operatorType", SOARoleOperatorType.User);

            JSONSerializerExecute.FillDeserializedCollection(dictionary["values"], row.Values);

            return(row);
        }
Beispiel #21
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfDynamicResourceDescriptor dynResourceDesp = (WfDynamicResourceDescriptor)base.Deserialize(dictionary, type, serializer);

            dynResourceDesp.Name = DictionaryHelper.GetValue(dictionary, "Name", string.Empty);

            WfConditionDescriptor condition = JSONSerializerExecute.Deserialize <WfConditionDescriptor>(dictionary["Condition"]);

            dynResourceDesp.Condition = condition;

            return(dynResourceDesp);
        }
Beispiel #22
0
        private static void ResponsePrepareDataResult(object data)
        {
            string serializedData = JSONSerializerExecute.Serialize(data);

            HttpContext.Current.Response.ResponseWithScriptTag((writer) =>
            {
                writer.Write("top.document.getElementById(\"preparedData\").value = ");
                writer.WriteLine("\"" + WebUtility.CheckScriptString(serializedData, false) + "\";");

                writer.WriteLine("top.document.getElementById(\"prepareDataFinished\").click();");
            });
        }
        protected void changeAssignees_ExecuteStep(object data)
        {
            ChangeAssigneesParam cap = JSONSerializerExecute.Deserialize <ChangeAssigneesParam>(data);

            IWfProcess process = WfRuntime.GetProcessByProcessID(cap.ProcessID);

            CheckPermission(process);

            WfReplaceAssigneesExecutor executor = new WfReplaceAssigneesExecutor(null, process.CurrentActivity, null, cap.Users);

            executor.Execute();
        }
 private void CreateResourceTemplate()
 {
     hiddenUserResTemplate.Value             = JSONSerializerExecute.Serialize(WfUserResourceDescriptor.EmptyInstance);
     hiddenDepartResTemplate.Value           = JSONSerializerExecute.Serialize(WfDepartmentResourceDescriptor.EmptyInstance);
     hiddenRoleResTemplate.Value             = JSONSerializerExecute.Serialize(WfRoleResourceDescriptor.EmptyInstance);
     hiddenGroupResTemplate.Value            = JSONSerializerExecute.Serialize(WfGroupResourceDescriptor.EmptyInstance);
     hiddenActOperatorResTemplate.Value      = JSONSerializerExecute.Serialize(WfActivityOperatorResourceDescriptor.EmptyInstance);
     hiddenActAssigneeResTemplate.Value      = JSONSerializerExecute.Serialize(WfActivityAssigneesResourceDescriptor.EmptyInstance);
     hiddenDynamicResTypesDataTemplate.Value = JSONSerializerExecute.Serialize(WfDynamicResourceDescriptor.EmptyInstance);
     hiddenActiveMatrixResTemplate.Value     = JSONSerializerExecute.Serialize(WfActivityMatrixResourceDescriptor.EmptyInstance);
     hiddenAURoleResTemplate.Value           = JSONSerializerExecute.Serialize(WfAURoleResourceDescriptor.EmptyInstance);
 }
        protected override void LoadClientState(string clientState)
        {
            string[] state = (string[])JSONSerializerExecute.DeserializeObject(clientState, typeof(string[]));

            this.opinionText = state[0];
            this.opinionType = state[1];

            if (string.IsNullOrEmpty(opinionType) == false)
            {
                OpinionInput.SetOpinionType(this.opinionType);
            }
        }
Beispiel #26
0
        public override object Deserialize(IDictionary <string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            WfClientBranchProcessTemplateDescriptor template = (WfClientBranchProcessTemplateDescriptor)base.Deserialize(dictionary, type, serializer);

            template.Condition = JSONSerializerExecute.Deserialize <WfClientConditionDescriptor>(dictionary.GetValue("condition", (object)null));

            JSONSerializerExecute.FillDeserializedCollection <WfClientResourceDescriptor>(dictionary.GetValue("resources", (object)null), template.Resources);
            JSONSerializerExecute.FillDeserializedCollection <WfClientResourceDescriptor>(dictionary.GetValue("cancelSubProcessNotifier", (object)null), template.CancelSubProcessNotifier);
            JSONSerializerExecute.FillDeserializedCollection <WfClientRelativeLinkDescriptor>(dictionary.GetValue("relativeLinks", (object)null), template.RelativeLinks);

            return(template);
        }
Beispiel #27
0
        public void Int32To64JsonTest()
        {
            Int64 ticks = 32L;

            string json = JSONSerializerExecute.Serialize(ticks);

            Console.WriteLine(json);

            Int64 deserialized = (Int64)JSONSerializerExecute.DeserializeObject(ticks.ToString(), typeof(Int64));

            Assert.AreEqual(ticks, deserialized);
        }
Beispiel #28
0
        public void SimpleObjectJsonTest()
        {
            JsonTestObj data = JsonTestObj.PrepareData();

            string json = JSONSerializerExecute.Serialize(data);

            Console.WriteLine(json);

            JsonTestObj deserializedData = JSONSerializerExecute.Deserialize <JsonTestObj>(json);

            AssertObjects(data, deserializedData);
        }
 public void SaveImageProperty()
 {
     if (this.StringValue.IsNotEmpty())
     {
         var img = JSONSerializerExecute.Deserialize <ImageProperty>(this.StringValue);
         if (img != null)
         {
             ImagePropertyAdapter.Instance.UpdateContent(img);
             this.StringValue = JSONSerializerExecute.Serialize(img);
         }
     }
 }
Beispiel #30
0
        public string getAnalysisResult(string functionName, string servicAddress)
        {
            WfServiceOperationDefinition state = GetWfServiceOperationDefinition(functionName, servicAddress);

            if (state != null)
            {
                return(JSONSerializerExecute.Serialize(state, state.GetType()));
            }
            else
            {
                return("");
            }
        }