public void CustomEmployeesMapSqlRecord(Employee mapObject, Microsoft.SqlServer.Server.SqlDataRecord record, int rowIndex, IEnumerable <string> errors)
        {
            record.SetValue(record.GetOrdinal("SSN"), mapObject.L2SSN);
            record.SetValue(record.GetOrdinal("Name"), mapObject.L1Name);
            string errXml = errors.Count() > 0 ? FileIOHelpers.ErrorsToXml(errors, rowIndex) : null;

            record.SetValue(record.GetOrdinal("Errors"), errXml);
        }
Пример #2
0
        public void MapSqlRecord(Microsoft.SqlServer.Server.SqlDataRecord record, int rowIndex, IEnumerable <string> errors)
        {
            record.SetString("SSN", this.L2SSN);
            record.SetString("Name", this.L1Name);
            string errs = errors.Count() > 0 ? FileIOHelpers.ErrorsToXml(errors, rowIndex) : null;

            record.SetString("Errors", errs);
        }
Пример #3
0
        /// <summary>
        /// Writes the data to a csv file.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="destinationPath">The destination path.</param>
        /// <param name="data">The data.</param>
        /// <param name="columnInfoList">The column information list.</param>
        /// <param name="writeHeaders">if set to <c>true</c> [write headers].</param>
        /// <exception cref="System.ArgumentNullException">
        /// data
        /// or
        /// columnInfoList
        /// </exception>
        public virtual void WriteData <T>(string destinationPath, IDataReader data, CsvColumnInfoList <T> columnInfoList, bool writeHeaders = true)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }
            var dataList = FileIOHelpers.GetEnumerableFromReader <T>(data);

            this.WriteData <T>(destinationPath, dataList, columnInfoList, writeHeaders);
        }
Пример #4
0
        public static void MapValues(Company mapObject, SqlDataRecord record, int rowIndex, IEnumerable <string> errors)
        {
            record.SetInt32("CompanyId", mapObject.CompanyId);
            SetDateTime(record, "StartDate", mapObject.StartDate);
            SetDateTime(record, "EndDate", mapObject.EndDate);
            record.SetString("LegalName", mapObject.LegalName);
            record.SetString("DBAName", mapObject.DBAName);
            SetDateTime(record, "ChangeDate", mapObject.ChangeDate);
            record.SetString("UserId", mapObject.UserId);

            if (errors.Count() > 0)
            {
                record.SetString("ImportErrors", FileIOHelpers.ErrorsToXml(errors, rowIndex));
            }
        }
Пример #5
0
        /// <summary>
        /// Provides a custom mapper for the sql record if needed. Typically this might be the case if the columns in the destination table do not match the import type properties.
        /// </summary>
        /// <param name="record">The record.</param>
        /// <param name="rowIndex">Index of the row.</param>
        /// <param name="errors">The errors.</param>
        public void MapSqlRecord(SqlDataRecord record, int rowIndex, IEnumerable <string> errors)
        {
            record.SetInt32("CompanyId", this.CompanyId);
            Common.SetDateTime(record, "StartDate", this.StartDate);
            Common.SetDateTime(record, "EndDate", this.EndDate);
            record.SetString("LegalName", this.LegalName);
            record.SetString("DBAName", this.DBAName);
            Common.SetDateTime(record, "ChangeDate", this.ChangeDate);
            record.SetString("UserId", this.UserId);

            if (errors.Count() > 0)
            {
                record.SetString("ImportErrors", FileIOHelpers.ErrorsToXml(errors, rowIndex));
            }
        }
