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