4568

pending completion

Build # 4568

Build Type

push

travis-ci

Committed by

dkayiwa

Commit Message

TRUNK-4977: ImageHandler to delete trailing 0-byte files.

  modified:   api/src/main/java/org/openmrs/obs/handler/ImageHandler.java

(cherry picked from commit 410dd584f)

Run Details

4 of 4 new or added lines in 1 file covered. (100.0%)

18091 of 32348 relevant lines covered (55.93%)

0.56 hits per line

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

42.86

/api/src/main/java/org/openmrs/obs/handler/ImageHandler.java

/**
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
 * the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
 *
 * Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
 * graphic logo is a trademark of OpenMRS Inc.
 */
package org.openmrs.obs.handler;

import java.awt.image.BufferedImage;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.HashSet;
import java.util.Set;
import java.util.Iterator;

import javax.imageio.ImageIO;
import javax.imageio.ImageReader;
import javax.imageio.stream.FileImageInputStream;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.openmrs.Obs;
import org.openmrs.api.APIException;
import org.openmrs.obs.ComplexData;
import org.openmrs.obs.ComplexObsHandler;

/**
 * Handler for storing basic images for complex obs to the file system. The image mime type used is
 * taken from the image name. if the .* image name suffix matches
 * {@link javax.imageio.ImageIO#getWriterFormatNames()} then that mime type will be used to save the
 * image. Images are stored in the location specified by the global property: "obs.complex_obs_dir"
 * 
 * @see org.openmrs.util.OpenmrsConstants#GLOBAL_PROPERTY_COMPLEX_OBS_DIR
 * @since 1.5
 */
public class ImageHandler extends AbstractHandler implements ComplexObsHandler {
        
        /** Views supported by this handler */
        private static final String[] supportedViews = { ComplexObsHandler.RAW_VIEW };
        
        public static final Log log = LogFactory.getLog(ImageHandler.class);
        
        private Set<String> extensions;
        
        /**
         * Constructor initializes formats for alternative file names to protect from unintentionally
         * overwriting existing files.
         */
        public ImageHandler() {
                super();
                
                // Create a HashSet to quickly check for supported extensions.
                extensions = new HashSet<String>();
                for (String mt : ImageIO.getWriterFormatNames()) {
                        extensions.add(mt);
                }
        }
        
        /**
         * Currently supports all views and puts the Image file data into the ComplexData object
         * 
         * @see org.openmrs.obs.ComplexObsHandler#getObs(org.openmrs.Obs, java.lang.String)
         */
        public Obs getObs(Obs obs, String view) {
                File file = getComplexDataFile(obs);
                
                // Raw image
                if (ComplexObsHandler.RAW_VIEW.equals(view)) {
                        BufferedImage img = null;
                        try {
                                img = ImageIO.read(file);
                        }
                        catch (IOException e) {
                                log.error("Trying to read file: " + file.getAbsolutePath(), e);
                        }
                        
                        ComplexData complexData = new ComplexData(file.getName(), img);
                        
                        // Image MIME type
                        try {
                                FileImageInputStream imgStream = new FileImageInputStream(file);
                                Iterator<ImageReader> imgReader = ImageIO.getImageReaders(imgStream);
                                imgStream.close();
                                if (imgReader.hasNext()) {
                                        complexData.setMimeType("image/" + imgReader.next().getFormatName().toLowerCase());
                                } else {
                                        log.warn("MIME type of " + file.getAbsolutePath() + " is not known");
                                }
                        }
                        catch (FileNotFoundException e) {
                                log.error("Image " + file.getAbsolutePath() + " was not found", e);
                        }
                        catch (IOException e) {
                                log.error("Trying to determine MIME type of " + file.getAbsolutePath(), e);
                        }
                        
                        obs.setComplexData(complexData);
                } else {
                        // No other view supported
                        // NOTE: if adding support for another view, don't forget to update supportedViews list above
                        return null;
                }
                
                return obs;
        }
        
        /**
         * @see org.openmrs.obs.ComplexObsHandler#getSupportedViews()
         */
        @Override
        public String[] getSupportedViews() {
                return supportedViews;
        }
        
