D-Net

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.controllers.DivHelpContentController;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivIdDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.DivHelpContentResponse;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.DivIdResponse;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.*;

@Service

public class DivIdService {

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

    @Autowired

    private DivIdDAO divIdDAO;

    @Autowired

    private PageService pageService;

    @Autowired

    private PortalService portalService;

    @Autowired

    private DivHelpContentController divHelpContentController;

    public List<DivId> getDivIds(String page, String name, String pid) {

        Portal portal = portalService.getPortal(pid);

        String dashboardAlias = portal.getAlias();

        List<DivId> divIds = null;

        if(page != null && name != null) {

            DivId divId = divIdDAO.findByPagesContainingAndName(page, name);

            if(divId != null) {

                divIds = new ArrayList<>();

                divIds.add(divId);

            }

        } else if(page != null) {

            divIds = divIdDAO.findByPagesContaining(page);

        } else if(name != null) {

            DivId divId = divIdDAO.findByName(name);

            if(divId != null) {

                divIds = new ArrayList<>();

                divIds.add(divId);

            }

        } else {

            divIds = divIdDAO.findAll();

        }

        if(dashboardAlias != null) {

            Iterator<DivId> iteratorDivIds = divIds.iterator();

            while(iteratorDivIds.hasNext()) {

                DivId divId = iteratorDivIds.next();

                if (!dashboardAlias.equals(divId.getDashboardAlias())) {

                    iteratorDivIds.remove();

                }

            }

        }

        return divIds;

    }

    public List<DivIdResponse> getDivIdsFull(String page, String name, String pid) {

        List<DivId> divIds = this.getDivIds(page, name, pid);

        List<DivIdResponse> divIdResponses = new ArrayList<>();

        for(DivId divId : divIds) {

            DivIdResponse divIdResponse = new DivIdResponse(divId);

            List<Page> pages = new ArrayList<>();

            for(String pageId : divId.getPages()) {

                pages.add(pageService.getPage(pageId));

            }

            divIdResponse.setPages(pages);

            divIdResponses.add(divIdResponse);

        }

        return divIdResponses;

    }

    public DivId getDivIdByName(String name) {

        return divIdDAO.findByName(name);

    }

    public DivId getDivId(String id) {

        return divIdDAO.findById(id);

    }

    public DivIdResponse getDivIdFull(String id) {

        DivId divId = divIdDAO.findById(id);

        return divIdResponseFromDivId(divId);

    }

    public DivIdResponse divIdResponseFromDivId(DivId divId) {

        DivIdResponse divIdResponse = new DivIdResponse(divId);

        List<Page> pages = new ArrayList<>();

        for(String pageId : divId.getPages()) {

            pages.add(pageService.getPage(pageId));

        }

        divIdResponse.setPages(pages);

        return divIdResponse;

    }

    public void deleteAllDivIds() {

        divIdDAO.deleteAll();

    }

    public DivIdResponse insertDivId(DivIdResponse divIdResponse) {

        DivId divId = this.getDivIdByDivIdResponse(divIdResponse);

        DivId savedDivId = divIdDAO.save(divId);

        divIdResponse.setId(savedDivId.getId());

        return this.getDivIdFull(divId.getId());

    }

    private DivId getDivIdByDivIdResponse(DivIdResponse divIdResponse) {

        DivId divId = new DivId();

        divId.setId(divIdResponse.getId());

        divId.setName(divIdResponse.getName());

        divId.setDashboardAlias(divIdResponse.getDashboardAlias());

        List<Page> fullPages = divIdResponse.getPages();

        List<String> pages = new ArrayList<String>();

        for(Page page : fullPages) {

            pages.add(page.getId());

        }

        divId.setPages(pages);

        return divId;

    }

    public DivIdResponse updateDivId(DivIdResponse divIdResponse) {

//        DivId divIdOld = divIdDAO.findById(divIdResponse.getId());

//        DivId divId = this.getDivIdByDivIdResponse(divIdResponse);

//        divIdDAO.save(divId);

//

//        boolean openaireEnabled = divId.getOpenaire();

//        boolean connectEnabled = divId.getConnect();

//

//        if(divId.getCommunities() && !divIdOld.getCommunities()) {

//            List<Portal> communities = communityController.getAllPortals();

//            for( Portal community : communities ) {

//                if(!community.getPid().equals("openaire") && !community.getPid().equals("connect")) {

//                    divHelpContentController.addDivHelpContentsInPortal(community.getPid(), community.getId(), divId.getName());

//                }

//            }

//        }

//        if(openaireEnabled && !divIdOld.getOpenaire()) {

//            Portal community = communityController.getPortal("openaire");

//            divHelpContentController.addDivHelpContentsInPortal(community.getPid(), community.getId(), divId.getName());

//        }

//

//        if(connectEnabled && !divIdOld.getConnect()) {

//            Portal community = communityController.getPortal("connect");

//            divHelpContentController.addDivHelpContentsInPortal(community.getPid(), community.getId(), divId.getName());

//        }

//

//        if(!divId.getCommunities()) {

//            List<Portal> communities = communityController.getAllPortals();

//            for( Portal community : communities ) {

//                if(!community.getPid().equals("openaire") && !community.getPid().equals("connect")) {

//                    // delete div contents related to this divId

//                    List<DivHelpContentResponse> divHelpContentResponses = divHelpContentController.getDivHelpContents(community.getPid(), null, divId.getName(), null);

//                    for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

//                        divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

//                    }

//                }

//            }

//        }

//

//        if(!openaireEnabled) {

//            Portal community = communityController.getPortal("openaire");

//

//            // delete div contents related to this divId

//            List<DivHelpContentResponse> divHelpContentResponses = divHelpContentController.getDivHelpContents("openaire", null, divId.getName(), null);

//            for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

//                divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

//            }

//        }

//

//        if(!connectEnabled) {

//            Portal community = communityController.getPortal("connect");

//

//            // delete div contents related to this divId

//            List<DivHelpContentResponse> divHelpContentResponses = divHelpContentController.getDivHelpContents("connect", null, divId.getName(), null);

//            for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

//                divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

//            }

//        }

        DivId divId = this.getDivIdByDivIdResponse(divIdResponse);

        divIdDAO.save(divId);

        return divIdResponse;

    }

