D-Net

package eu.dnetlib.uoamonitorservice.controllers;

import eu.dnetlib.uoamonitorservice.dao.*;

import eu.dnetlib.uoamonitorservice.entities.*;

import eu.dnetlib.uoamonitorservice.handlers.EntityNotFoundException;

import eu.dnetlib.uoamonitorservice.handlers.PathNotValidException;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.*;

import java.net.URLEncoder;

@RestController

@CrossOrigin(origins = "*")

public class IndicatorController {

    private final Logger log = Logger.getLogger(this.getClass());

    @Autowired

    private StakeholderDAO stakeholderDAO;

    @Autowired

    private TopicDAO topicDAO;

    @Autowired

    private CategoryDAO categoryDAO;

    @Autowired

    private SubCategoryDAO subCategoryDAO;

    @Autowired

    @Autowired

                                   @PathVariable("topicId") String topicId,

                                   @PathVariable("categoryId") String categoryId,

                                   @PathVariable("subcategoryId") String subcategoryId,

        if(indicator.getId() != null) {

            oldIndicator = indicatorDAO.findById(indicator.getId());

        }

        indicatorDAO.save(indicator);

        if(stakeholder.getDefaultId() == null) {

            if(indicatorId == null) {

                onSaveDefaultIndicator(indicator, sectionId);

            }

            else {

        }

        if (index == -1) {

            indicators.add(indicator.getId());

            sectionDAO.save(section);

            log.debug("Indicator saved!");

        }

        return indicator;

    }

        // new indicator in default profile - add it on profiles of the same type

            indicatorNew.copyFromDefault(indicator);

            for (IndicatorPath indicatorPath : indicatorNew.getIndicatorPaths()) {

            }

