Example #1
0
        public override bool IsValid(DataRow R, out string errmess, out string errfield)
        {
            if (!base.IsValid(R, out errmess, out errfield))
            {
                return(false);
            }
            string filterkey = QueryCreator.WHERE_KEY_CLAUSE(R, DataRowVersion.Current, false);

            DataRow [] RR = R.Table.Select(filterkey);
            if (RR.Length > 1)
            {
                errmess  = "Attenzione! L'operazione selezionata è stata già assegnata alla tabella scelta";
                errfield = "opkind";
                return(false);
            }
            return(true);
        }
Example #2
0
        void CalcolaResiduo(bool LeggiDati)
        {
            if (Meta.InsertMode)
            {
                txtResiduo.Text = "";
                return;
            }
            if (LeggiDati)
            {
                Meta.GetFormData(true);
            }
            DataRow Curr = DS.estimatedetail.Rows[0];
            decimal N    = CfgFn.GetNoNullDecimal(Curr["number"]);

            if (!NInvoicedEvalued)
            {
                string filter = QueryCreator.WHERE_KEY_CLAUSE(Curr, DataRowVersion.Default, true);
                NInvoiced = CfgFn.GetNoNullDecimal(
                    Conn.DO_READ_VALUE("estimatedetailtoinvoice", filter, "invoiced"));
            }
            decimal INVOICED = NInvoiced;
            decimal residual = N - INVOICED;

            if (NInvoiced >= 0)
            {
                txtNInvoiced.Text = NInvoiced.ToString("n");
            }
            else
            {
                txtNInvoiced.Text = "";
            }

            if (residual >= 0)
            {
                txtResiduo.Text = residual.ToString("n");
            }
            else
            {
                txtResiduo.Text = "";
            }
        }
Example #3
0
    void UpdateSourceTable()
    {
        //Scollega le righe presenti in ToAdd, ove presenti in SourceTable
        DataRow[] ToAddRows = ToAdd.Select();
        foreach (DataRow ToUnlinkRow in ToAddRows)
        {
            string unlinkkeyfilter = QueryCreator.WHERE_KEY_CLAUSE(ToUnlinkRow,
                                                                   DataRowVersion.Default, false);
            DataRow[] ToUnlinkRows = SourceTable.Select(unlinkkeyfilter);
            if (ToUnlinkRows.Length == 0)
            {
                continue;
            }
            DataRow ToUnlink = ToUnlinkRows[0];
            linked.UnlinkDataRow(ToUnlink);
        }

        //Collega le righe presenti in Added, aggiungendole se non presenti
        DataRow[] AddedRows = Added.Select();
        foreach (DataRow ToLinkRow in AddedRows)
        {
            string linkkeyfilter = QueryCreator.WHERE_KEY_CLAUSE(ToLinkRow,
                                                                 DataRowVersion.Default, false);
            DataRow[] TolinkRows = SourceTable.Select(linkkeyfilter);
            DataRow   AddedRow;
            if (TolinkRows.Length == 0)
            {
                //La riga va aggiunta
                AddedRow = AddRowToTable(SourceTable, ToLinkRow);
            }
            else
            {
                AddedRow = TolinkRows[0];
            }
            linked.CheckEntityChildRowAdditions(AddedRow, null);
        }
        // Qui vanno rifatti i SetDataTable
        SetDataTable(ToAdd, GridToAdd);
        SetDataTable(Added, GridAdded);
    }
