WebSVN - OpenConcerto - Diff - Rev 151 and 156 - /trunk/OpenConcerto/src/org/openconcerto/erp/core/sales/pos/ui/CaisseFrame.java

 import org.openconcerto.erp.core.sales.pos.model.RegisterFiles;
 import org.openconcerto.erp.core.sales.pos.model.RegisterLog;
 import org.openconcerto.erp.core.sales.pos.model.RegisterState;
 import org.openconcerto.erp.core.sales.pos.model.RegisterState.Status;
 import org.openconcerto.erp.core.sales.pos.model.Ticket;
+import org.openconcerto.erp.utils.TM;
 import org.openconcerto.sql.PropsConfiguration;
 import org.openconcerto.sql.RemoteShell;
 import org.openconcerto.sql.element.SQLElementDirectory;
 import org.openconcerto.sql.model.SQLBase;
 import org.openconcerto.sql.model.SQLRowAccessor;
 import org.openconcerto.sql.model.SQLRowValues;
+import org.openconcerto.sql.model.SQLRowValuesListFetcher;
 import org.openconcerto.sql.sqlobject.ElementComboBox;
 import org.openconcerto.utils.ClassPathLoader;
 import org.openconcerto.utils.ExceptionHandler;
 import org.openconcerto.utils.cc.ExnTransformer;
 import java.net.MalformedURLException;
 import java.sql.SQLException;
 import java.text.ParseException;
 import java.util.EnumSet;
 import java.util.List;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.FutureTask;
 import java.util.logging.Level;
