aswi2020vldc-gitlab/src/main/java/vldc/aswi/service/parameter/ParameterManagerImpl.java @ d411f143

package vldc.aswi.service.parameter;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
import vldc.aswi.dao.AssemblyRepository;
import vldc.aswi.dao.FunctionRepository;
import vldc.aswi.dao.LocationRepository;
import vldc.aswi.dao.OperatorRepository;
import vldc.aswi.dao.parameter.ParameterInConfigurationRepository;
import vldc.aswi.dao.parameter.ParameterRepository;
import vldc.aswi.dao.parameter.ParameterTypeRepository;
import vldc.aswi.dao.parameter.ParameterValueRepository;
import vldc.aswi.domain.*;
import vldc.aswi.domain.parameter.Parameter;
import vldc.aswi.domain.parameter.ParameterInConfiguration;
import vldc.aswi.domain.parameter.ParameterValue;

import javax.transaction.Transactional;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

/**
 * Manager for Parameter.
 */
@Service
@Slf4j
public class ParameterManagerImpl implements ParameterManager {

    /** Autowired parameter repository. */
    @Autowired
    private ParameterRepository parameterRepository;

    /** Autowired assembly repository. */
    @Autowired
    private AssemblyRepository assemblyRepository;

    /** Autowired parameterType repository. */
    @Autowired
    private ParameterTypeRepository parameterTypeRepository;

    /** Autowired location repository. */
    @Autowired
    private LocationRepository locationRepository;

    /** Autowired function repository. */
    @Autowired
    private FunctionRepository functionRepository;

    /** Autowired operator repository. */
    @Autowired
    private OperatorRepository operatorRepository;

    /** Autowired parameterValue repository. */
    @Autowired
    private ParameterValueRepository parameterValueRepository;

    /** Autowired parameter in configuration manager. */
    @Autowired
    private ParameterInConfigurationManager parameterInConfigurationManager;

    /**
     * Initialization setup for parameter manager. Check if parameter repository contains
     * records and if not, initialize default values.
     */
    @EventListener(classes = {
            ContextRefreshedEvent.class
    })
    @Order(1)
    @Transactional
    public void setup() {
        if (this.parameterRepository.count() == 0) {
            log.info("No parameter present, creating items.");

        }
    }

    /**
     * Get all parameters from database.
     * @return List of parameters.
     */
    @Override
    public List<Parameter> getParameters() {
        List<Parameter> retVal = new LinkedList<>();
        this.parameterRepository.findAll().forEach(retVal::add);
        return retVal;
    }

    /**
     * Add new parameter into database.
     * @param assemblyId - Assembly in which parameter is presented.
     * @param parameterValuesList - Parameter values.
     */
    @Override
    public void addParameters(Long assemblyId, List<Parameter> parameterValuesList) {
        Assembly assembly = this.assemblyRepository.getById(assemblyId);
        if (parameterValuesList == null) return;

        for (Parameter parameterValues : parameterValuesList) {
            // Create new parameter and assign him all values.
            Parameter parameter = new Parameter();
            parameter.setName(parameterValues.getName());
            parameter.setNameOfSelect(parameterValues.getNameOfSelect());
            parameter.setAssembly(assembly);
            parameter.setParameterOrder(parameterValues.getParameterOrder());
            parameter.setParameterType(this.parameterTypeRepository.findByName(parameterValues.getParameterType().getName()));
            parameter.setDefaultValue(parameterValues.getDefaultValue());

            List<Location> locationList = new LinkedList<>();
            List<Function> functionList = new LinkedList<>();
            List<Operator> operatorList = new LinkedList<>();
            List<ParameterValue> valueList = new LinkedList<>();

            // Try to put all locations into list.
            if (parameterValues.getLocations() != null && parameterValues.getLocations().size() > 0) {
                for (Location location : parameterValues.getLocations()) {
                    locationList.add(this.locationRepository.getById(location.getId()));
                }
            }

            // Try to put all functions into list.
            if (parameterValues.getFunctions() != null && parameterValues.getFunctions().size() > 0) {
                for (Function function : parameterValues.getFunctions()) {
                    functionList.add(this.functionRepository.getById(function.getId()));
                }
            }

            // Try to put all operators into list.
            if (parameterValues.getOperators() != null && parameterValues.getOperators().size() > 0) {
                for (Operator operator : parameterValues.getOperators()) {
                    operatorList.add(this.operatorRepository.getById(operator.getId()));
                }
            }

            if (parameter.getParameterType().getName().equals("Výčet")) {
                // Try to put all values into list.
                if (parameterValues.getParameterValues() != null && parameterValues.getParameterValues().size() > 0) {
                    for (ParameterValue parameterValue : parameterValues.getParameterValues()) {
                        valueList.add(this.parameterValueRepository.getById(parameterValue.getId()));
                    }
                }

                parameter.setParameterValues(valueList);
            }

            // Set lists of values into parameter.
            parameter.setLocations(locationList);
            parameter.setFunctions(functionList);
            parameter.setOperators(operatorList);

            // Insert parameter into database.
            this.parameterRepository.save(parameter);
        }
    }