    public Boolean deleteDivIds(List<String> divIds) throws Exception {

        for (String id: divIds) {

            DivId divId = divIdDAO.findById(id);

            // delete div contents related to this divId

            List<DivHelpContentResponse> divHelpContentResponses = divHelpContentController.getDivHelpContents(null, null, divId.getName(), null);

            for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

                divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

            }

            divIdDAO.delete(id);

        }

        return true;

    }

    public void deleteDivId(String id) {

        divIdDAO.delete(id);

    }

    public Set<String> getDivIdsPages(String pid) {

        Portal portal = portalService.getPortal(pid);

        String dashboardAlias = portal.getAlias();

        List<DivId> divIds = null;

        Set<String> hasPortalPageDivIds = new HashSet<>();

        if(dashboardAlias != null) {

            divIds = divIdDAO.findByDashboardAlias(dashboardAlias);

        } else {

            divIds = divIdDAO.findAll();

        }

        for(DivId divId : divIds) {

            for(String pageId : divId.getPages()) {

                hasPortalPageDivIds.add(pageId);

            }

        }

        return hasPortalPageDivIds;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.PageHelpContent;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.PageHelpContentResponse;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.ArrayList;

import java.util.List;

@Service

public class PageHelpContentService {

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

    @Autowired

    private PageHelpContentDAO pageHelpContentDAO;

    @Autowired

    private PageService pageService;

    @Autowired

    private PortalService portalService;

    public List<PageHelpContentResponse> getPageHelpContents(String pid, String page, String position, String active, String before) {

        List<PageHelpContent> pageHelpContents = null;

        Portal _portal = null;

        String portalId = null;

        if(pid != null) {

            _portal = portalService.getPortal(pid);

            if(_portal != null) {

                portalId = _portal.getId();

            }

        }

        if(pid != null && position != null && active != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(portalId, position, Boolean.parseBoolean(active), Boolean.parseBoolean(before));

        } else if(pid != null && position != null && active != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndPlacementAndIsActiveOrderByOrderAsc(portalId, position, Boolean.parseBoolean(active));

        } else if(pid != null && position != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndPlacementAndIsPriorToOrderByOrderAsc(portalId, position, Boolean.parseBoolean(before));

        } else if(pid != null && active != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(portalId, Boolean.parseBoolean(active), Boolean.parseBoolean(before));

        } else if(position != null && active != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(position, Boolean.parseBoolean(active), Boolean.parseBoolean(before));

        } else if(pid != null && position != null ) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndPlacementOrderByOrderAsc(portalId, position);

        } else if(pid != null && active != null ) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndIsActiveOrderByPlacementAscOrderAsc(portalId, Boolean.parseBoolean(active));

        } else if(pid != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalAndIsPriorToOrderByPlacementAscOrderAsc(portalId, Boolean.parseBoolean(before));

        } else if(position != null && active != null) {

            pageHelpContents = pageHelpContentDAO.findByPlacementAndIsActiveOrderByOrderAsc(position, Boolean.parseBoolean(active));

        } else if(position != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByPlacementAndIsPriorToOrderByOrderAsc(position,  Boolean.parseBoolean(before));

        } else if(active != null && before != null) {

            pageHelpContents = pageHelpContentDAO.findByIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(Boolean.parseBoolean(active), Boolean.parseBoolean(before));

        } else if(pid != null) {

            pageHelpContents = pageHelpContentDAO.findByPortalOrderByPlacementAscOrderAsc(portalId);

        } else if(position != null) {

            pageHelpContents = pageHelpContentDAO.findByPlacementOrderByOrderAsc(position);

        } else if(active != null) {

            pageHelpContents = pageHelpContentDAO.findByIsActiveOrderByPlacementAscOrderAsc(Boolean.parseBoolean(active));

        } else if(before != null) {

            pageHelpContents = pageHelpContentDAO.findByIsPriorToOrderByPlacementAscOrderAsc(Boolean.parseBoolean(before));

        } else {

            pageHelpContents = pageHelpContentDAO.findAllByOrderByPlacementAscOrderAsc();

        }

        List<PageHelpContentResponse> pageHelpContentResponses = new ArrayList<>();

        for (PageHelpContent pageHelpContent : pageHelpContents) {

            Page _page = pageService.getPage(pageHelpContent.getPage());

            if(page == null || page.equals(_page.getRoute())) {

                PageHelpContentResponse pageHelpContentResponse = new PageHelpContentResponse(pageHelpContent);

                pageHelpContentResponse.setPage(_page);

                pageHelpContentResponse.setPortal(portalService.getPortalById(pageHelpContent.getPortal()));

                pageHelpContentResponses.add(pageHelpContentResponse);

            }

        }

        return pageHelpContentResponses;

    }

    public void deleteAllPageHelpContents() {

        pageHelpContentDAO.deleteAll();

    }

    public PageHelpContent insertPageHelpContent(PageHelpContent pageHelpContent) {

        String portalId = portalService.getPortal(pageHelpContent.getPortal()).getId();

        pageHelpContent.setPortal(portalId);

        return pageHelpContentDAO.save(pageHelpContent);

    }

    public PageHelpContent updatePageHelpContent(PageHelpContent pageHelpContent) {

        return pageHelpContentDAO.save(pageHelpContent);

    }

    public PageHelpContent getPageHelpContent(String id) {

        return pageHelpContentDAO.findById(id);

    }

    public List<String> togglePageHelpContent(List<String> pageHelpContents, String status) throws Exception {

        for (String id: pageHelpContents) {

            log.debug("Id of pageHelpContent: "+id);

            PageHelpContent pageHelpContent = pageHelpContentDAO.findById(id);

            pageHelpContent.setIsActive(Boolean.parseBoolean(status));

            pageHelpContentDAO.save(pageHelpContent);

        }

        return pageHelpContents;

    }

    public void deletePageHelpContent(String id) {

        pageHelpContentDAO.delete(id);

    }

    public Boolean deletePageHelpContents(List<String> pageHelpContents) throws Exception {

        for (String id: pageHelpContents) {

            pageHelpContentDAO.delete(id);

        }

        return true;

    }

    public void addPageHelpContentsInPortal(String pid, String portalId) {

        if (pid != "connect" && pid != "openaire") {

            String organizations_page_content = "<div> <p>Here you can write more details about the organizations related to your community.</p> </div>";

            Page organizationsPage = (pageService.getAllPages(null, "/organizations", null)).get(0);

            PageHelpContent organizations_pageHelpContent = new PageHelpContent(organizationsPage.getId(), pid, "top", 1, organizations_page_content, false, false);

            this.insertPageHelpContent(organizations_pageHelpContent);

            String depositLearnHow_page_content = "" +

                    "<div class=\"uk-width-3-5 uk-align-center\"> " +

                    " <div class=\"uk-text-bold\">How to comply with funder Open Access policies</div> " +

                    " <ul class=\"uk-list uk-list-bullet\"> " +

                    "   <li>Read the <a class=\"custom-external\" href=\"https://www.openaire.eu/how-to-comply-to-h2020-mandates-for-publications\" target=\"_blank\"> OpenAIRE guide to learn how to comply with EC H2020 Open Access policy on publications </a></li> " +

                    "   <li>Read the <a class=\"custom-external\" href=\"https://www.openaire.eu/how-to-comply-to-h2020-mandates-for-data\" target=\"_blank\"> OpenAIRE guide to learn how to comply with EC H2020 Open Access policy on research data </a></li> " +

                    "   <li>If you want to know about National Open Access policies, please check them out <a class=\"custom-external\" href=\"https://www.openaire.eu/frontpage/country-pages\" target=\"_blank\">here</a></li> " +

                    "   <li>All OpenAIRE guides can be found <a class=\"custom-external\" href=\"https://www.openaire.eu/guides\" target=\"_blank\">here</a></li> " +

                    " </ul> " +

                    "</div>";

            Page depositLearnHowPage = (pageService.getAllPages(null, "/participate/deposit/learn-how", null)).get(0);

            PageHelpContent depositLearnHow_pageHelpContent = new PageHelpContent(depositLearnHowPage.getId(), pid, "bottom", 1, depositLearnHow_page_content, true, false);

            this.insertPageHelpContent(depositLearnHow_pageHelpContent);

        }

    }

}

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.dao.PortalDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.*;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.*;