            indicatorDAO.save(indicatorNew);

    }

        // indicator already exists - check if changed and update all indicators based on it

        boolean changed = false;

        List<Indicator> indicators = indicatorDAO.findByDefaultId(indicator.getId());

        for(Indicator indicatorBasedOnDefault : indicators) {

                    && (oldIndicator.getName() == null || oldIndicator.getName().equals(indicatorBasedOnDefault.getName()))) {

                indicatorBasedOnDefault.setName(indicator.getName());

                changed = true;

            }

            if(indicator.getDescription() != null && !indicator.getDescription().equals(indicatorBasedOnDefault.getDescription())

                    && (oldIndicator.getDescription() == null || oldIndicator.getDescription().equals(indicatorBasedOnDefault.getDescription()))) {

                indicatorBasedOnDefault.setName(indicator.getName());

                changed = true;

            }

            List<IndicatorPath> indicatorPaths = indicatorBasedOnDefault.getIndicatorPaths();

            for (IndicatorPath indicatorPath : indicator.getIndicatorPaths()) {

                IndicatorPath indicatorPathBasedOnDefault = indicatorBasedOnDefault.getIndicatorPaths().get(i);

                if(indicatorPathBasedOnDefault == null) {

                    // Add new indicator path in existing indicators

                    IndicatorPath indicatorPathNew = new IndicatorPath(indicatorPath);

                    parameterMapping(indicatorPathNew, stakeholder);

                    indicatorPaths.add(indicatorPathNew);

                    changed = true;

                } else {

                    log.debug("indicatorPathBasedOnDefault.getType(): "+indicatorPathBasedOnDefault.getType());

                    log.debug("oldIndicatorPath.getType(): "+oldIndicatorPath.getType());

                    if(indicatorPath.getType() != null

                            && !indicatorPath.getType().equals(indicatorPathBasedOnDefault.getType())

                            && !indicatorPath.getSource().equals(indicatorPathBasedOnDefault.getSource())

                        changed = true;

                    }

                            && !indicatorPath.getUrl().equals(indicatorPathBasedOnDefault.getUrl())

                        changed = true;

                    }

                            && !indicatorPath.getChartObject().equals(indicatorPathBasedOnDefault.getChartObject())

                        changed = true;

                    }

                    if(indicatorPath.getParameters() != null) {

                        if (indicatorPathBasedOnDefault.getParameters() == null) {

                            indicatorPathBasedOnDefault.setParameters(new HashMap<>());

                        }

                        //if (indicatorPath.getParameters().size() != indicatorPathBasedOnDefault.getParameters().size()) {

                            //log.debug("Different number of parameters");

                            for (Map.Entry<String, String> parameter : indicatorPath.getParameters().entrySet()) {

                                log.debug("\nindicatorPath: parameter.getKey(): "+parameter.getKey()+" - value: "+parameter.getValue()

                                        +"\nindicatorPathBasedOnDefault:parameters:key: "+  indicatorPathBasedOnDefault.getParameters().get(parameter.getKey())

                                        +"\noldIndicatorPath:parameters:key: "+  oldIndicatorPath.getParameters().get(parameter.getKey()));

                                if (!indicatorPathBasedOnDefault.getParameters().containsKey(parameter.getKey())

                                        || (oldIndicatorPath.getParameters() == null

                                            || (oldIndicatorPath.getParameters().get(parameter.getKey()).equals(indicatorPathBasedOnDefault.getParameters().get(parameter.getKey()))

                                                && !parameter.getValue().equals(indicatorPathBasedOnDefault.getParameters().get(parameter.getKey()))))

                                ) {

                                    indicatorPathBasedOnDefault.getParameters().put(parameter.getKey(), parameter.getValue());

                                    changed = true;

                                }

//                                else if(parameter.getKey().equals("type")) {

//                                    indicatorPathBasedOnDefault.getParameters().put(parameter.getKey(), parameter.getValue());

//                                    changed = true;

//                                }

                        //}

                        log.debug("After parameters check: " + changed);

                    if(indicatorPath.getJsonPath() != null) {

                        int j = 0;

                        for (String jsonString : indicatorPath.getJsonPath()) {

                            log.debug("indicatorPath.getJsonPath(): " + jsonString);

                            String jsonStringBasedOnDefault = null;

                            if(indicatorPathBasedOnDefault.getJsonPath() != null ) {

                                jsonStringBasedOnDefault = indicatorPathBasedOnDefault.getJsonPath().get(j);

                            } else {

                                indicatorPathBasedOnDefault.setJsonPath(new ArrayList<>());

                            }

                            log.debug("indicatorPathBasedOnDefault.getJsonPath().get(" + j + "): " + jsonStringBasedOnDefault);

                            if (!jsonString.equals(jsonStringBasedOnDefault)

                                    && (oldIndicatorPath.getJsonPath() == null

                                    || oldIndicatorPath.getJsonPath().get(i).equals(jsonStringBasedOnDefault))

                            ) {

                                indicatorPathBasedOnDefault.getJsonPath().set(j, jsonString);

                                changed = true;

                            }

                            j++;

                }

                i++;

            }

                continue;

        }

    }

            if (indicatorPath.getParameters().containsKey("index_name")) {

                indicatorPath.getParameters().put("index_name", stakeholder.getIndex_name());

            } else if (indicatorPath.getParameters().containsKey("index_shortName")) {

                indicatorPath.getParameters().put("index_shortName", stakeholder.getIndex_name().toLowerCase());

            } else if (indicatorPath.getParameters().containsKey("index_id")) {

                indicatorPath.getParameters().put("index_id", stakeholder.getIndex_id());

            }

//        String url = indicatorPath.getUrl();

//        String encoded_index_id = urlEncode(URLEncoder.encode(stakeholder.getIndex_id(), "UTF-8"));

//        url = url.replace("index_id", encoded_index_id);

//        String encoded_index_name = urlEncode(URLEncoder.encode(stakeholder.getIndex_name(), "UTF-8"));

//        url = url.replace("index_name", encoded_index_name);

//        String encoded_index_shortName = urlEncode(URLEncoder.encode(stakeholder.getIndex_shortName(), "UTF-8"));

//        url = url.replace("index_shortName", encoded_index_shortName);

