/* * Community.java * * Version: $Revision: 1.35 $ * * Date: $Date: 2005/07/19 18:47:13 $ * * Copyright (c) 2002-2005, Hewlett-Packard Company and Massachusetts * Institute of Technology.  All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are * met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * - Neither the name of the Hewlett-Packard Company nor the name of the * Massachusetts Institute of Technology nor the names of their * contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. */package org.dspace.content;import java.io.IOException;import java.io.InputStream;import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import org.apache.log4j.Logger;import org.dspace.authorize.AuthorizeException;import org.dspace.authorize.AuthorizeManager;import org.dspace.authorize.ResourcePolicy;import org.dspace.core.Constants;import org.dspace.core.Context;import org.dspace.core.LogManager;import org.dspace.eperson.Group;import org.dspace.handle.HandleManager;import org.dspace.history.HistoryManager;import org.dspace.search.DSIndexer;import org.dspace.storage.rdbms.DatabaseManager;import org.dspace.storage.rdbms.TableRow;import org.dspace.storage.rdbms.TableRowIterator;/** * Class representing a community * <P> * The community's metadata (name, introductory text etc.) is loaded into' * memory. Changes to this metadata are only reflected in the database after * <code>update</code> is called. *  * @author Robert Tansley * @version $Revision: 1.35 $ */public class Community extends DSpaceObject{    /** log4j category */    private static Logger log = Logger.getLogger(Community.class);    /** Our context */    private Context ourContext;    /** The table row corresponding to this item */    private TableRow communityRow;    /** The logo bitstream */    private Bitstream logo;    /** Handle, if any */    private String handle;    /**     * Construct a community object from a database row.     *      * @param context     *            the context this object exists in     * @param row     *            the corresponding row in the table     */    Community(Context context, TableRow row) throws SQLException    {        ourContext = context;        communityRow = row;        // Get the logo bitstream        if (communityRow.isColumnNull("logo_bitstream_id"))        {            logo = null;        }        else        {            logo = Bitstream.find(ourContext, communityRow                    .getIntColumn("logo_bitstream_id"));        }        // Get our Handle if any        handle = HandleManager.findHandle(context, this);        // Cache ourselves        context.cache(this, row.getIntColumn("community_id"));    }    /**     * Get a community from the database. Loads in the metadata     *      * @param context     *            DSpace context object     * @param id     *            ID of the community     *      * @return the community, or null if the ID is invalid.     */    public static Community find(Context context, int id) throws SQLException    {        // First check the cache        Community fromCache = (Community) context                .fromCache(Community.class, id);        if (fromCache != null)        {            return fromCache;        }        TableRow row = DatabaseManager.find(context, "community", id);        if (row == null)        {            if (log.isDebugEnabled())            {                log.debug(LogManager.getHeader(context, "find_community",                        "not_found,community_id=" + id));            }            return null;        }        else        {            if (log.isDebugEnabled())            {                log.debug(LogManager.getHeader(context, "find_community",                        "community_id=" + id));            }            return new Community(context, row);        }    }    /**     * Create a new community, with a new ID.     *      * @param context     *            DSpace context object     *      * @return the newly created community     */    public static Community create(Community parent, Context context)            throws SQLException, AuthorizeException    {        // Only administrators and adders can create communities        if (!(AuthorizeManager.isAdmin(context) || AuthorizeManager                .authorizeActionBoolean(context, parent, Constants.ADD)))        {            throw new AuthorizeException(                    "Only administrators can create communities");        }        TableRow row = DatabaseManager.create(context, "community");        Community c = new Community(context, row);        c.handle = HandleManager.createHandle(context, c);        // create the default authorization policy for communities        // of 'anonymous' READ        Group anonymousGroup = Group.find(context, 0);        ResourcePolicy myPolicy = ResourcePolicy.create(context);        myPolicy.setResource(c);        myPolicy.setAction(Constants.READ);        myPolicy.setGroup(anonymousGroup);        myPolicy.update();        HistoryManager.saveHistory(context, c, HistoryManager.CREATE, context                .getCurrentUser(), context.getExtraLogInfo());        log.info(LogManager.getHeader(context, "create_community",                "community_id=" + row.getIntColumn("community_id"))                + ",handle=" + c.handle);        return c;    }    /**     * Get a list of all communities in the system. These are alphabetically     * sorted by community name.     *      * @param context     *            DSpace context object     *      * @return the communities in the system     */    public static Community[] findAll(Context context) throws SQLException    {        TableRowIterator tri = DatabaseManager.query(context, "community",                "SELECT * FROM community ORDER BY name");        List communities = new ArrayList();        while (tri.hasNext())        {            TableRow row = tri.next();            // First check the cache            Community fromCache = (Community) context.fromCache(                    Community.class, row.getIntColumn("community_id"));            if (fromCache != null)            {                communities.add(fromCache);            }            else            {                communities.add(new Community(context, row));            }        }        // close the TableRowIterator to free up resources        tri.close();        Community[] communityArray = new Community[communities.size()];        communityArray = (Community[]) communities.toArray(communityArray);        return communityArray;    }    /**     * Get a list of all top-level communities in the system. These are     * alphabetically sorted by community name. A top-level community is one     * without a parent community.     *      * @param context     *            DSpace context object     *      * @return the top-level communities in the system     */    public static Community[] findAllTop(Context context) throws SQLException    {        // get all communities that are not children        TableRowIterator tri = DatabaseManager.query(context, "community",                "SELECT * FROM community WHERE NOT community_id IN "                        + "(SELECT child_comm_id FROM community2community) "                        + "ORDER BY name");        List topCommunities = new ArrayList();        while (tri.hasNext())        {            TableRow row = tri.next();            // First check the cache            Community fromCache = (Community) context.fromCache(                    Community.class, row.getIntColumn("community_id"));            if (fromCache != null)            {                topCommunities.add(fromCache);            }            else            {                topCommunities.add(new Community(context, row));            }        }        // close the TableRowIterator to free up resources        tri.close();        Community[] communityArray = new Community[topCommunities.size()];        communityArray = (Community[]) topCommunities.toArray(communityArray);        return communityArray;    }    /**     * Get the internal ID of this collection     *      * @return the internal identifier     */    public int getID()    {        return communityRow.getIntColumn("community_id");    }    public String getHandle()    {        return handle;    }    /**     * Get the value of a metadata field     *      * @param field     *            the name of the metadata field to get     *      * @return the value of the metadata field     *