D-Net

import eu.dnetlib.uoaadmintools.dao.*;

import eu.dnetlib.uoaadmintools.entities.Community;

import eu.dnetlib.uoaadmintools.entities.Entity;

import eu.dnetlib.uoaadmintools.entities.Page;

import eu.dnetlib.uoaadmintools.entities.PageHelpContent;

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static javax.swing.text.html.HTML.Tag.P;

	@Autowired

	private CommunityDAO communityDAO;

	@Autowired

	private EntityDAO entityDAO;

	@Autowired

	private PageDAO pageDAO;

	@Autowired

	private PageHelpContentDAO pageHelpContentDAO;

/*

	public void deleteAllEntities() {

		List<Entity> entities = entityDAO.findAll();

		for(Entity entity : entities) {

			entityDAO.delete(entity.getId());

		}

	}

	@Test

	public void deleteAllCommunities() {

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

		for(Community community : communities) {

			communityDAO.delete(community.getId());

		}

	}

	@Test

	public void deleteAllPages() {

		List<Page> pages = pageDAO.findAll();

		for(Page page : pages) {

			pageDAO.delete(page.getId());

		}

	}

	@Test

	public void deleteAllPageContents() {

		List<PageHelpContent> pageHelpContents = pageHelpContentDAO.findAll();

		for(PageHelpContent pageHelpContent : pageHelpContents) {

			pageHelpContentDAO.delete(pageHelpContent.getId());

		}

	}

	@Test

	public void createEntity() {

		Entity entity = new Entity();

		entity.setName("Publication");

		entityDAO.save(entity);

	}

	@Test

	public void createPage() {

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

		//entities.add("5a300ee4c97a7d2c000b9e9d");	// Publication

		entities.add("5a319f8bc97a7d241ebddf75");	// Research Data

		Page page = new Page();

		page.setName("Search Research Data");

		page.setRoute("/search/find/datasets");

		page.setType("search");

		page.setEntities(entities);

		pageDAO.save(page);

	}

	@Test

	public void createCommunity() {

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

		//entities.put("5a300ee4c97a7d2c000b9e9d", true);	// Publication

		entities.put("5a319f8bc97a7d241ebddf75", false);	// Research Data

		//entities.put("5a3064f9c97a7d4964408ee0", false);	// Software

		//entities.put("5a30652ec97a7d4964408ee1", false);	// Organization

		//entities.put("5a306539c97a7d4964408ee2", false);	// Project

		//entities.put("5a30654dc97a7d4964408ee3", false);	// Content Provider

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

		//pages.put("5a30191ac97a7d3a7fa77362", true);		// Search Publications

		pages.put("5a31a4cac97a7d28468f0f5c", false);		// Search Research Data

		//pages.put("5a30657ac97a7d4964408ee4", false);		// Search Software

		//pages.put("5a30eeffc97a7d74234434ad", false);		// Search Organizations

		//pages.put("5a30efd9c97a7d7609b77ca5", false);		// Search Projects

		//pages.put("5a30f08bc97a7d7609b77ca7", false);		// Search Content Providers

		//pages.put("5a300f19c97a7d2c6e084b9f", false);		// Test

		Community community = new Community();

		community.setName("Test Community");

		community.setEntities(entities);

		community.setPages(pages);

		communityDAO.save(community);

	}

*/

	@Test

    Page findByName(String name);

package eu.dnetlib.uoaadmintools.dao;

import eu.dnetlib.uoaadmintools.entities.Entity;

import java.util.List;

public interface EntityDAO {

    List<Entity> findAll();

    Entity findById(String Id);

    Entity findByName(String name);

    Entity save(Entity entity);

    void deleteAll();

    void delete(String id);

}

    List<PageHelpContent> findByCommunity(String CommunityId);

    Page findByName(String name);

package eu.dnetlib.uoaadmintools.dao;

import eu.dnetlib.uoaadmintools.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 findByName(String name);

    Entity save(Entity entity);

    void deleteAll();

    void delete(String id);

}

package eu.dnetlib.uoaadmintools.dao;

import eu.dnetlib.uoaadmintools.entities.Community;

import java.util.List;

public interface CommunityDAO {

    List<Community> findAll();

    Community findById(String Id);

    Community findByName(String Name);

    Community save(Community community);

    void deleteAll();

    void delete(String id);

}

    List<PageHelpContent> findByCommunity(String CommunityId);

package eu.dnetlib.uoaadmintools.dao;

import eu.dnetlib.uoaadmintools.entities.Community;

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

