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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
 * 
 * The contents of this file are subject to the terms of the GNU General Public License Version 3
 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
 * language governing permissions and limitations under the License.
 * 
 * When distributing the software, include this License Header Notice in each file.
 */
 
 package org.openconcerto.task.config;

import org.openconcerto.sql.Configuration;
import org.openconcerto.sql.PropsConfiguration;
import org.openconcerto.sql.element.ConfSQLElement;
import org.openconcerto.sql.element.SQLElementDirectory;
import org.openconcerto.sql.model.DBRoot;
import org.openconcerto.sql.model.DBSystemRoot;
import org.openconcerto.sql.model.SQLBase;
import org.openconcerto.sql.model.SQLDataSource;
import org.openconcerto.sql.model.SQLField;
import org.openconcerto.sql.model.SQLFilter;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLTable;
import org.openconcerto.sql.model.SQLTableEvent;
import org.openconcerto.sql.model.SQLTableModifiedListener;
import org.openconcerto.sql.users.UserCommonSQLElement;
import org.openconcerto.sql.users.rights.RightSQLElement;
import org.openconcerto.sql.users.rights.UserRightSQLElement;
import org.openconcerto.task.TM;
import org.openconcerto.task.element.CompanyAccessSQLElement;
import org.openconcerto.task.element.TaskRightSQLElement;
import org.openconcerto.task.element.TaskSQLElement;
import org.openconcerto.utils.BaseDirs;
import org.openconcerto.utils.DesktopEnvironment;
import org.openconcerto.utils.LogUtils;
import org.openconcerto.utils.ProductInfo;
import org.openconcerto.utils.i18n.Grammar_fr;
import org.openconcerto.utils.i18n.NounClass;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Properties;

import net.jcip.annotations.GuardedBy;

public abstract class ComptaBasePropsConfiguration extends PropsConfiguration {

    public abstract void setUpSocieteDataBaseConnexion(int base);

    public static File getConfFile(final ProductInfo info) {
        final String confFilePath = System.getProperty("gestion.confFile");
        final File wdFile = new File("Configuration", "main.properties");
        final File confFile;
        if (confFilePath != null) {
            confFile = new File(confFilePath);
        } else if (wdFile.isFile()) {
            confFile = wdFile;
        } else {
            // we added organisation name, so migrate preferences
            final File prefsFolder = BaseDirs.create(info).getPreferencesFolder();
            if (!prefsFolder.exists()) {
                try {
                    final File oldDir = DesktopEnvironment.getDE().getPreferencesFolder(info.getName());
                    Configuration.migrateToNewDir(oldDir, prefsFolder);
                } catch (IOException ex) {
                    throw new IllegalStateException("Couldn't migrate preferences dir", ex);
                }
            }
            confFile = new File(prefsFolder, "main.properties");
        }
        return confFile;
    }

    public static InputStream getStreamStatic(final String name) {
        InputStream stream = ((PropsConfiguration) Configuration.getInstance()).getStream(name);

        // FIXME Checker ailleurs ou throws filenotfoundexception

        // if (stream == null) {
        //
        // JOptionPane.showMessageDialog(null, "Impossible de trouver le fichier " + name);
        // }
        return stream;
    }

    public static InputStream getStream(final String name, final String... dirs) throws FileNotFoundException {
        InputStream res = null;
        for (final String dir : dirs) {
            // getResourceAsStream() doesn't handle dir//file
            res = getStreamStatic(dir + (dir.endsWith("/") ? "" : "/") + name);
            if (res != null)
                return res;
        }
        throw new FileNotFoundException(name + " not found in " + Arrays.asList(dirs));
    }

    @GuardedBy("this")
    private SQLRow rowSociete = null;
    private final SQLTableModifiedListener rowSocieteListener = (evt) -> updateRowSociete(evt);
    @GuardedBy("this")
    private DBRoot baseSociete;

    {
        // * logs
        LogUtils.rmRootHandlers();
        LogUtils.setUpConsoleHandler();
        this.setLoggersLevel();
    }

    public ComptaBasePropsConfiguration(Properties props, final ProductInfo productInfo) {
        super(props);

        this.setProductInfo(productInfo);
        // don't overwrite (allow to map no roots, just to test connection)
        if (getProperty("systemRoot.rootsToMap") == null) {
            final String interAppRootName = getInterAppRootName();
            this.setProperty("systemRoot.rootsToMap", interAppRootName);
            this.setProperty("systemRoot.rootPath", interAppRootName);
        }
    }

    @Override
    public void destroy() {
        this.setRowSociete(null);
        super.destroy();
    }

    public final String getInterAppRootName() {
        String name = "ilm";
        return name + "_Common";
    }