Example #4
0
    void InitTables()
    {
        myDS = new DataSet();
        myDS.EnforceConstraints = false;

        string columnlist = QueryCreator.SortedColumnNameList(SourceTable);

        Added           = Conn.CreateTableByName(tablename, columnlist);
        Added.TableName = "added";
        Added.Namespace = SourceTable.Namespace;

        myDS.Tables.Add(Added);
        DataAccess.SetTableForReading(Added, tablename);
        CopyKeyWhenBlank(SourceTable, Added);

        ToAdd           = Conn.CreateTableByName(tablename, columnlist);
        ToAdd.TableName = "toadd";
        myDS.Tables.Add(ToAdd);
        DataAccess.SetTableForReading(ToAdd, tablename);
        CopyKeyWhenBlank(SourceTable, ToAdd);

        //Riempie la Table delle righe "ToAdd" prendendole dal DB. Questa tabella
        // contiene anche righe già "added" in memoria, che vanno quindi escluse.
        //Inoltre va integrata con righe che erano "added" e sono state rimosse
        // in memoria
        DataAccess.RUN_SELECT_INTO_TABLE(Conn, ToAdd, sorting, filterSQL, null, true);

        //Riempie la Table delle righe "Added". Questa contiene anche righe che sono
        // state rimosse in memoria, e quindi vanno rimosse (e integrate a "ToAdd")
        QueryCreator.MergeDataTable(Added, SourceTable);

        //Per tutte le righe rimosse in memoria (che rispettano il filtro): le toglie da
        // Added e le mette in ToAdd.
        string tomovefilter = GetData.MergeFilters(notentitychildfilter, filter);

        DataRow[] RowsToMove = Added.Select(tomovefilter);
        foreach (DataRow ToMove in RowsToMove)
        {
            string verifyexistentfilter = QueryCreator.WHERE_KEY_CLAUSE(ToMove,
                                                                        DataRowVersion.Default, false);
            //Just for sure I remove from ToAdd those rows I'm going to add to it!
            DataRow[] ToRemoveFromToAdd = ToAdd.Select(verifyexistentfilter);
            foreach (DataRow ToRemFromToAdd in ToRemoveFromToAdd)
            {
                ToRemFromToAdd.Delete();
                ToRemFromToAdd.AcceptChanges();
            }
            //Adds the row to ToAdd
            AddRowToTable(ToAdd, ToMove);

            //Remove the row from Added
            ToMove.Delete();
            if (ToMove.RowState != DataRowState.Detached)
            {
                ToMove.AcceptChanges();
            }
        }


        //Per tutte le righe rimosse in memoria rimanenti (ossia che NON rispettano
        // il filtro) : le rimuovo da Added
        DataRow[] ToRemoveFromAdded = Added.Select(notentitychildfilter);
        foreach (DataRow ToRemFromAdded in ToRemoveFromAdded)
        {
            ToRemFromAdded.Delete();
            if (ToRemFromAdded.RowState != DataRowState.Detached)
            {
                ToRemFromAdded.AcceptChanges();
            }
        }

        //Per tutte le righe rimaste in Added: le rimuove da ToAdd
        DataRow[] ToRemoveFromToAdd2 = Added.Select();
        foreach (DataRow ToRemFromToAdd in ToRemoveFromToAdd2)
        {
            string    ToRemKeyFilter = QueryCreator.WHERE_KEY_CLAUSE(ToRemFromToAdd, DataRowVersion.Default, false);
            DataRow[] ToRemove       = ToAdd.Select(ToRemKeyFilter);
            foreach (DataRow ToRem in ToRemove)
            {
                ToRem.Delete();
                if (ToRem.RowState != DataRowState.Detached)
                {
                    ToRem.AcceptChanges();
                }
            }
        }
        MetaData M = linked.Dispatcher.Get(tablename);

        M.DescribeColumns(ToAdd, listingtype);
        M.DescribeColumns(Added, listingtype);

        HT["Added"] = Added;
        HT["ToAdd"] = ToAdd;
        SetDataTable(ToAdd, GridToAdd);
        SetDataTable(Added, GridAdded);
    }
