Package ugh.dl

Examples of ugh.dl.Metadata


              }
              field.setWert(myautoren);
            } else {
              /* bei normalen Feldern die Inhalte auswerten */
              MetadataType mdt = ughHelp.getMetadataType(this.prozessKopie.getRegelsatz().getPreferences(), field.getMetadata());
              Metadata md = ughHelp.getMetadata(myTempStruct, mdt);
              if (md != null) {
                field.setWert(md.getValue());
              }
            }
          } catch (UghHelperException e) {
            Helper.setFehlerMeldung(e.getMessage(), "");
          }
View Full Code Here


               * bis auf die Autoren alle additionals in die Metadaten übernehmen
               */
              if (!field.getMetadata().equals("ListOfCreators")) {
                MetadataType mdt = this.ughHelp.getMetadataType(this.prozessKopie.getRegelsatz().getPreferences(),
                    field.getMetadata());
                Metadata md = this.ughHelp.getMetadata(myTempStruct, mdt);
                /*
                 * wenn das Metadatum null ist, dann jetzt initialisieren
                 */
                if (md == null) {
                  md = new Metadata(mdt);
                  md.setDocStruct(myTempStruct);
                  myTempStruct.addMetadata(md);
                }
                md.setValue(field.getWert());
                /*
                 * wenn dem Topstruct und dem Firstchild der Wert gegeben werden soll
                 */
                if (myTempChild != null) {
                  md = this.ughHelp.getMetadata(myTempChild, mdt);

                  md.setValue(field.getWert());
                }
              }
            } catch (NullPointerException e) {
            } catch (UghHelperException e) {

            } catch (MetadataTypeNotAllowedException e) {

            }
          } // end if ughbinding
        }// end for

        /*
         * -------------------------------- Collectionen hinzufügen --------------------------------
         */
        DocStruct colStruct = this.myRdf.getDigitalDocument().getLogicalDocStruct();
        try {
          addCollections(colStruct);
          /*
           * falls ein erstes Kind vorhanden ist, sind die Collectionen dafür
           */
          colStruct = colStruct.getAllChildren().get(0);
          addCollections(colStruct);
        } catch (RuntimeException e) {
          /*
           * das Firstchild unterhalb des Topstructs konnte nicht ermittelt werden
           */
        }

        /*
         * -------------------------------- 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
              && this.myRdf.getDigitalDocument().getPhysicalDocStruct() != null) {
            List<? extends Metadata> alleImagepfade = this.myRdf.getDigitalDocument().getPhysicalDocStruct().getAllMetadataByType(mdt);
            if (alleImagepfade != null && alleImagepfade.size() > 0) {
              for (Metadata md : alleImagepfade) {
                this.myRdf.getDigitalDocument().getPhysicalDocStruct().getAllMetadata().remove(md);
              }
            }
            Metadata newmd = new Metadata(mdt);
            newmd.setValue("./" + this.prozessKopie.getTitel() + DIRECTORY_SUFFIX);
            this.myRdf.getDigitalDocument().getPhysicalDocStruct().addMetadata(newmd);
          }
          /* Rdf-File schreiben */
          this.prozessKopie.writeMetadataFile(this.myRdf);

 