    // use Configuration directory if it exists
    @Override
    protected FileMode getFileMode() {
        return FileMode.NORMAL_FILE;
    }

    @Override
    protected void initDS(SQLDataSource ds) {
        super.initDS(ds);
        // Old H2 versions need this to safely open page store files
        // (https://github.com/h2database/h2database/issues/1023), and new version ignore it
        // (https://github.com/h2database/h2database/pull/1208).
        ds.addConnectionProperty("MVCC", "false");
        // Don't begin transition from page store just yet.
        ds.addConnectionProperty("MV_STORE", "false");
    }

    @Override
    protected List<String> getMappings() {
        final List<String> res = new ArrayList<>(super.getMappings());
        final String pkg = "/" + TM.class.getPackage().getName().replace('.', '/');
        res.add(pkg + "/translation/SQLElementNames");
        return res;
    }

    @Override
    protected SQLElementDirectory createDirectory() {
        final SQLElementDirectory dir = super.createDirectory();

        // TACHE_COMMON points to SOCIETE but we never display it we don't need the full element
        dir.addSQLElement(new ConfSQLElement("SOCIETE_COMMON", Grammar_fr.getInstance().createPhrase(NounClass.FEMININE, "société")));
        dir.addSQLElement(new ConfSQLElement("EXERCICE_COMMON", Grammar_fr.getInstance().createPhrase(NounClass.MASCULINE, "exercice")));
        dir.addSQLElement(new ConfSQLElement("ADRESSE_COMMON", Grammar_fr.getInstance().createPhrase(NounClass.FEMININE, "adresse")));

        dir.addSQLElement(new TaskRightSQLElement());
        dir.addSQLElement(new TaskSQLElement());

        dir.addSQLElement(new UserCommonSQLElement(getRoot(), false));
        dir.addSQLElement(new CompanyAccessSQLElement());
        dir.addSQLElement(new UserRightSQLElement(getRoot()));
        dir.addSQLElement(new RightSQLElement(getRoot()));

        return dir;
    }

    @Override
    protected SQLFilter createFilter() {
        // we don't use the filter so remove everything
        return new SQLFilter(getDirectory(), getSystemRoot().getGraph().cloneForFilterKeep(Collections.<SQLField> emptySet()));
    }

    public final String getSocieteBaseName() {
        return getRowSociete().getString("DATABASE_NAME");
    }

    public synchronized final SQLRow getRowSociete() {
        return this.rowSociete;
    }

    public final int getSocieteID() {
        final SQLRow row = this.getRowSociete();
        return row == null ? SQLRow.NONEXISTANT_ID : row.getID();
    }

    private synchronized void updateRowSociete(SQLTableEvent evt) {
        if (evt.getRow().equals(this.rowSociete)) {
            this.rowSociete.fetchValues();
        }
    }

    public final SQLTable getSocieteTable() {
        return getSocieteTable(true);
    }

    protected final SQLTable getSocieteTable(final boolean mustExist) {
        return getSystemRoot().findTable("SOCIETE_COMMON", mustExist);
    }

    // undefined ID is allowed (used for the template root)
    protected final void setRowSociete(Number id) {
        final boolean clear = id == null;
        final SQLRow row;
        final SQLTable tableSociete = getSocieteTable(!clear);
        if (clear) {
            row = null;
            // might be null if mapsToRoot is empty (e.g. tests)
            if (tableSociete != null)
                tableSociete.removeTableModifiedListener(this.rowSocieteListener);
        } else {
            row = tableSociete.getRow(id.intValue());
            if (row == null) {
                throw new IllegalArgumentException("no row for id " + id + " in " + tableSociete);
            } else if (!row.isValid()) {
                throw new IllegalArgumentException("invalid row : " + row);
            }
            tableSociete.addTableModifiedListener(this.rowSocieteListener);
        }
        synchronized (this) {
            this.rowSociete = row;
        }
    }

    @Deprecated
    public final SQLBase getSQLBaseSociete() {
        return this.getRootSociete().getBase();
    }

    public final DBRoot getRootSociete() {
        return this.getRootSociete(true);
    }

    protected synchronized final DBRoot getRootSociete(final boolean create) {
        if (create && this.baseSociete == null && this.getRowSociete() != null)
            this.baseSociete = this.createSQLBaseSociete();
        return this.baseSociete;
    }

    private DBRoot createSQLBaseSociete() {
        final DBSystemRoot b = this.getSystemRoot();
        // now map the societe
        final String societeBaseName = this.getSocieteBaseName();
        b.addRootToMap(societeBaseName);
        try {
            b.reload(Collections.singleton(societeBaseName));
        } catch (SQLException e) {
            throw new IllegalStateException("could not access societe base", e);
        }
        b.prependToRootPath(societeBaseName);
        return b.getRoot(societeBaseName);
    }

}