import java.util.List;

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

    List<Community> findAll();

    Community findById(String Id);

    Community findByName(String Name);

    Community save(Community community);

    void deleteAll();

    void delete(String id);

}

    private Community community;

    private boolean before = false;

    public Community getCommunity() {

        return community;

    }

    public void setCommunity(Community community) {

        this.community = community;

    }

    public boolean isBefore() { return before; }

    public void setBefore(boolean before) { this.before = before; }

    private String community;

    private boolean before = false;

    public String getCommunity() {

        return community;

    }

    public void setCommunity(String community) {

        this.community = community;

    }

    public boolean isBefore() { return before; }

    public void setBefore(boolean before) { this.before = before; }

package eu.dnetlib.uoaadmintools.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

import java.util.Map;

public class CommunityPage {

    @Id

    @JsonProperty("_id")

    private String id;

    private String route;

    private String name;

    private String type;

    private List<Entity> entities;

    private Boolean isEnabled;

    public CommunityPage() {}

    public CommunityPage(Page page) {

        this.setId(page.getId());

        this.setRoute(page.getRoute());

        this.setName(page.getName());

        this.setType(page.getType());

    }

    public String getId() {

        return id;

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getRoute() {

        return route;

    }

    public void setRoute(String route) {

        this.route = route;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getType() {

        return type;

    }

    public void setType(String type) {

        this.type = type;

    }

    public List<Entity> getEntities() { return entities; }

    public void setEntities(List<Entity> entities) { this.entities = entities; }

    public Boolean getIsEnabled() { return isEnabled; }

    public void setIsEnabled(Boolean isEnabled) { this.isEnabled = isEnabled; }

}

package eu.dnetlib.uoaadmintools.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

import java.util.Map;

public class CommunityEntity {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    private Boolean isEnabled;

    public CommunityEntity() {}

    public CommunityEntity(Entity entity) {

        this.setId(entity.getId());

        this.setName(entity.getName());

        this.setIsEnabled(true);

    }

    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 Boolean getIsEnabled() { return isEnabled; }

    public void setIsEnabled(Boolean isEnabled) { this.isEnabled = isEnabled; }

}

package eu.dnetlib.uoaadmintools.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

import java.util.Map;

public class CommunityResponse {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    private List<CommunityPage> pages;

    private List<CommunityEntity> entities;

    public CommunityResponse() {}

    public CommunityResponse(Community community) {

        this.setId(community.getId());

        this.setName(community.getName());

    }

    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<CommunityPage> getPages() { return pages; }

    public void setPages(List<CommunityPage> pages) { this.pages = pages; }

    public List<CommunityEntity> getEntities() { return entities; }

    public void setEntities(List<CommunityEntity> entities) {

        this.entities = entities;

    }

}

package eu.dnetlib.uoaadmintools.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

import java.util.List;

import java.util.Map;

public class Community {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    private Map<String, Boolean> pages;

    private Map<String, Boolean> entities;

    public Community() {

    }

    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 Map<String, Boolean> getPages() { return pages; }

    public void setPages(Map<String, Boolean> pages) { this.pages = pages; }

    public Map<String, Boolean> getEntities() { return entities; }

    public void setEntities(Map<String, Boolean> entities) {

        this.entities = entities;

    }

}

import java.util.List;

    private String type;

    private List<String> entities;

    public String getType() {

        return type;

    }

    public void setType(String type) {

        this.type = type;

    }

    public List<String> getEntities() { return entities; }

    public void setEntities(List<String> entities) { this.entities = entities; }

package eu.dnetlib.uoaadmintools.entities;

import com.fasterxml.jackson.annotation.JsonProperty;

import org.springframework.data.annotation.Id;

public class Entity {

    @Id

    @JsonProperty("_id")

    private String id;

    private String name;

    public Entity() {

    }

    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;

    }

}

import eu.dnetlib.uoaadmintools.dao.CommunityDAO;

import eu.dnetlib.uoaadmintools.entities.Community;

import eu.dnetlib.uoaadmintools.entities.CommunityPage;

import eu.dnetlib.uoaadmintools.entities.Entity;

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

import java.util.ArrayList;

import java.util.Map;

    @Autowired

    private CommunityDAO communityDAO;

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

