nl.tno.bim.mapping.services.MappingSetServiceImpl Maven / Gradle / Ivy

Go to download
package nl.tno.bim.mapping.services;

import java.math.BigInteger;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import nl.tno.bim.mapping.controller.MappingSetController;
import nl.tno.bim.mapping.domain.Mapping;
import nl.tno.bim.mapping.domain.MappingSet;
import nl.tno.bim.mapping.domain.MappingSetMap;
import nl.tno.bim.mapping.repositories.MappingRepository;
import nl.tno.bim.mapping.repositories.MappingSetMapRepository;
import nl.tno.bim.mapping.repositories.MappingSetRepository;

@Component
public class MappingSetServiceImpl implements MappingSetService {
    private final static Logger logger = LoggerFactory.getLogger(MappingSetController.class);

    private MappingSetRepository mappingSetRepository;
    private MappingSetMapRepository mappingSetMapRepository;
    private MappingRepository mappingRepository;
    
    @Autowired
    public void setMappingSetRepository(MappingSetRepository mappingSetRepository) {
        this.mappingSetRepository = mappingSetRepository;
    }
    
    @Autowired
    public void setMappingSetMapRepository(MappingSetMapRepository mappingSetMapRepository) {
		this.mappingSetMapRepository = mappingSetMapRepository;
	}
    
    @Autowired
    public void setMappingRepository(MappingRepository mappingRepository) {
        this.mappingRepository = mappingRepository;
    }

    @Override
    public MappingSet persistNewMappingService(MappingSet mappingSet) {
    	
    	// fill in the date if not defined
    	if(mappingSet.getDate() == null) {
    		mappingSet.setDate(new Date());
    	}
    	
    	// find the most recent revision id
    	Long revId = (long)0;
    	if (mappingSet.getId() != null) {
    		revId = 1 + mappingSetMapRepository.selectMaxMappingRevisionIdFromMappingSetMapWhereMappingSetId(mappingSet.getId());
    	}
    	
    	// add revision ids if not defined.
    	for ( MappingSetMap map : mappingSet.getMappingSetMaps()) {
    		// any new mappingsetmaps require an update to the mappingrevision
    		if (map.getMappingRevisionId() == null) {
    			map.setMappingRevisionId(revId);
    		}
    		
    		// save the mappings separately to avoid cascading misery
    		if (map.getMapping().getId() == null ) {
    			Mapping savedMapping = mappingRepository.save(map.getMapping());
    			map.setMapping(savedMapping);
    		} else if (!this.mappingRepository.existsById(map.getMapping().getId())) {
    			mappingRepository.save(map.getMapping());
    		}
    	}
    	
        return mappingSetRepository.save(mappingSet);
    }

    @Override
    public MappingSet retrieveMappingSetById(Long id) {
        Optional optionalMappingSet = mappingSetRepository.findById(id);
        if (optionalMappingSet.isPresent()) {
            return optionalMappingSet.get();
        }
        return null;
    }

    @Override
    public List searchMappingSet(String projectId) {
        List ms = new ArrayList();
        if (projectId != null) {
            ms = mappingSetRepository.findByProjectId(projectId);
        } else {
            mappingSetRepository.findAll().iterator().forEachRemaining(ms::add);
        }
        return ms;
    }

    @Override
    public MappingSet loadMappingSetWithLatestByProjectId(String contextId) {
        MappingSet mappingSet = new MappingSet();
        if (contextId != null) {
            List objs = mappingSetRepository.findMappingSetWithLatestRevisionByProjectId(contextId);
            if (objs.size() > 0) {
            	mappingSet = convertMappingSetMatrixToMappingSetObject(objs).get(0);
            }
        }
       	
        return mappingSet;
    }

    private List convertMappingSetMatrixToMappingSetObject(List objs) {
        List mappingSets = new ArrayList();
        MappingSet mappingSet = null;
        MappingSetMap mappingSetMap = null;
        
        // preload and index all mappings to avoid one by one calls.
        Set mapIds = new HashSet<>();
        for (Object[] obj : objs) {
            if (obj[6] != null) {
            	mapIds.add((new BigInteger(obj[6].toString())).longValue());
            }
        }
        
        Map mapObjs = new HashMap<>();
        for (Mapping map : mappingRepository.findByIdIn(mapIds.stream().collect(Collectors.toList()))) {
        	mapObjs.put(map.getId(), map);
        }

        
        for (Object[] obj : objs) {
        	if (mappingSet == null || mappingSet.getProjectId() != ((String) obj[2])) {
        		
        		mappingSet = new MappingSet(
        				((String) obj[2]),
        				new Date(((Timestamp) obj[1]).getTime()),
        				(new BigInteger(obj[0].toString())).longValue());
        		mappingSet.setMappingSetMaps(new ArrayList<>());
        		mappingSets.add(mappingSet);
        	}
        	if (obj[5] != null && obj[4] != null && obj[3] != null) {
            	mappingSetMap = new MappingSetMap(
            			(new BigInteger(obj[5].toString())).longValue(),
            			(String) obj[4],
            			(new BigInteger(obj[3].toString())).longValue());


                Long mappingId = (new BigInteger(obj[6].toString())).longValue();
                if (mapObjs.containsKey(mappingId)) {
                	mappingSetMap.setMapping(mapObjs.get(mappingId));
                }
                
                mappingSet.getMappingSetMaps().add(mappingSetMap);
        	}
        }
        return mappingSets;
    }
}