@Service

public class PortalService {

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

    @Autowired

    private PortalDAO portalDAO;

    @Autowired

    private PageService pageService;

    @Autowired

    private EntityService entityService;

    @Autowired

    private DivIdService divIdService;

    @Autowired

    private PageHelpContentService pageHelpContentService;

    @Autowired

    private DivHelpContentService divHelpContentService;

    public List<Portal> getAllPortals() {

        List<Portal> portals = portalDAO.findAll();

        return portals;

    }

    public List<PortalResponse> getAllPortalsFull() {

        List<Portal> portals = portalDAO.findAll();

        List<PortalResponse> portalsResponse = new ArrayList<>();

        for(Portal portal : portals) {

            PortalResponse portalResponse = new PortalResponse(portal);

            setEnabledPagesForPortalByType(portal, portalResponse);

            setEnabledEntitiesForPortalByType(portal, portalResponse);

            //Layout layout = layoutDAO.findById(portal.getLayout());

            //portalResponse.setLayout(layout);

            portalsResponse.add(portalResponse);

        }

        return portalsResponse;

    }

    private void setEnabledPagesForPortalByType(Portal portal, PortalResponse portalResponse) {

        List<PortalPage> pages = this.getPagesForPortalByType(portal.getPid(), null, null, null);

        log.debug("PAGES number="+pages.size());

        Iterator<PortalPage> iteratorPages = pages.iterator();

        while(iteratorPages.hasNext()) {

            PortalPage page = iteratorPages.next();

            if(!page.getIsEnabled()) {

                iteratorPages.remove();

            }

        }

        portalResponse.setPages(pages);

        log.debug("PAGES set");

    }

    private void setEnabledEntitiesForPortalByType(Portal portal, PortalResponse portalResponse) {

        List<PortalEntity> entities = this.getEntitiesForPortal(portal.getPid(), null);

        log.debug("ENTITIES number="+entities.size());

        Iterator<PortalEntity> iteratorEntities = entities.iterator();

        while(iteratorEntities.hasNext()) {

            PortalEntity entity = iteratorEntities.next();

            if(!entity.getIsEnabled()) {

                iteratorEntities.remove();

            }

        }

        portalResponse.setEntities(entities);

        log.debug("ENTITIES set");

    }

    public PortalResponse getPortalFull(String pid) {

        Portal portal = portalDAO.findByPid(pid);

        PortalResponse portalResponse = new PortalResponse(portal);

        setEnabledPagesForPortalByType(portal, portalResponse);

        setEnabledEntitiesForPortalByType(portal, portalResponse);

        //Layout layout = layoutDAO.findById(portal.getLayout());

        //portalResponse.setLayout(layout);

        return portalResponse;

    }

