org.dspace.content.dao.impl.BitstreamDAOImpl.java Source code

Introduction

Here is the source code for org.dspace.content.dao.impl.BitstreamDAOImpl.java

Source

/**
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE and NOTICE files at the root of the source
 * tree and available online at
 *
 * http://www.dspace.org/license/
 */
package org.dspace.content.dao.impl;

import org.dspace.content.Bitstream;
import org.dspace.content.Collection;
import org.dspace.content.Community;
import org.dspace.content.Item;
import org.dspace.content.dao.BitstreamDAO;
import org.dspace.core.AbstractHibernateDSODAO;
import org.dspace.core.Constants;
import org.dspace.core.Context;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.Restrictions;

import java.sql.SQLException;
import java.util.Iterator;
import java.util.List;

/**
 * Hibernate implementation of the Database Access Object interface class for the Bitstream object.
 * This class is responsible for all database calls for the Bitstream object and is autowired by spring
 * This class should never be accessed directly.
 *
 * @author kevinvandevelde at atmire.com
 */
public class BitstreamDAOImpl extends AbstractHibernateDSODAO<Bitstream> implements BitstreamDAO {

    protected BitstreamDAOImpl() {
        super();
    }

    @Override
    public List<Bitstream> findDeletedBitstreams(Context context) throws SQLException {
        Criteria criteria = createCriteria(context, Bitstream.class);
        criteria.add(Restrictions.eq("deleted", true));

        return list(criteria);

    }

    @Override
    public List<Bitstream> findDuplicateInternalIdentifier(Context context, Bitstream bitstream)
            throws SQLException {
        Criteria criteria = createCriteria(context, Bitstream.class);
        criteria.add(Restrictions.and(Restrictions.eq("internalId", bitstream.getInternalId()),
                Restrictions.not(Restrictions.eq("id", bitstream.getID()))));

        return list(criteria);
    }

    @Override
    public List<Bitstream> findBitstreamsWithNoRecentChecksum(Context context) throws SQLException {
        //        "select bitstream.deleted, bitstream.store_number, bitstream.size_bytes, "
        //                    + "bitstreamformatregistry.short_description, bitstream.bitstream_id,  "
        //                    + "bitstream.user_format_description, bitstream.internal_id, "
        //                    + "bitstream.source, bitstream.checksum_algorithm, bitstream.checksum, "
        //                    + "bitstream.name, bitstream.description "
        //                    + "from bitstream left outer join bitstreamformatregistry on "
        //                    + "bitstream.bitstream_format_id = bitstreamformatregistry.bitstream_format_id "
        //                    + "where not exists( select 'x' from most_recent_checksum "
        //                    + "where most_recent_checksum.bitstream_id = bitstream.bitstream_id )"

        Query query = createQuery(context,
                "select b from Bitstream b where b not in (select c.bitstream from MostRecentChecksum c)");
        return query.list();
    }

    @Override
    public Iterator<Bitstream> findByCommunity(Context context, Community community) throws SQLException {
        Query query = createQuery(context,
                "select b from Bitstream b " + "join b.bundles bitBundles " + "join bitBundles.items item "
                        + "join item.collections itemColl " + "join itemColl.communities community "
                        + "WHERE :community IN community");

        query.setParameter("community", community);

        return iterate(query);
    }

    @Override
    public Iterator<Bitstream> findByCollection(Context context, Collection collection) throws SQLException {
        Query query = createQuery(context, "select b from Bitstream b " + "join b.bundles bitBundles "
                + "join bitBundles.items item " + "join item.collections c " + "WHERE :collection IN c");

        query.setParameter("collection", collection);

        return iterate(query);
    }

    @Override
    public Iterator<Bitstream> findByItem(Context context, Item item) throws SQLException {
        Query query = createQuery(context, "select b from Bitstream b " + "join b.bundles bitBundles "
                + "join bitBundles.items item " + "WHERE :item IN item");

        query.setParameter("item", item);

        return iterate(query);
    }

    @Override
    public Iterator<Bitstream> findByStoreNumber(Context context, Integer storeNumber) throws SQLException {
        Query query = createQuery(context, "select b from Bitstream b where b.storeNumber = :storeNumber");
        query.setParameter("storeNumber", storeNumber);
        return iterate(query);
    }

    @Override
    public Long countByStoreNumber(Context context, Integer storeNumber) throws SQLException {
        Criteria criteria = createCriteria(context, Bitstream.class);
        criteria.add(Restrictions.eq("storeNumber", storeNumber));
        return countLong(criteria);
    }

    @Override
    public int countRows(Context context) throws SQLException {
        return count(createQuery(context, "SELECT count(*) from Bitstream"));
    }

    @Override
    public int countDeleted(Context context) throws SQLException {
        return count(createQuery(context, "SELECT count(*) FROM Bitstream b WHERE b.deleted=true"));
    }

    @Override
    public int countWithNoPolicy(Context context) throws SQLException {
        Query query = createQuery(context,
                "SELECT count(bit.id) from Bitstream bit where bit.deleted<>true and bit.id not in"
                        + " (select res.dSpaceObject from ResourcePolicy res where res.resourceTypeId = :typeId )");
        query.setParameter("typeId", Constants.BITSTREAM);
        return count(query);
    }

    @Override
    public List<Bitstream> getNotReferencedBitstreams(Context context) throws SQLException {
        return list(createQuery(context,
                "select bit from Bitstream bit where bit.deleted != true"
                        + " and bit.id not in (select bit2.id from Bundle bun join bun.bitstreams bit2)"
                        + " and bit.id not in (select com.logo.id from Community com)"
                        + " and bit.id not in (select col.logo.id from Collection col)"
                        + " and bit.id not in (select bun.primaryBitstream.id from Bundle bun)"));
    }
}