示例#1
0
 public static void DoMemberLevelValidation(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
 {
     if (!fieldConfig.Validators.IsNullOrEmpty() && (vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
     {
         ChoValidator.ValidateFor(dict[fn], fn, fieldConfig.Validators);
     }
 }
示例#2
0
        public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
        {
            if (!((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel))
            {
                return;
            }

            if (rec is IDictionary <string, object> )
            {
                ((IDictionary <string, object>)rec).DoMemberLevelValidation(fn, fieldConfig, vm);
            }
            else
            {
                if (fieldConfig.PI != null)
                {
                    if (fieldConfig.Validators.IsNullOrEmpty())
                    {
                        ChoValidator.ValidateFor(rec, fieldConfig.PI);
                    }
                    else
                    {
                        ChoValidator.ValidateFor(ChoType.GetPropertyValue(rec, fieldConfig.PI), fn, fieldConfig.Validators);
                    }
                }
            }
        }
示例#3
0
        public static void DoObjectLevelValidatation(this object record, ChoRecordFieldConfiguration[] fieldConfigs)
        {
            bool hasConfigValidators = (from fc in fieldConfigs
                                        where !fc.Validators.IsNullOrEmpty()
                                        select fc).Any();

            if (hasConfigValidators)
            {
                Dictionary <string, ValidationAttribute[]> valDict = (from fc in fieldConfigs
                                                                      select new KeyValuePair <string, ValidationAttribute[]>(fc.Name, fc.Validators)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
                IDictionary <string, Object> dict = null;
                if (record is ExpandoObject)
                {
                    dict = record as IDictionary <string, Object>;
                }
                else
                {
                    dict = record.ToDictionary();
                }

                ChoValidator.Validate(dict, valDict);
            }
            else
            {
                if (!(record is ExpandoObject))
                {
                    ChoValidator.Validate(record);
                }
            }
        }
        public static void DoObjectLevelValidation(this object recObject, ChoRecordConfiguration configuration, IEnumerable <ChoRecordFieldConfiguration> fieldConfigurations)
        {
            if ((configuration.ObjectValidationMode & ChoObjectValidationMode.ObjectLevel) == ChoObjectValidationMode.ObjectLevel)
            {
                if (configuration.HasConfigValidators)
                {
                    IDictionary <string, Object> dict = null;
                    if (recObject is ExpandoObject)
                    {
                        dict = recObject as IDictionary <string, Object>;
                    }
                    else
                    {
                        dict = new Dictionary <string, object>();

                        foreach (var pd in configuration.PIDict.Values)
                        {
                            dict.Add(pd.Name, ChoType.GetPropertyValue(recObject, pd));
                        }
                    }

                    ChoValidator.Validate(dict, configuration.ValDict);
                }
                else
                {
                    if (!configuration.IsDynamicObject)
                    {
                        ChoValidator.Validate(recObject);
                    }
                }
            }
        }
示例#5
0
 public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm, object fieldValue)
 {
     if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
     {
         if (fieldConfig.Validators.IsNullOrEmpty())
         {
             ChoValidator.ValidateFor(fieldValue, fn, fieldConfig.Validators);
         }
     }
 }
示例#6
0
        public static void DoObjectLevelValidation(this object recObject, ChoRecordConfiguration configuration, IEnumerable <ChoRecordFieldConfiguration> fieldConfigurations)
        {
            if (recObject == null)
            {
                return;
            }

            if ((configuration.ObjectValidationMode & ChoObjectValidationMode.ObjectLevel) == ChoObjectValidationMode.ObjectLevel)
            {
                if (configuration.Validator == null)
                {
                    if (configuration.HasConfigValidators)
                    {
                        IDictionary <string, Object> dict = null;
                        if (recObject is IDictionary <string, object> )
                        {
                            dict = recObject as IDictionary <string, Object>;
                        }
                        else
                        {
                            dict = new Dictionary <string, object>();

                            foreach (var pd in configuration.PIDict.Values)
                            {
                                dict.Add(pd.Name, ChoType.GetPropertyValue(recObject, pd));
                            }
                        }

                        ChoValidator.Validate(dict, configuration.ValDict);
                    }
                    else
                    {
                        if (!configuration.IsDynamicObject)
                        {
                            ChoValidator.Validate(recObject);
                        }
                    }
                }
                else
                {
                    if (recObject != null && configuration.Validator(recObject))
                    {
                        throw new ValidationException("Failed to validate '{0}' object. {1}".FormatString(recObject.GetType().FullName, Environment.NewLine));
                    }
                }
            }
        }
示例#7
0
 public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm, object fieldValue)
 {
     if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
     {
         if (fieldConfig.Validators.IsNullOrEmpty())
         {
             if (!(rec is ExpandoObject))
             {
                 ChoValidator.ValidateFor(fieldValue, fn, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(rec.GetType(), fn)).ToArray());
             }
         }
         else
         {
             ChoValidator.ValidateFor(fieldValue, fn, fieldConfig.Validators);
         }
     }
 }
示例#8
0
 public static void DoMemberLevelValidation(this IDictionary <string, object> dict, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
 {
     if (!fieldConfig.Validators.IsNullOrEmpty() && (vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
     {
         if (fieldConfig.Validator == null)
         {
             ChoValidator.ValidateFor(dict[fn], fn, fieldConfig.Validators);
         }
         else
         {
             if (!fieldConfig.Validator(dict[fn]))
             {
                 throw new ValidationException("Failed to validate '{0}' member. {1}".FormatString(fn, Environment.NewLine));
             }
         }
     }
 }
示例#9
0
 public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
 {
     if (rec is ExpandoObject)
     {
         ((IDictionary <string, object>)rec).DoMemberLevelValidation(fn, fieldConfig, vm);
     }
     else
     {
         if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
         {
             if (fieldConfig.Validators.IsNullOrEmpty())
             {
                 ChoValidator.ValidateFor(rec, fn);
             }
             else
             {
                 ChoValidator.ValidateFor(ChoType.GetMemberValue(rec, fn), fn, fieldConfig.Validators);
             }
         }
     }
 }
示例#10
0
        public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
        {
            if (!((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel))
            {
                return;
            }

            if (rec is IDictionary <string, object> )
            {
                ((IDictionary <string, object>)rec).DoMemberLevelValidation(fn, fieldConfig, vm);
            }
            else
            {
                if (fieldConfig.Validator == null)
                {
                    if (fieldConfig.PD == null)
                    {
                        fieldConfig.PD = fieldConfig.PropertyDescriptor;
                    }
                    if (fieldConfig.PD != null)
                    {
                        if (fieldConfig.Validators.IsNullOrEmpty())
                        {
                            ChoValidator.ValidateFor(rec, fieldConfig.PD);
                        }
                        else
                        {
                            ChoValidator.ValidateFor(fieldConfig.PD.GetValue(rec), fn, fieldConfig.Validators);
                        }
                    }
                }
                else
                {
                    if (!fieldConfig.Validator(fieldConfig.PD.GetValue(rec)))
                    {
                        throw new ValidationException("Failed to validate '{0}' member. {1}".FormatString(fn, Environment.NewLine));
                    }
                }
            }
        }
示例#11
0
        public static object ChangeType <T>(object value, Type conversionType)
            where T : Attribute
        {
            if (value == null)
            {
                return(ChoActivator.CreateInstanceAndInit(conversionType));
            }

            if (conversionType.IsAssignableFrom(value.GetType()))
            {
                return(value);
            }

            object dest = null;

            if (value is IConvertible)
            {
                dest = Convert.ChangeType(value, conversionType);
            }
            else
            {
                dest = ChoActivator.CreateInstanceAndInit(conversionType);
                value.CloneTo <T>(dest);
            }

            if (dest != null && !dest.GetType().IsSimple())
            {
                ChoObjectValidationMode m = GetValidationMode(value);
                if (m == ChoObjectValidationMode.MemberLevel)
                {
                    ChoValidator.Validate(dest);
                }
                else if (m == ChoObjectValidationMode.ObjectLevel)
                {
                    ChoValidator.Validate(dest);
                }
            }
            return(dest);
        }
示例#12
0
        private void Initialize()
        {
            try
            {
                if (!Monitor.TryEnter(_padLock, 1 * 1000))
                {
                    return;
                }

                IDictionary <string, object> kvpDict = null;

                if (_func != null)
                {
                    kvpDict = _func();
                }
                else
                {
                    kvpDict = Seed();
                }

                if (kvpDict == null)
                {
                    return;
                }

                IDictionary <string, object> mkvpDict = _kvpDict;
                bool hasDiff = mkvpDict == null || kvpDict.Except(mkvpDict).Concat(mkvpDict.Except(kvpDict)).Any();
                if (!hasDiff)
                {
                    return;
                }

                _kvpDict = kvpDict;

                ChoPropertyAttribute attr = null;
                object memberValue        = null;
                string propName           = null;
                //scan through members and load them
                foreach (var prop in ChoType.GetMembers(GetType()).Where(m => m.GetCustomAttribute <ChoIgnoreMemberAttribute>() != null && !ChoType.IsReadOnlyMember(m)))
                {
                    attr = ChoType.GetMemberAttribute <ChoPropertyAttribute>(prop);
                    try
                    {
                        SetDefaultValue(prop, true);

                        propName = attr != null && !attr.Name.IsNullOrWhiteSpace() ? attr.Name : prop.Name;

                        if (kvpDict.ContainsKey(propName))
                        {
                            memberValue = AfterKVPLoaded(prop.Name, kvpDict[propName]);
                        }
                        else
                        {
                            memberValue = AfterKVPLoaded(prop.Name, null);
                        }

                        if (memberValue != null && memberValue is string)
                        {
                            string mv = memberValue as string;
                            if (attr != null)
                            {
                                switch (attr.TrimOption)
                                {
                                case ChoPropertyValueTrimOption.Trim:
                                    mv = mv.Trim();
                                    break;

                                case ChoPropertyValueTrimOption.TrimEnd:
                                    mv = mv.TrimEnd();
                                    break;

                                case ChoPropertyValueTrimOption.TrimStart:
                                    mv = mv.TrimStart();
                                    break;
                                }
                            }

                            memberValue = mv;
                        }

                        if (ChoType.GetMemberType(prop) == typeof(string))
                        {
                            if (!((string)memberValue).IsNullOrEmpty())
                            {
                                ChoType.ConvertNSetMemberValue(this, prop, memberValue);
                            }
                        }
                        else
                        {
                            if (memberValue != null)
                            {
                                ChoType.ConvertNSetMemberValue(this, prop, memberValue);
                            }
                        }
                        ChoValidator.ValidateFor(this, prop);
                    }
                    catch (Exception ex)
                    {
                        //ChoLog.Error("{0}: Error loading '{1}' property. {2}".FormatString(NName, prop.Name, ex.Message));
                        SetDefaultValue(prop, false);
                    }
                }
            }
            catch (Exception outerEx)
            {
                //ChoLog.Error("{0}: Error loading options. {1}".FormatString(NName, outerEx.Message));
            }
            finally
            {
                Monitor.Exit(_padLock);
            }
        }
示例#13
0
        private bool FillRecord(object rec, Tuple <int, string> pair)
        {
            int    lineNo;
            string line;

            lineNo = pair.Item1;
            line   = pair.Item2;

            object fieldValue = null;

            string[] fieldValues = (from x in line.Split(Configuration.Delimiter, Configuration.StringSplitOptions, Configuration.QuoteChar)
                                    select x).ToArray();
            if (Configuration.ColumnCountStrict)
            {
                if (fieldValues.Length != Configuration.RecordFieldConfigurations.Count)
                {
                    throw new ChoParserException("Incorrect number of field values found at line [{2}]. Expected [{0}] field values. Found [{1}] field values.".FormatString(Configuration.RecordFieldConfigurations.Count, fieldValues.Length, pair.Item1));
                }
            }

            Dictionary <string, string> _fieldNameValues = ToFieldNameValues(fieldValues);

            ValidateLine(pair.Item1, fieldValues);

            ChoCSVRecordFieldConfiguration fieldConfig = null;

            foreach (KeyValuePair <string, ChoCSVRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
            {
                fieldConfig = kvp.Value;

                if (Configuration.CSVFileHeaderConfiguration.HasHeaderRecord)
                {
                    if (_fieldNameValues.ContainsKey(fieldConfig.FieldName))
                    {
                        fieldValue = _fieldNameValues[fieldConfig.FieldName];
                    }
                    else if (Configuration.ColumnCountStrict)
                    {
                        throw new ChoParserException("No matching '{0}' field header found.".FormatString(fieldConfig.FieldName));
                    }
                }
                else
                {
                    if (fieldConfig.FieldPosition - 1 < fieldValues.Length)
                    {
                        fieldValue = fieldValues[fieldConfig.FieldPosition - 1];
                    }
                    else if (Configuration.ColumnCountStrict)
                    {
                        throw new ChoParserException("Missing field value for {0} [Position: {1}] field.".FormatString(fieldConfig.FieldName, fieldConfig.FieldPosition));
                    }
                }

                fieldValue = CleanFieldValue(fieldConfig, fieldValue as string);

                if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
                {
                    continue;
                }

                try
                {
                    bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue);
                    if (!ignoreFieldValue)
                    {
                        if (rec is ExpandoObject)
                        {
                            if (fieldConfig.FieldType != typeof(string))
                            {
                                fieldValue = ChoConvert.ConvertTo(fieldValue, fieldConfig.FieldType, Configuration.Culture);
                            }
                            var x = rec as IDictionary <string, Object>;
                            x.Add(kvp.Key, fieldValue);
                        }
                        else
                        {
                            if (ChoType.HasProperty(rec.GetType(), kvp.Key))
                            {
                                ChoType.ConvertNSetMemberValue(rec, kvp.Key, fieldValue);
                                fieldValue = ChoType.GetMemberValue(rec, kvp.Key);

                                if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
                                {
                                    ChoValidator.ValididateFor(rec, kvp.Key);
                                }
                            }
                            else
                            {
                                throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
                            }
                        }
                    }

                    if (!RaiseAfterRecordFieldLoad(rec, pair.Item1, kvp.Key, fieldValue))
                    {
                        return(false);
                    }
                }
                catch (ChoParserException)
                {
                    throw;
                }
                catch (ChoMissingRecordFieldException)
                {
                    if (Configuration.ThrowAndStopOnMissingField)
                    {
                        throw;
                    }
                }
                catch (Exception ex)
                {
                    ChoETLFramework.HandleException(ex);

                    if (fieldConfig.ErrorMode == ChoErrorMode.ThrowAndStop)
                    {
                        throw;
                    }
                    try
                    {
                        ChoFallbackValueAttribute fbAttr = ChoTypeDescriptor.GetPropetyAttribute <ChoFallbackValueAttribute>(rec.GetType(), kvp.Key);
                        if (fbAttr != null)
                        {
                            if (!fbAttr.Value.IsNullOrDbNull())
                            {
                                ChoType.ConvertNSetMemberValue(rec, kvp.Key, fbAttr.Value);
                            }
                        }
                        else
                        {
                            throw;
                        }
                    }
                    catch
                    {
                        if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
                        {
                            continue;
                        }
                        else if (fieldConfig.ErrorMode == ChoErrorMode.ReportAndContinue)
                        {
                            if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex))
                            {
                                throw;
                            }
                        }
                        else
                        {
                            throw;
                        }
                    }
                }
            }

            return(true);
        }
示例#14
0
        private bool LoadLine(Tuple <int, string> pair, ref object rec)
        {
            try
            {
                if (!RaiseBeforeRecordLoad(rec, ref pair))
                {
                    return(false);
                }

                if (pair == null || pair.Item2 == null)
                {
                    return(false);
                }

                if (!pair.Item2.IsNullOrWhiteSpace())
                {
                    if (!FillRecord(rec, pair))
                    {
                        return(false);
                    }

                    if (!(rec is ExpandoObject) &&
                        (Configuration.ObjectValidationMode & ChoObjectValidationMode.ObjectLevel) == ChoObjectValidationMode.ObjectLevel)
                    {
                        ChoValidator.Validate(rec);
                    }
                }

                if (!RaiseAfterRecordLoad(rec, pair))
                {
                    return(false);
                }
            }
            catch (ChoParserException)
            {
                throw;
            }
            catch (ChoMissingRecordFieldException)
            {
                throw;
            }
            catch (Exception ex)
            {
                ChoETLFramework.HandleException(ex);
                if (Configuration.ErrorMode == ChoErrorMode.IgnoreAndContinue)
                {
                    rec = null;
                }
                else if (Configuration.ErrorMode == ChoErrorMode.ReportAndContinue)
                {
                    if (!RaiseRecordLoadError(rec, pair, ex))
                    {
                        throw;
                    }
                }
                else
                {
                    throw;
                }

                return(true);
            }

            return(true);
        }