    public PortalResponse updatePortal(Portal portal) {

        Portal com = portalDAO.findById(portal.getId());

//        Statistics statistics = statisticsDAO.findByPid(com.getPid());

//        statistics.setPid(portal.getPid());

//        statisticsDAO.save(statistics);

//

//        PortalSubscribers portalSubscribers =  communitySubscribersDAO.findByPid(com.getPid());

//        portalSubscribers.setPid(portal.getPid());

//        communitySubscribersDAO.save(portalSubscribers);

        com.setName(portal.getName());

        com.setPid(portal.getPid());

        portalDAO.save(com);

        PortalResponse portalResponse = this.getPortalFull(portal.getPid());

        return portalResponse;

    }

    public PortalResponse insertPortal(Portal portal) {

        List<PortalEntity> portalEntities = new ArrayList<>();

        List<PortalPage> portalPages = new ArrayList<>();

        Map<String, Boolean> entities = new HashMap<>();

        Map<String, Boolean> pages = new HashMap<>();

        for(Entity entity : entityService.getAllEntities()) {

            entities.put(entity.getId(), true);

            PortalEntity portalEntity = new PortalEntity(entity);

            portalEntity.setIsEnabled(true);

            portalEntities.add(portalEntity);

        }

        for(Page page : pageService.getAllPages(null, null, null)) {

            pages.put(page.getId(), true);

            PortalPage portalPage = new PortalPage(page);

            if(page.getRoute().equals("/curators") || page.getRoute().equals("/organizations")) {

                portalPage.setIsEnabled(false);

            } else {

                portalPage.setIsEnabled(true);

            }

            portalPages.add(portalPage);

        }

        portal.setEntities(entities);

        portal.setPages(pages);

//        Statistics statistics =  new Statistics(portal.getPid());

//        statisticsDAO.save(statistics);

//        PortalSubscribers portalSubscribers =  new PortalSubscribers(portal.getPid());

//        communitySubscribersDAO.save(portalSubscribers);

        Portal savedPortal = portalDAO.save(portal);

        PortalResponse portalResponse = this.getPortalFull(savedPortal.getPid());

        log.debug("pid of saved portal: "+ savedPortal.getPid());

        String id = savedPortal.getId();

        divHelpContentService.addDivHelpContentsInPortal(savedPortal.getPid(), id, null);

        pageHelpContentService.addPageHelpContentsInPortal(savedPortal.getPid(), id);

        return portalResponse;

    }

    private Portal getPortalByPortalResponse(PortalResponse portalResponse) {

        Portal portal = new Portal();

        portal.setId(portalResponse.getId());

        portal.setName(portalResponse.getName());

        List<PortalEntity> fullEntities = portalResponse.getEntities();

        Map<String, Boolean> entities = new HashMap<String, Boolean>();

        for(PortalEntity entity : fullEntities) {

            entities.put(entity.getId(), true);

        }

        for(Entity entity : entityService.getAllEntities()) {

            if(!entities.containsKey(entity.getId())) {

                entities.put(entity.getId(), false);

            }

        }

        portal.setEntities(entities);

        List<PortalPage> fullPages = portalResponse.getPages();

        Map<String, Boolean> pages = new HashMap<String, Boolean>();

        for(PortalPage page : fullPages) {

            pages.put(page.getId(), true);

        }

        for(Page page : pageService.getAllPages(null, null, null)) {

            if(!pages.containsKey(page.getId())) {

                pages.put(page.getId(), false);

            }

        }

        portal.setPages(pages);

//        Layout layout = portalResponse.getLayout();

//        portal.setLayout(layout.getId());

        return portal;

    }

    public Boolean deletePortals(List<String> portals) throws Exception {

        for (String id: portals) {

            Portal portal = portalDAO.findById(id);

            String pid = portal.getPid();

            // delete div contents related to this portal

            List<DivHelpContentResponse> divHelpContentResponses = divHelpContentService.getDivHelpContents(pid, null, null, null);

            for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

                divHelpContentService.deleteDivHelpContent(divHelpContentResponse.getId());

            }

            // delete page contents related to this portal

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentService.getPageHelpContents(pid, null,null, null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentService.deletePageHelpContent(pageHelpContentResponse.getId());

            }

//            Statistics stats = statisticsDAO.findByPid(pid);

//            if(stats != null) {

//                statisticsDAO.delete(stats.getId());

//            }

//

//            PortalSubscribers portalSubscribers = communitySubscribersDAO.findByPid(pid);

//            if(portalSubscribers != null) {

//                communitySubscribersDAO.delete(portalSubscribers.getId());

//            }

//

//            Layout layout = layoutDAO.findById(portal.getLayout());

//            if(layout != null) {

//                layoutDAO.delete(layout.getId());

//            }

            portalDAO.delete(id);

        }

