?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix the build.
[castle.git] / MonoRail / Castle.MonoRail.ActiveRecordSupport / ARDataBinder.cs
blobc38954fcce5eb7894a38c9c463f9cdb1a5bb8cf4
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.ActiveRecordSupport
16 {
17 using System;
18 using System.Collections;
19 using System.Reflection;
20 using Castle.ActiveRecord;
21 using Castle.ActiveRecord.Framework.Internal;
22 using Castle.Components.Binder;
23 using Iesi.Collections;
24 using NHibernate.Property;
25 using Iesi.Collections.Generic;
26 using System.Collections.Generic;
27
28 /// <summary>
29 /// Extends <see cref="DataBinder"/> class with some
30 /// ActiveRecord specific functionality.
31 /// <seealso cref="AutoLoadBehavior"/>
32 /// <seealso cref="ARDataBindAttribute"/>
33 /// </summary>
34 /// <remarks>
35 /// Autoload can be turned <i>on</i> on the parameter, see <see cref="AutoLoadBehavior"/>.
36 /// </remarks>
37 public class ARDataBinder : DataBinder
38 {
39 protected internal static readonly object[] EmptyArg = new object[0];
40
41 private AutoLoadBehavior autoLoad;
42 private bool persistchanges;
43 private string[] expectCollPropertiesList;
44 private Stack<ActiveRecordModel> modelStack = new Stack<ActiveRecordModel>();
45
46 /// <summary>
47 /// Gets or sets a value indicating if the changes should be persisted.
48 /// </summary>
49 /// <value><c>true</c> if the changes should be persisted; otherwise, <c>false</c>.</value>
50 public bool PersistChanges
51 {
52 get { return persistchanges; }
53 set { persistchanges = value; }
54 }
55
56 /// <summary>
57 /// Gets or sets the <see cref="AutoLoadBehavior"/>.
58 /// </summary>
59 /// <value>The auto load behavior.</value>
60 public AutoLoadBehavior AutoLoad
61 {
62 get { return autoLoad; }
63 set { autoLoad = value; }
64 }
65
66 protected override void PushInstance(object instance, string prefix)
67 {
68 ActiveRecordModel model = ActiveRecordModel.GetModel(instance.GetType());
69
70 if (model == null && modelStack.Count != 0)
71 {
72 foreach(NestedModel nestedModel in CurrentARModel.Components)
73 {
74 if (string.Compare(nestedModel.Property.Name, prefix, true) == 0)
75 {
76 model = nestedModel.Model;
77 break;
78 }
79 }
80 }
81
82 if (model != null)
83 {
84 modelStack.Push(model);
85 }
86
87 base.PushInstance(instance, prefix);
88 }
89
90 protected override void PopInstance(object instance, string prefix)
91 {
92 ActiveRecordModel model = ActiveRecordModel.GetModel(instance.GetType());
93
94 if (model == null && CurrentARModel != null && CurrentARModel.IsNestedType)
95 {
96 modelStack.Pop();
97 }
98
99 if (model != null)
100 {
101 ActiveRecordModel actualModel = modelStack.Pop();
102
103 if (actualModel != model)
104 {
105 throw new BindingException("Unexpected ARModel on the stack: found {0}, expecting {1}",
106 actualModel.ToString(), model.ToString());
107 }
108 }
109
110 base.PopInstance(instance, prefix);
111 }
112
113 /// <summary>
114 /// Gets the current AR model.
115 /// </summary>
116 /// <value>The current AR model.</value>
117 protected ActiveRecordModel CurrentARModel
118 {
119 get
120 {
121 return modelStack.Count == 0 ? null : modelStack.Peek();
122 }
123 }
124
125 public object BindObject(Type targetType, string prefix, string exclude, string allow, string expect,
126 CompositeNode treeRoot)
127 {
128 expectCollPropertiesList = CreateNormalizedList(expect);
129
130 return BindObject(targetType, prefix, exclude, allow, treeRoot);
131 }
132
133 protected override object CreateInstance(Type instanceType, String paramPrefix, Node node)
134 {
135 if (node == null)
136 {
137 throw new BindingException(
138 "Nothing found for the given prefix. Are you sure the form fields are using the prefix " +
139 paramPrefix + "?");
140 }
141
142 if (node.NodeType != NodeType.Composite)
143 {
144 throw new BindingException("Unexpected node type. Expecting Composite, found " + node.NodeType);
145 }
146
147 CompositeNode cNode = (CompositeNode) node;
148
149 object instance;
150
151 bool shouldLoad = autoLoad != AutoLoadBehavior.Never;
152
153 if (autoLoad == AutoLoadBehavior.OnlyNested)
154 {
155 shouldLoad = StackDepth != 0;
156 }
157
158 if (shouldLoad)
159 {
160 if (instanceType.IsArray)
161 {
162 throw new BindingException("ARDataBinder AutoLoad does not support arrays");
163 }
164
165 ActiveRecordModel model = ActiveRecordModel.GetModel(instanceType);
166
167 PrimaryKeyModel pkModel;
168
169 object id = ObtainPrimaryKeyValue(model, cNode, paramPrefix, out pkModel);
170
171 if (IsValidKey(id))
172 {
173 instance = FindByPrimaryKey(instanceType, id);
174 }
175 else
176 {
177 if (autoLoad == AutoLoadBehavior.NewInstanceIfInvalidKey ||
178 (autoLoad == AutoLoadBehavior.NewRootInstanceIfInvalidKey && StackDepth == 0))
179 {
180 instance = base.CreateInstance(instanceType, paramPrefix, node);
181 }
182 else if (autoLoad == AutoLoadBehavior.NullIfInvalidKey ||
183 autoLoad == AutoLoadBehavior.OnlyNested ||
184 (autoLoad == AutoLoadBehavior.NewRootInstanceIfInvalidKey && StackDepth != 0))
185 {
186 instance = null;
187 }
188 else
189 {
190 throw new BindingException(string.Format(
191 "Could not find primary key '{0}' for '{1}'",
192 pkModel.Property.Name, instanceType.FullName));
193 }
194 }
195 }
196 else
197 {
198 instance = base.CreateInstance(instanceType, paramPrefix, node);
199 }
200
201 return instance;
202 }
203
204 /// <summary>
205 /// for joined subclasses HasAndBelongsToMany properties doesn't include the ones of the parent class
206 /// so we need to check them recursively
207 /// </summary>
208 protected bool FindPropertyInHasAndBelongsToMany(ActiveRecordModel model, string propertyName,
209 ref Type foundType, ref ActiveRecordModel foundModel)
210 {
211 foreach(HasAndBelongsToManyModel hasMany2ManyModel in model.HasAndBelongsToMany)
212 {
213 // Inverse=true relations will be ignored
214 if (hasMany2ManyModel.Property.Name == propertyName && !hasMany2ManyModel.HasManyAtt.Inverse)
215 {
216 foundType = hasMany2ManyModel.HasManyAtt.MapType;
217 foundModel = ActiveRecordModel.GetModel(foundType);
218 return true;
219 }
220 }
221 if (model.IsJoinedSubClass || model.IsDiscriminatorSubClass)
222 {
223 return FindPropertyInHasAndBelongsToMany(model.Parent, propertyName, ref foundType, ref foundModel);
224 }
225 return false;
226 }
227
228 /// <summary>
229 /// for joined subclasses HasMany properties doesn't include the ones of the parent class
230 /// so we need to check them recursively
231 /// </summary>
232 protected bool FindPropertyInHasMany(ActiveRecordModel model, string propertyName,
233 ref Type foundType, ref ActiveRecordModel foundModel)
234 {
235 foreach(HasManyModel hasManyModel in model.HasMany)
236 {
237 // Inverse=true relations will be ignored
238 if (hasManyModel.Property.Name == propertyName && !hasManyModel.HasManyAtt.Inverse)
239 {
240 foundType = hasManyModel.HasManyAtt.MapType;
241 foundModel = ActiveRecordModel.GetModel(foundType);
242 return true;
243 }
244 }
245 if (model.IsJoinedSubClass || model.IsDiscriminatorSubClass)
246 {
247 return FindPropertyInHasMany(model.Parent, propertyName, ref foundType, ref foundModel);
248 }
249 return false;
250 }
251
252 protected override object BindSpecialObjectInstance(Type instanceType, string prefix, Node node,
253 out bool succeeded)
254 {
255 succeeded = false;
256
257 ActiveRecordModel model = CurrentARModel;
258
259 if (model == null)
260 {
261 return null;
262 }
263
264 object container = CreateContainer(instanceType);
265
266 bool found = false;
267 Type targetType = null;
268 ActiveRecordModel targetModel = null;
269
270 found = FindPropertyInHasAndBelongsToMany(model, prefix, ref targetType, ref targetModel);
271
272 if (!found)
273 {
274 found = FindPropertyInHasMany(model, prefix, ref targetType, ref targetModel);
275 }
276
277 if (found)
278 {
279 succeeded = true;
280
281 ClearContainer(container);
282
283 if (node.NodeType == NodeType.Indexed)
284 {
285 IndexedNode indexNode = (IndexedNode) node;
286
287 Array collArray = Array.CreateInstance(targetType, indexNode.ChildrenCount);
288
289 collArray = (Array) InternalBindObject(collArray.GetType(), prefix, node);
290
291 foreach(object item in collArray)
292 {
293 AddToContainer(container, item);
294 }
295 }
296 else if (node.NodeType == NodeType.Leaf)
297 {
298 PrimaryKeyModel pkModel = targetModel.PrimaryKey;
299 Type pkType = pkModel.Property.PropertyType;
300
301 LeafNode leafNode = (LeafNode) node;
302
303 bool convSucceeded;
304
305 if (leafNode.IsArray) // Multiples values found
306 {
307 foreach(object element in (Array) leafNode.Value)
308 {
309 object keyConverted = Converter.Convert(pkType, leafNode.ValueType.GetElementType(),
310 element, out convSucceeded);
311
312 if (convSucceeded)
313 {
314 object item = FindByPrimaryKey(targetType, keyConverted);
315 AddToContainer(container, item);
316 }
317 }
318 }
319 else // Single value found
320 {
321 object keyConverted = Converter.Convert(pkType, leafNode.ValueType.GetElementType(),
322 leafNode.Value, out convSucceeded);
323
324 if (convSucceeded)
325 {
326 object item = FindByPrimaryKey(targetType, keyConverted);
327 AddToContainer(container, item);
328 }
329 }
330 }
331 }
332
333 return container;
334 }
335
336 protected virtual object FindByPrimaryKey(Type targetType, object id)
337 {
338 return FindByPrimaryKey(targetType, id, true);
339 }
340
341 protected virtual object FindByPrimaryKey(Type targetType, object id, bool throwOnNotFound)
342 {
343 return ActiveRecordMediator.FindByPrimaryKey(targetType, id, throwOnNotFound);
344 }
345
346 protected override bool IsSpecialType(Type instanceType)
347 {
348 return IsContainerType(instanceType);
349 }
350
351 protected override void SetPropertyValue(object instance, PropertyInfo prop, object value)
352 {
353 object[] attributes = prop.GetCustomAttributes(typeof(WithAccessAttribute), false);
354
355 if (attributes.Length == 0)
356 {
357 base.SetPropertyValue(instance, prop, value);
358 return;
359 }
360
361 WithAccessAttribute accessAttribute = (WithAccessAttribute) attributes[0];
362 IPropertyAccessor propertyAccessor;
363
364 switch(accessAttribute.Access)
365 {
366 case PropertyAccess.Property:
367 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("property");
368 break;
369 case PropertyAccess.Field:
370 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("field");
371 break;
372 case PropertyAccess.FieldCamelcase:
373 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("field.camelcase");
374 break;
375 case PropertyAccess.FieldCamelcaseUnderscore:
376 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("field.camelcase-underscore");
377 break;
378 case PropertyAccess.FieldPascalcaseMUnderscore:
379 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("field.pascalcase-m-underscore");
380 break;
381 case PropertyAccess.FieldLowercaseUnderscore:
382 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("field.lowercase-underscore");
383 break;
384 case PropertyAccess.NosetterCamelcase:
385 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("nosetter.camelcase");
386 break;
387 case PropertyAccess.NosetterCamelcaseUnderscore:
388 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("nosetter.camelcase-underscore");
389 break;
390 case PropertyAccess.NosetterPascalcaseMUndersc:
391 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("nosetter.pascalcase-m-underscore");
392 break;
393 case PropertyAccess.NosetterLowercaseUnderscore:
394 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("nosetter.lowercase-underscore");
395 break;
396 case PropertyAccess.NosetterLowercase:
397 propertyAccessor = PropertyAccessorFactory.GetPropertyAccessor("nosetter.lowercase");
398 break;
399 default:
400 throw new ArgumentOutOfRangeException();
401 }
402
403 propertyAccessor.GetSetter(instance.GetType(), prop.Name).Set(instance, value);
404 }
405
406 /// <summary>
407 /// for joined subclasses BelongsTo properties doesn't include the ones of the parent class
408 /// so we need to check them recursively
409 /// </summary>
410 protected bool IsBelongsToRef(ActiveRecordModel arModel, string prefix)
411 {
412 foreach(BelongsToModel model in arModel.BelongsTo)
413 {
414 if (model.Property.Name == prefix)
415 {
416 return true;
417 }
418 }
419 if (arModel.IsJoinedSubClass || arModel.IsDiscriminatorSubClass)
420 {
421 return IsBelongsToRef(arModel.Parent, prefix);
422 }
423 return false;
424 }
425
426 protected override bool ShouldRecreateInstance(object value, Type type, string prefix, Node node)
427 {
428 if (IsContainerType(type))
429 {
430 return true;
431 }
432
433 if (node != null && CurrentARModel != null)
434 {
435 // If it's a belongsTo ref, we need to recreate it
436 // instead of overwrite its properties, otherwise NHibernate will complain
437 if (IsBelongsToRef(CurrentARModel, prefix))
438 {
439 return true;
440 }
441 }
442
443 return base.ShouldRecreateInstance(value, type, prefix, node);
444 }
445
446 protected override void BeforeBindingProperty(object instance, PropertyInfo prop, string prefix,
447 CompositeNode node)
448 {
449 base.BeforeBindingProperty(instance, prop, prefix, node);
450
451 if (IsPropertyExpected(prop, node))
452 {
453 ClearExpectedCollectionProperties(instance, prop);
454 }
455 }
456
457 private bool IsPropertyExpected(PropertyInfo prop, CompositeNode node)
458 {
459 string propId = string.Format("{0}.{1}", node.FullName, prop.Name);
460
461 if (expectCollPropertiesList != null)
462 {
463 return Array.BinarySearch(expectCollPropertiesList, propId, CaseInsensitiveComparer.Default) >= 0;
464 }
465
466 return false;
467 }
468
469 private void ClearExpectedCollectionProperties(object instance, PropertyInfo prop)
470 {
471 object value = prop.GetValue(instance, null);
472
473 ClearContainer(value);
474 }
475
476 #region helpers
477
478 private object ObtainPrimaryKeyValue(ActiveRecordModel model, CompositeNode node, String prefix,
479 out PrimaryKeyModel pkModel)
480 {
481 pkModel = ObtainPrimaryKey(model);
482
483 String pkPropName = pkModel.Property.Name;
484
485 Node idNode = node.GetChildNode(pkPropName);
486
487 if (idNode != null && idNode.NodeType != NodeType.Leaf)
488 {
489 throw new BindingException("Expecting leaf node to contain id for ActiveRecord class. " +
490 "Prefix: {0} PK Property Name: {1}", prefix, pkPropName);
491 }
492
493 LeafNode lNode = (LeafNode) idNode;
494
495 if (lNode == null)
496 {
497 throw new BindingException("ARDataBinder autoload failed as element {0} " +
498 "doesn't have a primary key {1} value", prefix, pkPropName);
499 }
500
501 bool conversionSuc;
502
503 return Converter.Convert(pkModel.Property.PropertyType, lNode.ValueType, lNode.Value, out conversionSuc);
504 }
505
506 private static PrimaryKeyModel ObtainPrimaryKey(ActiveRecordModel model)
507 {
508 if (model.IsJoinedSubClass || model.IsDiscriminatorSubClass)
509 {
510 return ObtainPrimaryKey(model.Parent);
511 }
512 return model.PrimaryKey;
513 }
514
515 private bool IsValidKey(object id)
516 {
517 if (id != null)
518 {
519 if (id.GetType() == typeof(String))
520 {
521 return id.ToString() != String.Empty;
522 }
523 else if (id.GetType() == typeof(Guid))
524 {
525 return Guid.Empty != ((Guid) id);
526 }
527 else
528 {
529 return Convert.ToInt64(id) != 0;
530 }
531 }
532
533 return false;
534 }
535
536 private bool IsContainerType(Type type)
537 {
538 bool isContainerType = type == typeof(IList) || type == typeof(ISet);
539
540 if (!isContainerType && type.IsGenericType)
541 {
542 Type[] genericArgs = type.GetGenericArguments();
543
544 Type genType = typeof(ICollection<>).MakeGenericType(genericArgs);
545
546 isContainerType = genType.IsAssignableFrom(type);
547 }
548
549 return isContainerType;
550 }
551
552 private object CreateContainer(Type type)
553 {
554 if (type.IsGenericType)
555 {
556 if (type.GetGenericTypeDefinition() == typeof(ISet<>))
557 {
558 Type[] genericArgs = type.GetGenericArguments();
559 Type genericType = typeof(HashedSet<>).MakeGenericType(genericArgs);
560 return Activator.CreateInstance(genericType);
561 }
562 else if (type.GetGenericTypeDefinition() == typeof(IList<>))
563 {
564 Type[] genericArgs = type.GetGenericArguments();
565 Type genericType = typeof(List<>).MakeGenericType(genericArgs);
566 return Activator.CreateInstance(genericType);
567 }
568 }
569 else
570 {
571 if (type == typeof(IList))
572 {
573 return new ArrayList();
574 }
575 else if (type == typeof(ISet))
576 {
577 return new HashedSet();
578 }
579 }
580 return null;
581 }
582
583 private void ClearContainer(object instance)
584 {
585 if (instance is IList)
586 {
587 (instance as IList).Clear();
588 }
589 else if (instance is ISet)
590 {
591 (instance as ISet).Clear();
592 }
593 }
594
595 private void AddToContainer(object container, object item)
596 {
597 if (container is IList)
598 {
599 (container as IList).Add(item);
600 }
601 else if (container is ISet)
602 {
603 (container as ISet).Add(item);
604 }
605 else if (container != null)
606 {
607 Type itemType = item.GetType();
608
609 Type collectionType = typeof(ICollection<>).MakeGenericType(itemType);
610
611 if (collectionType.IsAssignableFrom(container.GetType()))
612 {
613 MethodInfo addMethod = container.GetType().GetMethod("Add");
614
615 addMethod.Invoke(container, new object[] {item});
616 }
617 }
618 }
619
620 #endregion
621 }
622 }
Git import of castle svn