D-Net

package eu.dnetlib.uoaadmintoolslibrary.configuration.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("admintoolslibrary.google")

public class GoogleConfig {

    private String secret;

    public String getSecret() {

        return secret;

    }

    public void setSecret(String secret) {

        this.secret = secret;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.emailSender;

import org.apache.log4j.Logger;

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

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

import org.springframework.stereotype.Service;

import javax.mail.*;

import javax.mail.internet.AddressException;

import javax.mail.internet.InternetAddress;

import javax.mail.internet.MimeMessage;

import java.util.List;

import java.util.Properties;

import eu.dnetlib.uoaadmintoolslibrary.configuration.properties.MailConfig;

@Service

@Configurable

public class EmailSender {

    private static final Logger logger = Logger.getLogger(EmailSender.class);

    @Autowired

    private MailConfig mailConfig;

    public boolean send(List<String> recipients, String subject, String body, Boolean bcc) {

        // Get system properties

        Properties properties = System.getProperties();

        properties.setProperty("mail.smtp.host", mailConfig.getHost());

        properties.put("mail.smtp.port", mailConfig.getPort());

        properties.put("mail.smtp.auth", mailConfig.getAuth()); //enable authentication

        properties.put("mail.smtp.starttls.enable", "true");

        logger.debug("Try to connect to mail sender with "+ mailConfig.getUsername());

        Session session = Session.getInstance(properties,

                new javax.mail.Authenticator() {

                    protected PasswordAuthentication getPasswordAuthentication() {

                        return new PasswordAuthentication(mailConfig.getUsername(), mailConfig.getPassword());

                    }

                });

        try {

            logger.debug("Try to sent e-mail to "+recipients.toString()+

                    "\nSubject: "+subject+

                    "\nBody:"+body);

            // Create a default MimeMessage object.

            MimeMessage message = new MimeMessage(session);

            // Set From: header field of the header.

            message.setFrom(new InternetAddress(mailConfig.getFrom()));

            // Set To: header field of the header.

            if(!bcc) {

                for (String to : recipients) {

                    message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

                }

            }else{

                for (String to : recipients) {

                    message.addRecipient(Message.RecipientType.BCC, new InternetAddress(to));

                }

            }

            message.addRecipient(Message.RecipientType.BCC, new InternetAddress("openaire.test@gmail.com"));

            // Set Subject: header field

            message.setSubject(subject);

            // For simple text setText() can be used instead of setContent()

            // Send the actual HTML message, as big as you like

            message.setContent(body, "text/html");

            // Send message

            Transport.send(message);

            logger.debug("Sent message successfully....\n");

            return true;

        } catch (AddressException ae) {

            logger.error("Email could not be send.", ae);

            return false;

        } catch (MessagingException me) {

            logger.error("Email could not be send.", me);

            return false;

        }

    }

}

package eu.dnetlib.uoaadmintoolslibrary.entities.fullEntities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

public class DivIdResponse {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    private List<Page> pages;

    private Boolean connect;

    private Boolean communities;

    private Boolean openaire;

    public DivIdResponse() {}

    public DivIdResponse(DivId divId) {

        this.id = divId.getId();

        this.name = divId.getName();

        setConnect(divId.getConnect());

        setCommunities(divId.getCommunities());

        setOpenaire(divId.getOpenaire());

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public List<Page> getPages() {

        return pages;

    }

    public void setPages(List<Page> pages) {

        this.pages = pages;

    }

    public Boolean getConnect() {

        return connect;

    }

    public void setConnect(Boolean connect) { this.connect = connect; }

    public Boolean getCommunities() { return communities; }

    public void setCommunities(Boolean communities) {

        this.communities = communities;

    }

    public Boolean getOpenaire() {

        return openaire;

    }

    public void setOpenaire(Boolean openaire) {

        this.openaire = openaire;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.handlers;

import org.springframework.http.HttpStatus;

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

@ResponseStatus(HttpStatus.NOT_ACCEPTABLE)

public class InvalidReCaptchaException extends RuntimeException{

    public InvalidReCaptchaException(String message){

        super(message);

    }

}

package eu.dnetlib.uoaadmintoolslibrary.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

public class Entity {

    @Id

    @JsonProperty("_id")

    private String id;

    private String pid;

    private String name;

    public Entity() {}

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getPid() {

        return pid;

    }

    public void setPid(String pid) {

        this.pid = pid;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

public interface PageDAO {

    List<Page> findAll();

    List<Page> findByConnect(boolean connect);

    List<Page> findByCommunities(boolean communities);

    List<Page> findByOpenaire(boolean openaire);

    Page findByConnectAndRoute(boolean connect, String route);

    Page findByCommunitiesAndRoute(boolean communities, String route);

    Page findByOpenaireAndRoute(boolean openaire, String route);

    Page findById(String Id);

    Page findByRoute(String route);

    Page save(Page page);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

public interface EntityDAO {

    List<Entity> findAll();

    Entity findById(String Id);

    Entity findByPid(String Pid);

    Entity findByName(String name);

    Entity save(Entity entity);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

public interface DivIdDAO {

    List<DivId> findAll();

    List<DivId> findByPagesContaining(String page);

    DivId findByPagesContainingAndName(String page, String name);

    DivId findByName(String name);

    DivId findById(String Id);

    List<DivId> findByConnect(boolean connect);

    List<DivId> findByCommunities(boolean communities);

    List<DivId> findByOpenaire(boolean openaire);

    DivId save(DivId divId);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.PageHelpContent;

public interface PageHelpContentDAO {

    List<PageHelpContent> findAll();

    List<PageHelpContent> findByCommunityAndPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(String communityId, String position, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndPlacementAndIsActiveOrderByOrderAsc(String communityId, String position, boolean isActive);

    List<PageHelpContent> findByCommunityAndPlacementAndIsPriorToOrderByOrderAsc(String communityId, String position, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(String communityId, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(String position, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndPlacementOrderByOrderAsc(String communityId, String postion);

    List<PageHelpContent> findByCommunityAndIsActiveOrderByPlacementAscOrderAsc(String communityId, boolean isActive);

    List<PageHelpContent> findByCommunityAndIsPriorToOrderByPlacementAscOrderAsc(String communityId, boolean isPriorTo);

    List<PageHelpContent> findByPlacementAndIsActiveOrderByOrderAsc(String position, boolean isActive);

    List<PageHelpContent> findByPlacementAndIsPriorToOrderByOrderAsc(String position, boolean isPriorTo);

    List<PageHelpContent> findByIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityOrderByPlacementAscOrderAsc(String communityId);

    List<PageHelpContent> findByPlacementOrderByOrderAsc(String postion);

    List<PageHelpContent> findByIsActiveOrderByPlacementAscOrderAsc(boolean isActive);

    List<PageHelpContent> findByIsPriorToOrderByPlacementAscOrderAsc(boolean isPriorTo);

    List<PageHelpContent> findAllByOrderByPlacementAscOrderAsc();

    //List<PageHelpContent> findByCommunityAndPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(String communityId, String postion, boolean isActive, boolean isBefore);

    PageHelpContent findById(String Id);

    PageHelpContent findByIdOrderByOrder(String Id);

    PageHelpContent save(PageHelpContent pageHelpContent);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.controllers;

import org.apache.log4j.Logger;

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

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

import java.util.*;

import eu.dnetlib.uoaadmintoolslibrary.dao.CommunityDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivIdDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Community;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

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

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

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

@RestController

@CrossOrigin(origins = "*")

public class PageController {

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

    @Autowired

    private PageDAO pageDAO;

    @Autowired

    private CommunityDAO communityDAO;

    @Autowired

    private DivIdDAO divIdDAO;

    @Autowired

    private PageHelpContentController pageHelpContentController;

    @Autowired

    private DivHelpContentController divHelpContentController;

    @Autowired

    private DivIdController divIdController;

    @Autowired

    private EntityController entityController;

    @RequestMapping(value = "/pageFull", method = RequestMethod.GET)

    public List<CommunityPage> getPagesFull(@RequestParam(value="pid", required=false) String pid,

                                            @RequestParam(value="page_route", required=false) String page_route) {

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

        List<CommunityPage> communityPages = new ArrayList<>();

        for(Page page : pages) {

            CommunityPage communityPage = new CommunityPage(page);

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

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

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

            }

            communityPage.setEntities(entities);

            communityPages.add(communityPage);

        }

        return communityPages;

    }

    @RequestMapping(value = "/page", method = RequestMethod.GET)

    public List<Page> getAllPages(@RequestParam(value="pid", required=false) String pid,

                                  @RequestParam(value="page_route", required=false) String page_route,

                                  @RequestParam(value="with_positions", required=false) String with_positions) {

        List<Page> pages;

        if (pid != null) {

            if (pid.equals("openaire")) {

                if (page_route != null) {

                    pages = new ArrayList<Page>();

                    pages.add(pageDAO.findByOpenaireAndRoute(true, page_route));

                } else {

                    pages = pageDAO.findByOpenaire(true);

                }

            } else if (pid.equals("connect")) {

                if (page_route != null) {

                    pages = new ArrayList<Page>();

                    pages.add(pageDAO.findByConnectAndRoute(true, page_route));

                } else {

                    pages = pageDAO.findByConnect(true);

                }

            } else {

                if (page_route != null) {

                    pages = new ArrayList<Page>();

                    pages.add(pageDAO.findByCommunitiesAndRoute(true, page_route));

                } else {

                    pages = pageDAO.findByCommunities(true);

                }

            }

        } else if (page_route != null) {

            pages = new ArrayList<Page>();

            pages.add(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;

    }

    @RequestMapping(value = "/page", method = RequestMethod.DELETE)

    public void deleteAllPages() {

        pageDAO.deleteAll();

    }

    @RequestMapping(value = "/page/update", method = RequestMethod.POST)

    public CommunityPage updatePage(@RequestBody CommunityPage communityPage) {

        this.deletePageHelpContentsForPositionsIfDisabled(communityPage);

        Page page = this.getPageByCommunityPage(communityPage);

        pageDAO.save(page);

        return communityPage;

    }

    @RequestMapping(value = "/page/save", method = RequestMethod.POST)

    public CommunityPage insertPage(@RequestBody CommunityPage communityPage) {

        Page page = this.getPageByCommunityPage(communityPage);

        Page savedPage = pageDAO.save(page);

        communityPage.setId(savedPage.getId());

        // add page in communities

        List<Community> communities = communityDAO.findAll();

        for( Community community : communities ) {

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

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

            community.setPages(pages);

            communityDAO.save(community);

        }

        return communityPage;

    }

    private Page getPageByCommunityPage(CommunityPage communityPage) {

        Page page = new Page();

        page.setId(communityPage.getId());

        page.setRoute(communityPage.getRoute());

        page.setName(communityPage.getName());

        page.setType(communityPage.getType());

        page.setConnect(communityPage.getConnect());

        page.setCommunities(communityPage.getCommunities());

        page.setOpenaire(communityPage.getOpenaire());

        page.setTop(communityPage.getTop());

        page.setBottom(communityPage.getBottom());

        page.setLeft(communityPage.getLeft());

        page.setRight(communityPage.getRight());

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

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

        for(Entity entity : fullEntities) {

            entities.add(entity.getId());

        }

        page.setEntities(entities);

        return page;

    }

    private void deletePageHelpContentsForPositionsIfDisabled(CommunityPage communityPage) {

        if(!communityPage.getTop()) {

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

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!communityPage.getBottom()) {

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

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!communityPage.getLeft()) {

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

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

        if(!communityPage.getRight()) {

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

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        }

    }

    @RequestMapping(value = "/page/delete", method = RequestMethod.POST)

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

        for (String id: pages) {

            pageDAO.delete(id);

            // delete divIds related only to this page from all communities, 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 communities

                    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 communities

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

            // delete page from communities

            List<Community> communities = communityDAO.findAll();

            for( Community community : communities ) {

                Map<String, Boolean> communityPages = community.getPages();

                communityPages.remove(id);

                community.setPages(communityPages);

                communityDAO.save(community);

            }

        }

        return true;

    }

    @RequestMapping(value = "/page/{id}", method = RequestMethod.GET)

    public Page getPage(@PathVariable(value = "id") String id) {

        return pageDAO.findById(id);

    }

    @RequestMapping(value = "/page/{id}", method = RequestMethod.DELETE)

    public void deletePage(@PathVariable(value = "id") String id) {

        pageDAO.delete(id);

    }

    @RequestMapping(value = "/page/{id}/entity", method = RequestMethod.GET)

    public List<String> getPageEntities(@PathVariable(value = "id") String id) {

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

    }

    @RequestMapping(value = "page/{id}/entity/toggle", method = RequestMethod.POST)

    public Page togglePageEntity(@PathVariable(value = "id") String id, @RequestParam String entityId, @RequestParam 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);

    }

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.Community;

public interface CommunityDAO {

    List<Community> findAll();

    Community findById(String Id);

    Community findByPid(String Pid);

    Community findByName(String Name);

    Community save(Community community);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivHelpContent;

public interface DivHelpContentDAO {

    List<DivHelpContent> findAll();

    List<DivHelpContent> findByCommunity(String community);

    List<DivHelpContent> findByDivId(String divId);

    List<DivHelpContent> findByIsActive(boolean isActive);

    List<DivHelpContent> findByCommunityAndDivId(String community, String divId);

    List<DivHelpContent> findByCommunityAndIsActive(String community, boolean isActive);

    List<DivHelpContent> findByDivIdAndIsActive(String divId, boolean isActive);

    List<DivHelpContent> findByCommunityAndDivIdAndIsActive(String community, String divId, boolean isActive);

    DivHelpContent findById(String Id);

    DivHelpContent save(DivHelpContent divHelpContent);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao.MongoDBDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivHelpContent;

public interface MongoDBDivHelpContentDAO extends DivHelpContentDAO, MongoRepository<DivHelpContent, String> {

    List<DivHelpContent> findAll();

    List<DivHelpContent> findByCommunity(String community);

    List<DivHelpContent> findByDivId(String divId);

    List<DivHelpContent> findByIsActive(boolean isActive);

    List<DivHelpContent> findByCommunityAndDivId(String community, String divId);

    List<DivHelpContent> findByCommunityAndIsActive(String community, boolean isActive);

    List<DivHelpContent> findByDivIdAndIsActive(String divId, boolean isActive);

    List<DivHelpContent> findByCommunityAndDivIdAndIsActive(String community, String divId, boolean isActive);

    DivHelpContent findById(String Id);

    DivHelpContent save(DivHelpContent divHelpContent);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao.MongoDBDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

public interface MongoDBPageDAO extends PageDAO, MongoRepository<Page, String> {

    List<Page> findAll();

    List<Page> findByConnect(boolean connect);

    List<Page> findByCommunities(boolean communities);

    List<Page> findByOpenaire(boolean openaire);

    Page findByConnectAndRoute(boolean connect, String route);

    Page findByCommunitiesAndRoute(boolean communities, String route);

    Page findByOpenaireAndRoute(boolean openaire, String route);

    Page findById(String Id);

    Page findByRoute(String route);

    Page save(Page page);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.controllers;

import org.apache.log4j.Logger;

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

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

import java.util.ArrayList;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.CommunityDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Community;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

import eu.dnetlib.uoaadmintoolslibrary.entities.PageHelpContent;

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

@RestController

@CrossOrigin(origins = "*")

public class PageHelpContentController {

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

    @Autowired

    private PageHelpContentDAO pageHelpContentDAO;

    @Autowired

    private PageController pageController;

    @Autowired

    private CommunityController communityController;

    @Autowired

    private CommunityDAO communityDAO;

    @RequestMapping(value = "/pagehelpcontent", method = RequestMethod.GET)

    public List<PageHelpContentResponse> getPageHelpContents(@RequestParam(required=false) String community,

                                                             @RequestParam(required=false) String page,

                                                             @RequestParam(required=false) String position,

                                                             @RequestParam(required=false) String active,

                                                             @RequestParam(required=false) String before) {

        List<PageHelpContent> pageHelpContents = null;

        Community _community = null;

        String communityId = null;

        if(community != null) {

            _community = communityController.getCommunity(community);

            if(_community != null) {

                communityId = _community.getId();

            }

        }

        //pageHelpContents = pageHelpContentDAO.findByCommunityAndPlacementAndIsActiveAndisPriorToOrderByOrderAsc(community, position, Boolean.parseBoolean(active), Boolean.parseBoolean(before));

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

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

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

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

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

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

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

            pageHelpContents = pageHelpContentDAO.findByCommunityAndIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(communityId, 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(community != null && position != null ) {

            pageHelpContents = pageHelpContentDAO.findByCommunityAndPlacementOrderByOrderAsc(communityId, position);

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

            pageHelpContents = pageHelpContentDAO.findByCommunityAndIsActiveOrderByPlacementAscOrderAsc(communityId, Boolean.parseBoolean(active));

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

            pageHelpContents = pageHelpContentDAO.findByCommunityAndIsPriorToOrderByPlacementAscOrderAsc(communityId, 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(community != null) {

            pageHelpContents = pageHelpContentDAO.findByCommunityOrderByPlacementAscOrderAsc(communityId);

        } 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 = pageController.getPage(pageHelpContent.getPage());

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

                PageHelpContentResponse pageHelpContentResponse = new PageHelpContentResponse(pageHelpContent);

                pageHelpContentResponse.setPage(_page);

                pageHelpContentResponse.setCommunity(communityDAO.findById(pageHelpContent.getCommunity()));

                pageHelpContentResponses.add(pageHelpContentResponse);

            }

        }

        return pageHelpContentResponses;

    }

    /*

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

        public List<PageHelpContentResponse> getCommunityPageHelpContents(@PathVariable(value = "id") String communityId) {

            List<PageHelpContent> pageHelpContents =  pageHelpContentDAO.findByCommunity(communityId);

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

            for (PageHelpContent pageHelpContent : pageHelpContents) {

                PageHelpContentResponse pageHelpContentResponse = new PageHelpContentResponse(pageHelpContent);

                pageHelpContentResponse.setPage(pageDAO.findById(pageHelpContent.getPage()));

                pageHelpContentResponse.setCommunity(communityDAO.findById(pageHelpContent.getCommunity()));

                pageHelpContentResponses.add(pageHelpContentResponse);

            }

            return pageHelpContentResponses;

        }

    */

    @RequestMapping(value = "/pagehelpcontent", method = RequestMethod.DELETE)

    public void deleteAllPageHelpContents() {

        pageHelpContentDAO.deleteAll();

    }

    @RequestMapping(value = "/pagehelpcontent/save", method = RequestMethod.POST)

    public PageHelpContent insertPageHelpContent(@RequestBody PageHelpContent pageHelpContent) {

        String communityId = communityController.getCommunity(pageHelpContent.getCommunity()).getId();

        pageHelpContent.setCommunity(communityId);

        return pageHelpContentDAO.save(pageHelpContent);

    }

    @RequestMapping(value = "/pagehelpcontent/update", method = RequestMethod.POST)

    public PageHelpContent updatePageHelpContent(@RequestBody PageHelpContent pageHelpContent) {

        return pageHelpContentDAO.save(pageHelpContent);

    }

    @RequestMapping(value = "/pagehelpcontent/{id}", method = RequestMethod.GET)

    public PageHelpContent getPageHelpContent(@PathVariable(value = "id") String id) {

        return pageHelpContentDAO.findById(id);

    }

    @RequestMapping(value = "/pagehelpcontent/toggle", method = RequestMethod.POST)

    public List<String> togglePageHelpContent(@RequestBody List<String> pageHelpContents, @RequestParam 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;

    }

    @RequestMapping(value = "/pagehelpcontent/{id}", method = RequestMethod.DELETE)

    public void deletePageHelpContent(@PathVariable(value = "id") String id) {

        pageHelpContentDAO.delete(id);

    }

    @RequestMapping(value = "/pagehelpcontent/delete", method = RequestMethod.POST)

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

        for (String id: pageHelpContents) {

            pageHelpContentDAO.delete(id);

        }

        return true;

    }

    public void addPageHelpContentsInCommunity(String pid, String communityId) {

        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 = (pageController.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 = (pageController.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.dao.MongoDBDAOs;

import eu.dnetlib.uoaadmintoolslibrary.dao.EntityDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Entity;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

public interface MongoDBEntityDAO extends EntityDAO, MongoRepository<Entity, String> {

    List<Entity> findAll();

    Entity findById(String Id);

    Entity findByPid(String Pid);

    Entity findByName(String name);

    Entity save(Entity entity);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao.MongoDBDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivIdDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

public interface MongoDBDivIdDAO extends DivIdDAO, MongoRepository<DivId, String> {

    List<DivId> findAll();

    List<DivId> findByPagesContaining(String page);

    DivId findByPagesContainingAndName(String page, String name);

    DivId findByName(String name);

    DivId findById(String Id);

    List<DivId> findByConnect(boolean connect);

    List<DivId> findByCommunities(boolean communities);

    List<DivId> findByOpenaire(boolean openaire);

    DivId save(DivId divId);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.dao.MongoDBDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.PageHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.PageHelpContent;

public interface MongoDBPageHelpContentDAO extends PageHelpContentDAO, MongoRepository<PageHelpContent, String> {

    List<PageHelpContent> findAll();

    List<PageHelpContent> findByCommunityAndPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(String communityId, String position, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndPlacementAndIsActiveOrderByOrderAsc(String communityId, String position, boolean isActive);

    List<PageHelpContent> findByCommunityAndPlacementAndIsPriorToOrderByOrderAsc(String communityId, String position, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(String communityId, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByPlacementAndIsActiveAndIsPriorToOrderByOrderAsc(String position, boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityAndPlacementOrderByOrderAsc(String communityId, String postion);

    List<PageHelpContent> findByCommunityAndIsActiveOrderByPlacementAscOrderAsc(String communityId, boolean isActive);

    List<PageHelpContent> findByCommunityAndIsPriorToOrderByPlacementAscOrderAsc(String communityId, boolean isPriorTo);

    List<PageHelpContent> findByPlacementAndIsActiveOrderByOrderAsc(String position, boolean isActive);

    List<PageHelpContent> findByPlacementAndIsPriorToOrderByOrderAsc(String position, boolean isPriorTo);

    List<PageHelpContent> findByIsActiveAndIsPriorToOrderByPlacementAscOrderAsc(boolean isActive, boolean isPriorTo);

    List<PageHelpContent> findByCommunityOrderByPlacementAscOrderAsc(String communityId);

    List<PageHelpContent> findByPlacementOrderByOrderAsc(String postion);

    List<PageHelpContent> findByIsActiveOrderByPlacementAscOrderAsc(boolean isActive);

    List<PageHelpContent> findByIsPriorToOrderByPlacementAscOrderAsc(boolean isPriorTo);

    List<PageHelpContent> findAllByOrderByPlacementAscOrderAsc();

    //List<PageHelpContent> findByCommunityAndPlacementAndIsActiveAndBeforeOrderByOrderAsc(String communityId, String postion, boolean isActive, boolean before);

    PageHelpContent findById(String Id);

    PageHelpContent findByIdOrderByOrder(String Id);

    PageHelpContent save(PageHelpContent pageHelpContent);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.controllers;

import org.apache.log4j.Logger;

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

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

import java.util.ArrayList;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.CommunityDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivHelpContentDAO;

import eu.dnetlib.uoaadmintoolslibrary.dao.DivIdDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Community;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivHelpContent;

import eu.dnetlib.uoaadmintoolslibrary.entities.DivId;

import eu.dnetlib.uoaadmintoolslibrary.entities.Page;

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

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

@RestController

@CrossOrigin(origins = "*")

public class DivHelpContentController {

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

    @Autowired

    DivIdController divIdController;

    @Autowired

    private DivHelpContentDAO divHelpContentDAO;

    @Autowired

    private DivIdDAO divIdDAO;

    @Autowired

    private CommunityDAO communityDAO;

    @RequestMapping(value = "/divhelpcontent", method = RequestMethod.GET)

    public List<DivHelpContentResponse> getDivHelpContents(@RequestParam(required = false) String community,

                                                           @RequestParam(required = false) String page,

                                                           @RequestParam(required = false) String div,

                                                           @RequestParam(required = false) String active) {

        Community _community = communityDAO.findByPid(community);

        String communityId = null;

        if(_community != null) {

            communityId = _community.getId();

        }

        DivId divId = divIdDAO.findByName(div);

        String divIdId = null;

        if(divId != null) {

            divIdId = divId.getId();

        }

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

        List<DivHelpContent> divHelpContents = null;

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

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

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

            divHelpContents = divHelpContentDAO.findByCommunityAndDivId(communityId, divIdId);

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

            divHelpContents = divHelpContentDAO.findByCommunityAndIsActive(communityId, Boolean.parseBoolean(active));

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

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

        } else if(community != null) {

            divHelpContents = divHelpContentDAO.findByCommunity(communityId);

        } 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 = divIdDAO.findById(divHelpContent.getDivId());

            }

            divIdResponse = divIdController.divIdResponseFromDivId(divId);

            if(community == null) {

                _community = communityDAO.findById(divHelpContent.getCommunity());

            }

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

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

                    DivHelpContentResponse divHelpContentResponse = new DivHelpContentResponse(divHelpContent);

                    divHelpContentResponse.setDivId(divIdResponse);

                    divHelpContentResponse.setCommunity(_community);

                    divHelpContentResponses.add(divHelpContentResponse);

                    break;

                }

            }

        }

        return divHelpContentResponses;

    }

    @RequestMapping(value = "/divhelpcontent/{id}", method = RequestMethod.GET)

    public DivHelpContent getDivHelpContent(@PathVariable(value = "id") String id) {

        return divHelpContentDAO.findById(id);

    }

    @RequestMapping(value = "/divhelpcontent", method = RequestMethod.POST)

    public DivHelpContent insertOrUpdateDivHelpContent(@RequestBody DivHelpContent divHelpContent) {

        return divHelpContentDAO.save(divHelpContent);

    }

    @RequestMapping(value = "/divhelpcontent/{id}", method = RequestMethod.DELETE)

    public void deleteDivHelpContent(@PathVariable(value = "id") String id) {

        divHelpContentDAO.delete(id);

    }

    @RequestMapping(value = "/divhelpcontent/delete", method = RequestMethod.POST)

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

        for (String id: divHelpContents) {

            divHelpContentDAO.delete(id);

        }

        return true;

    }

    @RequestMapping(value = "/divhelpcontent/toggle", method = RequestMethod.POST)

    public List<String> toggleDivHelpContent(@RequestBody List<String> divHelpContents, @RequestParam 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 addDivHelpContentsInCommunity(String pid, String communityId, String divIdName) {

        //String organizations_class_content = "<div> <p>Here you can write more details about the organizations related to your community.</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 community and/or a category and search for a community concept, or browse to the community 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 = divIdController.getDivIds(null, divIdName, null);

        for( DivId div : divIds ) {

            if (div != null && (

                    (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(), communityId, organizations_class_content, false));

                } else

                */

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

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

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

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

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

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

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

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

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

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

                }

            }

        }

    }

}

package eu.dnetlib.uoaadmintoolslibrary.dao.MongoDBDAOs;

import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.List;

import eu.dnetlib.uoaadmintoolslibrary.dao.CommunityDAO;

import eu.dnetlib.uoaadmintoolslibrary.entities.Community;

public interface MongoDBCommunityDAO extends CommunityDAO, MongoRepository<Community, String> {

    List<Community> findAll();

    Community findById(String Id);

    Community findByPid(String Pid);

    Community findByName(String Name);

    Community save(Community community);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintoolslibrary.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

public class DivId {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    private List<String> pages;

    private Boolean connect;

    private Boolean communities;

    private Boolean openaire;

    public DivId() {}

    public DivId(DivId divId) {

        setName(divId.getName());

        setPages(divId.getPages());

        setConnect(divId.getConnect());

        setCommunities(divId.getCommunities());

        setOpenaire(divId.getOpenaire());

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public List<String> getPages() {

        return pages;

    }

    public void setPages(List<String> pages) {

        this.pages = pages;

    }

    public Boolean getConnect() {

        return connect;

    }

    public void setConnect(Boolean connect) { this.connect = connect; }

    public Boolean getCommunities() { return communities; }

    public void setCommunities(Boolean communities) {

        this.communities = communities;

    }

    public Boolean getOpenaire() {

        return openaire;

    }

    public void setOpenaire(Boolean openaire) {

        this.openaire = openaire;

    }

}

package eu.dnetlib.uoaadmintoolslibrary.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

public class PageHelpContent {

    @Id

    @JsonProperty("_id")

    private String id;

    private String page;

    private String community;

    private String placement;

    private int order;

    private String content;

    private boolean isActive = true;

    private boolean isPriorTo = false;

    public PageHelpContent() {}

    public PageHelpContent(String page, String community, String placement, int order, String content, boolean isActive, boolean isPriorTo) {

        this.page = page;

        this.community = community;

        this.placement = placement;

        this.order = order;

        this.content = content;

        this.isActive = isActive;

        this.isPriorTo = isPriorTo;

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getPage() {

        return page;

    }

    public void setPage(String page) {

        this.page = page;

    }

    public String getCommunity() {

        return community;

    }

    public void setCommunity(String community) {

        this.community = community;

    }

    public String getPlacement() {

        return placement;

    }

    public void setPlacement(String placement) {

        this.placement = placement;

    }

    public int getOrder() {

        return order;

    }

    public void setOrder(int order) {

        this.order = order;

    }

    public String getContent() {

        return content;

    }

    public void setContent(String content) {

        this.content = content;

    }

    public boolean getIsActive() {

        return isActive;

    }

    public void setIsActive(boolean isActive) {

        this.isActive = isActive;

    }

    public boolean getIsPriorTo() { return isPriorTo; }

    public void setIsPriorTo(boolean isPriorTo) { this.isPriorTo = isPriorTo; }

}

package eu.dnetlib.uoaadmintoolslibrary.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.Map;

public class Community {

    @Id

    @JsonProperty("_id")

    private String id;