        return true;

    }

    public Portal insertOrUpdatePortal(Portal portal) {

        return portalDAO.save(portal);

    }

    public Portal getPortalById(String id) {

        log.debug("ID: "+ id);

        return portalDAO.findById(id);

    }

    public Portal getPortal(String pid) {

        log.debug("PID: "+ pid);

        return portalDAO.findByPid(pid);

    }

    public void deletePortal(String id) {

        portalDAO.delete(id);

    }

    public List<PortalPage> getPagesForPortalByType(String pid, String page_type, String page_route, String div) {

        List<PortalPage> return_pages = new ArrayList<PortalPage>();

        Portal portal = portalDAO.findByPid(pid);

        Map<String, Boolean> pages = portal.getPages();

        if(pages != null) {

            for (Map.Entry<String, Boolean> page : pages.entrySet()) {

                if(div != null && div.equals("true")) {

                    List<DivId> divIds = divIdService.getDivIds(page.getKey(), null, null);

                    Iterator<DivId> divIdIterator = divIds.iterator();

                    while (divIdIterator.hasNext()) {

                        DivId divId = divIdIterator.next();

                        if(!portal.getAlias().equals(divId.getDashboardAlias())) {

                            divIdIterator.remove();

                        }

                    }

                    if(divIds.isEmpty()) {

                        continue;

                    }

                }

                Page p = pageService.getPage(page.getKey());

                if(portal.getAlias().equals(p.getDashboardAlias())) {

                    if ((page_type == null && page_route == null) || (page_route == null && p.getType().equals(page_type))

                            || p.getRoute().equals(page_route)) {

                        PortalPage portalPage = new PortalPage(p);

                        List<Entity> entities = new ArrayList<>();

                        for (String entity : p.getEntities()) {

                            entities.add(entityService.getEntity(entity));

                        }

                        portalPage.setEntities(entities);

                        portalPage.setIsEnabled(page.getValue());

                        return_pages.add(portalPage);

                        if (page_route != null) {

                            break;

                        }

                    }

                }

            }

        }

        return_pages.sort(Comparator.comparing(PortalPage::getName));

        return return_pages;

    }

    public Portal insertOrUpdatePage(String id, PortalPage page) {

        Portal portal = portalDAO.findById(id);

        Map<String, Boolean> pages = portal.getPages();

        String name = page.getName();

        boolean isEnabled = page.getIsEnabled();

        pages.put(name, isEnabled);

        portal.setPages(pages);

        return portalDAO.save(portal);

    }

    public Portal togglePage(String pid, List<String> pageIds, String status) throws Exception {

        Portal portal = portalDAO.findByPid(pid);

        Map<String, Boolean> pages = portal.getPages();

        for (String pageId: pageIds) {

            log.debug("Toggle portal page: " + pageId + " of portal: " + pid + " to " + status);

            pages.put(pageId, Boolean.parseBoolean(status));

        }

        portal.setPages(pages);

        return portalDAO.save(portal);

    }

    public Portal toggleEntity(String pid, List<String> entityIds, String status) throws Exception {

        Portal portal = portalDAO.findByPid(pid);

        Map<String, Boolean> entities = portal.getEntities();

        Map<String, Boolean> pages = portal.getPages();

        for (String entityId: entityIds) {

            log.debug("Toggle portal entity: " + entityId + " of portal: " + pid + " to " + status);

            entities.put(entityId, Boolean.parseBoolean(status));

            if(pages != null) {

                for (Map.Entry<String, Boolean> pageEntry : pages.entrySet()) {

                    Page page = pageService.getPage(pageEntry.getKey());

                    if (page.getEntities().contains(entityId) && page.getType().equals("search")) {

                        pages.put(pageEntry.getKey(), Boolean.parseBoolean(status));

                    }

                }

            }

        }

        portal.setEntities(entities);

        return portalDAO.save(portal);

    }

    public List<PortalEntity> getEntitiesForPortal(String pid, String entity) {

        List<PortalEntity> return_entities = new ArrayList<PortalEntity>();

        Map<String, Boolean> entities = portalDAO.findByPid(pid).getEntities();

        //log.debug("/portal/"+pid+"/entities -- entity: "+entity);

        if (entity != null) {

            Entity _entity = entityService.getEntityByPid(entity);

            String entityId = _entity.getId();

            PortalEntity portalEntity = new PortalEntity(_entity);

            portalEntity.setIsEnabled(entities.get(entityId));

            return_entities.add(portalEntity);

        } else {

            if(entities != null) {

                for (Map.Entry<String, Boolean> _entity : entities.entrySet()) {

                    PortalEntity portalEntity = new PortalEntity(entityService.getEntity(_entity.getKey()));

                    portalEntity.setIsEnabled(_entity.getValue());

                    return_entities.add(portalEntity);

                }

            }

        }

        return return_entities;

    }

//    @RequestMapping(value = "/community/{pid}/layout", method = RequestMethod.GET)

//    public Layout getLayoutForCommunity(@PathVariable(value = "pid") String pid) {

//        Portal portal = portalDAO.findByPid(pid);

//        if(portal.getLayout() != null) {

//            return layoutDAO.findById(portal.getLayout());

//        } else {

//            return null;

//        }

//    }

//    @RequestMapping(value = "/community/{pid}/layout", method = RequestMethod.POST)

//    public Layout updateLayoutForCommunity(@PathVariable(value = "pid") String pid, @RequestBody Layout layout) {

//        Portal portal = portalDAO.findByPid(pid);

//        if(portal.getLayout() != null) {

//            layout.setId(portal.getLayout());

//            layout = layoutDAO.save(layout);

//        } else {

//            layout = layoutDAO.save(layout);

//            portal.setLayout(layout.getId());

//            portalDAO.save(portal);

//        }

//        return layout;