    public CommunityPage updatePage(@RequestBody CommunityPage 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(), false);

            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());

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

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

        for(Entity entity : fullEntities) {

            entities.add(entity.getId());

        }

        page.setEntities(entities);

        return page;

    }

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

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

        for (String id: pages) {

            pageDAO.delete(id);

            // delete pages 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}/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.uoaadmintools.controllers;

import eu.dnetlib.uoaadmintools.dao.CommunityDAO;

import eu.dnetlib.uoaadmintools.dao.PageDAO;

import eu.dnetlib.uoaadmintools.entities.Community;

import eu.dnetlib.uoaadmintools.entities.CommunityEntity;

import eu.dnetlib.uoaadmintools.entities.Entity;

import eu.dnetlib.uoaadmintools.dao.EntityDAO;

import eu.dnetlib.uoaadmintools.entities.Page;

import org.apache.log4j.Logger;

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

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

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

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

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

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

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

import java.util.List;

import java.util.Map;

@RestController

@CrossOrigin(origins = "*")

public class EntityController {

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

    @Autowired

    private EntityDAO entityDAO;

    @Autowired

    private PageDAO pageDAO;

    @Autowired

    private CommunityDAO communityDAO;

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

    public List<Entity> getAllEntities() {

        return entityDAO.findAll();

    }

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

    public void deleteAllEntities() {

        entityDAO.deleteAll();

    }

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

    public Entity insertOrUpdateEntity(@RequestBody Entity entity) {

        return entityDAO.save(entity);

    }

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

    public Entity getEntity(@PathVariable(value = "id") String id) {

        return entityDAO.findById(id);

    }

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

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

        entityDAO.delete(id);

    }

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

    public CommunityEntity updateEntity(@RequestBody CommunityEntity communityEntity) {

        Entity entity = this.getEntityByCommunityEntity(communityEntity);

        entityDAO.save(entity);

        return communityEntity;

    }

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

    public CommunityEntity insertEntity(@RequestBody CommunityEntity communityEntity) {

        Entity entity = this.getEntityByCommunityEntity(communityEntity);

        Entity savedEntity = entityDAO.save(entity);

        communityEntity.setId(savedEntity.getId());

        // add entity in communities

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

        for( Community community : communities ) {

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

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

            community.setEntities(entities);

            communityDAO.save(community);

        }

        return communityEntity;

    }

    private Entity getEntityByCommunityEntity(CommunityEntity communityPage) {

        Entity entity = new Entity();

        entity.setId(communityPage.getId());

        entity.setName(communityPage.getName());

        return entity;

    }

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

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

        for (String id: entities) {

            entityDAO.delete(id);

            // delete entities from communities

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

            for( Community community : communities ) {

                Map<String, Boolean> communityEntities = community.getEntities();

                communityEntities.remove(id);

                community.setEntities(communityEntities);

                communityDAO.save(community);

            }

            // delete entities from pages

            List<Page> pages = pageDAO.findAll();

            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);

                pageDAO.save(page);

            }

        }

        return true;

    }

}

import eu.dnetlib.uoaadmintools.dao.CommunityDAO;

    @Autowired

    private CommunityDAO communityDAO;

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

            pageHelpContentResponses.add(pageHelpContentResponse);

    @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;

    }

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

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

        return pageHelpContents;

    @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;

    }

package eu.dnetlib.uoaadmintools.controllers;

import eu.dnetlib.uoaadmintools.dao.EntityDAO;

import eu.dnetlib.uoaadmintools.dao.PageDAO;

import eu.dnetlib.uoaadmintools.entities.*;

import eu.dnetlib.uoaadmintools.dao.CommunityDAO;

import org.apache.log4j.Logger;

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

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

import java.util.*;

@RestController

@CrossOrigin(origins = "*")

public class CommunityController {

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

    @Autowired

    private CommunityDAO communityDAO;

    @Autowired

    private PageDAO pageDAO;

    @Autowired

    private EntityDAO entityDAO;

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

    public List<Community> getAllCommunities() {

        return communityDAO.findAll();

    }

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

    public List<CommunityResponse> getAllCommunitiesFull() {

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

        List<CommunityResponse> communitiesResponse = new ArrayList<>();

        for(Community community : communities) {

            CommunityResponse communityResponse = new CommunityResponse(community);

            List<CommunityPage> pages = this.getPagesForCommunityByType(community.getId(), null);

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

            while(iteratorPages.hasNext()) {

                CommunityPage page = iteratorPages.next();

                if(!page.getIsEnabled()) {

                    iteratorPages.remove();

                }

            }

            communityResponse.setPages(pages);

            List<CommunityEntity> entities = this.getEntitiesForCommunity(community.getId());

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

            while(iteratorEntities.hasNext()) {

                CommunityEntity entity = iteratorEntities.next();

                if(!entity.getIsEnabled()) {

                    iteratorEntities.remove();

                }

            }

            communityResponse.setEntities(entities);

            communitiesResponse.add(communityResponse);

        }

        return communitiesResponse;

    }

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

