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.SQLField;
import org.openconcerto.sql.model.SQLFilter;
import org.openconcerto.sql.model.SQLRow;
import org.openconcerto.sql.model.SQLTable;
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;

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));
    }

    private int idSociete = SQLRow.NONEXISTANT_ID;
    private SQLRow rowSociete = null;
    private DBRoot baseSociete;

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

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

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


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

    @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 final SQLRow getRowSociete() {
        return this.rowSociete;
    }

    public final int getSocieteID() {
        return this.idSociete;
    }

    protected final void setRowSociete(int id) {
        this.idSociete = id;
        final SQLTable tableSociete = getSystemRoot().findTable("SOCIETE_COMMON");
        final SQLRow row = tableSociete.getRow(id);
        if (row == null) {
            throw new IllegalArgumentException("no row for id " + id + " in " + tableSociete);
        } else if (!row.isValid()) {
            throw new IllegalArgumentException("invalid row : " + row);
        }
        this.rowSociete = row;
    }

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

    public final DBRoot getRootSociete() {
        if (this.baseSociete == null && this.rowSociete != 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);
    }

}