VisualSapfor/src/Common/Database/Tables/DataSet.java

package Common.Database.Tables;
import Common.Current_;
import Common.Database.Objects.DBObject;
import Common.MainModule_;
import Common.Utils.TextLog;
import Common.Visual.DataSetControlForm;
import Common.Visual.DataSetFilter;
import Common.Visual.FilterInterface;
import Common.Visual.Menus.DataMenuBar;
import Common.Visual.Tables.ColumnFilter;
import Common.Visual.UI;
import Common.Visual.Windows.Dialog.DBObjectDialog;
import Common.Visual.Windows.Dialog.DialogFields;

import javax.swing.*;
import java.awt.*;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Vector;
import java.util.stream.Collectors;
public class DataSet<K, D extends DBObject> extends DataSetAnchestor {
    //-
    public LinkedHashMap<Class, Object> selections = new LinkedHashMap<>();
    //---
    public String Name;
    public Class<K> k; //класс первичного ключа.
    public Class<D> d; //класс объектов.
    public LinkedHashMap<K, D> Data = new LinkedHashMap<>(); //наполнение
    //-
    public DataSetControlForm ui_;
    //-
    public LinkedHashMap<Integer, ColumnFilter> columnsFilters = new LinkedHashMap<>(); //текстовые фильтры столбцов
    protected FilterInterface f_ui; // отображение количества объектов
    //--
    protected Vector<DataSetFilter<D>> filters = new Vector<>();
    //--
    public DataSet(Class<K> k_in, Class<D> d_in) {
        k = k_in;
        d = d_in;
        Name = d.getSimpleName();
    }
    protected void createFilters() {
    }
    public boolean hasMenuBar(){return true;}
    public DataMenuBar createMenuBar() {
        return new DataMenuBar(getPluralDescription());
    }
    public void mountUI(JPanel content_in) {
        UI.Clear(content_in);
        //-->
        ui_ = createUI();
        ui_.setContent(content_in);
        //-->
        if (hasMenuBar()) {
            try {
                DataMenuBar bar = null;
                if (!MainModule_.instance.getUI().menuBars.containsKey(getClass())) {
                    bar = createMenuBar();
                    if (ui_.hasCheckBox())
                        bar.createSelectionButtons(this);
                    MainModule_.instance.getUI().menuBars.put(getClass(), bar);
                } else {
                    bar = MainModule_.instance.getUI().menuBars.get(getClass());
                }
                content_in.add(bar, BorderLayout.NORTH);
                //--
                setFilterUI(count -> MainModule_.instance.getUI().menuBars.get(getClass()).countLabel.setText(String.valueOf(count)));
                //--
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
        content_in.add(ui_.getDataPanel(), BorderLayout.CENTER);
        //----
        createFilters();
        if (!filters.isEmpty()) {
            DataMenuBar menuBar = MainModule_.instance.getUI().menuBars.get(getClass());
            for (DataSetFilter<D> filter : filters)
                menuBar.addMenus(filter.menu);
        }
    }
    public DataSetControlForm getUi() {
        return ui_;
    }
    public void setFilterUI(FilterInterface ui_in) {
        f_ui = ui_in;
    }
    public void ClearUI() {
        if ((ui_ != null) && ui_.isShown()) {
            ui_.ClearSelection();
            ui_.Clear();
            if (f_ui != null)
                f_ui.ShowNoMatches();
        }
    }
    public void RefreshUI() {
        if (ui_ != null) ui_.Refresh();
    }
    public int getRowCountUI() {
        return ui_.getRowCount();
    }
    public void SetCurrentObjectUI(Object pk) {
        if (ui_ != null) {
            //todo возможно проверить, что текущий объект уже соответствует ключу, и если да, то ничего делать.
            ui_.ClearSelection(); //сброс текущего объекта и всего что с ним связано.
            ui_.Select(pk);
        }
    }
    public String[] getUIColumnNames() {
        return new String[]{};
    }
    protected DataSetControlForm createUI() {
        return null;
    }
    public boolean hasUI() {
        return ui_ != null;
    }
    public void CheckAll(boolean flag) {
        for (D object : Data.values()) {
            if (object.isVisible())
                object.Select(flag);
        }
        RefreshUI();
    }
    public D getFirstRecord() {
        return Data.values().stream().findFirst().orElse(null);
    }
    public Vector<D> getOrderedRecords(Comparator<D> comparator) {
        Vector<D> res = new Vector<>(Data.values());
        res.sort(comparator);
        return res;
    }
    @SuppressWarnings("unchecked")
    public DBObjectDialog<D, ? extends DialogFields> getDialog() {
        return null;
    }
    public boolean ShowAddObjectDialog(DBObject object) {
        return getDialog().ShowDialog(getSingleDescription() + ": добавление", object);
    }
    public boolean ShowEditObjectDialog(DBObject object) {
        DBObjectDialog dialog = getDialog();
        dialog.edit = true;
        dialog.SetEditLimits();
        return dialog.ShowDialog(getSingleDescription() + ": редактирование", object);
    }
    public boolean ViewObject(DBObject object) {
        DBObjectDialog dialog = getDialog();
        dialog.SetReadonly();
        dialog.ShowDialog(getSingleDescription() + ": просмотр", object);
        return false;
    }
    public boolean ShowDeleteObjectDialog(DBObject object) {
        return UI.Warning(getSingleDescription() + " " + object.getBDialogName() + " будет удален(а)");
    }
    public boolean ShowDeleteObjectsDialog(int toDeleteCount) {
        return UI.Warning(getPluralDescription() + " в количестве " + toDeleteCount + " будут удалены)");
    }
    public String QName() {
        return "\"" + Name + "\"";
    }
    public String getPKName() {
        return "";
    } //получить имя ключевого поля. нужно для таблиц.
    public String getPluralDescription() {
        return "";
    }
    public String getSingleDescription() {
        return "";
    }
    //-
    public void put(Object key, D object) {
        Data.put((K) key, object);
    }
    public D get(Object key) {
        return Data.get(key);
    }
    public Object getFieldAt(D object, int columnIndex) {
        return null;
    }
    public void clear() {
        Data.clear();
    }
    public int size() {
        return Data.size();
    }
    public boolean containsKey(Object key) {
        return Data.containsKey(key);
    }
    //-
    public Vector<K> getVisibleKeys() {
        Comparator<D> comparator = getComparator();
        Vector<K> res = new Vector<>();
        if (comparator == null) {
            for (K key : Data.keySet())
                if (Data.get(key).isVisible())
                    res.add(key);
        } else {
            Vector<D> raw = new Vector<>();
            for (D object : Data.values()) {
                if (object.isVisible())
                    raw.add(object);
            }
            raw.sort(comparator);
            for (D object : raw)
                res.add((K) object.getPK());
        }
        return res;
    }
    protected Comparator<D> getComparator() {
        return null;
    }
    public int getSelectedCount() {
        return (int) Data.values().stream().filter(d -> d.isVisible() && d.isSelected()).count();
    }
    public Vector<D> getSelectedItems() {
        return Data.values().stream().filter(d -> d.isVisible() && d.isSelected()).collect(Collectors.toCollection(Vector::new));
    }
    public Vector<K> getSelectedKeys() {
        return Data.values().stream().filter(DBObject::isSelected).map(d -> (K) d.getPK()).collect(Collectors.toCollection(Vector::new));
    }
    //--
    // применить значение фильтра к фильру объекта  напирмер Message.filterValue = text;
    public void changeColumnFilterValue(int columnIndex, String text) {
    }
    public Object getColumnFilterValue(int columnIndex) {
        return "";
    }
    //--
    public void ShowUI() {
        for (DataSetFilter<D> filter : filters)
            filter.Drop();
        //--
        if (ui_ != null) {
            ui_.Show();
            if (f_ui != null)
                f_ui.ShowMatchesCount(getRowCountUI());
        }
        //--
        for (DataSetFilter<D> filter : filters)
            filter.Refresh();
    }
    public void ShowUI(Object key) {
        for (DataSetFilter<D> filter : filters)
            filter.Drop();
        //--
        if (ui_ != null) {
            ui_.Show(key);
            if (f_ui != null)
                f_ui.ShowMatchesCount(getRowCountUI());
        }
        //--
        for (DataSetFilter<D> filter : filters)
            filter.Refresh();
    }
    public boolean applyFilters(D object) {
        for (DataSetFilter<D> filter : filters) {
            if (!filter.Validate(object))
                return false;
        }
        return true;
    }
    //------------------------------------------------------------------------------------
    public Current_ CurrentName() {
        return null;
    }
    public boolean CheckCurrent(TextLog log) {
        return MainModule_.instance.Check(log, CurrentName());
    }
    public boolean CheckSelectedOrCurrent(TextLog log) {
        if ((getSelectedCount() == 0) && (CurrentName()==null || (getCurrent()==null))) {
            log.Writeln_(getPluralDescription() + ":");
            log.Writeln_("Отсутствуют отмеченные объекты, или текущий объект!");
            return false;
        }
        return true;
    }
    public boolean hasCurrent() {
        return MainModule_.instance.get(CurrentName()) != null;
    }
    public void dropCurrent() {
        MainModule_.instance.set(CurrentName(), null);
    }
    public D getCurrent() {
        return (D) MainModule_.instance.get(CurrentName());
    }
    public void setCurrent(D o) {
        MainModule_.instance.set(CurrentName(), o);
    }
    public Vector<D> getSelectedOrCurrent() {
        Vector<D> res = new Vector<>();
        if (getSelectedCount() > 0)
            res = getSelectedItems();
        else {
            if ((CurrentName() != null) && (getCurrent() != null)) {
                res.add(getCurrent());
            }
        }
        return res;
    }
    public Vector<K> getSelectedOrCurrentKeys(){
        Vector<K> res = new Vector<>();
        if (getSelectedCount() > 0)
            res = getSelectedKeys();
        else {
            if ((CurrentName() != null) && (getCurrent() != null)) {
                res.add((K) getCurrent().getPK());
            }
        }
        return res;
    }
    public void SaveLastSelections() {
        if (hasUI()) {
            Object lastPk = null;
            if ((CurrentName() != null) && (getCurrent() != null))
                lastPk = getCurrent().getPK();
            if (!selections.containsKey(getClass()))
                selections.put(getClass(), lastPk);
            else selections.replace(getClass(), lastPk);
        }
    }
    public void RestoreLastSelections() {
        if (hasUI()) {
            Object lastPk = selections.get(getClass());
            if ((CurrentName() != null) && (lastPk != null)) {
                ui_.Select(lastPk);
            }
        }
    }
    //-------------------------------------------------------------------------------------
}