Basic classes for exporters and part of the BibTeXConverter (wip)

git-svn-id: https://svn.libreccm.org/ccm/trunk@731 8810af33-2d31-482b-a856-94f89814c4df

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/PublicationFormat.java

@@ -0,0 +1,90 @@
+package com.arsdigita.cms.scipublications.exporter;
+
+import javax.activation.MimeType;
+
+/**
+ *
+ * @author jensp
+ */
+public class PublicationFormat {
+
+    private String name;
+    private MimeType mimeType;
+    private String fileExtension;
+
+    public PublicationFormat() {
+        super();
+    }
+
+    public PublicationFormat(final String name,
+                             final MimeType mimeType,
+                             final String fileExtension) {
+        this.name = name;
+        this.mimeType = mimeType;
+        this.fileExtension = fileExtension;
+    }
+
+    public String getFileExtension() {
+        return fileExtension;
+    }
+
+    public void setFileExtension(final String fileExtension) {
+        this.fileExtension = fileExtension;
+    }
+
+    public MimeType getMimeType() {
+        return mimeType;
+    }
+
+    public void setMimeType(final MimeType mimeType) {
+        this.mimeType = mimeType;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        final PublicationFormat other = (PublicationFormat) obj;
+        if ((this.name == null) ? (other.name != null)
+            : !this.name.equals(other.name)) {
+            return false;
+        }
+        if (this.mimeType != other.mimeType && (this.mimeType == null || !this.mimeType.
+                                                equals(other.mimeType))) {
+            return false;
+        }
+        if ((this.fileExtension == null) ? (other.fileExtension != null)
+            : !this.fileExtension.equals(other.fileExtension)) {
+            return false;
+        }
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        return hash;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("PublicationFormat = {name = \"%s\"; "
+                             + "mimeType = {%s}; "
+                             + "fileExtension = \"\"}",
+                             name,
+                             mimeType.toString(),
+                             fileExtension);
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/SciPublicationsExporter.java

@@ -0,0 +1,15 @@
+package com.arsdigita.cms.scipublications.exporter;
+
+import com.arsdigita.cms.contenttypes.Publication;
+
+/**
+ *
+ * @author jensp
+ */
+public interface SciPublicationsExporter {
+
+    PublicationFormat getSupportedFormat();
+
+    String exportPublication(Publication publication);
+
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/SciPublicationsExporters.java

@@ -0,0 +1,53 @@
+package com.arsdigita.cms.scipublications.exporter;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.ServiceLoader;
+
+/**
+ *
+ * @author jensp
+ */
+public final class SciPublicationsExporters {
+
+    private Map<String, SciPublicationsExporter> exporters =
+                                                 new HashMap<String, SciPublicationsExporter>();
+
+    private static class Instance {
+
+        private static final SciPublicationsExporters INSTANCE =
+                                                      new SciPublicationsExporters();
+    }
+
+    private SciPublicationsExporters() {
+        ServiceLoader<SciPublicationsExporter> exporterServices ;
+
+        exporterServices = ServiceLoader.load(SciPublicationsExporter.class);
+
+        for(SciPublicationsExporter exporter : exporterServices) {
+            exporters.put(exporter.getSupportedFormat().getName(), exporter);
+        }
+    }
+
+    public SciPublicationsExporters getInstance() {
+        return Instance.INSTANCE;
+    }
+
+    public SciPublicationsExporter getExporterForFormat(final String format) {
+        return exporters.get(format);
+    }
+
+    public List<PublicationFormat> getSupportedFormats() {
+        List<PublicationFormat> supportedFormats;
+
+        supportedFormats = new ArrayList<PublicationFormat>();
+
+        for(Map.Entry<String, SciPublicationsExporter> entry : exporters.entrySet()) {
+            supportedFormats.add(entry.getValue().getSupportedFormat());
+        }
+
+        return supportedFormats;
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/BibTeXExporter.java

@@ -0,0 +1,70 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex;
+
+import com.arsdigita.cms.scipublications.exporter.bibtex.builders.BibTeXBuilder;
+import com.arsdigita.cms.scipublications.exporter.bibtex.builders.BibTeXBuilders;
+import com.arsdigita.cms.contenttypes.ArticleInCollectedVolume;
+import com.arsdigita.cms.contenttypes.ArticleInJournal;
+import com.arsdigita.cms.contenttypes.CollectedVolume;
+import com.arsdigita.cms.contenttypes.Expertise;
+import com.arsdigita.cms.contenttypes.GreyLiterature;
+import com.arsdigita.cms.contenttypes.InProceedings;
+import com.arsdigita.cms.contenttypes.InternetArticle;
+import com.arsdigita.cms.contenttypes.Journal;
+import com.arsdigita.cms.contenttypes.Monograph;
+import com.arsdigita.cms.contenttypes.Proceedings;
+import com.arsdigita.cms.contenttypes.Publication;
+import com.arsdigita.cms.contenttypes.PublicationWithPublisher;
+import com.arsdigita.cms.contenttypes.Review;
+import com.arsdigita.cms.contenttypes.WorkingPaper;
+import com.arsdigita.cms.scipublications.exporter.PublicationFormat;
+import com.arsdigita.cms.scipublications.exporter.SciPublicationsExporter;
+import javax.activation.MimeType;
+import javax.activation.MimeTypeParseException;
+import org.apache.log4j.Logger;
+
+/**
+ *
+ * @author jensp
+ */
+public class BibTeXExporter implements SciPublicationsExporter {
+
+    private final static Logger logger = Logger.getLogger(BibTeXExporter.class);
+
+    public PublicationFormat getSupportedFormat() {
+        try {
+            return new PublicationFormat("BibTeX",
+                                         new MimeType("text", "x-bibtex"),
+                                         "bib");
+        } catch (MimeTypeParseException ex) {
+            logger.warn("Failed to create MimeType for PublicationFormat."
+                        + "Using null mimetype instead. Cause: ", ex);
+            return new PublicationFormat("BibTeX",
+                                         null,
+                                         "bib");
+
+        }
+    }
+
+    public String exportPublication(final Publication publication) {
+        BibTeXBuilder builder;
+        
+
+        builder = BibTeXBuilders.getInstance().
+                getBibTeXBuilderForCcmPublicationtType(publication.getClass().
+                getName());
+
+        if ((builder == null) && publication instanceof PublicationWithPublisher) {
+            builder = BibTeXBuilders.getInstance().
+                    getBibTeXBuilderForCcmPublicationtType(
+                    PublicationWithPublisher.class.getName());
+        } else {
+            builder = BibTeXBuilders.getInstance().
+                    getBibTeXBuilderForCcmPublicationtType(Publication.class.
+                    getName());
+        }
+
+        
+
+        return builder.toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/AbstractBibTeXBuilder.java

@@ -0,0 +1,161 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import com.arsdigita.cms.contenttypes.GenericPerson;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.log4j.Logger;
+
+/**
+ *
+ * @author jensp
+ */
+public abstract class AbstractBibTeXBuilder implements BibTeXBuilder {
+
+    private static final Logger logger = Logger.getLogger(
+            AbstractBibTeXBuilder.class);
+    private List<GenericPerson> authors = new ArrayList<GenericPerson>();
+    private List<GenericPerson> editors = new ArrayList<GenericPerson>();
+    private EnumMap<BibTeXField, String> fields = new EnumMap<BibTeXField, String>(
+            BibTeXField.class);
+
+    @Override
+    public void addAuthor(final GenericPerson author) {
+        authors.add(author);
+    }
+
+    @Override
+    public void addEditor(final GenericPerson editor) {
+        editors.add(editor);
+    }
+
+    @Override
+    public void setField(final BibTeXField name, final String value)
+            throws UnsupportedFieldException {
+        if (isFieldSupported(name)) {
+            fields.put(name, value);
+        } else {
+            throw new UnsupportedFieldException(
+                    String.format("The field '%s' is not supported for "
+                                  + "the BibTeX type '%s'.",
+                                  name,
+                                  getBibTeXType()));
+        }
+    }
+
+    @Override
+    public String toBibTeX() {
+        String type;
+        StringBuilder builder;
+
+        if (checkMandatoryFields()) {
+            type = getBibTeXType();
+        } else {
+            logger.warn(String.format("Missing mandandory field"
+                    + "for BibTeX type '%s'. Using type 'type'.",
+                    getBibTeXType()));
+            type = "misc";
+        }
+
+        builder = new StringBuilder();
+
+        builder.append('@');
+        builder.append(type);
+        builder.append('{');
+        builder.append(generateBibTeXId());
+        builder.append(",\n");
+
+        if (authors.size() > 0) {
+            addField("author", generatePersonFieldValue(authors), builder);
+        }
+
+        if (editors.size() > 0) {
+            addField("editor", generatePersonFieldValue(editors), builder);
+        }
+
+        for (Map.Entry<BibTeXField, String> field : fields.entrySet()) {
+            addField(field.getKey().name().toLowerCase(),
+                     field.getValue(),
+                     builder);
+        }
+
+
+
+        return builder.toString();
+    }
+   
+    protected String generateBibTeXId() {
+        StringBuilder builder;
+
+        builder = new StringBuilder();
+
+        if (authors.size() > 0) {
+            builder.append(authors.get(0).getSurname().substring(0, 3));
+        } else if (fields.containsKey(BibTeXField.TITLE)) {
+            builder.append(fields.get(BibTeXField.TITLE));
+        }
+
+        if (fields.containsKey(BibTeXField.YEAR)) {
+            builder.append(fields.get(BibTeXField.YEAR));
+        }
+
+        return builder.toString();
+    }
+    
+    protected abstract List<BibTeXField> getMandatoryFields();
+
+    protected abstract boolean isFieldSupported(final BibTeXField name);
+
+    private boolean checkMandatoryFields() {
+        if (getMandatoryFields().contains(BibTeXField.AUTHOR)
+            && authors.isEmpty()) {
+            return false;
+        }
+
+        if (getMandatoryFields().contains(BibTeXField.EDITOR)
+            && editors.isEmpty()) {
+            return false;
+        }
+
+        for (BibTeXField field : getMandatoryFields()) {
+            if (!BibTeXField.AUTHOR.equals(field)
+                && !BibTeXField.EDITOR.equals(field)
+                && !fields.containsKey(field)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private String generatePersonFieldValue(final List<GenericPerson> persons) {
+        StringBuilder builder;
+        GenericPerson person;
+
+        builder = new StringBuilder();
+
+        for (int i = 0; i < authors.size(); i++) {
+            person = authors.get(i);
+            builder.append(person.getGivenName());
+            builder.append(' ');
+            builder.append(person.getSurname());
+
+            if (i < (authors.size() - 1)) {
+                builder.append(" and ");
+            }
+        }
+
+        return builder.toString();
+    }
+
+    private void addField(final String name,
+                          final String value,
+                          final StringBuilder builder) {
+        builder.append(' ');
+        builder.append(name);
+        builder.append(" = \"");
+        builder.append(value);
+        builder.append("\",\n");
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/ArticleBuilder.java

@@ -0,0 +1,45 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class ArticleBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.JOURNAL,
+                                                   BibTeXField.YEAR};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.JOURNAL,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.VOLUME,
+                                                   BibTeXField.NUMBER,
+                                                   BibTeXField.PAGES,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.NOTE};
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "article";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/BibTeXBuilder.java

@@ -0,0 +1,22 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import com.arsdigita.cms.contenttypes.GenericPerson;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public interface BibTeXBuilder {
+
+    void addAuthor(GenericPerson author);
+
+    void addEditor(GenericPerson editor);
+
+    void setField(BibTeXField name, String value) throws UnsupportedFieldException;
+
+    String getBibTeXType();
+
+    String toBibTeX();
+    
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/BibTeXBuilders.java

@@ -0,0 +1,38 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.ServiceLoader;
+
+/**
+ *
+ * @author jensp
+ */
+public class BibTeXBuilders {
+
+    private Map<String, BibTeXBuilder> builders =
+                                       new HashMap<String, BibTeXBuilder>();
+
+    private BibTeXBuilders() {
+        ServiceLoader<BibTeXBuilder> builderServices;
+
+        builderServices = ServiceLoader.load(BibTeXBuilder.class);
+
+        for (BibTeXBuilder builder : builderServices) {
+            builders.put(builder.getBibTeXType(), builder);
+        }
+    }
+
+    private static class Instance {
+
+        private static final BibTeXBuilders INSTANCE = new BibTeXBuilders();
+    }
+
+    public static BibTeXBuilders getInstance() {
+        return Instance.INSTANCE;
+    }
+
+    public BibTeXBuilder getBibTeXBuilderForCcmPublicationtType(final String type) {
+        return builders.get(type);
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/BibTeXField.java

@@ -0,0 +1,31 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+/**
+ *
+ * @author jensp
+ */
+public enum BibTeXField {
+
+    ADDRESS,
+    AUTHOR,
+    BOOKTITLE,
+    CHAPTER,
+    EDITION,
+    EDITOR,
+    HOWPUBLISHED,
+    INSTITUION,
+    ISBN,
+    JOURNAL,
+    MONTH,
+    NOTE,
+    NUMBER,
+    ORGANIZATION,
+    PAGES,
+    PUBLISHER,
+    SERIES,
+    SCHOOL,
+    TITLE,
+    TYPE,
+    VOLUME,
+    YEAR
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/BookBuilder.java

@@ -0,0 +1,52 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class BookBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.YEAR};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.VOLUME,
+                                                   BibTeXField.NUMBER,
+                                                   BibTeXField.SERIES,
+                                                   BibTeXField.ADDRESS,
+                                                   BibTeXField.EDITION,
+                                                   BibTeXField.EDITOR,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.NOTE,
+                                                   BibTeXField.ISBN};
+
+    public BookBuilder() {
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "book";
+    }
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/InCollectionBuilder.java

@@ -0,0 +1,54 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class InCollectionBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.BOOKTITLE,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.YEAR};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.BOOKTITLE,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.EDITOR,
+                                                   BibTeXField.VOLUME,
+                                                   BibTeXField.NUMBER,
+                                                   BibTeXField.SERIES,
+                                                   BibTeXField.TYPE,
+                                                   BibTeXField.CHAPTER,
+                                                   BibTeXField.PAGES,
+                                                   BibTeXField.ADDRESS,
+                                                   BibTeXField.EDITION,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.NOTE
+    };
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "incollection";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/InProceedingsBuilder.java

@@ -0,0 +1,50 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class InProceedingsBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.BOOKTITLE,
+                                                   BibTeXField.YEAR};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.BOOKTITLE,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.EDITOR,
+                                                   BibTeXField.VOLUME,
+                                                   BibTeXField.NUMBER,
+                                                   BibTeXField.SERIES,
+                                                   BibTeXField.PAGES,
+                                                   BibTeXField.ADDRESS,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.ORGANIZATION,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.NOTE};
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "inproceedings";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/MiscBuilder.java

@@ -0,0 +1,39 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class MiscBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.HOWPUBLISHED,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.NOTE};
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "misc";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/ProceedingsBuilder.java

@@ -0,0 +1,45 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class ProceedingsBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.TITLE,
+                                                   BibTeXField.YEAR};
+    private final BibTeXField[] supportedFields = {BibTeXField.TITLE,
+                                                   BibTeXField.YEAR,
+                                                   BibTeXField.EDITOR,
+                                                   BibTeXField.VOLUME,
+                                                   BibTeXField.NUMBER,
+                                                   BibTeXField.SERIES,
+                                                   BibTeXField.ADDRESS,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.ORGANIZATION,
+                                                   BibTeXField.PUBLISHER,
+                                                   BibTeXField.NOTE};
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "proceedings";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/UnPublishedBuilder.java

@@ -0,0 +1,40 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ *
+ * @author jensp
+ */
+public class UnPublishedBuilder extends AbstractBibTeXBuilder {
+
+    private final BibTeXField[] mandatoryFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.NOTE};
+    private final BibTeXField[] supportedFields = {BibTeXField.AUTHOR,
+                                                   BibTeXField.TITLE,
+                                                   BibTeXField.NOTE,
+                                                   BibTeXField.MONTH,
+                                                   BibTeXField.YEAR};
+
+    @Override
+    protected List<BibTeXField> getMandatoryFields() {
+        return Arrays.asList(mandatoryFields);
+    }
+
+    @Override
+    protected boolean isFieldSupported(BibTeXField name) {
+        return Arrays.asList(supportedFields).contains(name);
+    }
+
+    @Override
+    public String getBibTeXType() {
+        return "unpublished";
+    }
+
+    @Override
+    public String toString() {
+        return toBibTeX();
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/builders/UnsupportedFieldException.java

@@ -0,0 +1,31 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.builders;
+
+/**
+ *
+ * @author jensp
+ */
+public class UnsupportedFieldException extends Exception {
+
+    /**
+     * Creates a new instance of <code>UnsupportedFieldException</code> without detail message.
+     */
+    public UnsupportedFieldException() {
+    }
+
+
+    /**
+     * Constructs an instance of <code>UnsupportedFieldException</code> with the specified detail message.
+     * @param msg the detail message.
+     */
+    public UnsupportedFieldException(String msg) {
+        super(msg);
+    }
+
+    public UnsupportedFieldException(Throwable cause) {
+        super(cause);
+    }
+
+    public UnsupportedFieldException(String msg, Throwable cause) {
+        super(msg, cause);
+    }
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/converters/BibTeXConverter.java

@@ -0,0 +1,15 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.converters;
+
+import com.arsdigita.cms.contenttypes.Publication;
+
+/**
+ *
+ * @param <T>
+ * @author jensp
+ */
+public interface BibTeXConverter {
+
+    String convert(Publication publication);
+
+    String getCcmType();
+}

ccm-sci-publications/src/com/arsdigita/cms/scipublications/exporter/bibtex/converters/BibTeXConverters.java

@@ -0,0 +1,36 @@
+package com.arsdigita.cms.scipublications.exporter.bibtex.converters;
+
+import com.arsdigita.cms.contenttypes.Publication;
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author jensp
+ */
+public class BibTeXConverters {
+
+    private Map<String, BibTeXConverter> converters =
+            new HashMap<String, BibTeXConverter>();
+
+    private BibTeXConverters() {
+
+    }
+
+    private static class Instance {
+        private static BibTeXConverters INSTANCE = new BibTeXConverters();
+    }
+
+    public static BibTeXConverters getInstance() {
+        return Instance.INSTANCE;
+    }
+
+    public String convert(final Publication publication) {
+        BibTeXConverter converter;
+
+        converter = converters.get(publication.getClass().getName());
+
+        return converter.convert(publication);
+    }
+
+}