예제 #1
0
        bool needUpdate(DataRow row, string[] cols)
        {
            if (row == null)
            {
                return(false);
            }



            bool flagResetOnAllNullOrDef = flags.isFlagEnabled(UpdateTypeFlags.resetIfAllCurrentRelColsAreDefaultOrNull);
            bool flagStopIfOneNullOrDef  = !flags.isFlagEnabled(UpdateTypeFlags.continueIfOneOfCurrentRelColsDefaultOrNull);


            if (ToolCell.isDefaultOrNullAll(row, cols))
            {
                if (flagResetOnAllNullOrDef)
                {
                    ToolRow.initTableNewRow(row, allChildCol);
                    return(false);
                }
                if (flagStopIfOneNullOrDef)
                {
                    return(false);
                }
            }
            if (ToolCell.hasDefaultOrNull(row, cols))
            {
                if (flagStopIfOneNullOrDef)
                {
                    return(false);
                }
            }
            return(true);
        }
예제 #2
0
        public static object[][] getGroups(DataTable table, string[] colsArr)
        {
            List <object[]> list = new List <object[]>();

            DataColumn[] colsObj = new DataColumn[colsArr.Length];
            for (int i = 0; i < colsArr.Length; ++i)
            {
                colsObj[i] = table.Columns[colsArr[i]];
            }

            foreach (DataRow row in table.Rows)
            {
                object[] curValues = ToolRow.copyRowToArr(colsObj, row);

                foreach (object[] arr in list)
                {
                    if (ToolArray.isEqual(arr, curValues))
                    {
                        curValues = null;
                        break;
                    }
                }

                if (curValues != null)
                {
                    list.Add(curValues);
                }
            }



            list.Sort(new ToolArray.Comparer());

            return(list.ToArray());
        }
예제 #3
0
        internal static void insertRowAt(DataTable table, int i, object[] arr)
        {
            i = Math.Max(i, 0);
            DataRow rowN = table.NewRow();

            ToolRow.copyArrToRow(arr, rowN);
            table.Rows.InsertAt(rowN, i);
        }
예제 #4
0
        private static bool hasRow(DataTable table, DataRow row)
        {
            DataRow rowS = null;

            if (table != null && row != null && table.PrimaryKey != null && table.PrimaryKey.Length > 0)
            {
                object[] arr = ToolRow.copyRowToArr(table.PrimaryKey, row);
                rowS = table.Rows.Find(arr);
            }
            return(rowS != null);
        }
예제 #5
0
        public static DataTable create(DataRow row)
        {
            DataTable table = null;

            if (row != null)
            {
                table = row.Table.Clone();
                ToolRow.copyRowToTable(row, table);
            }

            return(table);
        }
예제 #6
0
 public static void trimColumn(DataTable table, string col)
 {
     if ((table != null) && (table.Columns[col].DataType == typeof(string)))
     {
         for (int i = 0; i < table.Rows.Count; ++i)
         {
             if (!ToolRow.isDeleted(table.Rows[i]))
             {
                 table.Rows[i][col] = ((string)ToolCell.isNull(table.Rows[i][col], string.Empty)).Trim();
             }
         }
     }
 }
예제 #7
0
        static object[] compareData(DataRow row, DataColumn[] cols, object[] values)
        {
            bool sameData = true;

            object[] curValues = ToolRow.copyRowToArr(cols, row);
            for (int i = 0; i < curValues.Length; ++i)
            {
                if (!ToolType.isEqual(curValues[i], values[i]))
                {
                    sameData = false;
                    break;
                }
            }
            return(sameData ? null : curValues);
        }
예제 #8
0
        public static double getSumDouble(DataTable table, string col)
        {
            double res = 0;

            if (table != null)
            {
                for (int i = 0; i < table.Rows.Count; ++i)
                {
                    if (!ToolRow.isDeleted(table.Rows[i]))
                    {
                        res += (double)ToolCell.isNull(table.Rows[i][col], 0.0);
                    }
                }
            }
            return(res);
        }
예제 #9
0
        public static double getSumDouble(DataRow[] rows, string col)
        {
            double res = 0;

            if (rows != null)
            {
                for (int i = 0; i < rows.Length; ++i)
                {
                    if (!ToolRow.isDeleted(rows[i]))
                    {
                        res += (double)ToolCell.isNull(rows[i][col], 0.0);
                    }
                }
            }
            return(res);
        }
예제 #10
0
        public static double getSum(IEnumerable rows, string col)
        {
            IEnumerator enumer = rows.GetEnumerator();

            enumer.Reset();
            Double sum = 0;

            while (enumer.MoveNext())
            {
                if (!ToolRow.isDeleted((DataRow)enumer.Current))
                {
                    sum += Convert.ToDouble(((DataRow)enumer.Current)[col]);
                }
            }
            return(sum);
        }