+import java.util.logging.Logger;
 import javax.swing.JFrame;
 import javax.swing.JOptionPane;
 import javax.swing.JPanel;
 import javax.swing.SwingUtilities;
 import javax.swing.ToolTipManager;
 import org.jdom2.JDOMException;
 public class CaisseFrame extends JFrame {
+    private final POSConfiguration posConf;
     private final ComptaPropsConfiguration conf;
     private final RegisterFiles files;
     private final RegisterDB registerDB;
     final CaissePanel mainPanel;
-    CaisseFrame(final ComptaPropsConfiguration conf, final RegisterFiles files, final RegisterDB registerDB) throws Exception {
+    CaisseFrame(final POSConfiguration posConf, final ComptaPropsConfiguration conf, final RegisterFiles files, final RegisterDB registerDB) throws Exception {
+        this.posConf = posConf;
         this.conf = conf;
         this.files = files;
         this.registerDB = registerDB;
         this.mainPanel = new CaissePanel(this);
         setContentPane(mainPanel);
         setFocusable(true);
+    }
+    public final POSConfiguration getPOSConf() {
+        return this.posConf;
+    }
     public final ComptaPropsConfiguration getConf() {
         return this.conf;
+    }
     public final RegisterFiles getFiles() {
             ExceptionHandler.setThrowableHandler(Gestion.createDefaultThrowableHandler());
             // SpeedUp Linux
             System.setProperty("sun.java2d.pmoffscreen", "false");
             System.setProperty(SQLBase.STRUCTURE_USE_XML, "true");
             System.setProperty(PropsConfiguration.REDIRECT_TO_FILE, "true");
+            final POSConfiguration posConf = POSConfiguration.setInstance();
-            if (POSConfiguration.getInstance().isUsingJPos()) {
+            if (posConf.isUsingJPos()) {
                 ClassPathLoader c = ClassPathLoader.getInstance();
                 try {
-                    final List<String> posDirectories = POSConfiguration.getInstance().getJPosDirectories();
+                    final List<String> posDirectories = posConf.getJPosDirectories();
                     for (String posDirectory : posDirectories) {
                         if (posDirectory != null && !posDirectory.trim().isEmpty()) {
                             c.addJarFromDirectory(new File(posDirectory.trim()));
+                        }
+                    }
                     e.printStackTrace();
+                }
                 c.load();
+            }
-            final ComptaPropsConfiguration conf = POSConfiguration.getInstance().createConnexion();
+            final ComptaPropsConfiguration conf = posConf.createConnexion();
-            final int userID = POSConfiguration.getInstance().getUserID();
-            final RegisterFiles registerFiles = new RegisterFiles(POSConfiguration.getInstance().getRootDir(), true, POSConfiguration.getInstance().getPosID());
-            final RegisterDB registerDB = new RegisterDB(conf.getDirectory(), conf.getProductInfo(), POSConfiguration.getInstance().getPosID());
+            final int userID = posConf.getUserID();
+            final int posID = posConf.getPosID();
+            final RegisterFiles registerFiles = new RegisterFiles(posConf.getRootDir(), true, posConf.getPosID());
+            final RegisterDB registerDB = new RegisterDB(conf.getDirectory(), conf.getProductInfo(), posConf.getPosID());
+            // check if register exists
+            final SQLRowValuesListFetcher fetcher = SQLRowValuesListFetcher.create(new SQLRowValues(registerDB.getRegisterTable()));
+            if (fetcher.fetchOne(posID) == null) {
+                SwingUtilities.invokeLater(() -> {
+                    JOptionPane.showMessageDialog(null, TM.tr("register.missing", posID), TM.tr("register.missing.title"), JOptionPane.ERROR_MESSAGE);
+                });
+                posConf.closeConnexion();
+                return;
+            }
             // check before changing any state
             final boolean quit = registerDB.fetchRegisterState().checkIfMoved();
             if (quit) {
-                quit();
+                quit(posConf);
                 return;
+            }
-            final RegisterState reconciledState = registerFiles.doWithLock(new ExnTransformer<RegisterFiles, RegisterState, IOException>() {
-                @Override
+            final Logger logger = POSConfiguration.getLogger();
-                public RegisterState transformChecked(RegisterFiles input) throws IOException {
+            final RegisterState reconciledState;
-                    try {
+            try {
-                        return reconcileFSandDB(conf.getDirectory(), input, registerDB, userID);
+                reconciledState = registerFiles.doWithLock(new ExnTransformer<RegisterFiles, RegisterState, Exception>() {
-                    } catch (Exception e) {
+                    @Override
+                    public RegisterState transformChecked(RegisterFiles input) throws Exception {
-                        throw new IOException("Couldn't reconcile local and remote state", e);
+                        return reconcileFSandDB(posConf, conf.getDirectory(), input, registerDB);
+                    }
+                });
+            } catch (ReconcileException re) {
+                logger.log(Level.WARNING, "States couldn’t be reconciled, local : " + re.getLocalState() + ", remote : " + re.getRemoteState(), re);
+                final String generalMsg;
+                boolean onlyOptionPane = false;
+                if (re instanceof OutsideMeddlingException) {
+                    generalMsg = TM.tr("register.notReconciled.outsideMeddling") + '\n';
+                    onlyOptionPane = true;
+                } else if (re instanceof ResumeException) {
+                    generalMsg = TM.tr("register.notReconciled.resumeFailed") + '\n';
+                } else {
+                    generalMsg = "";
+                }
+                final String message = TM.getTM().trM("register.notReconciled." + re.getTranslationKey(), "localDate", re.getLocalState().copyDate(), "remoteDate", re.getRemoteState().copyDate());
+                if (onlyOptionPane) {
+                    SwingUtilities.invokeLater(() -> {
+                        JOptionPane.showMessageDialog(null, generalMsg + message, TM.tr("register.notReconciled.title"), JOptionPane.ERROR_MESSAGE);
-            });
+                    });
+                } else {
+                    ExceptionHandler.handle(generalMsg + message, re);
+                }
+                // ATTN this calls ComptaPropsConfiguration.tearDownLogging(), so even syserr is
+                // closed.
+                posConf.closeConnexion();
+                return;
+            } catch (Exception e) {
+                throw new IOException("Couldn't reconcile local and remote state", e);
+            }
-            POSConfiguration.getLogger().log(Level.INFO, "FS and DB states reconciled : {0}", reconciledState);
+            logger.log(Level.INFO, "FS and DB states reconciled : {0}", reconciledState);
             System.setProperty("awt.useSystemAAFontSettings", "on");
             System.setProperty("swing.aatext", "true");
             System.setProperty(ElementComboBox.CAN_MODIFY, "true");
                     final RegisterLog newLog = registerFiles.open(userID, registerDB);
                     state = newLog.getRegisterState();
+                }
+            }
             if (state.getStatus() != Status.OPEN) {
-                POSConfiguration.getLogger().log(Level.FINE, "State not open ({0}), exiting", state);
+                logger.log(Level.FINE, "State not open ({0}), exiting", state);
-                POSConfiguration.getInstance().closeConnexion();
+                posConf.closeConnexion();
                 return;
+            }
-            POSConfiguration.getLogger().log(Level.INFO, "FS and DB states open, opening UI");
+            logger.log(Level.INFO, "FS and DB states open, opening UI");
             SwingUtilities.invokeLater(new Runnable() {
                 public void run() {
                     try {
                         // UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                     } catch (Exception e) {
                         e.printStackTrace();
+                    }
                     try {
-                        CaisseFrame f = new CaisseFrame(conf, registerFiles, registerDB);
+                        CaisseFrame f = new CaisseFrame(posConf, conf, registerFiles, registerDB);
                         f.setUndecorated(true);
                         f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                         f.pack();
                         if (System.getProperty("os.name").toLowerCase().startsWith("mac os x")) {
                             f.setLocation(0, 24);
                         } else {
                             f.setLocation(0, 0);
+                        }
                         Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
-                        if (POSConfiguration.getInstance().getScreenWidth() > 0 && POSConfiguration.getInstance().getScreenHeight() > 0) {
+                        if (posConf.getScreenWidth() > 0 && posConf.getScreenHeight() > 0) {
-                            f.setSize(new Dimension(POSConfiguration.getInstance().getScreenWidth() - f.getX(), POSConfiguration.getInstance().getScreenHeight() - f.getY()));
+                            f.setSize(new Dimension(posConf.getScreenWidth() - f.getX(), posConf.getScreenHeight() - f.getY()));
                         } else {
                             f.setSize(new Dimension(screenSize.getSize().width - f.getX(), screenSize.getSize().height - f.getY()));
+                        }
                         System.out.println("Affichage de l'interface");
                         f.setVisible(true);
             // Catch throwable to be able to see NoClassDefFound and other hard issues
             ExceptionHandler.handle("Erreur d'initialisation de la caisse", e);
+        }
+    }
+    public static class ReconcileException extends IllegalStateException {
+        private RegisterState localState, remoteState;
+        private final String translationKey;
+        protected ReconcileException(final String msg, final String key) {
+            this(msg, key, null);
+        }
+        protected ReconcileException(final String msg, final String key, final Throwable cause) {
+            super(Objects.requireNonNull(msg, "message"), cause);
+            this.translationKey = Objects.requireNonNull(key, "translation key");
+        }
+        public final RegisterState getLocalState() {
+            return this.localState;
+        }
+        public final RegisterState getRemoteState() {
+            return this.remoteState;
+        }
+        public final String getTranslationKey() {
+            return this.translationKey;
+        }
+        protected final ReconcileException init(final RegisterState localState, final RegisterState remoteState) {
+            this.localState = Objects.requireNonNull(localState, "local state");
+            this.remoteState = Objects.requireNonNull(remoteState, "remote state");
+            return this;
+        }
+    }
+    // the FS and/or DB states were modified outside of this software.
+    public static final class OutsideMeddlingException extends ReconcileException {
+        protected OutsideMeddlingException(final String msg, final String key) {
+            super(msg, key);
+        }
+    }
+    // the opening or closure was interrupted, the process was resumed but it failed.
+    public static final class ResumeException extends ReconcileException {
+        protected ResumeException(final String msg, final String key, final Throwable cause) {
+            super(msg, key, Objects.requireNonNull(cause, "missing cause"));
+        }
+    }
+    /*
+     * List of translations keys.
+     */
+    private static final String unknownTK = "unknown";
+    // localOpen
+    private static final String open_datesMismatch = "open.datesMismatch";
+    private static final String localOpen_remoteClosed = "localOpen_remoteClosed";
+    private static final String localOpen_remoteMissing = "localOpen_remoteMissing";
+    // remoteOpen
+    private static final String localMissing_remoteReopen = "localMissing_remoteReopen";
+    private static final String localOpenFailed_remoteOpen = "localOpenFailed_remoteOpen";
+    private static final String localClosed_remoteCloseFailed = "localClosed_remoteCloseFailed";
+    private static final String localClosed_remoteOpen_datesMismatch = "localClosed_remoteOpen.datesMismatch";
+    // both closed
+    private static final String localMissing_remoteClosed = "localMissing_remoteClosed";
+    private static final String closed_datesMismatch = "closed.datesMismatch";
+    private static final String localClosed_remoteMissing = "localClosed_remoteMissing";
-    private static RegisterState reconcileFSandDB(final SQLElementDirectory dir, final RegisterFiles files, final RegisterDB registerDB, final int userID)
+    private static RegisterState reconcileFSandDB(final POSConfiguration posConf, final SQLElementDirectory dir, final RegisterFiles files, final RegisterDB registerDB)
             throws IOException, JDOMException, ParseException, SQLException {
         // *** find local and remote states
         final RegisterLog lastLog = files.getLastLog();
         POSConfiguration.getLogger().log(Level.CONFIG, "Found last log {0}", lastLog);
         // *** import remaining obsolete receipts
         if (localState.getStatus() == Status.OBSOLETE) {
             if (remoteState.hasDate())
                 throw new IllegalStateException("There remains obsolete receipts but DB can no longer import them : " + remoteState);
-            final List<Ticket> allTickets = POSConfiguration.getInstance().allTickets();
+            final List<Ticket> allTickets = posConf.allTickets();
             POSConfiguration.getLogger().log(Level.INFO, "{0} obsolete receipt(s) will be stored in the DB", allTickets.size());
-            POSConfiguration.getInstance().commitAll(allTickets);
+            posConf.commitAll(allTickets);
             final List<File> remainingReceipts = ReceiptCode.getReceiptsToImport(files.getPosID());
             if (!remainingReceipts.isEmpty())
                 throw new IllegalStateException("Not all obsolete receipts could be imported : " + remainingReceipts);
             localState = new RegisterState(Status.CLOSED, null);
             POSConfiguration.getLogger().log(Level.FINE, "All obsolete receipts have been stored in the DB");
             throw new IllegalStateException("Unexpected remote status :" + remoteState);
         // *** reconcile if possible
         if (!localState.equals(remoteState)) {
             POSConfiguration.getLogger().log(Level.INFO, "Different FS and DB state, will try to reconcile\nFS " + localState + " with\nDB " + remoteState);
+            final int userID = posConf.getUserID();
             // OK because of the check above
             final boolean localOpen = localState.getStatus() == Status.OPEN;
             final boolean remoteOpen = remoteState.getStatus() == Status.OPEN;
             // Time line
             // Open Local
             // 7
             try {
                 if (localOpen) {
                     if (remoteOpen) {
-                        throw new IllegalStateException("Both open with but with different dates");
+                        throw new OutsideMeddlingException("Both open with but with different dates", open_datesMismatch);
                     } else {
                         // DB is at 0 or 5, local is at 2
-                        throw new IllegalStateException("local is open but the DB isn't");
+                        throw new OutsideMeddlingException("local is open but the DB isn't", remoteState.hasDate() ? localOpen_remoteClosed : localOpen_remoteMissing);
+                    }
                 } else if (remoteOpen) {
                     assert remoteState.hasDate() : "Remote state open without date : " + remoteState;
                     final SQLRowValues lastClosure = fetchedState.getLastClosureEntry();
                     final java.util.Date lastClosureDate = lastClosure == null ? null : lastClosure.getDate("DATE").getTime();
                     if (!localState.hasDate()) {
                         // at 1
                         // MAYBE allow it for new install, for now the receipts must be copied
                         // over
                         if (lastClosureDate != null)
-                            throw new IllegalStateException("DB was closed (" + lastClosureDate + ") and now open, but local log is missing");
+                            throw new OutsideMeddlingException("DB was closed and now open, but local log is missing", localMissing_remoteReopen);
                         try {
                             localState = files.open(userID, fetchedState).getRegisterState();
                         } catch (Exception e) {
-                            throw new IllegalStateException("The local opening (following the already open DB) failed", e);
+                            throw new ResumeException("The local opening (following the already open DB) failed", localOpenFailed_remoteOpen, e);
+                        }
                     } else if (remoteState.compareDateTo(lastLog.getFirstRegisterEvent().getDate()) == 0) {
                         // at 4
                         try {
-                            remoteState = registerDB.close(userID, files.getLastLog()).getRegisterState();
+                            remoteState = registerDB.close(posConf, files.getLastLog()).getRegisterState();
                         } catch (Exception e) {
-                            throw new IllegalStateException("The closure of the DB (following the already closed local) failed", e);
+                            throw new ResumeException("The closure of the DB (following the already closed local) failed", localClosed_remoteCloseFailed, e);
+                        }
                     } else if (lastClosureDate != null && localState.compareDateTo(lastClosureDate) == 0) {
                         // at 6, TODO factor with above
                         try {
                             localState = files.open(userID, fetchedState).getRegisterState();
                         } catch (Exception e) {
-                            throw new IllegalStateException("The local opening (following the already open DB) failed", e);
+                            throw new ResumeException("The local opening (following the already open DB) failed", localOpenFailed_remoteOpen, e);
+                        }
                     } else {
                         // DB is at 1, local is between 4 and 6
-                        throw new IllegalStateException("DB was opened for a different date");
+                        throw new OutsideMeddlingException("DB was opened for a different date", localClosed_remoteOpen_datesMismatch);
+                    }
                 } else {
+                    assert !localOpen && !remoteOpen;
                     if (!localState.hasDate()) {
                         assert remoteState.hasDate() : "Both closed with no dates, but not equal";
                         // DB is at 5, local is at 0
                         // MAYBE allow it for new install, for now the receipts must be copied
                         // over
-                        throw new IllegalStateException("DB was opened and closed, but local log is missing");
+                        throw new OutsideMeddlingException("DB was opened and closed, but local log is missing", localMissing_remoteClosed);
                     } else if (remoteState.hasDate()) {
                         // DB is at 5, local is at 5 but not for the same day
                         assert remoteState.compareDateTo(localState) != 0 : "Both closed with equal dates, but not equal";
-                        throw new IllegalStateException("DB was opened and closed for a different date");
+                        throw new OutsideMeddlingException("DB was opened and closed for a different date", closed_datesMismatch);
                     } else {
                         // DB is at 0, local is between 4 and 6
-                        throw new IllegalStateException("DB was never opened but local was closed");
+                        throw new OutsideMeddlingException("DB was never opened but local was closed", localClosed_remoteMissing);
+                    }
+                }
+            } catch (ReconcileException e) {
+                throw e.init(localState, remoteState);
             } catch (Exception e) {
-                throw new IllegalStateException("States couldn't be reconciled, local : " + localState + ", remote : " + remoteState, e);
+                throw new ReconcileException("Unknown exception", unknownTK, e).init(localState, remoteState);
+            }
+        }
         if (!remoteState.equals(localState))
             throw new IllegalStateException("Unexpected state");
         return remoteState;
+    }
-    static public void quit() {
+    static public void quit(final POSConfiguration posConf) {
         POSConfiguration.getLogger().log(Level.INFO, "User exit");
-        POSConfiguration.getInstance().closeConnexion();
+        posConf.closeConnexion();
         Frame[] l = Frame.getFrames();
         for (int i = 0; i < l.length; i++) {
             Frame f = l[i];
             System.err.println(f.getName() + " " + f + " Displayable: " + f.isDisplayable() + " Valid: " + f.isValid() + " Active: " + f.isActive());
+        }
+        }
+    }
     @Override
     public void dispose() {
-        quit();
+        quit(this.posConf);
         // Fermeture
         this.getControler().setLCD("   CAISSE FERMEE    ", "", 0);
         super.dispose();
+    }

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

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/erp/core/sales/pos/ui/CaisseFrame.java - Rev 151 → 156