VisualSapfor/src/_VisualDVM/TestingSystem/Common/TestsDatabase.java

package _VisualDVM.TestingSystem.Common;
import Common.CommonConstants;
import Common.Database.SQLITE.SQLiteDatabase;
import Common.Utils.Utils_;
import _VisualDVM.ComponentsServer.Component.Sapfor.Sapfor;
import _VisualDVM.ComponentsServer.UserAccount.UserAccount;
import _VisualDVM.Constants;
import _VisualDVM.Global;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentJson;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsJson;
import _VisualDVM.GlobalData.CompilerEnvironment.Json.EnvironmentsSetJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsJson;
import _VisualDVM.GlobalData.CompilerOption.Json.OptionsSetJson;
import _VisualDVM.Passes.PassCode;
import _VisualDVM.ServerObjectsCache.VisualCaches;
import _VisualDVM.TestingSystem.Common.Group.Group;
import _VisualDVM.TestingSystem.Common.Group.GroupsDBTable;
import _VisualDVM.TestingSystem.Common.Test.Test;
import _VisualDVM.TestingSystem.Common.Test.TestDBTable;
import _VisualDVM.TestingSystem.Common.TestFile.TestFile;
import _VisualDVM.TestingSystem.Common.TestFile.TestFilesDBTable;
import _VisualDVM.TestingSystem.Common.TestingPackageToKill.TestingPackagesToKillDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOption;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOption.DVMCompilationOptionsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSet;
import _VisualDVM.TestingSystem.DVM.DVMCompilationOptionsSet.DVMCompilationOptionsSetsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfiguration;
import _VisualDVM.TestingSystem.DVM.DVMConfiguration.DVMConfigurationDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroup;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationGroup.DVMConfigurationGroupsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettings;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationSettings.DVMConfigurationSettingsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTest;
import _VisualDVM.TestingSystem.DVM.DVMConfigurationTest.DVMConfigurationTestsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironment;
import _VisualDVM.TestingSystem.DVM.DVMEnvironment.DVMEnvironmentsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSet;
import _VisualDVM.TestingSystem.DVM.DVMEnvironmentsSet.DVMEnvironmentsSetsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackage;
import _VisualDVM.TestingSystem.DVM.DVMPackage.DVMPackageDBTable;
import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfiguration;
import _VisualDVM.TestingSystem.DVM.DVMPackageConfiguration.DVMPackageConfigurationsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettings;
import _VisualDVM.TestingSystem.DVM.DVMSettings.DVMSettingsDBTable;
import _VisualDVM.TestingSystem.DVM.DVMTasks.DVMRunTasksSet;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfiguration;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfiguration.SapforConfigurationDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationGroup.SapforConfigurationGroup;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationGroup.SapforConfigurationGroupsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationSettings.SapforConfigurationSettings;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationSettings.SapforConfigurationSettingsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationTest.SapforConfigurationTest;
import _VisualDVM.TestingSystem.SAPFOR.SapforConfigurationTest.SapforConfigurationTestsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforPackage.SapforPackage;
import _VisualDVM.TestingSystem.SAPFOR.SapforPackage.SapforPackageDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforPackageConfiguration.SapforPackageConfiguration;
import _VisualDVM.TestingSystem.SAPFOR.SapforPackageConfiguration.SapforPackageConfigurationsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforSettings.SapforSettingsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.SapforSettingsCommand.SapforSettingsCommandsDBTable;
import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapfor;
import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapforState;
import _VisualDVM.TestingSystem.SAPFOR.ServerSapfor.ServerSapforsDBTable;
import javafx.util.Pair;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.nio.file.Paths;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.Vector;
public class TestsDatabase extends SQLiteDatabase {
    public GroupsDBTable groups;
    //--
    public TestDBTable tests;
    public TestFilesDBTable testsFiles;
    //---
    public DVMSettingsDBTable dvmSettings;
    public DVMCompilationOptionsSetsDBTable dvmCompilationOptionsSets;
    public DVMCompilationOptionsDBTable dvmCompilationOptions;
    public DVMEnvironmentsSetsDBTable dvmEnvironmentsSets;
    public DVMEnvironmentsDBTable dvmEnvironments;
    public DVMConfigurationDBTable dvmConfigurations;
    public DVMConfigurationGroupsDBTable dvmConfigurationGroups;
    public DVMConfigurationTestsDBTable dvmConfigurationTests;
    public DVMConfigurationSettingsDBTable dvmConfigurationSettings;
    public DVMPackageDBTable dvmPackages;
    public DVMPackageConfigurationsDBTable dvmPackageConfigurations;
    public DVMRunTasksSet dvmRunTasks = new DVMRunTasksSet();
    //--
    public ServerSapforsDBTable serverSapfors;
    public SapforSettingsDBTable sapforSettings;
    public SapforSettingsCommandsDBTable sapforSettingsCommands;
    public SapforConfigurationDBTable sapforConfigurations;
    public SapforConfigurationGroupsDBTable sapforConfigurationGroups;
    public SapforConfigurationTestsDBTable sapforConfigurationTests;
    public SapforConfigurationSettingsDBTable sapforConfigurationSettings;
    public SapforPackageDBTable sapforPackages;
    public SapforPackageConfigurationsDBTable sapforPackageConfigurations;
    //--
    public TestingPackagesToKillDBTable testingPackagesToKill;
    //--
    public TestsDatabase() {
        super(Paths.get(System.getProperty("user.dir"), "Data", Constants.tests_db_name + ".sqlite").toFile());
    }
    @Override
    protected void initAllTables() throws Exception {
        addTable(groups = new GroupsDBTable());
        addTable(tests = new TestDBTable());
        addTable(testsFiles = new TestFilesDBTable());
        //--
        addTable(dvmSettings = new DVMSettingsDBTable());
        //--
        addTable(dvmCompilationOptionsSets = new DVMCompilationOptionsSetsDBTable());
        addTable(dvmCompilationOptions = new DVMCompilationOptionsDBTable());
        addTable(dvmEnvironmentsSets =new DVMEnvironmentsSetsDBTable());
        addTable(dvmEnvironments = new DVMEnvironmentsDBTable());
        //---
        addTable(dvmConfigurations = new DVMConfigurationDBTable());
        addTable(dvmConfigurationGroups = new DVMConfigurationGroupsDBTable());
        addTable(dvmConfigurationTests = new DVMConfigurationTestsDBTable());
        addTable(dvmConfigurationSettings = new DVMConfigurationSettingsDBTable());
        addTable(dvmPackages = new DVMPackageDBTable());
        addTable(dvmPackageConfigurations = new DVMPackageConfigurationsDBTable());
        //-
        addTable(serverSapfors = new ServerSapforsDBTable());
        addTable(sapforSettings = new SapforSettingsDBTable());
        addTable(sapforSettingsCommands = new SapforSettingsCommandsDBTable());
        addTable(sapforConfigurations = new SapforConfigurationDBTable());
        addTable(sapforConfigurationGroups = new SapforConfigurationGroupsDBTable());
        addTable(sapforConfigurationTests = new SapforConfigurationTestsDBTable());
        addTable(sapforConfigurationSettings = new SapforConfigurationSettingsDBTable());
        addTable(sapforPackages = new SapforPackageDBTable());
        addTable(sapforPackageConfigurations = new SapforPackageConfigurationsDBTable());
        //--
        addTable(testingPackagesToKill = new TestingPackagesToKillDBTable());
    }
    @Override
    public PassCode getSynchronizePassCode() {
        return PassCode.SynchronizeTests;
    }
    public Vector<SapforPackage> getFirstActiveSapforPackagesCopies() {
        Vector<SapforPackage> res = new Vector<>();
        Vector<SapforPackage> packages = new Vector<>();
        SapforPackage activePackage = null;
        //1. получить активные пакеты.
        for (SapforPackage p : sapforPackages.Data.values()) {
            switch (p.state) {
                case Done:
                case Aborted:
                case Draft:
                case ConnectionError:
                case DoneWithErrors:
                    break;
                default:
                    packages.add(p);
                    break;
            }
        }
        //2. отсортировать по приоритету.
        packages.sort(new Comparator<SapforPackage>() {
            @Override
            public int compare(SapforPackage o1, SapforPackage o2) {
                return Integer.compare(o1.state.ordinal(), o2.state.ordinal());
            }
        });
        if (!packages.isEmpty()) {
            activePackage = packages.lastElement();
            if (activePackage.state.equals(TasksPackageState.Queued)) {
                activePackage.state = TasksPackageState.TestsSynchronize;
                try {
                    Update(activePackage);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            res.add(new SapforPackage(activePackage));
            ; //копия чтобы не было конфликта доступа с нитью планировщика.
        }
        return res;
    }
    public Vector<DVMPackage> getFirstActiveDVMPackagesCopies() {
        Vector<DVMPackage> res = new Vector<>();
        //--
        LinkedHashMap<String, Vector<DVMPackage>> packagesByMachines = new LinkedHashMap<>();
        //----
        //1. Получить список активных пакетов по машинам.
        for (DVMPackage dvmPackage : dvmPackages.Data.values()) {
            switch (dvmPackage.state) {
                case Done:
                case DoneWithErrors:
                case Aborted:
                case Draft:
                case ConnectionError:
                    break;
                default:
                    //активен.
                    Vector<DVMPackage> packages = null;
                    //--
                    if (packagesByMachines.containsKey(dvmPackage.machine_address)) {
                        packages = packagesByMachines.get(dvmPackage.machine_address);
                    } else {
                        packages = new Vector<>();
                        packagesByMachines.put(dvmPackage.machine_address, packages);
                    }
                    packages.add(dvmPackage);
                    break;
            }
        }
        //2. Выбрать для каждой машины наиболее приоритетный пакет.
        for (String machine : packagesByMachines.keySet()) {
            Vector<DVMPackage> packages = packagesByMachines.get(machine);
            if (!packages.isEmpty()) {
                packages.sort(new Comparator<DVMPackage>() {
                    @Override
                    public int compare(DVMPackage o1, DVMPackage o2) {
                        return Integer.compare(o1.state.ordinal(), o2.state.ordinal());
                    }
                });
                //-
                DVMPackage activePackage = packages.lastElement();
                if (activePackage.state.equals(TasksPackageState.Queued)) {
                    activePackage.state = TasksPackageState.TestsSynchronize;
                    try {
                        Update(activePackage);
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
                res.add(new DVMPackage(activePackage)); //копия чтобы не было конфликта доступа с нитью планировщика.
            }
        }
        return res;
    }
    //--
    public void DetectTestMinMaxDim(ServerSapfor serverSapfor, Group group, Test test) throws Exception {
        switch (group.language) {
            case fortran:
                if (serverSapfor != null) {
                    Sapfor.getTestMinMaxDim_F(new File(serverSapfor.call_command), test);
                    Update(test);
                }
                break;
            case c:
                Sapfor.getTestMinMaxDime_C(test);
                Update(test);
                break;
        }
    }
    public void importTestFile(Test test, File file) throws Exception {
        File testDirectory = new File(Global.TestsDirectory, String.valueOf(test.id));
        Utils_.CheckAndCleanDirectory(testDirectory);
        File dst = Paths.get(testDirectory.getAbsolutePath(), file.getName()).toFile();
        FileUtils.copyFile(file, dst);
    }
    public void CreateTestFromSingleFile(UserAccount account, ServerSapfor sapfor, Group group, File file, String testDescription) throws Exception {
        Test test = new Test();
        test.description = testDescription;
        test.sender_name = account.name;
        test.sender_address = account.email;
        test.group_id = group.id;
        Insert(test);
        //->>
        importTestFile(test, file);
        TestFile testFile = new TestFile(test, file);
        Insert(testFile);
        //--
        DetectTestMinMaxDim(sapfor, group, test);
    }
    public void RefreshGroup(UserAccount account, ServerSapfor sapfor, Pair<Group, Vector<File>> groupData) throws Exception {
        Group group = groupData.getKey();
        Vector<File> files = groupData.getValue();
        //--
        Group oldGroup = groups.getGroupByDescription(group.language, group.description);
        if (oldGroup == null) {
            Insert(group);
            for (File file : files) {
                String testDescription = Utils_.getNameWithoutExtension(file.getName()) + "_" + group.language.getDVMCompile();
                CreateTestFromSingleFile(account, sapfor, group, file, testDescription);
            }
        } else {
            for (File file : files) {
                String testDescription = Utils_.getNameWithoutExtension(file.getName()) + "_" + group.language.getDVMCompile();
                Test oldTest = tests.getStandardTestByDescription(oldGroup.id, testDescription);
                if (oldTest == null) {
                    CreateTestFromSingleFile(account, sapfor, oldGroup, file, testDescription);
                } else {
                    importTestFile(oldTest, file);
                }
            }
        }
    }
    public Vector<DVMPackage> getFirstActiveDVMPackageCopyForMachineURL(String arg) {
        Vector<DVMPackage> res = new Vector<>();
        Vector<DVMPackage> machinePackages = new Vector<>();
        //--
        //1. Получить список активных пакетов для машины.
        for (DVMPackage dvmPackage : dvmPackages.Data.values()) {
            switch (dvmPackage.state) {
                case Done:
                case DoneWithErrors:
                case Aborted:
                case Draft:
                case ConnectionError:
                    break;
                default:
                    if (dvmPackage.getMachineURL().equals(arg))
                        machinePackages.add(dvmPackage);
                    break;
            }
        }
        if (!machinePackages.isEmpty()) {
            machinePackages.sort(new Comparator<DVMPackage>() {
                @Override
                public int compare(DVMPackage o1, DVMPackage o2) {
                    return Integer.compare(o1.state.ordinal(), o2.state.ordinal());
                }
            });
            //-
            DVMPackage activePackage = machinePackages.lastElement();
            if (activePackage.state.equals(TasksPackageState.Queued)) {
                activePackage.state = TasksPackageState.TestsSynchronize;
                try {
                    Update(activePackage);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
            }
            res.add(new DVMPackage(activePackage));
        }
        return res;
    }
    public ServerSapfor getSapforCopyForCompilation() {
        for (ServerSapfor serverSapfor : serverSapfors.Data.values()) {
            if (serverSapfor.state.equals(ServerSapforState.Queued)) {
                return new ServerSapfor(serverSapfor);
            }
        }
        return null;
    }
    public ServerSapfor getSapforForVersion(String version_in) {
        for (ServerSapfor serverSapfor : serverSapfors.Data.values()) {
            if (serverSapfor.version.equals(version_in))
                return serverSapfor;
        }
        return null;
    }
    public Integer getInstalledSapforMaxVersion() {
        int max_version = CommonConstants.Nan;
        for (ServerSapfor sapfor : serverSapfors.Data.values()) {
            if (sapfor.state.equals(ServerSapforState.Done)) {
                int version = CommonConstants.Nan;
                try {
                    version = Integer.parseInt(sapfor.version);
                } catch (Exception ex) {
                    ex.printStackTrace();
                }
                if (version > max_version) max_version = version;
            }
        }
        return max_version;
    }
    public boolean hasActiveSapfors() {
        for (ServerSapfor serverSapfor : serverSapfors.Data.values()) {
            if (serverSapfor.state.isActive())
                return true;
        }
        return false;
    }
    public void UnselectAllGTC() {
        groups.getUI().SelectAll(false);
        tests.getUI().SelectAll(false);
        dvmConfigurations.getUI().SelectAll(false);
    }
    //todo возможно рассмотреть вариант с синхроннизацией тестов для пакетов через команду серверу а не в нити
    //во избежание конфликта доступа,или удалением тестов во время копирования(?)
    @Override
    public void DropUI() {
        super.DropUI();
        dvmConfigurations.ClearUI();
        groups.ClearUI();
        sapforConfigurations.ClearUI();
        serverSapfors.ClearUI();
        dvmPackages.ClearUI();
        sapforPackages.ClearUI();
        sapforSettings.ClearUI();
        dvmSettings.ClearUI();
    }
    @Override
    public void ResetUI() {
        VisualCaches.ClearDataForClass(DVMConfiguration.class);
        VisualCaches.ClearDataForClass(SapforConfiguration.class);
        VisualCaches.ClearDataForClass(DVMPackage.class);
        VisualCaches.ClearDataForClass(SapforPackage.class);
        //server.db.machines
        dvmConfigurations.ShowUI();
        groups.ShowUI();
        sapforConfigurations.ShowUI();
        serverSapfors.ShowUI();
        dvmPackages.ShowUI();
        sapforPackages.ShowUI();
        sapforSettings.ShowUI();
        dvmSettings.ShowUI();
        super.ResetUI();
    }
    public void saveTestFiles(Test test) throws Exception {
        for (TestFile file : test.files) {
            file.test_id = test.id;
            Insert(file);
        }
        test.files = null;
    }
    public void DeleteTestFiles(Test test) throws Exception {
        Vector<TestFile> files = getVectorByFK(test, TestFile.class);
        for (TestFile file : files)
            Delete(file);
    }
    public void saveDVMPackageConfigurations(DVMPackage dvmPackage) throws Exception {
        for (DVMPackageConfiguration packageConfiguration : dvmPackage.configurations) {
            packageConfiguration.dvmpackage_id = dvmPackage.id;
            Insert(packageConfiguration);
        }
        dvmPackage.configurations = null;
    }
    public void saveSapforPackageConfigurations(SapforPackage dvmPackage) throws Exception {
        for (SapforPackageConfiguration packageConfiguration : dvmPackage.configurations) {
            packageConfiguration.sapforpackage_id = dvmPackage.id;
            Insert(packageConfiguration);
        }
        dvmPackage.configurations = null;
    }
    public Vector<Integer> getDVMConfigurationGroupsIds(DVMConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        for (DVMConfigurationGroup dvmConfigurationGroup : dvmConfigurationGroups.Data.values()) {
            if (dvmConfigurationGroup.dvmconfiguration_id == configuration.id)
                res.add(dvmConfigurationGroup.group_id);
        }
        return res;
    }
    public Vector<Integer> getDVMConfigurationTestsIds(DVMConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        if (configuration.groupsOnly == 0) {
            for (DVMConfigurationTest dvmConfigurationTest : dvmConfigurationTests.Data.values()) {
                if (dvmConfigurationTest.dvmconfiguration_id == configuration.id)
                    res.add(dvmConfigurationTest.test_id);
            }
        } else {
            Vector<Integer> groups_ids = getDVMConfigurationGroupsIds(configuration);
            for (int groud_id : groups_ids)
                res.addAll(getFKi(groud_id, Group.class, Test.class));
        }
        return res;
    }
    public Vector<Integer> getDVMConfigurationSettingsIds(DVMConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        for (DVMConfigurationSettings dvmConfigurationSettings : dvmConfigurationSettings.Data.values()) {
            if (dvmConfigurationSettings.dvmconfiguration_id == configuration.id)
                res.add(dvmConfigurationSettings.dvmsettings_id);
        }
        return res;
    }
    //--
    public Vector<Integer> getSapforConfigurationGroupsIds(SapforConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        for (SapforConfigurationGroup sapforConfigurationGroup : sapforConfigurationGroups.Data.values()) {
            if (sapforConfigurationGroup.sapforconfiguration_id == configuration.id)
                res.add(sapforConfigurationGroup.group_id);
        }
        return res;
    }
    public Vector<Integer> getSapforConfigurationTestsIds(SapforConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        if (configuration.groupsOnly == 0) {
            for (SapforConfigurationTest sapforConfigurationTest : sapforConfigurationTests.Data.values()) {
                if (sapforConfigurationTest.sapforconfiguration_id == configuration.id)
                    res.add(sapforConfigurationTest.test_id);
            }
        } else {
            Vector<Integer> groups_ids = getSapforConfigurationGroupsIds(configuration);
            for (int groud_id : groups_ids)
                res.addAll(getFKi(groud_id, Group.class, Test.class));
        }
        return res;
    }
    public Vector<Integer> getSapforConfigurationSettingsIds(SapforConfiguration configuration) {
        Vector<Integer> res = new Vector<>();
        for (SapforConfigurationSettings sapforConfigurationSettings : sapforConfigurationSettings.Data.values()) {
            if (sapforConfigurationSettings.sapforconfiguration_id == configuration.id)
                res.add(sapforConfigurationSettings.sapforsettings_id);
        }
        return res;
    }
    //--
    public LinkedHashMap<Integer, Vector<Integer>> getDVMConfigurationGroupsTestsIds(DVMConfiguration configuration) {
        LinkedHashMap<Integer, Vector<Integer>> res = new LinkedHashMap<>();
        Vector<Integer> all_tests_ids = getDVMConfigurationTestsIds(configuration);
        for (int group_id : getDVMConfigurationGroupsIds(configuration)) {
            Vector<Integer> test_ids = new Vector<>();
            for (int test_id : all_tests_ids) {
                if (tests.get(test_id).group_id == group_id)
                    test_ids.add(test_id);
            }
            res.put(group_id, test_ids);
        }
        return res;
    }
    public LinkedHashMap<Integer, Vector<Integer>> getSapforConfigurationGroupsTestsIds(SapforConfiguration configuration) {
        LinkedHashMap<Integer, Vector<Integer>> res = new LinkedHashMap<>();
        Vector<Integer> all_tests_ids = getSapforConfigurationTestsIds(configuration);
        for (int group_id : getSapforConfigurationGroupsIds(configuration)) {
            Vector<Integer> test_ids = new Vector<>();
            for (int test_id : all_tests_ids) {
                if (tests.get(test_id).group_id == group_id)
                    test_ids.add(test_id);
            }
            res.put(group_id, test_ids);
        }
        return res;
    }
    //--
    public Vector<Integer> getDVMPackageConfigurationsIds(DVMPackage dvmPackage) {
        Vector<Integer> res = new Vector<>();
        for (DVMPackageConfiguration dvmPackageConfiguration : dvmPackageConfigurations.Data.values()) {
            if (dvmPackageConfiguration.dvmpackage_id == dvmPackage.id)
                res.add(dvmPackageConfiguration.dvmconfiguration_id);
        }
        return res;
    }
    public Vector<Integer> getSapforPackageConfigurationsIds(SapforPackage sapforPackage) {
        Vector<Integer> res = new Vector<>();
        for (SapforPackageConfiguration sapforPackageConfiguration : sapforPackageConfigurations.Data.values()) {
            if (sapforPackageConfiguration.sapforpackage_id == sapforPackage.id)
                res.add(sapforPackageConfiguration.sapforconfiguration_id);
        }
        return res;
    }
    //--
    public OptionsSetJson convertOptionsToJson(DVMSettings dvmSettings_in) {
        OptionsSetJson res = new OptionsSetJson();
        if (dvmSettings_in.id != CommonConstants.Nan) {
            Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class);
            for (DVMCompilationOptionsSet optionsSet: optionsSets){
                Vector<DVMCompilationOption> options = getVectorByFK(optionsSet, DVMCompilationOption.class);
                OptionsJson optionsJson = new OptionsJson();
                for (DVMCompilationOption option:options){
                    optionsJson.values.add(new OptionJson(option.name,option.value));
                }
                res.values.add(optionsJson);
            }
        }
        return res;
    }
    public void DeleteDVMSettingsOptions(DVMSettings dvmSettings) throws Exception{
        Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings, DVMCompilationOptionsSet.class);
        for (DVMCompilationOptionsSet optionsSet: optionsSets){
             DeleteDependencies(optionsSet);
             Delete(optionsSet);
        }
    }
    public void InsertDVMSettingsOptions(DVMSettings dvmSettings) throws Exception{
        OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvmSettings.packedCompilationOptionsJson, OptionsSetJson.class);
        for (OptionsJson optionsJson: optionsSetJson.values){
            DVMCompilationOptionsSet optionsSet = new DVMCompilationOptionsSet(dvmSettings);
            Insert(optionsSet);
            for (OptionJson optionJson: optionsJson.values){
                DVMCompilationOption option = new DVMCompilationOption();
                option.dvmcompilationoptionsset_id=optionsSet.id;
                option.name = optionJson.name;
                option.value = optionJson.value;
                Insert(option);
            }
        }
    }
    public void DeleteDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception{
        Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings, DVMEnvironmentsSet.class);
        for (DVMEnvironmentsSet environmentsSet: environmentsSets){
            DeleteDependencies(environmentsSet);
            Delete(environmentsSet);
        }
    }
    public void InsertDVMSettingsEnvironments(DVMSettings dvmSettings) throws Exception{
        EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvmSettings.packedRunEnvironmentValuesJson,  EnvironmentsSetJson.class);
        for (EnvironmentsJson environmentsJson: environmentsSetJson.values){
            DVMEnvironmentsSet environmentsSet = new DVMEnvironmentsSet(dvmSettings);
            Insert(environmentsSet);
            for (EnvironmentJson environmentJson: environmentsJson.values){
                DVMEnvironment environment = new DVMEnvironment();
                environment.dvmenvironmentsset_id=environmentsSet.id;
                environment.name = environmentJson.name;
                environment.value = environmentJson.value;
                Insert(environment);
            }
        }
    }
    //--
    public void Patch() throws Exception {
        /*
        Vector<DVMCompilationOptionsSet> sets = new Vector<>();
        for (DVMSettings dvm_settings : dvmSettings.Data.values()) {
            OptionsSetJson optionsSetJson = Utils_.gson.fromJson(dvm_settings.packedCompilationOptionsJson, OptionsSetJson.class);
            for (OptionsJson optionsJson : optionsSetJson.values) {
                DVMCompilationOptionsSet set = new DVMCompilationOptionsSet(dvm_settings);
                set.options = new Vector<>();
                for (OptionJson optionJson : optionsJson.values) {
                    set.options.add(new DVMCompilationOption(optionJson.name, optionJson.value));
                }
                sets.add(set);
            }
        }
        BeginTransaction();
        for (DVMCompilationOptionsSet set : sets) {
            Insert(set);

            for (DVMCompilationOption option : set.options) {
                option.dvmcompilationoptionsset_id = set.id;
                Insert(option);
            }
        }
        Commit();
         */
        /*
        Vector<DVMEnvironmentsSet> sets = new Vector<>();
        for (DVMSettings dvm_settings : dvmSettings.Data.values()) {
            EnvironmentsSetJson environmentsSetJson = Utils_.gson.fromJson(dvm_settings.packedRunEnvironmentValuesJson, EnvironmentsSetJson.class);
            for (EnvironmentsJson environmentsJson : environmentsSetJson.values) {
                DVMEnvironmentsSet set = new DVMEnvironmentsSet(dvm_settings);
                set.environments = new Vector<>();
                for (EnvironmentJson environmentJson : environmentsJson.values) {
                    set.environments.add(new DVMEnvironment(environmentJson.name, environmentJson.value));
                }
                sets.add(set);
            }
        }
        BeginTransaction();
        for (DVMEnvironmentsSet set : sets) {
            Insert(set);
            for (DVMEnvironment option : set.environments) {
                option.dvmenvironmentsset_id = set.id;
                Insert(option);
            }
        }
        Commit();
        */
            }

