aswi2020vldc-gitlab/src/main/java/vldc/aswi/web/controller/ConfigurationController.java @ ba7a20a1

package vldc.aswi.web.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.validation.BeanPropertyBindingResult;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import vldc.aswi.domain.Assembly;
import vldc.aswi.domain.Configuration;
import vldc.aswi.domain.Location;
import vldc.aswi.domain.Operator;
import vldc.aswi.domain.parameter.ParameterInConfiguration;
import vldc.aswi.model.ExportType;
import vldc.aswi.model.table.contingencyTable.ContingencyTableRow;
import vldc.aswi.service.*;
import vldc.aswi.service.parameter.ParameterManager;
import vldc.aswi.utils.AuthControl;
import vldc.aswi.utils.Utils;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import vldc.aswi.validators.ConfigurationValidator;

import javax.validation.Valid;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * Manager for configuration.
 */
@Controller
public class ConfigurationController extends BasicController{

    /** Autowired location manager. */
    @Autowired
    private LocationManager locationManager;

    /** Autowired assembly manager. */
    @Autowired
    private AssemblyManager assemblyManager;

    /** Autowired sql query manager. */
    @Autowired
    private SqlQueryManager sqlQueryManager;

    /** Autowired export manager. */
    @Autowired
    private ExportManager exportManager;

    /** Autowired parameter manager. */
    @Autowired
    private ParameterManager parameterManager;

    /** Autowired configuration manager */
    @Autowired
    private ConfigurationManager configurationManager;

    /** Autowired configuration validator */
    @Autowired
    private ConfigurationValidator configurationValidator;

    /** Name of thymeleaf parameter, which will contain text in assembly form. */
    private String assemblyTitleName = "title";

    /** Title text for table generation form.  */
    private String generateTableTitleText = "Generování tabulky - ";

    /**
     * Opens an configuration page after configuration name was clicked
     * @param id ID of configuration
     * @return modelAndView of page to be shown
     */
    @GetMapping("/configuration")
    public ModelAndView configurationGet(@RequestParam("configurationID") String id,
                                         @ModelAttribute("successText") String successMsg,
                                         @ModelAttribute("errorText") String errorMsg) {
        ModelAndView modelAndView = new ModelAndView("assembly");

        ModelMap modelMap = modelAndView.getModelMap();

        Configuration configuration = configurationManager.getConfigurationById(Long.parseLong(id));

        // TODO: 04.05.2020 error page when id doesn't exist

        String userName = AuthControl.getUserName();

        if (userName == null) {
            // TODO: 04.05.2020 error message, user not authenticated
        }
        else if (!userName.equals(configuration.getUser().getUsername())) {
            // TODO: 04.05.2020 error page wrong user
            return new ModelAndView("redirect:/");
        }

        List<ParameterInConfiguration> parametersInConfiguration = new ArrayList<>(configuration.getParametersInConfiguration());
        configuration.setParametersInConfiguration(parametersInConfiguration);

        initializeFields(configuration);

        modelMap.addAttribute("configuration", configuration);
        modelMap.addAttribute("formAction", "/configuration?configurationID=" + configuration.getId());

        modelMap.addAttribute(assemblySuccessName, successMsg);
        modelMap.addAttribute(assemblyErrorName, errorMsg);

        return modelAndView;
    }

    /**
     * Saves or edits configuration and redirects to the page with configuration
     * @param newConfiguration contained with configuration data
     * @param id ID of configuration, if empty new configuration is created
     * @param bindingResult binding result
     * @return modelAndView with redirection
     */
    @PostMapping("/configuration")
    public ModelAndView configurationPost(@Valid Configuration newConfiguration,
                                           BindingResult bindingResult,
                                           @RequestParam("isNotRemoveEmpty") String isNotRemoveEmptyString,
                                           @RequestParam("configurationID") String id,
                                           @RequestParam(required=false, value="generateTable") String generateTable,
                                           @RequestParam(required=false, value="exportXlsx") String exportXlsx,
                                           @RequestParam(required=false, value="exportPdf") String exportPdf,
                                           @RequestParam(required=false, value="saveConfiguration") String saveConfiguration,
                                            RedirectAttributes redirectAttributes,
                                            HttpServletRequest request,
                                            HttpServletResponse response
                                          )
    {
        ModelAndView modelAndView = new ModelAndView();
        ModelMap modelMap = modelAndView.getModelMap();
        boolean isNotRemoveEmpty = isNotRemoveEmptyString == null || !isNotRemoveEmptyString.equals("");

        if (bindingResult.hasErrors()) {
            // TODO: 04.05.2020 Error message
            modelAndView.setViewName("redirect:/");

            return modelAndView;
        }

        if (generateTable != null)
        {
            prepareForTable(newConfiguration);
            BindingResult errors = new BeanPropertyBindingResult(newConfiguration, newConfiguration.getClass().getName());
            configurationValidator.validate(newConfiguration, errors);
            if (errors.hasErrors()) {
                addConfigurationDataIntoModelAndView(newConfiguration, modelAndView, modelMap);

                modelMap.addAttribute(assemblyErrorName, getFullErrorMessage(errors));
                modelMap.addAttribute(assemblyTitleName, generateTableTitleText + " " + newConfiguration.getName());
            }
            else {
                List<ContingencyTableRow> rows = this.sqlQueryManager.getContingencyTableRow(newConfiguration.getAssembly(),
                        newConfiguration.getParametersInConfiguration(), isNotRemoveEmpty);

                modelMap.addAttribute("configurationID", id);
                modelMap.addAttribute("contingencyTableRows", rows);
                addConfigurationDataIntoModelAndView(newConfiguration, modelAndView, modelMap);
            }
        }
        else if (exportXlsx != null)
        {
            prepareForTable(newConfiguration);
            this.exportManager.exportContingencyTable(newConfiguration, isNotRemoveEmpty, response, ExportType.XLSX);

            // Return null, because we want to continue on our page with selected parameters / attributes.
            return null;
        }
        else if (exportPdf != null)
        {
            prepareForTable(newConfiguration);
            this.exportManager.exportContingencyTable(newConfiguration, isNotRemoveEmpty, response, ExportType.PDF);

            // Return null, because we want to continue on our page with selected parameters / attributes.
            return null;
        }
        else if (saveConfiguration != null)
        {
            Configuration configuration = configurationManager.saveConfiguration(newConfiguration, id);

            initializeFields(configuration);

            redirectAttributes.addFlashAttribute(assemblySuccessName, "Šablona byla úspěšně uložena");
            modelAndView.setViewName("redirect:/configuration?configurationID=" + configuration.getId());

        }

        return modelAndView;
    }

