Package ugh.dl

Examples of ugh.dl.DigitalDocument


        /*
         * -------------------------------- Imagepfad hinzufügen (evtl. vorhandene zunächst löschen) --------------------------------
         */
        try {
          DigitalDocument dd = this.myRdf.getDigitalDocument();
          DocStructType dst = this.prozessVorlage.getRegelsatz().getPreferences().getDocStrctTypeByName("BoundBook");
          DocStruct dsBoundBook = dd.createDocStruct(dst);
          dd.setPhysicalDocStruct(dsBoundBook);

          UghHelper ughhelp = new UghHelper();
          MetadataType mdt = ughhelp.getMetadataType(this.prozessKopie, "pathimagefiles");

          if (this.myRdf != null && this.myRdf.getDigitalDocument() != null
View Full Code Here


    LinkedList<DocStruct> listArtikel = new LinkedList<DocStruct>();

    /*
     * -------------------------------- Vorbereitung der Dokumentenstruktur --------------------------------
     */
    DigitalDocument dd = new DigitalDocument();
    DocStructType dst = this.myPrefs.getDocStrctTypeByName("Periodical");
    DocStruct dsPeriodical = dd.createDocStruct(dst);
    dst = this.myPrefs.getDocStrctTypeByName("PeriodicalVolume");
    DocStruct dsPeriodicalVolume = dd.createDocStruct(dst);
    dsPeriodical.addChild(dsPeriodicalVolume);

    /*
     * -------------------------------- alle Zeilen durchlaufen --------------------------------
     */
    while ((line = reader.readLine()) != null) {
      // myLogger.debug(line);

      /*
       * -------------------------------- wenn die Zeile leer ist, ist es das Ende eines Absatzes --------------------------------
       */
      if (line.length() == 0) {
        istAbsatz = false;
        /* wenn die Zeile nicht leer ist, den Inhalt prüfen */
      } else {

        /* prüfen ob der String korrekte xml-Zeichen enth�lt */
        String xmlTauglich = xmlTauglichkeitPruefen(line);
        if (xmlTauglich.length() > 0) {
          throw new WrongImportFileException("Parsingfehler (nicht druckbares Zeichen) der Importdatei in der Zeile <br/>" + xmlTauglich);
        }

        /* wenn es gerade ein neuer Absatz ist, diesen als neuen Artikel in die Liste übernehmen */
        if (!istAbsatz) {
          DocStructType dstLocal = this.myPrefs.getDocStrctTypeByName("Article");
          DocStruct ds = dd.createDocStruct(dstLocal);
          listArtikel.add(ds);
          // myLogger.debug("---------------          neuer Artikel          ----------------");
          istAbsatz = true;
          istErsterTitel = true;
        }

        /* Position des Trennzeichens ermitteln */
        int posTrennzeichen = line.indexOf(this.Trennzeichen);
        /* wenn kein Trennzeichen vorhanden, Parsingfehler */
        if (posTrennzeichen == -1) {
          myLogger.error("Import() - Parsingfehler (kein Doppelpunkt) der Importdatei in der Zeile <br/>" + HtmlTagsMaskieren(line));
          throw new WrongImportFileException("Parsingfehler (kein Doppelpunkt) der Importdatei in der Zeile <br/>"
              + HtmlTagsMaskieren(line));
        } else {
          String myLeft = line.substring(0, posTrennzeichen).trim();
          String myRight = line.substring(posTrennzeichen + 1, line.length()).trim();
          ParsenArtikel(listArtikel.getLast(), myLeft, myRight, istErsterTitel);

          /* wenn es ein Titel war, ist der nächste nicht mehr der erste Titel */
          if (myLeft.equals("TI")) {
            istErsterTitel = false;
          }

          /* wenn es gerade der Zeitschriftenname ist, die Zeitschrift benennen */
          if (myLeft.equals("J")) {
            ParsenAllgemein(dsPeriodical, myLeft, myRight);
          }

          /* wenn es gerade eine Jahresangabe ist, dann für den aktuellen Band */
          if (myLeft.equals("Y")) {
            ParsenAllgemein(dsPeriodicalVolume, myLeft, myRight);
          }

          /* wenn es gerade eine Jahresangabe ist, dann für den aktuellen Band */
          if (myLeft.equals("V")) {
            ParsenAllgemein(dsPeriodicalVolume, myLeft, myRight);
          }

          /*
           * wenn es gerade die Heftnummer ist, dann jetzt dem richtigen Heft zuordnen und dieses ggf. noch vorher anlegen
           */
          if (myLeft.equals("I")) {
            DocStruct dsPeriodicalIssue = ParsenHeftzuordnung(dsPeriodicalVolume, myRight, dd);
            dsPeriodicalIssue.addChild(listArtikel.getLast());
          }
        }
      }
    }

    /*
     * -------------------------------- physischer Baum (Seiten) --------------------------------
     */
    dst = this.myPrefs.getDocStrctTypeByName("BoundBook");
    DocStruct dsBoundBook = dd.createDocStruct(dst);

    /*
     * -------------------------------- jetzt die Gesamtstruktur bauen und in xml schreiben --------------------------------
     */
    // DigitalDocument dd = new DigitalDocument();
    dd.setLogicalDocStruct(dsPeriodical);
    dd.setPhysicalDocStruct(dsBoundBook);
    try {
      Fileformat gdzfile = new XStream(this.myPrefs);
      gdzfile.setDigitalDocument(dd);

      /*
 
View Full Code Here

  public boolean validate(Fileformat gdzfile, Prefs inPrefs, Prozess inProzess) {
    String metadataLanguage = (String) Helper.getManagedBeanValue("#{LoginForm.myBenutzer.metadatenSprache}");
    this.myProzess = inProzess;
    boolean ergebnis = true;

    DigitalDocument dd = null;
    try {
      dd = gdzfile.getDigitalDocument();
    } catch (Exception e) {
      Helper.setFehlerMeldung(Helper.getTranslation("MetadataDigitalDocumentError") + inProzess.getTitel(), e.getMessage());
      ergebnis = false;
    }

    DocStruct logical = dd.getLogicalDocStruct();
    if (logical.getAllIdentifierMetadata() != null && logical.getAllIdentifierMetadata().size() > 0) {
      Metadata identifierTopStruct = logical.getAllIdentifierMetadata().get(0);
      try {
        if (!identifierTopStruct.getValue().replaceAll("[\\w|-]", "").equals("")) {
          List<String> parameter = new ArrayList<String>();
          parameter.add(identifierTopStruct.getType().getNameByLanguage(metadataLanguage));
          parameter.add(logical.getType().getNameByLanguage(metadataLanguage));
         
          Helper.setFehlerMeldung(Helper.getTranslation("InvalidIdentifierCharacter", parameter));
         
          ergebnis = false;
        }
        DocStruct firstChild = logical.getAllChildren().get(0);
        Metadata identifierFirstChild = firstChild.getAllIdentifierMetadata().get(0);
        if (identifierTopStruct.getValue() != null && identifierTopStruct.getValue() != ""
            && identifierTopStruct.getValue().equals(identifierFirstChild.getValue())) {
          List<String> parameter = new ArrayList<String>();
          parameter.add(identifierTopStruct.getType().getName());
          parameter.add(logical.getType().getName());
          parameter.add(firstChild.getType().getName());
          Helper.setFehlerMeldung(Helper.getTranslation("InvalidIdentifierSame", parameter));
          ergebnis = false;
        }
        if (!identifierFirstChild.getValue().replaceAll("[\\w|-]", "").equals("")) {
          List<String> parameter = new ArrayList<String>();
          parameter.add(identifierTopStruct.getType().getNameByLanguage(metadataLanguage));
          parameter.add(firstChild.getType().getNameByLanguage(metadataLanguage));
          Helper.setFehlerMeldung(Helper.getTranslation("InvalidIdentifierCharacter", parameter));
          ergebnis = false;
        }
      } catch (Exception e) {
        // no firstChild or no identifier
      }
    } else {
      Helper.setFehlerMeldung(Helper.getTranslation("MetadataMissingIdentifier"));
      ergebnis = false;
    }
    /*
     * -------------------------------- PathImagesFiles prüfen --------------------------------
     */
    if (!this.isValidPathImageFiles(dd.getPhysicalDocStruct(), inPrefs)) {
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Docstructs ohne Seiten prüfen --------------------------------
     */
    DocStruct logicalTop = dd.getLogicalDocStruct();
    if (logicalTop == null) {
      Helper.setFehlerMeldung(inProzess.getTitel() + ": " + Helper.getTranslation("MetadataPaginationError"));
      ergebnis = false;
    }

    this.docStructsOhneSeiten = new ArrayList<DocStruct>();
    this.checkDocStructsOhneSeiten(logicalTop);
    if (this.docStructsOhneSeiten.size() != 0) {
      for (Iterator<DocStruct> iter = this.docStructsOhneSeiten.iterator(); iter.hasNext();) {
        DocStruct ds = iter.next();
        Helper.setFehlerMeldung(inProzess.getTitel() + ": " + Helper.getTranslation("MetadataPaginationStructure")
            + ds.getType().getNameByLanguage(metadataLanguage));
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Seiten ohne Docstructs prüfen --------------------------------
     */
    List<String> seitenOhneDocstructs = null;
    try {
      seitenOhneDocstructs = checkSeitenOhneDocstructs(gdzfile);
    } catch (PreferencesException e1) {
      Helper.setFehlerMeldung("[" + inProzess.getTitel() + "] Can not check pages without docstructs: ");
      ergebnis = false;
    }
    if (seitenOhneDocstructs != null && seitenOhneDocstructs.size() != 0) {
      for (Iterator<String> iter = seitenOhneDocstructs.iterator(); iter.hasNext();) {
        String seite = iter.next();
        Helper.setFehlerMeldung(inProzess.getTitel() + ": " + Helper.getTranslation("MetadataPaginationPages"), seite);
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf mandatory Values der Metadaten prüfen --------------------------------
     */
    List<String> mandatoryList = checkMandatoryValues(dd.getLogicalDocStruct(), new ArrayList<String>(), metadataLanguage);
    if (mandatoryList.size() != 0) {
      for (Iterator<String> iter = mandatoryList.iterator(); iter.hasNext();) {
        String temp = iter.next();
        Helper.setFehlerMeldung(inProzess.getTitel() + ": " + Helper.getTranslation("MetadataMandatoryElement"), temp);
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Details in den Metadaten prüfen, die in der Konfiguration angegeben wurden
     * --------------------------------
     */
    List<String> configuredList = checkConfiguredValidationValues(dd.getLogicalDocStruct(), new ArrayList<String>(), inPrefs, metadataLanguage);
    if (configuredList.size() != 0) {
      for (Iterator<String> iter = configuredList.iterator(); iter.hasNext();) {
        String temp = iter.next();
        Helper.setFehlerMeldung(inProzess.getTitel() + ": " + Helper.getTranslation("MetadataInvalidData"), temp);
      }
      ergebnis = false;
    }

    MetadatenImagesHelper mih = new MetadatenImagesHelper(inPrefs, dd);
    try {
      if (!mih.checkIfImagesValid(inProzess.getTitel(), inProzess.getImagesTifDirectory(true))) {
        ergebnis = false;
      }
    } catch (Exception e) {
      Helper.setFehlerMeldung(inProzess.getTitel() + ": ", e);
      ergebnis = false;
    }
   
    try {
      List<String> images = mih.getDataFiles(myProzess);
      if (images != null) {
        int sizeOfPagination = dd.getPhysicalDocStruct().getAllChildren().size();
        int sizeOfImages = images.size();
        if (sizeOfPagination != sizeOfImages) {
          List<String> param = new ArrayList<String>();
          param.add(String.valueOf(sizeOfPagination));
          param.add(String.valueOf(sizeOfImages));
View Full Code Here

        if (insertPage.equals("lastPage")) {
            metadataBean.createPagination();
        } else {

            Prefs prefs = metadataBean.getMyProzess().getRegelsatz().getPreferences();
            DigitalDocument doc = metadataBean.getDocument();
            DocStruct physical = doc.getPhysicalDocStruct();

            List<DocStruct> pageList = physical.getAllChildren();

            int indexToImport = Integer.parseInt(insertPage);
            DocStructType newPageType = prefs.getDocStrctTypeByName("page");
            DocStruct newPage = doc.createDocStruct(newPageType);
            MetadataType physicalPageNoType = prefs.getMetadataTypeByName("physPageNumber");
            MetadataType logicalPageNoType = prefs.getMetadataTypeByName("logicalPageNumber");
            for (int index = 0; index < pageList.size(); index++) {

                if (index == indexToImport) {
                    DocStruct oldPage = pageList.get(index);

                    // physical page no for new page

                    Metadata mdTemp = new Metadata(physicalPageNoType);
                    mdTemp.setValue(String.valueOf(indexToImport + 1));
                    newPage.addMetadata(mdTemp);

                    // new physical page no for old page
                    oldPage.getAllMetadataByType(physicalPageNoType).get(0).setValue(String.valueOf(indexToImport + 2));

                    // logical page no
                    // logicalPageNoType = prefs.getMetadataTypeByName("logicalPageNumber");
                    mdTemp = new Metadata(logicalPageNoType);

                    if (insertMode.equalsIgnoreCase("uncounted")) {
                        mdTemp.setValue("uncounted");
                    } else {
                        // set new logical no. for new and old page
                        Metadata oldPageNo = oldPage.getAllMetadataByType(logicalPageNoType).get(0);
                        mdTemp.setValue(oldPageNo.getValue());
                        if (index + 1 < pageList.size()) {
                            Metadata pageNoOfFollowingElement = pageList.get(index + 1).getAllMetadataByType(logicalPageNoType).get(0);
                            oldPageNo.setValue(pageNoOfFollowingElement.getValue());
                        } else {
                            oldPageNo.setValue("uncounted");
                        }
                    }

                    newPage.addMetadata(mdTemp);
                    doc.getLogicalDocStruct().addReferenceTo(newPage, "logical_physical");

                    ContentFile cf = new ContentFile();
                    cf.setLocation(filename);
                    newPage.addContentFile(cf);
                    doc.getFileSet().addFile(cf);

                }
                if (index > indexToImport) {
                    DocStruct currentPage = pageList.get(index);
                    // check if element is last element
View Full Code Here

    }

    /* --------------------------------
     * DocStruct rukursiv durchlaufen
     * --------------------------------*/
    DigitalDocument mydocument = null;
    try {
      mydocument = gdzfile.getDigitalDocument();
      DocStruct logicalTopstruct = mydocument.getLogicalDocStruct();
      rueckgabe += getNumberOfUghElements(logicalTopstruct, inType);
    } catch (PreferencesException e1) {
      Helper.setFehlerMeldung("[" + myProzess.getId() + "] Can not get DigitalDocument: ", e1.getMessage());
      logger.error(e1);
      rueckgabe = 0;
View Full Code Here

  public int executeScriptForStepObject(StepObject step, String script, boolean automatic) {
    if (script == null || script.length() == 0) {
      return -1;
    }
    script = script.replace("{", "(").replace("}", ")");
    DigitalDocument dd = null;
    ProcessObject po = ProcessManager.getProcessObjectForId(step.getProcessId());

    FolderInformation fi = new FolderInformation(po.getId(), po.getTitle());
    Prefs prefs = ProcessManager.getRuleset(po.getRulesetId()).getPreferences();
View Full Code Here

        // myRdf.write("D:/temp.rdf.xml");

        /* zugriff auf ugh-Klassen */
        PicaPlus pp = new PicaPlus(inPrefs);
        pp.read(myHitlist);
        DigitalDocument dd = pp.getDigitalDocument();
        Fileformat ff = new XStream(inPrefs);
        ff.setDigitalDocument(dd);
        /* BoundBook hinzufügen */
        DocStructType dst = inPrefs.getDocStrctTypeByName("BoundBook");
        DocStruct dsBoundBook = dd.createDocStruct(dst);
        dd.setPhysicalDocStruct(dsBoundBook);
        /* Inhalt des RDF-Files überprüfen und ergänzen */
        checkMyOpacResult(ff.getDigitalDocument(), inPrefs, myFirstHit, verbose);
        // rdftemp.write("D:/PicaRdf.xml");
        return ff;
    }
View Full Code Here

    String imageFolderPath = myProzess.getImagesDirectory();
    File imageFolder = new File(imageFolderPath);
    /*
     * before creating mets file, change relative path to absolute -
     */
    DigitalDocument dd = gdzfile.getDigitalDocument();
    if (dd.getFileSet() == null) {
      Helper.setMeldung(myProzess.getTitel() + ": digital document does not contain images; temporarily adding them for mets file creation");

      MetadatenImagesHelper mih = new MetadatenImagesHelper(this.myPrefs, dd);
      mih.createPagination(myProzess, null);
    }

    /*
     * get the topstruct element of the digital document depending on anchor property
     */
    DocStruct topElement = dd.getLogicalDocStruct();
    if (this.myPrefs.getDocStrctTypeByName(topElement.getType().getName()).isAnchor()) {
      if (topElement.getAllChildren() == null || topElement.getAllChildren().size() == 0) {
        throw new PreferencesException(myProzess.getTitel()
            + ": the topstruct element is marked as anchor, but does not have any children for physical docstrucs");
      } else {
        topElement = topElement.getAllChildren().get(0);
      }
    }

    /*
     * -------------------------------- if the top element does not have any image related, set them all --------------------------------
     */
    if (topElement.getAllToReferences("logical_physical") == null || topElement.getAllToReferences("logical_physical").size() == 0) {
      if (dd.getPhysicalDocStruct() != null && dd.getPhysicalDocStruct().getAllChildren() != null) {
        Helper.setMeldung(myProzess.getTitel()
            + ": topstruct element does not have any referenced images yet; temporarily adding them for mets file creation");
        for (DocStruct mySeitenDocStruct : dd.getPhysicalDocStruct().getAllChildren()) {
          topElement.addReferenceTo(mySeitenDocStruct, "logical_physical");
        }
      } else {
        Helper.setFehlerMeldung(myProzess.getTitel() + ": could not found any referenced images, export aborted");
        dd = null;
        return false;
      }
    }

    for (ContentFile cf : dd.getFileSet().getAllFiles()) {
      String location = cf.getLocation();
      // If the file's location string shoes no sign of any protocol,
      // use the file protocol.
      if (!location.contains("://")) {
        location = "file://" + location;
      }
      URL url = new URL(location);
      File f = new File(imageFolder, url.getFile());
      cf.setLocation(f.toURI().toString());
    }

    mm.setDigitalDocument(dd);

    /*
     * -------------------------------- wenn Filegroups definiert wurden, werden diese jetzt in die Metsstruktur übernommen
     * --------------------------------
     */
    // Replace all paths with the given VariableReplacer, also the file
    // group paths!
    VariableReplacer vp = new VariableReplacer(mm.getDigitalDocument(), this.myPrefs, myProzess, null);
    Set<ProjectFileGroup> myFilegroups = myProzess.getProjekt().getFilegroups();

    if (myFilegroups != null && myFilegroups.size() > 0) {
      for (ProjectFileGroup pfg : myFilegroups) {
        // check if source files exists
        if (pfg.getFolder() != null && pfg.getFolder().length() > 0) {
          File folder = new File(myProzess.getMethodFromName(pfg.getFolder()));
          if (folder != null && folder.exists() && folder.list().length > 0) {
            VirtualFileGroup v = new VirtualFileGroup();
            v.setName(pfg.getName());
            v.setPathToFiles(vp.replace(pfg.getPath()));
            v.setMimetype(pfg.getMimetype());
            v.setFileSuffix(pfg.getSuffix());
            mm.getDigitalDocument().getFileSet().addVirtualFileGroup(v);
          }
        } else {

          VirtualFileGroup v = new VirtualFileGroup();
          v.setName(pfg.getName());
          v.setPathToFiles(vp.replace(pfg.getPath()));
          v.setMimetype(pfg.getMimetype());
          v.setFileSuffix(pfg.getSuffix());
          mm.getDigitalDocument().getFileSet().addVirtualFileGroup(v);
        }
      }
    }

    // Replace rights and digiprov entries.
    mm.setRightsOwner(vp.replace(myProzess.getProjekt().getMetsRightsOwner()));
    mm.setRightsOwnerLogo(vp.replace(myProzess.getProjekt().getMetsRightsOwnerLogo()));
    mm.setRightsOwnerSiteURL(vp.replace(myProzess.getProjekt().getMetsRightsOwnerSite()));
    mm.setRightsOwnerContact(vp.replace(myProzess.getProjekt().getMetsRightsOwnerMail()));
    mm.setDigiprovPresentation(vp.replace(myProzess.getProjekt().getMetsDigiprovPresentation()));
    mm.setDigiprovReference(vp.replace(myProzess.getProjekt().getMetsDigiprovReference()));
    mm.setDigiprovPresentationAnchor(vp.replace(myProzess.getProjekt().getMetsDigiprovPresentationAnchor()));
    mm.setDigiprovReferenceAnchor(vp.replace(myProzess.getProjekt().getMetsDigiprovReferenceAnchor()));

    mm.setPurlUrl(vp.replace(myProzess.getProjekt().getMetsPurl()));
    mm.setContentIDs(vp.replace(myProzess.getProjekt().getMetsContentIDs()));

    String pointer = myProzess.getProjekt().getMetsPointerPath();
    pointer = vp.replace(pointer);
    mm.setMptrUrl(pointer);

    String anchor = myProzess.getProjekt().getMetsPointerPathAnchor();
    pointer = vp.replace(anchor);
    mm.setMptrAnchorUrl(pointer);

    // if (!ConfigMain.getParameter("ImagePrefix", "\\d{8}").equals("\\d{8}")) {
    List<String> images = new ArrayList<String>();
    if (ConfigMain.getBooleanParameter("ExportValidateImages", true)) {
      try {
        // TODO andere Dateigruppen nicht mit image Namen ersetzen
        images = new MetadatenImagesHelper(this.myPrefs, dd).getDataFiles(myProzess);
        int sizeOfPagination = dd.getPhysicalDocStruct().getAllChildren().size();
        if (images != null) {
          int sizeOfImages = images.size();
          if (sizeOfPagination == sizeOfImages) {
            dd.overrideContentFiles(images);
          } else {
            List<String> param = new ArrayList<String>();
            param.add(String.valueOf(sizeOfPagination));
            param.add(String.valueOf(sizeOfImages));
            Helper.setFehlerMeldung(Helper.getTranslation("imagePaginationError", param));
            return false;
          }
        }
      } catch (IndexOutOfBoundsException e) {
        myLogger.error(e);
        return false;
      } catch (InvalidImagesException e) {
        myLogger.error(e);
        return false;
      }
    } else {
      // create pagination out of virtual file names
      dd.addAllContentFiles();

    }
    mm.write(targetFileName);
    Helper.setMeldung(null, myProzess.getTitel() + ": ", "ExportFinished");
    return true;
View Full Code Here

    String imageFolderPath = this.fi.getImagesDirectory();
    File imageFolder = new File(imageFolderPath);
    /*
     * before creating mets file, change relative path to absolute -
     */
    DigitalDocument dd = gdzfile.getDigitalDocument();
    if (dd.getFileSet() == null) {
      Helper.setFehlerMeldung(process.getTitle() + ": digital document does not contain images; aborting");
      return false;
    }

    /*
     * get the topstruct element of the digital document depending on anchor property
     */
    DocStruct topElement = dd.getLogicalDocStruct();
    if (this.myPrefs.getDocStrctTypeByName(topElement.getType().getName()).isAnchor()) {
      if (topElement.getAllChildren() == null || topElement.getAllChildren().size() == 0) {
        throw new PreferencesException(process.getTitle()
            + ": the topstruct element is marked as anchor, but does not have any children for physical docstrucs");
      } else {
        topElement = topElement.getAllChildren().get(0);
      }
    }

    /*
     * -------------------------------- if the top element does not have any image related, set them all --------------------------------
     */
    if (topElement.getAllToReferences("logical_physical") == null || topElement.getAllToReferences("logical_physical").size() == 0) {
      if (dd.getPhysicalDocStruct() != null && dd.getPhysicalDocStruct().getAllChildren() != null) {
        Helper.setMeldung(process.getTitle()
            + ": topstruct element does not have any referenced images yet; temporarily adding them for mets file creation");
        for (DocStruct mySeitenDocStruct : dd.getPhysicalDocStruct().getAllChildren()) {
          topElement.addReferenceTo(mySeitenDocStruct, "logical_physical");
        }
      } else {
        Helper.setFehlerMeldung(process.getTitle() + ": could not found any referenced images, export aborted");
        dd = null;
        return false;
      }
    }

    if (dd != null) {
      for (ContentFile cf : dd.getFileSet().getAllFiles()) {
        String location = cf.getLocation();
        // If the file's location string shoes no sign of any protocol,
        // use the file protocol.
        if (!location.contains("://")) {
          location = "file://" + location;
        }
        URL url = new URL(location);
        File f = new File(imageFolder, url.getFile());
        cf.setLocation(f.toURI().toString());
      }

      mm.setDigitalDocument(dd);

      /*
       * -------------------------------- wenn Filegroups definiert wurden, werden diese jetzt in die Metsstruktur übernommen
       * --------------------------------
       */
      // Replace all paths with the given VariableReplacer, also the file
      // group paths!
      VariableReplacerWithoutHibernate vp = new VariableReplacerWithoutHibernate(mm.getDigitalDocument(), this.myPrefs, process, null);
      List<ProjectFileGroup> myFilegroups = ProjectManager.getFilegroupsForProjectId(this.project.getId());

      if (myFilegroups != null && myFilegroups.size() > 0) {
        for (ProjectFileGroup pfg : myFilegroups) {
          // check if source files exists
          if (pfg.getFolder() != null && pfg.getFolder().length() > 0) {
            File folder = new File(this.fi.getMethodFromName(pfg.getFolder()));
            if (folder != null && folder.exists() && folder.list().length > 0) {
              VirtualFileGroup v = new VirtualFileGroup();
              v.setName(pfg.getName());
              v.setPathToFiles(vp.replace(pfg.getPath()));
              v.setMimetype(pfg.getMimetype());
              v.setFileSuffix(pfg.getSuffix());
              mm.getDigitalDocument().getFileSet().addVirtualFileGroup(v);
            }
          } else {

            VirtualFileGroup v = new VirtualFileGroup();
            v.setName(pfg.getName());
            v.setPathToFiles(vp.replace(pfg.getPath()));
            v.setMimetype(pfg.getMimetype());
            v.setFileSuffix(pfg.getSuffix());
            mm.getDigitalDocument().getFileSet().addVirtualFileGroup(v);
          }
        }
      }

      // Replace rights and digiprov entries.
      mm.setRightsOwner(vp.replace(this.project.getMetsRightsOwner()));
      mm.setRightsOwnerLogo(vp.replace(this.project.getMetsRightsOwnerLogo()));
      mm.setRightsOwnerSiteURL(vp.replace(this.project.getMetsRightsOwnerSite()));
      mm.setRightsOwnerContact(vp.replace(this.project.getMetsRightsOwnerMail()));
      mm.setDigiprovPresentation(vp.replace(this.project.getMetsDigiprovPresentation()));
      mm.setDigiprovReference(vp.replace(this.project.getMetsDigiprovReference()));
      mm.setDigiprovPresentationAnchor(vp.replace(this.project.getMetsDigiprovPresentationAnchor()));
      mm.setDigiprovReferenceAnchor(vp.replace(this.project.getMetsDigiprovReferenceAnchor()));

      mm.setPurlUrl(vp.replace(this.project.getMetsPurl()));
      mm.setContentIDs(vp.replace(this.project.getMetsContentIDs()));

      String pointer = this.project.getMetsPointerPath();
      pointer = vp.replace(pointer);
      mm.setMptrUrl(pointer);

      String anchor = this.project.getMetsPointerPathAnchor();
      pointer = vp.replace(anchor);
      mm.setMptrAnchorUrl(pointer);

      List<String> images = new ArrayList<String>();
      try {
        // TODO andere Dateigruppen nicht mit image Namen ersetzen
        images = this.fi.getDataFiles();
        if (images != null) {
          int sizeOfPagination = dd.getPhysicalDocStruct().getAllChildren().size();
          int sizeOfImages = images.size();
          if (sizeOfPagination == sizeOfImages) {
            dd.overrideContentFiles(images);
          } else {
            List<String> param = new ArrayList<String>();
            param.add(String.valueOf(sizeOfPagination));
            param.add(String.valueOf(sizeOfImages));
            Helper.setFehlerMeldung(Helper.getTranslation("imagePaginationError", param));
View Full Code Here

    FolderInformation fi = new FolderInformation(processId, process.getTitle());
    this.title = title;
    String metadataLanguage = (String) Helper.getManagedBeanValue("#{LoginForm.myBenutzer.metadatenSprache}");
    boolean ergebnis = true;

    DigitalDocument dd = null;
    try {
      dd = gdzfile.getDigitalDocument();
    } catch (Exception e) {
      Helper.setFehlerMeldung(Helper.getTranslation("MetadataDigitalDocumentError") + title, e.getMessage());
      ergebnis = false;
    }

    DocStruct logical = dd.getLogicalDocStruct();
    if (logical.getAllIdentifierMetadata() != null && logical.getAllIdentifierMetadata().size() > 0) {
      Metadata identifierTopStruct = logical.getAllIdentifierMetadata().get(0);
      try {
        if (!identifierTopStruct.getValue().replaceAll("[\\w|-]", "").equals("")) {
          Helper.setFehlerMeldung(Helper.getTranslation("MetadataIdentifierError")
              + identifierTopStruct.getType().getNameByLanguage(metadataLanguage) + " in DocStruct "
              + logical.getType().getNameByLanguage(metadataLanguage) + Helper.getTranslation("MetadataInvalidCharacter"));
          ergebnis = false;
        }
        DocStruct firstChild = logical.getAllChildren().get(0);
        Metadata identifierFirstChild = firstChild.getAllIdentifierMetadata().get(0);
        if (identifierTopStruct.getValue() != null && identifierTopStruct.getValue() != ""
            && identifierTopStruct.getValue().equals(identifierFirstChild.getValue())) {
          Helper.setFehlerMeldung(Helper.getTranslation("MetadataIdentifierError") + identifierTopStruct.getType().getName()
              + Helper.getTranslation("MetadataIdentifierSame") + logical.getType().getName() + " and "
              + firstChild.getType().getName());
          ergebnis = false;
        }
        if (!identifierFirstChild.getValue().replaceAll("[\\w|-]", "").equals("")) {
          Helper.setFehlerMeldung(Helper.getTranslation("MetadataIdentifierError") + identifierFirstChild.getType().getName()
              + " in DocStruct " + firstChild.getType().getName() + Helper.getTranslation("MetadataInvalidCharacter"));
          ergebnis = false;
        }
      } catch (Exception e) {
        // no firstChild or no identifier
      }
    } else {
      Helper.setFehlerMeldung(Helper.getTranslation("MetadataMissingIdentifier"));
      ergebnis = false;
    }
    /*
     * -------------------------------- PathImagesFiles prüfen --------------------------------
     */
    if (!this.isValidPathImageFiles(dd.getPhysicalDocStruct(), inPrefs)) {
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Docstructs ohne Seiten prüfen --------------------------------
     */
    DocStruct logicalTop = dd.getLogicalDocStruct();
    if (logicalTop == null) {
      Helper.setFehlerMeldung(title + ": " + Helper.getTranslation("MetadataPaginationError"));
      ergebnis = false;
    }

    this.docStructsOhneSeiten = new ArrayList<DocStruct>();
    this.checkDocStructsOhneSeiten(logicalTop);
    if (this.docStructsOhneSeiten.size() != 0) {
      for (Iterator<DocStruct> iter = this.docStructsOhneSeiten.iterator(); iter.hasNext();) {
        DocStruct ds = iter.next();
        Helper.setFehlerMeldung(title + ": " + Helper.getTranslation("MetadataPaginationStructure")
            + ds.getType().getNameByLanguage(metadataLanguage));
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Seiten ohne Docstructs prüfen --------------------------------
     */
    List<String> seitenOhneDocstructs = null;
    try {
      seitenOhneDocstructs = checkSeitenOhneDocstructs(gdzfile);
    } catch (PreferencesException e1) {
      Helper.setFehlerMeldung("[" + title + "] Can not check pages without docstructs: ");
      ergebnis = false;
    }
    if (seitenOhneDocstructs != null && seitenOhneDocstructs.size() != 0) {
      for (Iterator<String> iter = seitenOhneDocstructs.iterator(); iter.hasNext();) {
        String seite = iter.next();
        Helper.setFehlerMeldung(title + ": " + Helper.getTranslation("MetadataPaginationPages"), seite);
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf mandatory Values der Metadaten prüfen --------------------------------
     */
    List<String> mandatoryList = checkMandatoryValues(dd.getLogicalDocStruct(), new ArrayList<String>(), metadataLanguage);
    if (mandatoryList.size() != 0) {
      for (Iterator<String> iter = mandatoryList.iterator(); iter.hasNext();) {
        String temp = iter.next();
        Helper.setFehlerMeldung(title + ": " + Helper.getTranslation("MetadataMandatoryElement"), temp);
      }
      ergebnis = false;
    }

    /*
     * -------------------------------- auf Details in den Metadaten prüfen, die in der Konfiguration angegeben wurden
     * --------------------------------
     */
    List<String> configuredList = checkConfiguredValidationValues(dd.getLogicalDocStruct(), new ArrayList<String>(), inPrefs, metadataLanguage,
        project);
    if (configuredList.size() != 0) {
      for (Iterator<String> iter = configuredList.iterator(); iter.hasNext();) {
        String temp = iter.next();
        Helper.setFehlerMeldung(title + ": " + Helper.getTranslation("MetadataInvalidData"), temp);
      }
      ergebnis = false;
    }

    MetadatenImagesHelper mih = new MetadatenImagesHelper(inPrefs, dd);
    try {
      if (!mih.checkIfImagesValid(title, fi.getImagesTifDirectory(true))) {
        ergebnis = false;
      }
    } catch (Exception e) {
      Helper.setFehlerMeldung(title + ": ", e);
      ergebnis = false;
    }

    /*
     * -------------------------------- Metadaten ggf. zum Schluss speichern --------------------------------
     */

    try {
      List<String> images = fi.getDataFiles();
      if (images != null) {
        int sizeOfPagination = dd.getPhysicalDocStruct().getAllChildren().size();
        int sizeOfImages = images.size();
        if (sizeOfPagination != sizeOfImages) {
          List<String> param = new ArrayList<String>();
          param.add(String.valueOf(sizeOfPagination));
          param.add(String.valueOf(sizeOfImages));
View Full Code Here

TOP

Related Classes of ugh.dl.DigitalDocument

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.