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

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.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.table.contingencyTable.ContingencyTableRow;
import vldc.aswi.service.AssemblyManager;
import vldc.aswi.service.ConfigurationManager;
import vldc.aswi.service.LocationManager;
import vldc.aswi.service.SqlQueryManager;
import vldc.aswi.utils.AuthControl;
import vldc.aswi.utils.Utils;
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 configuration manager */
    @Autowired
    private ConfigurationManager configurationManager;

    /**
     * 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);
        Comparator<ParameterInConfiguration> comparator = Comparator.comparingInt(o -> o.getParameter().getParameterOrder());

        modelMap.addAttribute("configuration", configuration);
        modelMap.addAttribute("comparator", comparator);
        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(Configuration newConfiguration,
                                           BindingResult bindingResult,
                                           @RequestParam("configurationID") String id,
                                           @RequestParam(required=false, value="generateTable") String generateTable,
                                           @RequestParam(required=false, value="exportXls") String exportXls,
                                           @RequestParam(required=false, value="exportPdf") String exportPdf,
                                           @RequestParam(required=false, value="saveConfiguration") String saveConfiguration,
                                            RedirectAttributes redirectAttributes
                                          )
    {
        ModelAndView modelAndView = new ModelAndView();
        ModelMap modelMap = modelAndView.getModelMap();

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

            return modelAndView;
        }

        if (generateTable != null)
        {
            prepareForTable(newConfiguration);
            System.out.println("Generuj tabulku");

            List<ContingencyTableRow> rows = this.sqlQueryManager.getContingencyTableRow(newConfiguration.getAssembly().getSQLQuery(),
                    newConfiguration.getParametersInConfiguration());

            modelMap.addAttribute("configurationID", id);
            modelMap.addAttribute("contingencyTableRows", rows);
            Comparator<ParameterInConfiguration> comparator = Comparator.comparingInt(o -> o.getParameter().getParameterOrder());
            initializeFields(newConfiguration);
            modelMap.addAttribute("configuration", newConfiguration);
            modelMap.addAttribute("comparator", comparator);
            modelMap.addAttribute("formAction", "/configuration?configurationID=" + id);
            modelAndView.setViewName("assembly");
        }
        else if (exportXls != null)
        {
            System.out.println("Generuj XLS");
        }
        else if (exportPdf != null)
        {
            System.out.println("Generuj PDF");
        }
        else if (saveConfiguration != null)
        {
            System.out.println("ulož konfiguraci");
            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(assembly.getParameters().get(i));
            if (parameterInConfiguration.getLocation() != null) {
                parameterInConfiguration.setLocation(locationManager.getLocationById(parameterInConfiguration.getLocation().getId()));
            }
        }
    }
}