        /**
         * @see org.openmrs.obs.ComplexObsHandler#saveObs(org.openmrs.Obs)
         */
        public Obs saveObs(Obs obs) throws APIException {
                // Get the buffered image from the ComplexData.
                BufferedImage img = null;
                
                Object data = obs.getComplexData().getData();
                if (data instanceof BufferedImage) {
                        img = (BufferedImage) obs.getComplexData().getData();
                } else if (data instanceof InputStream) {
                        try {
                                img = ImageIO.read((InputStream) data);
                                if (img == null) {
                                        throw new IllegalArgumentException("Invalid image file");
                                }
                        }
                        catch (IOException e) {
                                throw new APIException("Obs.error.unable.convert.complex.data", new Object[] { "input stream" }, e);
                        }
                }
                
                if (img == null) {
                        throw new APIException("Obs.error.cannot.save.complex", new Object[] { obs.getObsId() });
                }
                
                File outfile = null;
                try {
                        outfile = getOutputFileToWrite(obs);
                        
                        String extension = getExtension(obs.getComplexData().getTitle());
                        
                        // TODO: Check this extension against the registered extensions for validity
                        
                        // Write the file to the file system.
                        ImageIO.write(img, extension, outfile);
                        
                        // Set the Title and URI for the valueComplex
                        obs.setValueComplex(extension + " image |" + outfile.getName());
                        
                        // Remove the ComlexData from the Obs
                        obs.setComplexData(null);
                        
                }
                catch (IOException ioe) {
                   if (outfile != null && outfile.length() == 0) {
                      outfile.delete(); // OpenJDK 7 & 8 may leave a 0-byte file when ImageIO.write(..) fails.
                   }
                        throw new APIException("Obs.error.trying.write.complex", null, ioe);
                }
                
                return obs;
        }
        
}

