public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is string)
            {
                if (Value_RE.Match(value.ToString()).Success) 
                {
                    writer.WriteRawValue(value.ToString()); 
                }
                else
                {
                    string prms;
                    
                    switch (this.Name)
                    {
                        case "before":
                            prms = "el,type,action,extraParams,o";
                            break;
                        case "complete":
                            prms = "success,response,result,el,type,action,extraParams,o";
                            break;
                        default:
                            prms = "response,result,el,type,action,extraParams,o";
                            break;
                    }

                    value = TokenUtils.ReplaceRawToken(TokenUtils.ParseTokens(value.ToString(), this.OwnerControl));
                    writer.WriteRawValue(new JFunction((string)value, prms).ToScript()); 
                }
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            ListItemCollection items = value as ListItemCollection;

            if (items.Count == 0)
            {
                writer.WriteRawValue("Ext.data.StoreManager.getArrayStore(2)");
                return;
            }

            StringBuilder sb = new StringBuilder("[");

            if (items != null && items.Count > 0)
            {
                foreach (ListItem item in items)
                {
                    sb.Append("[");
                    
                    string val = item.Value.IsEmpty() ? item.Text : item.Value;
                    
                    sb.Append(item.Mode == ParameterMode.Value ? JSON.Serialize(val) : val);
                    sb.Append(",");
                    sb.Append(item.Text.IsEmpty() ? JSON.Serialize(item.Value) : JSON.Serialize(item.Text));
                    sb.Append("],");
                }
                sb.Remove(sb.Length - 1, 1);
            }
            
            sb.Append("]");

            writer.WriteRawValue(sb.ToString());
        }
        /// <summary>
        /// Writes the JSON representation of the object.
        /// </summary>
        /// <param name="writer">The <see cref="JsonWriter"/> to write to.</param>
        /// <param name="value">The value.</param>
        /// <param name="serializer">Serializer</param>
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is DateTime || value is DateTime?)
            {
                DateTime date = value is DateTime ? (DateTime)value : (value as DateTime?).Value;

                if (date != DateTime.MinValue)
                {
                    writer.WriteValue(date.ToString(this.RenderMilliseconds ? DateTimeFormatMs : DateTimeFormat, CultureInfo.InvariantCulture));
                }
                else
                {
                    writer.WriteRawValue("null");
                }

                return;
            }
            else
            {
                DateTimeOffset dateTimeOffset = (DateTimeOffset)value;

                if (dateTimeOffset != DateTimeOffset.MinValue)
                {
                    writer.WriteValue(dateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture));
                }
                else
                {
                    writer.WriteRawValue("null");
                }
            }

            writer.WriteRawValue("null");
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value != null && value is ComponentListener)
            {
                ComponentListener componentListener = (ComponentListener)value;

                if (!componentListener.IsDefault)
                {
                    if (this.Owner is BaseItem)
                    {
                        componentListener.Owner = ((BaseItem)this.Owner).Owner;
                    }
                    else if (this.Owner is Control) 
                    {
                        componentListener.Owner = (Control)this.Owner;
                    }

                    if (this.PropertyName.IsNotEmpty())
                    {
                        componentListener.SetArgumentList(this.Owner.GetType().GetProperty(this.PropertyName));
                    }
                    
                    writer.WriteRawValue(new ClientConfig().Serialize(componentListener));
                    return;
                }
            }
            writer.WriteRawValue("{}");
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value != null && value is Renderer)
            {
                string temp = ((Renderer)value).ToConfigString();

                if (temp.IsNotEmpty())
                {
                    writer.WriteRawValue(temp);
                    return;
                }
            }
            writer.WriteRawValue("null");
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            switch ((ThreeStateBool)value)
            {
                case ThreeStateBool.False:
                    writer.WriteRawValue("false");
                    return;
                case ThreeStateBool.True:
                    writer.WriteRawValue("true");
                    return;
            }

            writer.WriteRawValue("undefined");
        }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     var arr = value as string[];
     if (arr != null)
     {
         if (arr.Length == 1)
         {
             writer.WriteRawValue("\"" + arr[0] + "\"");
         }
         else
         {
             writer.WriteRawValue("[{0}]".FormatWith(((string[])value).Join(",", "\"{0}\"")));
         }
     }
 }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value is int[])
     {
         writer.WriteRawValue("[{0}]".FormatWith(((int[])value).Join(",", "{0}")));
     }
 }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value is string)
     {
         writer.WriteRawValue(new JFunction((string)value).ToScript()); 
     }
 }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value is string)
     {
         writer.WriteRawValue(new JFunction(TokenUtils.ParseTokens((string)value, false, this.Owner is Control ? (Control)this.Owner : null)).ToScript());                 
     }
 }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            ListItemCollection items = value as ListItemCollection;

            //StringBuilder sb = new StringBuilder("new Ext.data.SimpleStore({fields:[\"text\",\"value\"],data :[");
            StringBuilder sb = new StringBuilder("[");

            if (items != null && items.Count > 0)
            {
                foreach (ListItem item in items)
                {
                    sb.Append("[");
                    var val = item.Value.IsEmpty() ? item.Text : item.Value;
                    sb.Append(item.Mode == ParameterMode.Value ? JSON.Serialize(val) : val);
                    sb.Append(",");
                    sb.Append(item.Text.IsEmpty() ? JSON.Serialize(item.Value) : JSON.Serialize(item.Text));
                    sb.Append("],");
                }
                sb.Remove(sb.Length - 1, 1);
            }
            
            //sb.Append("]})");
            sb.Append("]");

            writer.WriteRawValue(sb.ToString());
        }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     if (value is JFunction)
     {
         writer.WriteRawValue((value as JFunction).ToScript());
     }
     else
     {
         writer.WriteNull();
     }
 }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            IList items = (IList)value;

            if (value != null && items.Count > 0)
            {
                if (items.Count == 1 && this.IsSingleItemArray())
                {
                    Control item = (Control)items[0];

                    var pnl = item as AbstractPanel;

                    if (!item.Visible)
                    {
                        writer.WriteNull();
                        return;
                    }

                    writer.WriteRawValue(this.Format(items[0] as Control));
                }
                else
                {
                    bool visible = false;

                    foreach (Observable item in items)
                    {
                        if (item.Visible)
                        {
                            visible = true;
                        }
                    }

                    if (visible)
                    {
                        writer.WriteStartArray();

                        foreach (Observable item in items)
                        {
                            if (item.Visible)
                            {
                                writer.WriteRawValue(this.Format(item));
                            }
                        }

                        writer.WriteEndArray();
                    }
                    else
                    {
                        writer.WriteNull();
                    }
                }
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is DateTime || value is DateTime?)
            {
                DateTime date = value is DateTime ? (DateTime)value : (value as DateTime?).Value;

                if (date.Equals(DateTime.MinValue))
                {
                    writer.WriteRawValue("null");
                }
                else
                {
                    string template = (date.TimeOfDay == new TimeSpan(0, 0, 0)) ? "{0},{1},{2}" : "{0},{1},{2},{3},{4},{5},{6}";

                    writer.WriteStartConstructor("Date");
                    writer.WriteRawValue(
                        string.Format(template, date.Year, date.Month - 1, date.Day,
                                      date.Hour, date.Minute, date.Second, date.Millisecond));
                    writer.WriteEndConstructor();
                }
            }
        }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     ConfigItemCollection items = (ConfigItemCollection)value;
     
     if (value != null && items.Count > 0)
     {
         foreach (ConfigItem item in items)
         {
             writer.WritePropertyName(items.CamelName ? Ext.Net.Utilities.StringUtils.ToLowerCamelCase(item.Name) : item.Name);
             writer.WriteRawValue(item.ValueToString());
         }
     }
 }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is string)
            {
                string temp = (string)value;

                if (temp.IsNotEmpty())
                {
                    writer.WriteValue(DateTimeUtils.ConvertNetToPHP(temp));
                    return;
                }
            }
            writer.WriteRawValue(null);
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            Control control = value as Control;

            if (control != null)
            {
                if (!control.Visible)
                {
                    writer.WriteNull();
                    return;
                }

                writer.WriteRawValue(this.Format(control));
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            DynamicConfigDictionary config = (DynamicConfigDictionary)value;

            if (config != null)
            {
                var keys = config.GetDynamicMemberNames();  
                
                foreach (string key in keys)
                {
                    writer.WritePropertyName(Ext.Net.Utilities.StringUtils.ToLowerCamelCase(key));
                    writer.WriteRawValue(JSON.Serialize(config.GetDynamicValue(key), new Newtonsoft.Json.Serialization.CamelCasePropertyNamesContractResolver()));
                }
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            LoadMask mask = value as LoadMask;

            if (mask != null && mask.ShowMask)
            {
                string jsonMask = new ClientConfig().Serialize(mask);

                if (jsonMask.IsEmpty() || jsonMask.Equals("{}"))
                {
                    writer.WriteValue(true);
                }
                else
                {
                    writer.WriteRawValue(jsonMask);
                }
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value is string)
            {
                string re = (string)value;

                if (!re.StartsWith("/", StringComparison.InvariantCulture))
                {
                    re = "/{0}".FormatWith(re);
                }

                if (!re.EndsWith("/", StringComparison.InvariantCulture))
                {
                    re = "{0}/".FormatWith(re);
                }

                writer.WriteRawValue(re);
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            string temp = (string)value ?? "";

            if (temp.IsNotEmpty())
            {
                if (temp.StartsWith("<raw>"))
                {
                    writer.WriteRawValue(temp.Remove(0,5));
                }
                else
                {
                    writer.WriteValue(temp);
                }

                return;
            }
            writer.WriteValue("");

            return;
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            ParameterCollection parameters = value as ParameterCollection;

            if (parameters != null)
            {
                StringBuilder sb = new StringBuilder("{params:{");

                foreach (Parameter parameter in parameters)
                {
                    sb.Append(parameter.ToString()).Append(",");
                }
                if (sb[sb.Length-1] == ',')
                {
                    sb.Remove(sb.Length - 1, 1);
                }
                sb.Append("}}");

                writer.WriteRawValue(sb.ToString());
            }
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            string temp = (string)value ?? "";

            if (temp.IsNotEmpty())
            {
                string rawMarker = TokenUtils.Settings.RawMarker;
                if (temp.StartsWith(rawMarker))
                {
                    writer.WriteRawValue(temp.Remove(0,rawMarker.Length));
                }
                else
                {
                    writer.WriteValue(temp);
                }

                return;
            }
            writer.WriteValue("");

            return;
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
        {
            if (writer == null) return;

            writer.WriteRawValue(DateTimeHelper.ToUnixDateTime((DateTime)value).ToString(CultureInfo.InvariantCulture));
        }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            if (value != null && value is ComponentDirectEvent)
            {
                ComponentDirectEvent directEvent = (ComponentDirectEvent)value;

                if (!directEvent.IsDefault)
                {
                    Control owner = null;
                    MessageBusDirectEvent busEvent = directEvent as MessageBusDirectEvent;

                    if (this.Owner is BaseItem)
                    {
                        owner = ((BaseItem)this.Owner).Owner;
                    }
                    else if (this.Owner is Control)
                    {
                        owner = (Control)this.Owner;
                    }

                    directEvent.Owner = owner;
                    directEvent.ExtraParams.Owner = owner;

                    foreach (Parameter param in directEvent.ExtraParams)
                    {
                        param.Owner = owner;
                    }

                    HandlerConfig cfg = directEvent.GetListenerConfig();
                    if (cfg.Delay == 0 && directEvent.HasOwnDelay)
                    {
                        cfg.Delay = -1;
                    }

                    string deScope = directEvent.Scope;
                    directEvent.ClearListenerConfig();
                    
                    string configObject = new ClientConfig().SerializeInternal(directEvent, directEvent.Owner);

                    StringBuilder cfgObj = new StringBuilder(configObject.Length + 64);

                    cfgObj.Append(configObject);
                    cfgObj.Remove(cfgObj.Length - 1, 1);
                    cfgObj.AppendFormat("{0}control:this", configObject.Length > 2 ? "," : "");

                    if (busEvent != null)
                    {
                        cfgObj.Append(",eventType:'bus'");
                    }

                    if (busEvent == null)
                    {
                        if (this.PropertyName != "Click")
                        {
                            cfgObj.AppendFormat(",action:'{0}'", this.PropertyName);
                        }
                    }
                    else
                    {
                        cfgObj.AppendFormat(",action:'{0}:'+name", busEvent.Name);
                    }
                    

                    cfgObj.Append("}");

                    if (this.PropertyName.IsNotEmpty())
                    {
                        directEvent.SetArgumentList(this.Owner.GetType().GetProperty(this.PropertyName));
                    }

                    JFunction jFunction = new JFunction("Ext.net.directRequest(".ConcatWith(cfgObj.ToString(), ");"), directEvent.ArgumentList.ToArray());

                    string scope = deScope.IsEmpty() || deScope == "this" ? "" : deScope;

                    StringBuilder sb = new StringBuilder();
                    
                    sb.Append("{");
                    sb.Append("fn:").Append(jFunction.ToScript()).Append(",");

                    if (scope.Length > 0)
                    {
                        sb.Append("scope:").Append(scope).Append(",");
                    }

                    if (busEvent != null)
                    {
                        if (busEvent.Bus.IsNotEmpty())
                        {
                            sb.Append("bus:'").Append(busEvent.Bus).Append("',");
                        }
                        if (busEvent.Name.IsNotEmpty())
                        {
                            sb.Append("name:'").Append(busEvent.Name).Append("',");
                        }                                                
                    }

                    string cfgStr = cfg.Serialize();

                    if (cfgStr != "{}")
                    {
                        sb.Append(cfgStr.Chop());
                    }

                    if (sb[sb.Length - 1] == ',')
                    {
                        sb.Remove(sb.Length - 1, 1);
                    }

                    sb.Append("}");

                    writer.WriteRawValue(sb.ToString());

                    return;
                }
            }

            writer.WriteRawValue("{}");
        }
Exemple #26
0
            public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
            {
                if (value.GetType() == typeof(float)) {
                    var roundedValue = Math.Round((float) value, Precission);
                    var intValue = (int) roundedValue;

                    if (intValue == roundedValue) {
                        writer.WriteRawValue(intValue.ToString());
                    } else {
                        writer.WriteValue(roundedValue);
                    }

                    return;
                }

                if (value.GetType() == typeof(double)) {
                    var roundedValue = Math.Round((double) value, Precission);
                    var longValue = (long) roundedValue;

                    if (longValue == roundedValue) {
                        writer.WriteRawValue(longValue.ToString());
                    } else {
                        writer.WriteValue(roundedValue);
                    }

                    return;
                }
            }
        public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
        {
            IList items = (IList)value;

            if (value != null && items.Count > 0)
            {
                if (items.Count == 1 && this.IsSingleItemArray())
                {
                    Control item = (Control)items[0];

                    if (!item.Visible)
                    {
                        writer.WriteNull();
                        return;
                    }

                    if (!(item is IProxyContainer))
                    {
                        writer.WriteRawValue(this.Format(items[0] as Control));
                    }
                    else
                    {
                        List<string> ids = ((IProxyContainer)item).GetIDS();

                        if (ids != null && ids.Count > 0)
                        {
                            if (ids.Count == 1)
                            {
                                writer.WriteRawValue(this.Format(ids[0]));
                            }
                            else
                            {
                                writer.WriteStartArray();

                                foreach (string id in ids)
                                {
                                    writer.WriteRawValue(this.Format(id));
                                }

                                writer.WriteEndArray();
                            }
                        }
                    }
                }
                else
                {
                    bool visible = false;

                    foreach (Observable item in items)
                    {
                        if (item.Visible)
                        {
                            visible = true;
                        }
                    }

                    if (visible)
                    {
                        writer.WriteStartArray();

                        foreach (Observable item in items)
                        {
                            if (item.Visible)
                            {
                                if (!(item is IProxyContainer))
                                {
                                    writer.WriteRawValue(this.Format(item));
                                }
                                else
                                {
                                    List<string> ids = ((IProxyContainer)item).GetIDS();

                                    if (ids != null && ids.Count > 0)
                                    {
                                        foreach (string id in ids)
                                        {
                                            writer.WriteRawValue(this.Format(id));
                                        }
                                    }
                                }                                
                            }
                        }

                        writer.WriteEndArray();
                    }
                    else
                    {
                        writer.WriteNull();
                    }
                }
            }
        }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     writer.WriteRawValue(Convert.ToInt32(value as Enum).ToString());
 }
 public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, JsonSerializer serializer)
 {
     writer.WriteRawValue((value as JRawValue).ToString());
 }