//    }

    public Map<String, List<PageHelpContentResponse>> getPageHelpContentsByPosition(String pid, String page, String active) {

        Map<String, List<PageHelpContentResponse>> pageHelpContentResponses = new HashMap<>();

        List<PageHelpContentResponse> pageHelpContents = null;

        pageHelpContents = pageHelpContentService.getPageHelpContents(pid, page, null, active, null);

        pageHelpContentResponses.put("top", new ArrayList<>());

        pageHelpContentResponses.put("bottom", new ArrayList<>());

        pageHelpContentResponses.put("left", new ArrayList<>());

        pageHelpContentResponses.put("right", new ArrayList<>());

        for (PageHelpContentResponse pageHelpContentResponse : pageHelpContents) {

            pageHelpContentResponses.get(pageHelpContentResponse.getPlacement()).add(pageHelpContentResponse);

        }

        return pageHelpContentResponses;

    }

    public Map<String, List<DivHelpContentResponse>> getDivHelpContentsByPosition(String pid, String page, String active) {

        Map<String, List<DivHelpContentResponse>> divHelpContentResponses = new HashMap<>();

        List<DivHelpContentResponse> divHelpContents = null;

        divHelpContents = divHelpContentService.getDivHelpContents(pid, page, null, active);

        for (DivHelpContentResponse divHelpContentResponse : divHelpContents) {

            if(!divHelpContentResponses.containsKey(divHelpContentResponse.getDivId())) {

                divHelpContentResponses.put(divHelpContentResponse.getDivId().getName(), new ArrayList<>());

            }

            divHelpContentResponses.get(divHelpContentResponse.getDivId().getName()).add(divHelpContentResponse);

        }

        return divHelpContentResponses;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivHelpContent;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.DivHelpContentResponse;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.DivIdResponse;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.ArrayList;

import java.util.List;

@Service

public class DivHelpContentService {

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

    @Autowired

    private DivHelpContentDAO divHelpContentDAO;

    @Autowired

    DivIdService divIdService;

    @Autowired

    private PortalService portalService;

    public List<DivHelpContentResponse> getDivHelpContents(String pid, String page, String div, String active) {

        Portal _portal = portalService.getPortal(pid);

        String portalId = null;

        if(_portal != null) {

            portalId = _portal.getId();

        }

        DivId divId = divIdService.getDivIdByName(div);

        String divIdId = null;

        if(divId != null) {

            divIdId = divId.getId();

        }

        List<DivHelpContentResponse> divHelpContentResponses = new ArrayList<>();

        List<DivHelpContent> divHelpContents = null;

        if(pid != null && div != null && active != null) {

            divHelpContents = divHelpContentDAO.findByPortalAndDivIdAndIsActive(portalId, divIdId, Boolean.parseBoolean(active));

        } else if(pid != null && div != null) {

            divHelpContents = divHelpContentDAO.findByPortalAndDivId(portalId, divIdId);

        } else if(pid != null && active != null) {

            divHelpContents = divHelpContentDAO.findByPortalAndIsActive(portalId, Boolean.parseBoolean(active));

        } else if(div != null && active != null) {

            divHelpContents = divHelpContentDAO.findByDivIdAndIsActive(divIdId, Boolean.parseBoolean(active));

        } else if(pid != null) {

            divHelpContents = divHelpContentDAO.findByPortal(portalId);

        } else if(div != null) {

            divHelpContents = divHelpContentDAO.findByDivId(divIdId);

        } else if(active != null){

            divHelpContents = divHelpContentDAO.findByIsActive(Boolean.parseBoolean(active));

        } else {

            divHelpContents = divHelpContentDAO.findAll();

        }

        for (DivHelpContent divHelpContent : divHelpContents) {

            DivIdResponse divIdResponse = null;

            if(div == null) {

                divId = divIdService.getDivId(divHelpContent.getDivId());

            }

            divIdResponse = divIdService.divIdResponseFromDivId(divId);

            if(pid == null) {

                _portal = portalService.getPortalById(divHelpContent.getPortal());

            }

            for(Page p : divIdResponse.getPages()) {

                if (page == null || p.getRoute().equals(page)) {

                    DivHelpContentResponse divHelpContentResponse = new DivHelpContentResponse(divHelpContent);

                    divHelpContentResponse.setDivId(divIdResponse);

                    divHelpContentResponse.setPortal(_portal);

                    divHelpContentResponses.add(divHelpContentResponse);

                    break;

                }

            }

        }

        return divHelpContentResponses;

    }

    public DivHelpContent getDivHelpContent(String id) {

        return divHelpContentDAO.findById(id);

    }

    public DivHelpContent insertOrUpdateDivHelpContent(DivHelpContent divHelpContent) {

        return divHelpContentDAO.save(divHelpContent);

    }

    public void deleteDivHelpContent(String id) {

        divHelpContentDAO.delete(id);

    }

    public Boolean deleteDivHelpContents(List<String> divHelpContents) throws Exception {

        for (String id: divHelpContents) {

            divHelpContentDAO.delete(id);

        }

        return true;

    }

    public List<String> toggleDivHelpContent(List<String> divHelpContents, String status) throws Exception {

        for (String id: divHelpContents) {

            log.debug("Id of divHelpContent: "+id);

            DivHelpContent divHelpContent = divHelpContentDAO.findById(id);

            divHelpContent.setIsActive(Boolean.parseBoolean(status));

            divHelpContentDAO.save(divHelpContent);

        }

        return divHelpContents;

    }

    public void addDivHelpContentsInPortal(String pid, String portalId, String divIdName) {

        Portal portal = portalService.getPortal(pid);

        String dashboardAlias = portal.getAlias();

        //String organizations_class_content = "<div> <p>Here you can write more details about the organizations related to your portal.</p> </div>";

        String link_context_form_content = "<div> <div><span class=\"uk-text-bold\"><span uk-icon=\"icon: info\">&nbsp;</span> Information:</span> Select a research portal and/or a category and search for a portal concept, or browse to the portal tree through the categories</div> </div>";

        String link_project_form_content = "<div> <div><span class=\"uk-text-bold\"><span uk-icon=\"icon: info\">&nbsp;</span> Information:</span> Search for projects using project name or grant id. Limit results filtering by funder.</div> </div>";

        String link_result_form_content = "<div> <div><span class=\"uk-text-bold\"><span uk-icon=\"icon: info\">&nbsp;</span> Information:</span></div> Search for research results in OpenAIRE information space, Datacite, CrossRef or ORCID. <div class=\"uk-text-small\">Use keywords, DOI (more than one - space separated), author&#39;s ORCID</div> </div>";

        String link_result_bulk_content = "<div> <div><span class=\"uk-text-bold\"><span uk-icon=\"icon: info\">&nbsp;</span> Information:</span> Upload a csv file containing a list of DOIs. For each DOI found in the file, metadata will be fetched from CrossRef or Datacite and will be added to your selected research results.</div> <div class=\"uk-margin-top uk-text-small\"><span class=\"uk-text-bold\">CSV format:</span> <ul class=\"uk-list\"> <li>The format of CSV file should be &quot;DOI&quot;,&quot;ACCESS_MODE&quot;,&quot;DATE&quot;.</li> <li>The value &quot;DOI&quot; is required</li> <li>Access mode column should have values: &quot;OPEN&quot;,&quot;CLOSED&quot; or &quot;EMBARGO&quot;.</li> <li>Date column valid format is YYYY-MM-DD and is required when access mode has value EMBARGO.</li> <li>In case access mode is not available default value is &quot;OPEN&quot;.</li> </ul> </div> </div>";

        String link_metadata_content = "<div> <div><span class=\"uk-text-bold\"><span uk-icon=\"icon: info\">&nbsp;</span> Information:</span> Manage access mode &amp; type of selected research results. For OpenAIRE this functionality isn&#39;t available.</div> </div>";

        List<DivId> divIds = divIdService.getDivIds(null, divIdName, null);

        for( DivId div : divIds ) {

            if (div != null && div.getDashboardAlias().equals(dashboardAlias) ) {

//                    (div.getOpenaire() && pid.equals("openaire")) ||

//                            (div.getConnect() && pid.equals("connect")) ||

//                            (div.getCommunities() && !pid.equals("openaire") && !pid.equals("connect"))

//            )) {

                /*

                if (div.getName().equals("organizations")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, organizations_class_content, false));

                } else

                */

                if (div.getName().equals("link-context-form")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, link_context_form_content, false));

                } else if (div.getName().equals("link-project-form")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, link_project_form_content, false));

                } else if (div.getName().equals("link-result-form")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, link_result_form_content, false));

                } else if (div.getName().equals("link-result-bulk")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, link_result_bulk_content, false));

                } else if (div.getName().equals("link-metadata")) {

                    this.insertOrUpdateDivHelpContent(new DivHelpContent(div.getId(), portalId, link_metadata_content, false));

                }

            }

        }

    }

}

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.dao.EntityDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.PortalEntity;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.List;

