MonoRail/Castle.MonoRail.ActiveRecordScaffold/Helpers/ARFormHelper.cs

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