Example #1
0
        public static void Upload(this System.Data.DataTable dt, string tableName)
        {

            string query = "SELECT * from " + tableName;


            using (SqlConnection conn = new SqlConnection(SqlConnStr))
            {
                using (SqlDataAdapter oda = new SqlDataAdapter())
                {
                    using (SqlCommandBuilder bu = new SqlCommandBuilder())
                    {
                        using (SqlBulkCopy bulkcopy = new SqlBulkCopy(conn))
                        {
                            oda.SelectCommand = new SqlCommand(query, conn);
                            bulkcopy.DestinationTableName = "dbo." + tableName;
                            DataTable dtsql = new DataTable();
                            oda.Fill(dtsql);
                            List<DataRow> lst_temp = dt.AsEnumerable().ToList();
                            foreach (DataRow row in lst_temp)
                            {
                                dtsql.ImportRow(row);
                            }
                            conn.Open();

                            bulkcopy.WriteToServer(dtsql);
                            conn.Close();
                        }
                    }
                }
            }

        }
Example #2
0
        public static DataTable CalculateSum(this DataTable source)
        {
            var query = source.AsEnumerable();

            var table = query.CopyToDataTable();

            var newRow = table.NewRow();

            //Summe Heizperiode

            newRow[0] = "Summe Heizperiode";

            int cellsCount = table.Columns.Count - 1;
            for (int i = 1; i <= cellsCount; i++)
            {
                newRow[i] = CalcColumnSumme(table, i, true);
            }

            //Summe Jahr
            var newRow2 = table.NewRow();
            newRow2[0] = "Summe Jahr";

            for (int i = 1; i <= cellsCount; i++)
            {
                newRow2[i] = CalcColumnSumme(table, i, false);
            }
            table = GetTableWithMonts(table);

            table.Rows.Add(newRow);
            table.Rows.Add(newRow2);

            return table;
        }
 public static bool IsEqualTo(this DataTable source, DataTable other)
 {
     if (other == null)
     {
         return false;
     }
     return source.AsEnumerable().SequenceEqual(other.AsEnumerable(), DataRowComparer.Default);
 }
        public static IEnumerable<ListItem> GenerateItems(this DataTable Table, string ValueField, string TextField)
        {
            IEnumerable<ListItem> Result = new List<ListItem>();

            var datos = Table.AsEnumerable();
            Result = datos.Select(p => new ListItem { Value = p[ValueField].ToString(), Text = p[TextField].ToString() });

            return Result;
        }
Example #5
0
 /// <summary>
 /// Get Authors as SelectedList (for Views)
 /// </summary>
 /// <param name="Authors">List of Athors</param>
 /// <param name="currAuthor">Current Author will be selected</param>
 /// <returns></returns>
 public static List<SelectListItem> AsSelectedList(this IQueryable<Author> Authors, int currAuthor = 0)
 {
     return (from author in Authors.AsEnumerable()
             select new SelectListItem
             {
                 Value = author.Id.ToString(),
                 Text = author.FirstName + " " + author.LastName,
                 Selected = author.Id == currAuthor
             }).ToList();
 }
Example #6
0
        public static AMSChannelCollection ToAMSChannels(this IEnumerable<IChannel> channels)
        {
            channels.NullCheck("channels");

            AMSChannelCollection result = new AMSChannelCollection();

            channels.AsEnumerable().ForEach(c => result.Add(c.ToAMSChannel()));

            return result;
        }
Example #7
0
 /// <summary>
 /// Get Themes as SelectedList (for Views)
 /// </summary>
 /// <param name="Themes">List of Themes</param>
 /// <param name="currTheme">Current Theme will be selected</param>
 /// <returns></returns>
 public static List<SelectListItem> AsSelectedList(this IQueryable<Theme> Themes, int currTheme = 0)
 {
     return (from theme in Themes.AsEnumerable()
             select new SelectListItem
             {
                 Value = theme.Id.ToString(),
                 Text = theme.ThemeName,
                 Selected = theme.Id == currTheme
             }).ToList();
 }