//        indicatorPath.setUrl(url);

        String indicatorPathField = "";

        for( int i=0; i<encodedIndicatorPathField.length(); i++ ){

            String character = encodedIndicatorPathField.substring(i, i+1);

            if(character.equals("+")) {

                indicatorPathField = indicatorPathField.concat("%20");

            } else if(character.equals("%")) {

                //grab the hex in pairs

                String output = encodedIndicatorPathField.substring(i+1, (i + 3));

                if(output.equals("7E") || output.equals("27") || output.equals("28") || output.equals("29") || output.equals("21")) {

                    //convert hex to decimal

                    int decimal = Integer.parseInt(output, 16);

                    //convert the decimal to character

                    StringBuilder sb = new StringBuilder();

                    sb.append((char) decimal);

                    indicatorPathField = indicatorPathField.concat(sb.toString());

                } else {

                    indicatorPathField = indicatorPathField.concat(character + output);

                }

                i += 2;

            } else {

                indicatorPathField = indicatorPathField.concat(character);

            }

        }

        return indicatorPathField;

    }

                                   @PathVariable("topicId") String topicId,

                                   @PathVariable("categoryId") String categoryId,

                                   @PathVariable("subcategoryId") String subcategoryId,

        log.debug("delete indicator");

        if(indicator != null) {

            Section<String> section = checkForExceptions(stakeholderId, topicId, categoryId, subcategoryId, sectionId, indicator.getType());

            if (index != -1) {

                indicators.remove(index);

                sectionDAO.save(section);

                log.debug("Indicator deleted!");

                throw new PathNotValidException("Delete indicator: Indicator with id: "+indicatorId+" not found in Sectiom: "+sectionId);

        } else {

            throw new EntityNotFoundException("Delete indicator: Indicator with id: "+indicatorId+" not found");

        return true;

    }

//    public boolean deleteAllChartIndicators(@PathVariable("stakeholderId") String stakeholderId) {

//        log.debug("delete all chart indicators of stakeholder");

//        log.debug("Stakeholder: "+stakeholderId);

//

//        Stakeholder<String> stakeholder = stakeholderDAO.findById(stakeholderId);

//        if(stakeholder != null) {

//

//            for(String topicId : stakeholder.getTopics()) {

//                Topic<String> topic = topicDAO.findById(topicId);

//                if(topic != null) {

//                    for(String categoryId : topic.getCategories()) {

//                        Category<String> category = categoryDAO.findById(categoryId);

//                        if(category != null) {

//                            for(String subcategoryId : category.getSubCategories()) {

//                                SubCategory<String> subcategory = subCategoryDAO.findById(subcategoryId);

//                                if(subcategory != null) {

//

//                                    for(String sectionId : subcategory.getCharts()) {

//                                        Section<String> section = sectionDAO.findById(sectionId);

//                                        if (section != null) {

//

//                                            List<String> indicators = section.getIndicators();

//                                            Iterator<String> indicatorsIterator = section.getIndicators().iterator();

//

//                                            while (indicatorsIterator.hasNext()) {

//                                                String indicatorId = indicatorsIterator.next();

//                                                Indicator indicator = indicatorDAO.findById(indicatorId);

//                                                if (indicator != null) {

//                                                    int index = indicators.indexOf(indicatorId);

//                                                    if (index != -1) {

//                                                        indicatorsIterator.remove();

//                                                        //indicators.remove(index);

//

//                                                        indicatorDAO.delete(indicatorId);

//                                                        log.debug("Indicator deleted!");

//                                                    } else {

//                                                        // EXCEPTION - Indicator not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias(); -> SubCategory: subcategory.getAlias(); -> Section: section.getTitle();

//                                                        throw new PathNotValidException("Delete indicator: Indicator with id: " + indicatorId + " not found in Section: " + sectionId);

//                                                    }

//                                                } else {

//                                                    // EXCEPTION - Indicator not found

//                                                    throw new EntityNotFoundException("Delete indicator: Indicator with id: " + indicatorId + " not found");

//                                                }

//                                            }

//                                            sectionDAO.save(section);

//                                        } else {

//                                            // EXCEPTION - Section not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias(); -> SubCategory: subcategory.getAlias();

//                                            throw new PathNotValidException("Delete indicator: Section with id: " + sectionId + " not found in SubCategory: " + subcategoryId);

//                                        }

//                                    }

//                                } else {

//                                    // EXCEPTION - SubCategory not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias();

//                                    throw new PathNotValidException("Delete indicator: SubCategory with id: "+subcategoryId+" not found in Category: "+categoryId);

//                                }

//                            }

//                        } else {

//                            // EXCEPTION - Category not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias();

//                            throw new PathNotValidException("Delete indicator: Category with id: "+categoryId+" not found in Topic: "+topicId);

//                        }

//                    }

//                } else {

//                    // EXCEPTION - Topic not found in Stakeholder: stakeholder.getAlias();

//                    throw new PathNotValidException("Delete indicator: Topic with id: "+topicId+" not found in Stakeholder: "+stakeholderId);

//                }

//            }

//        } else {

//            // EXCEPTION - Stakeholder not found

//            throw new EntityNotFoundException("Delete indicator: Stakeholder with id: "+stakeholderId+" not found");

//        }

//        return true;

//    }

                                             @PathVariable("categoryId") String categoryId,

                                             @PathVariable("subcategoryId") String subcategoryId,

                                             @PathVariable("sectionId") String sectionId,

                                             @PathVariable("type") String type,

                                             @RequestBody List<String> indicators) {

        log.debug("Indicators reordered!");

        for(String indicatorId : indicators) {

            indicatorsFull.add(indicatorDAO.findById(indicatorId));

        }

        return indicatorsFull;

                                         @PathVariable("topicId") String topicId,

                                         @PathVariable("categoryId") String categoryId,

                                         @PathVariable("subcategoryId") String subcategoryId,

        log.debug("toggle indicator status (isActive)");

        Indicator indicator = indicatorDAO.findById(indicatorId);

        if (indicator == null) {

            // EXCEPTION - Indicator not found

            throw new EntityNotFoundException("Toggle indicator status: Indicator with id: "+indicatorId+" not found");

        }

        indicator.setIsActive(!indicator.getIsActive());

        return indicator.getIsActive();

    }

                                         @PathVariable("topicId") String topicId,

                                         @PathVariable("categoryId") String categoryId,

                                         @PathVariable("subcategoryId") String subcategoryId,

        log.debug("toggle indicator access (isPublic)");

        Indicator indicator = indicatorDAO.findById(indicatorId);

        if (indicator == null) {

            // EXCEPTION - Indicator not found

            throw new EntityNotFoundException("Toggle indicator access: Indicator with id: "+indicatorId+" not found");

        }

        indicator.setIsPublic(!indicator.getIsPublic());

        return indicator.getIsPublic();

    }

        Section<String> section = checkForExceptions(stakeholderId, topicId, categoryId, subcategoryId, sectionId, indicator.getType());

        List<String> indicators = section.getIndicators();

        if(indicators.contains(indicator.getId())) {

            indicatorDAO.save(indicator);

            log.debug("Indicator toggled!");

        } else {

            // EXCEPTION - Indicator not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias(); -> SubCategory: subCategory.getAlias(); -> Section: section.getTitle();

            throw new PathNotValidException("Toggle indicators: Indicator with id: "+indicator.getId()+" not found in Section: "+sectionId);

        }

    }

    private Section checkForExceptions(String stakeholderId, String topicId, String categoryId, String subcategoryId, String sectionId, String indicatorType) {

            // EXCEPTION - Stakeholder not found

            throw new EntityNotFoundException("Save indicator: Stakeholder with id: " + stakeholderId + " not found");

        }

        if(topic == null) {

            // EXCEPTION - Topic not found

            throw new EntityNotFoundException("Save indicator: Topic with id: "+topicId+" not found");

        }

            // EXCEPTION - Topic not found in Stakeholder: stakeholder.getAlias();

            throw new PathNotValidException("Save indicator: Topic with id: " + topicId + " not found in Stakeholder: " + stakeholderId);

        }

        if(category == null) {

            // EXCEPTION - Category not found

            throw new EntityNotFoundException("Save indicator: Category with id: "+categoryId+" not found");

        }

            // EXCEPTION - Category not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias();

            throw new PathNotValidException("Save indicator: Category with id: "+categoryId+" not found in Topic: "+topicId);

        }

        SubCategory<String> subcategory = subCategoryDAO.findById(subcategoryId);

        if(subcategory == null) {

            // EXCEPTION - SubCategory not found

            throw new EntityNotFoundException("Save indicator: SubCategory with id: "+subcategoryId+" not found");

        }

        if (!category.getSubCategories().contains(subcategoryId)) {

            // EXCEPTION - SubCategory not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias();

            throw new PathNotValidException("Save indicator: SubCategory with id: "+subcategoryId+" not found in Category: "+categoryId);

        }

        Section<String> section = sectionDAO.findById(sectionId);

        if(section == null) {

            // EXCEPTION - Section not found

            throw new EntityNotFoundException("Save indicator: Section with id: "+sectionId+" not found");

        }

        if(indicatorType.equals("chart")) {

            if (!subcategory.getCharts().contains(sectionId)) {

                // EXCEPTION - Section not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias(); -> SubCategory: subcategory.getAlias();

                throw new PathNotValidException("Save indicator: SubCategory with id: " + subcategoryId + " not found in Category: " + categoryId);

            if (!subcategory.getNumbers().contains(sectionId)) {

                // EXCEPTION - Section not found in Stakeholder: stakeholder.getAlias(); -> Topic: topic.getAlias(); -> Category: category.getAlias(); -> SubCategory: subcategory.getAlias();

                throw new PathNotValidException("Save indicator: SubCategory with id: " + subcategoryId + " not found in Category: " + categoryId);

            }

        return  section;