    public CommunityResponse getCommunityFull(@PathVariable(value = "id") String id) {

        Community community = communityDAO.findById(id);

        CommunityResponse communityResponse = new CommunityResponse(community);

        List<CommunityPage> pages = this.getPagesForCommunityByType(community.getId(), null);

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

        while(iteratorPages.hasNext()) {

            CommunityPage page = iteratorPages.next();

            if(!page.getIsEnabled()) {

                iteratorPages.remove();

            }

        }

        communityResponse.setPages(pages);

        List<CommunityEntity> entities = this.getEntitiesForCommunity(community.getId());

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

        while(iteratorEntities.hasNext()) {

            CommunityEntity entity = iteratorEntities.next();

            if(!entity.getIsEnabled()) {

                iteratorEntities.remove();

            }

        }

        communityResponse.setEntities(entities);

//        communityResponse.setPages(this.getPagesForCommunityByType(community.getId(), null));

//        communityResponse.setEntities(this.getEntitiesForCommunity(community.getId()));

        return communityResponse;

    }

    @RequestMapping(value = "/communityFullByName/{name}", method = RequestMethod.GET)

    public CommunityResponse getCommunityFullByName(@PathVariable(value = "name") String name) {

        Community community = communityDAO.findByName(name);

        CommunityResponse communityResponse = new CommunityResponse(community);

        List<CommunityPage> pages = this.getPagesForCommunityByType(community.getId(), null);

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

        while(iteratorPages.hasNext()) {

            CommunityPage page = iteratorPages.next();

            if(!page.getIsEnabled()) {

                iteratorPages.remove();

            }

        }

        communityResponse.setPages(pages);

        List<CommunityEntity> entities = this.getEntitiesForCommunity(community.getId());

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

        while(iteratorEntities.hasNext()) {

            CommunityEntity entity = iteratorEntities.next();

            if(!entity.getIsEnabled()) {

                iteratorEntities.remove();

            }

        }

        communityResponse.setEntities(entities);

        return communityResponse;

    }

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

    public CommunityResponse updateCommunity(@RequestBody Community community) {

        CommunityResponse communityResponse = this.getCommunityFull(community.getId());

        communityResponse.setName(community.getName());

        Community com = communityDAO.findById(community.getId());

        com.setName(community.getName());

        // = this.getCommunityByCommunityResponse(communityResponse);

        communityDAO.save(com);

        return communityResponse;

    }

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

    public CommunityResponse insertCommunity(@RequestBody Community community) {

        //Community community = this.getCommunityByCommunityResponse(communityResponse);

        List<CommunityEntity> communityEntities = new ArrayList<>();

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

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

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

        for(Entity entity : entityDAO.findAll()) {

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

            CommunityEntity communityEntity = new CommunityEntity(entity);

            communityEntity.setIsEnabled(false);

            communityEntities.add(communityEntity);

        }

        for(Page page : pageDAO.findAll()) {

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

            CommunityPage communityPage = new CommunityPage(page);

            communityPage.setIsEnabled(false);

            communityPages.add(communityPage);

        }

        community.setEntities(entities);

        Community savedCommunity = communityDAO.save(community);

//        communityResponse.setId(savedCommunity.getId());

        CommunityResponse communityResponse = new CommunityResponse();

        return communityResponse;

    }

    private Community getCommunityByCommunityResponse(CommunityResponse communityResponse) {

        Community community = new Community();

        community.setId(communityResponse.getId());

        community.setName(communityResponse.getName());

        List<CommunityEntity> fullEntities = communityResponse.getEntities();

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

        for(CommunityEntity entity : fullEntities) {

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

        }

        for(Entity entity : entityDAO.findAll()) {

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

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

            }

        }

        community.setEntities(entities);

        List<CommunityPage> fullPages = communityResponse.getPages();

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

        for(CommunityPage page : fullPages) {

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

        }