    /**
     * Update parameter - remove deleted parameters, add new parameters, update updated parameters.
     * @param assemblyId - Assembly in which parameter is presented.
     * @param newAssemblyParameters - List of parameters.
     */
    @Override
    public void updateParameters(Long assemblyId, List<Parameter> newAssemblyParameters) {
        Assembly assembly = this.assemblyRepository.getById(assemblyId);
        List<Parameter> currentAssemblyParameters = assembly.getParameters();

        if (newAssemblyParameters != null) {
            // Remove removed parameters.
            newAssemblyParameters = removeRemovedParametersFromList(newAssemblyParameters);

            // Find new parameters.
            List<Parameter> currentAssemblyParametersNew = new LinkedList<>(currentAssemblyParameters);
            List<Parameter> newAssemblyParametersNew = new LinkedList<>(newAssemblyParameters);
            newAssemblyParametersNew.removeAll(currentAssemblyParametersNew);

            // Find deleted parameters.
            List<Parameter> currentAssemblyParametersDeleted = new LinkedList<>(currentAssemblyParameters);
            List<Parameter> newAssemblyParametersDeleted = new LinkedList<>(newAssemblyParameters);
            currentAssemblyParametersDeleted.removeAll(newAssemblyParametersDeleted);

            // Find duplicate elements - for updating.
            List<Parameter> currentAssemblyParametersUpdated = new LinkedList<>(currentAssemblyParameters);
            List<Parameter> newAssemblyParametersUpdated = new LinkedList<>(newAssemblyParameters);
            newAssemblyParametersUpdated.retainAll(currentAssemblyParametersUpdated);

            // If no parameter has been deleted or added, then updating is unnecessary.
            if (newAssemblyParametersNew.size() == 0 && currentAssemblyParametersDeleted.size() == 0 && newAssemblyParametersUpdated.size() == 0)
                return;

            // Remove deleted parameters.
            for (Parameter parameterWithValues : currentAssemblyParametersDeleted) {
                deleteParameter(parameterWithValues.getId());
            }

            // Update rest parameters.
            updateParameters(newAssemblyParametersUpdated);

            // Add new parameters
            addParameters(assemblyId, newAssemblyParametersNew);

            assembly.setParameters(this.parameterRepository.getByAssemblyId(assemblyId));
        }
    }

    /**
     * Remove removed parameters by web application.
     * Web page returns list of parameters, even those, which was removed, but those parameters
     * are empty object (null values in every attribute), so we need to remove them from list.
     * @param parameterValuesList - List of parameters from web.
     * @return Filtered list of parameters.
     */
    private List<Parameter> removeRemovedParametersFromList(List<Parameter> parameterValuesList) {
        List<Parameter> filteredParametersWithValues = new ArrayList<Parameter>();

        for (Parameter parameterWithValues : parameterValuesList) {
            // Because name of parameter is required, then we know that parameter
            // with name == null is just empty object.
            if (parameterWithValues.getName() != null) {
                filteredParametersWithValues.add(parameterWithValues);
            }
        }

        return filteredParametersWithValues;
    }