    /**
     * Get method for configuration delete.
     * @param id - ID of configuration.
     * @return ModelAndView for index.
     */
    @GetMapping("/configuration_delete")
    public ModelAndView configurationDeleteGet(@RequestParam("configurationID") String id, RedirectAttributes redirectAttributes) {
        ModelAndView modelAndView = new ModelAndView("redirect:/");

        Long configurationId = Utils.tryParseLong(id);

        if (configurationId == null) {
            redirectAttributes.addFlashAttribute(assemblyErrorName, "Sestavu se nepodařilo odstranit");
        }

        boolean success = this.configurationManager.deleteConfiguration(configurationId);

        if (success)
        {
            redirectAttributes.addFlashAttribute(assemblySuccessName, "Sestava byla úspěšně odstraněna");
        }
        else
        {
            redirectAttributes.addFlashAttribute(assemblyErrorName, "Sestavu se nepodařilo odstranit");
        }

        return modelAndView;
    }

    /**
     * Initializes fields of a given configuration
     * @param configuration configuration which fields should be initialized
     */
    private void initializeFields(Configuration configuration) {
        for(ParameterInConfiguration parameterInConfiguration : configuration.getParametersInConfiguration()) {
            if(parameterInConfiguration.getLocation() == null) {
                parameterInConfiguration.setLocation(new Location());
            }
            if(parameterInConfiguration.getOperator() == null) {
                parameterInConfiguration.setOperator(new Operator());
            }
            if(parameterInConfiguration.getFunctions() == null) {
                parameterInConfiguration.setFunctions(new ArrayList<>());
            }
        }
    }

    /**
     * Prepares the configuration for contingency table generation. Initializes assembly and parameters of parameters in
     * configuration.
     * @param configuration configuration to be prepared.
     */
    private void prepareForTable(Configuration configuration) {
        Assembly assembly = assemblyManager.getAssemblyById(configuration.getAssembly().getId());
        configuration.setAssembly(assembly);

        for(int i = 0; i < configuration.getParametersInConfiguration().size(); i++) {
            ParameterInConfiguration parameterInConfiguration = configuration.getParametersInConfiguration().get(i);
            parameterInConfiguration.setParameter(parameterManager.getParameterById(parameterInConfiguration.getParameter().getId()));
            parameterInConfiguration.setParameter(assembly.getParameters().get(i));
            if (parameterInConfiguration.getLocation() != null) {
                parameterInConfiguration.setLocation(locationManager.getLocationById(parameterInConfiguration.getLocation().getId()));
            } else {
                parameterInConfiguration.setLocation(new Location());
            }
            parameterInConfiguration.setConfiguration(configuration);
        }

        Comparator<ParameterInConfiguration> comparator = Comparator.comparingInt(o -> o.getParameter().getParameterOrder());
        configuration.getParametersInConfiguration().sort(comparator);
    }

    /**
     * Adds configuration and other data to modelAndView.
     * @param newConfiguration Configuration to be added to the modelAndView.
     * @param modelAndView ModelAndView to which to which modelMap belongs.
     * @param modelMap ModelMap to which data is added.
     */
    private void addConfigurationDataIntoModelAndView(Configuration newConfiguration, ModelAndView modelAndView, ModelMap modelMap) {
        initializeFields(newConfiguration);
        modelMap.addAttribute("configuration", newConfiguration);
        modelMap.addAttribute("formAction", "/configuration?configurationID=" + newConfiguration.getAssembly().getId());
        modelAndView.setViewName("assembly");
    }
}