MonoRail/Castle.MonoRail.Framework/Attributes/JSONReturnBinderAttribute.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MonoRail.Framework
  16 {
  17         using System;
  18         using System.Collections.Generic;
  19         using System.Reflection;
  20         using Services;
  21
  22         /// <summary>
  23         /// Pendent
  24         /// </summary>
  25         [AttributeUsage(AttributeTargets.ReturnValue, AllowMultiple = false, Inherited = false)]
  26         public class JSONReturnBinderAttribute : Attribute, IReturnBinder
  27         {
  28                 private string properties;
  29
  30                 /// <summary>
  31                 /// Gets or sets the properties to be serialized.
  32                 /// </summary>
  33                 /// <value>The properties.</value>
  34                 public string Properties
  35                 {
  36                         get { return properties; }
  37                         set { properties = value; }
  38                 }
  39
  40                 /// <summary>
  41                 /// Binds the specified parameters for the action.
  42                 /// </summary>
  43                 /// <param name="context">The context.</param>
  44                 /// <param name="controller">The controller.</param>
  45                 /// <param name="controllerContext">The controller context.</param>
  46                 /// <param name="returnType">Type being returned.</param>
  47                 /// <param name="returnValue">The return value.</param>
  48                 /// <returns></returns>
  49                 public void Bind(IEngineContext context, IController controller, IControllerContext controllerContext,
  50                                                  Type returnType, object returnValue)
  51                 {
  52                         // Cancel any view rendering
  53                         controllerContext.SelectedViewName = null;
  54
  55                         IJSONSerializer serializer = context.Services.JSONSerializer;
  56
  57                         IResponse response = context.Response;
  58
  59                         string userAgent = context.Request.Headers["User-Agent"];
  60
  61                         // Ridiculous hack, but necessary. If we set the mime type for mobile clients, they
  62                         // will treat the response as binary!!
  63                         if (userAgent != null && userAgent.IndexOf("Windows CE") == -1)
  64                         {
  65                                 // Sets the mime type
  66                                 response.ContentType = "application/json, text/javascript";
  67                         }
  68
  69                         string raw;
  70
  71                         if (returnValue != null)
  72                         {
  73                                 if (properties == null)
  74                                 {
  75                                         raw = serializer.Serialize(returnValue);
  76                                 }
  77                                 else
  78                                 {
  79                                         Type normalized = returnType.IsArray ? returnType.GetElementType() : returnType;
  80
  81                                         raw = serializer.Serialize(returnValue, new PropertyConverter(normalized, properties));
  82                                 }
  83                         }
  84                         else
  85                         {
  86                                 if (returnType.IsArray)
  87                                 {
  88                                         raw = "[]";
  89                                 }
  90                                 else
  91                                 {
  92                                         raw = "{}";
  93                                 }
  94                         }
  95
  96                         response.Output.Write(raw);
  97                 }
  98
  99                 class PropertyConverter : IJSONConverter
 100                 {
 101                         private readonly Type targetType;
 102                         private List<PropertyInfo> properties = new List<PropertyInfo>();
 103
 104                         public PropertyConverter(Type targetType, string propertyNames)
 105                         {
 106                                 this.targetType = targetType;
 107
 108                                 foreach(string propertyName in propertyNames.Split(','))
 109                                 {
 110                                         PropertyInfo prop = targetType.GetProperty(propertyName);
 111
 112                                         if (prop == null)
 113                                         {
 114                                                 throw new MonoRailException("Failed to JSON serialize object. " +
 115                                                         "Property " + propertyName + " could not be found for type " + targetType.FullName);
 116                                         }
 117
 118                                         properties.Add(prop);
 119                                 }
 120                         }
 121
 122                         public void Write(IJSONWriter writer, object value)
 123                         {
 124                                 writer.WriteStartObject();
 125
 126                                 foreach(PropertyInfo info in properties)
 127                                 {
 128                                         object propVal = info.GetValue(value, null);
 129
 130                                         writer.WritePropertyName(info.Name);
 131                                         writer.WriteValue(propVal);
 132                                 }
 133
 134                                 writer.WriteEndObject();
 135                         }
 136
 137                         public bool CanHandle(Type type)
 138                         {
 139                                 return type == targetType;
 140                         }
 141
 142 #if DOTNET35
 143                         public object ReadJson(IJSONReader reader, Type objectType)
 144                         {
 145                                 throw new NotImplementedException();
 146                         }
 147 #endif
 148                 }
 149         }
 150 }