Example #5
0
        private bool aggiornaDB(string tName)
        {
            StringBuilder SB = new StringBuilder();

            if (tName == "config")
            {
                // A differenza delle altre tabelle CONFIG viene inserita o aggiornata.
                // L'aggiornamento vinee fatto solo sui campi relativi al patrimonio
                string   assetsetup_fields = "assetload_flag, asset_flagnumbering, asset_flagrestart";
                string[] listaCampi        = new string[] { "assetload_flag", "asset_flagnumbering", "asset_flagrestart" };
                foreach (DataRow rAssetSetup in dsFile.Tables["config"].Rows)
                {
                    string filtro = QHS.CmpEq("ayear", rAssetSetup["ayear"]);
                    int    nRow   = Meta.Conn.RUN_SELECT_COUNT("config", filtro, true);
                    if (nRow > 0)
                    {
                        string queryAssetSetup = "UPDATE config SET ";
                        string u = "";
                        foreach (string fName in listaCampi)
                        {
                            u += fName + " = " + QHS.quote(rAssetSetup[fName]) + ",";
                        }
                        u = u.Substring(0, u.Length - 2);
                        queryAssetSetup += u + " WHERE " + QHS.CmpEq("ayear", rAssetSetup["ayear"]);
                        SB.Append(queryAssetSetup);
                    }
                    else
                    {
                        string fieldForInsert = "ayear," + assetsetup_fields;
                        string sqlInsert      = "INSERT INTO config (" + fieldForInsert + ") VALUES (";
                        string values         = GeneraSQL.GetSQLDataValues(rAssetSetup);
                        sqlInsert += values;
                        SB.Append(sqlInsert);
                    }
                }
            }
            else
            {
                string f_id;
                string f_code;
                string f_descr;
                ottieniCampiTabella(tName, out f_id, out f_code, out f_descr);
                if ((f_id == "") || (f_code == "") || (f_descr == ""))
                {
                    return(false);
                }

                string[] tLinked = ottieniElencoTabelleCollegate(tName);
                // Parte UPDATE delle chiavi esterne e DELETE delle righe che non devono esserci nel DB del dipartimento
                foreach (DataRow r in dsLookUp.Tables[tName].Rows)
                {
                    if ((r["!linkedcode"] == DBNull.Value) || (r["!linkedcode"].ToString() == ""))
                    {
                        continue;
                    }
                    foreach (string tabella in tLinked)
                    {
                        if ((tabella == null) || (tabella == ""))
                        {
                            continue;
                        }
                        string valore_codice_db = r[f_code].ToString();
                        string valore_codice_ds = r["!linkedcode"].ToString();
                        if (valore_codice_db != valore_codice_ds)
                        {
                            string sqlUpdate =
                                "UPDATE " + tabella + " SET " + f_id + " = " + QueryCreator.quotedstrvalue(r["!linkedid"], true)
                                + " WHERE " + f_id + " = " + QueryCreator.quotedstrvalue(r[f_id], true) + "\n\r";
                            SB.Append(sqlUpdate);
                        }
                    }
                    string sqlDelete = "DELETE FROM " + tName + " WHERE " + f_id + " = " + QueryCreator.quotedstrvalue(r[f_id], true) + "\n\r";
                    SB.Append(sqlDelete);
                    if (SB.ToString() != "")
                    {
                        SB.Append("GO\n\r");
                    }
                }

                // Parte delle INSERT delle righe assenti nel DB del dipartimento
                string fields = "";
                foreach (DataColumn c in dsPruned.Tables[tName].Columns)
                {
                    fields += c.ColumnName + ",";
                }

                fields = fields.Remove(fields.Length - 1, 1);

                foreach (DataRow rDS in dsPruned.Tables[tName].Rows)
                {
                    string filter = QueryCreator.WHERE_KEY_CLAUSE(rDS, DataRowVersion.Current, false);
                    if (dsLookUp.Tables[tName].Select(filter).Length > 0)
                    {
                        continue;
                    }
                    string sqlInsert = "INSERT INTO " + tName + "(" + fields + ") VALUES (";
                    string values    = GeneraSQL.GetSQLDataValues(rDS);
                    sqlInsert += values;

                    SB.Append(sqlInsert);
                }
            }
            if (SB.ToString() != "")
            {
                SB.Append("GO\n\r");

                string error;
                return(Download.RUN_SCRIPT(Meta.Conn, SB, out error));
            }
            return(true);
        }