diff --git a/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/DaBInImporter.java b/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/DaBInImporter.java index 1df7442a6..f08b3d099 100644 --- a/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/DaBInImporter.java +++ b/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/DaBInImporter.java @@ -2615,6 +2615,7 @@ public class DaBInImporter extends Program { } else { publication = new ContentBundle(publicationDe); publication.setDefaultLanguage("de"); + publication.addInstance(publicationEn); } publication.setLifecycle(createLifecycle(publicationsLifecycle)); publication.setContentSection(publicationsSection); diff --git a/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/FixLangVersionsOfPublications.java b/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/FixLangVersionsOfPublications.java new file mode 100644 index 000000000..cc543d162 --- /dev/null +++ b/ccm-cms-dabinimporter/src/com/arsdigita/cms/dabin/FixLangVersionsOfPublications.java @@ -0,0 +1,347 @@ +package com.arsdigita.cms.dabin; + +import com.arsdigita.cms.ContentBundle; +import com.arsdigita.cms.ContentItem; +import com.arsdigita.cms.Folder; +import com.arsdigita.cms.ItemCollection; +import com.arsdigita.cms.contenttypes.ArticleInCollectedVolume; +import com.arsdigita.cms.contenttypes.ArticleInJournal; +import com.arsdigita.cms.contenttypes.AuthorshipCollection; +import com.arsdigita.cms.contenttypes.CollectedVolume; +import com.arsdigita.cms.contenttypes.Expertise; +import com.arsdigita.cms.contenttypes.GenericOrganizationalUnit; +import com.arsdigita.cms.contenttypes.GenericPerson; +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.Publisher; +import com.arsdigita.cms.contenttypes.Review; +import com.arsdigita.cms.contenttypes.WorkingPaper; +import com.arsdigita.london.util.Transaction; +import com.arsdigita.packaging.Program; +import com.arsdigita.persistence.OID; +import org.apache.commons.cli.CommandLine; + +/** + * + * @author jensp + */ +public class FixLangVersionsOfPublications extends Program { + + public FixLangVersionsOfPublications() { + this(true); + } + + public FixLangVersionsOfPublications(boolean startup) { + super("FixLangVersionsOfPublications", + "0.1.0", + "configFile", + startup); + } + + @Override + protected void doRun(CommandLine cmdLine) { + + final String[] args = cmdLine.getArgs(); + + if (args.length != 1) { + System.out.println( + "\n\nUsage: FixLangVersionsOfPublication folderId"); + help(System.err); + System.exit(-1); + } + + Transaction transaction = new Transaction() { + + @Override + protected void doRun() { + + int folderId = Integer.parseInt(args[0]); + Folder folder = new Folder(new OID(Folder.BASE_DATA_OBJECT_TYPE, + folderId)); + + System.out.println("Fixing publications in folder: " + folder. + getDisplayName()); + + ItemCollection items = folder.getItems(); + + while (items.next()) { + ContentItem item = items.getContentItem(); + + ContentBundle bundle = null; + Publication publicationDe; + Publication publicationEn = null; + + if (item instanceof ContentBundle) { + bundle = (ContentBundle) item; + } else { + if (item instanceof Publication) { + Publication publication = (Publication) item; + bundle = publication.getContentBundle(); + } else { + System.out.printf( + "Item %s is not a publication. Skiping.\n", + item.getID().toString()); + } + } + + publicationDe = (Publication) bundle.getPrimaryInstance(); + System.out.printf( + "Procesing publication '%s' (Bundle id: %s; type: %s)...\n", + publicationDe.getName(), + bundle.getID(), + publicationDe.getClass().getName()); + + if (bundle.hasInstance("en")) { + System.out.println( + "\tPublication has already an english version. Skiping."); + continue; + } + + //Copy special properties + if ((publicationDe instanceof ArticleInJournal) + || (publicationDe instanceof Review)) { + System.out.println( + "\tPublication is an ArticleInJournal (or a Review)"); + + ArticleInJournal articleDe = + (ArticleInJournal) publicationDe; + ArticleInJournal articleEn = new ArticleInJournal(); + + articleEn.setVolume(articleDe.getVolume()); + articleEn.setIssue(articleDe.getIssue()); + articleEn.setPagesFrom(articleDe.getPagesFrom()); + articleEn.setPagesTo(articleDe.getPagesTo()); + //articleEn.setJournal(articleDe.getJournal()); + articleEn.setPublicationDate(articleDe. + getPublicationDate()); + articleEn.setReviewed(articleDe.getReviewed()); + + publicationEn = articleEn; + } else if (publicationDe instanceof ArticleInCollectedVolume) { + System.out.println( + "\tpublicationDe is an ArticleInCollectedVolume"); + + ArticleInCollectedVolume articleDe = + (ArticleInCollectedVolume) publicationDe; + ArticleInCollectedVolume articleEn = + new ArticleInCollectedVolume(); + + articleEn.setPagesFrom(articleDe.getPagesFrom()); + articleEn.setPagesTo(articleDe.getPagesTo()); + articleEn.setChapter(articleDe.getChapter()); + articleEn.setReviewed(articleDe.getReviewed()); + + publicationEn = articleEn; + } else if (publicationDe instanceof CollectedVolume) { + System.out.println( + "\tpublicationDe is an CollectedVolume"); + + //CollectedVolumes imported from DaBIn to not have associated + //articles + + CollectedVolume collectedVolumeDe = + (CollectedVolume) publicationDe; + CollectedVolume collectedVolumeEn = + new CollectedVolume(); + + collectedVolumeEn.setReviewed(collectedVolumeDe. + getReviewed()); + + publicationEn = collectedVolumeEn; + } else if (publicationDe instanceof Expertise) { + System.out.println("\tpublicationDe is an Experise"); + + Expertise expertiseDe = (Expertise) publicationDe; + Expertise expertiseEn = new Expertise(); + + expertiseEn.setPlace(expertiseDe.getPlace()); + if (expertiseDe.getOrganization().getContentBundle(). + hasInstance( + "en")) { + expertiseEn.setOrganization((GenericOrganizationalUnit) expertiseDe. + getOrganization(). + getContentBundle().getInstance("en")); + } else { + expertiseEn.setOrganization(expertiseDe. + getOrganization()); + } + expertiseEn.setNumberOfPages(expertiseDe. + getNumberOfPages()); + if (expertiseDe.getOrderer().getContentBundle(). + hasInstance("en")) { + expertiseEn.setOrderer((GenericOrganizationalUnit) expertiseDe. + getOrderer().getContentBundle().getInstance( + "en")); + } else { + expertiseEn.setOrderer(expertiseDe.getOrderer()); + } + + publicationEn = expertiseEn; + } else if (publicationDe instanceof GreyLiterature) { + System.out.println("\tpublicationDe is GreyLiterature"); + + GreyLiterature greyLiteratureDe = + (GreyLiterature) publicationDe; + GreyLiterature greyLiteratureEn = new GreyLiterature(); + + greyLiteratureEn.setPlace(greyLiteratureDe.getPlace()); + greyLiteratureEn.setNumber(greyLiteratureDe.getNumber()); + greyLiteratureEn.setNumberOfPages(greyLiteratureDe. + getNumberOfPages()); + greyLiteratureEn.setPagesFrom(greyLiteratureDe. + getPagesFrom()); + greyLiteratureEn.setPagesTo( + greyLiteratureDe.getPagesTo()); + + publicationEn = greyLiteratureEn; + } else if (publicationDe instanceof InProceedings) { + System.out.println("\tpublicationDe is an InProceedings"); + //Not used by the DaBInImporter + + } else if (publicationDe instanceof InternetArticle) { + System.out.println( + "\tpublicationDe is an InternetArticle"); + + //Not used by the DabInImporter + } else if (publicationDe instanceof Journal) { + System.out.println("\tpublicationDe is an Journal"); + + //Not used by the DaBInImporter + } else if (publicationDe instanceof Monograph) { + System.out.println("\tpublicationDe is an Monograph"); + + Monograph monographDe = (Monograph) publicationDe; + Monograph monographEn = new Monograph(); + + monographEn.setReviewed(monographDe.getReviewed()); + + publicationEn = monographEn; + } else if (publicationDe instanceof Proceedings) { + System.out.println("\tpublicationDe is a Proceedings"); + + //Not used by the DaBInImporter + } else if (publicationDe instanceof WorkingPaper) { + System.out.println( + "\tpublicationDe is UnPublished or a WorkingPaper"); + + WorkingPaper workingPaperDe = + (WorkingPaper) publicationDe; + WorkingPaper workingPaperEn = new WorkingPaper(); + + workingPaperEn.setPlace(workingPaperDe.getPlace()); + workingPaperEn.setNumber(workingPaperDe.getNumber()); + workingPaperEn.setNumberOfPages( + workingPaperDe.getNumberOfPages()); + workingPaperEn.setReviewed(workingPaperDe.getReviewed()); + + publicationEn = workingPaperEn; + } else { + System.out.println( + "\tUnknown publicationDe type. Skiping."); + continue; + } + + System.out.println("\tSetting common properties..."); + //Copy common properties + System.out.println("\tSetting name..."); + publicationEn.setName(publicationDe.getName()); + System.out.println("\tSetting title..."); + publicationEn.setTitle(publicationDe.getTitle()); + System.out.println("\tSetting year of publication..."); + publicationEn.setYearOfPublication(publicationDe. + getYearOfPublication()); + System.out.println("\tSetting abstract..."); + publicationEn.setAbstract(publicationDe.getAbstract()); + System.out.println("\tSetting misc..."); + publicationEn.setMisc(publicationDe.getMisc()); + + System.out.println("\tGetting authors..."); + AuthorshipCollection authors = publicationDe.getAuthors(); + authors.addOrder(AuthorshipCollection.LINKORDER); + System.out.println("\tAdding authors..."); + while (authors.next()) { + GenericPerson author = authors.getAuthor(); + boolean isEditor = authors.isEditor(); + + if (author.getContentBundle().hasInstance("en")) { + publicationEn.addAuthor((GenericPerson) author. + getContentBundle().getInstance("en"), + isEditor); + } else { + publicationEn.addAuthor(author, isEditor); + } + } + + //Copy properties for publication with publisher + if (publicationDe instanceof PublicationWithPublisher) { + System.out.println( + "\tpublicationDe is a publicationWithPublisher"); + + PublicationWithPublisher publicationWithPublisherDe = + (PublicationWithPublisher) publicationDe; + PublicationWithPublisher publicationWithPublisherEn = + (PublicationWithPublisher) publicationEn; + + System.out.printf("\tSetting isbn %s...", + publicationWithPublisherDe.getISBN()); + if (publicationWithPublisherDe.getISBN() != null) { + publicationWithPublisherEn.setISBN(publicationWithPublisherDe. + getISBN()); + } + System.out.printf("\tSetting volume...\n"); + publicationWithPublisherEn.setVolume(publicationWithPublisherDe. + getVolume()); + System.out.println("\tSetting number..."); + publicationWithPublisherEn.setNumberOfVolumes(publicationWithPublisherDe. + getNumberOfVolumes()); + System.out.println("\tSetting number of pages..."); + publicationWithPublisherEn.setNumberOfPages(publicationWithPublisherDe. + getNumberOfPages()); + System.out.println("\tSetting edition..."); + publicationWithPublisherEn.setEdition(publicationWithPublisherDe. + getEdition()); + if (publicationWithPublisherDe.getPublisher() != null) { + System.out.println("\tSetting publisher..."); + if (publicationWithPublisherDe.getPublisher(). + getContentBundle(). + hasInstance("en")) { + publicationWithPublisherEn.setPublisher((Publisher) publicationWithPublisherDe. + getPublisher().getContentBundle(). + getInstance("en")); + } else { + publicationWithPublisherEn.setPublisher(publicationWithPublisherDe. + getPublisher()); + } + } + + } else { + System.out.println("\tpublicationDe is a publication"); + } + + publicationEn.save(); + publicationEn.setLanguage("en"); + bundle.addInstance(publicationEn); + + bundle.save(); + + + + System.out.println("\tEnglish version created."); + } + } + }; + + transaction.run(); + + } + + public static void main(String[] args) { + new FixLangVersionsOfPublications().run(args); + } +} diff --git a/ccm-sci-publications/src/com/arsdigita/cms/contenttypes/UnPublished.java b/ccm-sci-publications/src/com/arsdigita/cms/contenttypes/UnPublished.java index c8a9e39d0..6302411d6 100644 --- a/ccm-sci-publications/src/com/arsdigita/cms/contenttypes/UnPublished.java +++ b/ccm-sci-publications/src/com/arsdigita/cms/contenttypes/UnPublished.java @@ -26,7 +26,6 @@ import com.arsdigita.persistence.DataObject; import com.arsdigita.persistence.OID; import com.arsdigita.util.Assert; import java.math.BigDecimal; -import org.apache.log4j.Logger; /** *