MonoRail/Castle.MonoRail.ActiveRecordSupport/Scaffold/Helpers/ARFormHelper.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.ActiveRecordSupport.Scaffold.Helpers
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Collections.Specialized;
  20         using System.Text;
  21         using System.Reflection;
  22         using Castle.ActiveRecord;
  23         using Castle.ActiveRecord.Framework.Internal;
  24         using Castle.MonoRail.Framework.Helpers;
  25
  26         public class ARFormHelper : FormHelper
  27         {
  28                 private StringBuilder stringBuilder = new StringBuilder(1024);
  29
  30                 private IDictionary model2nestedInstance = new Hashtable();
  31
  32                 private static readonly int[] Months = { 1,2,3,4,5,6,7,8,9,10,11,12 };
  33                 private static readonly int[] Days = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
  34                                                        11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
  35                                                        21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31 };
  36                 private static readonly int[] Years;
  37                 private TextHelper textHelper = new TextHelper();
  38
  39                 static ARFormHelper()
  40                 {
  41                         int lastYear = DateTime.Now.Year;
  42
  43                         Years = new int[lastYear - 1950 + 50];
  44
  45                         for(int year = 1950; year < lastYear + 50; year++)
  46                         {
  47                                 Years[year - 1950] = year;
  48                         }
  49                 }
  50
  51                 public TextHelper TextHelper
  52                 {
  53                         get { return textHelper; }
  54                 }
  55
  56                 public ICollection GetModelHierarchy(ActiveRecordModel model, object instance)
  57                 {
  58                         ArrayList list = new ArrayList();
  59
  60                         ActiveRecordModel hierarchy = model;
  61
  62                         while(hierarchy != null)
  63                         {
  64                                 list.Add(hierarchy);
  65
  66                                 hierarchy = ActiveRecordModel.GetModel(hierarchy.Type.BaseType);
  67                         }
  68
  69                         hierarchy = model;
  70
  71                         while(hierarchy != null)
  72                         {
  73                                 foreach(NestedModel nested in hierarchy.Components)
  74                                 {
  75                                         object nestedInstance = nested.Property.GetValue(instance, null);
  76
  77                                         if (nestedInstance == null)
  78                                         {
  79                                                 nestedInstance = CreationUtil.Create(nested.Property.PropertyType);
  80                                         }
  81
  82                                         if (nestedInstance != null)
  83                                         {
  84                                                 model2nestedInstance[nested.Model] = nestedInstance;
  85                                         }
  86
  87                                         list.Add(nested.Model);
  88                                 }
  89
  90                                 hierarchy = ActiveRecordModel.GetModel(hierarchy.Type.BaseType);
  91                         }
  92
  93                         return list;
  94                 }
  95
  96                 #region CanHandle methods
  97
  98                 public bool CanHandle(FieldModel field)
  99                 {
 100                         return CanHandleType(field.Field.FieldType);
 101                 }
 102
 103                 public bool CanHandle(PropertyModel propModel)
 104                 {
 105                         return CanHandleType(propModel.Property.PropertyType);
 106                 }
 107
 108                 public bool CanHandle(PropertyInfo propInfo)
 109                 {
 110                         return CanHandleType(propInfo.PropertyType);
 111                 }
 112
 113                 public bool CanHandle(BelongsToModel model)
 114                 {
 115                         return CheckModelAndKeyAreAccessible(model.BelongsToAtt.Type);
 116                 }
 117
 118                 public bool CanHandle(HasManyModel model)
 119                 {
 120                         if (!model.HasManyAtt.Inverse)
 121                         {
 122                                 return CheckModelAndKeyAreAccessible(model.HasManyAtt.MapType);
 123                         }
 124                         return false;
 125                 }
 126
 127                 public bool CanHandle(HasAndBelongsToManyModel model)
 128                 {
 129                         if (!model.HasManyAtt.Inverse)
 130                         {
 131                                 return CheckModelAndKeyAreAccessible(model.HasManyAtt.MapType);
 132                         }
 133                         return false;
 134                 }
 135
 136                 private bool CheckModelAndKeyAreAccessible(Type type)
 137                 {
 138                         ActiveRecordModel otherModel = ActiveRecordModel.GetModel(type);
 139
 140                         PrimaryKeyModel keyModel = ObtainPKProperty(otherModel);
 141
 142                         if (otherModel == null || keyModel == null)
 143                         {
 144                                 return false;
 145                         }
 146
 147                         return true;
 148                 }
 149
 150                 private PrimaryKeyModel ObtainPKProperty(ActiveRecordModel model)
 151                 {
 152                         if (model == null) return null;
 153
 154                         ActiveRecordModel curModel = model;
 155
 156                         while(curModel != null)
 157                         {
 158                                 PrimaryKeyModel keyModel = curModel.PrimaryKey;
 159
 160                                 if (keyModel != null)
 161                                 {
 162                                         return keyModel;
 163                                 }
 164
 165                                 curModel = curModel.Parent;
 166                         }
 167
 168                         return null;
 169                 }
 170
 171                 private bool CanHandleType(Type type)
 172                 {
 173                         return (type.IsPrimitive ||
 174                                         type == typeof(String) ||
 175                                 type == typeof(Decimal) ||
 176                                 type == typeof(Single) ||
 177                                 type == typeof(Double) ||
 178                                 type == typeof(Byte) ||
 179                                 type == typeof(SByte) ||
 180                                 type == typeof(bool) ||
 181                                 type == typeof(Enum) ||
 182                                 type == typeof(DateTime));
 183                 }
 184
 185                 #endregion
 186
 187                 #region CreateControl methods
 188
 189                 public String CreateControl(ActiveRecordModel model, String prefix,
 190                                             FieldModel fieldModel, object instance)
 191                 {
 192                         stringBuilder.Length = 0;
 193
 194                         FieldInfo fieldInfo = fieldModel.Field;
 195
 196                         String propName = CreatePropName(model, prefix, fieldInfo.Name);
 197
 198                         if (fieldInfo.FieldType == typeof(DateTime))
 199                         {
 200                                 stringBuilder.Append(LabelFor(propName + "day", TextHelper.PascalCaseToWord(fieldInfo.Name) + ": &nbsp;"));
 201                         }
 202                         else
 203                         {
 204                                 stringBuilder.Append(LabelFor(propName, TextHelper.PascalCaseToWord(fieldInfo.Name) + ": &nbsp;"));
 205                         }
 206
 207                         FieldAttribute propAtt = fieldModel.FieldAtt;
 208
 209                         RenderAppropriateControl(model, fieldInfo.FieldType, propName, null, null,
 210                                                  propAtt.Unique, propAtt.NotNull, propAtt.ColumnType, propAtt.Length);
 211
 212                         return stringBuilder.ToString();
 213                 }
 214
 215                 public String CreateControl(ActiveRecordModel model, String prefix,
 216                                             PropertyModel propertyModel, object instance)
 217                 {
 218                         stringBuilder.Length = 0;
 219
 220                         PropertyInfo prop = propertyModel.Property;
 221
 222                         // Skip non standard properties
 223                         if (!prop.CanWrite || !prop.CanRead) return String.Empty;
 224
 225                         // Skip indexers
 226                         if (prop.GetIndexParameters().Length != 0) return String.Empty;
 227
 228                         String propName = CreatePropName(model, prefix, prop.Name);
 229
 230                         if (prop.PropertyType == typeof(DateTime))
 231                         {
 232                                 stringBuilder.Append(LabelFor(propName + "day", TextHelper.PascalCaseToWord(prop.Name) + ": &nbsp;"));
 233                         }
 234                         else
 235                         {
 236                                 stringBuilder.Append(LabelFor(propName, TextHelper.PascalCaseToWord(prop.Name) + ": &nbsp;"));
 237                         }
 238
 239                         PropertyAttribute propAtt = propertyModel.PropertyAtt;
 240
 241                         RenderAppropriateControl(model, prop.PropertyType, propName, prop, null,
 242                                                  propAtt.Unique, propAtt.NotNull, propAtt.ColumnType, propAtt.Length);
 243
 244                         return stringBuilder.ToString();
 245                 }
 246
 247                 public String CreateControl(ActiveRecordModel model, String prefix,
 248                                             PropertyInfo prop, object instance)
 249                 {
 250                         stringBuilder.Length = 0;
 251
 252                         // Skip non standard properties
 253                         if (!prop.CanWrite || !prop.CanRead) return String.Empty;
 254
 255                         // Skip indexers
 256                         if (prop.GetIndexParameters().Length != 0) return String.Empty;
 257
 258                         String propName = CreatePropName(model, prefix, prop.Name);
 259
 260                         if (prop.PropertyType == typeof(DateTime))
 261                         {
 262                                 stringBuilder.Append(LabelFor(propName + "day", TextHelper.PascalCaseToWord(prop.Name) + ": &nbsp;"));
 263                         }
 264                         else
 265                         {
 266                                 stringBuilder.Append(LabelFor(propName, TextHelper.PascalCaseToWord(prop.Name) + ": &nbsp;"));
 267                         }
 268
 269                         RenderAppropriateControl(model, prop.PropertyType,
 270                                                  propName, prop, null, false, false, null, 0);
 271
 272                         return stringBuilder.ToString();
 273                 }
 274
 275                 public String CreateControl(ActiveRecordModel model, String prefix,
 276                                             BelongsToModel belongsToModel, object instance)
 277                 {
 278                         stringBuilder.Length = 0;
 279
 280                         PropertyInfo prop = belongsToModel.Property;
 281
 282                         prefix += "." + prop.Name;
 283
 284                         ActiveRecordModel otherModel = ActiveRecordModel.GetModel(belongsToModel.BelongsToAtt.Type);
 285
 286                         PrimaryKeyModel keyModel = ObtainPKProperty(otherModel);
 287
 288                         if (otherModel == null || keyModel == null)
 289                         {
 290                                 return "Model not found or PK not found";
 291                         }
 292
 293                         object[] items = CommonOperationUtils.FindAll(otherModel.Type);
 294
 295                         String propName = CreatePropName(model, prefix, keyModel.Property.Name);
 296
 297                         stringBuilder.Append(LabelFor(propName, TextHelper.PascalCaseToWord(prop.Name) + ": &nbsp;"));
 298
 299                         IDictionary attrs = new HybridDictionary(true);
 300
 301                         attrs["value"] = keyModel.Property.Name;
 302
 303                         if (!belongsToModel.BelongsToAtt.NotNull)
 304                         {
 305                                 attrs.Add("firstOption", "Empty");
 306                                 attrs.Add("firstOptionValue", "");
 307                         }
 308
 309                         stringBuilder.Append(Select(propName, items, attrs));
 310
 311                         return stringBuilder.ToString();
 312                 }
 313
 314                 public String CreateControl(ActiveRecordModel model, String prefix,
 315                                             HasManyModel hasManyModel, object instance)
 316                 {
 317                         stringBuilder.Length = 0;
 318
 319                         PropertyInfo prop = hasManyModel.Property;
 320
 321                         prefix += "." + prop.Name;
 322
 323                         ActiveRecordModel otherModel = ActiveRecordModel.GetModel(hasManyModel.HasManyAtt.MapType);
 324
 325                         PrimaryKeyModel keyModel = ObtainPKProperty(otherModel);
 326
 327                         if (otherModel == null || keyModel == null)
 328                         {
 329                                 return "Model not found or PK not found";
 330                         }
 331
 332                         object[] source = CommonOperationUtils.FindAll(otherModel.Type);
 333
 334                         stringBuilder.Append(prop.Name + ": &nbsp;");
 335                         stringBuilder.Append("<br/>\r\n");
 336
 337                         IDictionary attrs = new HybridDictionary(true);
 338
 339                         attrs["value"] = keyModel.Property.Name;
 340
 341                         FormHelper.CheckboxList list = CreateCheckboxList(prefix, source, attrs);
 342
 343                         foreach(object item in list)
 344                         {
 345                                 stringBuilder.Append(list.Item());
 346
 347                                 stringBuilder.Append(item.ToString());
 348
 349                                 stringBuilder.Append("<br/>\r\n");
 350                         }
 351
 352                         return stringBuilder.ToString();
 353                 }
 354
 355                 public String CreateControl(ActiveRecordModel model, String prefix,
 356                                             HasAndBelongsToManyModel hasAndBelongsModel, object instance)
 357                 {
 358                         stringBuilder.Length = 0;
 359
 360                         PropertyInfo prop = hasAndBelongsModel.Property;
 361
 362                         prefix += "." + prop.Name;
 363
 364                         ActiveRecordModel otherModel = ActiveRecordModel.GetModel(hasAndBelongsModel.HasManyAtt.MapType);
 365
 366                         PrimaryKeyModel keyModel = ObtainPKProperty(otherModel);
 367
 368                         if (otherModel == null || keyModel == null)
 369                         {
 370                                 return "Model not found or PK not found";
 371                         }
 372
 373                         object[] source = CommonOperationUtils.FindAll(otherModel.Type);
 374
 375                         stringBuilder.Append(prop.Name + ": &nbsp;");
 376                         stringBuilder.Append("<br/>\r\n");
 377
 378                         IDictionary attrs = new HybridDictionary(true);
 379
 380                         attrs["value"] = keyModel.Property.Name;
 381
 382                         FormHelper.CheckboxList list = CreateCheckboxList(prefix, source, attrs);
 383
 384                         foreach(object item in list)
 385                         {
 386                                 stringBuilder.Append(list.Item());
 387
 388                                 stringBuilder.Append(item.ToString());
 389
 390                                 stringBuilder.Append("<br/>\r\n");
 391                         }
 392
 393                         return stringBuilder.ToString();
 394                 }
 395
 396                 #endregion
 397
 398                 private void RenderAppropriateControl(ActiveRecordModel model,
 399                                                       Type propType, string propName, PropertyInfo property,
 400                                                       object value, bool unique, bool notNull, String columnType, int length)
 401                 {
 402                         IDictionary htmlAttributes = new Hashtable();
 403
 404                         if (propType == typeof(String))
 405                         {
 406                                 if (String.Compare("stringclob", columnType, true) == 0)
 407                                 {
 408                                         stringBuilder.AppendFormat(TextArea(propName));
 409                                 }
 410                                 else
 411                                 {
 412                                         if (length > 0)
 413                                         {
 414                                                 htmlAttributes["maxlength"] = length.ToString();
 415                                         }
 416
 417                                         stringBuilder.AppendFormat(TextField(propName, htmlAttributes));
 418                                 }
 419                         }
 420                         else if (propType == typeof(Int16) || propType == typeof(Int32) || propType == typeof(Int64))
 421                         {
 422                                 stringBuilder.AppendFormat(NumberField(propName, htmlAttributes));
 423                         }
 424                         else if (propType == typeof(Single) || propType == typeof(Double) || propType == typeof(Decimal))
 425                         {
 426                                 stringBuilder.AppendFormat(NumberField(propName, htmlAttributes));
 427                         }
 428                         else if (propType == typeof(DateTime))
 429                         {
 430                                 stringBuilder.AppendFormat(Select(propName + "month", Months, htmlAttributes));
 431                                 stringBuilder.AppendFormat(Select(propName + "day", Days, htmlAttributes));
 432                                 stringBuilder.AppendFormat(Select(propName + "year", Years, htmlAttributes));
 433                         }
 434                         else if (propType == typeof(bool))
 435                         {
 436                                 stringBuilder.Append(CheckboxField(propName));
 437                         }
 438                         else if (propType == typeof(Enum))
 439                         {
 440                                 // TODO: Support flags as well
 441
 442                                 String[] names = System.Enum.GetNames(propType);
 443
 444                                 IList options = new ArrayList();
 445
 446                                 foreach(String name in names)
 447                                 {
 448                                         options.Add(String.Format("{0} {1}\r\n",
 449                                                                   RadioField(propName, name), LabelFor(name, TextHelper.PascalCaseToWord(name))));
 450                                 }
 451                         }
 452                 }
 453
 454                 private static string CreatePropName(ActiveRecordModel model, String prefix, String name)
 455                 {
 456                         string propName;
 457
 458                         if (model.IsNestedType)
 459                         {
 460                                 propName = String.Format("{0}.{1}.{2}", prefix, model.ParentNested.Property.Name, name);
 461                         }
 462                         else
 463                         {
 464                                 propName = String.Format("{0}.{1}", prefix, name);
 465                         }
 466
 467                         return propName;
 468                 }
 469         }
 470 }