1	/**
2	* This Source Code Form is subject to the terms of the Mozilla Public License,
3	* v. 2.0. If a copy of the MPL was not distributed with this file, You can
4	* obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
5	* the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
6	*
7	* Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
8	* graphic logo is a trademark of OpenMRS Inc.
9	*/
10	package org.openmrs.obs.handler;
11
12	import java.awt.image.BufferedImage;
13	import java.io.File;
14	import java.io.FileNotFoundException;
15	import java.io.IOException;
16	import java.io.InputStream;
17	import java.util.HashSet;
18	import java.util.Set;
19	import java.util.Iterator;
20
21	import javax.imageio.ImageIO;
22	import javax.imageio.ImageReader;
23	import javax.imageio.stream.FileImageInputStream;
24
25	import org.apache.commons.logging.Log;
26	import org.apache.commons.logging.LogFactory;
27	import org.openmrs.Obs;
28	import org.openmrs.api.APIException;
29	import org.openmrs.obs.ComplexData;
30	import org.openmrs.obs.ComplexObsHandler;
31
32	/**
33	* Handler for storing basic images for complex obs to the file system. The image mime type used is
34	* taken from the image name. if the .* image name suffix matches
35	* {@link javax.imageio.ImageIO#getWriterFormatNames()} then that mime type will be used to save the
36	* image. Images are stored in the location specified by the global property: "obs.complex_obs_dir"
37	*
38	* @see org.openmrs.util.OpenmrsConstants#GLOBAL_PROPERTY_COMPLEX_OBS_DIR
39	* @since 1.5
40	*/
41	public class ImageHandler extends AbstractHandler implements ComplexObsHandler {
42
43	/** Views supported by this handler */
44	private static final String[] supportedViews = { ComplexObsHandler.RAW_VIEW };	1✔
45
46	public static final Log log = LogFactory.getLog(ImageHandler.class);	1✔
47
48	private Set<String> extensions;
49
50	/**
51	* Constructor initializes formats for alternative file names to protect from unintentionally
52	* overwriting existing files.
53	*/
54	public ImageHandler() {
55	super();	1✔
56
57	// Create a HashSet to quickly check for supported extensions.
58	extensions = new HashSet<String>();	1✔
59	for (String mt : ImageIO.getWriterFormatNames()) {	1✔
60	extensions.add(mt);	1✔
61	}
62	}	1✔
63
64	/**
65	* Currently supports all views and puts the Image file data into the ComplexData object
66	*
67	* @see org.openmrs.obs.ComplexObsHandler#getObs(org.openmrs.Obs, java.lang.String)
68	*/
69	public Obs getObs(Obs obs, String view) {
70	File file = getComplexDataFile(obs);	1✔
71
72	// Raw image
73	if (ComplexObsHandler.RAW_VIEW.equals(view)) {	1✔
74	BufferedImage img = null;	1✔
75	try {
76	img = ImageIO.read(file);	1✔
77	}
78	catch (IOException e) {	×
79	log.error("Trying to read file: " + file.getAbsolutePath(), e);	×
80	}	1✔
81
82	ComplexData complexData = new ComplexData(file.getName(), img);	1✔
83
84	// Image MIME type
85	try {
86	FileImageInputStream imgStream = new FileImageInputStream(file);	1✔
87	Iterator<ImageReader> imgReader = ImageIO.getImageReaders(imgStream);	1✔
88	imgStream.close();	1✔
89	if (imgReader.hasNext()) {	1✔
90	complexData.setMimeType("image/" + imgReader.next().getFormatName().toLowerCase());	1✔
91	} else {
92	log.warn("MIME type of " + file.getAbsolutePath() + " is not known");	×
93	}
94	}
95	catch (FileNotFoundException e) {	×
96	log.error("Image " + file.getAbsolutePath() + " was not found", e);	×
97	}
98	catch (IOException e) {	×
99	log.error("Trying to determine MIME type of " + file.getAbsolutePath(), e);	×
100	}	1✔
101
102	obs.setComplexData(complexData);	1✔
103	} else {	1✔
104	// No other view supported
105	// NOTE: if adding support for another view, don't forget to update supportedViews list above
106	return null;	1✔
107	}
108
109	return obs;	1✔
110	}
111
112	/**
113	* @see org.openmrs.obs.ComplexObsHandler#getSupportedViews()
114	*/
115	@Override
116	public String[] getSupportedViews() {
117	return supportedViews;	1✔
118	}
119
120	/**
121	* @see org.openmrs.obs.ComplexObsHandler#saveObs(org.openmrs.Obs)
122	*/
123	public Obs saveObs(Obs obs) throws APIException {
124	// Get the buffered image from the ComplexData.
125	BufferedImage img = null;	×
126
127	Object data = obs.getComplexData().getData();	×
128	if (data instanceof BufferedImage) {	×
129	img = (BufferedImage) obs.getComplexData().getData();	×
130	} else if (data instanceof InputStream) {	×
131	try {
132	img = ImageIO.read((InputStream) data);	×
133	if (img == null) {	×
134	throw new IllegalArgumentException("Invalid image file");	×
135	}
136	}
137	catch (IOException e) {	×
138	throw new APIException("Obs.error.unable.convert.complex.data", new Object[] { "input stream" }, e);	×
139	}	×
140	}
141
142	if (img == null) {	×
143	throw new APIException("Obs.error.cannot.save.complex", new Object[] { obs.getObsId() });	×
144	}
145
146	File outfile = null;	×
147	try {
148	outfile = getOutputFileToWrite(obs);	×
149
150	String extension = getExtension(obs.getComplexData().getTitle());	×
151
152	// TODO: Check this extension against the registered extensions for validity
153
154	// Write the file to the file system.
155	ImageIO.write(img, extension, outfile);	×
156
157	// Set the Title and URI for the valueComplex
158	obs.setValueComplex(extension + " image \|" + outfile.getName());	×
159
160	// Remove the ComlexData from the Obs
161	obs.setComplexData(null);	×
162
163	}
164	catch (IOException ioe) {	×
165	if (outfile != null && outfile.length() == 0) {	×
166	outfile.delete(); // OpenJDK 7 & 8 may leave a 0-byte file when ImageIO.write(..) fails.	×
167	}
168	throw new APIException("Obs.error.trying.write.complex", null, ioe);	×
169	}	×
170
171	return obs;	×
172	}
173
174	}

openmrs / openmrs-core / 4568

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