MonoRail/Castle.MonoRail.ActiveRecordSupport/ARFetcher.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
  16 {
  17         using System;
  18         using System.Reflection;
  19
  20         using NHibernate;
  21         using NHibernate.Expressions;
  22
  23         using Castle.ActiveRecord;
  24         using Castle.ActiveRecord.Framework.Internal;
  25         using Castle.Components.Binder;
  26         using Castle.MonoRail.Framework;
  27
  28         /// <summary>
  29         /// Class responsible on loading records for parameters marked with the <see cref="ARFetchAttribute" />.
  30         /// </summary>
  31         public class ARFetcher
  32         {
  33                 private readonly IConverter converter;
  34
  35                 public ARFetcher(IConverter converter)
  36                 {
  37                         this.converter = converter;
  38                 }
  39
  40                 public object FetchActiveRecord(ParameterInfo param, ARFetchAttribute attr, IRequest request)
  41                 {
  42                         Type type = param.ParameterType;
  43
  44                         bool isArray = type.IsArray;
  45
  46                         if (isArray) type = type.GetElementType();
  47
  48                         ActiveRecordModel model = ActiveRecordModel.GetModel(type);
  49
  50                         if (model == null)
  51                         {
  52                                 throw new MonoRailException(String.Format("'{0}' is not an ActiveRecord " +
  53                                         "class. It could not be bound to an [ARFetch] attribute.", type.Name));
  54                         }
  55
  56                         if (model.CompositeKey != null)
  57                         {
  58                                 throw new MonoRailException("ARFetch only supports single-attribute primary keys");
  59                         }
  60
  61                         String webParamName = attr.RequestParameterName != null ? attr.RequestParameterName : param.Name;
  62
  63                         if (!isArray)
  64                         {
  65                                 return LoadActiveRecord(type, request.Params[webParamName], attr, model);
  66                         }
  67
  68                         object[] pks = request.Params.GetValues(webParamName);
  69
  70                         if (pks == null)
  71                         {
  72                                 pks = new object[0];
  73                         }
  74
  75                         Array objs = Array.CreateInstance(type, pks.Length);
  76
  77                         for(int i = 0; i < objs.Length; i++)
  78                         {
  79                                 objs.SetValue(LoadActiveRecord(type, pks[i], attr, model), i);
  80                         }
  81
  82                         return objs;
  83                 }
  84
  85                 private object LoadActiveRecord(Type type, object pk, ARFetchAttribute attr, ActiveRecordModel model)
  86                 {
  87                         object instance = null;
  88
  89                         if (pk != null && !String.Empty.Equals(pk))
  90                         {
  91                                 PrimaryKeyModel pkModel = ObtainPrimaryKey(model);
  92
  93                                 Type pkType = pkModel.Property.PropertyType;
  94
  95                                 bool conversionSucceeded;
  96                                 object convertedPk = converter.Convert(pkType, pk.GetType(), pk, out conversionSucceeded);
  97
  98                                 if (!conversionSucceeded)
  99                                 {
 100                                         throw new MonoRailException("ARFetcher could not convert PK {0} to type {1}", pk, pkType);
 101                                 }
 102
 103                                 if (attr.Eager == null || attr.Eager.Length == 0)
 104                                 {
 105                                         // simple load
 106                                         instance = ActiveRecordMediator.FindByPrimaryKey(type, convertedPk, attr.Required);
 107                                 }
 108                                 else
 109                                 {
 110                                         // load using eager fetching of lazy collections
 111                                         DetachedCriteria criteria = DetachedCriteria.For(type);
 112                                         criteria.Add(Expression.Eq(pkModel.Property.Name, convertedPk));
 113                                         foreach (string associationToEagerFetch in attr.Eager.Split(','))
 114                                         {
 115                                                 string clean = associationToEagerFetch.Trim();
 116                                                 if (clean.Length == 0)
 117                                                 {
 118                                                         continue;
 119                                                 }
 120
 121                                                 criteria.SetFetchMode(clean, FetchMode.Eager);
 122                                         }
 123
 124                                         object[] result = (object[]) ActiveRecordMediator.FindAll(type, criteria);
 125                                         if (result.Length > 0)
 126                                                 instance = result[0];
 127                                 }
 128                         }
 129
 130                         if (instance == null && attr.Create)
 131                         {
 132                                 instance = Activator.CreateInstance(type);
 133                         }
 134
 135                         return instance;
 136                 }
 137
 138                 private static PrimaryKeyModel ObtainPrimaryKey(ActiveRecordModel model)
 139                 {
 140                         if (model.IsJoinedSubClass || model.IsDiscriminatorSubClass)
 141                         {
 142                                 return ObtainPrimaryKey(model.Parent);
 143                         }
 144                         return model.PrimaryKey;
 145                 }
 146
 147         }
 148 }