source: OAIProvider/trunk/src/main/java/eu/clarin/oai/provider/impl/RepositoryAdapterImpl.java @ 1914

package eu.clarin.oai.provider.impl;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import eu.clarin.oai.provider.DublinCoreConverter;
import eu.clarin.oai.provider.MetadataFormat;
import eu.clarin.oai.provider.OAIException;
import eu.clarin.oai.provider.Record;
import eu.clarin.oai.provider.RecordList;
import eu.clarin.oai.provider.Repository;
import eu.clarin.oai.provider.SetSpecDesc;
import eu.clarin.oai.provider.ext.RepositoryAdapter;
import eu.clarin.oai.provider.ext.ResumptionToken;

final class RepositoryAdapterImpl implements RepositoryAdapter {
    private final OAIProvider provider;
    private final Repository repository;
    private final Set<String> adminEmailAddresses;
    private final Set<MetadataFormat> metadataFormats =
        new HashSet<MetadataFormat>();
    private final Set<SetSpecDesc> setSpecs;

    RepositoryAdapterImpl(OAIProvider provider, Repository repository)
            throws OAIException {
        this.provider = provider;
        this.repository = repository;

        this.adminEmailAddresses = repository.getAdminAddreses();
//        if (this.adminEmailAddresses == null) {
//            throw new OAIRepositoryImplementationError(
//                    " retured null");
//        }
//        if (this.adminEmailAddresses.isEmpty()) {
//            throw new OAIRepositoryImplementationError(
//                    "getAdminAddreses() returned empty set");
//        }

        // handle Dublin Core and do some sanity checks
        Set<DublinCoreConverter> converters =
            repository.getDublinCoreConverters();
//        if (converters == null) {
//            throw new OAIRepositoryImplementationError(
//                    "getDublinCoreConverters() retruned null");
//        }
//        if (converters.isEmpty()) {
//            throw new OAIRepositoryImplementationError(
//                    "getDublinCoreConverters() retruned empty set");
//        }
        this.metadataFormats.add(new DublinCoreMetadataFormat(converters));

        // handle metadata custom formats and do some sanity checks
        Set<MetadataFormat> formats = repository.getCustomMetadataFormats();
        if (formats != null) {
//            Set<String> prefixes = new HashSet<String>();
            for (MetadataFormat format : formats) {
//                String prefix = format.getPrefix();
//                if (prefix == null) {
//                    throw new OAIRepositoryImplementationError(
//                            "metadata format needs prefix non-null " +
//                            "prefix (MetadataFormat: " + format + ")");
//                }
//                if (prefixes.contains(prefix)) {
//                    throw new OAIRepositoryImplementationError(
//                            "metadata prefix '" + prefix + "' is not unique" +
//                            "in repository (MetadataFormat: " + format + ")");
//                }
//                if ("oai_dc".equals(prefix)) {
//                    throw new OAIRepositoryImplementationError(
//                            "dublin core metadata format must " +
//                            "not be in the set of supported custom metadata " +
//                            "formats (MetadataFormat: " + format + ")");
//                }
                // add format
                this.metadataFormats.add(format);
            }
        }

        // cache set specs
        Set<SetSpecDesc> tmp = repository.getSetDescs();
        if ((tmp != null) && tmp.isEmpty()) {
            tmp = null;
        }
        this.setSpecs = tmp;
    }

    @Override
    public OAIProvider getProvider() {
        return provider;
    }

    @Override
    public String getId() {
        return repository.getId();
    }

    @Override
    public String getName() {
        return repository.getName();
    }

    @Override
    public Set<String> getAdminEmailAddresses() {
        return adminEmailAddresses;
    }

    @Override
    public Date getEarliestTimestamp() {
        Date date = repository.getEarliestTimestamp();
        if (date == null) {
            date = new Date();
        }
        return date;
    }

    @Override
    public Repository.DeletedNotion getDeletedNotion() {
        return repository.getDeletedNotion();
    }