Example #8
0
		public static HashSet<Field> FieldsIn (this LispList<PathElement> path)
		{
			var result = new HashSet<Field> ();
			if (path != null) {
				foreach (PathElement element in path.AsEnumerable ()) {
					Field f;
					if (element.TryField (out f))
						result.Add (f);
				}
			}
			return result;
		}
 /// <summary>DataTableの各RowをExpandoObjectに変換します。</summary>
 public static IEnumerable<dynamic> AsDynamic(this DataTable table)
 {
     return table.AsEnumerable().Select(x =>
     {
         IDictionary<string, object> dict = new ExpandoObject();
         foreach (DataColumn column in x.Table.Columns)
         {
             var value = x[column];
             if (value is System.DBNull) value = null;
             dict.Add(column.ColumnName, value);
         }
         return (dynamic)dict;
     });
 }
        public static IObservable<KeyValuePair<string, string>> AsObservable(this IConfiguration configuration) {
            return Observable.Create<KeyValuePair<string, string>>(observer => {
                var dictionary = configuration.AsEnumerable().ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);

                var token = ChangeToken.OnChange(() => configuration.GetReloadToken(), () => {
                    var value = (string)null;
                    foreach(var kvp in configuration.AsEnumerable()) {
                        if(dictionary.TryGetValue(kvp.Key, out value) && value.Equals(kvp.Value, StringComparison.OrdinalIgnoreCase)) {
                            continue;
                        }
                        else {
                            dictionary[kvp.Key] = kvp.Value;
                            observer.OnNext(kvp);
                        }
                    }
                });

                return () => {
                    observer.OnCompleted();
                    token.Dispose();
                };
            });
        }
        public static IDictionary<string, object> ToRouteValues(
            this IDictionary<string, MethodArgumentTestContext> dictionary,
            Func<KeyValuePair<string, MethodArgumentTestContext>, bool> filter = null)
        {
            var result = dictionary.AsEnumerable();

            if (filter != null)
            {
                result = result.Where(filter);
            }

            return result.ToDictionary(
                a => a.Key,
                a => a.Value.Value);
        }
		public static SimpleModelState ToJsonValidation(this ModelStateDictionary modelState)
		{
			var v = from m in modelState.AsEnumerable()
					from e in m.Value.Errors
					select new SimpleError { Key = m.Key, ErrorMessage = e.ErrorMessage };
			v = v.ToList();

			var pe = v.Where(x => !string.IsNullOrEmpty(x.Key)).ToList();
			var me = v.Where(x => string.IsNullOrEmpty(x.Key)).ToList();

			return new SimpleModelState
			{
				IsValid = modelState.IsValid,
				PropertyErrors = pe,
				ModelErrors = me
			};
		}