import java.util.Map;

@Service

public class EntityService {

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

    @Autowired

    private EntityDAO entityDAO;

    @Autowired

    private PageService pageService;

    @Autowired

    private PortalService portalService;

    public List<Entity> getAllEntities() {

        return entityDAO.findAll();

    }

    public void deleteAllEntities() {

        entityDAO.deleteAll();

    }

    public Entity insertOrUpdateEntity(Entity entity) {

        return entityDAO.save(entity);

    }

    public Entity getEntity(String id) {

        return entityDAO.findById(id);

    }

    public Entity getEntityByPid(String pid) {

        return entityDAO.findByPid(pid);

    }

    public void deleteEntity(String id) {

        entityDAO.delete(id);

    }

    public PortalEntity updateEntity(PortalEntity portalEntity) {

        Entity entity = this.getEntityByPortalEntity(portalEntity);

        entityDAO.save(entity);

        return portalEntity;

    }

    public PortalEntity insertEntity(Entity entity) {

        Entity savedEntity = entityDAO.save(entity);

        PortalEntity portalEntity = new PortalEntity(savedEntity);

        // add entity in portals

        List<Portal> portals = portalService.getAllPortals();

        for( Portal portal : portals ) {

            Map<String, Boolean> entities = portal.getEntities();

            entities.put(entity.getId(), true);

            portal.setEntities(entities);

            portalService.insertOrUpdatePortal(portal);

        }

        return portalEntity;

    }

    private Entity getEntityByPortalEntity(PortalEntity portalEntity) {

        Entity entity = new Entity();

        entity.setId(portalEntity.getId());

        entity.setPid(portalEntity.getPid());

        entity.setName(portalEntity.getName());

        return entity;

    }