View Full Code Here

  /* =============================================================== */

  private void addCollections(DocStruct colStruct) {
    for (String s : this.digitalCollections) {
      try {
        Metadata md = new Metadata(this.ughHelp.getMetadataType(this.prozessKopie.getRegelsatz().getPreferences(), "singleDigCollection"));
        md.setValue(s);
        md.setDocStruct(colStruct);
        colStruct.addMetadata(md);
      } catch (UghHelperException e) {
        Helper.setFehlerMeldung(e.getMessage(), "");
        e.printStackTrace();
      } catch (DocStructHasNoTypeException e) {
View Full Code Here

     * -------------------------------- nachdem alle Metadaten durchlaufen
     * wurden, jetzt abhängig vom Sprachcode den richtigen MainTitle
     * zuweisen --------------------------------
     */
    MetadataType mdt_org = myPrefs.getMetadataTypeByName("TitleDocMain");
    Metadata meta_org = new Metadata(mdt_org);
    MetadataType mdt_trans = myPrefs.getMetadataTypeByName("MainTitleTranslated");
    Metadata meta_trans = new Metadata(mdt_trans);
    if (language.equals("ru")) {
      meta_org.setValue(titelRu);
      meta_trans.setValue(titelOther);
    } else {
      meta_trans.setValue(titelRu);
      meta_org.setValue(titelOther);
    }

    if (meta_org.getValue() != null && meta_org.getValue().length() > 0) {
      inStruct.addMetadata(meta_org);
    }
    if (meta_trans.getValue() != null && meta_trans.getValue().length() > 0) {
      inStruct.addMetadata(meta_trans);
    }
  }
View Full Code Here

   */
  private void RusdmlDropPersons(DocStruct inStruct) {
    if (inStruct.getAllPersons() != null) {
      List<Person> kopie = new ArrayList<Person>(inStruct.getAllPersons());
      for (Iterator<Person> iter = kopie.iterator(); iter.hasNext();) {
        Metadata meta = iter.next();
        if (meta.getType().getName().equals("ZBLAuthor")) {
          inStruct.getAllPersons().remove(meta);
        }
      }
    }
  }
View Full Code Here

    /* erstmal prüfen, ob das Heft schon existiert */
    List<DocStruct> myList = dsPeriodicalVolume.getAllChildrenByTypeAndMetadataType("PeriodicalIssue", "CurrentNo");
    if (myList != null && myList.size() != 0) {
      for (DocStruct dsIntern : myList) {
        // myLogger.debug(dsIntern.getAllMetadataByType(mdt).getFirst());
        Metadata myMD1 = dsIntern.getAllMetadataByType(mdt).get(0);
        // myLogger.debug("und der Wert ist: " + myMD1.getValue());
        if (myMD1.getValue().equals(myRight)) {
          dsPeriodicalIssue = dsIntern;
        }
      }
    }
    /* wenn das Heft nicht gefunden werden konnte, jetzt anlegen */
    if (dsPeriodicalIssue == null) {
      dst = this.myPrefs.getDocStrctTypeByName("PeriodicalIssue");
      dsPeriodicalIssue = inDigitalDocument.createDocStruct(dst);
      Metadata myMD = new Metadata(mdt);
      // myMD.setType(mdt);
      myMD.setValue(myRight);
      dsPeriodicalIssue.addMetadata(myMD);
      dsPeriodicalVolume.addChild(dsPeriodicalIssue);
    }
    return dsPeriodicalIssue;
  }
View Full Code Here

      TypeNotAllowedForParentException, MetadataTypeNotAllowedException {

    // myLogger.debug(myLeft);
    // myLogger.debug(myRight);
    // myLogger.debug("---");
    Metadata md;
    MetadataType mdt;

    // J: Zeitschrift
    // V: Band
    // I: Heft
    // Y: Jahrgang

    /*
     * -------------------------------- Zeitschriftenname --------------------------------
     */
    if (myLeft.equals("J")) {
      mdt = this.myPrefs.getMetadataTypeByName("TitleDocMain");
      List<? extends ugh.dl.Metadata> myList = inStruct.getAllMetadataByType(mdt);
      /* wenn noch kein Zeitschrifenname vergeben wurde, dann jetzt */
      if (myList.size() == 0) {
        md = new Metadata(mdt);
        // md.setType(mdt);
        md.setValue(myRight);
        inStruct.addMetadata(md);
      } else {
        /* wurde schon ein Zeitschriftenname vergeben, prüfen, ob dieser genauso lautet */
        md = myList.get(0);
        if (!myRight.equals(md.getValue())) {
          throw new WrongImportFileException("Parsingfehler: verschiedene Zeitschriftennamen in der Datei ('" + md.getValue() + "' & '"
              + myRight + "')");
        }
      }
      return;
    }

    /*
     * -------------------------------- Jahrgang --------------------------------
     */
    if (myLeft.equals("Y")) {
      mdt = this.myPrefs.getMetadataTypeByName("PublicationYear");
      List<? extends ugh.dl.Metadata> myList = inStruct.getAllMetadataByType(mdt);

      /* wenn noch kein Zeitschrifenname vergeben wurde, dann jetzt */
      if (myList.size() == 0) {
        md = new Metadata(mdt);
        // md.setType(mdt);
        md.setValue(myRight);
        inStruct.addMetadata(md);
      } else {

        /* wurde schon ein Zeitschriftenname vergeben, prüfen, ob dieser genauso lautet */
        md = myList.get(0);

        /*
         * -------------------------------- da Frau Jansch ständig Importprobleme mit jahrübergreifenden Bänden hat, jetzt mal auskommentiert
         * --------------------------------
         */
        // if (!myRight.equals(md.getValue()))
        // throw new WrongImportFileException("Parsingfehler: verschiedene Jahresangaben in der Datei ('"
        // + md.getValue() + "' & '" + myRight + "')");
      }
      return;
    }

    /*
     * -------------------------------- Bandnummer --------------------------------
     */
    if (myLeft.equals("V")) {
      mdt = this.myPrefs.getMetadataTypeByName("CurrentNo");
      List<? extends ugh.dl.Metadata> myList = inStruct.getAllMetadataByType(mdt);

      /* wenn noch keine Bandnummer vergeben wurde, dann jetzt */
      if (myList.size() == 0) {
        md = new Metadata(mdt);
        md.setValue(myRight);
        inStruct.addMetadata(md);
      } else {

        /* wurde schon eine Bandnummer vergeben, prüfen, ob dieser genauso lautet */
        md = myList.get(0);
        if (!myRight.equals(md.getValue())) {
          throw new WrongImportFileException("Parsingfehler: verschiedene Bandangaben in der Datei ('" + md.getValue() + "' & '" + myRight
              + "')");
        }
      }
      return;
    }
View Full Code Here

  private void ParsenArtikel(DocStruct inStruct, String myLeft, String myRight, boolean istErsterTitel) throws MetadataTypeNotAllowedException,
      WrongImportFileException {
    // myLogger.debug(myLeft);
    // myLogger.debug(myRight);
    // myLogger.debug("---");
    Metadata md;
    MetadataType mdt;

    // J: Zeitschrift
    // V: Band
    // I: Heft
    // Y: Jahrgang
    // SO: Quelle (fuer uns intern)
    // AR: Author (Referenz)
    // BR: Biographische Referenz
    // AB: Abstract-Review
    // DE: Vorlaeufige AN-Nummer (eher fuer uns intern)
    // SI: Quellenangabe für Rezension im Zentralblatt
    //   

    /*
     * -------------------------------- erledigt
     *
     * TI: Titel AU: Autor LA: Sprache NH: Namensvariationen CC: MSC 2000 KW: Keywords AN: Zbl und/oder JFM Nummer P: Seiten
     *
     * --------------------------------
     */

    /*
     * -------------------------------- Titel --------------------------------
     */
    if (myLeft.equals("TI")) {
      if (istErsterTitel) {
        mdt = this.myPrefs.getMetadataTypeByName("TitleDocMain");
      } else {
        mdt = this.myPrefs.getMetadataTypeByName("MainTitleTranslated");
      }
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- Sprache --------------------------------
     */
    if (myLeft.equals("LA")) {
      mdt = this.myPrefs.getMetadataTypeByName("DocLanguage");
      md = new Metadata(mdt);
      md.setValue(myRight.toLowerCase());
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLIdentifier --------------------------------
     */
    if (myLeft.equals("AN")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLIdentifier");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLPageNumber --------------------------------
     */
    if (myLeft.equals("P")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLPageNumber");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLSource --------------------------------
     */
    if (myLeft.equals("SO")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLSource");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLAbstract --------------------------------
     */
    if (myLeft.equals("AB")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLAbstract");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLReviewAuthor --------------------------------
     */
    if (myLeft.equals("RV")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLReviewAuthor");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLCita --------------------------------
     */
    if (myLeft.equals("CI")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLCita");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLTempID --------------------------------
     */
    if (myLeft.equals("DE")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLTempID");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLReviewLink --------------------------------
     */
    if (myLeft.equals("SI")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLReviewLink");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- ZBLIntern --------------------------------
     */
    if (myLeft.equals("XX")) {
      mdt = this.myPrefs.getMetadataTypeByName("ZBLIntern");
      md = new Metadata(mdt);
      md.setValue(myRight);
      inStruct.addMetadata(md);
      return;
    }

    /*
     * -------------------------------- Keywords --------------------------------
     */
    if (myLeft.equals("KW")) {
      StringTokenizer tokenizer = new StringTokenizer(myRight, ";");
      while (tokenizer.hasMoreTokens()) {
        md = new Metadata(this.myPrefs.getMetadataTypeByName("Keyword"));
        String myTok = tokenizer.nextToken();
        md.setValue(myTok.trim());
        inStruct.addMetadata(md);
      }
      return;
    }

    /*
     * -------------------------------- Autoren als Personen --------------------------------
     */
    if (myLeft.equals("AU")) {
      StringTokenizer tokenizer = new StringTokenizer(myRight, ";");
      while (tokenizer.hasMoreTokens()) {
        Person p = new Person(this.myPrefs.getMetadataTypeByName("ZBLAuthor"));
        String myTok = tokenizer.nextToken();

        if (myTok.indexOf(",") == -1) {
          throw new WrongImportFileException("Parsingfehler: Vorname nicht mit Komma vom Nachnamen getrennt ('" + myTok + "')");
        }

        p.setLastname(myTok.substring(0, myTok.indexOf(",")).trim());
        p.setFirstname(myTok.substring(myTok.indexOf(",") + 1, myTok.length()).trim());
        p.setRole("ZBLAuthor");
        inStruct.addPerson(p);
      }
      return;
    }

    /*
     * -------------------------------- AutorVariationen als Personen --------------------------------
     */
    if (myLeft.equals("NH")) {
      StringTokenizer tokenizer = new StringTokenizer(myRight, ";");
      while (tokenizer.hasMoreTokens()) {
        Person p = new Person(this.myPrefs.getMetadataTypeByName("AuthorVariation"));
        String myTok = tokenizer.nextToken();

        if (myTok.indexOf(",") == -1) {
          throw new WrongImportFileException("Parsingfehler: Vorname nicht mit Komma vom Nachnamen getrennt ('" + myTok + "')");
        }

        p.setLastname(myTok.substring(0, myTok.indexOf(",")).trim());
        p.setFirstname(myTok.substring(myTok.indexOf(",") + 1, myTok.length()).trim());
        p.setRole("AuthorVariation");
        inStruct.addPerson(p);
      }
      return;
    }

    /*
     * -------------------------------- MSC 2000 - ClassificationMSC --------------------------------
     */
    if (myLeft.equals("CC")) {
      StringTokenizer tokenizer = new StringTokenizer(myRight);
      while (tokenizer.hasMoreTokens()) {
        md = new Metadata(this.myPrefs.getMetadataTypeByName("ClassificationMSC"));
        String myTok = tokenizer.nextToken();
        md.setValue(myTok.trim());
        inStruct.addMetadata(md);
      }
      return;
    }
  }
View Full Code Here

      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
View Full Code Here

  private boolean isValidPathImageFiles(DocStruct phys, Prefs myPrefs) {
    try {
      MetadataType mdt = this.ughhelp.getMetadataType(myPrefs, "pathimagefiles");
      List<? extends Metadata> alleMetadaten = phys.getAllMetadataByType(mdt);
      if (alleMetadaten != null && alleMetadaten.size() > 0) {
        @SuppressWarnings("unused")
        Metadata mmm = alleMetadaten.get(0);

        return true;
      } else {
        Helper.setFehlerMeldung(this.title + ": " + "Can not verify, image path is not set", "");
View Full Code Here

TOP

Related Classes of ugh.dl.Metadata

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.