source/mircoders/storage/DatabaseContent.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.storage;
  33
  34 import java.sql.Connection;
  35 import java.sql.Statement;
  36
  37 import mir.entity.EntityList;
  38 import mir.entity.EntityRelation;
  39 import mir.log.LoggerWrapper;
  40 import mir.storage.Database;
  41 import mir.storage.StorageObject;
  42 import mir.storage.StorageObjectFailure;
  43 import mircoders.entity.EntityContent;
  44
  45 /**
  46  * <b>this class implements the access to the content-table</b>
  47  *
  48  *
  49  */
  50
  51 public class DatabaseContent extends Database implements StorageObject {
  52
  53   private static DatabaseContent      instance;
  54   private static EntityRelation       relationComments;
  55   private static EntityRelation       relationFeature;
  56
  57   // Contructors / Singleton
  58
  59   // the following *has* to be sychronized cause this static method
  60   // could get preemted and we could end up with 2 instances of DatabaseFoo.
  61   // see the "Singletons with needles and thread" article at JavaWorld -mh
  62   public synchronized static DatabaseContent getInstance()
  63     throws StorageObjectFailure {
  64
  65     if (instance == null ) {
  66       instance = new DatabaseContent();
  67       instance.myselfDatabase = instance;
  68     }
  69     return instance;
  70   }
  71
  72   private DatabaseContent() throws StorageObjectFailure {
  73
  74     super();
  75     theTable="content";
  76     theCoreTable="media";
  77     logger = new LoggerWrapper("Database.Content");
  78
  79     relationComments =
  80         new EntityRelation("id", "to_media", DatabaseComment.getInstance(), EntityRelation.TO_MANY);
  81     relationFeature =
  82         new EntityRelation("id", "to_feature", DatabaseFeature.getInstance(), EntityRelation.TO_ONE);
  83     theEntityClass = mircoders.entity.EntityContent.class;
  84   }
  85
  86   // methods
  87
  88   /**
  89    * sets the database flag is_produced to unproduced
  90    */
  91
  92   public void setUnproduced(String where) throws StorageObjectFailure
  93   {
  94     Connection con=null;Statement stmt=null;
  95     String sql = "update content set is_produced='0' where " + where;
  96     logger.debug("set unproduced: "+where);
  97     try {
  98       con = getPooledCon();
  99       // should be a preparedStatement because is faster
 100       stmt = con.createStatement();
 101       executeUpdate(stmt,sql);
 102       logger.debug("set unproduced: "+where);
 103     }
 104     catch (Exception e) {_throwStorageObjectException(e, "-- set unproduced failed");}
 105     finally { freeConnection(con,stmt);}
 106   }
 107
 108   /**
 109    * returns the comments that belong to the article (via entityrelation)
 110    * where db-flag is_published is true
 111    */
 112   public EntityList getComments(EntityContent entC) throws StorageObjectFailure {
 113     return relationComments.getMany(entC,"webdb_create","is_published='1'");
 114   }
 115
 116   /**
 117    * returns the features that belong to the article (via entityrelation)
 118    */
 119   public EntityList getFeature(EntityContent entC) throws StorageObjectFailure {
 120     return relationFeature.getMany(entC);
 121   }
 122
 123   public boolean delete(String id) throws StorageObjectFailure
 124   {
 125     DatabaseComment.getInstance().deleteByContentId(id);
 126     super.delete(id);
 127     return true;
 128   }
 129
 130 }