#23576

Committed 25 Oct 2024 05:00PM UTC coverage: 21.181% (+0.3%) from 20.86%

Build # #23576

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #10899 from DANS-KNAW-jp/10898-own-cloud-zips

replace ZipInputStream with ZipFile

Run Details

71 of 98 new or added lines in 4 files covered. (72.45%)

4 existing lines in 3 files now uncovered.

18243 of 86130 relevant lines covered (21.18%)

0.21 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

36.36

/src/main/java/edu/harvard/iq/dataverse/ingest/IngestServiceShapefileHelper.java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package edu.harvard.iq.dataverse.ingest;

import edu.harvard.iq.dataverse.DataFile;
//import edu.harvard.iq.dataverse.DataFileServiceBean;
import edu.harvard.iq.dataverse.DatasetVersion;
import edu.harvard.iq.dataverse.util.ShapefileHandler;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;
import java.util.logging.Logger;
//import jakarta.ejb.EJB;

/**
 *  Used by the IngestServiceBean to redistribute a zipped Shapefile*
 * 
 *  - Accomplish the actions described in the ShapefileHandler function "rezipShapefileSets"
 *  - Return a list of DataFile objects
 * 
 * @author raprasad
 */
public class IngestServiceShapefileHelper {
    
    //@EJB
    //DataFileServiceBean fileService; 

    /*
        code to add to IngestServiceBean
            File rezipFolder = this.getShapefileUnzipTempDirectory();
            IngestServiceShapefileHelper shapefileIngestHelper = new IngestServiceShapefileHelper(tempFile.toFile(), rezipFolder);
            List<DataFile> dataFiles = shapefileIngestHelper.getDataFiles();
            rezipFolder.delete();
     */
    
    private static final Logger logger = Logger.getLogger(IngestServiceShapefileHelper.class.getCanonicalName());

    private ShapefileHandler shpHandler;
    private DatasetVersion datasetVersion;
    List<DataFile> dataFileList = null;
    private File zippedShapefile;
    private File rezipFolder;

  
    
    public List<DataFile> getDataFileList(){
        if (this.dataFileList==null){
            return null;
        }
        if (this.dataFileList.size()==0){
            return null;
        }
        return this.dataFileList;
    }
    
    private boolean isValidFile(File fileObject){
        
         if (fileObject==null){
            logger.warning("fileObject was null");
            return false;
        }
        if (!fileObject.isFile()){
            logger.warning("fileObject was not a file.  Failed \"isFile()\": " + fileObject.getAbsolutePath());
            return false;
        }
        return true;
    }
    
    
   private boolean isValidFolder(File fileObject){
        
         if (fileObject==null){
            logger.warning("fileObject was null");
            return false;
        }
        if (!fileObject.isDirectory()){
            logger.warning("fileObject was not a directory.  Failed \"isFile()\": " + fileObject.getAbsolutePath());
            return false;
        }
        return true;
    }
    /*
        Constructor that accepts a file object
    */
   public IngestServiceShapefileHelper(File zippedShapefile, File rezipFolder){
        
        if ((!isValidFile(zippedShapefile))||(!isValidFolder(rezipFolder))){
            return;
        }
        this.zippedShapefile = zippedShapefile;
        this.rezipFolder = rezipFolder;
        //this.datasetVersion = version;

        //this.processFile(zippedShapefile, rezipFolder);

    }

    private FileInputStream getFileInputStream(File fileObject){
        if (fileObject==null){
            return null;
        }
        try {
            return new FileInputStream(fileObject);
        } catch (FileNotFoundException ex) {
            logger.severe("Failed to create FileInputStream from File: " + fileObject.getAbsolutePath());
            return null;
        }
    }

    private void closeFileInputStream(FileInputStream fis){
        if (fis==null){
            return;
        }
        try {
            fis.close();
        } catch (IOException ex) {
            logger.info("Failed to close FileInputStream");
        }
    }

