Examples of de.sub.goobi.beans.Prozess

de.sub.goobi.beans.Prozess

   *             if no suitable template is found
   */
  protected ProzesskopieForm newProcessFromTemplate(String templateTitle) throws IllegalArgumentException {
    ProzesskopieForm result = new ProzesskopieForm();


    Prozess selectedTemplate = getTemplateByTitle(templateTitle);
    result.setProzessVorlage(selectedTemplate);
    result.Prepare();
    return result;
  }

View Full Code Here

              logger.trace("8");
              if (size == getSize(list)) {
                hotfolder.lock();
                logger.trace("9");
                ProzessDAO dao = new ProzessDAO();
                Prozess template = dao.get(hotfolder.getTemplate());
                dao.refresh(template);
                logger.trace("10");
                List<String> metsfiles = hotfolder.getFileNamesByFilter(GoobiHotfolder.filter);
                logger.trace("11");
                HashMap<String, Integer> failedData = new HashMap<String, Integer>();

View Full Code Here

          form.setDigitalCollections(col);
        }
        form.OpacAuswerten();


        try {
          Prozess p = form.NeuenProzessAnlegen2();
          if (p.getId() != null) {


            // copy image files to new directory
            File images = new File(dir.getAbsoluteFile() + File.separator + processTitle.substring(0, processTitle.length() - 4)
                + File.separator);
            List<String> imageDir = new ArrayList<String>();
            if (images.isDirectory()) {
              String[] files = images.list();
              for (int i = 0; i < files.length; i++) {
                imageDir.add(files[i]);
              }
              for (String file : imageDir) {
                File image = new File(images, file);
                File dest = new File(p.getImagesOrigDirectory(false) + image.getName());
                FileUtils.moveFile(image, dest);
              }
              FileUtils.deleteDirectory(images);
            }


            // copy fulltext files


            File fulltext = new File(dir.getAbsoluteFile() + File.separator + processTitle.substring(0, processTitle.length() - 4)
                + "_txt" + File.separator);
            if (fulltext.isDirectory()) {
          
              FileUtils.moveDirectory(fulltext, new File(p.getTxtDirectory()));
            }


            // copy source files


            File sourceDir = new File(dir.getAbsoluteFile() + File.separator + processTitle.substring(0, processTitle.length() - 4)
                + "_src" + File.separator);
            if (sourceDir.isDirectory()) {
              FileUtils.moveDirectory(sourceDir, new File(p.getImportDirectory()));
            }


            try {
              FileUtils.forceDelete(new File(dir.getAbsolutePath() + File.separator + processTitle));
            } catch (Exception e) {
              logger.error("Can not delete file " + processTitle + " after importing " + p.getTitel() + " into goobi", e);
              return 30;
            }
            File anchor = new File(dir.getAbsolutePath() + File.separator + processTitle.substring(0, processTitle.length() - 4)
                + "_anchor.xml");
            if (anchor.exists()) {
              FileUtils.deleteQuietly(anchor);
            }
            List<StepObject> steps = StepManager.getStepsForProcess(p.getId());
            for (StepObject s : steps) {
              if (s.getBearbeitungsstatus() == 1 && s.isTypAutomatisch()) {
                ScriptThreadWithoutHibernate myThread = new ScriptThreadWithoutHibernate(s);
                myThread.start();
              }

View Full Code Here

    String metsfilename = io.getMetsFilename();
    logger.trace("mets filename is " + metsfilename);
    String basepath = metsfilename.substring(0, metsfilename.length() - 4);
    logger.trace("basepath is " + basepath);
    File metsfile = new File(metsfilename);
    Prozess p = null;
    if (!testTitle(processTitle)) {
      logger.trace("wrong title");
      // removing all data
      File imagesFolder = new File(basepath);
      if (imagesFolder.exists() && imagesFolder.isDirectory()) {

View Full Code Here

      myLogger.error(e);
    } catch (ReadException e) {
      myLogger.error(e);
    }
    ;
    this.prozessKopie = new Prozess();
    this.prozessKopie.setTitel("");
    this.prozessKopie.setIstTemplate(false);
    this.prozessKopie.setInAuswahllisteAnzeigen(false);
    this.prozessKopie.setProjekt(this.prozessVorlage.getProjekt());
    this.prozessKopie.setRegelsatz(this.prozessVorlage.getRegelsatz());

View Full Code Here

      myLogger.error(e);
    } catch (ReadException e) {
      myLogger.error(e);
    }
    ;
    this.prozessKopie = new Prozess();
    this.prozessKopie.setTitel("");
    this.prozessKopie.setIstTemplate(false);
    this.prozessKopie.setInAuswahllisteAnzeigen(false);
    this.prozessKopie.setProjekt(this.prozessVorlage.getProjekt());
    this.prozessKopie.setRegelsatz(this.prozessVorlage.getRegelsatz());

View Full Code Here

   *             ============================================================ == ==
   */
  @Override
  public String TemplateAuswahlAuswerten() throws DAOException {
    /* den ausgewählten Prozess laden */
    Prozess tempProzess = new ProzessDAO().get(this.auswahl);
    if (tempProzess.getWerkstueckeSize() > 0) {
      /* erstes Werkstück durchlaufen */
      Werkstueck werk = tempProzess.getWerkstueckeList().get(0);
      for (Werkstueckeigenschaft eig : werk.getEigenschaften()) {
        for (AdditionalField field : this.additionalFields) {
          if (field.getTitel().equals(eig.getTitel())) {
            field.setWert(eig.getWert());
          }
        }
      }
    }


    if (tempProzess.getVorlagenSize() > 0) {
      /* erste Vorlage durchlaufen */
      Vorlage vor = tempProzess.getVorlagenList().get(0);
      for (Vorlageeigenschaft eig : vor.getEigenschaften()) {
        for (AdditionalField field : this.additionalFields) {
          if (field.getTitel().equals(eig.getTitel())) {
            field.setWert(eig.getWert());
          }
        }
      }
    }


    try {
      this.myRdf = tempProzess.readMetadataAsTemplateFile();
    } catch (Exception e) {
      Helper.setFehlerMeldung("Fehler beim Einlesen der Template-Metadaten ", e);
    }


    /* falls ein erstes Kind vorhanden ist, sind die Collectionen dafür */

View Full Code Here

    logger.debug("Load Production Data from xml.");
    ArrayList<ProductionData> dataList = load(filename);
    logger.debug("Got " + dataList.size() + " items");




    Prozess template = new Prozess();
    template.setProjekt(altdaten);
    template.setTitel("Altdatenvorlage");
    template.setIstTemplate(true);


    // gdz Regelsatz
    Regelsatz ruleset = new RegelsatzDAO().get(Integer.valueOf(17));


    template.setRegelsatz(ruleset);


    session.save(template);
    Set<Schritt> step = getSteps(template);
    template.setSchritte(step);
    for (Schritt s : step) {
      session.save(s);
    }
    session.save(template);
    int i = 0;
    int newProj = 0;
    int oldProj = 0;
    for (ProductionData pd : dataList) {
      String ppn = pd.getWERKPPNDIGITAL();
      if (ppn != null && ppn.length() > 0) {
        // get ppn.
        int ppnIndex = ppn.indexOf("PPN");
        if (ppnIndex == -1) {
          ppnIndex = ppn.indexOf("ppn");
        }
        if (ppnIndex != -1) {
          ppn = ppn.substring(ppnIndex + 3);
          logger.debug(ppn);


          // get all werkstueckeigenschaften for this ppn
          ArrayList<String> ppnlist = new ArrayList<String>();
          ppnlist.add(ppn);
          ppnlist.add("PPN" + ppn);
          Criteria crit = session.createCriteria(Werkstueckeigenschaft.class).add(Restrictions.in("wert", ppnlist));
          ArrayList<Werkstueckeigenschaft> weList = new ArrayList<Werkstueckeigenschaft>();
          weList.addAll(crit.list());
          // -------------------------------------------------------------------------------
          // add properties to existing prozess
          // -------------------------------------------------------------------------------
          boolean added = false;
          if (weList.size() > 0) {
            Werkstueckeigenschaft we = weList.get(0);
            Werkstueck w = we.getWerkstueck();
            if (w != null) {
              Prozess p = w.getProzess();
              if (p != null) {
                logger.debug("Add new Properties for Process : " + p.getTitel());
                addNewPropertiesForExistingProcesses(session, p.getId(), pd);
                added = true;
                oldProj++;
              }
            }
          }

View Full Code Here

  private void generateNewPropertiesForNewProzess(Session session, Regelsatz ruleset, Projekt project, ProductionData pd)
      throws HibernateException, SQLException {


    // generate new Process


    Prozess prozess = new Prozess();


    prozess.setProjekt(getProjekt(pd));
    String title = pd.getWERKATS() + "_" + pd.getWERKPPNDIGITAL();
    title = title.replaceAll("\\W", "");
    prozess.setTitel(title);
    prozess.setIstTemplate(false);
    prozess.setRegelsatz(ruleset);
    Werkstueck werk = new Werkstueck();
    werk.setProzess(prozess);


    Werkstueckeigenschaft we = new Werkstueckeigenschaft();
    we.setWerkstueck(werk);
    we.setTitel("PPN");
    String ppn = pd.getWERKPPNDIGITAL();


    // get ppn.
    int ppnIndex = ppn.indexOf("PPN");
    if (ppnIndex == -1) {
      ppnIndex = ppn.indexOf("ppn");
    }
    if (ppnIndex != -1) {
      ppn = ppn.substring(ppnIndex + 3);
    }


    we.setWert(ppn);
    if (werk.getEigenschaften() == null) {
      werk.setEigenschaften(new HashSet<Werkstueckeigenschaft>());
    }
    werk.getEigenschaften().add(we);


    Vorlage v = new Vorlage();
    v.setProzess(prozess);


    if (prozess.getWerkstuecke() == null) {
      HashSet<Werkstueck> werkstueckeSet = new HashSet<Werkstueck>();
      prozess.setWerkstuecke(werkstueckeSet);
    }
    if (prozess.getVorlagen() == null) {
      HashSet<Vorlage> vorlagenSet = new HashSet<Vorlage>();
      prozess.setVorlagen(vorlagenSet);
    }
    prozess.getWerkstuecke().add(werk);
    prozess.getVorlagen().add(v);


    session.save(werk);
    session.save(we);
    session.save(v);
    session.save(prozess);
    Set<Schritt> step = getSteps(prozess);
    prozess.setSchritte(step);
    for (Schritt s : step) {
      session.save(s);
    }


    session.save(prozess);

View Full Code Here

  private void addNewPropertiesForExistingProcesses(Session session, int pId, ProductionData pd) throws HibernateException, SQLException,
      ConfigurationException {


    
    // Prozess holen
    Prozess p = null;
    Criteria crit = session.createCriteria(Prozess.class).add(Restrictions.eq("id", pId));
    if (crit.list().size() > 0) {
      p = (Prozess) crit.list().get(0);
    }
    if (p == null)
      return;


    /*******************************************
     * properties and attributes for processes *
     ******************************************/
    generateProzessProperty(session, p, "ImportMarker", "merged", PropertyType.String, 0, false);


    // AutorTitelSchluessel
    generateProzessProperty(session, p, "ATS", pd.getWERKATS(), PropertyType.String, 0, false);


    // Auftragsnummer
    generateProzessProperty(session, p, "Auftragsnummer", pd.getAUFTRAGSNUMMER(), PropertyType.String, 0, false);


    // BEMERKUNG


    generateProzessProperty(session, p, "Bemerkung", pd.getBEMERKUNG(), PropertyType.String, 0, false);


    // KOMMENTAR
    generateProzessProperty(session, p, "Kommentar", pd.getKOMMENTAR(), PropertyType.String, 0, false);


    // FEHLERKOMMENTAR
    generateProzessProperty(session, p, "Fehlerkommentar", pd.getFEHLERKOMMENTAR(), PropertyType.String, 0, false);


    // AUFTRAGGEBER
    generateProzessProperty(session, p, "Auftraggeber", String.valueOf(pd.getAUFTRAGGEBER()), PropertyType.Integer, 0, false);


    // BEMERKUNG2
    // TODO Name
    generateProzessProperty(session, p, "Bemerkung2", String.valueOf(pd.getBEMERKUNG2()), PropertyType.Integer, 0, false);


    // XSLSHEET
    // TODO Name
    generateProzessProperty(session, p, "XslSheet", String.valueOf(pd.getXSLSHEET()), PropertyType.Integer, 0, false);


    /********************************************
     * DigiWunschbuch Sponsor *
     *******************************************/
    List<Prozesseigenschaft> eig = p.getEigenschaftenList();
    if (p.getProjekt().getTitel().equals("DigiWunschBuch")) {
      boolean sponsor = false;
      if (eig != null) {


        for (Prozesseigenschaft pe : eig) {
          if (pe.getTitel().contains("Besteller") && (pe.getWert() != null)) {
            sponsor = true;
          }
        }
      }
      if (!sponsor) {
        // SponsorNaming
        generateProzessProperty(session, p, "Patennennung", String.valueOf(pd.getPatennennung()), PropertyType.Integer, 0, false);


        // Patenname
        generateProzessProperty(session, p, "Patenname", pd.getPatenname(), PropertyType.String, 0, false);


        // StempelGesetzt
        generateProzessProperty(session, p, "Stempel gesetzt", String.valueOf(pd.getStempelGesetzt()), PropertyType.Integer, 0, false);


        // xmlTag
        generateProzessProperty(session, p, "xml-Tag", String.valueOf(pd.getXmlTag()), PropertyType.Integer, 0, false);


        // otrsID
        generateProzessProperty(session, p, "OTRS-ID", pd.getOtrsID(), PropertyType.String, 0, false);


        // versandErfolgt
        generateProzessProperty(session, p, "Versand", String.valueOf(pd.getVersandErfolgt()), PropertyType.Integer, 0, false);


        // pdfErstellt
        generateProzessProperty(session, p, "PDF erstellt", String.valueOf(pd.getPdfErstellt()), PropertyType.Integer, 0, false);
      }
    }
    List<Werkstueck> wl = p.getWerkstueckeList();
    boolean ppndigital = false;
    boolean ppnconflict = false;
    for (Werkstueck w : wl) {
      List<Werkstueckeigenschaft> wel = w.getEigenschaftenList();


      String ppn = pd.getWERKPPNDIGITAL();
      if (ppn.startsWith("ppn") || ppn.startsWith("PPN")) {
        ppn = ppn.substring(3);
      }
      for (Werkstueckeigenschaft we : wel) {
        if (we.getTitel().contains("PPN digital")) {
          if (we.getWert() == null) {
            ppndigital = true;
            we.setWert(pd.getWERKPPNDIGITAL());
          } else if (we.getWert().contains(ppn)) {
            ppndigital = true;
          } else if (!we.getWert().contains(ppn)) {
            ppnconflict = true;
          }
        }
      }
      if (!ppndigital && ppnconflict) {
        conflicts.add(new ImportConflicts(String.valueOf(w.getId()), "PPN digital f-Satz", "", pd.getWERKPPNDIGITAL()));
      }
    }


    if (!ppndigital) {
      Werkstueck newWerk = new Werkstueck();
      newWerk.setProzess(p);
      session.save(newWerk);
      // PPN digital f-Satz
      newWerk.setProzess(p);


      generateWerkProperty(session, newWerk, "PPN digital f-Satz", pd.getWERKPPNDIGITAL(), PropertyType.String, 0, false);
    }
    ppnconflict = false;
    boolean signatur = false;
    boolean ppnanalog = false;
    boolean sigconflict = false;
    Vorlage newVorlage = new Vorlage();
    newVorlage.setProzess(p);
    String ppn = pd.getWERKPPNANALOG();
    if (ppn != null) {
      if (ppn.startsWith("ppn") || ppn.startsWith("PPN")) {
        ppn = ppn.substring(3);
      }
      for (Vorlage v : p.getVorlagenList()) {
        for (Vorlageeigenschaft ve : v.getEigenschaftenList()) {
          if (pd.getWERKSIGNATUR() != null) {
            if (ve.getTitel().contains("Signatur")) {
              newVorlage = v;
              if (ve.getWert() == null) {
                signatur = true;
                ve.setWert(pd.getWERKSIGNATUR());
              } else if (ve.getWert().contains(pd.getWERKSIGNATUR())) {
                signatur = true;
              } else {
                sigconflict = true;
              }
            }
          }
          if (ve.getTitel().contains("PPN analog")) {
            newVorlage = v;
            if (ve.getWert() == null) {
              ppnanalog = true;
              ve.setWert(pd.getWERKPPNANALOG());
            } else if (ve.getWert().contains(ppn)) {
              ppnanalog = true;
            } else {
              ppnconflict = true;
            }


          }


        }
        if (!ppnanalog && ppnconflict) {
          conflicts.add(new ImportConflicts(String.valueOf(v.getId()), "PPN analog", "", ppn + " or " + "PPN" + ppn));
        }
        if (!signatur && sigconflict) {
          conflicts.add(new ImportConflicts(String.valueOf(v.getId()), "Signatur", "", pd.getWERKSIGNATUR()));
        }
      }
      if (newVorlage.getId() == null) {
        session.save(newVorlage);
      }
      if (!signatur) {
        // WERKSIGNATUR


        generateVorlageProperty(session, newVorlage, "Signatur", pd.getWERKSIGNATUR(), PropertyType.String, 0, false);
      }
      if (!ppnanalog) {


        generateVorlageProperty(session, newVorlage, "PPN analog f-Satz", pd.getWERKPPNANALOG(), PropertyType.String, 0, false);


      }


    }


    List<Schritt> stepList = p.getSchritteList();


    for (Schritt s : stepList) {


      /********************************************
       * step 'scannen' *
       * TODO einzelne farbformate
       *******************************************/
      if (s.getTitel().contains("scan") || s.getTitel().contains("Scan")) {
        boolean pages = false;
        boolean scangeraet = false;
        for (Schritteigenschaft se : s.getEigenschaftenList()) {
          if (se.getTitel().contains("Anzahl der Images") || se.getTitel().contains("Anzahl der Seiten")
              || se.getTitel().contains("Seitenzahl")) {
            if (!se.getWert().equals(pd.getWERKSCANSEITEN())) {
              conflicts.add(new ImportConflicts(String.valueOf(s.getId()), "Seitenzahl", se.getWert(), String.valueOf(pd
                  .getWERKSCANSEITEN())));
            }
            pages = true;
          } else if (se.getTitel().contains("Scangerät")) {
            if (se.getWert().equals(String.valueOf(pd.getSCANNERTYP()))) {
              scangeraet = true;
            } else {
              conflicts.add(new ImportConflicts(String.valueOf(s.getId()), "Scangerät", se.getWert(), pd.getSCANNERTYP()));
              scangeraet = true;
            }
          }
        }


        if (!pages) {
          // WERKSCANSEITEN
          generateStepProperty(session, s, "Seitenanzahl", String.valueOf(pd.getWERKSCANSEITEN()), PropertyType.Integer, 0, false);


        }
        if (!scangeraet) {
          // SCANNERTYP
          generateStepProperty(session, s, "Scangerät", pd.getSCANNERTYP(), PropertyType.String, 0, false);
        }
        // DRUCKQUALITAET
        generateStepProperty(session, s, "Druckqualität", String.valueOf(pd.getDRUCKQUALITAET()), PropertyType.Integer, 0, false);
      }
      /********************************************
       * step 'Qualitätskontrolle' *
       *******************************************/
      else if (s.getTitel().contains("Qualitätskontrolle")) {
        if (s.getBearbeitungsende() == null) {
          s.setBearbeitungsende(pd.getWERKQKONTROLLDATUM());


        }


        /********************************************
         * step 'Imagenachbearbeitung' *
         *******************************************/
      } else if (s.getTitel().contains("Imagenachbearbeitung")) {


        generateStepProperty(session, s, "BitonalImageNachbearbeitung", pd.getBITONALIMAGENACHBEARBEITUNG(), PropertyType.String, 0, false);


        // GRAUIMAGENACHBEARBEITUNG
        generateStepProperty(session, s, "GrauImageNachbearbeitung", pd.getGRAUIMAGENACHBEARBEITUNG(), PropertyType.String, 0, false);


        // FARBEIMAGENACHBEARBEITUNG
        generateStepProperty(session, s, "FarbeImageNachbearbeitung", pd.getFARBEIMAGENACHBEARBEITUNG(), PropertyType.String, 0, false);


        // FARBGRAUABB
        generateStepProperty(session, s, "FarbgrauABB", String.valueOf(pd.getFARBGRAUABB()), PropertyType.Integer, 0, false);


        // ImageNachbearbBitonalDatum
        generateStepProperty(session, s, "DatumBitonalImageNachbearbeitung", String.valueOf(pd.getImageNachbearbBitonalDatum()), PropertyType.Date,
            0, false);


        // ImageNachbearbBitonalPerson
//        generateStepProperty(session, s, "PersonBitonalImageCorrection", pd.getImageNachbearbBitonalPerson(), PropertyType.String, 0, false);


        // ImageNachbearbGrauDatum
        generateStepProperty(session, s, "DatumGrauImageNachbearbeitung", String.valueOf(pd.getImageNachbearbGrauDatum()), PropertyType.Date,
            0, false);


        // ImageNachbearbGrauPerson
//        generateStepProperty(session, s, "PersonGrayscaleImageCorrection", pd.getImageNachbearbGrauPerson(), PropertyType.String, 0, false);


        // ImageNachbearbFarbeDatum
        generateStepProperty(session, s, "DatumFarbeImageNachbearbeitung", String.valueOf(pd.getImageNachbearbFarbeDatum()), PropertyType.Date, 0,
            false);


        // ImageNachbearbFarbePerson
//        generateStepProperty(session, s, "PersonColorImageCorrection", pd.getImageNachbearbFarbePerson(), PropertyType.String, 0, false);


        /********************************************
         * step 'Archiv' *
         *******************************************/
      } else if (s.getTitel().contains("Archivierung")) {
        generateStepProperty(session, s, "CD-Sicherung-BK", pd.getCDSICHERUNG(), PropertyType.String, 0, false);


        // MAARCHIV
        generateStepProperty(session, s, "MA-ArchivNr", pd.getMAARCHIV(), PropertyType.String, 0, false);


      }


    }


    // History Events


    for (Schritt s : stepList) {
      if (s.getTitel().equals("Bibliographische Aufnahme")) {
        p.getHistory().add(new HistoryEvent(pd.getDATUMAUFNAHMEWERK(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepDone, p));
      } else if (s.getTitel().equals("scannen")) {
        p.getHistory().add(new HistoryEvent(pd.getWERKSCANDATUM(), pd.getWERKSCANSEITEN(), null, HistoryEventType.imagesMasterDiff, p));
        p.getHistory().add(new HistoryEvent(pd.getWERKSCANDATUM(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepDone, p));
        p.getHistory().add(new HistoryEvent(pd.getDATUMAUFNAHMEWERK(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepOpen, p));
      } else if (s.getTitel().equals("Qualitaetskontrolle")) {
        p.getHistory().add(new HistoryEvent(pd.getWERKQKONTROLLDATUM(), pd.getWERKSCANSEITEN(), null, HistoryEventType.imagesWorkDiff, p));
        p.getHistory().add(new HistoryEvent(pd.getWERKQKONTROLLDATUM(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepDone, p));
        p.getHistory().add(new HistoryEvent(pd.getWERKSCANDATUM(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepOpen, p));
      } else if (s.getTitel().equals("Imagenachbearbeitung")) {
        p.getHistory().add(
            new HistoryEvent(pd.getImageNachbearbBitonalDatum(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepDone, p));
        p.getHistory().add(new HistoryEvent(pd.getWERKQKONTROLLDATUM(), s.getReihenfolge(), s.getTitel(), HistoryEventType.stepOpen, p));
        try {
          p.getHistory().add(
              new HistoryEvent(pd.getImageNachbearbBitonalDatum(), new Integer(pd.getBITONALIMAGENACHBEARBEITUNG()), null,
                  HistoryEventType.bitonal, p));
          p.getHistory().add(
              new HistoryEvent(pd.getImageNachbearbBitonalDatum(), new Integer(pd.getGRAUIMAGENACHBEARBEITUNG()), null,
                  HistoryEventType.grayScale, p));
          p.getHistory().add(
              new HistoryEvent(pd.getImageNachbearbBitonalDatum(), new Integer(pd.getFARBEIMAGENACHBEARBEITUNG()), null,
                  HistoryEventType.color, p));


        } catch (NumberFormatException e) {

View Full Code Here

0 1 2 3 4

TOP

Related Classes of de.sub.goobi.beans.Prozess

de.sub.goobi.forms.AdministrationForm

de.sub.goobi.forms.AktuelleSchritteForm

de.sub.goobi.forms.LongRunningTasksForm

de.sub.goobi.forms.MassImportForm

de.sub.goobi.forms.ModuleServerForm

de.sub.goobi.forms.ProzesskopieForm

de.sub.goobi.forms.ProzessverwaltungForm

de.sub.goobi.helper.BatchProcessHelper

de.sub.goobi.helper.BatchStepHelper

de.sub.goobi.helper.GoobiScript

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.