D-Net

package eu.dnetlib.uoaadmintools.controllers;

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;

    private DivIdDAO divIdDAO;

    @Autowired

    private PageHelpContentController pageHelpContentController;

    @Autowired

    private DivHelpContentController divHelpContentController;

    @Autowired

    private DivIdController divIdController;

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

        Iterator it = communities.iterator();

        while(it.hasNext()) {

            Community community = (Community)it.next();

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

                List<DivId> divIds = divIdDAO.findByCommunity(community.getId());

                if(divIds.isEmpty()) {

                    it.remove();

                }

            }

        }

        return communities;

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

            while(iteratorPages.hasNext()) {

                CommunityPage page = iteratorPages.next();

                if(!page.getIsEnabled()) {

                    iteratorPages.remove();

                }

            }

            communityResponse.setPages(pages);

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

            while(iteratorEntities.hasNext()) {

                CommunityEntity entity = iteratorEntities.next();

                if(!entity.getIsEnabled()) {

                    iteratorEntities.remove();

                }

            }

            communityResponse.setEntities(entities);

            communitiesResponse.add(communityResponse);

        }

        return communitiesResponse;

    }

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

        Community community = communityDAO.findByPid(pid);

        while(iteratorPages.hasNext()) {

            CommunityPage page = iteratorPages.next();

            if(!page.getIsEnabled()) {

                iteratorPages.remove();

            }

        }

        communityResponse.setPages(pages);

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

        while(iteratorPages.hasNext()) {

            CommunityPage page = iteratorPages.next();

            if(!page.getIsEnabled()) {

                iteratorPages.remove();

            }

        }

        communityResponse.setPages(pages);

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

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

        com.setName(community.getName());

        communityDAO.save(com);

    }

    @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()) {

            CommunityEntity communityEntity = new CommunityEntity(entity);

        }

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

            CommunityPage communityPage = new CommunityPage(page);

            communityPages.add(communityPage);

        }

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

            // delete divIds related to this page from all communities

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

            for(DivId divId : divIds) {

                divIdController.deleteDivId(divId.getId());

            }

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

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

            for(DivHelpContentResponse divHelpContentResponse : divHelpContentResponses) {

                divHelpContentController.deleteDivHelpContent(divHelpContentResponse.getId());

            }

            // delete contents related to this community

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

            for(PageHelpContentResponse pageHelpContentResponse : pageHelpContentResponses) {

                pageHelpContentController.deletePageHelpContent(pageHelpContentResponse.getId());

            }

        return true;

    }

//    public void deleteAllCommunities() {

//        communityDAO.deleteAll();

//    }

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

    public Community insertOrUpdateCommunity(@RequestBody Community community) {

        return communityDAO.save(community);

    }

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

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

        return communityDAO.findByPid(pid);

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

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

        communityDAO.delete(id);

    }

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

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

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

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

                    Community community = communityDAO.findByPid(pid);

                    List<DivId> divIds = divIdDAO.findByCommunityAndPage(community.getId(), page.getKey());

                    if(divIds.isEmpty()) {

                        continue;

                    }

                }

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

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

                    CommunityPage communityPage = new CommunityPage(p);

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

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

                    }

                    communityPage.setEntities(entities);

                    communityPage.setIsEnabled(page.getValue());

                    return_pages.add(communityPage);

                    if (page_route != null) {

                        break;

                    }

            }

        }

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

    }

    public Community togglePage(@PathVariable(value = "pid") String pid, @RequestBody List<String> pageIds, @RequestParam String status) throws Exception {

        Community community = communityDAO.findByPid(pid);

        for (String pageId: pageIds) {

        }

        return communityDAO.save(community);

    }

    public Community toggleEntity(@PathVariable(value = "pid") String pid, @RequestBody List<String> entityIds, @RequestParam String status) throws Exception {

        Community community = communityDAO.findByPid(pid);

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

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

                    }

        }

        community.setEntities(entities);

    }

    public List<CommunityEntity> getEntitiesForCommunity(@PathVariable(value = "pid") String pid, @RequestParam(value="entity", required=false) String entity) {

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

        if (entity != null) {

            String entityId = entityDAO.findByPid(entity).getId();

            CommunityEntity communityEntity = new CommunityEntity(entityDAO.findById(entityId));

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

            if(entities != null) {

                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;

    }

}