    public Boolean deleteEntities(List<String> entities) throws Exception {

        for (String id: entities) {

            entityDAO.delete(id);

            // delete entity from portals

            List<Portal> portals = portalService.getAllPortals();

            for( Portal portal : portals ) {

                Map<String, Boolean> portalEntities = portal.getEntities();

                portalEntities.remove(id);

                portal.setEntities(portalEntities);

                portalService.insertOrUpdatePortal(portal);

            }

            // delete entity from pages

            List<Page> pages = pageService.getAllPages(null, null, null);

            for( Page page : pages ) {

                List<String> pageEntities = page.getEntities();

                int index = 0;

                for(String pageEntity : pageEntities) {

                    if(pageEntity == id) {

                        pageEntities.remove(index);

                        break;

                    }

                    index++;

                }

                page.setEntities(pageEntities);

                pageService.insertOrUpdatePage(page);

            }

        }

        return true;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.services;

import eu.dnetlib.uoaadmintoolslibrary.controllers.DivHelpContentController;

import eu.dnetlib.uoaadmintoolslibrary.controllers.DivIdController;

import eu.dnetlib.uoaadmintoolslibrary.controllers.EntityController;

import eu.dnetlib.uoaadmintoolslibrary.controllers.PageHelpContentController;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivIdDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.Portal;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.DivHelpContentResponse;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.PageHelpContentResponse;

import eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities.PortalPage;

import org.apache.log4j.Logger;

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

import org.springframework.stereotype.Service;

import java.util.*;

@Service

public class PageService {

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

    @Autowired

    private PageDAO pageDAO;

    @Autowired

    private PortalService portalService;

    @Autowired

    private DivIdDAO divIdDAO;

    @Autowired

    private PageHelpContentController pageHelpContentController;

    @Autowired

    private DivHelpContentController divHelpContentController;

    @Autowired

    private DivIdController divIdController;

    @Autowired

    private EntityController entityController;

    public List<PortalPage> getPagesFull(String pid, String page_route) {

        List<Page> pages = this.getAllPages(pid, page_route, null);

        List<PortalPage> portalPages = new ArrayList<>();

        for(Page page : pages) {

            PortalPage portalPage = new PortalPage(page);

            List<Entity> entities = new ArrayList<>();

            for(String entityId : page.getEntities()) {

                entities.add(entityController.getEntity(entityId));

            }

            portalPage.setEntities(entities);

            portalPages.add(portalPage);

        }

        return portalPages;

    }

    public List<Page> getAllPages(String pid, String page_route, String with_positions) {

        List<Page> pages;

        if (pid != null) {

            Portal portal = portalService.getPortal(pid);

            String dashboardAlias = portal.getAlias();

            if (page_route != null) {

                pages = new ArrayList<Page>();

                pages.add(pageDAO.findByDashboardAliasAndRoute(dashboardAlias, page_route));

            } else {

                pages = pageDAO.findByDashboardAlias(dashboardAlias);

            }

        } else if (page_route != null) {

            pages = pageDAO.findByRoute(page_route);

        } else {

            pages = pageDAO.findAll();

        }

        if (with_positions != null) {

            boolean at_least_one_position = Boolean.parseBoolean(with_positions);

            Iterator<Page> iteratorPages = pages.iterator();

            while(iteratorPages.hasNext()) {

                Page page = iteratorPages.next();

                if(at_least_one_position) {

                    if(!page.getTop() && !page.getBottom() && !page.getLeft() && !page.getRight()) {

                        iteratorPages.remove();

                    }

                } else {

                    if(page.getTop() || page.getBottom() || page.getLeft() || page.getRight()) {

                        iteratorPages.remove();

                    }

                }

            }

        }

        pages.sort(Comparator.comparing(Page::getName));

        return pages;

    }

    public void deleteAllPages() {

        pageDAO.deleteAll();

    }

    public Page insertOrUpdatePage(Page page) {

        return pageDAO.save(page);

    }

    public PortalPage updatePage(PortalPage portalPage) {

        this.deletePageHelpContentsForPositionsIfDisabled(portalPage);

        Page page = this.getPageByPortalPage(portalPage);

        pageDAO.save(page);

        return portalPage;

    }

    public PortalPage insertPage(PortalPage portalPage) {

        Page page = this.getPageByPortalPage(portalPage);

        Page savedPage = pageDAO.save(page);

        portalPage.setId(savedPage.getId());

        // add page in portals

        List<Portal> portals = portalService.getAllPortals();

        for( Portal portal : portals ) {

            Map<String, Boolean> pages = portal.getPages();

            pages.put(page.getId(), true);

            portal.setPages(pages);

            portalService.insertOrUpdatePortal(portal);

        }

        return portalPage;

    }

    private Page getPageByPortalPage(PortalPage portalPage) {

        Page page = new Page();

        page.setId(portalPage.getId());

        page.setRoute(portalPage.getRoute());

        page.setName(portalPage.getName());

        page.setType(portalPage.getType());

        page.setDashboardAlias(portalPage.getDashboardAlias());

        page.setTop(portalPage.getTop());

        page.setBottom(portalPage.getBottom());

        page.setLeft(portalPage.getLeft());

        page.setRight(portalPage.getRight());

        List<Entity> fullEntities = portalPage.getEntities();

        List<String> entities = new ArrayList<String>();

        for(Entity entity : fullEntities) {

            entities.add(entity.getId());

        }

        page.setEntities(entities);

        return page;

    }

    private void deletePageHelpContentsForPositionsIfDisabled(PortalPage portalPage) {

        if(!portalPage.getTop()) {

            // delete page contents with position "top" related to this page from all portals

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentController.getPageHelpContents(null, portalPage.getRoute(), "top", null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!portalPage.getBottom()) {

            // delete page contents with position "bottom" related to this page from all portals

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentController.getPageHelpContents(null, portalPage.getRoute(), "bottom", null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!portalPage.getLeft()) {

            // delete page contents with position "left" related to this page from all portals

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentController.getPageHelpContents(null, portalPage.getRoute(), "left", null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!portalPage.getRight()) {

            // delete page contents with position "right" related to this page from all portals

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentController.getPageHelpContents(null, portalPage.getRoute(), "right", null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

    }

    public Boolean deletePages(List<String> pages) throws Exception {

        for (String id: pages) {

            pageDAO.delete(id);

            // delete divIds related only to this page from all portals, otherwise remove this page from divIds

            List<DivId> divIds = divIdController.getDivIds(id, null, null);

            for(DivId divId : divIds) {

                if(divId.getPages().size() == 1) {

                    divIdController.deleteDivId(divId.getId());

                    // delete div contents related to this page from all portals

                    List<DivHelpContentResponse> divHelpContentResponses = divHelpContentController.getDivHelpContents(null, id, divId.getId(), null);

                    for (DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

                        divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

                    }

                } else {

                    List<String> divIdPages = divId.getPages();

                    divIdPages.remove(id);

                    divId.setPages(divIdPages);

                    divIdDAO.save(divId);

                }

            }

            // delete page contents related to this page from all portals

            List<PageHelpContentResponse> pageHelpContentResponses = pageHelpContentController.getPageHelpContents(null, id, null, null, null);

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

            // delete page from portals

            List<Portal> portals = portalService.getAllPortals();

            for( Portal portal : portals ) {

                Map<String, Boolean> portalPages = portal.getPages();

                portalPages.remove(id);

                portal.setPages(portalPages);

                portalService.insertOrUpdatePortal(portal);

            }

        }

        return true;

    }

    public Page getPage(String id) {

        return pageDAO.findById(id);

    }

    public void deletePage(String id) {

        pageDAO.delete(id);

    }

    public List<String> getPageEntities(String id) {

        return pageDAO.findById(id).getEntities();

    }

    public Page togglePageEntity(String id, String entityId, String status) throws Exception {

        log.debug("Toggle entity : "+entityId +" of page: "+id+" to "+status);

        Page page = pageDAO.findById(id);

        List<String> entities = page.getEntities();

        if(Boolean.parseBoolean(status) && !entities.contains(entityId)) {

            entities.add(entityId);

        } else if (!Boolean.parseBoolean(status)) {

            entities.remove(entityId);

        }

        page.setEntities(entities);

        return pageDAO.save(page);

    }

}