    /**
     * Update updated parameters.
     * @param parameterValuesList - List of updated parameters.
     */
    private void updateParameters(List<Parameter> parameterValuesList) {
        for (Parameter parameterWithValues : parameterValuesList) {
            List<ParameterValue> values = new ArrayList<>(parameterWithValues.getParameterValues());

            // Get current parameter from database.
            Parameter parameter = this.parameterRepository.getById(parameterWithValues.getId());
            // Update current parameter values.
            parameter.setName(parameterWithValues.getName());
            parameter.setParameterOrder(parameterWithValues.getParameterOrder());
            parameter.setNameOfSelect(parameterWithValues.getNameOfSelect());
            parameter.setAssembly(this.assemblyRepository.getById(parameterWithValues.getAssembly().getId()));
            parameter.setParameterType(this.parameterTypeRepository.getById(parameterWithValues.getParameterType().getId()));
            parameter.setDefaultValue(parameterWithValues.getDefaultValue());

            // Insert changes into database.
            this.parameterRepository.save(parameter);

            // Update parameter values, locations, functions and operators.
            if (parameter.getParameterType().getName().equals("Výčet")) {
                updateParameterValues(parameterWithValues.getId(), values);
            }

            updateParameterLocations(parameterWithValues.getId(), parameterWithValues.getLocations());
            updateParameterFunctions(parameterWithValues.getId(), parameterWithValues.getFunctions());
            updateParameterOperators(parameterWithValues.getId(), parameterWithValues.getOperators());
        }
    }

    /**
     * Update current parameter locations.
     * @param id - Id of parameter.
     * @param updatedLocations - List of locations.
     */
    private void updateParameterLocations(Long id, List<Location> updatedLocations) {
        Parameter parameter = this.parameterRepository.getById(id);
        List<Location> currentLocations = parameter.getLocations();

        // Get new locations.
        List<Location> currentLocationsNew = new LinkedList<>(currentLocations);
        List<Location> updatedLocationsNew = new LinkedList<>(updatedLocations);
        updatedLocationsNew.removeAll(currentLocationsNew);

        // Get deleted locations.
        List<Location> currentLocationsDeleted = new LinkedList<>(currentLocations);
        List<Location> updatedLocationsDeleted = new LinkedList<>(updatedLocations);
        currentLocationsDeleted.removeAll(updatedLocationsDeleted);

        // If there is no change, do not update.
        if (updatedLocationsNew.size() == 0 && currentLocationsDeleted.size() == 0) return;

        // Add new locations.
        for (Location newLocation : updatedLocationsNew) {
            currentLocations.add(this.locationRepository.getById(newLocation.getId()));
        }

        // Remove deleted locations.
        currentLocations.removeAll(currentLocationsDeleted);

        // Insert changes into database.
        this.parameterRepository.save(parameter);
    }

    /**
     * Update current parameter functions.
     * @param id - Id of parameter.
     * @param updatedFunctions - List of functions.
     */
    private void updateParameterFunctions(Long id, List<Function> updatedFunctions) {
        Parameter parameter = this.parameterRepository.getById(id);
        List<Function> currentFunctions = parameter.getFunctions();

        // Get new functions.
        List<Function> currentFunctionsNew = new LinkedList<>(currentFunctions);
        List<Function> updatedFunctionsNew = new LinkedList<>(updatedFunctions);
        updatedFunctionsNew.removeAll(currentFunctionsNew);

        // Get deleted functions.
        List<Function> currentFunctionsDeleted = new LinkedList<>(currentFunctions);
        List<Function> updatedFunctionsDeleted = new LinkedList<>(updatedFunctions);
        currentFunctionsDeleted.removeAll(updatedFunctionsDeleted);

        // If there is no change, do not update.
        if (updatedFunctionsNew.size() == 0 && currentFunctionsDeleted.size() == 0) return;

        // Add new functions.
        for (Function newFunction : updatedFunctionsNew) {
            currentFunctions.add(this.functionRepository.getById(newFunction.getId()));
        }

        // Delete removed functions.
        currentFunctions.removeAll(currentFunctionsDeleted);

        // Insert changes into database.
        this.parameterRepository.save(parameter);
    }

    /**
     * Update current parameter operators.
     * @param id - Id of parameter.
     * @param updatedOperators - List of operators.
     */
    private void updateParameterOperators(Long id, List<Operator> updatedOperators) {
        Parameter parameter = this.parameterRepository.getById(id);
        List<Operator> currentOperators = parameter.getOperators();

        // Get new operators.
        List<Operator> currentOperatorsNew = new LinkedList<>(currentOperators);
        List<Operator> updatedOperatorsNew = new LinkedList<>(updatedOperators);
        updatedOperatorsNew.removeAll(currentOperatorsNew);

        // Get deleted operators.
        List<Operator> currentOperatorsDeleted = new LinkedList<>(currentOperators);
        List<Operator> updatedOperatorsDeleted = new LinkedList<>(updatedOperators);
        currentOperatorsDeleted.removeAll(updatedOperatorsDeleted);

        // If there is no changes, do not update.
        if (updatedOperatorsNew.size() == 0 && currentOperatorsDeleted.size() == 0) return;

        // Insert new operators.
        for (Operator newOperator : updatedOperatorsNew) {
            currentOperators.add(this.operatorRepository.getById(newOperator.getId()));
        }

        // Delete removed operators.
        currentOperators.removeAll(currentOperatorsDeleted);

        // Insert changes into database.
        this.parameterRepository.save(parameter);
    }