    public boolean processFile() {
       
       if ((!isValidFile(this.zippedShapefile))||(!isValidFolder(this.rezipFolder))){
            return false;
        }
        try {
            this.shpHandler = new ShapefileHandler(zippedShapefile);
            if (!shpHandler.containsShapefile()){
                logger.severe("Shapefile was incorrectly detected upon Ingest (FileUtil) and passed here");
                return false;
            }
            logger.info("rezipFolder: " + rezipFolder.getAbsolutePath());
            return shpHandler.rezipShapefileSets(rezipFolder);
        } catch (IOException ex) {
            logger.severe("Shapefile was not correctly unpacked/repacked");
            logger.severe("shpHandler message: " + shpHandler.errorMessage);
            return false;
        }
        //   return createDataFiles(rezipFolder);
        
    }
    
    
    public List<File> getFinalRezippedFiles(){
        if (this.shpHandler==null){
            return null;
        }
        return this.shpHandler.getFinalRezippedFiles();
    }
    /*
        Note: This creates DataFile objects, the files themselves already exist!
    */
    /*
    private boolean createDataFiles(File rezipFolder){
        if (!isValidFolder(rezipFolder)){
            return false;
        }
        
        // Initialize dataFileList
        this.dataFileList = new ArrayList<DataFile>(); 

        for (File singleFile : rezipFolder.listFiles()){
            if (!singleFile.isFile()){
                continue; // not a file
            }
            DataFile datafile = createSingleDataFile(singleFile);
            if (!(datafile==null)){
                   this.dataFileList.add(datafile);
            }           
        }
        
        return false;
    }
    */
    
    
}

