Refactoring of archive creation

        if (URIUtils.isURIInternal(target)) {

            URIUtils.returnVosPathFromNodeURI(linkNode.getTarget(), authority);

        } else {

            // Let's discuss if we need to combine this validation with

            // TODO: Let's discuss if we need to combine this validation with

            // protocol endpoints management (URIService, ProtocolType)

            // Let's start with http and https only for now

            if (!(target.toLowerCase().startsWith("http://")

import it.inaf.ia2.aa.data.User;

import it.inaf.oats.vospace.datamodel.Views;

import it.inaf.oats.vospace.exception.InvalidArgumentException;

import it.inaf.oats.vospace.parent.exchange.ArchiveEntryDescriptor;

import java.io.OutputStream;

import java.util.ArrayList;

import java.util.List;

import org.springframework.http.MediaType;

import org.springframework.stereotype.Component;

import org.springframework.web.client.RestTemplate;

import static org.springframework.web.servlet.mvc.method.RequestMappingInfo.paths;

@Component

public class FileServiceClient {

            vosPaths.add(target);

        }

        // OK generate descriptors

        // follow links to links in vosPaths

        vosPaths = linkService.followLinksToLinks(vosPaths);

        List<ArchiveEntryDescriptor> entryDescriptors = linkService.followLinksForArchiveService(vosPaths);

        ArchiveRequest archiveRequest = new ArchiveRequest();

        archiveRequest.setJobId(jobId);

        archiveRequest.setPaths(vosPaths);

        archiveRequest.setEntryDescriptors(entryDescriptors);

        archiveRequest.setType(archiveTypeFromViewUri(transfer.getView().getUri()));

        String url = fileServiceUrl + "/archive";

        private String type;

        private String jobId;

        private List<String> paths;

        private List<ArchiveEntryDescriptor> entryDescriptors;        

        public String getType() {

            return type;

            this.jobId = jobId;

        }

        public List<String> getPaths() {

            return paths;

        public List<ArchiveEntryDescriptor> getEntryDescriptors() {

            return entryDescriptors;

        }

        public void setPaths(List<String> paths) {

            this.paths = paths;

        public void setEntryDescriptors(List<ArchiveEntryDescriptor> entryDescriptors) {

            this.entryDescriptors = entryDescriptors;

        }

    }

import it.inaf.oats.vospace.datamodel.NodeUtils;

import it.inaf.oats.vospace.exception.InternalFaultException;

import it.inaf.oats.vospace.parent.exchange.ArchiveEntryDescriptor;

import it.inaf.oats.vospace.persistence.NodeDAO;

import java.util.ArrayList;

import java.util.List;

    // Returns a new list = the list in argument with paths of links to links are substituted with 

    // their actual destination vos path. Only links to external resources 

    // (http:// ... ) should remain

    public List<String> followLinksToLinks(List<String> vosPaths) {

    public List<ArchiveEntryDescriptor> followLinksForArchiveService(List<String> vosPaths) {

        List<LinkNode> linkNodesInPaths = nodeDao.returnLinkNodesInList(vosPaths);

        // No links no change

        if(linkNodesInPaths.isEmpty())

            return vosPaths;

            return vosPaths.stream().map(p -> new ArchiveEntryDescriptor(p))

                    .collect(Collectors.toList());

        List<String> linkVosPaths = linkNodesInPaths.stream()

                .map(ln -> NodeUtils.getVosPath(ln)).collect(Collectors.toList());

        resultVosPaths.removeAll(linkVosPaths);

        // follow links and add resulting vos paths. The only remaining links

        // are expected to be external (http://... and so on)

        // Generate descriptors from non link vospaths

        List<ArchiveEntryDescriptor> resultDescriptors = 

                resultVosPaths.stream().map(p -> new ArchiveEntryDescriptor(p))

                        .collect(Collectors.toList());

        resultVosPaths.addAll(linkNodesInPaths.stream()

               .map(ln -> NodeUtils.getVosPath(this.followLink(ln)))

               .collect(Collectors.toList()));

        // Add descriptors from links

        resultDescriptors.addAll(

                linkNodesInPaths.stream().map(p -> getLinkNodeArchiveEntryDescriptor(p))

                .collect(Collectors.toList())       

        );              

        return resultVosPaths;                               

        return resultDescriptors;

    }

    private ArchiveEntryDescriptor getLinkNodeArchiveEntryDescriptor(LinkNode node){

        String vosPath = NodeUtils.getVosPath(node);

        String targetNodeVosPath = NodeUtils.getVosPath(this.followLink(node));

        return new ArchiveEntryDescriptor(vosPath, targetNodeVosPath);

    }

    public Node followLink(LinkNode linkNode) {

        ReflectionTestUtils.setField(fileServiceClient, "fileServiceUrl", "http://file-service");

    }

    // TODO: fix tests

    @Test

    public void testTarArchiveJob() {

        testStartArchiveJob(Views.TAR_VIEW_URI);

        ArchiveRequest archiveRequest = testStartArchiveJob(transfer);

        assertEquals(1, archiveRequest.getPaths().size());

        assertEquals("/mydir", archiveRequest.getPaths().get(0));

        //assertEquals(1, archiveRequest.getPaths().size());

        //assertEquals("/mydir", archiveRequest.getPaths().get(0));

    }

    @Test

        ArchiveRequest archiveRequest = testStartArchiveJob(transfer);

        assertEquals(2, archiveRequest.getPaths().size());

        assertEquals("/parent_dir/file1", archiveRequest.getPaths().get(0));

        assertEquals("/parent_dir/file2", archiveRequest.getPaths().get(1));

        //assertEquals(2, archiveRequest.getPaths().size());

        //assertEquals("/parent_dir/file1", archiveRequest.getPaths().get(0));

        //assertEquals("/parent_dir/file2", archiveRequest.getPaths().get(1));

    }

    private ArchiveRequest testStartArchiveJob(Transfer transfer) {