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;

import org.openconcerto.sql.Configuration;

import org.openconcerto.sql.model.DBSystemRoot;

import org.openconcerto.sql.model.SQLField;

import org.openconcerto.sql.model.SQLRow;

import org.openconcerto.sql.model.SQLRowListRSH;

import org.openconcerto.sql.model.SQLRowValues;

import org.openconcerto.sql.model.SQLSelect;

import org.openconcerto.sql.model.SQLTable;

import org.openconcerto.sql.model.Where;

import org.openconcerto.sql.users.User;

import org.openconcerto.sql.users.UserManager;

import org.openconcerto.sql.users.rights.UserRightsManager;

import org.openconcerto.task.config.ComptaBasePropsConfiguration;

import org.openconcerto.utils.cc.IFactory;

import java.sql.SQLException;

import java.sql.Timestamp;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Vector;

import javax.swing.JOptionPane;

import javax.swing.JTable;

import javax.swing.SwingUtilities;

import javax.swing.SwingWorker;

import javax.swing.table.AbstractTableModel;

public class TodoListModel extends AbstractTableModel {

    public static final int EXTENDED_MODE = 1;

    public static final int SIMPLE_MODE = 2;

    public int mode = SIMPLE_MODE;

    private static final int MIN_DELAY = 30;// * 1000; // en secondes

    private static final int MAX_DELAY = 6;// 120 * 1000;

    private long currentDelay = MIN_DELAY;

    private boolean stop = false;

    private final List<Integer> listIdListener = new Vector<Integer>(); // Contient des Integer, id

    // que l'on ecoute

    private JTable table = null;

    private List<ModelStateListener> stateListenerList = new Vector<ModelStateListener>(1);

    private final UserManager uMngr;

    protected List<UserTaskRight> rights;

    private boolean historyVisible = false;

    private List<TodoListElement> elements = new ArrayList<TodoListElement>();

    TodoListModel(final UserManager uMngr) {

        this.uMngr = uMngr;

        launchUpdaterThread();

        this.mode = SIMPLE_MODE;

    }

