Esempio n. 1
0
        public ValidationModel(PropertyModel propertyModel, IPropertyAttribute attribute, MethodInfo methodForValidation)
        {
            string message = attribute.GetValidationMessage();

            SetMessage(message);
            SetFunction(propertyModel, attribute, methodForValidation);
        }
 public PropertyController(IProperty propertyService
                           , ISystemJob systemJobService
                           , IPropertyAttribute propertyAttributeService)
 {
     this.propertyService          = propertyService;
     this.systemJobService         = systemJobService;
     this.propertyAttributeService = propertyAttributeService;
 }
 public PropertyAttributesViewComponent(IPropertyAttribute PropertyAttributeService
                                        , IEPCRating EPCRatingService
                                        , ITenureType TenureTypeService
                                        , IPropertyType PropertyTypeService)
 {
     this.PropertyAttributeService = PropertyAttributeService;
     this.EPCRatingService         = EPCRatingService;
     this.TenureTypeService        = TenureTypeService;
     this.PropertyTypeService      = PropertyTypeService;
 }
 public PropertyAttributeController(IPropertyAttribute PropertyAttributeService
                                    , IEPCRating EPCRatingService
                                    , ITenureType TenureTypeService
                                    , IPropertyType PropertyTypeService
                                    )
 {
     this.PropertyAttributeService = PropertyAttributeService;
     this.EPCRatingService         = EPCRatingService;
     this.TenureTypeService        = TenureTypeService;
     this.PropertyTypeService      = PropertyTypeService;
 }
Esempio n. 5
0
        private IValidationModel MakeValidationModel(PropertyModel propertyModel, IPropertyAttribute attribute)
        {
            Type       type = typeof(ValidationModel <>).MakeGenericType(propertyModel.ReferencedModelType);
            MethodInfo methodForValidation = FindSpecificMethod(propertyModel.PropertyType, attribute.GetType());

            object[] param = new[] { (object)propertyModel, (object)attribute, (object)methodForValidation };

            object instance = Activator.CreateInstance(type, param);

            return((IValidationModel)instance);
        }
Esempio n. 6
0
        private void BindValidation(PropertyModel propertyModel)
        {
            Type typeOfModelToValidate = propertyModel.ReferencedModelType;

            foreach (object attribute in propertyModel.Attributes)
            {
                IPropertyAttribute baseAttribute = attribute as BasePropertyAttribute;
                if (baseAttribute != null)
                {
                    IValidationModel validationModel = MakeValidationModel(propertyModel, baseAttribute);
                    validationCollection[typeOfModelToValidate].Add(validationModel);
                }
            }
        }
Esempio n. 7
0
        public void SetFunction(PropertyModel propertyModel, IPropertyAttribute attribute, MethodInfo validationMethod)
        {
            Func <T, bool>       predicate = null;
            MethodCallExpression validator = null;
            Type typeOfViewModel           = propertyModel.ReferencedModelType;
            Type typeOfAttribute           = attribute.GetType();

            ParameterExpression pe  = Expression.Parameter(typeOfViewModel, "instance");
            Expression          exp = Expression.Call(pe, propertyModel.Property.GetGetMethod());

            validator = GenerateMethodCallExpression(attribute, validationMethod, exp);
            predicate = Expression.Lambda <Func <T, bool> >(validator, pe).Compile();

            function = predicate;
        }
