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