예제 #11
0
 void tableSource_ColumnChanging(object sender, DataColumnChangeEventArgs e)
 {
     if (e.Row.RowState != DataRowState.Detached)
     {
         if (isMyCollumn(e.Column.ColumnName) && validator.check(e.Row))
         {
             if (block())
             {
                 try
                 {
                     ToolRow.initTableNewRow(e.Row, cols);
                 }
                 finally
                 {
                     unblock();
                 }
             }
         }
     }
 }
예제 #12
0
 void tableSource_RowDeleting(object sender, DataRowChangeEventArgs e)
 {
     if (e.Row.RowState != DataRowState.Detached)
     {
         if (validator.check(e.Row))
         {
             if (block())
             {
                 try
                 {
                     ToolRow.initTableNewRow(e.Row, cols);
                 }
                 finally
                 {
                     unblock();
                 }
             }
         }
     }
 }
        public void check()
        {
            if (block())
            {
                try
                {
                    DataRow fRow = null;
                    switch (direction)
                    {
                    case RowMaintainDirection.down:
                        fRow = ToolRow.getFirstRealRow(tableSource, validator);
                        break;

                    case RowMaintainDirection.up:
                        fRow = ToolRow.getLastRealRow(tableSource, validator);
                        break;
                    }

                    if (fRow == null || !maintainRow.check(fRow))
                    {
                        DataRow nRow = ToolRow.initTableNewRow(tableSource.NewRow());
                        for (int i = 0; i < cols.Length; ++i)
                        {
                            ToolCell.set(nRow, cols[i], values[i]);
                        }
                        int indx = 0;

                        switch (place)
                        {
                        case RowMaintainPlace.top:
                            indx = ToolRow.getSectionStart(tableSource, validator);
                            break;

                        case RowMaintainPlace.bottom:
                            indx = ToolRow.getSectionEnd(tableSource, validator);
                            if (indx >= 0)
                            {
                                ++indx;
                            }
                            break;
                        }
                        if (indx < 0)
                        {
                            switch (noSectionPlace)
                            {
                            case RowMaintainPlace.top:
                                indx = 0;
                                break;

                            case RowMaintainPlace.bottom:
                                indx = int.MaxValue;
                                break;
                            }
                        }
                        tableSource.Rows.InsertAt(nRow, indx);
                    }
                }

                finally
                {
                    unblock();
                }
            }
        }
예제 #14
0
 void distribute(DataRow row, string[] cols)
 {
     if (validator.check(row))
     {
         if (needUpdate(row, cols))
         {
             bool drivedUpdateMode = flags.isFlagEnabled(UpdateTypeFlags.__spe__updateIfDrived);
             if (drivedUpdateMode)
             {
                 bool hasFull = false;
                 for (int i = 0; i < allChildCol.Length; ++i)
                 {
                     if (ToolColumn.isColumnFullName(allChildCol[i]))
                     {
                         hasFull = true;
                     }
                 }
                 if (!hasFull)
                 {
                     return;
                 }
             }
             //getData
             source.getBuilder().reset();
             for (int i = 0; i < cols.Length; ++i)
             {
                 string col = ToolColumn.extractColumnName(getColMap(cols[i]));
                 string tab = ToolColumn.extractTableName(getColMap(cols[i]));
                 object val = row[cols[i]];
                 if ((tab != string.Empty) && (col != string.Empty))
                 {
                     source.getBuilder().addParameterValueTable(tab, col, val);
                 }
                 else
                 if (col != string.Empty)
                 {
                     source.getBuilder().addParameterValue(col, val);
                 }
                 else
                 if (col == string.Empty)
                 {
                     source.getBuilder().addFreeParameterValue(val);
                 }
             }
             IDictionary dicData = ToolRow.convertFirstToDictionary(source.getAll());
             //
             if (dicData != null)
             { //Has data
                 string[] tmpChildCol = (drivedUpdateMode ? ToolColumn.selectFullNameCols(updateChildCol) : updateChildCol);
                 for (int i = 0; i < tmpChildCol.Length; ++i)
                 {
                     ToolCell.set(row, tmpChildCol[i], dicData[getColMap(tmpChildCol[i])]);
                 }
             }
             else
             { //No data
                 if (!flags.isFlagEnabled(UpdateTypeFlags.disableEditCancel))
                 {
                     row.CancelEdit();
                 }
                 else
                 {
                     if (flags.isFlagEnabled(UpdateTypeFlags.setTypeDefaultToDrivedChild))
                     {
                         ToolRow.initTableNewRow(row, (drivedUpdateMode ? ToolColumn.selectFullNameCols(childCol) : childCol));
                     }
                     if (flags.isFlagEnabled(UpdateTypeFlags.setTypeDefaultToRelChild))
                     {
                         ToolRow.initTableNewRow(row, (drivedUpdateMode ? ToolColumn.selectFullNameCols(bindChildCol) : bindChildCol));
                     }
                 }
             }
         }
     }
 }