Esempio n. 8
0
        public IModelProperty GetModelProperty(PropertyInfo propertyInfo, IPropertyAttribute attribute)
        {
            if (propertyInfo == null)
            {
                throw new ArgumentNullException("propertyInfo");
            }
            //if (attribute == null) throw new ArgumentNullException("attribute");
            var  modelType = propertyInfo.PropertyType;
            Type elementType;
            bool isArray      = false;
            bool isCollection = false;
            bool isEnumerable = false;
            Action <object, object>   addToCollection = null;
            Func <IEnumerable, Array> toArray         = null;

            if (isArray = helper.IsArray(modelType, out elementType)) //Array is ICollection<> and IEnumerable
            {
                modelType = elementType;
                toArray   = helper.BuildToArray(elementType);
            }
            else if (isCollection = helper.IsGenericCollection(modelType, out elementType)) //ICollection<> is IEnumerable
            {
                addToCollection = helper.BuildAddMethod(modelType);
                modelType       = elementType;
            }
            else
            {
                isEnumerable = helper.IsEnumerable(propertyInfo.PropertyType);  //Fallback to plain IEnumerable
            }
            return(new ModelProperty
            {
                Name = propertyInfo.Name,
                PropertyAttribute = attribute,
                Set = helper.BuildSetter(propertyInfo),
                Get = helper.BuildGetter(propertyInfo),
                PropertyType = propertyInfo.PropertyType,
                IsEnumerable = isEnumerable,
                IsCollection = isCollection,
                IsArray = isArray,
                ModelType = modelType,
                AddToCollection = addToCollection,
                ToArray = toArray
            });
        }
Esempio n. 9
0
        public MethodInfo FindSpecificMethod(string type, Type attributeType)
        {
            MethodInfo specificMethod = null;

            type = type.ToLower();
            if (methodsForValidation[type].Count > 0)
            {
                foreach (MethodInfo method in methodsForValidation[type])
                {
                    IPropertyAttribute attribute = (IPropertyAttribute)method.GetCustomAttribute(attributeType);
                    if (attribute != null)
                    {
                        specificMethod = method;
                        break;
                    }
                }
            }

            return(specificMethod);
        }
Esempio n. 10
0
        private MethodCallExpression GenerateMethodCallExpression(IPropertyAttribute attribute, MethodInfo validationMethod, Expression expressionForValidation)
        {
            AttributeType        type = attribute.GetAttributeType();
            MethodCallExpression exp  = null;

            switch (type)
            {
            case AttributeType.Required:
                exp = ValidationExpressionGenerator.GenerateRequiredExpression(validationMethod, expressionForValidation);
                break;

            case AttributeType.RangeLength:
                exp = ValidationExpressionGenerator.GenerateLengthRangeExpression((LengthPropertyAttribute)attribute, validationMethod, expressionForValidation);
                break;

            default:
                throw new InvalidEnumArgumentException("There is no expression for specified enum queryType!");
            }

            return(exp);
        }
Esempio n. 11
0
 public IModelProperty GetModelProperty <TSource, TProperty>(Expression <Func <TSource, TProperty> > propertyLambda, IPropertyAttribute attribute)
 {
     return(GetModelProperty(helper.GetPropertyInfo <TSource, TProperty>(propertyLambda), attribute));
 }
Esempio n. 12
0
 public PropertyMapping(PropertyInfo property, IPropertyAttribute propertyAttribute, Action <IPropertyAttribute, IBindingContainer> getMapping)
 {
     Property          = property;
     PropertyAttribute = propertyAttribute;
     GetMapping        = getMapping;
 }
Esempio n. 13
0
 public PropertyTypeMismatchException(IModelProperty fieldProperty, IPropertyAttribute fieldAttribute, object fieldValue) :
     base(String.Format("Type mismatch for property '{0}'. Expected type for '{1}' is {2}. Model Property is of type {3}. Field value is of type {4}."
                        , fieldProperty.Name, fieldAttribute.GetType().Name, fieldAttribute.ExpectedReturnType.FullName, fieldProperty.PropertyType.FullName,
                        fieldValue == null ? "" : fieldValue.GetType().FullName))
 {
 }
Esempio n. 14
0
 public PropertyTypeMismatchException(IModelProperty fieldProperty, IPropertyAttribute fieldAttribute, object fieldValue)
     : base(String.Format("Type mismatch for property '{0}'. Expected type for '{1}' is {2}. Model Property is of type {3}. Field value is of type {4}."
     , fieldProperty.Name, fieldAttribute.GetType().Name, fieldAttribute.ExpectedReturnType.FullName, fieldProperty.PropertyType.FullName,
     fieldValue.GetType().FullName))
 {
 }