    public static String printOptionsLine(Vector<DVMCompilationOption> options){
        Vector<String> res = new Vector<>();
        for (DVMCompilationOption option: options)
            res.add(option.print());
        return String.join(" ", res);
    }
    public static String printEnvironmentsLine(Vector<DVMEnvironment> environments){
        Vector<String> res = new Vector<>();
        for (DVMEnvironment environment: environments)
            res.add(environment.print());
        return String.join(" ", res);
    }
    public Vector<Pair<String, String>> getTasksParameters(DVMSettings dvmSettings_in) {
        //уравниваем количество наборов опций и окружений и сопоставляем 1 к 1
        Vector<Pair<String, String>> res = new Vector<>();
        Vector<DVMCompilationOptionsSet> optionsSets = getVectorByFK(dvmSettings_in, DVMCompilationOptionsSet.class);
        Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class);
        //--
        for (int i = 0; i < optionsSets.size(); ++i) {
            Vector<DVMCompilationOption> options = getVectorByFK(optionsSets.get(i), DVMCompilationOption.class);
            Vector<DVMEnvironment> environments = getVectorByFK(environmentsSets.get(i), DVMEnvironment.class);

            String optionsLine = printOptionsLine(options);
            String environmentsLine = (i < environmentsSets.size()) ? printEnvironmentsLine(environments) : "";
            res.add(new Pair<>(
                    optionsLine,
                    environmentsLine));
        }
        if (optionsSets.size() < environmentsSets.size()) {
            for (int i = optionsSets.size(); i < environmentsSets.size(); ++i) {
                res.add(new Pair<>(
                        "",
                        printEnvironmentsLine(getVectorByFK(environmentsSets.get(i), DVMEnvironment.class))
                ));
            }
        }
        return res;
    }
    public EnvironmentsSetJson convertEnvironmentsToJson(DVMSettings dvmSettings_in) {
        EnvironmentsSetJson res = new EnvironmentsSetJson();
        if (dvmSettings_in.id != CommonConstants.Nan) {
            Vector<DVMEnvironmentsSet> environmentsSets = getVectorByFK(dvmSettings_in, DVMEnvironmentsSet.class);
            for (DVMEnvironmentsSet environmentsSet: environmentsSets){
                Vector<DVMEnvironment> environments = getVectorByFK(environmentsSet, DVMEnvironment.class);
                EnvironmentsJson environmentsJson = new EnvironmentsJson();
                for (DVMEnvironment option:environments){
                    environmentsJson.values.add(new EnvironmentJson(option.name,option.value));
                }
                res.values.add(environmentsJson);
            }
        }
        return res;
    }
}