Example #13
0
        public static IQueryable<Message> Sort(this IQueryable<Message> source, MessageSort sortedBy, bool des)
        {
            if (sortedBy == MessageSort.PublishTime)
            {
                source = source.OrderBy(m => m.CreateTime);
            }
            else if (sortedBy == MessageSort.ReadTime)
            {
                source = source.OrderBy(m => m.ReadTime);
            }

            if (des)
            {
                source = source.AsEnumerable().Reverse().AsQueryable();
            }
            return source;
        }
        /// <summary>
        /// DataTableの各RowをExpandoObjectに変換します。
        /// </summary>
        /// <param name="table"></param>
        /// <returns></returns>
        public static dynamic AsDynamic(this DataTable table)
        {
            // return table.AsEnumerable()
            var dynamic = table.AsEnumerable()
                .Select(row =>
                {
                    IDictionary<string, object> expando = new ExpandoObject();
                    foreach (DataColumn column in row.Table.Columns)
                    {
                        var value = row[column];

                        if (value is DBNull) { value = null; }
                        expando.Add(column.ColumnName, value);
                    }
                    return (dynamic) expando;
                });

            return dynamic;
        }
 public static DataTable GroupBy(this DataTable inputDataTable, string[] columnNames)
 {
     var groupedDataTable = new DataTable();
     var distinctColumnNames = columnNames.Distinct().ToArray();
     foreach (var columnName in distinctColumnNames)
     {
         groupedDataTable.Columns.Add(columnName, inputDataTable.Columns[columnName].DataType);
     }
     foreach (
         var grouping in
             inputDataTable.AsEnumerable()
                 .GroupBy(r => new NTuple<object>(distinctColumnNames.Select(cn => r[cn]))))
     {
         var row = groupedDataTable.NewRow();
         for (int i = 0; i < distinctColumnNames.Length; i++)
         {
             row[i] = grouping.Key.Values[i];
         }
         groupedDataTable.Rows.Add(row);
     }
     return groupedDataTable;
 }
        public static string[] GetErrors(this ModelStateDictionary modelState, string prefix)
        {
            if (!modelState.IsValid)
            {
                List<string> errors = new List<string>();

                IEnumerable<KeyValuePair<string, ModelState>> states =
                    prefix.IsNullOrEmpty() ? modelState.AsEnumerable()
                    : modelState.Where(x => x.Key.StartsWith(prefix + "."));

                foreach (var modelStateKvp in states)
                {
                    foreach (var modelError in modelStateKvp.Value.Errors)
                    {
                        errors.Add(modelError.ErrorMessage);
                    }
                }

                return errors.ToArray();
            }

            return null;
        }
 public static List<SuiteUserModel> ToModel(this ICollection<SuiteUser> input)
 {
     return input.AsEnumerable().Select(model => model.ToModel()).ToList();
 }
		public static IEnumerable<Task> ApplyFilters(this IEnumerable<Task> taskList, IEnumerable<TaskFilter> filters)
		{
			IEnumerable<Task> filterResults = taskList.AsEnumerable();

			return filters.Aggregate(filterResults, (current, taskFilter) => current.Where(taskFilter.Filter));
		}
Example #19
0
        public static IQueryable<Task> Sort(this IQueryable<Task> source, string sort, bool des)
        {
            if (sort == TaskList.Sort_By_ActualComplete)
            {
                source = source.OrderBy(t => t.ActualCompleteTime);
            }
            else if (sort == TaskList.Sort_By_ExpectedComplete)
            {
                source = source.OrderBy(t => t.ExpectCompleteTime);
            }
            else if (sort == TaskList.Sort_By_ActualWorkPeriod)
            {
                source = source.OrderBy(t => t.ActualWorkPeriod);
            }
            else if (sort == TaskList.Sort_By_ExpectedWorkPeriod)
            {
                source = source.OrderBy(t => t.ExpectWorkPeriod);
            }
            else if (sort == TaskList.Sort_By_Created)
            {
                source = source.OrderBy(t => t.CreateTime);
            }
            else if (sort == TaskList.Sort_By_Own)
            {
                source = source.OrderBy(t => t.OwnTime);
            }
            else if (sort == TaskList.Sort_By_Assign)
            {
                source = source.OrderBy(t => t.AssignTime);
            }
            else if (sort == TaskList.Sort_By_LatestUpdate)
            {
                source = source.OrderBy(t => t.LatestUpdateTime);
            }
            else if (sort == TaskList.Sort_By_OverDue)
            {
                source = source.OrderBy(t => t.OverDue);
            }
            else if (sort == TaskList.Sort_By_Delay)
            {
                source = source.OrderBy(t => t.Delay);
            }
            else if (sort == TaskList.Sort_By_Priority)
            {
                source = source.OrderBy(t => t.Priority);
            }
            else
            {
                throw new Exception(string.Format("the sort parameter ({0}) is not correct.", sort));
            }

            if (des)
            {
                source = source.AsEnumerable().Reverse().AsQueryable();
            }

            return source;
        }
        public static List<LogData> ReferenceCheck(this DataTable dataTable, string field, DataTable referenceTable, string referenceField)
        {
            var logs = new List<LogData>();
            if (referenceTable != null)
            {
                var ValuesNotInRefs = dataTable.AsEnumerable().Select(a => Convert.ToString(a.Field<object>(field)))
                    .Except(referenceTable.AsEnumerable().Select(a => Convert.ToString(a.Field<object>(referenceField))));

                if (ValuesNotInRefs.Count() > 0)
                {
                    var inValidRows = (from row in dataTable.AsEnumerable()
                                       join id in ValuesNotInRefs
                                             on Convert.ToString(row.Field<object>(field)) equals id
                                       select row).CopyToDataTable();

                    foreach (var row in inValidRows.Rows.Cast<DataRow>())
                    {
                        logs.Add(new LogData
                        {
                            WorkSheet = dataTable.TableName,
                            ColumnName = field,
                            RowNumber = dataTable.Rows.IndexOf(row) + 2,
                            LogMessage = Convert.ToString(row.Field<object>(field)) + " is not available in reference sheet."
                        });
                        //str.AppendFormat("{0} : {1} : Row {2} : {3}", dataTable.TableName, field, dataTable.Rows.IndexOf(row) + 2,
                        //            Convert.ToString(row.Field<object>(field)) + " is not available in reference sheet.\n");
                    }
                }
            }
            return logs;
        }
 public static IEnumerable<ClassifiedSpan> ToClassifiedSpans(this ImmutableArray<SymbolDisplayPart> parts)
 {
     return parts.AsEnumerable().ToClassifiedSpans();
 }
 public static string GetFullText(this ImmutableArray<SymbolDisplayPart> parts)
 {
     // CONSIDER: this does the same thing as parts.ToDisplayString(), but more slowly.
     return parts.AsEnumerable().GetFullText();
 }