    private void launchUpdaterThread() {

        final Thread thread = new Thread(new Runnable() {

            public void run() {

                // Remplissage périodique

                while (!TodoListModel.this.stop) {

                    try {

                        Thread.sleep(TodoListModel.this.currentDelay * 1000);

                        if (!TodoListModel.this.stop) {

                            synchronousFill();

                        }

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                }

            }

        });

        // this only read data to be displayed, it can be safely interrupted at any moment

        thread.setDaemon(true);

        thread.setName("TodoListModel UpdaterThread");

        thread.start();

    }

    public void asynchronousFill() {

        final Thread thread = new Thread(new Runnable() {

            @Override

            public void run() {

                synchronousFill();

            }

        });

        thread.setName("TodoListModel asynchronousFill");

        thread.start();

    }

    /**

     *

     */

    private synchronized void synchronousFill() {

        if (this.table == null)

            return;

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                fireModelStateChanged(ModelStateListener.STATE_RELOADING);

            }

        });

        final Map<Integer, TodoListElement> newDataVector = new LinkedHashMap<Integer, TodoListElement>();

        try {

            fillFromDatabase(newDataVector);

        } catch (Exception e) {

            e.printStackTrace();

            SwingUtilities.invokeLater(new Runnable() {

                public void run() {

                    fireModelStateChanged(ModelStateListener.STATE_DEAD);

                }

            });

            return;

        }

        final Vector<Integer> rowsModified = new Vector<Integer>();

        final Vector<TodoListElement> rowsDeleted = new Vector<TodoListElement>();

        // size before removing

        final int newSize = newDataVector.size();

        final int oldSize;

        synchronized (this.elements) {

            oldSize = this.elements.size();

            for (int i = 0; i < oldSize; i++) {

                final TodoListElement elt = this.elements.get(i);

                final TodoListElement eltN = newDataVector.remove(elt.getRowValues().getID());

                if (eltN == null) {

                    rowsDeleted.add(elt);

                } else {

                    if (!eltN.equals(elt)) {

                        rowsModified.add(i);

                        elt.reloadValues(eltN.getRowValues());

                    }

                }

            }

            for (TodoListElement elt : rowsDeleted) {

                int index = this.elements.indexOf(elt);

                if (index >= 0) {

                    elements.remove(index);

                }

            }

            for (Integer i : newDataVector.keySet()) {

                this.elements.add(newDataVector.get(i));

            }

        }

        SwingUtilities.invokeLater(new Runnable() {

            public void run() {

                if ((rowsModified.size() == newSize) && !rowsModified.isEmpty()) {

                    fireTableDataChanged();

                    fireModelStateChanged(ModelStateListener.CONTENT_MODIFIED);

                } else if (newSize != oldSize) {

                    fireTableDataChanged();

                    fireModelStateChanged(ModelStateListener.CONTENT_MODIFIED);

                } else {

                    for (int i = 0; i < rowsModified.size(); i++) {

                        Integer indexModified = rowsModified.get(i);

                        fireTableRowsUpdated(indexModified, indexModified);

                    }

                    if (!rowsModified.isEmpty()) {

                        fireModelStateChanged(ModelStateListener.CONTENT_MODIFIED);

                    }

                }

                fireModelStateChanged(ModelStateListener.STATE_OK);

            }

        });

    }

    private final Where getAuthorizedTaskTypes(final int userID, final SQLTable tableTache) {

        final SQLField typeF = tableTache.getFieldRaw("TYPE");

        if (typeF == null)

            return null;

        final Set<String> types = UserRightsManager.getInstance().getObjects(userID, "TASK", new IFactory<Set<String>>() {

            @SuppressWarnings("unchecked")

            @Override

            public Set<String> createChecked() {

                final SQLSelect sel = new SQLSelect();

                sel.addSelect(typeF);

                sel.addGroupBy(typeF);

                return new HashSet<String>(tableTache.getDBSystemRoot().getDataSource().executeCol(sel.asString()));

            }

        });

        return types == null ? Where.TRUE : new Where(typeF, types);

    }

    private static final int societeID = ((ComptaBasePropsConfiguration) Configuration.getInstance()).getSocieteID();

    private static final DBSystemRoot base = Configuration.getInstance().getSystemRoot();

    private static final SQLTable tableTache = base.getRoot("Common").getTable("TACHE_COMMON");

    private static final Where where2 = new Where(tableTache.getField("ID_SOCIETE_COMMON"), "=", tableTache.getUndefinedID()).or(new Where(tableTache.getField("ID_SOCIETE_COMMON"), "=", societeID));

    private synchronized void fillFromDatabase(final Map<Integer, TodoListElement> m) {

        long time1 = System.currentTimeMillis();

        final SQLSelect select = new SQLSelect();

        select.addSelectStar(tableTache);

        Where where = new Where(tableTache.getField("ID_USER_COMMON_TO"), this.listIdListener);

        final int userID = getCurrentUser().getId();

        where = where.or(new Where(tableTache.getField("ID_USER_COMMON_ASSIGN_BY"), "=", userID));

        where = where.or(getAuthorizedTaskTypes(userID, tableTache));

        if (!isHistoryVisible()) {

            Where w3 = new Where(tableTache.getField("FAIT"), "=", Boolean.FALSE);

            Calendar cal = Calendar.getInstance();

            cal.set(Calendar.HOUR_OF_DAY, 0);

            cal.set(Calendar.MINUTE, 0);

            Where w4 = new Where(tableTache.getField("DATE_FAIT"), "<>", (Object) null);

            w4 = w4.and(new Where(tableTache.getField("DATE_FAIT"), ">", cal.getTime()));

            w3 = w3.or(w4);

            where = where.and(w3);

        }

        select.setWhere(where.and(where2));

        select.addFieldOrder(tableTache.getField("ID_USER_COMMON_TO"));

        select.addFieldOrder(tableTache.getField("DATE_EXP"));

        this.rights = UserTaskRight.getUserTaskRight(getCurrentUser());

        // don't use the cache since by definition this table is shared by everyone, so we can't

        // rely on our modifications

        final List<SQLRow> l = SQLRowListRSH.execute(select, false, false);

        for (SQLRow row : l) {

            final TodoListElement t = new TodoListElement(getUserManager(), row.asRowValues());

            // add tasks that we created, we must do, or that we can read

            // plus for preventec, tasks with a type must visible to everybody

            boolean add = false;

            String type = row.getString("TYPE");

            if (type != null && type.trim().length() > 0) {

                add = true;

            } else if (row.getInt("ID_USER_COMMON_CREATE") == userID || row.getInt("ID_USER_COMMON_TO") == userID) {

                add = true;

            } else {

                for (int i = 0; i < TodoListModel.this.rights.size(); i++) {

                    final UserTaskRight element = TodoListModel.this.rights.get(i);

                    if (element.getIdToUser() == row.getInt("ID_USER_COMMON_TO") && element.canRead()) {

                        add = true;

                        break;

                    }

                }

            }

            if (add)

                m.put(row.getID(), t);

        }

        long time2 = System.currentTimeMillis();

        final long t = time2 - time1;

        // System.err.println("Time to fill from DB : " + t);

        long delay = 2 + t / 1000;

        if (delay > MAX_DELAY)

            delay = MAX_DELAY;

        if (delay < MIN_DELAY)

            delay = MIN_DELAY;

        this.currentDelay = delay;

    }

    public int getColumnCount() {

        if (this.mode == EXTENDED_MODE)

            return 7;

        return 5;

    }

    @Override

    public boolean isCellEditable(int rowIndex, int columnIndex) {

        synchronized (this.elements) {

            // Modifier la priorité de la tache

            if (columnIndex == 1) {

                return true;

            }

            if (this.mode == EXTENDED_MODE && columnIndex == 3) {

                // Impossible de modifier la date de creation

                return false;

            }

            if (this.elements.size() <= rowIndex) {

                System.err.println("Size error :" + this.elements.size() + " i:" + rowIndex);

                rowIndex = 0;

            }

            final TodoListElement task = this.elements.get(rowIndex);

            if (task == null)

                return false;

            final int size = this.rights.size();

            if (columnIndex == 0)

                // Validation

                for (int i = 0; i < size; i++) {

                    UserTaskRight right = this.rights.get(i);

                    if (right.getIdToUser() == task.getUserId() && right.canValidate()) {

                        return true;

                    }

                }

            else if (columnIndex == this.getColumnCount() - 1) {

                // Colonne d'assignement

                return (task.getCreatorId().equals(getCurrentUser().getId()));

            } else {

                // Modification

                for (int i = 0; i < size; i++) {

                    UserTaskRight right = this.rights.get(i);

                    // i.e. we can still modify tasks we created and assigned to another user, but

                    // we cannot change tasks assigned to us

                    if (right.getIdToUser() == task.getCreatorId() && right.canModify()) {

                        return true;

                    }

                }

            }

        }

        return false;

    }

    @Override

    public Class<?> getColumnClass(final int columnIndex) {

        switch (columnIndex) {

        case 0:

            return Boolean.class;

        case 1:

            return Integer.class;

        case 2:

            return String.class;

        case 3:

            return Timestamp.class;

        case 4:

            if (this.mode == EXTENDED_MODE) {

                return Timestamp.class;

            }

            return Integer.class;

        case 5:

            return Timestamp.class;

        case 6:

            return Integer.class;

        default:

            return String.class;

        }

    }

    public Object getValueAt(int rowIndex, int columnIndex) {

        synchronized (this.elements) {

            if (this.elements.size() <= rowIndex) {

                System.err.println("Size error :" + this.elements.size() + " i:" + rowIndex);

                rowIndex = 0;

            }

            final TodoListElement task = this.elements.get(rowIndex);

            switch (columnIndex) {

            case 0:

                return task.isDone();

            case 1:

                return task.getPriority();

            case 2:

                return task.getName();

            case 3:

                if (this.mode == EXTENDED_MODE) {

                    return task.getDate();

                }

                return task.getExpectedDate();

            case 4:

                if (this.mode == EXTENDED_MODE) {

                    return task.getDoneDate();

                }

                return task.getUserId();

            case 5:

                return task.getExpectedDate();

            case 6:

                return task.getUserId();

            default:

                return "????????";

            }

        }

    }

    public TodoListElement getTaskAtRow(int rowIndex) {

        return this.elements.get(rowIndex);

    }

    @Override

    public int getRowCount() {

        return this.elements.size();

    }

    public void removeRow(int row) {

        elements.remove(row);

        fireTableRowsDeleted(row, row);

    }

    @Override

    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {

        synchronized (this.elements) {

            if (rowIndex >= getRowCount()) {

                // Cas de la perte de l'edition de la derniere ligne supprimee

                return;

            }

            final TodoListElement task = this.elements.get(rowIndex);

            switch (columnIndex) {

            case 0:

                task.setDone((Boolean) aValue);

                break;

            case 1:

                task.setPriority((Integer) aValue);

                break;

            case 2:

                task.setName((String) aValue);

                break;

            case 3:

                if (this.mode == EXTENDED_MODE) {

                    task.setDate((Timestamp) aValue);

                }

                task.setExpectedDate((Timestamp) aValue);

                break;

            case 4:

                if (this.mode == EXTENDED_MODE) {

                    task.setDoneDate((Timestamp) aValue);

                    break;

                }

                task.setUserId((Integer) aValue);

                break;

            case 5:

                task.setExpectedDate((Timestamp) aValue);

                break;

            case 6:

                task.setUserId((Integer) aValue);

                break;

            default:

                break;

            }

            task.commitChanges();

        }

        fireTableRowsUpdated(rowIndex, rowIndex);

    }

    @Override

    public String getColumnName(int columnIndex) {

        switch (columnIndex) {

        case 0:

            return "";

        case 1:

            return "";

        case 2:

            return TM.tr("taskToDo");

        case 3:

            if (this.mode == EXTENDED_MODE) {

                return TM.tr("created");

            }

            return TM.tr("todoBefore.col");

        case 4:

            if (this.mode == EXTENDED_MODE) {

                return TM.tr("completed");

            }

            return TM.tr("assignedTo");

        case 5:

            return TM.tr("todoBefore.col");

        case 6:

            return TM.tr("assignedTo");

        default:

            return "?????";

        }

    }

    /**

     * Ajoute une nouvelle Tâche de manière asynchrone

     */

    public void addNewTask() {

        final SwingWorker<?, ?> worker = new SwingWorker<Object, Object>() {

            @Override

            public Object doInBackground() {

                final SQLRowValues rowV = new SQLRowValues(tableTache);

                final Calendar cal = Calendar.getInstance();

                rowV.put("DATE_ENTREE", new java.sql.Timestamp(cal.getTimeInMillis()));

                cal.add(Calendar.HOUR_OF_DAY, 1);

                rowV.put("DATE_EXP", new java.sql.Timestamp(cal.getTimeInMillis()));

                cal.set(Calendar.YEAR, 2000);

                cal.set(Calendar.DAY_OF_YEAR, 1);

                cal.set(Calendar.HOUR_OF_DAY, 0);

                cal.set(Calendar.MINUTE, 0);

                cal.set(Calendar.MILLISECOND, 0);

                rowV.put("DATE_FAIT", new java.sql.Timestamp(cal.getTimeInMillis()));

                final int currentUserId = getCurrentUser().getId();

                rowV.put("ID_USER_COMMON_ASSIGN_BY", currentUserId);

                rowV.put("ID_USER_COMMON_TO", currentUserId);

                try {

                    rowV.insert();

                } catch (SQLException e) {

                    fireModelStateChanged(ModelStateListener.STATE_DEAD);

                    e.printStackTrace();

                }

                return null;

            }

            @Override

            public void done() {

                // synchrone pour que le fire fonctionne bien

                synchronousFill();

                fireTableRowsInserted(getRowCount(), getRowCount());

            }

        };

        worker.execute();

    }

    synchronized void setMode(int mode) {

        this.mode = mode;

        fireTableStructureChanged();

    }

    public synchronized int getMode() {

        return this.mode;

    }

    public boolean deleteTaskAtIndex(int index) {

        synchronized (this.elements) {

            final TodoListElement t = this.elements.get(index);

            final int currentUserId = getCurrentUser().getId();

            if (t.getCreatorId() != currentUserId) {

                JOptionPane.showMessageDialog(this.table, TM.tr("deleteForbidden"));

                return false;

            }

            t.archive();

        }

        removeRow(index);

        return true;

    }

    public void addIdListener(Integer id) {

        this.listIdListener.add(id);

        asynchronousFill();

    }

    public void addIdListenerSilently(Integer id) {

        this.listIdListener.add(id);

    }

    public void removeIdListener(Integer id) {

        this.listIdListener.remove(id);

        asynchronousFill();

    }

    public boolean listenToId(Integer id) {

        return this.listIdListener.contains(id);

    }

    public void setTable(JTable t) {

        this.table = t;

    }

    public void stopUpdate() {

        this.stop = true;

    }

    public void addModelStateListener(ModelStateListener l) {

        if (!this.stateListenerList.contains(l)) {

            this.stateListenerList.add(l);

        }

    }

    public void removeModelStateListener(ModelStateListener l) {

        if (this.stateListenerList.contains(l)) {

            this.stateListenerList.remove(l);

        }

    }

    private void fireModelStateChanged(int state) {

        final int size = this.stateListenerList.size();

        for (int i = 0; i < size; i++) {

            this.stateListenerList.get(i).stateChanged(state);

        }

    }

    public final UserManager getUserManager() {

        return this.uMngr;

    }

    public final User getCurrentUser() {

        return this.getUserManager().getCurrentUser();

    }

    public synchronized boolean isHistoryVisible() {

        return this.historyVisible;

    }

    public synchronized void setHistoryVisible(boolean historyVisible) {

        this.historyVisible = historyVisible;

    }

}