source/mircoders/media/MediaHandlerGeneric.java

   1 /*
   2  * Copyright (C) 2001, 2002 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30 package  mircoders.media;
  31
  32 import java.io.File;\r
  33 import java.io.FileInputStream;\r
  34 import java.io.InputStream;\r
  35 import java.util.List;\r
  36 import java.util.Vector;\r
  37 import javax.servlet.ServletContext;\r
  38 \r
  39 import mir.config.MirPropertiesConfiguration;\r
  40 import mir.entity.Entity;\r
  41 import mir.log.LoggerWrapper;\r
  42 import mir.media.MediaExc;\r
  43 import mir.media.MediaFailure;\r
  44 import mir.media.MirMedia;\r
  45 import mir.misc.FileUtil;\r
  46 import mir.misc.StringUtil;
  47
  48
  49 /**
  50  * This is the Generic MediaHandler. It stores the media data on
  51  * the filesystem and keeps basic metadata  (size, type...) in the
  52  * DB. Usually only representation needs to be overridden.
  53  * See the MediaHandlerAudio class to see an example of how one
  54  * could override it.
  55  * <p>
  56  * Most media handlers should override this class.
  57  * <p>
  58  * In theory, it could be used to handle miscellaneous media that
  59  * we don't have entered in the media_type table, (like RTF documents,
  60  * PS, PDF, etc..)
  61  * <p>
  62  * Of course it implements the MirMedia interface.
  63  *
  64  * @see mir.media.MirMedia
  65  * @author mh <mh@nadir.org>
  66  * @version $Id: MediaHandlerGeneric.java,v 1.20.2.2 2003/09/03 17:49:39 zapata Exp $
  67  */
  68
  69 public class MediaHandlerGeneric implements MirMedia
  70 {
  71     protected static MirPropertiesConfiguration configuration;
  72     protected static String imageHost;
  73     protected static String imageRoot;
  74
  75     protected LoggerWrapper logger;
  76
  77     static {
  78       try {
  79         configuration = MirPropertiesConfiguration.instance();
  80       }
  81       catch (MirPropertiesConfiguration.PropertiesConfigExc e) {
  82       }
  83       imageHost = configuration.getString("Producer.Image.Host");
  84       imageRoot = configuration.getString("Producer.ImageRoot");
  85     }
  86
  87     public MediaHandlerGeneric() {
  88       logger = new LoggerWrapper("Media.Generic");
  89     }
  90
  91     public void set (InputStream in, Entity ent, Entity mediaTypeEnt ) throws MediaExc, MediaFailure {
  92       String ext = mediaTypeEnt.getValue("name");
  93       String mediaFname = ent.getId() + "." + ext;
  94       String date = ent.getValue("date");
  95       String datePath = StringUtil.webdbDate2path(date);
  96       try {
  97         long size = FileUtil.write(getStoragePath() + File.separator + datePath +
  98                                    File.separator + mediaFname, in);
  99         ent.setValueForProperty("publish_path", datePath + mediaFname);
 100         ent.setValueForProperty("size", new Long(size).toString());
 101         ent.update();
 102       }
 103       catch (Throwable e) {
 104         logger.error("MediaHandlerGeneric.set: " + e.toString());
 105         throw new MediaFailure(e);
 106       }
 107     }
 108
 109     public void produce (Entity ent, Entity mediaTypeEnt ) throws MediaExc, MediaFailure {
 110       //check first if the media file exist since produced
 111       //location is also the storage location
 112
 113       String date = ent.getValue("date");
 114       String datePath = StringUtil.webdbDate2path(date);
 115       String relPath = datePath+ent.getId()+"."+mediaTypeEnt.getValue("name");
 116       String fname = getStoragePath()+relPath;
 117       if(! new File(fname).exists())
 118         throw new MediaExc("error in MirMedia.produce(): " + relPath + " does not exist!");
 119     }
 120
 121     public InputStream getMedia (Entity ent, Entity mediaTypeEnt) throws MediaExc, MediaFailure {
 122       String publishPath = ent.getValue("publish_path");
 123       String fname = getStoragePath()+publishPath;
 124       File f = new File(fname);
 125       if(! f.exists())
 126         throw new MediaExc("error in MirMedia.getMedia(): " + fname + " does not exist!");
 127
 128       FileInputStream inputStream;
 129       try {
 130         inputStream = new FileInputStream(f);
 131       }
 132       catch (Throwable e) {
 133         throw new MediaFailure("MediaHandlerGeneric.getMedia(): " + e.toString(), e);
 134       }
 135
 136       return inputStream;
 137     }
 138
 139     public InputStream getIcon (Entity ent) throws MediaExc, MediaFailure {
 140       return null;
 141     }
 142
 143     public String getIconMimeType (Entity aMediaEntity, Entity aMediaType) throws MediaExc, MediaFailure {
 144       ServletContext servletContext = MirPropertiesConfiguration.getContext();
 145       String fileName = aMediaEntity.getId()+"."+aMediaType.getValue("name");
 146
 147       return servletContext.getMimeType(fileName);
 148     };
 149
 150     public String getStoragePath()
 151     {
 152         return configuration.getString("Producer.Media.Path");
 153     }
 154
 155     public String getIconStoragePath()
 156     {
 157         return configuration.getString("Producer.Image.IconPath");
 158     }
 159
 160     public String getPublishHost()
 161     {
 162         return StringUtil.removeSlash(configuration.getString("Producer.Media.Host"));
 163     }
 164
 165     public String getTinyIconName()
 166     {
 167         return configuration.getString("Producer.Icon.TinyText");
 168     }
 169
 170     public String getBigIconName()
 171     {
 172         return configuration.getString("Producer.Icon.BigText");
 173     }
 174
 175     public String getIconAltName()
 176     {
 177         return "Generic media";
 178     }
 179
 180     public List getURL(Entity ent, Entity mediaTypeEnt)
 181     {
 182       List theList = new Vector();
 183       theList.add(ent);
 184       return theList;
 185     }
 186
 187     public boolean isVideo()
 188     {
 189       return false;
 190     }
 191
 192     public boolean isAudio()
 193     {
 194       return false;
 195     }
 196
 197     public boolean isImage()
 198     {
 199       return false;
 200     }
 201
 202     public String getDescr( Entity mediaType)
 203     {
 204       return mediaType.getValue("mime_type");
 205     }
 206
 207 }
 208
 209
 210