Experiments/Generator/Generators/Scaffold/Templates/ScaffoldHelper.cs

   1 using System;
   2 using System.IO;
   3 using System.Collections;
   4 using System.Text.RegularExpressions;
   5 using System.Reflection;
   6 using Castle.ActiveRecord;
   7 using Castle.ActiveRecord.Framework.Internal;
   8 using Castle.MonoRail.Framework;
   9 using Castle.MonoRail.Framework.Helpers;
  10
  11 namespace <%= HelpersNamespace %>
  12 {
  13         /// <summary>
  14         /// Helper for displaying cool things on web pages!
  15         /// </summary>
  16         public class ScaffoldHelper : AbstractHelper
  17         {
  18                 private HtmlHelper _htmlHelper = new HtmlHelper();
  19
  20                 #region Formating helpers
  21                 public string ToHumanName(string name)
  22                 {
  23                         return Regex.Replace(name, "([a-z])([A-Z])", new MatchEvaluator(HumanNameMatchEvaluator));
  24                 }
  25                 private string HumanNameMatchEvaluator(Match m)
  26                 {
  27                         return m.Groups[1] + " " + m.Groups[2].ToString().ToLower();
  28                 }
  29                 public string ToHumanName(PropertyModel prop)
  30                 {
  31                         return ToHumanName(prop.Property.Name);
  32                 }
  33
  34                 public string ToColumnName(string name)
  35                 {
  36                         if (Controller.Params["order"] == name)
  37                                 return ToHumanName(name);
  38                         return string.Format("<a href=\"?order={0}\">{1}</a>", name, ToHumanName(name));
  39                 }
  40                 public string ToColumnName(PropertyModel prop)
  41                 {
  42                         if (prop.PropertyAtt.ColumnType == "StringClob") // Can't order by!
  43                                 return ToHumanName(prop.Property.Name);
  44                         return ToColumnName(prop.Property.Name);
  45                 }
  46                 #endregion
  47
  48                 #region Properties helpers
  49                 public PropertyModel[] GetProperties(IEnumerable enumerable)
  50                 {
  51                         IEnumerator en = enumerable.GetEnumerator();
  52                         en.MoveNext();
  53                         return GetProperties(en.Current.GetType());
  54                 }
  55
  56                 public PropertyModel[] GetProperties(Type arType)
  57                 {
  58                         ArrayList props = new ArrayList();
  59                         ActiveRecordModel model = ActiveRecordModel.GetModel(arType);
  60
  61                         props.AddRange(model.Properties);
  62
  63                         foreach (BelongsToModel belong in model.BelongsTo)
  64                         {
  65                                 props.Add(new PropertyModel(belong.Property, new PropertyAttribute()));
  66                         }
  67
  68                         return (PropertyModel[]) props.ToArray(typeof(PropertyModel));
  69                 }
  70
  71                 public object GetPropertyValue(object obj, PropertyModel prop)
  72                 {
  73                         return prop.Property.GetValue(obj, null);
  74                 }
  75
  76                 public bool HasItems(IEnumerable enumerable)
  77                 {
  78                         return enumerable.GetEnumerator().MoveNext();
  79                 }
  80                 #endregion
  81
  82                 #region Input helpers
  83                 public string InputFor(string prefix, object ar, PropertyModel prop)
  84                 {
  85                         string name = string.Format("{0}.{1}", prefix, prop.Property.Name);
  86                         Type type = prop.Property.PropertyType;
  87                         object value = GetPropertyValue(ar, prop);
  88
  89                         if (typeof(ActiveRecordBase).IsAssignableFrom(type))
  90                         {
  91                                 return Select(name, value as ActiveRecordBase, type);
  92                         }
  93                         else if (type == typeof(DateTime))
  94                         {
  95                                 return HtmlHelper.DateTime(name, (DateTime) value);
  96                         }
  97                         else if (type == typeof(string) && prop.PropertyAtt.ColumnType == "StringClob")
  98                         {
  99                                 return HtmlHelper.TextArea(name, 40, 10, (string) value);
 100                         }
 101
 102                         if (value == null)
 103                                 return HtmlHelper.InputText(name, "");
 104                         else
 105                                 return HtmlHelper.InputText(name, value.ToString());
 106                 }
 107
 108                 public string Select(string name, object ar)
 109                 {
 110                         return Select(name, ar, ar.GetType());
 111                 }
 112
 113                 public string Select(string name, object ar, Type arType)
 114                 {
 115                         HtmlHelper helper = new HtmlHelper();
 116                         ActiveRecordModel model = ActiveRecordModel.GetModel(arType);
 117                         PropertyInfo prop = model.Key.Property;
 118                         object selected = null;
 119
 120                         if (ar != null && prop != null)
 121                         {
 122                                 selected = prop.GetValue(ar, null);
 123                         }
 124
 125                         return helper.Select(name + ".Id")
 126                                 + helper.CreateOptions(ActiveRecordMediator.FindAll(arType), "ToString", "Id", selected)
 127                                 + helper.EndSelect();
 128                 }
 129                 #endregion
 130
 131                 #region Errors helpers
 132                 public string ErrorsFor(ActiveRecordValidationBase ar)
 133                 {
 134                         if (this.Controller.Context.RequestType == "GET")
 135                                 return null;
 136                         return String.Join("<br>", ar.ValidationErrorMessages);
 137                 }
 138
 139                 public bool HasError(ActiveRecordValidationBase ar)
 140                 {
 141                         if (this.Controller.Context.RequestType == "GET")
 142                                 return false;
 143                         return ar.ValidationErrorMessages.Length > 0;
 144                 }
 145                 #endregion
 146
 147                 #region Pagination helpers
 148                 public string PageBrowser(Page page)
 149                 {
 150                         StringWriter output = new StringWriter();
 151                         PaginationHelper helper = new PaginationHelper();
 152                         helper.SetController(this.Controller);
 153
 154                         if (page.HasFirst)
 155                                 output.Write(helper.CreatePageLink(1, "First"));
 156                         else
 157                                 output.Write("First");
 158
 159                         output.Write(" | ");
 160
 161                         if (page.HasPrevious)
 162                                 output.Write(helper.CreatePageLink(page.PreviousIndex, "Previous"));
 163                         else
 164                                 output.Write("Previous");
 165
 166                         output.Write(" | ");
 167
 168                         if (page.HasNext)
 169                                 output.Write(helper.CreatePageLink(page.NextIndex, "Next"));
 170                         else
 171                                 output.Write("Next");
 172
 173                         output.Write(" | ");
 174
 175                         if (page.HasLast)
 176                                 output.Write(helper.CreatePageLink(page.LastIndex, "Last"));
 177                         else
 178                                 output.Write("Last");
 179
 180                         return output.ToString();
 181                 }
 182                 #endregion
 183
 184                 #region Debugging helpers
 185                 public string Debug(object ar)
 186                 {
 187                         return "<code><pre>" + Debug(ar, 0) + "</code></pre>";
 188                 }
 189                 private string Debug(object ar, int indent)
 190                 {
 191                         if (ar == null) return null;
 192
 193                         StringWriter output = new StringWriter();
 194                         string tab = new string('\t', indent);
 195                         object value;
 196
 197                         output.WriteLine("{0}(#{1}):", tab, ar.GetType().Name);
 198                         foreach (PropertyModel prop in GetProperties(ar.GetType()))
 199                         {
 200                                 value = GetPropertyValue(ar, prop);
 201
 202                                 output.WriteLine("{0}\t{1} ({2}) = {3}", tab, prop.Property.Name, prop.Property.PropertyType.Name, value);
 203                                 if (typeof(ActiveRecordBase).IsAssignableFrom(prop.Property.PropertyType))
 204                                 {
 205                                         output.WriteLine(Debug(value as ActiveRecordBase, indent+1));
 206                                 }
 207                         }
 208
 209                         return output.ToString();
 210                 }
 211                 #endregion
 212
 213                 #region Sub helpers
 214                 public HtmlHelper HtmlHelper {
 215                         get {
 216                                 return _htmlHelper;
 217                         }
 218                 }
 219                 #endregion
 220         }
 221 }