    /**
     * Update current parameter values.
     * @param parameterId - ID of parameter.
     * @param newParameterValues - List of parameter values.
     */
    private void updateParameterValues(Long parameterId, List<ParameterValue> newParameterValues) {
        Parameter parameter = this.parameterRepository.getById(parameterId);
        List<ParameterValue> currentParameterValues = parameter.getParameterValues();

        // Get new parameter values.
        List<ParameterValue> currentParameterValuesNew = new LinkedList<>(currentParameterValues);
        List<ParameterValue> newParameterValuesNew = new LinkedList<>(newParameterValues);
        newParameterValuesNew.removeAll(currentParameterValuesNew);

        // Get deleted parameter values.
        List<ParameterValue> currentParameterValuesDeleted = new LinkedList<>(currentParameterValues);
        List<ParameterValue> newParameterValuesDeleted = new LinkedList<>(newParameterValues);
        currentParameterValuesDeleted.removeAll(newParameterValuesDeleted);

        // If there is no changes, do not update.
        if (newParameterValuesNew.size() == 0 && currentParameterValuesDeleted.size() == 0) return;

        // Delete removed parameter values.
        for (ParameterValue parameterValue : currentParameterValuesDeleted) {
            this.parameterValueRepository.delete(parameterValue);
        }

        // Add new parameter values.
        addParameterValueValues(parameterId, newParameterValuesNew);
    }

    /**
     * Add new parameter values.
     * @param parameterId - ID of parameter.
     * @param newParameterValuesNew - List of new parameter values.
     */
    private void addParameterValueValues(Long parameterId, List<ParameterValue> newParameterValuesNew) {
        Parameter parameter = this.parameterRepository.getById(parameterId);

        for (ParameterValue parameterValueValues : newParameterValuesNew) {
            ParameterValue parameterValue = new ParameterValue();
            parameterValue.setValue(parameterValueValues.getValue());
            parameterValue.setParameter(parameter);

            // Insert new parameterValue into database.
            this.parameterValueRepository.save(parameterValue);
        }
    }

    /**
     * Delete parameter by id.
     * @param parameterId - ID of parameter.
     * @return True if parameter was successfully deleted, false if not.
     */
    private boolean deleteParameter(Long parameterId) {
        try {
            Parameter parameter = this.parameterRepository.getById(parameterId);

            this.parameterInConfigurationManager.deleteParametersInConfiguration(parameterId, false);

            // Delete removed parameter values.
            for (ParameterValue parameterValue : parameter.getParameterValues()) {
                this.parameterValueRepository.delete(parameterValue);
            }

            // Delete all functions from parameter in table 'Parametr_ma_Funkce'.
            List<Function> functionList = new ArrayList<>(parameter.getFunctions());
            for (Function function : functionList) {
                parameter.removeFunction(function);
            }

            // Delete all operators from parameter in table 'Parametr_ma_Operator'.
            List<Operator> operatorList = new ArrayList<>(parameter.getOperators());
            for (Operator operator : operatorList) {
                parameter.removeOperator(operator);
            }

            // Delete all locations from parameter in table 'Parametr_ma_Umisteni'.
            List<Location> locationList = new ArrayList<>(parameter.getLocations());
            for (Location location : locationList) {
                parameter.removeLocation(location);
            }

            this.parameterRepository.delete(parameter);

            return true;
        }
        catch (Exception e) {
            return false;
        }
    }

    /**
     * Delete parameters by assembly id.
     * @param assemblyId - ID of assembly.
     * @return True if all parameters were successfully deleted, false if not.
     */
    @Override
    public boolean deleteParameters(Long assemblyId) {
        try {
            List<Parameter> parameters = this.parameterRepository.getByAssemblyId(assemblyId);

            for (Parameter parameter : parameters) {
                boolean success = deleteParameter(parameter.getId());
                if (success == false) {
                    return false;
                }
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }
}