WebSVN - OpenConcerto - Diff - Rev 182 and 185 - /trunk/OpenConcerto/src/org/openconcerto/sql/view/list/RowValuesTableModel.java

 import org.openconcerto.sql.model.SQLUpdate;
 import org.openconcerto.sql.model.UndefinedRowValuesCache;
 import org.openconcerto.sql.model.Where;
 import org.openconcerto.sql.utils.AlterTable;
 import org.openconcerto.utils.CompareUtils;
-import org.openconcerto.utils.ExceptionHandler;
 import org.openconcerto.utils.ListMap;
 import org.openconcerto.utils.OrderedSet;
 import java.math.BigDecimal;
 import java.sql.SQLException;
     // modification of rowValues MUST be done in AWT EDT
     // methods that perform requests, MUST use the runnableQueue
     // synchronized is used to protect list access
     private List<SQLRowValues> rowValues = new ArrayList<SQLRowValues>();
+    private final boolean debug = false;
     private OrderedSet<TableModelListener> tableModelListeners = new OrderedSet<TableModelListener>();
     protected SQLElement element;
     private int nbColumn;
     private boolean editable = true;
     private Where fillWhere;
+    private boolean gestionReferentActive = false;
     public RowValuesTableModel() {
+    }
     public RowValuesTableModel(final SQLElement e, final List<SQLTableElement> list, SQLField validField) {
     public SQLRowValues getDefaultRowValues() {
         return this.defautRow;
+    }
+    public void setGestionReferentActive(boolean gestionReferent) {
+        this.gestionReferentActive = gestionReferent;
+    }
     public synchronized void addColumn(SQLTableElement e) {
         this.nbColumn++;
         this.list.add(e);
+    }
             return false;
         SQLTableElement elt = this.list.get(columnIndex);
         boolean validate = false;
         boolean fieldValidate = false;
-        if (this.validationField != null) {
+        if (this.validationField != null && this.validationField.getTable().getName().equals(getSQLElement().getTable().getName())) {
             fieldValidate = elt.getField().getName().equalsIgnoreCase(this.validationField.getName());
             validate = this.getRowValuesAt(rowIndex).getBoolean(this.validationField.getName());
+        }
         if (validate && fieldValidate) {
             return this.list.get(columnIndex).isCellEditable(this.getRowValuesAt(rowIndex), rowIndex, columnIndex);
         } else {
             SQLRowValues val = this.rowValues.get(rowIndex);
             SQLTableElement sqlTableElem = this.list.get(columnIndex);
             Object storedObject = val.getObject(sqlTableElem.getRowField());
             result = sqlTableElem.getValueFrom(val);
+            final Object resultToCheck;
+            if (sqlTableElem.getElementClass() != null && Number.class.isAssignableFrom(sqlTableElem.getElementClass()) && result != null && SQLRowAccessor.class.isAssignableFrom(result.getClass())
+                    && storedObject != null && Number.class.isAssignableFrom(storedObject.getClass())) {
+                resultToCheck = ((SQLRowAccessor) result).getIDNumber();
+            } else {
+                resultToCheck = result;
+            }
-            if (sqlTableElem.getElementClass() != null && Number.class.isAssignableFrom(sqlTableElem.getElementClass()) && !CompareUtils.equals(result, storedObject)) {
+            if (sqlTableElem.getElementClass() != null && Number.class.isAssignableFrom(sqlTableElem.getElementClass()) && !CompareUtils.equals(resultToCheck, storedObject)) {
                 fireTableDataChanged();
+            }
+        }
     public void putValue(Object value, int rowIndex, String fieldName) {
         putValue(value, rowIndex, fieldName, false);
+    }
     public void putValue(Object value, int rowIndex, String fieldName, boolean forcedFire) {
+        if (debug) {
+            System.err.println("putValue(row:" + rowIndex + "]) :" + value + "(" + value.getClass() + "   fieldName : " + fieldName + ")");
+            Thread.dumpStack();
+        }
         checkEDT();
         final SQLRowValues rowVal = this.rowValues.get(rowIndex);
         Object oldValue = rowVal.getObject(fieldName);
         if (!forcedFire) {
             if (oldValue == value) {
             return;
+        }
         if (oldValue != null && oldValue.equals(aValue)) {
             return;
+        }
         try {
             SQLTableElement sqlTableElem = this.list.get(columnIndex);
             SQLRowValues rowVal = this.rowValues.get(rowIndex);
             Object realVal = sqlTableElem.convertEditorValueToModel(aValue, rowVal);
             if (realVal == null || realVal.getClass() == this.getColumnClass(columnIndex)) {
                 sqlTableElem.setValueFrom(rowVal, realVal);
                 fireTableChanged(new TableModelEvent(this, rowIndex, rowIndex, columnIndex));
-            } else {
-                System.err.println("RowValuesTableModel:setValueAt:" + realVal + "(" + realVal.getClass() + ") at (row:" + rowIndex + "/col:" + columnIndex + ") column class : "
-                        + this.getColumnClass(columnIndex));
-                Thread.dumpStack();
+            }
         } catch (Exception e) {
             // can append when stop editing occur while removing a line
             e.printStackTrace();
+        }
         return sqlTableElem.getColumnName();
+    }
     /**
      * Valider les modifications dans la base
+     *
+     * @throws SQLException
      */
-    public void commitData() {
+    public void commitData() throws SQLException {
         commitData(false);
+    }
     /**
      * Valider les modifications dans la base
      */
-    public void commitData(boolean useMultipleInsertUpdate) {
+    public void commitData(boolean useMultipleInsertUpdate) throws SQLException {
         checkEDT();
         final List<SQLRowValues> rowsToCommmit = new ArrayList<SQLRowValues>();
         rowsToCommmit.addAll(this.rowValues);
-        try {
-            final SQLTable table = getDefaultRowValues().getTable();
+        final SQLTable table = getDefaultRowValues().getTable();
-            // Remove constraint on ORDRE for private
+        // Remove constraint on ORDRE for private
-            final Constraint constraint = table.getConstraint(ConstraintType.UNIQUE, Arrays.asList(table.getOrderField().getName()));
+        final Constraint constraint = table.getConstraint(ConstraintType.UNIQUE, Arrays.asList(table.getOrderField().getName()));
-            if (constraint != null) {
+        if (constraint != null) {
-                final String req = new AlterTable(table).dropConstraint(constraint.getName()).asString();
+            final String req = new AlterTable(table).dropConstraint(constraint.getName()).asString();
+            }
-                if (!updates.isEmpty()) {
+            if (!updates.isEmpty()) {
-                    SQLUpdate.executeMultipleWithBatch(table.getDBSystemRoot(), updates);
+                SQLUpdate.executeMultipleWithBatch(table.getDBSystemRoot(), updates);
+            }
+            if (this.gestionReferentActive) {
+                // Traitement des référents
+                List<SQLInsert> insertsRefs = new ArrayList<>();
+                List<SQLUpdate> updatesRefs = new ArrayList<>();
+                for (SQLRowValues rowVals : rowsToCommmit) {
+                    final Collection<SQLRowValues> referentRows = rowVals.getReferentRows();
+                    System.err.println(referentRows.size() + " ref Rows pour RowValues " + rowVals);
+                    for (SQLRowValues refRow : referentRows) {
+                        System.err.println("\t" + refRow);
+                        if (refRow.hasID()) {
+                            SQLUpdate update = new SQLUpdate(new Where(refRow.getTable().getKey(), "=", refRow.getID()));
+                            update.importValuesFrom(refRow);
+                            updatesRefs.add(update);
+                        } else {
+                            SQLInsert insert = new SQLInsert();
+                            insert.importValuesFrom(refRow);
+                            System.err.println("\t\t" + insert.asString());
+                            insertsRefs.add(insert);
+                        }
+                    }
+                }
+                if (!insertsRefs.isEmpty()) {
+                    SQLInsert.executeMultiple(table.getDBSystemRoot(), insertsRefs);
+                }
+                if (!updatesRefs.isEmpty()) {
+                    SQLUpdate.executeMultipleWithBatch(table.getDBSystemRoot(), updatesRefs);
+                }
+            }
-                table.fireTableModified(-1);
+            table.fireTableModified(-1);
-            } else {
+        } else {
-                for (int i = 0; i < size; i++) {
+            for (int i = 0; i < size; i++) {
-                    final SQLRowValues r = rowsToCommmit.get(i);
+                final SQLRowValues r = rowsToCommmit.get(i);
-                    r.put(r.getTable().getOrderField().getFieldName(), o.add(new BigDecimal(i + 1)));
+                r.put(r.getTable().getOrderField().getFieldName(), o.add(new BigDecimal(i + 1)));
-                    final StoreResult store = r.getGraph().store(StoreMode.COMMIT, false);
+                final StoreResult store = r.getGraph().store(StoreMode.COMMIT, false);
-                    final SQLRow row = store.getStoredRow(r);
+                final SQLRow row = store.getStoredRow(r);
-                    r.setID(row.getIDNumber());
+                r.setID(row.getIDNumber());
+            }
-            }
-        } catch (SQLException e) {
-            ExceptionHandler.handle("Unable to commit rows", e);
+        }
+    }
     public void addTableModelListener(TableModelListener l) {
     public final List<SQLTableElement> getList() {
         return this.list;
+    }
-    public void updateField(String field, SQLRowValues rowVals, String fieldCondition) {
+    public void updateField(String field, SQLRowValues rowVals, String fieldCondition) throws SQLException {
         checkEDT();
         if (rowVals != null) {
             int stop = this.rowValues.size();
             // FIXME check à faire sur l'ensemble des rows avec la methode isValid(). Quand
                 } else {
                     rowVals2.putEmptyLink(field);
+                }
+            }
             this.rowValuesDeleted.clear();
-            try {
-                this.element.archive(toArchive);
+            this.element.archive(toArchive);
-            } catch (SQLException e) {
-                throw new IllegalStateException("Unable to archive rows : " + toArchive, e);
-            }
             if (id != SQLRow.NONEXISTANT_ID) {
                 this.commitData();
+            }
+        }
+    }
-    public void updateField(String field, SQLRowValues rowVals) {
+    public void updateField(String field, SQLRowValues rowVals) throws SQLException {
         updateField(field, rowVals, null);
+    }
-    public void updateField(String field, int id) {
+    public void updateField(String field, int id) throws SQLException {
         updateField(field, id, null);
+    }
-    public void updateField(String field, int id, String fieldCondition) {
+    public void updateField(String field, int id, String fieldCondition) throws SQLException {
         if (id > 0) {
             updateField(field, this.element.getTable().getForeignTable(field).getRow(id).createUpdateRow(), fieldCondition);
+        }
+    }
+        }
         if (rowVals != null) {
             final List<SQLRowValues> newRows = new ArrayList<SQLRowValues>();
+            final SQLTable table = RowValuesTableModel.this.element.getTable();
             if (rowVals.hasID() && !rowVals.isUndefined() && rowVals.getID() != SQLRow.NONEXISTANT_ID) {
-                SQLRow row = rowVals.getTable().getRow(rowVals.getID());
-                List<SQLRow> rowSet;
-                if (referentField == null) {
-                    rowSet = row.getReferentRows(RowValuesTableModel.this.element.getTable());
+                newRows.addAll(fetchDataFromDB(rowVals, referentField, fieldWhere, value));
-                } else {
-                    rowSet = row.getReferentRows(referentField);
-                }
-                for (SQLRow row2 : rowSet) {
-                    if (fieldWhere == null || CompareUtils.equals(row2.getObject(fieldWhere.getName()), value)) {
-                        SQLRowValues rowVals2 = new SQLRowValues(RowValuesTableModel.this.element.getTable());
-                        rowVals2.loadAbsolutelyAll(row2);
-                        newRows.add(rowVals2);
-                    }
-                }
             } else {
                 final Collection<? extends SQLRowAccessor> colRows;
                 if (referentField == null) {
-                    colRows = rowVals.getReferentRows(RowValuesTableModel.this.element.getTable());
+                    colRows = rowVals.getReferentRows(table);
                 } else {
                     colRows = rowVals.getReferentRows(referentField);
+                }
                 for (SQLRowAccessor rowValues : colRows) {
                     if (fieldWhere == null || CompareUtils.equals(rowValues.getObject(fieldWhere.getName()), value)) {
             fireTableModelModified(RowValuesTableModel.this.rowValues.size());
+        }
+    }
+    public List<SQLRowValues> fetchDataFromDB(final SQLRowAccessor rowVals, final SQLField referentField, final SQLField fieldWhere, final Object value) {
+        final List<SQLRowValues> newRows = new ArrayList<>();
+        final SQLTable table = getSQLElement().getTable();
+        SQLRow row = rowVals.getTable().getRow(rowVals.getID());
+        List<SQLRow> rowSet;
+        if (referentField == null) {
+            rowSet = row.getReferentRows(table);
+        } else {
+            rowSet = row.getReferentRows(referentField);
+        }
+        for (SQLRow row2 : rowSet) {
+            if (fieldWhere == null || CompareUtils.equals(row2.getObject(fieldWhere.getName()), value)) {
+                SQLRowValues rowVals2 = new SQLRowValues(table);
+                rowVals2.loadAbsolutelyAll(row2);
+                newRows.add(rowVals2);
+            }
+        }
+        return newRows;
+    }
     public void addRow(SQLRowValues row) {
         checkEDT();
         addRow(row, true);
+    }

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/sql/view/list/RowValuesTableModel.java @ 177 - Rev 182 → 185