Пример #6
0
        /// <summary>
        /// Gets the row value.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="row">The row.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <param name="parseErrors">The parse errors.</param>
        /// <param name="parseErrorMessage">The parse error message.</param>
        /// <param name="isNullable">if set to <c>true</c> [is nullable].</param>
        /// <returns>System.Nullable&lt;T&gt;.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// row
        /// or
        /// propertyName
        /// or
        /// parseErrors
        /// </exception>
        public virtual T?GetRowValue <T>(dynamic row, string propertyName, ref List <string> parseErrors, string parseErrorMessage = null, bool isNullable = false) where T : struct
        {
            if (row == null)
            {
                throw new ArgumentNullException("row");
            }
            if (String.IsNullOrWhiteSpace(propertyName))
            {
                throw new ArgumentNullException("propertyName");
            }
            if (parseErrors == null)
            {
                throw new ArgumentNullException("parseErrors");
            }

            string input      = null;
            bool   valueFound = false;

            if (FileIOHelpers.IsDynamicType(row))
            {
                IDictionary <string, object> dict = row as IDictionary <string, object>;
                if (dict.ContainsKey(propertyName))
                {
                    input      = Convert.ToString(row[propertyName]);
                    valueFound = true;
                }
            }
            else
            {
                //the object is not a dynamic object, so get the value using reflection
                var prop = row.GetType().GetProperty(propertyName);
                if (prop != null)
                {
                    input      = Convert.ToString(prop.GetValue(row, null));
                    valueFound = true;
                }
            }

            if (valueFound)
            {
                return(GetRowValue <T>(input, ref parseErrors, parseErrorMessage, isNullable, propertyName));
            }
            else
            {
                return(default(T?));
            }
        }
Пример #7
0
        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>A <see cref="T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.</returns>
        public IEnumerator <SqlDataRecord> GetEnumerator()
        {
            if (_data == null || !_data.Any())
            {
                yield break;
            }

            PropertyInfo[] properties = _importType.GetProperties();
            StringComparer comparer   = StringComparer.InvariantCultureIgnoreCase;

            this._validator = this._validator ?? new ObjectValidator();
            bool?isDynamicType = null;

            int errorColumnOrdinal = -1;
            var sqlMetaArray       = _sqlMetadata.ToArray();

            if (_sqlMetadata.Any(x => comparer.Equals(x.Name, _errorColumn)))
            {
                SqlDataRecord tempRecord = new SqlDataRecord(sqlMetaArray);
                errorColumnOrdinal = tempRecord.GetOrdinal(_errorColumn);                 //will cause an exception if it does not exist, hence the any check
                tempRecord         = null;
            }

            foreach (dynamic row in _data)
            {
                _rowIndex++;
                SqlDataRecord record = new SqlDataRecord(sqlMetaArray);
                List <string> errors = new List <string>();

                //check the first object to see if it is a dynamic type as we dont need to run it throught the object mapper in that case
                if (!isDynamicType.HasValue)
                {
                    isDynamicType = FileIOHelpers.IsDynamicType(row);
                }

                T rowObj = default(T);

                if (isDynamicType.Value)
                {
                    try
                    {
                        rowObj = FileIOUtilities.MapObject <T>(row, _rowIndex, _validator, _fileValuesMapper, ref errors);
                    }
                    catch (Exception ex)
                    {
                        errors.Add(ex.ToString());
                    }
                }
                else
                {
                    rowObj = row;
                }

                try
                {
                    //built in data annotation validation
                    this._validator.TryValidate(rowObj, ref errors);
                    //custom validation
                    if (_customValidator != null)
                    {
                        _customValidator.Invoke(rowObj, ref errors);
                    }
                }
                catch (Exception ex)
                {
                    errors.Add(ex.ToString());
                }

                ISqlRecordMapper mapperObj = null;
                //if they provide a custom mapper use that one over the interface.
                if (this._customSqlMapper != null)
                {
                    this._customSqlMapper.Invoke(rowObj, record, _rowIndex, errors);
                }
                else if ((mapperObj = rowObj as ISqlRecordMapper) != null)
                {
                    mapperObj.MapSqlRecord(record, _rowIndex, errors);
                }
                else                 //last ditch effort, hopefully they don't rely on this
                {
                    object val;
                    //try to set the rows from the metadata, and the properties
                    foreach (SqlMetaData metaData in _sqlMetadata)
                    {
                        string name = metaData.Name;
                        val = null;
                        if (!comparer.Equals(name, _errorColumn))
                        {
                            var prop = properties.FirstOrDefault(x => comparer.Equals(x.Name, name));
                            if (prop != null && (val = prop.GetValue(rowObj, null)) != null)
                            {
                                record.SetValue(record.GetOrdinal(name), val);
                            }
                        }
                    }
                    //if an error column is defined, set the import errors
                    if (errorColumnOrdinal != -1 && errors.Count != 0)
                    {
                        string errorMessage = FileIOHelpers.ErrorsToXml(errors, _rowIndex);
                        record.SetString(errorColumnOrdinal, errorMessage);
                    }
                }
                yield return(record);
            }
        }