    @Override
    public Repository.Granularity getGranularity() {
        return repository.getGranularity();
    }

    @Override
    public boolean supportsCompressionMethod(int method) {
        int methods = repository.getCompressionMethods();
        return (methods & method) > 0;
    }

    @Override
    public String getDescription() {
        String description = repository.getDescription();
        if ((description != null) && !description.isEmpty()) {
            return description;
        }
        return null;
    }

    @Override
    public String getSampleRecordId() {
        return createRecordId(repository.getSampleRecordLocalId());
    }

    @Override
    public Set<MetadataFormat> getMetadataFormats() {
        return metadataFormats;
    }

//    @Override
//    public Set<MetadataFormat> getMetadataFormats(Record record) {
//        // FIXME: re-work
////        final Class<?> clazz = record.getItem().getClass();
//        Set<MetadataFormat> result = null;
////        for (MetadataFormat format : metadataFormats) {
////            if (format.canWriteClass(clazz)) {
////                if (result == null) {
////                    result = new HashSet<MetadataFormat>();
////                }
////                result.add(format);
////            }
////        }
//        if ((result == null) || result.isEmpty()) {
//            result = Collections.emptySet();
//        }
//        return result;
//    }

    @Override
    public MetadataFormat getMetadataFormatByPrefix(String prefix) {
        for (MetadataFormat format : metadataFormats) {
            if (prefix.equals(format.getPrefix())) {
                return format;
            }
        }
        return null;
    }

    @Override
    public Set<SetSpecDesc> getSetSpecs() {
        return setSpecs;
    }

    @Override
    public boolean isUsingSets() {
        return setSpecs != null;
    }

    @Override
    public String createRecordId(Object localId) {
        StringBuilder sb = new StringBuilder("oai:");
        sb.append(repository.getId());
        sb.append(":");
        sb.append(repository.unparseLocalId(localId));
        return sb.toString();
    }

    @Override
    public Object parseLocalId(String unparsedLocalId) {
        return repository.parseLocalId(unparsedLocalId);
    }

    @Override
    public Record getRecord(Object localId) throws OAIException {
        try {
            return repository.getRecord(localId);
        } catch (OAIException e) {
            throw e;
        } catch (Exception e) {
            throw new OAIException("error getting record", e);
        }
    }

    @Override
    public Record getRecordHeader(Object localId) throws OAIException {
        try {
            return repository.getRecordHeader(localId);
        } catch (OAIException e) {
            throw e;
        } catch (Exception e) {
            throw new OAIException("error getting record", e);
        }
    }

    @Override
    public RecordList getRecords(MetadataFormat format, Date from, Date until,
            String set, int offset) throws OAIException {
        /*
         * XXX: maybe add a OAIProvider defined upper limit?
         */
        int limit = repository.getPreferredResultListSize();
        if (limit < 1) {
            limit = Integer.MAX_VALUE;
        }
        try {
            return repository.getRecords(format, from, until, set, offset, limit);
        } catch (OAIException e) {
            throw e;
        } catch (Exception e) {
            throw new OAIException("error getting records", e);
        }
    }

    @Override
    public RecordList getRecordHeaders(MetadataFormat format, Date from,
            Date until, String set, int offset) throws OAIException {
        /*
         * XXX: maybe add a OAIProvider defined upper limit?
         */
        int limit = repository.getPreferredResultListSize();
        if (limit < 1) {
            limit = Integer.MAX_VALUE;
        }
        try {
            return repository.getRecordHeaders(format, from, until,
                    set, offset, limit);
        } catch (OAIException e) {
            throw e;
        } catch (Exception e) {
            throw new OAIException("error getting records", e);
        }
    }

    @Override
    public ResumptionToken createResumptionToken() {
        return provider.createResumptionToken(-1);
    }

    @Override
    public ResumptionToken getResumptionToken(Long id) {
        return provider.getResumptionToken(id, -1);
    }

} // class RepositoryAdapterImpl