?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixing an issue with output parameters that are of type IntPtr
[castle.git] / MonoRail / Castle.MonoRail.Framework / Helpers / AbstractFormRelatedHelper.cs
blobb12af0688c8dc2ede0225898b5bac654deed0cda
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.Framework.Helpers
16 {
17 using System;
18 using System.Collections;
19 using System.Collections.Generic;
20 using System.Collections.Specialized;
21 using System.Data;
22 using System.Reflection;
23 using System.Text;
24 using Castle.Components.Binder;
25 using Castle.Components.Validator;
26 using Castle.Core.Logging;
27 using Core;
28 using Internal;
29 using ValidationStrategy;
30
31 /// <summary>
32 /// Represents all scopes that the <see cref="FormHelper"/>
33 /// uses to search for root values
34 /// </summary>
35 public enum RequestContext
36 {
37 /// <summary>
38 /// All scopes should be searched
39 /// </summary>
40 All,
41 /// <summary>
42 /// Only PropertyBag should be searched
43 /// </summary>
44 PropertyBag,
45 /// <summary>
46 /// Only Flash should be searched
47 /// </summary>
48 Flash,
49 /// <summary>
50 /// Only Session should be searched
51 /// </summary>
52 Session,
53 /// <summary>
54 /// Only Request should be searched
55 /// </summary>
56 Request,
57 /// <summary>
58 /// Only Params should be searched
59 /// </summary>
60 Params
61 }
62
63 /// <summary>
64 /// Base class that exposes common operations for form handling, field bindings and so on.
65 /// </summary>
66 public abstract class AbstractFormRelatedHelper : AbstractHelper
67 {
68 /// <summary>
69 /// Common property flags for reflection
70 /// </summary>
71 protected static readonly BindingFlags PropertyFlags = BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
72 /// <summary>
73 /// Common property flags for reflection (with declared only)
74 /// </summary>
75 protected static readonly BindingFlags propertyFlagsDeclaredOnly = BindingFlags.GetProperty | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase | BindingFlags.DeclaredOnly;
76 /// <summary>
77 /// Common field flags for reflection
78 /// </summary>
79 protected static readonly BindingFlags FieldFlags = BindingFlags.GetField | BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase;
80
81 /// <summary>
82 /// Logger instance
83 /// </summary>
84 protected static ILogger logger = NullLogger.Instance;
85
86 /// <summary>
87 ///
88 /// </summary>
89 protected BrowserValidationConfiguration validationConfig;
90 /// <summary>
91 ///
92 /// </summary>
93 private IBrowserValidatorProvider validatorProvider;
94 /// <summary>
95 ///
96 /// </summary>
97 protected readonly Stack objectStack = new Stack();
98
99 private IValidatorRegistry validatorRegistry;
100 private ValidatorRunner validatorRunner;
101 private bool isValidationDisabled;
102
103 /// <summary>
104 /// Initializes a new instance of the <see cref="AbstractFormRelatedHelper"/> class.
105 /// </summary>
106 protected AbstractFormRelatedHelper()
107 {
108 }
109
110 /// <summary>
111 /// Initializes a new instance of the <see cref="AbstractFormRelatedHelper"/> class.
112 /// </summary>
113 /// <param name="validatorRegistry">The validator registry.</param>
114 /// <param name="validatorRunner">The validator runner.</param>
115 protected AbstractFormRelatedHelper(IValidatorRegistry validatorRegistry, ValidatorRunner validatorRunner)
116 {
117 this.validatorRegistry = validatorRegistry;
118 this.validatorRunner = validatorRunner;
119 }
120
121 /// <summary>
122 /// Initializes a new instance of the <see cref="AbstractFormRelatedHelper"/> class.
123 /// </summary>
124 /// <param name="engineContext">The engine context.</param>
125 protected AbstractFormRelatedHelper(IEngineContext engineContext) : base(engineContext)
126 {
127 }
128
129 /// <summary>
130 /// Gets or sets the validator provider.
131 /// </summary>
132 /// <value>The validator provider.</value>
133 public IBrowserValidatorProvider ValidatorProvider
134 {
135 get { return validatorProvider; }
136 set { validatorProvider = value; }
137 }
138
139 /// <summary>
140 /// Gets or sets the validator runner.
141 /// </summary>
142 /// <value>The validator runner.</value>
143 public ValidatorRunner ValidatorRunner
144 {
145 get { return validatorRunner; }
146 set { validatorRunner = value; }
147 }
148
149 /// <summary>
150 /// Gets or sets the validator registry.
151 /// </summary>
152 /// <value>The validator registry.</value>
153 public IValidatorRegistry ValidatorRegistry
154 {
155 get { return validatorRegistry; }
156 set { validatorRegistry = value; }
157 }
158
159 #region protected members
160
161 /// <summary>
162 /// Rewrites the target if within object scope.
163 /// </summary>
164 /// <param name="target">The target.</param>
165 /// <returns></returns>
166 protected string RewriteTargetIfWithinObjectScope(string target)
167 {
168 if (objectStack.Count == 0)
169 {
170 return target;
171 }
172 else
173 {
174 return ((FormScopeInfo) objectStack.Peek()).RootTarget + "." + target;
175 }
176 }
177
178 /// <summary>
179 /// Creates the specified input element
180 /// using the specified parameters to supply the name, value, id and others
181 /// html attributes.
182 /// </summary>
183 /// <param name="type"></param>
184 /// <param name="target">The object to get the value from and to be based on to create the element name.</param>
185 /// <param name="value"></param>
186 /// <param name="attributes">Attributes for the FormHelper method and for the html element it generates</param>
187 /// <returns>The generated form element</returns>
188 protected virtual string CreateInputElement(string type, string target, Object value, IDictionary attributes)
189 {
190 if (value == null)
191 {
192 value = CommonUtils.ObtainEntryAndRemove(attributes, "defaultValue");
193 }
194
195 string id = CreateHtmlId(attributes, target);
196
197 return CreateInputElement(type, id, target, FormatIfNecessary(value, attributes), attributes);
198 }
199
200 /// <summary>
201 /// Creates the specified input element
202 /// using the specified parameters to supply the name, value, id and others
203 /// html attributes.
204 /// </summary>
205 /// <param name="type"></param>
206 /// <param name="id"></param>
207 /// <param name="target">The object to get the value from and to be based on to create the element name.</param>
208 /// <param name="value"></param>
209 /// <param name="attributes">Attributes for the FormHelper method and for the html element it generates</param>
210 /// <returns>The generated form element</returns>
211 protected virtual string CreateInputElement(string type, string id, string target, string value, IDictionary attributes)
212 {
213 value = FormatIfNecessary(value, attributes);
214
215 value = SafeHtmlEncode(value);
216
217 if (attributes != null && attributes.Contains("mask"))
218 {
219 string mask = CommonUtils.ObtainEntryAndRemove(attributes, "mask");
220 string maskSep = CommonUtils.ObtainEntryAndRemove(attributes, "mask_separator", "-");
221
222 string onBlur = CommonUtils.ObtainEntryAndRemove(attributes, "onBlur", "void(0)");
223 string onKeyUp = CommonUtils.ObtainEntryAndRemove(attributes, "onKeyUp", "void(0)");
224
225 string js = "return monorail_formhelper_mask(event,this,'" + mask + "','" + maskSep + "');";
226
227 attributes["onBlur"] = "javascript:" + onBlur + ";" + js;
228 attributes["onKeyUp"] = "javascript:" + onKeyUp + ";" + js;
229 }
230
231 return String.Format("<input type=\"{0}\" id=\"{1}\" name=\"{2}\" value=\"{3}\" {4}/>",
232 type, id, target, value, GetAttributes(attributes));
233 }
234
235 /// <summary>
236 /// Creates the input element.
237 /// </summary>
238 /// <param name="type">The type.</param>
239 /// <param name="value">The value.</param>
240 /// <param name="attributes">The attributes.</param>
241 /// <returns></returns>
242 protected virtual string CreateInputElement(string type, string value, IDictionary attributes)
243 {
244 return String.Format("<input type=\"{0}\" value=\"{1}\" {2}/>",
245 type, FormatIfNecessary(value, attributes), GetAttributes(attributes));
246 }
247
248 /// <summary>
249 /// Formats if necessary.
250 /// </summary>
251 /// <param name="value">The value.</param>
252 /// <param name="attributes">The attributes.</param>
253 /// <returns></returns>
254 protected static string FormatIfNecessary(object value, IDictionary attributes)
255 {
256 string formatString = CommonUtils.ObtainEntryAndRemove(attributes, "textformat");
257
258 if (value != null && formatString != null)
259 {
260 IFormattable formattable = value as IFormattable;
261
262 if (formattable != null)
263 {
264 value = formattable.ToString(formatString, null);
265 }
266 }
267 else if (value == null)
268 {
269 value = String.Empty;
270 }
271
272 return value.ToString();
273 }
274
275 /// <summary>
276 /// Obtains the target property.
277 /// </summary>
278 /// <param name="context">The context.</param>
279 /// <param name="target">The target.</param>
280 /// <param name="action">The action.</param>
281 /// <returns></returns>
282 protected PropertyInfo ObtainTargetProperty(RequestContext context, string target, Action<PropertyInfo> action)
283 {
284 string[] pieces;
285
286 Type root = ObtainRootType(context, target, out pieces);
287
288 if (root != null && pieces.Length > 1)
289 {
290 return QueryPropertyInfoRecursive(root, pieces, 1, action);
291 }
292
293 return null;
294 }
295
296 /// <summary>
297 /// Queries the context for the target value
298 /// </summary>
299 /// <param name="target">The object to get the value from and to be based on to create the element name.</param>
300 /// <returns>The generated form element</returns>
301 protected object ObtainValue(string target)
302 {
303 return ObtainValue(RequestContext.All, target);
304 }
305
306 /// <summary>
307 /// Queries the context for the target value
308 /// </summary>
309 /// <param name="context"></param>
310 /// <param name="target">The object to get the value from and to be based on to create the element name.</param>
311 /// <returns>The generated form element</returns>
312 protected object ObtainValue(RequestContext context, string target)
313 {
314 string[] pieces;
315
316 object rootInstance = ObtainRootInstance(context, target, out pieces);
317
318 if (rootInstance != null && pieces.Length > 1)
319 {
320 return QueryPropertyRecursive(rootInstance, pieces, 1);
321 }
322
323 return rootInstance;
324 }
325
326 /// <summary>
327 /// Obtains the root instance.
328 /// </summary>
329 /// <param name="context">The context.</param>
330 /// <param name="target">The object to get the value from and to be based on to create the element name.</param>
331 /// <returns>The generated form element</returns>
332 protected object ObtainRootInstance(RequestContext context, string target)
333 {
334 object rootInstance = null;
335
336 if (context == RequestContext.All || context == RequestContext.PropertyBag)
337 {
338 rootInstance = ControllerContext.PropertyBag[target];
339 }
340 if (rootInstance == null && (context == RequestContext.All || context == RequestContext.Flash))
341 {
342 rootInstance = Context.Flash[target];
343 }
344 if (rootInstance == null && (context == RequestContext.All || context == RequestContext.Session))
345 {
346 rootInstance = Context.Session[target];
347 }
348 if (rootInstance == null && (context == RequestContext.All || context == RequestContext.Params))
349 {
350 rootInstance = Context.Request.Params[target];
351 }
352 if (rootInstance == null && (context == RequestContext.All || context == RequestContext.Request))
353 {
354 rootInstance = Context.Items[target];
355 }
356
357 return rootInstance;
358 }
359
360 /// <summary>
361 /// Obtains the root instance.
362 /// </summary>
363 /// <param name="context">The context.</param>
364 /// <param name="target">The target.</param>
365 /// <param name="pieces">The pieces.</param>
366 /// <returns></returns>
367 protected object ObtainRootInstance(RequestContext context, string target, out string[] pieces)
368 {
369 pieces = target.Split(new char[] { '.' });
370
371 string root = pieces[0];
372
373 int index;
374
375 bool isIndexed = CheckForExistenceAndExtractIndex(ref root, out index);
376
377 object rootInstance = ObtainRootInstance(context, root);
378
379 if (rootInstance == null)
380 {
381 return null;
382 }
383
384 if (isIndexed)
385 {
386 AssertIsValidArray(rootInstance, root, index);
387 }
388
389 if (!isIndexed && pieces.Length == 1)
390 {
391 return rootInstance;
392 }
393 else if (isIndexed)
394 {
395 rootInstance = GetArrayElement(rootInstance, index);
396 }
397
398 return rootInstance;
399 }
400
401 /// <summary>
402 /// Obtains the type of the root.
403 /// </summary>
404 /// <param name="context">The context.</param>
405 /// <param name="target">The target.</param>
406 /// <param name="pieces">The pieces.</param>
407 /// <returns></returns>
408 private Type ObtainRootType(RequestContext context, string target, out string[] pieces)
409 {
410 pieces = target.Split(new char[] { '.' });
411
412 Type foundType = (Type) ControllerContext.PropertyBag[pieces[0] + "type"];
413
414 if (foundType == null)
415 {
416 string trimmed = pieces[0].Split('[')[0];
417
418 foundType = (Type) ControllerContext.PropertyBag[trimmed + "type"];
419
420 if (foundType == null)
421 {
422 object root = ObtainRootInstance(context, target, out pieces);
423
424 if (root != null)
425 {
426 foundType = root.GetType();
427 }
428 }
429 }
430
431 return foundType;
432 }
433
434 /// <summary>
435 /// Queries the property info recursive.
436 /// </summary>
437 /// <param name="type">The type.</param>
438 /// <param name="propertyPath">The property path.</param>
439 /// <returns></returns>
440 protected static PropertyInfo QueryPropertyInfoRecursive(Type type, string[] propertyPath)
441 {
442 return QueryPropertyInfoRecursive(type, propertyPath, 0, null);
443 }
444
445 /// <summary>
446 /// Queries the property info recursive.
447 /// </summary>
448 /// <param name="type">The type.</param>
449 /// <param name="propertyPath">The property path.</param>
450 /// <param name="piece">The piece.</param>
451 /// <param name="action">The action.</param>
452 /// <returns></returns>
453 protected static PropertyInfo QueryPropertyInfoRecursive(Type type, string[] propertyPath, int piece, Action<PropertyInfo> action)
454 {
455 string property = propertyPath[piece];
456 int index;
457
458 bool isIndexed = CheckForExistenceAndExtractIndex(ref property, out index);
459
460 //PropertyInfo propertyInfo = type.GetProperty(property, ResolveFlagsToUse(type));
461 PropertyInfo propertyInfo = GetPropertyInfo(type, property);
462
463 if (propertyInfo == null)
464 {
465 if (logger.IsErrorEnabled)
466 {
467 logger.Error("No public property '{0}' found on type '{1}'", property, type.FullName);
468 }
469
470 return null;
471 }
472
473 if (!propertyInfo.CanRead)
474 {
475 throw new BindingException("Property '{0}' for type '{1}' can not be read",
476 propertyInfo.Name, type.FullName);
477 }
478
479 if (propertyInfo.GetIndexParameters().Length != 0)
480 {
481 throw new BindingException("Property '{0}' for type '{1}' has indexes, which are not supported",
482 propertyInfo.Name, type.FullName);
483 }
484
485 if (action != null)
486 {
487 action(propertyInfo);
488 }
489
490 type = propertyInfo.PropertyType;
491
492 if (typeof(ICollection).IsAssignableFrom(type))
493 {
494 return null;
495 }
496
497 if (isIndexed)
498 {
499 if (type.IsGenericType)
500 {
501 Type[] args = type.GetGenericArguments();
502 if (args.Length != 1)
503 throw new BindingException("Expected the generic indexed property '{0}' to be of 1 element", type.Name);
504 type = args[0];
505 }
506
507 if (type.IsArray)
508 {
509 type = type.GetElementType();
510 }
511 }
512
513 if (piece + 1 == propertyPath.Length)
514 {
515 return propertyInfo;
516 }
517
518 return QueryPropertyInfoRecursive(type, propertyPath, piece + 1, action);
519 }
520
521 /// <summary>
522 /// Query property paths agains the rootInstance type
523 /// </summary>
524 /// <param name="rootInstance">the object to query</param>
525 /// <param name="propertyPath">property path</param>
526 /// <returns>The generated form element</returns>
527 protected static object QueryPropertyRecursive(object rootInstance, string[] propertyPath)
528 {
529 return QueryPropertyRecursive(rootInstance, propertyPath, 0);
530 }
531
532 /// <summary>
533 /// Query property paths agains the rootInstance type
534 /// </summary>
535 /// <param name="rootInstance">the object to query</param>
536 /// <param name="propertyPath">property path</param>
537 /// <param name="piece">start index</param>
538 /// <returns>The generated form element</returns>
539 protected static object QueryPropertyRecursive(object rootInstance, string[] propertyPath, int piece)
540 {
541 string property = propertyPath[piece];
542 int index;
543
544 Type instanceType = rootInstance.GetType();
545
546 bool isIndexed = CheckForExistenceAndExtractIndex(ref property, out index);
547
548 //PropertyInfo propertyInfo = instanceType.GetProperty(property, ResolveFlagsToUse(instanceType));
549 PropertyInfo propertyInfo = GetPropertyInfo(instanceType, property);
550
551 object instance = null;
552
553 if (propertyInfo == null)
554 {
555 FieldInfo fieldInfo = instanceType.GetField(property, FieldFlags);
556
557 if (fieldInfo != null)
558 {
559 instance = fieldInfo.GetValue(rootInstance);
560 }
561 }
562 else
563 {
564 if (!propertyInfo.CanRead)
565 {
566 throw new BindingException("Property '{0}' for type '{1}' can not be read",
567 propertyInfo.Name, instanceType.FullName);
568 }
569
570 if (propertyInfo.GetIndexParameters().Length != 0)
571 {
572 throw new BindingException("Property '{0}' for type '{1}' has indexes, which are not supported",
573 propertyInfo.Name, instanceType.FullName);
574 }
575
576 instance = propertyInfo.GetValue(rootInstance, null);
577 }
578
579 if (isIndexed && instance != null)
580 {
581 AssertIsValidArray(instance, property, index);
582
583 instance = GetArrayElement(instance, index);
584 }
585
586 if (instance == null || piece + 1 == propertyPath.Length)
587 {
588 return instance;
589 }
590
591 return QueryPropertyRecursive(instance, propertyPath, piece + 1);
592 }
593
594 /// <summary>
595 /// Creates the HTML id.
596 /// </summary>
597 /// <param name="attributes">The attributes.</param>
598 /// <param name="target">The target.</param>
599 /// <returns>The generated form element</returns>
600 protected static string CreateHtmlId(IDictionary attributes, string target)
601 {
602 return CreateHtmlId(attributes, target, true);
603 }
604
605 /// <summary>
606 /// Creates the HTML id.
607 /// </summary>
608 /// <param name="attributes">The attributes.</param>
609 /// <param name="target">The target.</param>
610 /// <param name="removeEntry">if set to <c>true</c> [remove entry].</param>
611 /// <returns>The generated form element</returns>
612 protected static string CreateHtmlId(IDictionary attributes, string target, bool removeEntry)
613 {
614 string id;
615
616 if (removeEntry)
617 {
618 id = CommonUtils.ObtainEntryAndRemove(attributes, "id");
619 }
620 else
621 {
622 id = CommonUtils.ObtainEntry(attributes, "id");
623 }
624
625 if (id == null)
626 {
627 id = CreateHtmlId(target);
628 }
629
630 return id;
631 }
632
633 #endregion
634
635
636 #region Validation
637
638 /// <summary>
639 /// Disables the validation.
640 /// </summary>
641 public virtual void DisableValidation()
642 {
643 isValidationDisabled = true;
644 }
645
646 /// <summary>
647 /// Applies the validation.
648 /// </summary>
649 /// <param name="inputType">Type of the input.</param>
650 /// <param name="target">The target.</param>
651 /// <param name="attributes">The attributes.</param>
652 protected virtual void ApplyValidation(InputElementType inputType, string target, ref IDictionary attributes)
653 {
654 bool disableValidation = CommonUtils.ObtainEntryAndRemove(attributes, "disablevalidation", "false") == "true";
655
656 if (!IsValidationEnabled || disableValidation)
657 {
658 return;
659 }
660
661 if (validatorRegistry == null || validationConfig == null)
662 {
663 return;
664 }
665
666 if (attributes == null)
667 {
668 attributes = new HybridDictionary(true);
669 }
670
671 IValidator[] validators = CollectValidators(RequestContext.All, target);
672
673 IBrowserValidationGenerator generator = validatorProvider.CreateGenerator(validationConfig, inputType, attributes);
674
675 string id = CreateHtmlId(attributes, target, false);
676
677 foreach (IValidator validator in validators)
678 {
679 if (validator.SupportsBrowserValidation)
680 {
681 validator.ApplyBrowserValidation(validationConfig, inputType, generator, attributes, id);
682 }
683 }
684 }
685
686 private IValidator[] CollectValidators(RequestContext requestContext, string target)
687 {
688 List<IValidator> validators = new List<IValidator>();
689
690 ObtainTargetProperty(requestContext, target, delegate(PropertyInfo property)
691 {
692 validators.AddRange(validatorRegistry.GetValidators(validatorRunner, property.DeclaringType, property, RunWhen.Everytime));
693 });
694
695 return validators.ToArray();
696 }
697
698 /// <summary>
699 /// Gets a value indicating whether validation is enabled.
700 /// </summary>
701 /// <value>
702 /// <c>true</c> if validation is enabled; otherwise, <c>false</c>.
703 /// </value>
704 protected bool IsValidationEnabled
705 {
706 get
707 {
708 if (isValidationDisabled)
709 return false;
710
711 if (objectStack.Count == 0)
712 return true;
713
714 return ((FormScopeInfo) objectStack.Peek()).IsValidationEnabled;
715 }
716 }
717
718 #endregion
719
720 #region private helpers
721
722 private static void AssertIsValidArray(object instance, string property, int index)
723 {
724 Type instanceType = instance.GetType();
725
726 IList list = instance as IList;
727
728 bool validList = false;
729
730 if (list == null && instanceType.IsGenericType)
731 {
732 Type[] genArgs = instanceType.GetGenericArguments();
733
734 Type genList = typeof(System.Collections.Generic.IList<>).MakeGenericType(genArgs);
735 Type genTypeDef = instanceType.GetGenericTypeDefinition().MakeGenericType(genArgs);
736
737 validList = genList.IsAssignableFrom(genTypeDef);
738 }
739
740 if (!validList && list == null)
741 {
742 throw new MonoRailException("The property {0} is being accessed as " +
743 "an indexed property but does not seem to implement IList. " +
744 "In fact the type is {1}", property, instanceType.FullName);
745 }
746
747 if (index < 0)
748 {
749 throw new MonoRailException("The specified index '{0}' is outside the bounds " +
750 "of the array. Property {1}", index, property);
751 }
752 }
753
754 private static object GetArrayElement(object instance, int index)
755 {
756 IList list = instance as IList;
757
758 if (list == null && instance != null && instance.GetType().IsGenericType)
759 {
760 Type instanceType = instance.GetType();
761
762 Type[] genArguments = instanceType.GetGenericArguments();
763
764 Type genType = instanceType.GetGenericTypeDefinition().MakeGenericType(genArguments);
765
766 // I'm not going to retest for IList implementation as
767 // if we got here, the AssertIsValidArray has run successfully
768
769 PropertyInfo countPropInfo = genType.GetProperty("Count");
770
771 int count = (int) countPropInfo.GetValue(instance, null);
772
773 if (count == 0 || index + 1 > count)
774 {
775 return null;
776 }
777
778 PropertyInfo indexerPropInfo = genType.GetProperty("Item");
779
780 return indexerPropInfo.GetValue(instance, new object[] { index });
781 }
782
783 if (list == null || list.Count == 0 || index + 1 > list.Count)
784 {
785 return null;
786 }
787
788 return list[index];
789 }
790
791 private static bool CheckForExistenceAndExtractIndex(ref string property, out int index)
792 {
793 bool isIndexed = property.IndexOf('[') != -1;
794
795 index = -1;
796
797 if (isIndexed)
798 {
799 int start = property.IndexOf('[') + 1;
800 int len = property.IndexOf(']', start) - start;
801
802 string indexStr = property.Substring(start, len);
803
804 try
805 {
806 index = Convert.ToInt32(indexStr);
807 }
808 catch (Exception)
809 {
810 throw new MonoRailException("Could not convert (param {0}) index to Int32. Value is {1}",
811 property, indexStr);
812 }
813
814 property = property.Substring(0, start - 1);
815 }
816
817 return isIndexed;
818 }
819
820 /// <summary>
821 /// Compares the left and right value for equality.
822 /// </summary>
823 /// <param name="left">The left.</param>
824 /// <param name="right">The right.</param>
825 /// <returns></returns>
826 protected static bool AreEqual(object left, object right)
827 {
828 if (left == null || right == null)
829 return false;
830
831 if (left is string && right is String)
832 {
833 return String.Compare(left.ToString(), right.ToString()) == 0;
834 }
835
836 if (left.GetType() == right.GetType())
837 {
838 return right.Equals(left);
839 }
840
841 IConvertible convertible = left as IConvertible;
842
843 if (convertible != null)
844 {
845 try
846 {
847 object newleft = convertible.ToType(right.GetType(), null);
848 return (newleft.Equals(right));
849 }
850 catch (Exception)
851 {
852 // Do nothing
853 }
854 }
855
856 return left.ToString().Equals(right.ToString());
857 }
858
859 /// <summary>
860 /// Encodes the content if there is a valid context set for this helper.
861 /// </summary>
862 /// <param name="content">The content to be encoded.</param>
863 /// <returns></returns>
864 protected string SafeHtmlEncode(string content)
865 {
866 if (Context != null)
867 {
868 return HtmlEncode(content);
869 }
870
871 return content;
872 }
873
874 /// <summary>
875 /// Determines whether the present value matches the value on
876 /// the initialSetValue (which can be a single value or a set)
877 /// </summary>
878 /// <param name="value">Value from the datasource</param>
879 /// <param name="initialSetValue">Value from the initial selection set</param>
880 /// <param name="propertyOnInitialSet">Optional. Property to obtain the value from</param>
881 /// <param name="isMultiple"><c>true</c> if the initial selection is a set</param>
882 /// <returns><c>true</c> if it's selected</returns>
883 protected internal static bool IsPresent(object value, object initialSetValue,
884 ValueGetter propertyOnInitialSet, bool isMultiple)
885 {
886 if (!isMultiple)
887 {
888 object valueToCompare = initialSetValue;
889
890 if (propertyOnInitialSet != null)
891 {
892 // propertyOnInitialSet.GetValue(initialSetValue, null);
893 valueToCompare = propertyOnInitialSet.GetValue(initialSetValue);
894 }
895
896 return AreEqual(value, valueToCompare);
897 }
898 else
899 {
900 foreach (object item in (IEnumerable) initialSetValue)
901 {
902 object valueToCompare = item;
903
904 if (propertyOnInitialSet != null)
905 {
906 // valueToCompare = propertyOnInitialSet.GetValue(item, null);
907 valueToCompare = propertyOnInitialSet.GetValue(item);
908 }
909
910 if (AreEqual(value, valueToCompare))
911 {
912 return true;
913 }
914 }
915 }
916
917 return false;
918 }
919
920 /// <summary>
921 /// Adds the checked attribute to the attributes.
922 /// </summary>
923 /// <param name="attributes">The attributes.</param>
924 protected static void AddChecked(IDictionary attributes)
925 {
926 attributes["checked"] = "checked";
927 }
928
929 /// <summary>
930 /// Removes the checked attribute from the dictionary.
931 /// </summary>
932 /// <param name="attributes">The attributes.</param>
933 protected static void RemoveChecked(IDictionary attributes)
934 {
935 attributes.Remove("checked");
936 }
937
938 /// <summary>
939 /// Uses the specified name to create a valid id for the element
940 /// </summary>
941 /// <param name="name">The name.</param>
942 /// <returns></returns>
943 protected static string CreateHtmlId(string name)
944 {
945 StringBuilder sb = new StringBuilder(name.Length);
946
947 bool canUseUnderline = false;
948
949 foreach (char c in name.ToCharArray())
950 {
951 switch (c)
952 {
953 case '.':
954 case '[':
955 case ']':
956 if (canUseUnderline)
957 {
958 sb.Append('_');
959 canUseUnderline = false;
960 }
961 break;
962 default:
963 canUseUnderline = true;
964 sb.Append(c);
965 break;
966 }
967
968 }
969
970 return sb.ToString();
971 }
972
973 /// <summary>
974 /// Abstracts the approach to access values on objects.
975 /// </summary>
976 public abstract class ValueGetter
977 {
978 /// <summary>
979 /// Gets the name.
980 /// </summary>
981 /// <value>The name.</value>
982 public abstract string Name { get; }
983
984 /// <summary>
985 /// Gets the value.
986 /// </summary>
987 /// <param name="instance">The instance.</param>
988 /// <returns></returns>
989 public abstract object GetValue(object instance);
990 }
991
992 /// <summary>
993 /// Implementation of <see cref="ValueGetter"/>
994 /// that uses reflection to access values
995 /// </summary>
996 public class ReflectionValueGetter : ValueGetter
997 {
998 private PropertyInfo propInfo;
999
1000 /// <summary>
1001 /// Initializes a new instance of the <see cref="ReflectionValueGetter"/> class.
1002 /// </summary>
1003 /// <param name="propInfo">The prop info.</param>
1004 public ReflectionValueGetter(PropertyInfo propInfo)
1005 {
1006 this.propInfo = propInfo;
1007 }
1008
1009 /// <summary>
1010 /// Gets the name.
1011 /// </summary>
1012 /// <value>The name.</value>
1013 public override string Name
1014 {
1015 get { return propInfo.Name; }
1016 }
1017
1018 /// <summary>
1019 /// Gets the value.
1020 /// </summary>
1021 /// <param name="instance">The instance.</param>
1022 /// <returns></returns>
1023 public override object GetValue(object instance)
1024 {
1025 try
1026 {
1027 return propInfo.GetValue(instance, null);
1028 }
1029 catch (TargetException)
1030 {
1031 PropertyInfo tempProp = instance.GetType().GetProperty(Name);
1032
1033 if (tempProp == null)
1034 {
1035 throw;
1036 }
1037
1038 return tempProp.GetValue(instance, null);
1039 }
1040 }
1041 }
1042
1043 /// <summary>
1044 /// Implementation of <see cref="ValueGetter"/>
1045 /// that uses reflection and recusion to access values
1046 /// </summary>
1047 public class RecursiveReflectionValueGetter : ValueGetter
1048 {
1049 private readonly string[] keyName;
1050 private readonly string name = string.Empty;
1051
1052 /// <summary>
1053 /// Initializes a new instance of the <see cref="RecursiveReflectionValueGetter"/> class.
1054 /// </summary>
1055 /// <param name="targetType">The target type to query</param>
1056 /// <param name="keyName">the property path</param>
1057 public RecursiveReflectionValueGetter(Type targetType, string keyName)
1058 {
1059 this.keyName = keyName.Split('.');
1060 name = QueryPropertyInfoRecursive(targetType, this.keyName).Name;
1061 }
1062
1063 /// <summary>
1064 /// Gets the name.
1065 /// </summary>
1066 /// <value>The name.</value>
1067 public override string Name
1068 {
1069 get { return name; }
1070 }
1071
1072 /// <summary>
1073 /// Gets the value.
1074 /// </summary>
1075 /// <param name="instance">The instance.</param>
1076 /// <returns></returns>
1077 public override object GetValue(object instance)
1078 {
1079 try
1080 {
1081 return QueryPropertyRecursive(instance, keyName);
1082 }
1083 catch (TargetException)
1084 {
1085 PropertyInfo tempProp = instance.GetType().GetProperty(Name);
1086
1087 if (tempProp == null)
1088 {
1089 throw;
1090 }
1091
1092 return tempProp.GetValue(instance, null);
1093 }
1094 }
1095 }
1096
1097 /// <summary>
1098 /// Implementation of <see cref="ValueGetter"/>
1099 /// to access DataRow's value
1100 /// </summary>
1101 public class DataRowValueGetter : ValueGetter
1102 {
1103 private readonly string columnName;
1104
1105 /// <summary>
1106 /// Initializes a new instance of the <see cref="DataRowValueGetter"/> class.
1107 /// </summary>
1108 /// <param name="columnName">Name of the column.</param>
1109 public DataRowValueGetter(string columnName)
1110 {
1111 this.columnName = columnName;
1112 }
1113
1114 /// <summary>
1115 /// Gets the name.
1116 /// </summary>
1117 /// <value>The name.</value>
1118 public override string Name
1119 {
1120 get { return columnName; }
1121 }
1122
1123 /// <summary>
1124 /// Gets the value.
1125 /// </summary>
1126 /// <param name="instance">The instance.</param>
1127 /// <returns></returns>
1128 public override object GetValue(object instance)
1129 {
1130 DataRow row = (DataRow) instance;
1131
1132 return row[columnName];
1133 }
1134 }
1135
1136 /// <summary>
1137 /// Implementation of <see cref="ValueGetter"/>
1138 /// to access DataRowView's value
1139 /// </summary>
1140 public class DataRowViewValueGetter : ValueGetter
1141 {
1142 private readonly string columnName;
1143
1144 /// <summary>
1145 /// Initializes a new instance of the <see cref="DataRowViewValueGetter"/> class.
1146 /// </summary>
1147 /// <param name="columnName">Name of the column.</param>
1148 public DataRowViewValueGetter(string columnName)
1149 {
1150 this.columnName = columnName;
1151 }
1152
1153 /// <summary>
1154 /// Gets the name.
1155 /// </summary>
1156 /// <value>The name.</value>
1157 public override string Name
1158 {
1159 get { return columnName; }
1160 }
1161
1162 /// <summary>
1163 /// Gets the value.
1164 /// </summary>
1165 /// <param name="instance">The instance.</param>
1166 /// <returns></returns>
1167 public override object GetValue(object instance)
1168 {
1169 DataRowView row = (DataRowView) instance;
1170
1171 return row[columnName];
1172 }
1173 }
1174
1175 /// <summary>
1176 /// Empty implementation of a <see cref="ValueGetter"/>
1177 /// </summary>
1178 public class NoActionGetter : ValueGetter
1179 {
1180 /// <summary>
1181 /// Gets the name.
1182 /// </summary>
1183 /// <value>The name.</value>
1184 public override string Name
1185 {
1186 get { return string.Empty; }
1187 }
1188
1189 /// <summary>
1190 /// Gets the value.
1191 /// </summary>
1192 /// <param name="instance">The instance.</param>
1193 /// <returns></returns>
1194 public override object GetValue(object instance)
1195 {
1196 return null;
1197 }
1198 }
1199
1200 /// <summary>
1201 /// Implementation of <see cref="ValueGetter"/>
1202 /// to access enum fields
1203 /// </summary>
1204 public class EnumValueGetter : ValueGetter
1205 {
1206 private readonly Type enumType;
1207
1208 /// <summary>
1209 /// Initializes a new instance of the <see cref="EnumValueGetter"/> class.
1210 /// </summary>
1211 /// <param name="enumType">Type of the enum.</param>
1212 public EnumValueGetter(Type enumType)
1213 {
1214 this.enumType = enumType;
1215 }
1216
1217 /// <summary>
1218 /// Gets the name.
1219 /// </summary>
1220 /// <value>The name.</value>
1221 public override string Name
1222 {
1223 get { return string.Empty; }
1224 }
1225
1226 /// <summary>
1227 /// Gets the value.
1228 /// </summary>
1229 /// <param name="instance">The instance.</param>
1230 /// <returns></returns>
1231 public override object GetValue(object instance)
1232 {
1233 return Convert.ToDecimal(Enum.Format(enumType, Enum.Parse(enumType, Convert.ToString(instance)), "d"));
1234 }
1235 }
1236
1237 /// <summary>
1238 /// Abstract factory for <see cref="ValueGetter"/> implementations
1239 /// </summary>
1240 public class ValueGetterAbstractFactory
1241 {
1242 /// <summary>
1243 /// Creates the specified target type.
1244 /// </summary>
1245 /// <param name="targetType">Type of the target.</param>
1246 /// <param name="keyName">Name of the key.</param>
1247 /// <returns></returns>
1248 public static ValueGetter Create(Type targetType, string keyName)
1249 {
1250 if (targetType == null)
1251 {
1252 return new NoActionGetter();
1253 }
1254 else if (targetType == typeof(DataRow))
1255 {
1256 return new DataRowValueGetter(keyName);
1257 }
1258 else if (targetType == typeof(DataRowView))
1259 {
1260 return new DataRowViewValueGetter(keyName);
1261 }
1262 else if (targetType.IsEnum)
1263 {
1264 return new EnumValueGetter(targetType);
1265 }
1266 else
1267 {
1268 PropertyInfo info = null;
1269
1270 // check for recursion
1271 if (keyName.Contains("."))
1272 {
1273 info = QueryPropertyInfoRecursive(targetType, keyName.Split('.'));
1274
1275 if (info != null)
1276 {
1277 return new RecursiveReflectionValueGetter(targetType, keyName);
1278 }
1279 }
1280 else
1281 {
1282 info = GetPropertyInfo(targetType, keyName);
1283
1284 if (info != null)
1285 {
1286 return new ReflectionValueGetter(info);
1287 }
1288 }
1289
1290 return null;
1291 }
1292 }
1293 }
1294
1295 /// <summary>
1296 /// Gets the property info for the property with the <paramref name="propertyName"/>.
1297 /// </summary>
1298 /// <param name="type">Type that has the property.</param>
1299 /// <param name="propertyName">Name of the property.</param>
1300 /// <returns></returns>
1301 protected static PropertyInfo GetPropertyInfo(Type type, string propertyName)
1302 {
1303 PropertyInfo info = null;
1304
1305 try
1306 {
1307 info = type.GetProperty(propertyName, ResolveFlagsToUse(type));
1308 }
1309 catch (AmbiguousMatchException amex)
1310 {
1311 // This is kind of an edge case, so tried it the normal way first,
1312 // seems to happen if you override a generic property
1313
1314 if (logger.IsDebugEnabled)
1315 {
1316 logger.DebugFormat(amex, "Retrieving property {0} on type {1} raised a {2}. Maybe it is generic and overriden. Will try to get the most specific property now.",
1317 propertyName, type, amex.GetType().Name);
1318 }
1319
1320 // Try again on instance only, loop through base type hierarchy
1321 Type baseType = type;
1322 while (info == null)
1323 {
1324 info = baseType.GetProperty(propertyName, propertyFlagsDeclaredOnly);
1325
1326 baseType = baseType.BaseType;
1327 if (baseType == typeof(object) || baseType == null)
1328 {
1329 break;
1330 }
1331 }
1332 }
1333
1334 return info;
1335 }
1336
1337 private static BindingFlags ResolveFlagsToUse(Type type)
1338 {
1339 if (type.Assembly.FullName.StartsWith("DynamicAssemblyProxyGen") || type.Assembly.FullName.StartsWith("DynamicProxyGenAssembly2"))
1340 {
1341 return propertyFlagsDeclaredOnly;
1342 }
1343
1344 return PropertyFlags;
1345 }
1346
1347 #endregion
1348
1349 #region FormScopeInfo
1350
1351 /// <summary>
1352 /// Groups validation enabled configuration for a target set
1353 /// </summary>
1354 protected class FormScopeInfo
1355 {
1356 private readonly string target;
1357 private readonly bool isValidationEnabled;
1358
1359 /// <summary>
1360 /// Initializes a new instance of the <see cref="FormScopeInfo"/> class.
1361 /// </summary>
1362 /// <param name="target">The target.</param>
1363 /// <param name="isValidationEnabled">if set to <c>true</c> [is validation enabled].</param>
1364 public FormScopeInfo(string target, bool isValidationEnabled)
1365 {
1366 this.target = target;
1367 this.isValidationEnabled = isValidationEnabled;
1368 }
1369
1370 /// <summary>
1371 /// Gets the root target.
1372 /// </summary>
1373 /// <value>The root target.</value>
1374 public string RootTarget
1375 {
1376 get { return target; }
1377 }
1378
1379 /// <summary>
1380 /// Gets a value indicating whether this instance is validation enabled.
1381 /// </summary>
1382 /// <value>
1383 /// <c>true</c> if this instance is validation enabled; otherwise, <c>false</c>.
1384 /// </value>
1385 public bool IsValidationEnabled
1386 {
1387 get { return isValidationEnabled; }
1388 }
1389 }
1390
1391 #endregion
1392 }
1393 }
Git import of castle svn