1	/*
2	* To change this license header, choose License Headers in Project Properties.
3	* To change this template file, choose Tools \| Templates
4	* and open the template in the editor.
5	*/
6
7	package edu.harvard.iq.dataverse.ingest;
8
9	import edu.harvard.iq.dataverse.DataFile;
10	//import edu.harvard.iq.dataverse.DataFileServiceBean;
11	import edu.harvard.iq.dataverse.DatasetVersion;
12	import edu.harvard.iq.dataverse.util.ShapefileHandler;
13	import java.io.File;
14	import java.io.FileInputStream;
15	import java.io.FileNotFoundException;
16	import java.io.IOException;
17	import java.util.List;
18	import java.util.logging.Logger;
19	//import jakarta.ejb.EJB;
20
21	/**
22	* Used by the IngestServiceBean to redistribute a zipped Shapefile*
23	*
24	* - Accomplish the actions described in the ShapefileHandler function "rezipShapefileSets"
25	* - Return a list of DataFile objects
26	*
27	* @author raprasad
28	*/
29	public class IngestServiceShapefileHelper {
30
31	//@EJB
32	//DataFileServiceBean fileService;
33
34	/*
35	code to add to IngestServiceBean
36	File rezipFolder = this.getShapefileUnzipTempDirectory();
37	IngestServiceShapefileHelper shapefileIngestHelper = new IngestServiceShapefileHelper(tempFile.toFile(), rezipFolder);
38	List<DataFile> dataFiles = shapefileIngestHelper.getDataFiles();
39	rezipFolder.delete();
40	*/
41
42	private static final Logger logger = Logger.getLogger(IngestServiceShapefileHelper.class.getCanonicalName());	1✔
43
44	private ShapefileHandler shpHandler;
45	private DatasetVersion datasetVersion;
46	List<DataFile> dataFileList = null;	1✔
47	private File zippedShapefile;
48	private File rezipFolder;
49
50
51
52	public List<DataFile> getDataFileList(){
53	if (this.dataFileList==null){	×
54	return null;	×
55	}
56	if (this.dataFileList.size()==0){	×
57	return null;	×
58	}
59	return this.dataFileList;	×
60	}
61
62	private boolean isValidFile(File fileObject){
63
64	if (fileObject==null){	1✔
65	logger.warning("fileObject was null");	×
66	return false;	×
67	}
68	if (!fileObject.isFile()){	1✔
69	logger.warning("fileObject was not a file. Failed \"isFile()\": " + fileObject.getAbsolutePath());	×
70	return false;	×
71	}
72	return true;	1✔
73	}
74
75
76	private boolean isValidFolder(File fileObject){
77
78	if (fileObject==null){	1✔
79	logger.warning("fileObject was null");	×
80	return false;	×
81	}
82	if (!fileObject.isDirectory()){	1✔
83	logger.warning("fileObject was not a directory. Failed \"isFile()\": " + fileObject.getAbsolutePath());	×
84	return false;	×
85	}
86	return true;	1✔
87	}
88	/*
89	Constructor that accepts a file object
90	*/
91	public IngestServiceShapefileHelper(File zippedShapefile, File rezipFolder){	1✔
92
93	if ((!isValidFile(zippedShapefile))\|\|(!isValidFolder(rezipFolder))){	1✔
94	return;	×
95	}
96	this.zippedShapefile = zippedShapefile;	1✔
97	this.rezipFolder = rezipFolder;	1✔
98	//this.datasetVersion = version;
99
100	//this.processFile(zippedShapefile, rezipFolder);
101
102	}	1✔
103
104	private FileInputStream getFileInputStream(File fileObject){
NEW 105	if (fileObject==null){	×
NEW 106	return null;	×
107	}
108	try {
109	return new FileInputStream(fileObject);	×
110	} catch (FileNotFoundException ex) {	×
111	logger.severe("Failed to create FileInputStream from File: " + fileObject.getAbsolutePath());	×
112	return null;	×
113	}
114	}
115
116	private void closeFileInputStream(FileInputStream fis){
NEW 117	if (fis==null){	×
NEW 118	return;	×
119	}
120	try {
NEW 121	fis.close();	×
122	} catch (IOException ex) {	×
123	logger.info("Failed to close FileInputStream");	×
124	}	×
NEW 125	}	×
126
127	public boolean processFile() {
128
129	if ((!isValidFile(this.zippedShapefile))\|\|(!isValidFolder(this.rezipFolder))){	1✔
130	return false;	×
131	}
132	try {
133	this.shpHandler = new ShapefileHandler(zippedShapefile);	1✔
134	if (!shpHandler.containsShapefile()){	1✔
NEW 135	logger.severe("Shapefile was incorrectly detected upon Ingest (FileUtil) and passed here");	×
NEW 136	return false;	×
137	}
138	logger.info("rezipFolder: " + rezipFolder.getAbsolutePath());	1✔
139	return shpHandler.rezipShapefileSets(rezipFolder);	1✔
140	} catch (IOException ex) {	×
141	logger.severe("Shapefile was not correctly unpacked/repacked");	×
142	logger.severe("shpHandler message: " + shpHandler.errorMessage);	×
143	return false;	×
144	}
145	// return createDataFiles(rezipFolder);
146
147	}
148
149
150	public List<File> getFinalRezippedFiles(){
151	if (this.shpHandler==null){	1✔
152	return null;	×
153	}
154	return this.shpHandler.getFinalRezippedFiles();	1✔
155	}
156	/*
157	Note: This creates DataFile objects, the files themselves already exist!
158	*/
159	/*
160	private boolean createDataFiles(File rezipFolder){
161	if (!isValidFolder(rezipFolder)){
162	return false;
163	}
164
165	// Initialize dataFileList
166	this.dataFileList = new ArrayList<DataFile>();
167
168	for (File singleFile : rezipFolder.listFiles()){
169	if (!singleFile.isFile()){
170	continue; // not a file
171	}
172	DataFile datafile = createSingleDataFile(singleFile);
173	if (!(datafile==null)){
174	this.dataFileList.add(datafile);
175	}
176	}
177
178	return false;
179	}
180	*/
181
182
183	}

IQSS / dataverse / #23576

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous