aswi2020vldc-gitlab/src/main/java/vldc/aswi/service/ConfigurationManagerImpl.java @ 50c00b46

package vldc.aswi.service;

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.*;
import vldc.aswi.dao.parameter.ParameterInConfigurationRepository;
import vldc.aswi.dao.parameter.ParameterTypeRepository;
import vldc.aswi.domain.Assembly;
import vldc.aswi.domain.Configuration;
import vldc.aswi.domain.Function;
import vldc.aswi.domain.parameter.ParameterInConfiguration;
import vldc.aswi.service.parameter.ParameterInConfigurationManager;
import vldc.aswi.service.parameter.ParameterTypeManager;

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

@Service
@Slf4j
public class ConfigurationManagerImpl implements ConfigurationManager {

    /** Autowired configuration repository. */
    @Autowired
    private ConfigurationRepository configurationRepository;

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

    /** Autowired parameterInConfiguration repository. */
    @Autowired
    private ParameterInConfigurationRepository parameterInConfigurationRepository;

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

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

    /** Autowired parameter type manager. */
    @Autowired
    private ParameterTypeManager parameterTypeRepository;

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

    /** Autowired user repository. */
    @Autowired
    private UserRepository userRepository;

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

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

        }
    }

    /**
     * Get all configurations from database.
     * @return List of configurations.
     */
    @Override
    public List<Configuration> getConfigurations() {
        List<Configuration> retVal = new LinkedList<>();
        this.configurationRepository.findAll().forEach(retVal::add);
        return retVal;
    }

    /**
     * Gets configuration according to its ID
     * @param id ID of configuration
     * @return configuration by ID
     */
    @Override
    public Configuration getConfigurationById(Long id) {
        return configurationRepository.getById(id);
    }

    /**
     * Saves configuration and its contents into database
     * @param newConfiguration configuration to save
     * @param id id of configuration, if not empty configuration is updated
     * @return saved configuration
     */
    @Override
    public Configuration saveConfiguration(Configuration newConfiguration, String id) {
        if(id.equals("")) {
            return addConfiguration(newConfiguration);
        }
        else {
            return editConfiguration(newConfiguration, Long.valueOf(id));
        }
    }

    /**
     * Delete single configuration by id.
     * @param id - ID of configuration.
     * @return True if deleting was successful, false if not.
     */
    @Override
    public boolean deleteConfiguration(Long id) {
        try {
            this.parameterInConfigurationManager.deleteParametersInConfiguration(id);
            this.configurationRepository.deleteById(id);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * Delete all configurations by assembly id.
     * @param assemblyId - ID of assembly.
     * @return True if all configurations were successfully deleted, false if not.
     */
    @Override
    public boolean deleteConfigurations(Long assemblyId) {
        try {
            // Delete parameters in current configuration.
            List<Configuration> configurations = this.configurationRepository.getByAssemblyId(assemblyId);
            for (Configuration configuration : configurations) {
                this.parameterInConfigurationManager.deleteParametersInConfiguration(configuration.getId());
            }

            // Delete configuration.
            this.configurationRepository.deleteAll(configurations);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /**
     * Saves new configuration into database
     * @param newConfiguration container with data for a new configuration
     * @return saved configuration
     */
    private Configuration addConfiguration(Configuration newConfiguration) {
        Configuration configuration = new Configuration();
        Assembly assembly = assemblyRepository.getById(newConfiguration.getAssembly().getId());
        configuration.setAssembly(assembly);
        configuration.setName(newConfiguration.getName());
        configuration.setTableName(newConfiguration.getTableName());
        configuration.setUser(userRepository.getById((long) 1));
        Configuration savedConfiguration = configurationRepository.save(configuration);

        savedConfiguration.setParametersInConfiguration(new ArrayList<>());
        for(int i = 0; i < newConfiguration.getParametersInConfiguration().size(); i++) {
            ParameterInConfiguration parameterInConfiguration = new ParameterInConfiguration();
            parameterInConfiguration.setParameter(assembly.getParameters().get(i));
            parameterInConfiguration.setConfiguration(savedConfiguration);
            parameterInConfiguration.setOperatorValue(newConfiguration.getParametersInConfiguration().get(i).getOperatorValue());
            parameterInConfiguration.setColumnName(assembly.getParameters().get(i).getName());
            if(newConfiguration.getParametersInConfiguration().get(i).getColumnName() != null &&
                    !newConfiguration.getParametersInConfiguration().get(i).getColumnName().equals("")) {
                parameterInConfiguration.setColumnName(newConfiguration.getParametersInConfiguration().get(i).getColumnName());
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getLocation() != null) {
                parameterInConfiguration.setLocation(locationRepository.getById(
                        newConfiguration.getParametersInConfiguration().get(i).getLocation().getId()));
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getOperator() != null) {
                parameterInConfiguration.setOperator(operatorRepository.getByName(
                        newConfiguration.getParametersInConfiguration().get(i).getOperator().getName()));
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getFunctions() != null) {
                parameterInConfiguration.setFunctions(new ArrayList<>());
                for (Function function : newConfiguration.getParametersInConfiguration().get(i).getFunctions()) {
                    parameterInConfiguration.getFunctions().add(functionRepository.getByName(function.getName()));
                }
            }
            ParameterInConfiguration savedParameterInConfiguration = parameterInConfigurationRepository.save(
                    parameterInConfiguration);
            savedConfiguration.getParametersInConfiguration().add(savedParameterInConfiguration);
        }
        savedConfiguration = configurationRepository.save(savedConfiguration);

        return savedConfiguration;
    }

    /**
     * Saves edited configuration with given ID
     * @param newConfiguration container with data for edited configuration
     * @param id ID of edited configuration
     * @return saved configuration
     */
    private Configuration editConfiguration(Configuration newConfiguration, Long id) {
        Configuration configuration = configurationRepository.getById(id);
        configuration.setName(newConfiguration.getName());
        configuration.setTableName(newConfiguration.getTableName());

        for(int i = 0; i < configuration.getParametersInConfiguration().size(); i++) {
            ParameterInConfiguration parameterInConfiguration = configuration.getParametersInConfiguration().get(i);
            parameterInConfiguration.setOperatorValue(newConfiguration.getParametersInConfiguration().get(i).getOperatorValue());
            if(newConfiguration.getParametersInConfiguration().get(i).getColumnName() != null &&
                    !newConfiguration.getParametersInConfiguration().get(i).getColumnName().equals("")) {
                parameterInConfiguration.setColumnName(newConfiguration.getParametersInConfiguration().get(i).getColumnName());
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getLocation() != null) {
                parameterInConfiguration.setLocation(locationRepository.getById(
                        newConfiguration.getParametersInConfiguration().get(i).getLocation().getId()));
            }
            else {
                parameterInConfiguration.setLocation(null);
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getOperator() != null) {
                parameterInConfiguration.setOperator(operatorRepository.getByName(
                        newConfiguration.getParametersInConfiguration().get(i).getOperator().getName()));
            }
            if(newConfiguration.getParametersInConfiguration().get(i).getFunctions() != null) {
                parameterInConfiguration.setFunctions(new ArrayList<>());
                for (Function function : newConfiguration.getParametersInConfiguration().get(i).getFunctions()) {
                    parameterInConfiguration.getFunctions().add(functionRepository.getByName(function.getName()));
                }
            }
            parameterInConfigurationRepository.save(parameterInConfiguration);
        }

        return configurationRepository.save(configuration);
    }
}