Example #23
0
        private static string GetSecondaryUrl(this IEnumerable<ChannelEndpoint> endpoints)
        {
            string result = string.Empty;

            int index = 0;

            foreach (ChannelEndpoint endpoint in endpoints.AsEnumerable())
            {
                if (index == 1)
                {
                    if (endpoint != null && endpoint.Url != null)
                        result = endpoint.Url.ToString();

                    break;
                }

                index++;
            }

            return result;
        }
Example #24
0
 public static IEnumerable<DataRow> TableToList(this DataTable table)
 {
     return table.AsEnumerable(); //as EnumerableRowCollection<T>;
 }
 public static List<MappingModel> ToModel(this List<Mapping> input)
 {
     return input.AsEnumerable().Select(model => model.ToModel()).ToList();
 }
        public static List<LogData> GroupCheck(this DataTable dataTable, string basefield, List<string> ignoreFields)
        {
            var logs = new List<LogData>();
            ignoreFields.ForEach(a => dataTable.Columns.Remove(a));
            var blankColumns = dataTable.Columns.Cast<DataColumn>().Where(a => a.DataType == typeof(object) && a.ColumnName.StartsWith("Column")).ToList();
            blankColumns.ForEach(a => dataTable.Columns.Remove(a));
            
            var distinctRecords = dataTable.AsEnumerable().Distinct(System.Data.DataRowComparer.Default).ToList();  

            var groupedData = from row in distinctRecords.AsEnumerable()
                              group row by new { placeCol = row[basefield] } into groupby
                              select new
                              {
                                  Name = groupby.Key,
                                  CountOfClients = groupby.Count()
                              };

            foreach (var data in groupedData)
            {
                if (data.CountOfClients > 1)
                {
                    logs.Add(new LogData
                    {
                        WorkSheet = dataTable.TableName,
                        ColumnName = basefield,
                        RowNumber = 0,
                        LogMessage = "Common data is not matching for " + data.Name.placeCol + " " + basefield
                    });
                }
            }

            return logs;
        }
Example #27
0
 internal static Imports Single(this ImportChain importChain)
 {
     return importChain.AsEnumerable().Single();
 }
 public static List<EnvironmentModel> ToModel(this ICollection<Environment> input)
 {
     return input.AsEnumerable().Select(applicationModel => applicationModel.ToModel()).ToList();
 }
 public static List<ParameterModel> ToModel(this ICollection<Parameter> input)
 {
     return input.AsEnumerable().Select(parameterModel => parameterModel.ToModel()).ToList();
 }
 public static List<RegionModel> ToModel(this ICollection<Region> input)
 {
     return input.AsEnumerable().Select(RegionModel => RegionModel.ToModel()).ToList();
 }