        for(Page page : pageDAO.findAll()) {

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

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

            }

        }

        community.setPages(pages);

        return community;

    }

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

    public Boolean deleteCommunities(@RequestBody List<String> communities) throws Exception {

        for (String id: communities) {

            communityDAO.delete(id);

        }

        return true;

    }

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

    public void deleteAllCommunities() {

        communityDAO.deleteAll();

    }

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

    public Community insertOrUpdateCommunity(@RequestBody Community community) {

        return communityDAO.save(community);

    }

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

    public Community getCommunity(@PathVariable(value = "id") String id) {

        return communityDAO.findById(id);

    }

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

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

        communityDAO.delete(id);

    }

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

    public List<CommunityPage> getPagesForCommunityByType(@PathVariable(value = "id") String id, @RequestParam(value="page_type", required=false) String page_type) {

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

        Map<String, Boolean> pages = communityDAO.findById(id).getPages();

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

            Page p = pageDAO.findById(page.getKey());

            if (page_type==null || p.getType().equals(page_type)) {

                CommunityPage communityPage = new CommunityPage(p);

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

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

                    entities.add(entityDAO.findById(entity));

                }

                communityPage.setEntities(entities);

                communityPage.setIsEnabled(page.getValue());

                return_pages.add(communityPage);

            }

        }

        return return_pages;

    }

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

    public Community insertOrUpdatePage(@PathVariable(value = "id") String id, @RequestBody CommunityPage page) {

        Community community = communityDAO.findById(id);

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

        String name = page.getName();

        boolean isEnabled = page.getIsEnabled();

        pages.put(name, isEnabled);

        community.setPages(pages);

        return communityDAO.save(community);

    }

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

    public Community togglePage(@PathVariable(value = "id") String id, @RequestParam String pageId, @RequestParam String status) throws Exception {

        log.debug("Toggle community page: "+pageId +" of community: "+id+" to "+status);

        Community community = communityDAO.findById(id);

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

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

        community.setPages(pages);

        return communityDAO.save(community);

    }

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

    public Community toggleEntity(@PathVariable(value = "id") String id, @RequestParam String entityId, @RequestParam String status) throws Exception {

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

        Community community = communityDAO.findById(id);

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

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

        community.setEntities(entities);

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

        /*

        if(entityId.equals("5a300ed5c97a7d2bc448fdb5")) { // Research Data

            pages.put("5a301570c97a7d35ef89e601", Boolean.parseBoolean(status));    // Search Research Data

        } else if(entityId.equals("5a300ee4c97a7d2c000b9e9d")) { // Publication

            pages.put("5a30191ac97a7d3a7fa77362", Boolean.parseBoolean(status));    // Search Publications

        } else if(entityId.equals("5a3064f9c97a7d4964408ee0")) { // Software

            pages.put("5a30657ac97a7d4964408ee4", Boolean.parseBoolean(status));    // Search Software

        } else if(entityId.equals("5a30652ec97a7d4964408ee1")) { // Organization

            pages.put("5a30eeffc97a7d74234434ad", Boolean.parseBoolean(status));    // Search Organizations

        } else if(entityId.equals("5a306539c97a7d4964408ee2")) { // Project

            pages.put("5a30efd9c97a7d7609b77ca5", Boolean.parseBoolean(status));    // Search Projects

        } else if(entityId.equals("5a30654dc97a7d4964408ee3")) { // Content Provider

            pages.put("5a30f08bc97a7d7609b77ca7", Boolean.parseBoolean(status));    // Search Content Providers

        }

        */

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

            Page page = pageDAO.findById(pageEntry.getKey());

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

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

            }

        }

        return communityDAO.save(community);

    }

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

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

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

        Map<String, Boolean> entities = communityDAO.findById(id).getEntities();

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

            CommunityEntity communityEntity = new CommunityEntity(entityDAO.findById(entity.getKey()));

            communityEntity.setIsEnabled(entity.getValue());

            return_entities.add(communityEntity);

        }

        return return_entities;

    }

}

log4j.rootLogger = WARN, R

log4j.logger.eu.dnetlib = DEBUG

log4j.logger.org.springframework = INFO, S

log4j.additivity.org.springframework = false

log4j.appender.R=org.apache.log4j.RollingFileAppender

log4j.appender.R.File=/var/log/dnet/admin-tools/admin-tools.log

log4j.appender.R.MaxFileSize=10MB

log4j.appender.R.MaxBackupIndex=10

log4j.appender.R.layout=org.apache.log4j.PatternLayout

log4j.appender.R.layout.ConversionPattern= %d %p %t [%c] - %m%n

log4j.appender.S=org.apache.log4j.RollingFileAppender

log4j.appender.S.File=/var/log/dnet/admin-tools/admin-tools-spring.log

log4j.appender.S.MaxFileSize=10MB

log4j.appender.S.MaxBackupIndex=10

log4j.appender.S.layout=org.apache.log4j.PatternLayout

log4j.appender.S.layout.ConversionPattern= %d %p %t [%c] - %m%n

			<exclusions>

				<exclusion>

					<groupId> org.springframework.boot</groupId>

					<artifactId>spring-boot-starter-logging</artifactId>

				</exclusion>

			</exclusions>

		<dependency>

			<groupId>log4j</groupId>

			<artifactId>log4j</artifactId>

			<version>1.2.17</version>

		</dependency>