source: OAIProvider/trunk/src/main/java/eu/clarin/oai/provider/impl/VerbEnumerateRecord.java @ 1911

package eu.clarin.oai.provider.impl;

import java.io.IOException;
import java.util.Date;
import java.util.List;

import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

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.ext.Argument;
import eu.clarin.oai.provider.ext.OAIErrorCode;
import eu.clarin.oai.provider.ext.OAIOutputStream;
import eu.clarin.oai.provider.ext.RepositoryAdapter;
import eu.clarin.oai.provider.ext.ResumptionToken;
import eu.clarin.oai.provider.ext.Verb;
import eu.clarin.oai.provider.ext.VerbContext;

abstract class VerbEnumerateRecord extends Verb {
    private static final Argument[] ARGUMENTS = {
        DefaultArguments.FROM,
        DefaultArguments.UNTIL,
        DefaultArguments.SET,
        DefaultArguments.METADATAPREFIX,
        DefaultArguments.RESUMPTIONTOKEN
    };

    protected VerbEnumerateRecord() {
    }

    @Override
    public final Argument[] getArguments() {
        return ARGUMENTS;
    }

    @Override
    public final void process(VerbContext ctx) throws IOException,
            XMLStreamException, OAIException {
        logger.debug("process ENUMERATE-RECORD ({})", getName());

        RepositoryAdapter repository = ctx.getRepository();
        String prefix = null;
        String set = null;
        Date from = null;
        Date until = null;
        int offset = 0;
        boolean resume = false;
        
        if (ctx.hasArgument(DefaultArguments.ARG_RESUMPTIONTOKEN)) {
            final Long id =
                (Long) ctx.getArgument(DefaultArguments.ARG_RESUMPTIONTOKEN);
            ResumptionToken token = repository.getResumptionToken(id);
            if (token == null) {
                ctx.addError(OAIErrorCode.BAD_RESUMPTION_TOKEN,
                        "Invalid resumption token (id='" + id + "')");
                return; // bail early
            }
            synchronized (token) {
                prefix = token.getMetadataPrefix();
                set    = token.getSet();
                from   = token.getFrom();
                until  = token.getUntil();
                offset = token.getNextOffset();
            } // synchronized (token)
            resume = true;
        } else {
            prefix = (String) ctx.getArgument(DefaultArguments.ARG_METADATAPREFIX);
            set    = (String) ctx.getArgument(DefaultArguments.ARG_SET);
            from   = (Date)   ctx.getArgument(DefaultArguments.ARG_FROM);
            until  = (Date)   ctx.getArgument(DefaultArguments.ARG_UNTIL);
        }

        MetadataFormat format = repository.getMetadataFormatByPrefix(prefix);
        if (format != null) {
            if ((set != null) && !repository.isUsingSets()) {
                ctx.addError(OAIErrorCode.NO_SET_HIERARCHY,
                        "Repository does not support sets");
            } else {
                // fetch records
                final RecordList result = doGetRecords(repository, prefix,
                        from, until, set, offset);

                // process results
                if (result != null) {
                    try {
                        OAIOutputStream out = ctx.getOutputStream();
                        out.writeStartElement(getName());
                        int size = 0;
                        
                        // emulate a record ...
                        Record record = new Record() {
                            @Override
                            public Object getLocalId() {
                                return result.getLocalId();
                            }

                            @Override
                            public Date getDatestamp() {
                                return result.getDatestamp();
                            }

                            @Override
                            public boolean isDeleted() {
                                return result.isDeleted();
                            }

                            @Override
                            public List<String> getSetSpecs() {
                                return result.getSetSpecs();
                            }

                            public void writeRecord(XMLStreamWriter writer)
                                    throws XMLStreamException {
                                result.writeRecord(writer);
                            }
                        };

                        // process results
                        while (result.next()) {
                            doWriteRecord(repository, out, format, record);
                            size++;
                        } // while

                        /*
                         * add resumption token, if more results are pending or
                         * if this is the last batch of result list
                         */
                        if (resume || !result.isListComplete()) {
                            ResumptionToken token = null;
                            if (!result.isListComplete()) {
                                token = repository.createResumptionToken();
                                final int nextOffset = size + offset;
                                synchronized (token) {
                                    token.setMetadataPrefix(prefix);
                                    token.setSet(set);
                                    token.setFrom(from);
                                    token.setUntil(until);
                                    token.setNextOffset(nextOffset);
                                    token.setCursor(offset);
                                    token.setCompleteListSize(
                                            result.getTotalSize());
                                } // synchronized (token)
                            }
                            out.writeResumptionToken(token);
                        }
                        out.writeEndElement(); // ListRecords element
                        out.close();
                    } finally {
                        result.close();
                    }
                } else {
                    ctx.addError(OAIErrorCode.NO_RECORDS_MATCH,
                            "No records match");
                }
            }
        } else {
            ctx.addError(OAIErrorCode.CANNOT_DISSERMINATE_FORMAT,
                    "Repository does not support metadataPrefix '" +
                    prefix + "'");
        }
    }

    protected abstract RecordList doGetRecords(RepositoryAdapter repository,
            String prefix, Date from, Date until, String set, int offset)
            throws OAIException;

    protected abstract void doWriteRecord(RepositoryAdapter repository,
            OAIOutputStream out, MetadataFormat format, Record record)
            throws XMLStreamException;

} // abstract class VerbEnumerateRecord