Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Developments and news about Goobi workflow
At this point we provide a detailed insight into our current developments. We try to keep them relatively up to date and to summarize for each month if possible what innovations or changes have been made.
In the table of contents on the left you will find a list of the respective months for which such a compilation already exists. And here you find a direct link to the latest digests:
Developments and news about Goobi workflow
The major changeover in the Maven architecture of Goobi workflow and the plugins was completed in April. Due to the large amount of rework, we recommend that you only use the May release.
We implemented the Maven infrastructure change in April. Goobi workflow still looks the same, but a lot has changed under the bonnet. This is particularly interesting for developers and system administrators.
The new structure now makes it easier to refactor and maintain dependencies in a central location.
For developers, there is now no longer the goobi-workflow repository alone, but workflow-base
and goobi-workflow-core
. We recommend that developers delete all local repositories and check them out again from Github. The core and the plugins now define workflow-base as parent. The location of the artefacts in Nexus has also changed. They are no longer located under de.intranda.goobi.workflow
, but under io.goobi.workflow
.
For system administrators, the naming of artefacts in the plugins has changed. The spelling of .jar
plugin files and .xml
configuration files has been harmonised and standardised. Care must be taken during updates to ensure that no old artefacts are left behind.
A larger set of special plugins was finalised for a customer
Work in the context of vocabularies and archive is progressing
Developments and news about Goobi workflow
We are planning a major change to the Maven architecture of Goobi workflow and the plugins in the coming months. This internal work may temporarily affect the way developers and system administrators work.
For some time now, the number of images within a process can be displayed as an additional table column. Until now, however, it was not possible to activate this setting in general, but it had to be reset after each login. From the January release, it will be possible to save the option in the user settings so that it is active by default for an account.
It is now possible to search for all tasks that have a task with a specific title. Previously, the status of the task had to be specified (steplocked:
, stepopen:
, stepinwork:
, stepdone:
, ...). From now on, simply step:
followed by a title or part of a title also works.
The harvester introduced in October has been extended to include a test mode for the OAI-PMH type. If this is activated, only the first page is queried rather than the complete hit set. The resumptionToken is ignored.
Static from and until values can also be set. If the values are empty, the system searches incrementally for all new data since the last query.
In the January release, we worked on many small construction sites in the context of improved usability and accessibility. For example, some page titles have been added, operation via the keyboard under Firefox has been improved, alternative texts for graphic elements have been added and the page structure has been improved. The changes are only noticeable when Goobi workflow is operated with a screen reader or without a mouse.
For some time now, the journal has also been displayed for user accounts. From the January release, a message is automatically left there when the user profile is entered by an administrator.
The steptitle
option is now optional in the GoobiScript setPriority
function.
An error that occurred during an empty search for authority data is now intercepted.
The generic import plugin for Excel files can now also process the creation of processes via GoobiScript.
The Soutron OPAC plugin now also supports the new XML API.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 24.01.2. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
The major changeover in the Maven architecture of Goobi workflow and the plugins is in full swing, which is why there will be no Goobi workflow release in March.
The newly integrated configuration editor has been extended to allow complete files to be uploaded and downloaded. Furthermore, the backups of the files written in the background are optionally offered for download in the user interface
There have been minor changes to the user interface in the Quartz job management section. When a task is paused, the schedule and date for the next execution are now not displayed. In addition, the icon for one-time execution has been changed.
In the area of vocabularies, work has begun on standardising the usability of importing and exporting data records.
In the area of archives, work has begun on implementing the new Java logic for searching in collections.
An export plugin has been developed that supports the creation of special export formats in the Imagen Media Archive Management software.
The ALMA API plugin can now also contain conditions for variables.
The new step plugin allows metadata to be read from an Excel file and added to existing structural elements.
Developments and news about Goobi workflow
Finally, the column width can be customised within Goobi workflow. The information is saved in the browser's local storage. Once a setting has been made, it is therefore linked to the PC and the browser and is not stored on the server side. This means that different settings can be made on different PCs with different screens so that they do not always get in each other's way.
If there are several export steps in a process, you can now pass the title in the GoobiScript so that the correct export is triggered. Example:
Various minor styling adjustments were made in the area of breadcrumbs or menus Initial internal preparations have been made for Java 17 support
The message queue has received performance improvements
A discontinued Java library for processing regular expressions that has not been maintained for many years has been removed and replaced by an alternative solution.
A step plugin has been developed to download files, verify them and then provide feedback to the external system.
The current version number of Goobi workflow with this release is: 23.12.3. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
December was marked in the project by the upcoming end of the year: A lot of housekeeping and the attempt to tidy up and finish small things to start with air and a clean desk / project first into the vacations and then also so into the new year. For this reason, there is nothing new to report in the December digest of feature developments. Therefore we want to dare an outlook on what we see for the coming year.
For a long time we have been working in the background to change the existing user interface. Many hundreds of hours have already gone into it and the result will look more or less the same as before. However, this work will allow us to work on the surface much easier. Changes no longer have to be made and checked in many individual places, but can be implemented in one central place and then affect all places.
As soon as we are done with this work, we want to work on the usability in the interface. This will cover a number of different areas. Examples are the naming of functionality that should be consistent everywhere or the use of always the same icons for the same action. But also the consistent placement of control elements across the application is part of this, keyword: "Expectability".
Finally, visual redesigns are also part of it. More on this later.
We want to remove the deprecated Command plugins and replace them with the REST API. In addition, the possibilities that are available via the REST API will be massively expanded.
For example, it is planned to give access to functionalities from GoobiScript via REST. This could then, for example, trigger a mass export from scripts or allow the manipulation of metadata in individual processes.
This work should be an impulse to rethink the software architecture as well.
There are many places in the user interface where one can, may, should or would like to access the files of a process. Over the years, various places have been formed here, but they are all rather shortcuts and isolated solutions and a straightforward path is missing. In the coming year, we would like to address this at various levels. We want to collect the places in the user interface where access to the file system is possible and ask ourselves why the functionality is needed at exactly this place. Then we want to design and develop a central way to access the file system and last but not least we want to create a central place in the Java code that will be used for all file operations.
The current version number of Goobi workflow with this release is: 22.12. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Much of the functionality of the intranda harvester has been integrated into the Goobi workflow core. Repositories of different types can now be created and configured. The harvester queries a repository, for example of type OAI-PMH, at a specified frequency and downloads the data records to a specified folder. Repositories can be switched on or off individually.
It is possible to define a script that is to be applied to each downloaded data record. This makes it very easy to modify the downloaded files.
If desired, processes can also be created in Goobi workflow. To do this, a project, a production template and the import format must be selected. The mapping from the rule set is available for the import formats.
This integration allows data records to be harvested from Goobi workflow, for example, prepared via a script and then forwarded directly to the Goobi viewer hotfolder. Another scenario is that, for example, MARC-XML data records are downloaded from an OAI-PMH interface and processes are created in Goobi workflow for further work.
The Java library UGH has been extended so that it can also generate empty elements, as is necessary for the LIDO format. With the following export mapping, for example, an element is created even if there is no value:
The dashboard plugin allows you to scan a barcode into an input box and directly execute a previously selected action. For example, a task can be accepted or accepted and directly completed again.
A special import plugin has been developed for importing the Liechtensteiner Volksblatt.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 23.10.2. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Goobi workflow has now been extended so that thumbnails can now also be used in addition to the directories already used for the master files and derivatives. After completion of the entire implementation, these are then used within the metadata editor as well as within the Image QA plug-in for image display and thumbnail display. If such thumbnails are available, the image display can be done much faster. The directory convention for the thumbnails can be shown as follows for an exemplary process testitem_goobi_123
:
At the same time, it is even easier to clean up the Goobi workflow system. Master files and derivatives can now be deleted from the system to save space. At the same time, however, very strongly compressed files can still be used for the workflow-internal image display. In addition, this also ensures that the thumbnails are not accidentally used for publication to the Goobi viewer and overwrite the high-resolution images there. Such a workflow could be structured in a similar way:
Goobi workflow has been enhanced with an internal message queue, which can be used to process complex tasks. With this new mechanism, it is possible to configure how many jobs can run simultaneously, thus preventing unwanted load peaks on the Goobi server. At the same time, it is also possible to use an external queue. This makes it possible to execute orders independent of Goobi on other computers and to distribute computing load across several systems. Previous developments (commits) have so far only introduced this new queue. Shell calls and all Goobi scripts will have to be converted to this new mechanism in the future.
https://github.com/intranda/goobi/commit/af99eebcc7cb0231a528e0434fda66a3da2797b0 https://github.com/intranda/goobi/commit/bf77ef0656eeec4a4a261aa29a5b8ac98455d3b9 https://github.com/intranda/goobi/commit/c051dd18b22163ec7a9b336bd98d5a059519d064
The security dialog for the execution of GoobiScript was already revised not so long ago. However, what still disturbed the operation was that after entering the sum to be calculated, one still had to click with the mouse on the corresponding button to start the GoobiScript.
This has now been revised so that pressing the Enter key already checks the calculation and the GoobiScript starts.
https://github.com/intranda/goobi/commit/27c2764aa5c904cdfae7b16fecde7c5ec5e1f318
The first important step in the development of data exchange between different Goobi instances has now been taken as part of a more comprehensive import-export implementation. For this purpose, a new GoobiScript exportDatabaseInformation
was developed, which writes a very detailed process log to the process directory for each filtered process.
For example, such a log file looks like the following:
The implementation of this part is the first step in exchanging data between two Goobi instances. With the help of this export file, the workflows can now be transferred to other systems.
https://github.com/intranda/goobi/commit/82ccf81197b0940c6a05b5de42a5422d131dbbc7 https://github.com/intranda/goobi/commit/0d49071fcdc3f7886d9a414adea60eac7a6fab66 https://github.com/intranda/goobi/commit/d46d92445797d7c6d3f853f41f70346b80e461a6 https://github.com/intranda/goobi/commit/a3da5bb9858822e16e9aba28733c7ee74dd39247 https://github.com/intranda/goobi/commit/55c13e61c8d2f9069eec0c0111e1683026fa7e70
The work for exporting the workflow information into an XML file is only the first part for the future Goobi-to-Goobi data exchange. The second essential part for this is still in development. We are working intensively on a user interface that will allow you to import data from another Goobi into your own Goobi. The whole thing is implemented as an administration plug-in. However, the development has not yet been completed to the extent that an insight can already be given here. This will take place next month.
In the past, the log messages from Goobi workflow often contained error messages with a reference to broken pipe
. By changing the redirection after logging in, these error messages could now be reduced.
https://github.com/intranda/goobi/commit/755412a889fdd583ec7318272c2f2dcb593dcf9a
Developments and news about Goobi workflow
The process properties available in Goobi workflow can now also be displayed as a text area. They are configured using the familiar goobi_processProperties.xml
. An example configuration is as follows:
If the GoobiScript for deleting processes was called several times in succession using the same hit set, an error occurred which made it necessary to restart the application. The behaviour has been corrected.
The default configuration of ActiveMQ has been adjusted so that the service only listens on localhost.
An error that occurred when repeating certain variables in script steps has been fixed
A special import plugin was developed for the import of the two databases "Female Doctors in the German Empire and the Weimar Republic" and "Persecuted Doctors of the Berlin Municipal Health Service (1933-1945)" and the conversion into METS/MODS files.
A very powerful step plugin was finalised this month. This allows a wide range of metadata and links to be recorded for each image in a process.
The plugin makes it possible to read a task property and duplicate an existing workflow step multiple times for each line in the property. It also duplicates the properties split into individual properties per line.
The already known plugin for the fully automatic preparation of PDF files has been supplemented by free file naming and updated documentation.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 23.11.1. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
We are always looking for small areas in the user interface in order to specifically improve usability. In August, it was the area of actions within an assumed task, where we tried to create clarity simply by adapting the terminology used.
Here are two screenshots of the area before the update:
There was confusion mainly because the first tab was called "Execute task" and the visualisation suggested a button. However, nothing happened when you clicked on it. The second confusion arose in the area of errors and correction messages, where a "correction requested" and an "error solution reported" were displayed. The expectation here was rather that you would "report an error" and "send a correction". The user interface was made clearer simply by adapting the corresponding translations. Here is the result:
The GoobiScript openNextStep
has been added to set the first locked task of a process from the hit set to open if no other task is open. If it is an automatic task, it is also started automatically.
In addition, the addStep
GoobiScript now has the option of using the number: end
setting to insert the task at the end of the process, even without knowing the exact number. This is determined automatically during the setting.
A new endpoint has been added to the REST API to start open automatic tasks.
In addition, the endpoint for creating new processes has been extended so that metadata and properties can optionally be added at the same time.
In addition to a password, the VLM export now also supports the option of using the SFTP functionality with an SSKH key.
A special plugin for the export of five selected images and metadata as a JSON file was developed for the Federal Monuments Office in Austria.
A special import plugin was developed for the import of the Nuremberg house books and the conversion of an SQL data structure into METS/MODS files.
A step plugin for selecting and defining a sequence of images and saving the result for further processing as a process property was finalised.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 23.08. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Documentation of step details
Personal API Token
Error and correction messages can be sent in an accepted task. New is that now an optional dropdown menu is available where a list of classic error types can be configured.
The configuration is done for both error and correction messages in the central goobi_config.properties
file. Here is an example configuration:
Mail sending from Goobi workflow has been unified and different plugins that can also send emails can now access the same configuration. This eliminates redundancies in the code, minimizes maintenance and makes configuration easier.
For some time, we have been working in Goobi workflow with Sonarcloud for static analysis of code quality. In July last year, we started with a good 4,600 issues noted. With this release we have reached about 1,600 issues. In the last month alone, we were able to process around 1,000 issues. In addition, around 75 unit tests were transferred to the core.
When creating and deleting processes with a lot of steps (let's say more than 50) there were performance problems. These problems could be solved by changing SQL calls and Java code.
The Excel import plugin now allows the specification of a replacewith attribute for the generation of task titles - analog to the configuration in goobi_projects.xml
- in order to replace spaces with underscores, for example.
The PDF generation step plugin now allows specifying and using the PDF generation variants recently introduced in ContentServer. This allows, for example, valid PDF-A files to be generated as a step within a production template and stored in a specified location.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
A few words about the failing analysis:
In SonarCloud, quality requirements, called quality gates, can be defined. The quality gates are applied once to the entire source code and once to the source code that has been modified in the last 30 days.
The now failing quality gate in Goobi workflow refers to the adapted source code in the last 30 days. There, a test coverage of at least 25% is required and the duplications should be below 10%. Since we have touched a lot of source code with this release, we do not meet these requirements - based on the source code of the last 30 days.
However, the quality gate for the entire source code is met.
The current version number of Goobi workflow with this release is: 23.05.1. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
The Goobi workflow creation screen has always prevented a process with the same name from being created again. You would then receive a short error message saying that the process already exists. This has been enhanced so that you can now also view the details of the existing process.
The GoobiScript calls metadataAdd
and metadataReplace can now also create or manipulate authority data values. This makes it possible, for example, to subsequently adjust the GND ID for persons in bulk.
At the same time, the GoobiScript metadataReplaceAdvanced
was introduced. This call also allows you to work with regular expressions.
September also brought changes to the REST interface, two new endpoints were added. The first allows a search and returns a list of process IDs:
The second allows you to complete tasks with a defined title:
An import plugin has been developed to create an EAD archive structure with metadata from an Excel file.
There was no dedicated Goobi workflow release in September.
Developments and news about Goobi workflow
GoobiScript templates
Documentation of step details
In the settings of one's own user account, there is a new tab in which an API token can be generated and equipped with the corresponding rights.
Only super administrators or user accounts that belong to a group to which the corresponding right has been assigned have the right to create a token.
This token can then be used with a basic auth to query the previously enabled commands.
When creating a task, the mask can be configured via the file goobi_projects.xml
. Multiselect fields could also be defined with the attribute multiselect="true"
. If several values were then selected, they ended up one after the other in the configured metadatum or the defined property.
As of this release, a separate metadatum or property is written for each value.
A new step plugin has been developed that allows to convert the OCR text of all images of a process into a metadatum.
ALTO editing in the metadata editor can now also save files in S3.
The plugin for automatic PDF extraction has received minor improvements, for example in the case of missing spaces in the full text.
There was no dedicated Goobi workflow release in June.
Developments and news about Goobi workflow
Documentation of step details
Improved PDF-A generation
We have worked several hundred hours in the background on it and in the result only little changes at the surface first of all... In the substructure, however, a lot: Where source code was copied and modified over time, there is now a unified system again. New structures have been built, redundancies removed, code and markup for the same things unified and thus the whole structure simplified.
Probably the first thing you'll notice is that everything is a bit more airy and here and there some things might even look a bit strange now. Unusual in any case. But the basic structure and also the design remains the same.
Based on this work, we can now start to work on the usability: How do we want to arrange and name buttons and where? Where do we speak of the terminology in the plural and where singular? Which boxes are displayed where, what is the order of information, and how do we highlight relevant things, hide irrelevant or incidental ones, or reduce the focus? What is a consistent and reliable path to a goal and where do we want to deliberately create shortcuts? With this basis, we can change many things in one central place and it automatically affects all areas. Before we would have had to look at very very many places individually.
Please report things that now look funny or are incomprehensible.
In April, as part of a project, we began to revisit the REST API and develop what we believe to be essential functionality, refactoring and consolidating existing code as well. Specifically, we considered tasks, steps, properties and the journal and implemented the following functionalities:
Create tasks, read information, update or delete tasks.
Read out, update, add, delete or execute steps for an operation
Read journal and add, update or delete records
Read out, add, edit and delete properties
The logic uses - where possible - existing code from GoobiScript. The terminology is also chosen to be identical, so there should be recognition effects when working here. The new code has been given meaningful test coverage and the REST commands are also all listed and described in the Swagger documentation.
The new REST endpoints allow integration of functionality with external systems via a standardized interface in the Goobi workflow core.
Here are four example calls for the possibilities available for the journal:
For some time now, the plugins installed in an instance can be viewed via the interface. On the page you can also see if the plugin has been tested against the installed Goobi workflow version number.
With the April release, we started to not only test the plugins for compatibility, but also tag them with an identical version number. This way it is now also possible to immediately identify in the plugin repository the commits that ensure compatibility to a specific core version.
We still need to observe the solution we have found now and possibly also readjust it, but we have already come a big step closer to our goal: "To have plugin versions analogous to the Goobi workflow Core".
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 23.04.3. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Porting of user interface to new framework
Documentation of step details
Improved PDF-A generation
REST API
For some time now, Goobi workflow has been able to trigger certain tasks periodically. There are internal tasks that are executed once a day, but also plugins like DataPoller or delay plugins. This functionality works stably and reliably, but had two limitations that we addressed with this release.
First, everything was done in secret. There was no overview of which regular tasks existed, when they ran and if there was an error or not. For this overview, there is now a new page in the "Administration" section that lists the information mentioned. Also an individual execution or pausing of tasks is possible there.
The second part was the configuration options. Either things were not configurable at all or they were given in seconds since midnight. To start something at 15:30 then the value 55800
had to be specified. Not exactly intuitive. Now the cron syntax is used, which is much more intuitive to read and also more powerful in configuration. The syntax for 15:30 every day is now 0 30 15 * * ?
For some time now, it has been possible to configure additional columns for the table on the "Tasks" and "My tasks" page in the settings of a user account. From now on these are also sortable if they are in the database. This is for example the case for variables like {db_meta.XYZ}
, {process.XYZ}
, {product.XYZ
} or {template.XYZ}
. Other variables like {origpath}
or even {meta.XYZ}
are not sortable.
The usability issue is progressing in small steps. This month we have taken a look at the project configuration and there especially at the tab "METS Parameters" which has been renamed to "Content settings". The names of the lines as well as the inline help have been massively revised and provided with useful examples.
In the queues, the error table is now automatically and regularly emptied.
In the project settings, a custom URL for the DFG Viewer METS file can be stored in the "Content settings" area.
Developments and news about Goobi workflow
Porting of user interface to new framework
Periodic tasks
Documentation of step details
The ALTO Editor for OCR correction, which can be opened in the Metadata Editor if required, now also supports right-to-left languages. Switching is done automatically based on the selected setting in the Metadata Editor itself.
Minor usability changes are gradually being incorporated into the interface. In this digest we would like to go into a tiny sub-area and show what this means in practice. The starting point in this case is the metadata editor and the possibility to add another metadata. So far this looked like this:
We have looked at this small sub-area and noted the following points:
The heading "Create new metadata" suggests by the plural that one can "create" here several at the same time. But this is not possible because in the mask only one can be "created" at a time.
The word "create" is linked by the terminology rather with "create process". The word "add" is more appropriate here, since a new metadatum is to be added to an existing process.
Also, the word "new" in the context is actually too much. "Add metadata" is also clear and unambiguous. At this point, the ruleset is not edited.
"Type" is more likely to be associated with something like "Text, MultiSelect, DropDown, Textarea", but not "Additional title". A metadata of type "Additional title" is weird. Better is simply "Name".
"Save the changes" says that you have changed something. But something is "created" or isn't "Add" the correct terminology here?
The result of the considerations looks as follows:
Of course, there is much more you can ask yourself at this point:
Why is the box collapsible and expandable?
From a UX perspective, is it right to have the cancel and add buttons equally weighted visually?
Why isn't this simply opened in a modal as an overlay?
...
But these questions are more complex to answer and we are taking small steps. This example is just to show how we make things better in various places and little by little.
The step plugin to edit metadata directly from the accepted task can now hide empty fields. This was not possible before and led to very long lists in use cases where the plugin was used to quickly check metadata.
The current version number of Goobi workflow with this release is: 23.01. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
We are planning a major change to the Maven architecture of Goobi workflow and the plugins in the coming months. This internal work may temporarily affect the way developers and system administrators work.
In the coming months, intensive work will be carried out on the ‘Archives’ and ‘Vocabularies’ areas.
The former plugin for the Goobi workflow configuration editor has been integrated into the core and is available from this release without additional installation.
The interface of Goobi workflow is significantly styled using the classic web technologies CSS and Javascript. However, development takes place in SASS or LESS files, for example, which are then compiled into CSS. There are also various individual files in JavaScript, which are then combined into one file for the application. In the past, compiling and summarising took place on the developer's PC, who then checked the finished files into the repository. From the February release onwards, these steps will be carried out automatically in the CI environment. This simplifies the development process and reduces the potential for merge conflicts.
The comparator for file names has been fundamentally revised so that ascending and descending sorting of files in the core and in plugins is easier and more error-free.
The VLM export plugin can now use different configuration blocks based on metadata and conditions.
The step plugin for renaming files has been massively extended and can now contain several <condition />
and <replace />
arguments in the new configuration section <namepart />
.
There was a bugfix in the step plugin for editing metadata to save information about the representative correctly.
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the project page.
The current version number of Goobi workflow with this release is: 24.02.2. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Porting of user interface to new framework
Periodic tasks
Documentation of step details
A bottleneck in the performance of SQL queries with "Like" queries could be identified and fixed if. This was the case, for example, when queries for step titles were executed. Loading times could be reduced from 155 seconds to 3.2 seconds in some cases.
A significant speed increase was also achieved in the area of automatic tasks by changing the SQL queries.
The result is a faster responding user interface in certain situations.
Users can now configure individual search entries. For this purpose, a new input area for individual search settings is available in the user settings in the "General" area.
Each line is structured according to the name=search filter
principle where the placeholder {}
stands for the search term. An example configuration could be as follows:
If configured, a drop-down menu with the configured values appears in front of the search slot above the table on the "Operations" page.
The file renaming plugin used to rename automatically in all task folders. Now it can also work only in certain folders. The use case is that one has different upload steps, the files are stored in each case in a temporary folder, then the plugin names the files individually and these are then moved with a script into the _master folder. This way you can ensure an individual and yet uniform naming of the files.
The plugin for changing the workflow based on task properties can now also influence the priority for individual or all steps of a task. The background to this enhancement is that within a workflow the decision is made whether the task has to be put on the fast lane or not. If overtaking lane, then all steps in the task get a higher priority and appear accordingly higher up in the tasks.
The current version number of Goobi workflow with this release is: 23.02. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Within the metadata editor, we noticed that different browsers reacted differently when users clicked on the save button. Specifically, the Chrome and Safari web browsers did not perform any function when the Save button was clicked, while Firefox, for example, worked correctly.
Incidentally, the button with the title 'Save and return' was not affected by this problem..
After some back and forth and a lot of research into the causes, we were finally able to solve the problem and provide a fix with the release.
For 8 years now, Goobi workflow has offered the possibility of tracking various information and communications via the process log. It has also been possible for some time to upload files (e.g. for restoration documents). This was expanded about 1.5 years ago to include the option of saving damage documents when creating processes.
In other words: the process log is simply practical. So practical that we wanted to have it in other places as well. To do this, we had to foolishly rename it so that it would no longer be used only for processes.
The result is the journal. Functionally, it has remained the same as for the processes. Now, however, it is also available for the institutions and, at least in one special case (delivery of deposit copies), also for users.
We can think of other places in Goobi workflow where the journal could be helpful (e.g. for projects). Perhaps there will be an opportunity to do this soon, because someone else would find it just as practical. In that case, we will be able to expand the journal and report back here.
Especially in the case of very extensive works, there were always enormous delays in the loading speed when using S3 as a storage system. The reason for this is that an S3 system has no folder hierarchy and all files instead have enormously long file names. This looks like this, for example:
This deviating structure meant that when determining the master directory, for example, all files always had to be run through in order to check whether the directory name being searched for was represented. Especially with very extensive works, performance suffered greatly.
We have now changed this so that when searching for folders in the desired hierarchy level, everything after the next slash ( /
) is no longer taken into account and so when searching within the images folder, significantly fewer file names to be checked are listed.
In addition, we have now always limited the file search to the actually relevant folder, so that even when searching for the master images, the data of all folders of a process are no longer queried.
Another big improvement in performance resulted from the fact that in the IIIF API we now no longer check per image whether a directory with the name 'thumbs' exists, but cache the result for a while. This has also allowed us to significantly reduce the number of requests to the system once again.
During the detailed display of workflow information of individual work steps, it occasionally happened that empty table columns were displayed.
We have checked this once and revised it. This means that this small display error no longer occurs.
We noticed that the metadata editor did not display a user-friendly message if there was not enough storage available on the Goobi server to save the metadata while editing the metadata. Ideally, of course, this should not happen at all in everyday life. However, if it does happen, Goobi now notices the lack of storage space better and displays an easily understandable message for the user.
If it is necessary for Goobi itself to communicate with other services via a proxy, this was already possible quite easily in the past. However, a new requirement has arisen due to the increasing use of archive management. This requires communication with another local database, which in turn does not require communication via a proxy.
With this version, therefore, a new configuration option has been added, which from now on allows Goobi not to use the proxy for communication with its own server (localhost). This is configured with the new switch as follows:
If Goobi is used to use the LIDO format instead of METS, especially in the case of museum objects, from this version onwards it is possible to write empty elements within the generated XML files. For this purpose, a new configuration option has been created for the rule sets, internally specifying the following there:
Illustrated by a concrete example, this looks like this:
The result within the generated LIDO would then look like this:
The configuration made here has the following influence:
If the metadatum in question exists, it is exported normally. If, on the other hand, it does not exist, it is checked whether it is permitted in the current structure element. If this is the case, 'WriteXPath' is also executed. Such a configuration can also be specified for a group or for a metadatum in a group.
If such a configuration is not made, this line is omitted in the generated LIDO:
More on the configuration options for the metadata exports can be found in the following documentation:
Again this month, a lot of energy has gone into the completion of a new plugin for the granular collection of personal data. In addition to various minor and major bug fixes, the user interface, among other things, was once again thoroughly checked and adapted.
We expect to complete the plugin in October and to be able to document it thoroughly then. We will keep you up to date.
The Catalogue Poller is used to automatically update the metadata within the METS files periodically for numerous processes. In this way, catalogue changes can be automatically adopted and are subsequently also taken into account for the presentation of the digital copies. This plugin has now been fundamentally revised and equipped with further functions. In addition to some changes to the user interface, the main addition here was the new possibility that the Catalogue Poller can now also carry out test runs, which make it possible to see what changes would be made to the data without actually changing it. The result of such a test run can be downloaded as an Excel file.
Also new is the possibility that within the configuration of the metadata to be taken into account, it is no longer possible to name only those fields that are not to be changed (blacklist). Instead, it is now also possible to name only those fields that are to be changed (whitelist). Here is an excerpt from the configuration:
The documentation of the plugin can be found in an updated form at the following address:
The plugin can be downloaded as usual from GitHub here:
For some time now, there has been a plugin that can automatically generate PDFs during workflow execution. Until now, however, its configurability was limited. This has improved with the new version, so that an individual configuration can be defined for each project and title of a work step. This can look like this, for example:
In this way, the plugin can also be operated several times in a Goobi in different projects and workflows and with different settings in each case.
In the context of our developments for electronic deposit copies, there was a requirement that it should be possible to extract data from selected processes in Goobi workflow from external systems. The following functionality is available for this purpose:
Within the workflow, there is first a step for MARC export, which exports the metadata as marcxml. The following plugin is used for this:
The exported data then ends up in a directory that is monitored by the new REST plugin. This is the following plugin:
Within this REST plugin, various commands are available to enable communication between Goobi workflow and a library catalogue.
The following commands are available:
This command lists all records that are currently available.
Calling the REST API:
Response of the REST API:
This command can be used to query a specific data set.
Calling the REST API:
The REST API then responds with the queried MARC data set.
This call confirms the successful transfer of the data set and reports the catalogue ID (aDIS ID). The step is then closed.
Calling the REST API:
This command is used to report a data set to Goobi whose data transfer was not successful. The error is reported and the work step is set to error status.
Calling the REST API:
With the last two calls, a workflow step is closed or set to error status. The MARC data set is then removed from the export directory so that it is not listed again in the next search.
We noticed that the update instructions in July 2020 were still missing a note for the necessary adjustments to the configuration of the XMP header plugin. We have now added these so that everything should be up to date.
As before, the update instructions can be found at the following address:
The current version number of Goobi workflow with this release is: 22.09. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
In Goobi workflow, the rule set can be used to control which metadata may occur, for example, how often, where they are permitted and what content is possible in them. In this way, a quality requirement for the metadata to be captured can be well controlled and adhered to. In order for the user to comply well with these requirements, the metadata editor displays validation messages that indicate problems. In the past, however, these messages were only ever displayed globally, not directly on the metadata in question itself and also not on the associated structural element. In other words: As a user, you were a bit perplexed as to which field was not valid and where exactly. You had to do some searching first.
From now on, there are some major changes at this point. Validation messages appear directly at the field in red colour and point out the problems directly with a helpful message.
And also in the tree display of the structural elements in the left-hand pane, the validation problems are now highlighted and now allow the user to find very quickly the metadatum in question for which there is a message.
If you hold the mouse pointer over a structural element with errors, you will immediately see the corresponding message in a pop-up.
By the way, we also took the opportunity to introduce a new key combination for performing the validation. It is: CTRL
+ SHIFT
+ V
.
After minor optical adjustments the search slot within the task list of Goobi workflow had become too small, it was a bit too cumbersome to use lately. It was simply no longer possible to keep track of which search terms had already been entered when the search query became a little longer.
As of this month, this circumstance is a thing of the past. The search slot is now basically much longer on regular displays.
And even on mobile devices, the usability is such that you can work reasonably with the search:
Goobi workflow has had a vocabulary management system for some time, which can be used, among other things, to make the metadata editor as convenient as possible by means of selection fields with controlled lists. It is also possible that the values are not only available in a selection field but can also be selected from a hit list after using a search mask.
In such a case, not only the selected value is taken over for the subsequent display of the digitised material in the Goobi viewer. Instead, a URL for linking to the corresponding vocabulary record is also entered.
Unfortunately, a small error had crept in here, so that these URLs may not have been correct. We have now corrected this behaviour so that the URLs are now correct. However, please check whether you have already used this functionality. In this case, the URLs you have already entered should be corrected.
We had already announced that we would be making some major changes in the background with regard to accessibility and usability. In the case of the administration screen for users, we are now slowly putting these changes into operation. As announced, this will be accompanied by minor visual changes. This should soon have an impact on other areas as well.
This is how it already looks:
For some time there have been various GoobiScripts for changing data within metadata. Unfortunately, until now this was not easily possible for metadata groups. There have been some changes this month so that the existing GoobiScripts can also be used for metadata groups if the parameters are set correctly.
Since the changes are quite extensive, we have also adapted and extended the documentation. As before, it can be found at the following address:
Within the journal (formerly process log
), the individual activities of a workflow can usually be easily traced. Among other things, the calls of scripts were already logged there in the past in order to be able to trace them better in the event of problems. What was missing, however, was that the variables used were also displayed in their replaced form within the script calls. This has now been adapted so that after each call of a script within the journal, both the script call in its original form and in its resolved form are listed.
In the case of a simple script like this one:
... this is what the call within the journal now looks like:
By the way, we also took the opportunity to adjust the height of the box so that it makes better use of the available space and you can see more information at once without having to scroll.
Goobi workflow has a fairly granular rights system. It is so flexible that even plugins can define their own rights that a user must have in order to work with the plugin.
To make life a little easier for the administrators (including ourselves), we have now introduced that all users who have the status of 'super administrator' automatically have all rights in Goobi, including the individual rights that plug-ins bring with them.
As part of our developments in the delivery of electronic deposit copies, we needed a flexible way for files uploaded by users to be validated and checked for compliance with requirements. Among other things, it should be possible to use any external tools for validation and to ensure compliance with defined levels.
The result of the development is an extremely flexible validation plugin that can be configured very granularly. We have published extensive documentation for the plugin here, including several useful configuration examples:
And as usual, the source code of the plugin and a compiled version can be found on GitHub:
This should only affect a few users, but for those it is important:
The still quite new plugin for URN registration could not be used until now if the Goobi server is only allowed to access the internet via a proxy. Here we have now made an adjustment that from now on also allows operation behind a proxy.
We have updated the documentation for this change:
The plugin can be found as usual here on GitHub:
After a long development on the plugin for capturing linked entities, we have now also completed the related plugins and published them on GitHub. On the one hand, this is a special dashboard plugin:
On the other hand, this workflow plugin is also required:
The installation and configuration of these plugins are now also fully and very granularly documented. They are available as usual on our documentation platform:
The current version number of Goobi workflow with this release is: 22.10. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Together with a partner we developed a process chain that allows to import records exported from an easydb fully automatically into Goobi workflow, to process them and to export them into a Goobi viewer. For this process chain three plugins were used and extended to meet the requirements of the project.
The generic XML OPAC plugin can now not only query a remote API, but also read XML files from the file system.
The DataPoller (formerly CataloguePoller) has been extended as part of the project to not only work over a filter set of tasks, but also iterate over the files in a folder. Also new is the functionality for individual work orders to be processed through the internal ticket queue.
The Fetch-Images-From-Metadata step plugin has undergone minor adjustments to, for example, find files without file extensions, deal with duplicate file names, or skip error messages for missing images.
The process chain also works periodically, creating new operations or updating existing ones. Once imported, records proceed through the workflow steps as usual.
The core of Goobi workflow has been extended to offer plugins within the metadata editor. These plugins are integrated in the blue header at the top and provide their functionality.
The decisive factor for the development was the requirement to be able to change the publication type within the metadata editor. For this, template processes should be created and certain, marked metadata should be taken over during the change.
It happens again and again that certain metadata are to be formed automatically from other values. An example could be the main title of a letter, which should always be generated as follows: "Letter from [sender] to [recipient] at [place], [date]
".
To provide this functionality in the metadata editor the configuration file goobi_metadataDisplayRules.xml
was extended by the possibility to generate values from other metadata values for certain metadata under configurable conditions.
A configuration for the above example could look like this:
Within the metadata editor there is now the possibility to generate a PDF of all images at any time. For this purpose there is a new PDF button in the left column with the structure tree
There is a new step plugin to rename a task within a workflow. For this purpose, the variables available in Goobi workflow can be used. Additionally underscores and minus are allowed as characters. Empty variables are skipped and spaces are removed.
The plugin for exporting to the DDB newspaper portal has been adapted for better display of data in the DFG Viewer.
The documentation of goobi_config.properties has been extensively revised, documented and is now available in chapter 7.2 of the documentation:
The current version number of Goobi workflow with this release is: 22.11. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
We already announced it. Some users may have already noticed that the layout will change minimally (at first): We are gradually changing the layout of Goobi workflow to Bootstrap 5. The first pages have already been moved.
But who would have thought it: it is more elaborate than expected. So it will continue to accompany us as a theme for a bit.
We have already made some changes to the login and logout area in recent months, including the display of active users and logging. However, we noticed that after logging out, the user's session was not completely cleaned up immediately. We have adjusted a few things here and then put them through their paces. We are now satisfied with this, the storage space for the sessions is now somewhat smaller and, from our point of view, it can stay that way.
On some Goobi systems, especially those with a large database, it was noticeable that the listing of production templates was significantly slower than the listing of tasks. We took a closer look at this this month and were able to determine that the more extensive rights check of the project memberships had a significant influence here. Fortunately, this could be remedied quite well, so that now no performance losses should be noticeable in the production templates.
Unfortunately, we noticed a small bug concerning the checking of the password length of users. The length of the password was incorrectly checked - and noted as too short - even if data of an existing user was to be changed without a field for password entry being displayed in the user interface at all. We have corrected the error in this release.
To ensure the quality of software, software developers can implement automatic tests. Such tests can then automatically check individual functionalities of the overall software and are run at least before a release is published.
Goobi workflow has had several hundred such tests for many years. Nevertheless, it is our goal to cover as much of the source code as possible with tests in order to ensure code quality on the one hand, and on the other hand, to always be sure that the existing functionality is still guaranteed in the case of new developments and adaptations.
With this month's release, about 230 new tests have been added. The remarkable thing here, however, is not just the number of tests alone. The newly added tests relate to one of the most complex areas of Goobi workflow, in that we have now also achieved significantly better test coverage in the metadata editor.
In addition to increasing test coverage by means of automated tests, we have been working intensively on the code quality of Goobi workflow. To this end, we have now registered Goobi workflow within Sonarcloud, so that we automatically receive code analysis results there and can make successive improvements to the software's source code.
There you can see, for example, how we achieved a level A rating for all important areas of quality analysis this month:
Here you can also see a comparison between before and after:
If you want to take a detailed look at the quality of the Goobi workflow source code, you can take a look here:
Not so long ago we reported here about a new plugin for registering URNs that uses the REST API of the German National Library. This plugin has now already gone into regular operation with the first Goobi users. In this context, we have then added an additional functionality: the construction of URNs can now use the timestamp of the registration if desired.
Previous use with a counter:
New possibility with the use of a timestamp:
We have also taken the opportunity to make the log messages in the operation log a little clearer again, so that they all receive a prefix and are thus clearly distinguishable from other log messages, as in this example:
And of course we have also expanded the documentary and added the new possibilities:
Here is also the link to the source code and the compiled version of the plugin on GitHub:
We have found a malfunction in the popular Image-QA plugin. There, it is possible to delete images, provided that this has been activated. Apparently an error had crept in here, which caused that when selecting several images for deletion, not always the selected images were deleted. This has now been corrected.
More information about the plugin can be found here in the documentation:
And if you don't use the plugin yet, you should definitely try it. You can get it here:
With the Export-Package plug-in, a plug-in is available that allows almost all conceivable exports of data to third-party systems. It is possible to control exactly which data should be included in the export, where the data should be delivered and much more. Even a conversion of the METS files into third formats can be done by applying an xslt transformation. What was not yet possible, however, was that the exported result should not only be exported as a directory but also zipped afterwards. We have only developed this function and added it to the documentation accordingly.
Here you can find the detailed documentation of the plug-in:
And as usual, the source code of the plugin is here, together with the compiled version of the plugin:
We have implmeented and published a new plugin for the mass import of Excel files. The special feature here is that several structural elements are generated from each Excel file that is imported, one element per line. In addition, an existing EAD tree can be enriched with further nodes, so that an extensive inventory is created.
The functionality of the plugin can be viewed in detail here in the documentation:
And here is the source code of the plugin:
The current version number of Goobi workflow with this release is: 22.08. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
The plugin has been around for a long time. But somehow we haven't found the time to document the plugin yet, and so one could almost think that Goobi has no connection to Kalliope. But this is not true, because this documentation proves that such a plugin already exists:
If you look closely at the source code published on GitHub, you can even see that the plugin has been around since November 2014. Who would have thought that?
We already implemented a plugin for the connection to Ariadne some time ago. This has now been extended to allow more flexible control of the publication type. We also took the opportunity to document the plugin in detail and publish it on GitHub.
Here you can find the detailed documentation for the plugin:
And here we have published the plugin on GitHub:
About 1.5 years ago we already published a plugin that allowed the registration of DOIs. However, we were not entirely happy with the implementation. Especially if you take a close look at what can be reported in a separate metadata schema when registering persistent identifiers with DataCite, you realise that the previous solution had narrow limits there. For this reason, we have now implemented a second DOI plug-in that is much more flexible and could generate almost all conceivable data formats on the basis of XSLT.
Here we have documented the plugin in detail:
The source code for the plugin has been published here on GitHub:
Goobi worklow has had inline help for some time. This allows help texts to be displayed, especially for various forms, to support the input. Unfortunately, the problem was that the page was always reloaded when this integrated help was switched, so that values already entered or changed in the form were reset if they had not yet been saved.
There has now been a change in how the help display is activated. From now on, it loads solely via JavaScript and can thus be displayed without reloading the page. This avoids the problem of unsaved content being accidentally reset.
Some years ago, we developed an export plugin that allows a very flexible export and where, among other things, it was possible to control which image directories should all be taken into account for the export. We have now massively extended this plugin and documented it in an exemplary manner. It now also allows, among other things, that within an export call, depending on an existing metadata, an export can take place in several Goobi viewers and, for example, different image directories can be used and different handling of OCR data should take place.
More information can be found here in the new documentation:
And here we have published the new plugin on GitHub:
Basically, the whole month was strongly focused on documentation. In addition to the newly created documentation for new and existing plugins, a lot of new things have been added, especially in the area of configuration files.
The following Goobi workflow configuration files have been newly documented or massively revised in their existing documentation:
This configuration file is decisive for how the input fields should behave within the metadata editor:
This configuration file defines which areas of the REST API external services may access and how they must authenticate themselves:
This configuration file specifies the catalogues from which Goobi workflow should be able to import data:
This configuration file controls how to deal with umlauts returned by the catalogue query:
This extensive configuration file allows you to influence exactly how the Goobi creation mask should be structured.:
There were some special exceptions where the execution of multiple GoobiScripts only executed the last of the commands sent at the same time. Fortunately, this has now been found and fixed, so that even such similar commands can now be passed to Goobi and executed correctly..
For many years, Goobi workflow has offered the possibility for users to set an individual session timeout. Only very few users made use of this option and only because the default value was set to 30 minutes, which was too short. The new default value is now 4 hours.
Together with the Zentral- und Landesbibliothek Berlin (ZLB) we are currently developing a completely new functionality for the processing and provision of e-mandatory publications. Overall, this is quite an athletic undertaking with, in part, enormous complexity. For this reason, the development of the functionality will take a few more weeks. However, in order not to keep the world in suspense forever, we would like to provide a small insight into the current status quo of the developments by showing various screenshots of the (still) only German-language interface:
On a specially adapted interface in the corporate design, the deliverers can log in or register in Goobi workflow.
Delivering institutions create their own user accounts in an interface that is as intuitive to use as possible.
After the ZLB has activated newly registered users for submission, they can add further data on the submitting institution.
After complete registration of the delivering institution, various actions are possible, including the delivery of independent works.
Within the user interface, it is possible at any time to have help texts displayed for input via an embedded help function..
Within the regular Goobi workkflow interface, a special administration plug-in ensures that the ZLB has an overview of all delivering institutions that are available as clients in Goobi.
The associated users of a delivering institution can also be managed via the administrative areas.
Among other things, the privacy policy, which the submitters accept during registration, can also be edited in this area.
All in all, a lot has already been done here. However, the work is still in full swing and will take some time. Some functions and interfaces will probably change significantly in the coming weeks. But as a first glimpse, the screenshots here already show well what will be available in the coming weeks and months as additional functionality for all interested parties as an open source solution.
The current version number of Goobi workflow with this release is: 22.06. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
GoobiScript changes
Documentation of step details
It often happens that several GoobiScript calls have to be made in succession. Often the calls are repeated because, for example, in a certain project under certain conditions it is necessary to insert a certain step again and again.
There is now a new mechanism to make these tasks more convenient. In the "Administration" section, the new GoobiScript Templates section has been introduced. There, multiple calls can be elegantly concatenated and saved as a template. Each template has a mandatory name and an optional description.
In the list of GoobiScript templates, the self-defined templates are displayed as badges with their own colour. The description is displayed when the mouse is moved over the badge. The same possibilities for dedicated rights management apply to the templates as to the built-in GoobiScript calls.
When creating a process, the process properties can now also be managed via the central configuration file goobi_processProperties.xml
. For this purpose, the new XML element was added to the configuration file. The attributes are access=""
and template=""
. The values of the access
attribute are analogous to the other options already available in the file. The template
attribute controls which production template the setting applies to. The XML element is repeatable to be able to configure different production templates. It is possible to define a *
in the template
attribute so that the setting applies to all production templates.
With this change, it is possible for the first time to visually separate the metadata that is imported from the catalogue from the properties that are to be collected when creating an operation and are therefore completely different in terms of content. Until now, both were displayed mixed together in the upper area with the heading "Import metadata".
Here is an example of a configuration and a screenshot of how it had to be done and looked in goobi_projects.xml
:
The same configuration can now be mapped via goobi_processProperties.xml
. A separate box is then displayed for this purpose in which the settings can be made. This makes it possible to realise a more clearly structured and thus clearer interface.
The newspaper export for the DDB now writes extended information to meet DFG viewer display requirements.
The current version number of Goobi workflow with this release is: 23.07.2. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Within the plugin for the quality control of files, it has already been possible for some time that specific individual files can also be changed, provided that this has been activated in the configuration. For example, images can be permanently rotated or even deleted. A new feature is that images can now also be mirrored. This is possible both horizontally and vertically.
To use this functionality, the configuration must be adapted according to the specifications. As before, the details can be found in the plugin documentation:
If PDF files are to be used in the workflow, routines are available that automatically extract the contents of the PDF files and convert them to images. In the past, however, there was occasionally a display of irritating messages in the case of errors that occurred. This has been changed accordingly and is now much more meaningful and helpful for users.
The sorting of the display of users within Goobi workflow was not quite intuitive until now. This has now been fixed and the sorting is more intuitive without the upper and lower case of names having unexpected side effects.
Once again we have a new GoobiScript. This time we needed a functionality that allows us to completely duplicate existing processes in Goobi workflow together with their associated data. The title of the process to be used can be freely defined using variables. It is also possible to specify whether only the data from the database or also all internal directories are to be duplicated.
This is what the new GoobiScript looks like:
And as before, the full documentation for GoobiScript can be found at this address:
Until now, it was the case that the call of a plugin from the transaction details was not included in the transaction log. For better traceability, however, this would be practical from time to time. For this reason, we have now changed the logic of the execution so that such executions are also included in the operation log.
For the configuration of rulesets within the administrative interface of Goobi workflow, the file names of the rulesets in the central ruleset directory /opt/digiverso/goobi/rulesets/
had to be specified until now. There has now been a small change here. Instead of having to enter the file name manually, it can now be selected from a drop-down list. This avoids possible typing errors when specifying rulesets for the future.
When you have created and saved a new process within Goobi workflow, it is possible to go directly to the newly created process from there by clicking on the link Open the created process
. The breadcrumb displayed there for navigating to the complete list of all processes used to occasionally lead to an empty hit list. This has now been corrected so that the navigation works correctly and lists all processes at this point.
Goobi workflow allows individual plugins to define their own rights, which a user must have in order to run the plugin. Accordingly, it is possible to configure such flexible rights in the user administration of Goobi worklow. However, until recently it was also possible to add empty rights there, i.e. without specifying a right. This has now been corrected so that such an error entry is no longer possible.
In the past, when working with several rule sets, it was often necessary to check again in the area Administration
- Rule sets
which rule set file it actually was (e.g. for the rule set Standard
). In order to make this search easier, we have now implemented a small functionality that displays this file name directly within the transaction details when you hold the mouse pointer over the rule set name.
By the way, we have already implemented the same functionality in various other areas in the past. For example, in the properties:
And there is also this hidden function in the metadata:
The old backup system in Goobi workflow used to work only with a counter at the end of the file for the names of the backups. The file with the highest counter was the oldest backup:
This system had problems, especially in hierarchical file systems, because rarely used files are stored in a slower storage area. However, since the older backups were always renamed with the previous backup system, this sometimes resulted in very long storage times. Therefore, we have revised the mechanism of naming these backup files and now use a time stamp to name the backup files. The naming scheme is as follows:
Here, ii
is the milliseconds in the second. An example of a new backup file looks like this:
With the old backup solution in Goobi workflow, files not managed by Goobi were included in the rotation in the past (for example meta.xml.MYBACKUP
). This resulted in manually created backups being rotated away or the manually created file not being saved to disk. As of this release, Goobi only considers files meta.xml.1
, meta.xml.2
, meta.xml.3
etc. and backups created according to the new scheme for rotation. Manually created backups, on the other hand, remain unchanged.
The fact that metadata can now also be recorded for page areas in the metadata editor has been possible for about 1-2 years. What became apparent during daily use, however, was that better usability was still needed to add several page areas to a structural element or to adjust the size of such page areas or even to delete them. We have now implemented some improvements here.
Für ein Strukturelement können im Bereich zum Ändern von Strukturelementen
nun weitere Seitenbereiche ergänzt werden:
Und hier lassen sich bereits angelegte Seitenbereiche auch wieder einfach entfernen.
Until now, the Excel Import plugin ignored missing image folders and continued with the next process. Our concern, however, was that in such a case of use, there should be transparent communication with the user so that he or she would also be better informed of the missing images. With the extension of the plugin, this has now become possible. The following excerpt from the configuration illustrates how such situations can be handled from now on:
After an update, Goobi workflow checks whether the database schema is still up-to-date. If it is not up to date, an update is usually performed automatically, bringing the version of the schema to the current version. In some cases, however, something went wrong with this update and the version number in the database was increased anyway. This resulted in an outdated schema with the current version number saved. However, the error handling has now been improved so that the current version is no longer written to the database after an error. This prevents possible incompatibilities in the future.
There was a misbehaviour in the GoobiScript executeStepAndUpdateStatus
that prevented steps where a plugin is configured from closing correctly. This behaviour has now been corrected so that steps are now reliably closed when called by this GoobiScript.
Previously, when clicking on the Get number of metadata and images
link below the table of processes in Goobi workflow, the table with the results for each process was displayed first. However, as most users are more interested in the table with the summary, we decided to swap the order of the tables so that the summary now appears first without having to scroll through all the processes first.
The current version number of Goobi workflow with this release is: 22.02. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
We have developed a new plugin that automates the generation of dockets during the workflow. Up to now, it was already possible to download routing slips immediately after creating tasks or with a plugin within tasks. What is new is that routing slips can be created as PDF or image files with a new plugin and that they can be saved automatically in the desired resolution within a configurable directory.
More details about the plugin can be found in the detailed documentation here:
The source code of the plugin can be found published on GitHub:
It was not ensured in all cases that the image area capture in the metadata editor was only displayed if the associated rule sets also allowed this. We tested this again intensively and also made changes to the logic in order to avoid errors here. If we have thought of all areas, then no more difficulties should be expected here for the creation of new image areas, the addition of further image areas and the deletion of image areas for structural elements.
To ensure that we nevertheless take this well into account for updates, the update instructions have also been updated in this regard. There is a corresponding reference to the adjustments to be made within the rule sets:
We had not expected the two still quite new plugins for editing configuration files and rulesets to become so popular so quickly. In the course of their rapid spread, we soon realised that we still had to optimise a few things. Among other things, we noticed that the naming of the backup files should be changed again, that it would make sense to check and visualise the write permissions for the backup files and the files to be edited, and that we should change the way we display the success or error messages again.
So all in all, both editors should now be a little bit more practical than they already were. :)
Here again are the links to the updated documentation:
It is only a small thing, but in the end it bothered us ourselves so much that we are now happy about the change: The top node of each inventory within the Archive Management plugin was basically visualised incorrectly with a file icon. To avoid misunderstandings, this top node is now adequately labelled and thus self-explanatory for all users.
For a workflow step, it is now possible to configure that preview images are to be generated for display in the metadata editor or image QA plug-in. The generation of these preview images takes place when the work step is to be opened. If the internal message queue is active, the processing takes place via it, otherwise the images are generated directly. Only after the generation of these preview images has been successfully completed is the work step released for users to accept. Automatic tasks, on the other hand, are closed directly after the preview images have been generated.
An example of a configuration for the generation of such preview images looks like this:
The preview images are thus created in the respective directories as configured.
To ensure that users use secure passwords, it is now possible to control the minimum length that passwords must have when they are reassigned, when they are reset or when a user wants to change the password himself.
In the configuration file goobi_config.properties
the following optional value for the minimum length can be specified from now on:
This configuration switch and many others are documented in the Goobi workflow manual here:
There is a new plugin for enriching existing METS files on the basis of existing Excel files. Metadata and persons are read from a configurable file and transferred to the metadata of the process.
More details on the plugin and its configuration can be found here:
The source code of the plugin has been published here:
Another new plugin has been developed to read existing data from a directory and transfer it to METS. Metadata, structural data and pagination information are transferred from the directories. More details can be found in the documentation:
And this plugin is also published on GitHub:
For a specific use case, we needed a way to automatically determine and interpret individual metadata within existing METS files in order to subsequently generate independent metadata within the METS file. The existing use case is currently still very much tailored to the needs of the Kiel City Archive and therefore may not be reusable unchanged for other Goobi users. However, the plugin offers a good basis for implementing similar specifications on this basis in the future.
The detailed documentation for this new plugin can be found here:
The source code of the plugin has been published at this address on GitHub:
In most use cases, there are not multiple bulk import plugins installed within Goobi. For this reason, we have made a small change to simplify the selection of plugins in the user interface. If there is only one plugin to choose from, it will now always be selected immediately. This is not only logical and more convenient, but also saves unnecessary mouse clicks.
The existing plugin for editing metadata has been extended to add and delete metadata in the same way as in the metadata editor. This makes the operating logic more comprehensible for the user and the plugin allows additional application scenarios. The documentation of the plugin can still be found at this address:
With the possibility of directly uploading EAD files within the archive management plugin, some user scenarios were not initially considered. One such scenario is, for example, that the uploaded files may have unfavourable file names or the file extension may be missing. Such cases are now intercepted and spaces are also replaced by underscores. In this way, naming problems of EAD files should be a thing of the past. However, if you still encounter problems with future file names for EAD files, we would be happy to receive feedback on this so that we can make adjustments again.
When executing the GoobiScript metadataAdd
, logging in case of errors has not been exemplary so far. Specifically, we missed the display of information within the process log there. This has been corrected.
It is probably more exciting for technicians than for others: We have completely revised the implementation of the SRU client, as the programme libraries used there have reached end-of-life. With a new implementation, which is also used in many OPAC plug-ins, for example, we are now back to the state of the art.
We noticed that the logging within the mass upload plugin was clearly too granular and thus no longer really helpful for administrators. We have made changes here so that logging now takes place to the extent that it can also provide relevant information about what happened during the upload in cases where this is necessary.
More Goobi users always bring more potentially different use cases and other infrastructures. And so we sometimes notice where we can or should improve something for ourselves. This is also the case here in the area of logging out users. Here we already wished for better logging when users have logged in. And now we have done the same for logging out. Every admin is happy about that, right?
In the "Memory increase over time" statistics module, problems could occur with the display of large amounts of data. This was mainly due to the fact that the entered start time was not taken over and instead the first entry in the database was taken as the start date. This led to very large amounts of data (over 2500 data records), which the visualisation library used could no longer handle. The start date is now taken over correctly with the changes made and the display of not too large periods of time works again.
The current version number of Goobi workflow with this release is: 22.04. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Like many other well-known software solutions and websites, Goobi workflow was also affected by the security vulnerability within the Log4j programme library. At least theoretically. On the same day as the vulnerability became known, we updated the application, released a new version of Goobi workflow and updated about 200 servers. Security problems have therefore not occurred on any of the systems we look after.
During the rest of the month, we continued to work intensively on Log4j, logging in general and further updates, and we developed several automatic junit tests.
Once again there is a new GoobiScript. It is called metadataBackup
and allows you to easily create backups of the files meta.xml
and meta_anchor.xml
. These are the important internal METS files that belong to each process. Such a backup is particularly useful if automated changes are to be made to these files and a backup copy should therefore be created beforehand.
The call of this GoobiScript is simple without further parameters:
For a short moment, some Goobi installations were affected by the fact that Excel files could no longer be generated from the statistics. The reason for this was the update of a programme library for Excel files and the associated change of the file format. We have corrected this with the update.
If users adjusted the time period for the automatic saving of metadata, this caused loading problems when entering the metadata editor. This has been fixed.
The plugin for automatically deleting content from Goobi workflow has been extended. It is now possible to delete specific metadata and properties. This is useful, for example, if data is to be automatically anonymised after a set period of time.
The configuration options have been extended and documented for this use case:
The plugin itself for the installation as well as the source code can be found as usual on GitHub at the following URL:
The delay plugin for automatic pausing of workflows for a configurable time has been significantly extended. Instead of allowing only one central configuration as before, it is now possible to create a single configuration block per project or work step, as is the case with most other plugins. This means that the same plug-in can be used several times in different projects and workflow steps and can behave differently.
An exemplary configuration looks as follows:
And of course this plugin is also published on GitHub:
The GoobiScript executeStepAndUpdateStatus
ignored the configured queues when calling steps. This has now been fixed, so that the execution is regularly enqueued in the configured message queue and thus correctly prioritised.
The execution of scripts within the process details also previously ignored the execution within a queue. This has been corrected so that they are now also executed within the message queues and correctly prioritised.
The handy plugin overview with its version display for each individual plugin is a great help to Goobi administrators for maintenance. After all, it is easy to see whether all plugins are compatible with the Goobi version installed. Missing from this list, however, are those plugins that are stored in the directory goobi/lib
. In order to be able to see them in the list and check their status, the overview page has been extended.
Again this month, there have been some accessibility improvements. Among other things, all buttons that have a dropdown functionality have been adapted so that their state (open vs. closed) can be processed well by screen readers.
The current version number of Goobi workflow with this release is: 21.12. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Within the user settings, there is now the option in the General
section for each user to individually define the display mode. You can choose between Normal display
, Low vision mode
and the WCAG compliant mode
.
This option is of course in addition to the possibility for each user to customise the layout of Goobi themselves via their own CSS definitions.
In the configuration file editor plugin, it is now possible to configure a list of directories in which files are to be searched for editing. The new configuration now looks as follows:
In this context, it was considered that the editor should not be used to change its own configuration file. This would otherwise have allowed authorised users to define additional paths for the editor in order to carry out more profound interventions in the system.
The documentation for the plugin can be found here:
As part of our ongoing improvement of the user interface to increase accessibility, we have now also taken a closer look at the central Skip Link
. This is located at the top of all pages and allows users with keyboard control to navigate immediately to the content area of the page via the TAB
key. So now there has been a small correction for the correct order of scrolling through the page elements.
Within the dashboard, which the majority of Goobi workflow users use, the most recently completed tasks are displayed. In the past, tasks from recently processed production templates were inadvertently listed there. A correction has now been made to avoid this display error.
With the new developments, it is now possible to write comments on individual images. This comment function is integrated in several places in Goobi workflow: in the METS editor, in the ImageQA plugin and also in the LayoutWizzard. To use this new functionality, it must be activated within the central configuration file goobi_config.properties
:
Until now, clicking on a thumbnail in the metadata editor always set the current page in the pagination, even if you were in the structure data view, for example. This could inadvertently lead to operating errors if further pagination work was to be carried out later. By changing the operating logic, a click on the thumbnails now only changes the page selected in the pagination if you are actually in the pagination.
There was an error in the transaction log when a user pressed Enter after entering a message. The display was changed there instead of sending the message. This error is now fixed.
All buttons within Goobi workflow have been intensively checked to ensure that they continue to function and are displayed correctly after the extensive accessibility changes. If we have overlooked a button or functionality, please let us know.
Up to now, the GoobiScript parser first displayed the confirmation prompt when invalid YAML syntax was used and then displayed an error at the very top of the page. This led to confusion among users because the previously sent GoobiScript was not executed as expected after all. For this reason, from now on the GoobiScript will be checked for validity directly after it has been sent and, in the event of an error, an error message will be displayed directly above the GoobiScript area.
There was a misbehaviour in the GoobiScript addUserGroup
which, when called multiple times, resulted in only the last added user group being added to the desired task. This behaviour has now been fixed and the GoobiScript behaves correctly from now on.
In the vocabulary management, leading and trailing spaces are now removed from all text fields (Input, Textara, HTML) to avoid such accidental entries and the potential problems resulting from them.
The GoobiScripts metadataChangeValue
, metadataAdd
, metadataDelete
and metadataReplace
now use the Variable Replacer for content changes, allowing very flexible use involving other metadata field contents or even information about the process to which the metadata belongs.
An example call looks like this:
As before, more information is available here on the Goobi workflow variable system:
The current version number of Goobi workflow with this release is: 22.01. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
When a process is created in Goobi workflow and data from a catalogue is to be imported for it, it can occasionally happen that it has not already been configured for all the metadata provided where within the internal METS file the metadata is to be stored. This was previously not transparent for the user, so we have made a change. Metadata that cannot be transferred are now clearly visualised in the creation process.
Since a few versions, Goobi workflow has offered the possibility to display and edit the results of a full-text recognition in ALTO format directly from the metadata editor. This functionality was previously only accessible from the single page display. With the changes made, however, this is also possible from the thumbnails and subsequently allows navigation between the images within the open editing screen.
The already mentioned editor for full texts in ALTO format now supports the ALTO files in version 4.0 and allows their display and editing. This means that it is now also possible, for example, to display and edit the full texts of Transkribus.
The archive management plugin is being used productively in more and more projects. In this context, new wishes, necessary adaptations or even visual changes are always needed, which we gradually implement. Recently, there have been several optical adjustments to the entry mask, which make it worthwhile to take a look at the functionality again.
As a reminder, here again is the detailed documentation of the plugin:
With some developments, even with a lot of professional experience, one is still surprised at the extent to which they can take on and what one would not have expected. The topic of accessibility is a good example of this. We have already invested countless hours in optimising accessibility for Goobi workflow and already meet common validators. And yet there are always new surprises, as the following example shows:
This screenshot shows what effects changes can have if, for example, you change links to buttons so that screen readers, among others, can also handle them better. Of course, we didn't leave it like this, but styled it nicely again. However, if you find something similar in another part of Goobi workflow, please let us know so that we can correct it.
A few months after the actual accessibility work was completed, we noticed a few details that could be improved. These included the correct attributes in tables so that screen readers can interpret them correctly.
The compatibility with the common validators remains under constant observation and we try to maintain 100% compatibility. However, it is important to keep in mind that validators change over time in terms of requirements and therefore constant monitoring of compatibility remains necessary. So the topic as such is probably never really finished. At the moment, however, it looks to Goobi workflow as if we have done our homework well:
The mass upload plugin is especially useful when many processes in Goobi worklow are to be automatically supplied with the corresponding image files. Experience has shown that this works quite well. However, the button for assigning the images to the identified processes allowed a double execution by repeatedly clicking on it. This then led to undefined behaviour, so this had to be changed. The corresponding button is therefore no longer displayed if it has already been clicked and images are being sorted into the processes.
By the way, we took the opportunity to make a small correction: If the parameter use-barcodes
was set to true
in the configuration and no barcode could be determined when uploading images, a meaningful error message is now displayed.
This item comes from the category "Unexpected side effects": In fact, a faulty configuration of the Excel import plugin could lead to the dashboard and the listing of process templates in Goobi workflow no longer being displayed correctly. We have made corrections here so that everything looks good again.
Within the user administration, the display of the column with the buttons was too narrow, so that the buttons wrapped awkwardly. This has been remedied by making the column at least as wide as possible, so that it looks good even with many projects and user groups.
When users are deleted in Goobi, the user's record is not actually deleted in the background, but completely anonymised. This is done to ensure that the data as a whole remains complete. To make it clear that such users cannot actually be active in the workflow, such deleted users are now also removed from the list of authorised users for a task, provided they were assigned there. This is primarily a visual correction, as the user accounts were already deactivated and accordingly can no longer log in.
The fact that Goobi worklow and almost all plug-ins are under an open source licence should already have become common knowledge. There are currently over 300 plug-ins for Goobi workflow and about 130 have already been published on GitHub at https://github.com/intranda. Many of the plug-ins already have quite detailed documentation at https://docs.goobi.io, which explains, among other things, how to install the plugins. Until now, however, you had to download and compile the plugins yourself as source code. This was cumbersome and very technical. Therefore we have changed this so that compiled versions of the plugins are now automatically stored on GitHub whenever we make a change to a plugin or release a new Goobi version. You can access these compiled plugins by clicking on Releases
in the right-hand pane of the respective plugin.
Afterwards, one gets an insight into the downloadable files, which include the plugin itself as well as the possibly required configuration files. These files can now be downloaded and installed correctly according to the instructions, so that commissioning has been simplified considerably.
The current version number of Goobi workflow with this release is: 21.11. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
For some time now, there have been various GoobiScripts that can very conveniently make changes even to metadata in bulk. In the past, we have often focused on regular metadata. With a new GoobiScript we now also allow changes to persons. The reason for this is that we needed a convenient way to change the roles of persons in bulk, for example, to be able to make inventors instead of wrongly assigned person roles as authors in 100,000 transactions. In such a case, the call to the new GoobiScript would look like this:
As always, this and the many other GoobiScripts are described in detail in the online documentation.
Here is the link to further help:
It took a long time. But it has turned out really well: There is now very detailed documentation for future Goobi workflow developers. It shows in detail how to set up a development environment, which tools are needed for commissioning and which settings should be made here and there so that development runs smoothly.
In order to make it as easy as possible for future developers, we have also documented in the instructions how to set up a small, meaningful dataset very conveniently, so that development is also possible with actual meaningful data. For this, we benefited from our many experiences with Goobi-to-go.
So if you've always wanted to help develop Goobi, it's now easier than ever. Click here for the documentation:
Goobi worklow has for some time allowed exports to take place within a workflow via plugins. This is sometimes necessary for individual exports to special systems with special format requirements. However, if several exports are to take place within a workflow, it was previously not possible for administrators to specifically execute a particular export of a workflow. However, the exports already functioned as desired when the workflow was run through.
To make it easier for Goobi administrators to selectively call up individual export steps manually, export buttons are now displayed within the process details directly next to the relevant tasks. This means that they can now be called up as desired.
We noticed that the logging within the process log was still in need of improvement when the status of tasks was changed via GoobiScript. We wanted both the old and the new status to be easily traceable in the process log. For this reason, we have now made a small adjustment that makes such status changes more comprehensible.
We had recently already changed the naming of the backup files for the METS files of the Goobi processes so that they are better traceable in the editor, do not rotate further and thus cause unnecessary write accesses to slow memory areas. In order to implement this naming scheme consistently, we are now also using this mechanism for the automatically generated backups of the files that are created within the still quite new editors for the configuration files and rulesets.
Here, too, the naming of the backup files is now such that the date and time of the backup is immediately apparent from the file name and is a good help if the worst comes to the worst.
We have already described several times that the topic of accessibility is not only of interest to us but also occupies us full-time. In this respect, it is only logical that we have again improved many small things in favour of accessibility this month. This mainly concerned the display of the process log and some adjustments for the display of the process list.
But it will certainly not be the last time that this item is listed here in the digests 😀
We have already integrated various mechanisms for persistent identifiers into Goobi workflow in the past. In addition to URNs, Handle and DOI have also found their way into the Goobi universe. Recently, support for ARK identifiers was added. This is another system that, in interaction with the Goobi viewer, allows permanent linking of works and also granular linking at page level. Unlike other systems, ARK identifiers do not require a licence fee and can be freely assigned independently. More information on ARK in general can be found here:
And here you can find the documentation for the plugin we developed:
The source code for the plugin is published on GitHub here:
Sometimes it is helpful to see at a glance which ruleset is used for a process template. For this reason, the ruleset can now be displayed within the listing of processes and process templates. This is what it looks like:
A new plugin for sending mails within a task has been developed. The list of recipients and the text can be configured individually for different steps. All fields from the variable-replacer are also available. This means that metadata or information about the task, step or project can also be accessed in order to use them within the mail.
The detailed documentation for the commissioning of the plugin can be found here:
And at this point the plugin can be found as source code and in compiled version:
In the "General" area, there is now the option to individually define the display mode. Here you can choose between normal display, low vision mode and WCAG compatible mode.
We have developed a new plugin for exporting newspapers to the DDB newspaper portal. The plugin is used to create the specific METS structure required by the DDB for newspapers. A METS anchor file is created for the entire record of a newspaper. (https://wiki.deutsche-digitale-bibliothek.de/display/DFD/Gesamtaufnahme+Zeitung+1.0)
For each exported volume, another METS anchor file is created and linked within the overall record. The volume contains further structures for month and day. (https://wiki.deutsche-digitale-bibliothek.de/display/DFD/Jahrgang+Zeitung+1.0)
Each issue, on the other hand, is created as a single METS file and linked in the METS anchor file of the respective year. The issue may contain further structural data such as article descriptions or supplements. The digitised images are also referenced here. (https://wiki.deutsche-digitale-bibliothek.de/display/DFD/Ausgabe+Zeitung+1.0)
Detailed documentation for the plugin can be found here:
And at this point you will find both the source code of the plugin and the compiled version of the plugin:
The development of Goobi workflow started in 2004. In the meantime, many new functionalities have been added and the application has grown many times over. In order to maintain a good overview, but also to comply with established best practice for software development (Maven directory structure) and to make it even easier to keep the programme libraries used up to date in the future, we have massively revised the project structure. This should not result in any functional changes for the users. For us as developers, however, these are extensive interventions in everyday work and project organisation. If you notice any undesirable side effects when using Goobi workflow in the near future, which should certainly not be desired, please let us know.
Incidentally, these changes have also already shown some positive results. The updates made to various programme libraries as a result of the changeover have already led to a measurable increase in the security of potentially vulnerable code components of external libraries and a better ability to automate testing for possible future security vulnerabilities.
There was a small display error within the own tasks. There was an idiosyncratic line break with unusual character representation that did not belong there. We have corrected this. Nothing happened 😀
The current version number of Goobi workflow with this release is: 22.03. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Within the user interface, it is now possible to display the number of images as a column. This can be done within the task list as well as in the own tasks. This looks like this, for example:
We have slightly revised the incredibly practical display of installed plug-ins and their versions. All existing plugins are now listed correctly sorted and the paths to the directories are also listed.
In the list of tasks, we have made some improvements regarding sorting. The biggest noticeable difference will probably only be noticed by administrators:
All columns now sort lexicographically in ascending order when you activate the sorting of a column. Only the column with the ID behaves differently and sorts in descending order at the first click, in order to display the most recent transactions immediately at the top. Administrators will be pleased. :)
Goobi workflow has been using Maven as a build system for a number of years. Last month, the project structure within Maven was further consolidated so that there is a dedicated module for running automated tests and checks within the Continuous Integration infrastructure.
The previously existing modules to build a .war file for deploying the known application within a Tomcat and the module to build a .jar file have been cleaned up and are now only responsible for compiling the artefacts. A new addition is a CI module that bundles previously scattered steps in the lifecycle and also integrates new checks. These are in detail:
Running the JUnit tests
Checking the dependencies used for known security vulnerabilities (OWASP)
Creating an analysis of how much code is covered by unit tests (Jacoco)
Checking the source code for violations of selected checkstyle rules
Performing a static code analysis using Sonar
At the same time, the execution of the unit tests was changed from a suite-based infrastructure to a class-based one. The number of regularly checked tests could be massively increased. In addition, the last code sections that required compiling with Java 8 and explicit compiler options were cleaned up.
The changed project infrastructure now allows for faster building of the individual modules and thus less overhead in development, as well as expanded and improved testing of daily work to increase code quality.
Anyone who would like to track our progress in terms of code quality is welcome to do so here at any time:
The diagrams still show that we have a long way to go. But we are on the way.
And internally, progress looks something like this at the moment:
So things are moving forward. We'll report on it here more often in the future.
In the past we often noticed that we would have liked to have more logging if a GoobiScript did not do what we had hoped. We have now addressed this issue and solved it in such a way that administrators can easily see in the log files what was called. It now looks something like this:
Some time ago we had already reported that we were implementing an extensive interface to the software AEON. There have been numerous extensions here again. Among other things, the look of the interface was massively revised.
Properties can be individually adjusted or adopted for entire datasets or even for individual objects that are actually to be digitised, with deviations from the default values clearly visualised. In addition, it is now possible for processes whose digitisation workflow is already in progress to be stopped, unless a configurable status has already been reached.
So, all in all, great progress, but also further work in progress.
There are already a lot of GoobiScripts. But every now and then we notice that a certain functionality would be handy. This time we noticed that it would be quite practical if we could manipulate metadata not only in the logical areas of the METS files, but also within the metadata for the images. No sooner said than done. Besides the parameters work
top
child
and any
it is from now on possible for the GoobiScripts to understand and apply physical
for manipulating the metadata. More details can be found here in the documentation:
To make Goobi workflow better able to handle newer MySQL databases, we have replaced the driver for communicating with the database. From now on we use the following driver:
It is now possible to run Goobi workflow with MySQL versions 5.7 and 8. However, the earlier versions are no longer supported. This must be taken into account in future updates.
This is already mentioned in the update instructions:
As you can see from our digests and plugins, the documentation of our developments has been very important to us for several years. Currently, we have also turned our attention to the configuration files. This area is still a work-in-progress. But if you want to take a look, you will find a few good examples here:
There will be a lot more happening here in the next few weeks.
In the case of failed script calls, the process log was not really very helpful until now. This has been adjusted so that incorrect calls now appear with a clear error message in the process log.
Incorrectly, when creating new users, it was not displayed that a password for a new account was a mandatory field. This has been corrected.
The current version number of Goobi workflow with this release is: 22.05. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
In the project settings there are now two additional fields in the tab METS Parameter
to record the URL to the SRU interface of the Goobi viewer and the URL of the IIIF Manifest for the complete work.
Example entries could look as follows:
The result within a METS file created in this way is then accordingly as follows:
Not too long ago we introduced the new image comments here. With their first use at various institutions, however, we noticed that the internal storage location for the data was not ideal. For this reason, we have made a change for this. Those who have already used this functionality should therefore follow our update instructions provided here for the next update:
In the GoobiScript metadataChangeType
the parameter any
did not work as expected. This has been corrected and now allows metadata to be changed at all levels of a METS file as desired.
For the sake of completeness, here is the link to the detailed documentation of GoobiScript:
Administrators love logging. It helps to better understand why a problem occurred in case of an error and what can be considered as the trigger for a failure. For reliable operation of productive applications, meaningful logging is not only helpful, but often simply mandatory. It is all the better if the developers of a software work closely together with the administrators who actually run the software.
The result of such cooperation in the context of Goobi is that we are constantly trying to improve the logging of Goobi workflow. This month we took a closer look at the logging of the application stop and made some improvements. After all, sometimes too much logging is not right.
We had already reported on this at the Goobi Days. In recent months, however, our developments for processing newspapers have been used more and more frequently. That is why we would like to explicitly address this topic again together with the latest developments:
For some time now, it has been possible for Goobi to recognise newspaper editions semi-automatically and to index them with metadata. To this end, the workflow first automatically recognises newspaper editions on the basis of trained models. We have recently expanded this considerably and fed it with more ground truth data. Thus, the recognition accuracy of newspaper editions has improved many times over.
After this automatic recognition, a plugin is available in Goobi worklow for enriching the newspaper editions with edition-related metadata. This makes it relatively easy to record issue numbers, dates and publication days, including morning and evening editions, without having to do this individually for each issue. Instead, a semi-automatic mechanism takes effect here, which counts up the subsequent issues accordingly with a few entries from a user, enriches them with dates and also names them.
In addition, supplements can also be created quickly here, so that a comprehensive METS file is subsequently generated, which has standardised date information and can be searched in the Goobi viewer, e.g. via a calendar entry.
To meet the requirements of the German Digital Library and the DFG Viewer, by the way, an additional export plugin was recently added that prepares and provides the data according to the specifications.
We have worked a lot on the individual components described here in the last few months and have repeatedly optimised their operation. Some things will continue to happen here in the coming weeks. We would be happy to present this in detail in a workshop at the upcoming Goobi Days.
Up to now, we had not even mentioned the various newer import plugins that we had recently implemented for some specific mass imports. For these plugins, there is no detailed stand-alone documentation yet.
However, it is important for us to point out that there are several new mass imports that not only create processes in Goobi workflow, but also increasingly create or enrich entire archive trees with tectonics.
Depending on the project, structured METS files can also be created here, as with other importers for Goobi workflow, where structural elements and associated metadata are imported together with authority data for the associated image files.
The step plugin intranda_step_pdf-extraction
allows full texts to be extracted from PDF files and saved as ALTO files. However, we recently noticed an error in the processing, which was responsible for inappropriate gaps appearing within some words, among other things due to an existing hyphenation in the words.
We were now able to find and fix the cause of this problem. By the way, the plugin was already documented here:
We have published the plugin at the following URL, where the corrected version can now also be downloaded:
A lot has happened again in the area of our documentation:
In the GoobiScript addToProcessLog
the included explanations were not ideal. There was a small correction here, which now looks like this:
In order to make the update instructions for Goobi workflow more intuitive, they are now no longer structured by date, but by the respective published version. This change only applies to all future notes that are included there and not retroactively. It should hopefully make it a little clearer for administrators in the future.
We have again put a considerable amount of energy into documenting more configuration files. Almost all configuration files are now documented there in an exemplary manner. Some remaining work is still to be done. But if you want to have a look, here are some sample links to new documentation:
Configuration for dockets:
Configuration of the queues:
Configuration for properties:
Configuration for translations:
Configuration for the Web Api:
Configuration for the authority data:
Configuration for the field display in the metadata editor:
The current version number of Goobi workflow with this release is: 22.07. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
The following screenshot shows the SonarCloud analysis of the current release. More information is available directly on the .
Developments and news about Goobi workflow
Extension of the plugin for issue recognition of newspapers
Support of S3 as storage in further plug-ins
Enhanced accessibility for tables
AEON plugin development
Documentation and code releases
Already since a major change a few years ago, plugins can bring their own user rights. These can then be used in addition to the rights that Goobi workflow itself already brings. This is usually done by opening the plug-in to find out the name of the required right.
Then, within the user groups, you can enter the required right in the lower right area and thus also assign it to the user group.
In the case of very complex rights, of which individual plug-ins can also have several, the determination of the required rights is sometimes too cumbersome. For this reason, Goobi workflow has now been extended so that within the central Goobi configuration file all those rights can be made known that Goobi should list within the list of available rights. In this way, the rights of plug-ins are just as selectable and clickable as those already provided by Goobi itself.
The configuration of these additional rights is done within the configuration file goobi_config.properties
. It looks as follows as an example:
If the rights entered in this way are also to be displayed with suitable translations, these must be entered accordingly within the local messages_XY.properties
files. This must be done as an example:
As part of a project where Goobi is to notify another technical system (AEON) via an API when all operations in a batch have reached a certain status, a new plugin has been implemented. This is a step plugin that stops further execution of the workflow for the respective operation if there are other operations belonging to the same batch that have not yet reached the same status within the workflow. The last process that reaches the desired status triggers all processes to switch to the next process step together and thus continue to run through the workflow. This plug-in therefore serves to bring all processes back to the same status in the workflow. If desired, the plugin can also send a request to AEON via REST to inform about the change of status.
Detailed documentation for the plugin can be found here:
And this is where you will find both the source code of the plugin and the compiled version of the plugin:
The two plug-ins that allow simple or repeated catalogue queries during the already running workflow have been extended to work with the new functions of the JSON-OPAC plug-in. Since multiple fields can be used there for a single query from a catalogue, i.e. to import a result with multiple search parameters, the configuration of both plugins has had to change. For updates of Goobi or the plugins, the configuration files have to be considered accordingly. Details on this can be found both within the documentation of the plugins here:
... and here:
And of course the necessary adjustments are also listed in detail within the update instructions:
In the past, it was difficult to make small adjustments to Goobi when there was no direct access to the server. With the new plugin for editing configuration files directly from the Goobi user interface, this is now different. If a user has the necessary rights in the system, it is now possible to change configurations directly from Goobi.
In the background, the plugin creates backups in a definable number, so that an administrator can also restore an earlier version on the server. In addition, the plug-in also offers the option of integrated help. Here, you can determine yourself whether your own help texts should be displayed for editing configuration files. These must then be stored accordingly within the so-called message files and can even contain formatting information.
More details about the plugin can be found in the very detailed documentation here:
The source code and a compiled version of the plugin can be found here as usual:
When users logged in to Goobi workflow, it was difficult for us as developers to understand what was causing the technical problems. For this reason, we have taken the time to look into this issue and have thoroughly revised the writing of log files, especially with regard to logging in. The balancing act here is, of course, that we are allowed to log as little data as possible in view of the GDPR We have now thought of all these issues and adapted the logging accordingly. So we can work well with it in the future. And if someone wants to see it in action, they can simply try the following command on the server side:
About two years ago we massively extended Goobi workflow to allow better multi-client capability. This is based on the fact that several institutions/clients can now be defined in one Goobi instance.
However, if several institutions were not defined in a Goobi instance, a new selection field was unnecessarily available in many areas, in which usually only one institution could be selected, because the use case of several institutions in one instance occurs relatively rarely. Therefore, we have now made changes in various places in order to only show this display of institutions if there really are several institutions. Otherwise, both the selection field and the table column are basically hidden. This way, the interface remains tidy and clear and does not display unnecessary information.
We are gradually changing some visual subtleties so that the operation of Goobi becomes even more intuitive. One such refinement is, for example, that when editing data sets, we now list the name of the respective data set much more prominently in the title of the page. The screenshot shown here illustrates this quite well, because it displays the name of the edited project in large letters at the top, even if you are on a tab within the editing form. This makes it clear at all times which project you are currently making changes to, for example.
In order to enable the editing of ruleset files no longer only via server access, we have developed a new plugin. It allows editing of rule sets as xml files directly from the Goobi interface.
The loss of changes made within the files is avoided by the fact that a change to other rule sets always also checks whether there may be unsaved data.
In case something goes wrong, the plugin automatically creates backups in the background in a definable number, so that even accidental changes can be undone by an administrator on the server.
Please note: Even with this plugin, one should know what to configure here and how. The facilitated access to the rule sets can lead to serious data loss of previously recorded metadata if used incorrectly.
A very detailed documentation for the plugin can be found at the following address:
The source code of the plugin together with a compiled version of the plugin can be found on GitHub:
When uploading files with the file upload plugin, misleading error messages came up in the past when a validation did not want to accept the uploaded files. Until now, the same not really helpful message came up that no objects could be found. The actual reason for the message in such cases was that files were found, but they did not correspond to the validation rule. We have now revised this and display clearer messages for such use cases.
The current version number of Goobi workflow with this release is: 21.10. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Extension of the Archive Management Plugin
Extended Java 11 support
Adaptation of the export options
Extension of the handling of museum data from LIDO
For some time now, the Goobi workflow metadata editor has allowed OCR results to be viewed in text format. However, if you then discovered a recognition error, you were left with only three options:
use the transcription plugin in Goobi workflow and export text
instead of ALTO-XML
, which however prevents the marking of search hits on an image in Goobi viewer.
edit the ALTO file with a separate text editor in the file system. This is very time-consuming and hardly feasible for non-professionals.
do not correct the recognition error and try to sleep peacefully anyway.
Since this Goobi workflow version there is a new possibility:
You can use the new integrated ALTO editor within the metadata editor. The coordinates of the words are thus preserved and the full text can be edited almost like regular continuous text.
Highlighting the lines and words allows it to be easily seen where on the page each word is printed.
The documentation for the new functionality can also already be found in the Goobi workflow manual available online:
https://github.com/intranda/goobi-workflow/commit/50302f4464c417f090593a91151eb3c127643223 https://github.com/intranda/goobi-workflow/commit/4ebd2aa551680117bd8ef6f224f030a31caaef3c https://github.com/intranda/goobi-workflow/commit/04b4cddefcebb8d8675c116946bff3c1df4a9fda https://github.com/intranda/goobi-workflow/commit/293e19fc4cdc3289d4f6049868578bc7d4e21d61 https://github.com/intranda/goobi-workflow/commit/c0dcfcb477ef0c3266db1d18c7ff5da495f1835b https://github.com/intranda/goobi-workflow/commit/ef8609c9de7aeee3e00d66ff62a7545d1f88c00e https://github.com/intranda/goobi-workflow/commit/c619c43bdbd02763391e253056e44b3fc4953c2f https://github.com/intranda/goobi-workflow/commit/0a4350efff933aed8a6196074f40329591b19efa https://github.com/intranda/goobi-workflow/commit/94db988c85e3861fcad3c946917e353a697a1824 https://github.com/intranda/goobi-workflow/commit/e82ee6d1a2d8544a692141affda6fbffce51e31b
When an action is triggered in the metadata editor, the entire page is rarely reloaded so that the workflow is not interrupted and the scroll position of the individual containers can be maintained. When refreshing the page in this way, the developer can decide exactly which parts of the page should be refreshed.
In the past, some actions also updated parts of the page where it was not necessary. As a result, some actions, such as setting the representative, took an unusually long time. We have completely checked the metadata editor for this problem and optimised the updating for all actions.
https://github.com/intranda/goobi-workflow/commit/c8c4bb7bf26e3127795e5efef016f6c7bd88a36b https://github.com/intranda/goobi-workflow/commit/8d8fc0ba9de8344d1f8d7fe7ed1a4f6f99e2dba2 https://github.com/intranda/goobi-workflow/commit/e583242c440624e4b6ee8c63691c8ed7bfd7e993 https://github.com/intranda/goobi-workflow/commit/f472088c86c579faffabd33800cda5960d9227c2 https://github.com/intranda/goobi-workflow/commit/5c43b1e89e32ccf9927c2770354d78950213a26b https://github.com/intranda/goobi-workflow/commit/c390ceb75df8c4219711c9ef1fa9d0d754dd5844 https://github.com/intranda/goobi-workflow/commit/5550ce2393456cc214f1f21787fa49c91f841616 https://github.com/intranda/goobi-workflow/commit/27a0653758593f24d7e82ef645f239ed0805f8d2 https://github.com/intranda/goobi-workflow/commit/5cf7bd6e7b3176ae4692df5a25373f8474db49f6 https://github.com/intranda/goobi-workflow/commit/827aa52ff63663fa1aab7028b32786e4e5206976 https://github.com/intranda/goobi-workflow/commit/7cc545c634bd355d0d5b7ea66e39d5261930376c https://github.com/intranda/goobi-workflow/commit/020f270d011bb10d81ef23dddec9d095c9c2be57 https://github.com/intranda/goobi-workflow/commit/5ccfbf44e4c57302b834b8a04d7d0638ec229f05 https://github.com/intranda/goobi-workflow/commit/adf93e08dff00cf879fb4c4436cf935e156c6cf2 https://github.com/intranda/goobi-workflow/commit/fc516f07f9170849331be0271ae093b5e38f9cdb
In the past, it was often the case that after an update, the first time you entered the just freshly updated Goobi, the layout and/or some stylings were completely broken. This was not because the developers did a bad job, but because browsers like Chrome or Firefox cache files on the local device to save resources and bandwidth. The files are only re-downloaded from the server if they have changed. Therefore, it sometimes happened after an update that old files were mixed with new files and therefore the layout was broken. In this case, the page had to be completely reloaded (with the key combination Ctrl
+Shift
+R
) to discard the cached files and reload them.
To prevent this from happening in the future, we now append a unique text associated with the version to the address of each file that could potentially be cached locally for each Goobi release. This way, the browser will always request a new file for new versions and the layout will look correct immediately after the update, without having to press secret key combinations.
https://github.com/intranda/goobi-workflow/commit/b597c0439d3f5d6004e82811929c6156100ce167
Goobi workflow is used in many different ways. For example, there are some institutions that are not interested in metadata in METS/MODS or LIDO format. For these institutions it has been noticed that script calls mandatorily require a meta.xml
file in the task folder, otherwise they are aborted with an error. This has now been changed so that the meta.xml
file is only read for script calls if metadata information is actually required within the script call.
https://github.com/intranda/goobi-workflow/commit/d7d7d2ca5fa60a59c2ef3a996eaa43c5acb2845a
After the GoobiScript runtime was completely re-implemented last month, some problems with GoobiScripts from plugins still arose that caused the plugins not to work properly. These problems have now been fixed and everything is working as usual again.
https://github.com/intranda/goobi-workflow/commit/d154874ba63a7e815267db378218c551cf11273c https://github.com/intranda/goobi-workflow/commit/a8320d942345e6aaa39bc856a1d701184c2ed0ae https://github.com/intranda/goobi-workflow/commit/d232a0f60d6db4b81c3c14d0ade4ddc1e668c97c
The enhanced dashboard has been extended even further. There are two new widgets: The widget Changes in the last 7 days
shows steps that were completed, in progress or had errors in the last 7 days. The second new widget shows the steps that are currently in the queue. This is based on the new INFLIGHT
status introduced last month.
Another new feature is that the layout of the dashboard can now be configured individually via the user settings. This configuration can be done by editing the setting Arrangement of dashboard elements
within the user-specific User configuration
in the tab General
. Each line within the text box adds an element to the dashboard. Each line consists of two parts, separated by a space: First is a number that specifies the column in which the widget is to be displayed. The second part after the space is then the name of the widget to be added.
The list of currently available widgets is: assignedSteps
, batches
, htmlBox
, itm
, processSearch
, processTemplates
, queue
, rss
, statisticsProcesses2
, statisticsProcesses
, taskHistory
, tasksLastChanges
.
An example configuration could look as follows:
Developments and news about Goobi workflow
Development of a new capture plugin for integration with Atlas AEON
Development of a new plugin for editing configuration files from the user interface
Development of a new plugin for editing rule sets from the user interface
Development of a plugin for simultaneous editing of metadata from multiple processes
Until now, it was possible to continue to create processes within production templates for projects that are actually marked as deactivated. There has now been a change that should simplify the operation and make it more intuitive.
The buttons for creating individual processes and also those for mass import are now displayed in red for deactivated projects and show an explanatory warning message when used. In addition, the project name is also displayed in grey to indicate that the project has been deactivated. Deactivated projects are no longer listed in the drop-down fields that open by clicking on the arrow icon of the button.
Within the configuration of users, among other things, the required user groups and projects can be assigned that should belong to a user. At this point we have made a small optimisation that makes the operation more logical.
In both areas, the button for adding projects and user groups is now only displayed if further projects and user groups are available that have not yet been assigned. Accordingly, the button is now only displayed if it really enables a change. This should make operation a little more intuitive.
To improve the use of the archive management plugin once again, we have implemented some additional internal check routines and issue more informative messages within the user interface than before.
If, for example, the connection to the database is not available or expected information is missing, e.g. for the selection of the stock to be processed, helpful error messages are now displayed for the processor.
In the course of various internal menu changes, we have also merged the mobile menu (for smartphones and other narrow devices), which was previously maintained in a separate file, into one file. As a user, you will hopefully not notice anything. For us as developers, on the other hand, this approach is now much simpler, as new menu items to be added now only have to be considered in one central place.
We also took the opportunity to make some minimal visual adjustments and to change the colour highlighting of active pages. In the meantime, there was a colour inconsistency between some blue and some grey highlighted menu items. Now all active menu items are displayed in grey again.
We have developed a new plugin that we all didn't know we actually needed for a long time. The need came to light because large mass exports of data in particular occasionally resulted in errors due to rule set adjustments made in the meantime. Such situations can arise, for example, because metadata is defined differently at a later date. For example, if metadata is no longer allowed to occur but was allowed in the past, the METS files will not open correctly. Older Goobi processes were exported successfully and validly in the past, but with an updated rule set they may now violate the new rules.
This new plugin makes it easier to detect such processes. It can be easily executed for a filtered list of processes and checks the successful readability of the METS files at hand. In case of errors, these are listed in a table and it is possible to directly enter the METS editor for the corresponding process.
The source code of the plugin has been published here on GitHub:
The detailed documentation on installation, configuration and operation can be found at the following address:
In another project we had the special case that we had to completely reset the pagination for many processes, because the number of files for hundreds of processes changed. In this context, we noticed that there was no automatism in Goobi workflow that could make such a required change for many processes in mass.
For this reason, we have developed a plugin that allows resetting the pagination for large amounts of data. With the help of a freely selectable filter, the plugin can be used for thousands of processes.
The source code of the plugin has been published here on GitHub:
The detailed documentation on installation, configuration and operation can be found at the following address:
If users had assigned many projects within the user settings, the display of the information was not optimal. We therefore made a small optical adjustment here in August so that even very extensive lists of projects are displayed correctly.
And because this representation is also useful for the user groups, we have also changed it. However, this small adjustment will only be included in the upcoming September release.
The storage of keystore information is now no longer done from the user interface of Goobi workflow. For a better use of keystores also by other programs the configuration has been changed and is now done via the central configuration file goobi_config.properties
. A keystore can now be defined there as follows:
These and other changes that need to be considered for updates have been included in the publicly available update instructions. Those who do not yet know them can find them here:
Slowly but surely, some Goobi installations reach a data volume where database queries with unoptimised tables and database queries become too slow. For this reason, we have taken a close look at some database queries and tables and made changes. These adjustments are always included in the Goobi update. If, on the other hand, you carry out the update yourself, you will find further details on the changes in the update instructions:
The current version number of Goobi workflow with this release is: 21.08. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
New plugin for editing configuration files
New plugin for editing rule sets
Adjustments to the institution display
AEON plugin
About two years ago we had implemented a completely new print view for metadata. This not only introduced the new feature of having a picture of the representative. Above all, it was now possible to print the hierarchy of the structure tree with the corresponding person and metadata.
However, what we had not considered in the implementation was that Goobi users will really use this function intensively right away, even for very deep hierarchies. We had initially only implemented the consideration of two hierarchy levels. With the current revision, however, we now go up to eight levels deep in the listing on the print view.
What is new in this context is that the corresponding pages are now also listed. For each structural element, both the image numbers and the logical page numbers are now listed as a page range.
Once again there have been some minor changes within the execution of GoobiScript and the display of the results. A good example of such a minor change is, for example, that now the description of what the status of a GoobiScript is is a bit more meaningful. For example, for the GoobiScript for changing the project affiliation, understandable information is now displayed instead of the previously quite cryptic information that not even we as developers could do anything with. :)
During the commissioning of the XMP header plugin on a productive system, we noticed that the documentation was not completely up to date. This has now been revised and in connection with this some changes have been made to the plugin, which allow even better logging in case the plugin encounters errors during execution.
Here you can find the current version of the documentation online:
In some parts of Goobi workflow there were again several small changes to make it easier to use. These changes are too many and too small to be listed here. One example is the extension of the inline help texts, which have been slightly rewritten, including the configuration of file groups for the creation of METS files.
There have been several such changes in the background. In the best case, the user does not even notice these small adjustments.
In the user administration, changes to the affiliations for projects and groups can now be undone with the Cancel
button. This was not possible before. We have also made a similar adjustment to the projects, where the settings for the file groups now behave similarly.
In the area of user groups, the interface for users was still not ideal. This mainly concerned the assignment of individual permissions that can be brought by individual plugins. The possibility of entering such individual permissions already existed. However, it was not intuitive enough, so that it was too easy to overlook the input option. This has now been significantly improved with a revision.
On this occasion, we have also taken into account that a user should be able to recognise even better when no further permissions can be assigned. In such a case, a short help text is now displayed.
A development on the DOI plugin allows us to now use metadata from multiple levels of a document and its parent unit in multi-volume works for registering DOIs, to pass them as XML elements to Datacite, or even to use them as a list of elements with attributes for registering DOIs.
Here again is the link to the documentation of the DOI plugin:
And here is the link to the source code of the plugin:
The task log is often helpful when it comes to understanding why a task is in which status, what previous communication has already taken place and what may have gone wrong.
Until now, the task log was only displayed as a small box within the tasks, which made it difficult to read the events comfortably when there was a lot of content. For this reason, the task log box is now expandable and takes up the entire width of the browser window. In addition, it displays all content in such a way that scrolling within the box is no longer necessary.
The current version number of Goobi workflow with this release is: 21.09. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Outsourcing of some statistics to plugins with refreshing of the user interface
Implementation of a new search syntax
Revision of the internal folder structure to comply with the Maven convention
Expansion of the plugin documentation
Goobi now supports the conversion of the metadata format LIDO to METS. For example, it is now possible to import a LIDO file and save it internally as a METS file. In the same way, an existing METS file can also be exported again as a LIDO data set.
https://gitea.intranda.com/intranda/ugh-extension/commit/e9ce2e551e644f9e20ab6caf69c08f60ec37b48d https://gitea.intranda.com/intranda/ugh-extension/commit/f3b6864a867c28567c8c76af89436daaa6fc65f4
Previously, images in LIDO were expected as <linkResource>
within the <resourceRepresentation>
element:
With this month's developments, it has now become possible for images to be specified as <resourceID>
instead. This is particularly helpful for data transfer from the MuseumPlus application:
Please note: If an image belongs to a sub-element, the specification must be made within the <lido>
element that describes this sub-element.
https://gitea.intranda.com/intranda/ugh-extension/commit/183ef6f4b93a8b0becd0627df8094babce1a32ef
Recently, we had extended the so-called variable-replacer to the effect that it now also allows IIIF URLs for the corresponding images of a process in script calls. We had to make some corrections here so that the encoding of the URLs fits the respective use cases.
https://github.com/intranda/goobi-workflow/commit/b887afbc47b8871588e0c1f2d7275981e1141eab https://github.com/intranda/goobi-workflow/commit/1715a8603f476141b1c13d58385f51bc8641dff8
The vocabulary management in Goobi workflow makes it possible to manage controlled vocabularies in the user interface and to use them as choices for metadata fields in the metadata editor. A particularly practical feature is that the description for a particular entity can be changed and, by linking to only one vocabulary entry in the METS file, the entry is also automatically updated in all processes. Because of these advantages, vocabulary management is being used in more and more projects.
A problem can arise when using the vocabularies if, after exporting the data, Goobi viewer also needs to access the same vocabularies, as the Goobi workflow installation is often inaccessible from outside the facility network because it is located behind a firewall. For this reason, we have developed a new vocabulary server to which Goobi workflow mirrors all changes to the vocabularies configured in this way. In such a case, the URL of the data records in the publicly accessible vocabulary server, which is hosted by intranda and accordingly accessible worldwide, is entered in the metadata of the METS file. This means that the Goobi viewer can then access the vocabularies without any problems and always receive up-to-date data records from the vocabulary.
The code for this server has not yet been published and can be found in the intranda-internal Git repository: https://gitea.intranda.com/intranda/goobi-authority-server. The still internal documentation can also be found there in the repository: https://gitea.intranda.com/intranda/goobi-authority-server/src/branch/master/goobi-authority-server/docs/AuthorityServer.md. We have not yet decided when to publish this project. Before that, we would like to review the source code and also prepare and translate the documentation.
Since the first days of Goobi, there has been the possibility to create processes based on a catalogue query and thus reuse the data from the catalogue. Unfortunately, however, the response from the respective catalogues is sometimes not such that Goobi can reliably interpret, for example, the publication types from the expected fields. For this reason, it has long been possible to manipulate the catalogue response with the so-called Beautifier before evaluating it. This was already possible in the past with PICA records. What is new is that these possibilities now also exist for MARC records. Such a configuration could look like this, for example:
In this example, the leader at position 19
is replaced with a space (\u0020
) if the value e
is in the leader at position 6
.
This example shows how to create the field <controlfield tag="999">
with the value KXP
for a record of an OPAC query.
This example shows how a field content can be changed. Here the field 041$a
is replaced with the value ger
if it contains the value lat
.
The following URL documents the configuration for catalogues and also the definition of the Beautifier:
https://github.com/intranda/goobi-plugin-opac-marc/commit/13de8118b5aff7c3a82127d0d01a31cdf0a5edc1 https://github.com/intranda/goobi-plugin-opac-marc/commit/930386f0838e462ce5d31c1567beb00bc4b637f4 https://github.com/intranda/goobi-plugin-opac-marc/commit/54d86f5246d3cad5b4f437d22a70ef0aee39d67b
And the wild ride continued this month as far as accessibility optimisations are concerned. One gets the impression that this is a life task. But at least it feels like we are on the home stretch. Let's see how it looks next month. :)
https://github.com/intranda/goobi-workflow/commit/bcc76fa67841af7a7fe2a50a1fe3398c12554d1c https://github.com/intranda/goobi-workflow/commit/70f65c14ab97a2394a7d5b0d7baa98c6bc433af2 https://github.com/intranda/goobi-workflow/commit/b6bd4dad318910aa8d0aa98a8e8ea0d54ba469a3 https://github.com/intranda/goobi-workflow/commit/17b88937cc79b71c1914533aa85b3685c5ca01fc https://github.com/intranda/goobi-workflow/commit/5806a5e8e5e011d2ac5ac6c68da2dfa950ec4a01 https://github.com/intranda/goobi-workflow/commit/106283895a5604de04c809d2e3a7bcfa99d8fc93
Compiling Goobi workflow is no longer limited to the already quite old version 8 of Java. Instead, from now on not only operation with Java 11 is possible but also compiling.
For those who would like to compile Goobi themselves, here is a mini-summary of how to do it yourself:
https://github.com/intranda/goobi-workflow/commit/2049aa3ff998b4be5d11a8d792d8287cd65bafa7 https://github.com/intranda/goobi-workflow/commit/7cdde2381c9e0ce2d5bd9eb741b2f82c3f4d7fe3 https://github.com/intranda/goobi-workflow/commit/0138cc4c39a6985094e0f61d1c3adce71d1990c6
JSON Web Tokens (JWTs) are being used more and more in Goobi workflow to allow other programmes or people to perform certain actions for a certain time. Until now, a JWT-Secret
had to be pre-configured manually in order to be able to use this functionality. As of this month, Goobi workflow generates the JWT secret itself if it has not yet been pre-configured.
https://github.com/intranda/goobi-workflow/commit/35b13272d0f514b156eff0627783a87c258f60be
During the implementation of the automatic generation of the JWT secrets described above, a potential security gap was discovered: The JWT keys were not rotated, which could have allowed an attacker to guess the secret if many messages were intercepted. This has now been changed and the keys are rotated every 24 hours.
https://github.com/intranda/goobi-workflow/commit/8441eadb77d075d24ba6c448d2ceb27a3c189589
It happens very rarely that file names of images of individual processes are renamed bypassing Goobi, so that Goobi was previously unaware of these renaming changes and this could lead to problems when re-exporting the METS files.
With an adaptation of the standard export, we now circumvent this problem. Because in the case of the project configuration that the METS file should dynamically generate the file names depending on the recognised MIME type (e.g. image/jpeg), an update of the internally stored file names changed in the meantime is now also carried out within the METS file. In this way, such potential errors in the case of renaming carried out independently of Goobi (e.g. adjusted upper and lower case, changed file extension) are intercepted.
https://github.com/intranda/goobi-workflow/commit/e58838f80e6bd24fc48e649602eca004ecd1a5ec
Less spectacular for non-programmers sounds an elaborate change we are currently making internally for further code optimisations. We are currently using the Lombok program library even more for code generation of boring, bloated but unfortunately necessary source code, which by convention has to be within Java applications.
For those readers who are Java programmers themselves: Lombok is definitely worth a look and takes care of the automatic generation of getters, setters, constructors and a lot more.
https://github.com/intranda/goobi-workflow/commit/17a0d32698c2c941cc7ec47317b08e0904dac756 https://github.com/intranda/goobi-workflow/commit/ef797453faf8c83a5bb6cd5096d04106cbebae18 https://github.com/intranda/goobi-workflow/commit/a3ee13e8559eceb29f059557fdf80bb093bf73fd https://github.com/intranda/goobi-workflow/commit/5eb5eecb3dfe7e4bc103cd061b64d2b13dc17384 https://github.com/intranda/goobi-workflow/commit/afd5b82169ed063da7586ed9c329c5465785336f https://github.com/intranda/goobi-workflow/commit/93b8d5cc45897e949322b79a8e3a7634bc1396c2 https://github.com/intranda/goobi-workflow/commit/16e903327281e247d6e3da84c4bf6224d89175f3 https://github.com/intranda/goobi-workflow/commit/665f4bd3e2d9b94d479f0fbdb89a0bea3f66d264
We have recently massively expanded the metadata groups. For a project in Croatia, we needed some rework here: It was necessary that metadata groups can also be duplicated, so that they now correctly duplicate all associated metadata, persons and subgroups. This saves some unnecessary manual editing.
https://github.com/intranda/goobi-workflow/commit/4ae3035f0e6e1582d68235fd71a22fde8079b0b9
Developments and news about Goobi workflow
Performance optimisations for very large data sets
Development of a new capture plug-in for integration with Atlas AEON
Development of a plugin for simultaneous processing of metadata from multiple processes
Development of a new configuration editor
The development of a plugin for combining the processing of archive holdings with the possibility of selectively digitising them is arousing more and more interest and is already in productive use in several institutions. In this context, areas naturally come to light that should be readjusted in order to be able to cover further purposes:
Previously, it was possible to select individual record within the archive management plugin in order to create a process for them, which then runs through its workflow. What is new now is that this is also possible for an entire range of records.
To do this, one simply selects a parent node from the inventory and chooses the process template to be used. A new process is then created for each record for which no process exists yet and allows it to be processed.
In addition to the new functionality described for creating processes, there were also some minor changes in the operating logic. Especially when there was no archive record group yet and therefore a completely new record group was to be created, there was a need for improvement, which we tackled.
Accordingly, adding new record groups is now easier and also more comprehensible in the event of problems occurring.
A feature that we have all been wishing for for a long time has finally been implemented: Working in Goobi within multiple tabs or browser windows.
In the past it was a common problem that users of Goobi workflow tried to enter information from one project into another project and wanted to work with several windows at the same time. However, this used to be problematic because Goobi could only load one such element at a time in the background. For this reason, the last object entered was always the one loaded in the background and saved accordingly. In the past, this often led to great irritation. Now, however, this restriction has been removed so that it is possible to work with the same browser in the same session and with several tabs.
There is still one restriction: At the moment, a maximum of 64 tabs can be used simultaneously with Goobi. If one day this should be too little, we can increase the value to a maximum of 1024 tabs. :)
We have been using Java 11 for the development of Goobi workflow for some time now. Even with new installations and updates, the installed systems are now converted to Java 11.
From 1 September 2021, we will make Java 11 a mandatory requirement for all systems. If a system has not yet been updated to Java 11, this must be done after this date at the latest with the next Goobi workflow update.
Until now, processes that do not contain an explicit export step in the workflow could still be exported via the administrative views (e.g. using GoobiScript). However, as this behaviour was not always desired for materials with IP rights, we have made a change here and adapted the behaviour. Exports are now only possible for processes if they also contain a workflow step that is marked as Export
.
This change has been considered for the following areas:
GoobiScript for performing mass exports.
Button in the task listing
Button within the task details
The command plugin for exporting
Within the process list of Goobi workflow, various extended functions have been available for a long time. Among other things, you can generate and download the dockets. The internal log file of the selected process could also be generated here. However, until now it was only stored in the user's folder within the server file system, so that accessing it was quite cumbersome. This has been adjusted. The log file can now be downloaded in the same way as, for example, the routing slip and a complete PDF file of the respective process.
We have developed a new plugin to simplify the transfer of images. This is especially interesting for mass imports. The need arose for us in order to take over the pictures after the automatic creation of processes from a previous archive stock of an EAD file in the archive management plugin, which were listed within the EAD file in a metadatum, however, in an incomplete form. With this plugin, it is therefore possible for such information to be evaluated, split up on the basis of separators and then provided with additional path information in order to actually take over the files afterwards.
Documentation for this plugin has not yet been published and will follow in the next few days. The same applies to the publication of the plugin on Github.
When editing the details of a user, it has always been possible to specify which project and user group the user should belong to. At this point, the button for adding user groups and projects was previously displayed even if the user already belonged to all existing groups and projects.
The user interface has now been adapted so that the buttons for adding users are only displayed if they can also fulfil a function, i.e. if there are still user groups and projects of which the user is not yet a member. This has once again made the administration of users somewhat easier.
The advanced search for batches makes it possible to find all processes of a certain batch. The search syntax for such a search looks like this, for example:
This search finds all processes that are in the batch with the ID '42'. The opposite of this search, i.e. all those processes that are not in batch 42
, was not possible until now. This new search option has now been implemented and looks like this:
The extension of this search option is also already documented within the Goobi manual:
For a project it was necessary to harvester EAD files from an OAI interface. For this purpose, we developed a new plugin that creates processes in Goobi workflow for all data of the configured interface, if they do not already exist.
During the execution of the plugin, the metadata is selectively transferred to METS according to a configuration of XPath expressions.
Documentation for this plugin has not yet been published and will follow in the next few days. The same applies to the publication of the plugin on Github.
Since not too long ago, Goobi workflow has had the option to allow multiple institutions, each with their own administrators, to work in one instance. However, since such a way of working is very rare in everyday life, we have now made the display of institutions a little more dynamic.
From now on, institutions will only be displayed within the listings of users, groups and projects if more than one institution has been configured. This makes working with Goobi a little clearer again at this point.
In the user administration, it was previously only possible to search for the name of the user. With the latest changes, it is now possible to search all other fields as well. In addition, sorting is now also possible across all columns of the user table.
In the past, there was often confusion among Goobi users who wondered about unknown IPs in the list of logged-in users or the display of unknown active sessions. In the past, security problems were also wrongly feared here. To avoid this confusion in the future, the list of sessions is now filtered for the display of active users and only those are displayed who are actually logged in. This way we avoid potential misunderstandings and misinterpretations that could result from the display.
In the area of the metadata editor, there were again many changes, which we would like to briefly discuss here:
Thanks to the support of @hemed from the University Library of Bergen, Goobi is now able to search the authority database KulturNav, which is very popular especially in Scandinavia, and to take over authority data from it. This development was actually the first major pull request we have received on GitHub from an external developer.
Here you can find the technical details of the development together with the extensive communication between the developers involved:
Thanks to you @hemed for this great collaboration and your contribution to Goobi workflow!
There was a small inconsistency in the top menu of the metadata editor when moving the mouse over the single image/thumbnail buttons. The display has been adjusted and should now behave as expected.
When displaying thumbnails during pagination, there were undesired scrolling effects when clicking on an image. This bug has been fixed.
In the metadata editor, there are some actions that immediately save the METS file. Examples of this are, among others, the two buttons that reset the pagination or recreate it based on the image files that actually exist. This behaviour often hits users unexpectedly and therefore a warning is now displayed before performing these actions that the changes are saved directly and can only be undone by an administrator.
We have also made some changes in the area responsible for creating processes:
In the event that unexpected errors occur during the creation of processes, more detailed information is now provided on the errors that occurred. With these adjustments, incorrectly created processes should occur even less frequently.
We have also made a similar adjustment for the case that, for example, no metadata file 'meta.xml' could be created due to special ruleset configurations. Here too, a helpful error message is now displayed and prevents the incorrect creation of a process without a metadata file.
If projects are set to inactive, from now on the buttons for creating new processes in the production templates will be displayed in red and provided with a warning that the associated project is deactivated. In addition, the project name is also coloured grey to indicate that it is deactivated.
When creating new processes, the user who created the processes was also registered as the last user in all workflow steps, even before the processes were actually processed. In the past, this did not cause any problems, nor did it have any undesired side effects. However, we found it irritating and have now improved it.
The extended dashboard is super popular and used in almost every Goobi installation. Here we have made some adjustments this month:
The dashboard usually shows a chart that visualises the number of processes added in the last few months. Until now, all processes were listed that were available in the Goobi instance. With a change at this point, the diagram now behaves a little more helpfully: from now on, only those processes are taken into account in the diagram that are in projects of which the user is also a member. This is much more intuitive for the user.
As helpful as the dashboard is and as much as it can display; sometimes some of the widgets are not filled with data because they are simply not available. However, we found it unattractive that empty widgets were then displayed. For this reason, the display has now been revised and hides empty widgets.
There were again numerous smaller adjustments in various areas that should not go unmentioned.
Due to the changeover to buttons for accessibility reasons, the task titles in the task lists could no longer be marked in Firefox. This was inconvenient if you wanted to copy such a title to the clipboard. For this reason, we have made a change here so that this is possible again.
When a process is renamed in Goobi, all directories in the process directory are renamed in the background to match the new process name. Previously, symbolic links were omitted. This has been changed and from now on symbolic links will also be renamed.
Within the task details, consistent mouse-over texts were not displayed for all buttons. We have standardised this.
The current version number of Goobi workflow with this release is: 21.07. Within plugin developments, the following dependency must be entered accordingly for Maven projects within the pom.xml
file:
Developments and news about Goobi workflow
Final work on the archive management plugin
Extension of the Flex editor for provenances
Extension of the vocabulary management
Goobi workflow has supported various authentication methods for some time, including authentication using OpenID. Now, another very generic solution has been added, which evaluates HTTP headers of a request. This implementation has the great advantage that it can be used for many different scenarios, since the actual authentication can be left to external Apache modules. In this way, for example, authentication by means of a CAS is possible.
In order to provide a better overview of the different types of user authentication, we have created a new section in the documentation that lists the different configurations. The documentation can be found here:
Neben der Authentifizierung über die Datenbank, eine Anbindung an LDAP-Server und Active Directory, OpenID ist damit nun auch eine Anbindung an zahlreiche weitere Single-Sign-On-Systeme möglich.
The navigation for the display of thumbnails in the metadata editor has been revised. From now on, the navigation buttons are fixed in the upper area and remain visible even when scrolling down.
In addition, when switching from the large image view to the thumbnails, the system now scrolls directly to the currently selected image. This saves searching for the last image used in the future.
A description for the Goobi REST API is now available using Swagger UI
. This is a very common interface description that allows developers to try out the REST API of Goobi workflow with their own commands and thus implement a connection of external applications to Goobi workflow.
More information about the possibilities offered by interface documentation via Swagger can be found here:
This new interface description can be accessed within Goobi workflow via the Administration menu and from here immediately allows interactive testing of individual commands directly in the web browser:
The topic of accessibility has been with us for several months now and is proving to be very time-consuming. Nevertheless, we have now been able to achieve our ambitious goal of successful validation by means of two well-known browser plugins that check websites for compliance with the WCAG guidelines at level AA.
Especially the revision of the user interface for the metadata editor turned out to be quite complex. In addition to the typical requirements regarding colour contrasts, icons and help texts, we also took another look at the tab sequences, among other things.
The issue of accessibility is not finished for us with this work. We will continue to routinely check the user interfaces and will certainly have to adjust some plugins in this context. With the work described here, however, we have reached an enormous milestone for a accessible user interface for Goobi workflow.
Within a project, the requirement arose that the entire digitised object as well as each associated file had to be provided with its own identifiers, which were queried by a central service and subsequently had an influence on the naming of the files as well as being stored within the METS file. For this purpose, we have developed a new plugin, the OID-Creation-Plugin, and documented its installation and configuration here:
The source code for the plugin can be found as usual on GitHub published here:
In order for the OID identifier generation procedure described here to be used for the further workflow, the package export plugin also had to be extended.
This has been extended to support OID, the generation of UUIDs as well as for a validation of previously generated checksums for the individual image files.
We have developed a new plugin for transcribing content on images. It is still manageable in terms of its range of functions and does not yet allow the recording of coordinates for words or letters. It does, however, allow existing plaintext full texts to be edited or to be captured from scratch.
A detailed documentation of the new plugin can be found at this URL:
The source code for the plugin has been published on GitHub here:
If a project title contained a single inverted comma ('
), its processes could not be opened and edited correctly. This error has been fixed.
Developments and news about Goobi workflow
Implementation of an ALTO editor for editing full texts
Extensions to the dashboard
Adaptations to the caching
The metadata editor now allows metadata groups to be created within other metadata groups. This is of particular interest for museum content, for example, to be able to correctly map data from the LIDO format. To implement this functionality, the metadata library ugh has been massively extended and the metadata editor in Goobi has also received a few lines of new code. In addition to groups within groups, repeatable fields, mandatory fields, duplicating or deleting individual fields or subgroups and the evaluation of the DefaultDisplay="true"
directive within groups are now supported.
Unfortunately, the major issue of accessibility is still with us. But if you want it to be good, you have to have stamina. So this month we have again made many small, inconspicuous but sensible adjustments. First and foremost, it was once again a matter of converting other previous links to buttons.
By the way, here are some exciting links on the subject of buttons vs. links:
For a Swiss project, it was necessary for Goobi workflow and Goobi viewer to better handle digitised works that are already available as double pages. The particular difficulty was that such double pages should only be present in isolated cases within digitised works, but the page-turning logic within the viewer is then not affected by this and allows a double-page display for single pages just as seamlessly as it does a correct display of the individual double page.
In the metadata editor of Goobi workflow it is now possible to mark double pages as such. On the one hand, this concerns the marking of the page in order to classify it correctly within the METS files. On the other hand, the pagination options have also been extended so that there are now options for double page counting.
In the final result of such a generated METS file, the information captured in this way is correctly labelled and can be traced there. The Goobi viewer can then deal with it accordingly and allow the image to be displayed correctly for this purpose.
After we have recently reimplemented some of the processing of metadata groups, we noticed that the previous search for metadata groups was not yet possible to the desired extent. Therefore, we have now extended the indexing of metadata to include those of metadata groups.
This can be illustrated quite well using a concrete example. For example, a metadata group is configured in the rule set as follows:
This could then be filled with such information within a concrete process:
A search query like this can now be used to search for one of these fields:
You have probably heard about the increasing use of IIIF. We already use it a lot, especially in the context of Goobi viewer. Recently, however, it became apparent that we could benefit from this even more in the context of Goobi workflow. We have therefore extended the so-called VariableReplacer so that, in addition to common variables such as the process ID, metadata from the METS file and directory paths, it can now also generate the associated image files of a process as IIIF image URLs. This is practical if, for example, an external application or a script is to have access to all image files of a process in order to carry out processing on the basis of them.
This is used in the same way as other variables, e.g. in calling scripts:
The following two variables are available:
The return of such a variable looks, for example, as follows:
More information on the use of the VariableReplacer can be found in the Goobi manual at the following address:
When displaying active users within the Goobi workflow user interface, users were occasionally listed whose session had already expired or who were still displayed for other reasons. This was particularly annoying when we wanted to maintain the systems and take into account the supposedly active users. On closer analysis, we found a Goobi error here, which we were ultimately able to rectify. This means that ghost users are now a thing of the past.
For an institution in Luxembourg, we were required to automatically import a large dataset of files into Goobi, while also enriching the existing dataset that was in an EAD file.
The plugin we have developed for this purpose is still very much tailored to the specific use case of the institution and thus not yet directly applicable for other use cases without adaptations. However, if there is interest in such imports, we can develop this plugin further and make it generic. In the next few weeks we will publish and document this plugin together with many other plugins. Until then, please let us know if you are already interested in the plugin.
After having recently developed a plugin that enables handle registration with the EPIC service of the GWDG, we have now created another similar plugin. This is now the possibility to register works with Datacite in order to receive DOIs for them. It should be noted that DOIs are always assigned for publications, not for structural elements or even pages. With the extensions that will be made to the Goobi viewer in the near future, however, granular URLs, for example for pages, can also be made possible there on the basis of so-called web fragments.
The source code of the plugin has been published here on GitHub:
The detailed documentation on installation, configuration and operation can be found at the following address:
Internally, there was some major work this month, which is visually less noticeable and may seem less important to most users. In terms of content, however, such work is necessary from time to time in order to stay up-to-date with established software and to adapt to technological developments in order to remain compatible in the future. This month, therefore, some of the established programme libraries for processing XML files have been updated and tested. This mainly concerns libraries such as saxon, poi, xerces, xmlbeans and jaxb. In the best case, this results in the user not noticing any change and everything continues to work as usual.
By the way, another interve change we made also concerns the use of so-called session storage variables. There, both Goobi workflow and Goobi viewer had inadvertently chosen the same name. As a result, the scroll state was the same across both applications and some users were surprised to find that the metadata editor scrolled unexpectedly and as if by magic, because they had previously scrolled in the Goobi viewer. We have fixed this unusual error with the update.
Developments and news about Goobi workflow
Extension of LayoutWizzard functionalities
Extension of the documentation for many existing plugins
Implementation of metadata transfer from images
Extension for handling corporate bodies
Over the course of several months, we have developed a comprehensive new plugin for processing archival records. This plugin allows the capture of metadata for very extensive archive holdings within EAD files. It not only allows existing extensive archive holdings to be processed and selectively digitised. It also allows data to be entered as new holdings.
Internally, the objects, their metadata and the hierarchy of the objects among each other are stored in a standardised EAD file, which can also be downloaded from the web interface at any time.
For each node within the fonds, the metadata are subdivided into different areas (identification
, context
, content and internal order
, access and use conditions
, related documents
, annotations
, directory control
) according to the ISAD(G) standard and, thanks to the intensive cooperation with the MNHA in Luxembourgh, are also immediately available in German, English and French.
The structure of the entire tree can be changed very easily from the plugin's interface and individual nodes of even extensive stocks can be searched quickly. For the user interface, we have again resorted to the display of so-called badges. They allow a quick overview of the possible and also already used metadata per area of each node. In addition, the freely configurable validations highlight very clearly the points in the metadata where adjustments may still be necessary.
The detailed documentation of the plugin can be found at the following URL:
The source code of the plugin itself is available at the following URL:
The Vocabulary Manager has been used quite a lot since its release, first as a plugin and then as a core component of Goobi workflow. There are already early Goobi users, with several thousand records per vocabulary. However, it was also noticed that the handling of the vocabularies was not yet optimal, especially with large data sets. Therefore, we have now implemented a tabular display of the data records in the left-hand area, which allows sorting and searching in the columns. All in all, the operation of the vocabularies has not only become more intuitive and clearer, but also much better performing.
Within the administration of the vocabularies, it is possible to define which fields each vocabulary has, which type each of these fields should have and now also whether it should be displayed as a searchable and sortable column within the vocabulary.
Often, the contents of vocabularies initially come from other systems. Therefore, the vocabulary manager has an import mechanism for Excel files. We have also made some extensions and adjustments to this mechanism. For example, in future it will no longer be possible to completely overwrite existing vocabularies but to add to them, for example if data is to be imported again at a later date.
In this context, we have also reworked the routines for importing in order to be able to import even very extensive vocabularies in a performant way.
We have once again made some changes to the pagination within the METS editor of Goobi workflow. This concerns, for example, the functionality for the creation of Roman page numbers, so that now not only capital letters (X, V, I, etc.) can be used for Roman pagination but also small letters (x, v, i, etc.).
If you hold the mouse pointer over the respective elements, the name of the associated image file is now displayed as a tooltip.
Furthermore, the display of the assigned pagination has been revised to make it more readable. This has been adapted both in the middle area of the METS editor and within the pop-up that appears when the mouse pointer is held over the structure elements in the structure tree on the left-hand side.
In this way, the pagination information has become much easier to read and can also be better distinguished from the image number.
Whether from the terminal to check that no users are logged in before a restart, or for general monitoring: this new REST endpoint is simply practical. Under the URL https://mygoobi.tld/goobi/api/currentusers/
, a JSON-encoded list of currently logged-in users can be queried:
The Excel export of executed GoobiScripts has been slightly enhanced. It now also lists a timestamp and the name of the user who started the GoobiScript.
A new workflow plugin has been implemented that allows a mass upload of images and automatically creates Goobi processes based on the file names used. A configuration file can be used to control which naming scheme the files have to match in order to recognise them as belonging together. It is also possible to specify which process template is to be used and as which publication type the processes are to be generated.
The detailed documentation of the plugin can be found here:
The source code for the plugin can be found as usual on GitHub published here:
In the context of a project with a city archive, the need arose to extract metadata from image files. For this reason, we developed a step plugin that takes the first image of a process, reads selected metadata from it and transfers it to Goobi according to a configurable mapping. This then allows this information to be edited within the metadata editor and also displayed within the Goobi viewer.
How such a mapping is configured can be seen in this configuration file as an example:
More information about the functionality of the new plugin can be found in the documentation here:
The source code of the plugin was published here:
There have been some minor adjustments and improvements to the core of Goobi workflow for various areas. Among others, the following areas were affected:
When clicking on the Cancel
button when creating facilities, a message incorrectly appeared stating that the institution name was a required field. This has been corrected.
When editing institutions, contents of text fields were reset when the values of checkboxes were changed. This behaviour has been corrected.
Creating new users was not always successful due to changes in authentication options and has been fixed by revision.
The display of the processing status of message queues was incorrect in the case of deactivated message queues, so that a new login was necessary. This was also corrected.
Developments and news about Goobi workflow
Extension of the processing of GoobiScripts
New rights management for the execution of GoobiScript
Better support for corporate bodies and metadata groups
Flex editor for capturing manuscripts and more
We have extended the search options so that it is now possible to find processes by their creation date. The search syntax is as follows.
It is also possible to filter for processes created before or after a certain date (or even time):
These new search parameters thus also allow processes to be searched for a period of time:
Analogous to the new search options for processes, it is also possible to filter by workflow steps. Here the distinction is between stepstartdate
as the time of the start of processing and stepfinishdate
for the time of the end of processing.
To filter for the end of processing, the status of a step must also be searched for in the same search query. This looks accordingly as follows:
The following filter searches for processes where Scanning
and Export
were completed in 2021:
The use of the search has been adapted to the new possibilities within the documentation and can still be found at this address:
The functionality of the Change Workflow plug-in has been extended. From now on, not only the status of tasks can be changed, but also the assignment of user groups. A configuration for this looks as follows, for example:
In addition, with this update, properties of the processes can no longer be checked for their values alone. Instead, all available values that can be expressed as variables can now be used. From the previous configurations in this form:
such wording must now be used in the configuration files:
Further explanations about the possibilities of the variables can be found at the following URL:
The updated documentation for the Change Workflow plugin can be found here:
In several projects, the requirement arose that metadata within the METS file should be dynamically updatable. For example, it should be possible to generate metadata for hierarchically subordinate structural elements and, if necessary, enrich them with data from other structural elements or properties.
As with many other plug-ins, this plug-in has been kept quite generic and can be configured very individually depending on the purpose and workflow. Such a configuration looks like this, for example:
In the case of this configuration example, several different data are inserted consecutively into the field 'TitleDocMain' within monographs. These are field contents from the Mets file, static values, timestamps, counters and other types. Such combinations can also be used for deeper structural elements and thus allow very flexible application possibilities.
The detailed documentation of the plugin has not been written yet and will follow soon. The source code of the plugin itself is available at the following URL:
By switching to current technologies (CDI, JSF 2.3), websockets can now be used in Goobi worflow. These enable a high-performance bidirectional communication between server and browser. This means that we are now able to send messages to the user from the server side. A first use case where this is applied are the following two areas:
Administrative messages that are to be displayed to all users are now immediately displayed to all users, not just at the next reload.
The progress of GoobiScript executions is displayed live, without the need for a manual reload to update the progress bar.
When a message in a message queue repeatedly generates errors, it is marked as undeliverable and sent to another message queue, the "dead letter queue". Goobi now monitors this "Dead Letter Queue" for messages and sets the step associated with the message to error status so that a human user can view the error.
The most frequently used dashboard has received a helpful enhancement. There, it is now possible for those tasks to be listed that the user completed last. In addition to the display of which tasks the user is currently working on, there is now an immediate view of the recently completed tasks.
At the same time, a frequently expressed wish was realised: Recently completed tasks that have already disappeared from the task list and have progressed further in the workflow can also be undone from the dashboard in order to process them again. However, this is only possible if the subsequent task has not already been accepted for processing by a user or started by an automatism.
The mostly sequential order of workflow steps basically allows a very good overview of the sequence of tasks involved and their progress. However, we found the operation too cumbersome if the sequence of tasks should be changed or new tasks should be integrated between existing tasks of a workflow. Therefore, some major changes were made here. In the revised user interface, tasks can be moved by means of the arrow icon so that the corresponding sequence numbers of the workflow steps concerned are automatically adjusted without having to change the sequence numbers manually.
The second major innovation in this context is that new tasks to be integrated into an existing workflow are automatically given a correct sequence number, so that the new task is automatically placed correctly at the end of the existing workflow.
If, however, a sequence number is specified at this point that lies in the middle of the workflow, the already existing tasks are automatically shifted by one position each in order to insert the new task in between. However, this behaviour can also be prevented if desired, so that parallel execution of tasks is still possible.
To benefit from these new developments, this logic has also been extended to the execution of GoobiScript. For this reason, a new GoobiScript exists that allows the insertion of tasks into the workflow, taking into account the correct sequences to be changed for inserted tasks, even in bulk.
For the use of the new GoobiScript, see the relevant section within the Goobi workflow documentation:
Developments and news about Goobi workflow
Extension of metadata group support
Flex editor for capturing manuscripts and more
New pagination type for double pages
Markup of double pages in METS
Support for IIIF URLs within the Variable Replacer
GoobiScripts have become an indispensable part of the Goobi user's toolbox. However, although they are extremely practical and helpful, there were always problems with stuck queues or high system load when many GoobiScripts were waiting to be executed. There were also problems with parallel execution from time to time. These problems are now all a thing of the past, as the internal GoobiScript management and execution have been completely rethought and implemented. As a result, GoobiScript is now more efficient than ever before.
Goobi workflow allows GoobiScript to perform extensive operations to influence processes, their workflows, metadata or other areas, and to apply this uniformly to thousands of processes at once. In this respect, GoobiScript is often a great help when it comes to mass changes. Unfortunately, in the past these options were only available to a very limited group of users, as GoobiScript could of course also be used to inadvertently intervene in the processes in a major way, which meant that often only administrators had access to GoobiScript.
With the new developments in the rights system of Goobi workflow, there have been some improvements in this respect, so that it is now possible to grant individual user groups selected rights for the execution of defined Goobi scripts. In this way it is possible, for example, to allow users to execute the GoobiScript for performing the export even for many processes, but not other Goobi scripts such as changing metadata or intervening in the workflow.
The configuration of these rights is kept relatively simple. Individual commands can be specifically added here in the user group area, as can be seen in the following screenshot.
The revised rights management for controlling access to GoobiScript is clearly described within the Goobi manual. You can read about it here:
By the way, we have also significantly revised the documentation of the GoobiScripts in general to better explain their execution and operation. This documentation can still be found at the following address:
The fact that computationally intensive or time-consuming automatisms can be executed via a so-called message queue is still relatively new and brings enormous advantages, especially for larger projects, because in this way, for example, the calculations can also be distributed over several servers. What we have revised here is that tasks that got stuck during processing because one of the available queues was not accessible no longer remain in an uncertain state. Instead, they are now set to a formal error status, so that their faulty processing becomes apparent and their execution can be corrected accordingly.
A completely new step status INFLIGHT
has been introduced. This new status is set when an automatic workflow step is to be processed on another system, is transferred there, but has not yet been picked up by the external system and is accordingly not yet processed. With this new step status, it is possible to check at any time how busy the entire system is and whether additional servers should be connected to process computationally intensive tasks.
For good accessibility, it is particularly important that HTML elements have the right semantics. For example, a <a>
(a link, or anchor) means that a new page is being entered and not that an action is being performed. A <button>
, on the other hand, indicates that an action is being carried out. For historical-technical and also visual reasons, every action in Goobi workflow was previously implemented as a link. In the course of the great accessibility efforts of the last few months, we have also made major changes here. All links that actually trigger an action and are not only used for navigation have been converted into buttons.
This change should not affect the appearance of the website for the user. If there are any functional surprises because one of the numerous changes did not go smoothly, we would be pleased to receive feedback so that we can make adjustments if necessary.
Long requested and now they are here: customisable validation messages in the metadata editor.
For the very granular controllable validation checks that can be defined within the rule sets, messages were displayed in the metadata editor in the past that were not understandable for everyone because they were too technical. With the developments in this context, these messages are now controllable and can be specified individually and multilingually within the rule sets. Within the rule sets, this looks like this, for example:
In the user interface, this message is then displayed accordingly in the event of a violation of the validation requirements, for example:
Goobi workflow has local translation files located in the configuration directory. The translations stored in these files overwrite the translations provided by Goobi workflow itself. In this way it is possible to use individual texts in each Goobi workflow instance that are to be displayed in the user interface.
Goobi always monitors these files for changes and reloads these local translations if anything has changed in the files. However, this routine only works if the files are already available when Goobi is started. In the past it often happened that Goobi had to be restarted just to change or display a translation. With the changes we have now made, Goobi also checks on start-up whether all the translation files it may need are available in the corresponding directory and creates any missing files automatically.
By means of a setting in the process details, the processing of automatic workflow steps can now be paused in individual processes. This is particularly useful if a work has been imported into Goobi workflow earlier than planned, but the rest of the workflow takes place fully automatically. By making this change, the automatic export that should not yet take place can be prevented by just two clicks.
In the menu Administration
there is now a new menu item Automatic Steps
. This makes it possible to group automatic steps into so-called "job types". These job types can then be paused. This allows several fully automatic processes to be paused at once at a specific point. When the job type is started again at a later time, all paused steps are started again.
Goobi workflow allows to authenticate requests to its API via JSON Web Token (JWT). Such JWTs are created by Goobi workflow itself and sent to a third party service, which later uses them to legitimise the execution of an action in Goobi. The use of such a JWT method has the great advantage that a JWT only ever authenticates a very specific endpoint (for example, to complete a single workflow step from a single concrete process). Furthermore, this approach allows such a JWT to expire after a certain time. Thus, the potential loss of a JWT is also much less problematic than the loss of a token or password that is valid indefinitely for multiple endpoints.
To use this functionality, a central JWT secret must be stored within the central configuration file of Goobi workflow goobi_config.properties
. For example, the configuration may look like this:
After several months of work, Goobi workflow now fully supports corporate bodies. These are now listed as a separate section within the metadata editor, similar to People, Metadata and Metadata Groups, and allow multiple associated metadata to be captured.
Of course, it has also been taken into account that the connection to common standards databases is supported. Correspondingly, it is now also possible to search for corporate bodies and transfer their data.
The definition of entities is explained within the central UGH documentation for processing metadata:
A central configuration file of Goobi workflow is the file goobi_projects.xml
. It primarily controls how the creation screen for processes should behave, which fields should be displayed and to what extent this should vary per publication type.
Basically, this configuration of Goobi is already one of the more complex files and not necessarily self-explanatory. In addition, up to now this configuration file has in principle allowed different configurations to be defined for different projects. To do this, however, the entire, usually very extensive blocks had to appear several times in the file, which often led to unnecessary redundancies and repetitions. With a change at this point, this configuration should now become somewhat simpler and avoid such repetitions. Therefore, the previous 'project' elements now allow a repeatable naming of several project names for which the respective section is to apply. A direct comparison makes it easy to see where the innovations are:
Previous configuration of multiple projects where the configuration for the 'manuscript project' and the 'archive project' is identical and differs from the 'default':
Future configuration of several projects to be treated in the same way combined in one block:
Documentation on the structure of the configuration file goobi_projects.xml
can be found at the following URL:
Developments and news about Goobi workflow
Flex editor for capturing handwriting and more
Extension of rights management for individual GoobiScripts
Enhancement of the dashboard
Better support for corporate bodies
Goobi workflow now has a new function for documenting damage that is already known when processes are created and is to be recorded by means of photos. This is particularly helpful when the works concerned are to be handed over to a service provider, for example, and thus the condition of the works is to be documented before handover. The photos and descriptions uploaded in this context are stored within the process log and can be viewed again at any time.
A positive side effect that has arisen as a result of the introduction of this new functionality is that from now on master images and other files can also be uploaded directly into Goobi when processes are created, without this having to happen in a separate workflow step. This should prove to be a practical innovation for small project teams in particular.
To activate this new functionality, the following block within the element <createNewProcess>
must be defined for individual projects within the configuration file /opt/digiverso/goobi/config/goobi_projects.xml
:
As soon as this function is activated, the Goobi workflow user interface adapts by no longer displaying the save button when processes are created, but instead displaying a button that leads to the next page.
If not only damage documentation is to be uploaded but also files are to be uploaded to selected folders before processes are created, the configuration can be carried out as follows:
If the user has clicked on the button to go to the next page, a global comment can be entered here that is to apply to all images. The files can then be uploaded.
After uploading to the selected folder, the images are displayed together with the associated commentary and saved with the process. The comments on the individual images can, of course, be individual for each image.
Please note that comments are only saved for those images that are uploaded to the folder 'internal' as damage documentation. Images that are uploaded as master images, for example, do not have the option of including a comment per file.
The new function for the damage documentation can be considered within the automatically generated dockets. Thereby, all uploaded images together with the associated comments are listed on the subsequent pages of the docket.
To activate this display in the docket, a block like the following should be added to the configuration files /opt/digiverso/goobi/xslt/docket.xsl
and /opt/digiverso/goobi/xslt/docket_english.xsl
:
The PDF file that Goobi can generate based on the metadata usually contains an image of the representative. This image was previously included in an uncompressed version, so that the PDF files were sometimes very large. This has now been changed so that the embedded images first run through a JPEG compression and are only embedded in the PDF file afterwards. In this context, an adjustment has also been made to the configuration of the layout of these PDF files. Accordingly, these changes must now also be taken into account in the Goobi installations during updates. Until now, this block was usually used in the configuration file /opt/digiverso/goobi/xslt/docket_metadata.xsl
:
From now on, this block must be adjusted with regard to the image path as follows:
The encoding of the file should also be adapted so that it is changed to utf-8
:
The standard docket of Goobi workflow also needs a change within the configuration for the correct display of the internally renamed creation date for the process. Until now, this expression was usually used in the configuration files /opt/digiverso/goobi/xslt/docket.xsl
and /opt/digiverso/goobi/xslt/docket_english.xsl
:
This expression must be adapted as follows:
And also the encoding of these files should be adapted so that it is changed to utf-8
:
The batch docket also needs a change in the configuration for the correct display of the creation date for the processes.
The file /opt/digiverso/goobi/xslt/docket_multipage.xsl
used to contain this value:
This expression must be adjusted as follows:
Again, the encoding of the file should be adjusted to change it to utf-8
:
For some time now, Goobi has had two different plugins that allow catalogue polling to be carried out in the running workflow or even periodically, so that metadata can be imported or updated. These two plugins have been thoroughly extended once and their documentation has been adapted. A new time control has been implemented for the Catalogue Poller, which allows specifically defined datasets to be updated at configurable intervals. In addition, both the 'Catalogue Poller' and the 'Catalogue Request Plugin' have been extended so that queries can now also be made to the catalogue for sub-elements in order to update them.
How exactly the configuration must be set up in order to be able to use these new functions is explained in the respective documentation of the two plugins.
Here you can find the new detailed documentation of the Catalogue Request Plugin:
And here is the updated documentation of the Catalogue Poller:
With GoobiScript, Goobi workflow has for some time now had a mechanism to be able to modify even large lists of processes in bulk. This can include performing exports, making changes to workflow status, adding metadata within METS files and much more. Over the years, numerous GoobiScripts have been added, each with new functions, which we also explain in detail on a separate documentation page. Nevertheless, in the long run we found the structure of the commands not to be the right way, so we decided to make a major change here. Instead of the previous syntax, GoobiScript now uses the YAML language to define Goobi scripts. The structure of the commands is therefore a bit different than in the past. However, the change brings several major advantages.
On the one hand, the display of the commands now has syntax highlighting, so that reading and writing the Goobi scripts has become much clearer thanks to the formatting and colours. And secondly, all Goobi scripts now come with their own embedded documentation including examples, which is listed above each parameter. This makes it even easier to calculate how to use a specific command.
Another enormous gain of the conversion to the new YAML format is that we can now also very clearly combine different Goobi scripts one after the other in the same call by listing them one after the other with the separator line.
The documentation supplied can also be simply removed for a better overview:
The documentation for using GoobiScript can be found here, where the operation and possibilities are explained in detail:
A new GoobiScript has been developed that now allows new workflow steps to be better integrated into the workflow. With this command it is now possible to specify the new target position within the workflow that is still occupied by another workflow step. By calling this command, it is now possible that the new workflow step is inserted at this desired position and all subsequent workflow steps are moved to the correct positions accordingly.
The documentation for the new GoobiScript can be found here:
The technical infrastructure of Goobi workflow has been changed to CDI. This change was necessary in order to be able to provide Goobi workflow with important security updates in the future. In addition, this change opens up some new technical possibilities, such as the use of websockets. With websockets, the server can proactively inform the client (i.e. the web browser) about changes. This new technology is extremely practical for longer-running tasks such as imports or the Goobi scripts, for example, to keep the user informed about progress.
In the context of the development of the , Goobi was equipped for the first time with a function that allows a dataset to be queried and imported from the source system using more than just a single identifier. The Excel import plugin has been extended to enable this functionality for mass import using Excel files. In this context, the documentation of the plugin was also updated to describe such a use case there as well:
The way the plugin works is that it allows full text to be recorded page by page, so that a transcription is made for each digital record individually. The transcription is done by means of a rich text editor and allows some basic format adjustments. Due to the use of the very popular editor , further formatting can also be allowed quite easily if required.
NonSort
The
SortingTitle
Art of War
Subtitle
The Ancient Classic
iiifMediaFolder
Listing of IIIF URLs to all images from the media
directory of a process
iiifMasterFolder
Listing of IIIF URLs to all images from the master
directory of a process
Developments and news about Goobi workflow
Extension of single sign-on support
Implementation of checksum comparisons for exports
Completion of accessibility work according to WCAG
Swagger support
In the context of a project, it was required that individual processes should not be exported at the end of their workflow. Instead, it was required that a Goobi project be exported as a whole, so that an entire Excel file should be generated for all the processes of a project to be exported and the associated images saved in directories. In addition, the entire export should finally be available for download.
With a newly developed workflow plugin, this way of working is now possible. And as long as all processes of the project have also completed a configured workflow step, the plugin completes the likewise configured export step within the workflow, so that the workflow has a correct status progress.
Please note that the plugin with the very specific specifications of the Excel export may not necessarily be able to be used unchanged for other projects. Depending on the project goal and Goobi installation, adjustments to the plugin may be necessary for other application scenarios.
The detailed documentation of the plugin can be found at the following URL:
The source code of the plugin itself is available at the following URL:
Editing metadata should not be accompanied by entering the METS Editor in every use case. For some uses, a simplified interface is already sufficient here. For this reason, we have developed a new plugin that allows defined metadata to be edited directly within an open task. A configuration file can be used to define which metadata are to be displayed in which task and in which form they are to be editable (e.g. as a checkbox, input field, text area, dropdown).
In addition to editing the metadata, the plugin also allows a pure visual control of the data, so that the fields can be displayed as readonly. In addition, the representative of the process can also be set directly in the interface.
The editable metadata can also come from a configured vocabulary and thus be offered in a selection list. And in the event that metadata of another process is to be taken over, it is possible to search directly for the desired processes (e.g. for those with the same identifiers) and to reuse individual or all metadata from these.
The detailed documentation of the plugin can be found at the following URL:
The source code of the plugin itself is available at the following URL:
In the context of a Hebrew- and an Arabic-language project, the requirement arose that the multilingual metadata be entered by translators. The particular difficulty here was to keep track of progress. For this reason, a new statistics plugin was developed that prepares this information in tabular form and offers it for download.
A detailed documentation of the plugin can be found published here:
The source code of the plugin itself is available at the following URL:
We found the previous mechanism for resetting passwords less than ideal. Therefore, we have revised this area once. From now on, an administrator no longer has to switch to the user's role in order to change the user's password. Instead, this can now be done directly from the administration area for users.
To access this new function, the administrators' user group must have the new user role Allow setting of a new password
.
In this context, we have also made a change for changing your own password. From now on, it is necessary to enter the old password before a new password can be set.
With the plugin LayoutWizzard
many optimisations of digital copies can be automated very efficiently. First and foremost, it is used for (semi-) automatic cropping of digitised single or double pages from books, as explained in detail in its documentation here.:
Within the framework of a project, further requirements arose that the LayoutWizzard should also fulfil. Pages should not only be recognised from their background, straightened and trimmed. Rather, the background should be cleaned of irregularities. Black sponge rubber mats, as often used during digitisation, with slight discolouration, lint or other structures can be given a darker black tone more evenly in this way. The following example shows the difference between activated and non-activated background processing:
Since Goobi workflow is increasingly also being operated under Docker, new requirements also arise here with regard to commissioning. Specifically, the need arose for existing configuration files to be automatically copied from a mounted directory to the configuration directory /opt/digiverso/goobi/config/
when the Docker container is started. This functionality has now been implemented so that from now on individual configuration files can be maintained independently of the Docker image.
The Docker version of Goobi workflow can be found as usual at the following URL:
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
Implementation of a tectonics processing mask
Extension of metadata processing for a better handling of corporate bodies
Other general plugin developments
Preparation of the Goobi days :)
In August we developed a number of new plugins for partly completely new working methods. The first plugin to be mentioned here concerns the mass upload. This plugin has already been around for some time. It allows you to upload several images or read them from a directory to automatically assign them to the correct processes. The previous functionality was limited to recognising the correct Goobi processes on the basis of the file names. With the new development, it is now also possible to recognise a barcode on images so that the image with the barcode and all subsequent images up to the next image with barcode are assigned to the process from the barcode.
With this plugin, completely new working methods are now possible, where images created across objects are automatically divided into independent entities and assigned to the correct workflows.
The detailed documentation of the plugin can be found at the following URL:
The source code of the plugin itself is available at the following URL:
A new plugin now enables Goobi workflow to scale images as required in a single step. You can specify the maximum size of the scaled image on its longest side in a configuration file. You can also configure a watermark to be included in the image. This can consist of text as well as graphic elements. It is also possible to control where exactly the watermark should be inserted.
The definition of how the scaling and creation of the watermark should be done is controllable within the plugin configuration for different workflows. For example, a configuration for the image shown here would look like this within the file plugin_intranda_step_image_resize_and_watermark.xml
:
The documentation of the plugin can be found here:
The source code of the plugin itself is available at the following URL:
Plug-ins for querying catalogues have been available in Goobi since 2009, although until now it has always been sufficient to query a single record from a catalogue using a specific identifier. However, in one of the most recent projects in which we were involved, it became clear that there was also a need for more complex queries. Specifically, depending on the catalogue selection, one, two or even three identifiers should be used together in the catalogue query to obtain a concrete record. For this reason, the interface for Opac plugins had to be extended in such a way that such plugins can now control an additional area in which further entries should be possible. In the case of the JSON Opac plugin, this has been put into productive operation and the interface is now different from the Opac plugins of the past. In addition to the input of an identifier at least one line with additional information is now possible.
Details of what the JSON Opac plugin does, how it is configured and put into operation can be found in the documentation here:
The plugin's source code can be found on GitHub here:
After we have already put a lot of energy into supporting accessibility according to WCAG 2.1 in the past weeks, we had to work on it further in the METS Editor. The work has not yet been fully completed, so that this will continue to accompany us in September.
https://github.com/intranda/goobi-workflow/commit/52225055feac93b713c815bc4c02f8ac49bf4b79 https://github.com/intranda/goobi-workflow/commit/d62135f801ddb12e741b4335d9157d6f2f5e44a1 https://github.com/intranda/goobi-workflow/commit/6dc1fe71c727c8a941eb26f12aeac0a974da33af
In our major conversion of Goobi workflow for operation within the Amazon cloud, we have now included Amazon SQS. From now on, the queue for computationally intensive work as externally executable tasks can also be based on Amazon SQS. This further simplifies integration into an infrastructure maintained in AWS.
https://github.com/intranda/goobi-workflow/commit/2f399e7374322b577e1cdbc3ee8e4af3565d72e5
Developments and news about Goobi workflow
Completion of the tectonics editor
Extension of the manuscript editor with provenance information
Implementation of a multi-process editor
Data management within archives is fundamentally different from that of libraries. In particular the very hierarchical metadata acquisition is to be mentioned here, which results in the fact that hardly any metadata are available on the level of the object to be digitised. Instead, the metadata of the nodes of the so-called tectonic tree, which are arranged hierarchically above, play a decisive role here.
We are currently implementing a tectonics editor to enable smaller archives in particular to record their tectonics directly in Goobi workflow on the basis of an open source infrastructure and at the same time record the metadata in accordance with the ISAD(G) standard.
The user interface views shown here are still mockups. The implementation is already in progress. However, it hasn't been completed in September yet, so we will continue working on it next month and will be able to show actual screenshots and the corresponding documentation.
Within the German-speaking user community, the desire was repeatedly expressed that Goobi worklow should offer better support for corporate bodies. This development has now been tackled in a collaborative manner. A large part of this work has already been carried out this month, primarily on the basis of the UGH metadata library that works in the background. A second part of the development is still pending, but will follow next month. At that time, visual changes will also be visible within the Goobi user interface, which will be based on current developments.
The GoobiScripts metadataChange and metdataTypeChange, which are still quite new, have been renamed once again to make them more intuitive to use. The new names for these are now as follows:
metadataChangeValue
This GoobiScript allows you to change values within an existing metadata (e.g. the previous value NY
within the metadata place of publication
is replaced by the value New York
).
metadataChangeType
This GoobiScript keeps the value of the metadata unchanged. However, it changes the type of metadata (e.g. main title
becomes description
)
We also took the opportunity to update the GoobiScript documentation within the Goobi Manual. It can be found at the following addresses:
https://github.com/intranda/goobi-workflow/commit/0b0fb555cf35d95ea80f8020dc9c30e22b72f69a
In most cases, Goobi workflow is used at the end of the workflow to export the processes in the form of a METS file together with the digitised material as a derivative and display it online. The export of full-text results is often included in this process. If, on the other hand, master images, the internal metadata file or other data are to be exported in addition to the derivatives, Goobi workflow's standard export function reaches its limits. We have therefore developed a new generic export plugin that can be used repeatedly, even within a workflow, but which can also behave differently.
For each step within the workflow that wants to use this plugin, it can be individually defined how the export should be done. It can be controlled which image folders are to be exported, whether full texts are to be exported, whether selected other folders are to be considered for the export and where the whole thing is to be written to. Furthermore, the plugin also exports the internal METS file and the standard export METS file. For both METS files it can be defined whether they should be processed further by an XSLT transformation, for example to create another data format from them.
Such a configuration looks like the following example:
With this generic plugin almost any export can be implemented. If the standard METS export is not sufficient, this plugin can be used to quickly create an individual solution.
The detailed documentation of the plugin can be found at the following URL:
The source code of the plugin itself is available at the following URL
In order to be able to automatically delete certain contents of a process during the workflow, no plugin existed until now. Instead, we had helped ourselves in the past by implementing bash scripts. The new Delete Content plugin takes over this work from now on.
Like almost all step plugins, this one can be used repeatedly within a workflow and take over different tasks. Exactly which content is to be deleted in each case is controlled via a central configuration file. In this file it can be defined, for example, that the master images should be kept, but the derivatives and METS files should be deleted. This also controls whether the entire processes should be deactivated after deletion.
More details about the possibilities and configuration of the Delete Content plugin can be found in the documentation here:
Der Quellcode des Plugins ist unter folgender URL verfügbar:
From time to time there is a need to generate identifiers that are not yet available and that should be stored within the METS file. With the Generate Identifier plugin, such identifiers can be easily generated in the workflow and saved in a desired metadata field of the METS file. Here it can be defined whether a possibly already existing identifier should be overwritten or only generated in case of a missing metadata. It can also be determined how the identifier should be designed. At present, UUIDs, timestamps and random numbers with configurable length are available.
As usual, more information about the plugin can be found in the online documentation:
The source code of the plugin is available at the following URL:
In many cultural institutions, book objects are not digitised in their completely opened state, so that often the left and right pages of a book do not follow each other alternately. Instead, such books are sometimes digitised in such a way that a book is turned over from the front and only the right pages are included. This is followed by a second pass, in which the book is flipped through from the back and only the left pages are recorded. With the Reorder-Images plugin, such pages can be automatically put in the correct order. A configuration can be used to control how the sorting is to proceed and whether the images are to be renamed within the same directory or copied to another directory. With the latest developments it is possible to specify specific parts of file names which should not be affected by the sorting process and which should be inserted in a fixed order after the sorted files.
As usual, more information about the plugin can be found in the online documentation:
The source code of the plugin is available at the following URL:
Work on the METS Editor has progressed diligently in order to comply with WCAG 2.1 accessibility requirements. With the help of two automated validations, we were able to eliminate the individual complaints step by step in order to comply with WCAG at level AA. With the help of a university library, we were also able to carry out tests with a screen reader. In addition to the METS editor, we have now also revised the first plugins for Goobi workflow to improve accessibility. This includes the following plugins:
FileUpload
Plugin for the upload of master images, digital copies or other files within a task
ImageQA
Plugin for performing quality control of digitised material directly in the browser interface
Dashboard
Plugin to generate content for the dashboard that most Goobi installations use for your users
JSON-Opac
Opac plugin for retrieving data using the JSON format
Statistics
Standard statistics plugin that has been put into operation in most Goobi installations
Replace images
Plugin to replace previously generated placeholder images
The specifications on how web applications also have to guarantee accessibility can be found at the following URL:
Please note that these specifications may also be binding for your Goobi installation. You can find out more at these addresses:
For many months now, we have been releasing at least one stable version of Goobi workflow every month as a new release and combine this with the monthly digest. Following a major change to the infrastructure for compiling the application and the plugin, the automatic deployment of the compiled application no longer worked properly. This is now corrected. Under the following URL you can view and track the published releases of each month:
And the latest stable version of Goobi workflow can always be downloaded from this URL:
As in previous years, a large German-speaking user meeting of Goobi users and developers was held. Although this year's event was held in purely digital form, a similar amount of work was required to prepare presentations in the run-up to the event. Among other things, small visual refinements were again corrected in numerous places, layouts and translations were adapted, documentation was added or completely rewritten and published, and additional plugins were released on GitHub. All these numerous minor changes are also reflected within the application and its daily use.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
Completion of WCAG compatibility
Revision of the process creation page to use the data of the respective ruleset
Extension of queuing functionalities by means of Active MQ
Implementation of various generic plugins for different workflows
After we transferred the vocabulary manager to the core of Goobi workflow a few months ago, it was quickly used for several projects to have controlled vocabularies within the METS editor as a drop-down list or to run special plugins and exports that homogenise different spellings. What was noticeable was that the handling was not yet optimal, especially when it came to extensive vocabularies as they can be imported via an Excel import.
The vocabulary entries are from now on displayed with a paginator. This not only allows a significantly shorter loading time than before, but also prevents unnecessary scrolling of the website when switching between different data sets.
https://github.com/intranda/goobi-workflow/commit/241ef334ac0237dfc1195d3bfc64fdf4acc9b576 https://github.com/intranda/goobi-workflow/commit/904df6556feea3eb1a0fb9780e09e15af9911d19 https://github.com/intranda/goobi-workflow/commit/c31869eb31cd22a79630c4d429a59408eefbecf6
Last month, we reported on an extension to Goobi workflow that now allows users to have Goobi manage different folders with their own naming scheme. We have now also extended the file upload plugin to allow users to use this functionality in other places. It can now not only handle these new configurable folders. It now also allows for the user to upload files to more than one folder for individual tasks.
The configuration for such a use case within the file plugin_intranda_step_fileUpload.xml
would look like this as an example:
https://github.com/intranda/goobi-plugin-step-fileupload/commit/3dcc5ba4930501a378920703a309e7573f79cf6b https://github.com/intranda/goobi-plugin-step-fileupload/commit/0b2caa7105b15f4f3fe05d2bcfa7bf9feb4a007d https://github.com/intranda/goobi-plugin-step-fileupload/commit/12a803c02fd8e24e00609237d96725588393581a
After an extension of the FileUpload plugin, we have also extended the Image QA plugin in a similar way for the use of different folders. Now it is possible for a user to perform quality control of images within different folders of a process. Depending on which directories have been allowed in his task, the user can switch between the different folders and view the objects contained therein.
To determine which directories should be accessible to a user in which task, a configuration is made, for example, in the file plugin_intranda_step_imageQA.xml
:
https://github.com/intranda/goobi-plugin-step-imageqa/commit/9b99a3180b16f83b495062102a033068b5fd994d https://github.com/intranda/goobi-plugin-step-imageqa/commit/b444f75e681a284fddf0c3b73511b6da4a5f01d6 https://github.com/intranda/goobi-plugin-step-imageqa/commit/9b99a3180b16f83b495062102a033068b5fd994d
In order to allow different validation of different image folders for a project, the plugin for image validation based on JHove had to be revised. So it is now also possible to control in this plugin which folder should be validated exactly how, which also applies to the flexible individually configured directories. The configuration for this looks within the configuration file plugin_intranda_step_tif_validation.xml
exemplarily as follows:
The Web Content Accessibility Guidelines (WCAG) as an international standard for the accessible design of web pages are binding within the European Union for public bodies from 23 September 2019 for new and from 23 September 2020 also for existing websites according to WCAG 2.1 Level AA. In order to comply with these requirements, we are thoroughly revising the user interface of Goobi workflow. We were able to complete most areas in July. The very time consuming work will still move on, especially for the METS editor and the numerous plugins to be considered. However, we are delighted that we can now already fulfil the first accessibility validators.
https://github.com/intranda/goobi-workflow/commit/ed0e76c20334ff318d8e856927c6f3359a322c77 https://github.com/intranda/goobi-workflow/commit/e7c49f18cd4bba9bb299ec5f3f70034a92d5918f https://github.com/intranda/goobi-workflow/commit/e7c49f18cd4bba9bb299ec5f3f70034a92d5918f
Within a project, the requirement arose that automatic cropping by means of LayoutWizzard should not only be possible for entire processes. In particular, it was necessary to ensure that only one or two images were available in a process at any one time and that it should therefore be possible to process the images across processes. For this reason we implemented an extension for the LayoutWizzard that works as a workflow plugin. There it is possible to get images listed from several processes in order to crop them. In the list of images listed there, only those images from processes are shown that have already passed through a configured workflow step (e.g. a completed image analysis).
Documentation for this new plugin can be found at the following URL:
In addition to the major developments, there were again some other adjustments:
Like all major software, Goobi workflow uses numerous external programme libraries provided by other developers under an open source licence. We've tidied up a lot and updated many such libraries to keep them up to date. At first glance, a change of this kind hardly has any effect on the user interface. In the medium term, however, this will of course allow many additional extensions to the range of functions.
https://github.com/intranda/goobi-workflow/commit/ad712cdd5509fd478c8753ef6c112a389cb41e9e
Hardly any institution has yet taken advantage of the possibility of running Goobi workflow in the Amazon cloud under S3. However, for those who do, there is an adjustment for uploading large files. It is now also possible to work with files larger than 5 GB.
https://github.com/intranda/goobi-workflow/commit/2a384950ce45cd23fd1f082ef4f460d65995f091
During our regular clean-up work on the source code of the software some minor JavaScript bugs were found and fixed. This mainly concerns small discrepancies within the display in the user interface.
https://github.com/intranda/goobi-workflow/commit/4fd6f8a69755fa9568e5c0eac458d62bb28a63f8
In order to keep all the relevant plugins up to date, even when a new version of Goobi workflow is released every month, we have once again significantly revised our internal infrastructure based on Jenkins and Nexus. This enables us to ensure that our plug-ins are automatically compatible with the latest version of Goobi. As a result of this work, updates to Goobi systems are now much easier.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
Extension of the folder management per process
Accessibility according to WCAG
Enabling a cross-process possibility for working with the Layoutwizzard
Goobi workflow is being used in more and more institutions and countries. The circle of users is no longer limited to cultural institutions but also includes an increasing number of scanning service providers. Previously, data transfer between two different Goobi instances had been quite difficult. With the new Goobi-to-Goobi plugin, this has now become easy.
The working method is such that a total of three separate work steps must be carried out for the exchange:
First, the relevant data is exported from one Goobi. This includes the processes and media files. In addition, rule sets and user information can also be exported. The exact procedure for exporting is explained here:
After the data has been successfully exported, it must be transferred to the target system. This transfer currently requires an exchange via tools such as rsync
or the use of an external hard disk.
A description of the transfer with practical commands is described here:
As soon as the data is transferred to the destination machine, the import can begin. A separate user interface is available for this purpose, in which it can be specified which data are to be transferred exactly.
Detailed documentation is also available for this:
The complete documentation of the plugin can be found at the following address:
The source code of the plugin was published here:
Numerous new plugins have been added to the Goobi documentation platform and have received detailed documentation on configuration and operation. In this context, the licences and links to the source code repositories were also included. Furthermore, the documentation was published in German and English.
An overview of the currently publicly documented Goobi workflow plugins can be found here:
Many of the most frequently used plugins have now been released with their source code on GitHub. First we have created a standard for our readme files and then added it for all plugins to be published. Since June 2020 we have now over 70 open source repositories online at GitHub:
In total we have now published the source code of 48 plugins:
More information can be found on our GitHub page:
A new GoobiScript has been introduced to allow you to change the type of metadata within many METS files. The call to this GoobiScript looks like this:
With this command, depending on the selected parameters, an existing metadata can now be changed so that the value is retained but the type is changed. For example, a description
can become a main title
. In addition, it can also be determined at which level within the structure tree this change should take place. Thus it is possible to determine whether such a change should only be made for superordinate publications, only for sub-elements (e.g. volumes) or basically for independent publications.
https://github.com/intranda/goobi-workflow/commit/4306740b00a75d0a7874fb7cd10f8a19074f7754
Within the METS editor we wanted a faster way of working. In particular, we didn't like the fact that the large image displayed or even the thumbnails displayed were reloaded unnecessarily often, which interrupted the work somewhat. For this reason we changed the user interface so that there are now significantly more partial reloads of page content without affecting the entire page. The user will notice this change especially when switching back and forth between the individual tabs of the METS Editor. However, this will also be noticeable when adding, saving and editing people, metadata and metadata groups.
https://github.com/intranda/goobi-workflow/commit/c5fe9d3cd76fe93adbbb258b869a08724ba2a6e7 https://github.com/intranda/goobi-workflow/commit/b433851dd74017a985be26cdd38b2f1f27055bf6
A particularly large change was necessary in a project where different devices were used to generate master images and the files imported there had to be validated differently. We took this requirement as an opportunity to extend Goobi workflow so that it no longer just has the usual master
and media
(or tif
) folders. Instead, from now on, a large number of directories can be defined. In addition, we do not expect the old naming scheme of the names to be hard-coded anymore but allow other names.
Previous naming scheme:
New possible naming scheme:
Such a directory name can be defined within the configuration file goobi_config.properties
as follows:
https://github.com/intranda/goobi-workflow/commit/a0395f332aaba1ddc7b75792e2113bbbbb16e4bd
In addition to these major developments, there were again some minor adjustments, which will be briefly mentioned here:
Previously, when you created new processes, a process was successfully created in Goobi even if the associated METS file could not be saved correctly. This has now been corrected so that a meaningful message is displayed and the process is not created if an error occurs.
https://github.com/intranda/goobi-workflow/commit/18efa1677b98ac76828c6f40ac4fb7d22cb05da2
In some browsers, scrolling within the process log had difficulties, making it feel unintuitive to use. This has now been corrected so that scrolling is now intuitive.
https://github.com/intranda/goobi-workflow/commit/8a9b821eb620685bc340e332c38f468806dc16ea
In the past, commas in several Goobi configuration files had to be specially masked or escaped. So instead of a ,
you always had to specify \,
. This has now been corrected. Unfortunately, however, this change also means that some configuration files must now be checked for this escaping when updating Goobi. The same applies to the comma and the backslash, which can now be specified as \
instead of \\
.
https://github.com/intranda/goobi-workflow/commit/f58d6a47a066e9a9c26e30d3eea4c579b27d831d
Within the LayoutWizzard, there was a change that resulted in a higher speed when opening the LayoutWizzard for the first time and when scrolling between the preview images.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
LayoutWizzard Refactoring
Conversion of the Goobi code to use CDI
Accessibility according to WCAG 2.1
Having already completed support for audio and video within the METS editor of Goobi workflow last month, we also took another look at the Image QA plugin this month to make it compatible for audio and video display.
Again, the same compatibility restrictions apply as for the METS Editor, so that the following formats are possible directly within the display so far
Video formats:
Edge/Internet Explorer
YES
NO
NO
Chrome
YES
YES
YES
Firefox
YES
YES
YES
Safari
YES
NO
NO
Opera
YES
YES
YES
Audioformate:
Edge/Internet Explorer
YES
NO
NO
Chrome
YES
YES
YES
Firefox
YES
YES
YES
Safari
YES
YES
NO
Opera
YES
YES
YES
https://github.com/intranda/goobi/commit/32cad013767d747f308d1e0168e111232f44ee27
When an info.json
is requested for an image via IIIF, the existing thumbs are now returned as zoom levels. This causes the browser with the included tool for image display (openSeadragon) to request exactly these, so that the thumbnails can be passed through directly. This change brings with it an enormous acceleration of the loading times. For some images with longer loading times, for example, the time could be reduced from the original 2.4 seconds to only 0.2 seconds.
https://github.com/intranda/goobi/commit/0afa8ac5b58b801a07699ac982239965e2a257e8 https://github.com/intranda/goobi/commit/a61d3e0735e2b53bac5192adfa4b07e42d3395cd
The full screen view of the Image-QA Plugin has also been significantly reworked. It has now been implemented once again in JavaScript, which, in conjunction with the above fast image delivery, allows you to navigate through the images at a perceived desktop speed.
To use this new full screen display, this adjustment must be made within the plugin configuration:
https://github.com/intranda/goobi/commit/f43f2dbfd0eb737c8a75a00db987ee6e5c328411 https://github.com/intranda/goobi/commit/0042b21959930d2dc80c92d1864125e92bc40f8f https://github.com/intranda/goobi/commit/1843faf29f7985a5f6fc4a45d6f04e708b636b7e https://github.com/intranda/goobi/commit/fcf566fe0d0d4194585793c272f13c5603918001
Relatively recently, the METS Editor has integrated a new feature that allows the end page used to create a structural element to automatically become the new start page for the next structural element immediately after it has been created. This saves unnecessary mouse clicks in most use cases as well as some time.
Nevertheless, there are so many individual ways of working in the Goobi community that not everyone benefits from such innovations. For this reason we have now made this function deactivatable. Directly within the box for creating new force elements, you can now use the checkbox provided there to determine whether the page transfer function should be deactivated for the following force elements.
https://github.com/intranda/goobi/commit5f22c48421e29e0d4cce3a48e8c3e89a348a02a0
The JSON format is playing a major role in more and more systems when it comes to exchanging data between machines. Among other things this is so also in some catalogue systems already in use, so among other things within ArchiveSpace (https://archivesspace.org/). In order to support such data sources as well, a new Opac plugin for data transfer of JSON data was enabled.
Similar to the XML Opac plugin, the functionality of this plugin is kept extremely generic. Instead of using the XPath query language, JSON uses JSONPath to query metadata, so that very individual mappings of metadata from JSON to METS can be defined.
More information about the possible applications of JSONPath can be found here:
The source code for this new Opac plugin is published at Github:
An extensive documentation about the plugin and its configuration options can be found here:
https://github.com/intranda/goobi/commit/fa5ecfd989a96b2540dfae4d0c61e75e2d583797 https://github.com/intranda/goobi/commit/8a050eaf689f0cd4f0ceabaa69a493d9ebbc74cd https://github.com/intranda/goobi/commit/fa4ef8689ddd14726214b7a4c0f9ecce3c092330 https://github.com/intranda/goobi/commit/b40b6ab79fae816c3ec78d72a10687d6b9fb1915
The general refactoring work on Goobi workflow is progressing alongside the usual day-to-day business. Among other things, various program libraries have been updated, such as
PDFBox
Jackson
Jersey
https://github.com/intranda/goobi/commit/5b90c799f9955a1cf666ecdf679661e7d820c934
Developments and news about Goobi workflow
Two new GoobiScripts have been added:
deleteUserGroup removes a user group from steps
renameStep renames a step in multiple processes
Goobi workflow now supports openID Connect as an external authentication provider. The implementation is kept configurable and works with many openID Connect providers.
The new METS editor has landed in Goobi workflow stable. The primary goal of the conversion was to make the code more maintainable.
The new code structure has already allowed us to make some improvements. Most of these improvements avoid reloading the page, which should lead to a better workflow. For example, it is now possible to enlarge and reduce the size of individual areas without reloading.
Several dozen commits have been included in the new METS editor, so only the final merge commit is listed here:
If messages in the message queue could not be processed successfully several times, they have disappeared so far. From now on, Goobi will monitor the dead letter queue and display the messages from it in the user interface.
The thumbs
folder in a Goobi workflow process folder contains pre-rendered smaller versions of the images in the master and derivative folders. If an image is requested that is smaller than one of the thumbs
folders, that smaller image will be loaded and delivered.
Some performance optimizations have been made in the implementation of the logic described above. In addition, an image with exactly the right size is no longer loaded into memory, but passed directly to the browser.
Analogous to the search in authority databases, there is now also the option of starting a search in easyDB from the METS Editor and linking an object from easyDB with a Goobi process.
Developments and news about Goobi workflow
Migration of Goobi workflow for Java 11 support
Extension of the vocabulary manager
Implementation of a flexible editor for manuscript indexing
Thanks to extensive modifications to our metadata library UGH and to Goobi workflow, it is now possible to capture image sections in the METS Editor and add structural elements to them. This is done by simply clicking on the relevant button, in the same way as you would previously select a page area. You can then draw a frame on the image and assign structure and metadata. After creating such a screen section, it behaves in the same way as all previous structural elements.
A screencast is available here to illustrate the functionality and its operation:
A message queue for the controlled processing of long-running tasks was introduced in Goobi Workflow last year. This functionality has now been extended once again. The new functionality differs from the existing queue in that jobs in this queue can also be read and executed by external programs outside Goobi. From now on, this will enable us to automatically distribute the load of computationally intensive tasks, such as a JPEG conversion, across several machines. Further machines for such calculations can now be added or simply switched off again without any great configuration effort.
The METS Editor has been supporting right-to-left metadata display within input fields for some time. However, a new feature is that the reading direction of a work is now also taken into account for the image display. A title whose reading direction is right-to-left can be marked as such. Thus, the image navigation as also the display of thumbnails adapts itself, so that the button for turning to the next page is arranged, for example, on the left instead of on the right. This change was not only implemented within the METS editor but also in the ImageQA plugin.
Another major change within the UGH metadata library and the METS editor in Goobi workflow is the new option of displaying audio and video media. This is technically based on techniques available in the browser. For browsers such as Firefox and Chrome, this means that they are capable of playing MP4, WebM and Ogg videos, as well as MP3, WAV and Ogg audio files, for example. In comparison, Internet Explorer supports MP4 videos and MP3 for audio media.
The recently redesigned METS Editor had some display problems with very high monitor resolutions. Among other things, there were problems with larger zoom levels and when using 4K monitors. These problems were ultimately due to a rounding error and have now been fixed.
Gradually, over 200 JUnit tests were reactivated. These automated software tests had been developed some time ago. However, their execution had been deactivated in the past for the old Continuous Integration Platform due to lack of compatibility. By switching to Docker-based builds in our Jenkins and Travis, these issues have now been resolved and the tests have been reactivated.
Since the beginning of January 2020, the first Goobi instance within the Amazon cloud has gone live. Many of the developments made in recent months, such as the S3 connection, message queues and single sign-on using OpenID, were part and parcel of this move. We will continue to report on further developments in this area in the coming months.
The Log4j logging library used internally by Goobi was already a bit outdated. This month, we finally managed to integrate the new version with a new API into Goobi workflow. This change has affected almost all Java classes in Goobi workflow and is therefore certainly one of the biggest single commits in the history of Goobi.
There are now new options for controlling the creation of METS filegroups. You can now configure that instead of a specified configured mimetype and suffix, the file extensions are now used to specify the mimetypes of the files in the media folder. This allows a much more flexible generation of METS files depending on the actual files per object.
To use this functionality, the corresponding METS file group must be edited within the project settings. There the checkbox "Use file extensions and mimetype of files" must be activated.
It is also possible to exclude individual file types in a file group. This is necessary, for example, if one file group is to be created for audio files and another for the cover image. To do this, the list of unwanted file extensions must be entered in the "File extensions to be ignored" field. When creating the filegroup for the METS file, all files with this file extension will be skipped.
For the metadata library UGH there already existed in the past an extensive documentation as PDF file. This has now been transferred to the same documentation portal as numerous other documentations before.
At the same time we have translated this documentation into English. Thus the documentation of UGH can be maintained much better from now on, both regarding the topicality of the contents and the multilingualism.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
Further expansion of scalability to cloud infrastructure
Completion of the flexible editor for handwriting capture
Automation of Goobi-to-go deployment
Developing multilingualism
Within the METS Editor, the previous and next image of the currently displayed page is now preloaded. This has greatly reduced the waiting time for the next image to be displayed in case of scrolling, which has a very positive effect on the operation of the METS Editor.
Another improvement in the METS Editor is a feature that has been adopted from the Goobi viewer. This involves maintaining the current zoom level of the currently displayed image when you scroll to subsequent pages. For example, a zoom level on the page number is retained even when scrolling through the stack of images without having to enlarge the image repeatedly and align it for display in the image container.
Goobi workflow already has a user interface in German, English, Spanish and Hebrew. We are currently working on extending the range of languages for Dutch, Portuguese, French and Italian. This work has not yet been fully completed. However, we expect to be able to complete this in cooperation with the respective native speakers as early as March.
In the past, the METS Editor offered the possibility to print the structure tree. However, this functionality was no longer sufficient in recent years, as more and more information was required from users. In addition to the information about the structure tree, metadata and the representative of the image should also be displayed.
This functionality has now been developed. It replaces the previous button for printing within the METS Editor:
In addition, this function is also directly accessible from the operation list menu for each operation:
The PDF file created in this way usually looks like the following example. However, an individual design is also possible, since the mechanism of generation via XSLT transformation allows many degrees of freedom with regard to functionality and design.
So far we have had problems with the display of non-Latin characters within our generated dockets. By changing the default layouts, integrating Unicode-enabled fonts and some configuration work, we have now succeeded in ensuring that Hebrew characters, for example, can now also be displayed correctly.
The further development of Java was accompanied by the fact that Goobi workflow was meanwhile specified to be operated with Java 8. We have now been able to remove this restriction and have achieved compatibility with the current Java 11. We then ran Goobi workflow on our own developer computers under Java 11 for the whole of February and found no further problems. This is how we declare Goobi fit for Java 11.
Up to now, TIF validation has been run via the TaskManager. This type of execution had the advantage that load peaks could be avoided. However, it also had a disadvantage, namely that a more precise control of the workflow was not possible. So far, only the TIF validation step itself could be closed or set to an error status in case of errors. With the new step plug-in for Goobi Workflow, it is now possible to open a specific previous step automatically after automatic image validation has failed. This step can then be accepted directly by a user to correct the errors in the images.
How the steps between the validation step and the one to which the error is reported can be configured within the plugin. As well as the question which folder contents should be validated and how exactly the image validation should be done.
More information and the documentation for the plugin can be found at the following address:
A new plugin for renaming files was developed. It allows to automatically rename the images in the process folder according to a freely selectable scheme. All the variables that are also available in script steps and other parts of Goobi workflow are available for this. As usual, these variables are also available within the Goobi workflow documentation:
The documentation for the plugin can be found at:
For one project a plugin was needed where individual barcodes can be generated. This is a workflow plugin, within which only a prefix, a start value and a number of barcodes to be generated have to be specified. In addition, it is also possible to select the appearance of the barcodes from various templates. Similar to the routing slips, this is again based on a transformation via XSLT, which allows a completely free visual design of the barcodes to be generated. Thus, it is possible to influence how the paper format, the page layout, contents and also the barcode type to be used should be designed.
The barcodes can look like this example:
A documentation for the new plugin can be found at the following address:
To illustrate the operation of the plugin, a screencast is also available here:
Developments and news about Goobi workflow
With the current release, Goobi workflow is now multi-client capable. To this end, Goobi workflow now has institutions
to which the routing slips, rule sets, users, groups and projects can be assigned. It is also possible to assign routing slips and rule sets to several institutions at the same time.
Because users of Goobi workflow are always assigned to just one institution, Goobi initially looks completely unchanged for normal users. In the background, however, the restriction to the institution in question already takes effect, preventing access to the content of the other institutions. The restriction also applies to administrators, who can also only adjust the settings for their own institution and add users for these institutions. For the administration of the institutions themselves, there is now a new superordinate rights level in Goobi workflow, superadmin
.
For the commissioning of the multi-client capability at least one user must be given the right superadmin
. This is possible by using the following customized SQL statement within the database, where the correct ID of the user is entered:
The super administrator created in this way can then create other super administrators within the Goobi workflow user interface.
In the past, we have been approached by a growing number of interested parties who would like to use Goobi in a completely different way to the way it is used in most other institutions. Specifically, the idea is that the workflows should be designed in such a way that it is possible to create a logical structure even before digitised material is created. The associated images, however, should only be entered afterwards. Thanks to the enormous flexibility of Goobi workflow, it was possible to find a solution for this too. Two new plug-ins were developed to enable this method of working:
First of all the new plugin goobi-plugin-step-placeholder-creation
is used. Within its interface the user can define the number of placeholder images to be created and stored in the master image directory.
On the basis of the placeholder images created in this way, you can now work within the METS Editor almost as usual. Structural data and metadata can now be created and assigned to the respective pages.
The goobi-plugin-step-replace-images
plugin is then used in the rest of the workflow. This allows the temporary placeholder images to be replaced by the actual digitized images. At the same time, the plugin ensures that the images to be uploaded via drag & drop only replace the desired files and that the files are automatically renamed independently of the original naming of the files, as specified by the placeholder images. However, the file extension is dynamically adapted to the uploaded file format, so that besides TIF files, JPEG, JP2 or other formats can also be used.
Should individual images not be created and uploaded during the upload, this is also immediately apparent, for example, within the Image-QA Plugin and in the Metadata Editor due to the conspicuous placeholder images.
For a better understanding, a screencast is available here, which runs through the process of such a workflow in a comprehensible way.
The export plugin for the ingest into the long-term archive EWIG now supports submission manifests and also exports the contents of the process log. This means that it is now possible to trace within the long-term archive what exactly happened to the data and when during the workflow.
The detailed documentation for this plugin can be found at the following address:
If Goobi workflow is linked to a single sign-on via OpenID for authentication, an error has occurred in the past in the case of unknown users. Previously, these users were placed in an infinite loop during login, in which they were repeatedly forwarded to the login provider and then back to Goobi. The behaviour of Goobi has now been changed at this point so that a meaningful error page is displayed instead.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
LayoutWizzard extensions
Audio and Video integrations
Documentation
Extension of the vocabulary functionalities
Projects now have a new data field, the Identifier
. This new value is also available in the so-called Variable Replacer. This means that this new information can also be used within scripts, on run sheets or in plugins like the new file renaming plugin (see below).
There is now a new, enormously flexible editor that has been implemented for the indexing of manuscripts, but which can also be used in other areas. It basically consists of three columns, each of which can contain any number of boxes within which several input fields can be grouped. The special feature is that the contents of the individual boxes do not all have to be displayed at first. This enables the user to have an overview of the entire form without having to scroll. The individual boxes within the respective areas are activated by clicking on one of the badges and are thus visible. In this way, form fields that are not required are hidden and do not clutter the screen with unnecessary space-intensive components.
The individual fields within each box can be typed. This way it can be determined that certain information can be captured via input boxes, selection fields, text areas, checkboxes etc. in order to optimize the operation as much as possible.
Among other things, the functionality that the values for selection fields come from the new vocabulary manager comes into play. This allows you to manage controlled vocabularies within Goobi and use them directly within the Handwriting Editor.
All the content of the new manuscript editor is controlled via the plugin's configuration file and can be modified on the fly.
For some time now, an administration plugin for the management of vocabularies had already existed. This plugin has now been incorporated into the core of Goobi workflow and is now a central basic component for all Goobi workflow installations.
Within this new vocabulary manager, any number of vocabularies can now be defined and edited. For the creation and configuration of a vocabulary the authorization Vocabulary management - Administration
is required as a special right level. For the administration of individual vocabulary data sets, however, the authorization Vocabulary management - data sets
is required.
Various options are available for the administration of a vocabulary. For example, different fields of different types can be defined, each of which has multilingual content, can be prefilled with content and can also be defined as mandatory fields.
An import and export mechanism via the Microsoft Excel data format is also available for convenient data exchange. Already existing controlled vocabularies can thus be imported automatically even with large amounts of data.
The interface for editing the individual data records of a vocabulary adapts dynamically to the vocabulary definition. Depending on the configuration, several different fields of different types can be filled out per record.
The data sets created in this way are then available via a REST API for access by external applications, can be used within the METS Editor for use as metadata, or can be used for automatic enrichment of metadata.
Within the METS Editor it is now possible to select field contents from a vocabulary of the Vocabulary Manager. Thus, you can now define your own controlled vocabularies via the user interface and use them for metadata capture. There are two different working methods for this:
A selection of data records can be easily made via a drop-down field, which is defined within the configuration file goobi_metadataDisplayRules.xml
:
A selection of records is also possible via a search form, as is also possible for other vocabularies (e.g. Viaf, GND, Geonames etc.). In this case the configuration in the file goobi_metadataDisplayRules.xml
is done as follows:
Incidentally, for both use cases it is important that Goobi's REST API is active and allows access to the vocabulary within the goobi_rest.xml
configuration file as follows:
The new vocabulary management functionality allows many new usage scenarios for Goobi workflow. For example, a plug-in has been developed in this context that can automatically make corrections to existing metadata. To do this, you can specify within the configuration of the plugin which metadata is to be used as source information and in which metadata the target information is to be written. Thus, the following scenario can be covered:
within the metadata, different variants of the same location in different spellings and abbreviations, each without standard data specification, are displayed in the field Place of publication
This use case applies to numerous cities within the data sets with different notations
In a vocabulary, places are defined with the different spellings and abbreviations used, as well as the desired similar spelling
It is also defined in the vocabulary that a link to the standard data set from GeoNames should be used for the corrected value of the place of publication. For this purpose, the authority and the dataset identifier to be used is stored for the location
The plug-in is automatically executed before a digital asset is published in the Goobi workflow. It analyses all metadata fields to determine whether there is a replacement definition for them. If such a value is found, the required target notation is used together with the standard data specifications and written to the target field. If the configured metadata field does not contain any other spelling in the vocabulary, the source value is copied to the target field unchanged together with any existing standard data.
The configuration of such a replacement definition looks like this as an example:
Within the vocabulary, data records are stored for the various abbreviations and spellings, which are to be taken into account for the replacement:
After the successful run of the plugin, the metadata is automatically enriched. These replacements can also take place repeatedly within the workflow and update the configured target fields with the currently valid version from the vocabulary.
The detailed documentation of the plugin can be found here:
In the past, there were three variants of the Goobi step plug-ins:
A new variant has been added, which now allows a plugin to support both a partial and a complete user interface.
In this way it is now possible for a plugin, for example, to display a preview of what can be viewed and edited in detail in the complete user interface within an accepted task. This was first implemented using the Image-QA Plugin as an example.
The Image QA Plugin is one of the most widely used plugins. It has received several updates in the past. However, it has never been publicly documented. This month we have tackled this once. Besides several major and minor visual adjustments, we implemented extensive support for 3D objects and created a documentation.
And in case you don't know it yet, the QA plugin can do much more than just display images. Among other things it can do the following:
in different workflows it can behave differently with regard to display and functionality
a download of single or multiple images is possible
Images can be rotated individually or together in 90 degree steps
Images can be deleted
there is a full screen display
Full texts can be displayed parallel to the image
PDF files can be generated
the number of thumbnails is configurable
the resolution of the zoom levels for the large image is configurable
it is the first plugin to support the new display variant PART_AND_FULL
for displaying thumbnails directly within the task
A few months ago, a special import plug-in was developed that allows a mass import of metadata from an Excel spreadsheet and allows a detailed validation of the field contents even before the actual import. More about this plugin can be found in its documentation here:
In addition, there is now a second plugin that works closely with this import plugin. It reuses the same configuration file once again and provides a repeated possible display of metadata that was previously imported and revised during the workflow. As a step plug-in, it allows repeated execution and combined execution together with access to the Goobi workflow metadata editor.
Goobi workflow has undergone numerous minor visual changes that cannot be discussed in detail here. The majority of these visual adjustments relate to layout issues, standardising spacing and font sizes and icon display. In this context, we have also assigned slightly modified icons to a number of functions in order to avoid duplication and ensure that the layout is standardised.
After the major Updated METS Editor in November and December 2019, we received repeated feedback that it should still be possible to navigate between pages within the METS Editor by skipping one page at a time. This had been abolished in the context of the homogenization of the Paginator during the conversions. With our conversions we have now restored this function, so that navigation no longer has to be carried out in individual page jumps.
Developments and news about Goobi workflow
In the coming weeks we will probably focus on the following points:
Refactorization of the LayoutWizzard plugin for automatic image cropping
Conversion of the Goobi code to use CDI
The LayoutWizzard as a plugin for convenient cropping of images is becoming more and more popular. This was accompanied by the wish that its use should also be possible within the Amazon Cloud. For this reason, LayoutWizzard has now been revised so that it can be used on the S3 storage system in addition to a regular file system, just like Goobi workflow.
For more information about the LayoutWizzard, please refer to the detailed documentation for operation and configuration options:
Goobi workflow has been supporting the handling of 3D objects for several months now. This has already proved to be very useful for various data formats. However, handling very large files and their high-performance delivery and display was repeatedly a particular challenge. With the newly added functionality to support DRACO
compression, the visualisation of qualitative 3D models has now become much better, as the file sizes are considerably smaller than in the previously supported formats.
More information about compression using DRACO can be found here:
There is no significant change for the user in handling these new and already supported 3D formats. Objects can still be displayed, zoomed and rotated within the QA plug-in as well as within the METS editor as before.
Within the METS Editor, a user has also been able to manipulate the image stack for a long time, for example, to change the order of the files, delete files or even rename them. In the past, however, the operation of these functions was sometimes problematic, because after changes to the image stack, the METS file always had to be saved as well. With the revisions we have now made in this area, this is no longer necessary. Changes to files within the METS Editor are now always saved in the METS file as well, so that the METS file can no longer become asynchronous to the file names. In addition, we have conducted extensive testing to ensure that changes made will always affect all folders. For example, when renaming or deleting master files, derivative files, thumbnails, OCR results, LayoutWizzard files and also PDF files are immediately changed so that the changes made have the same effect in all versions of the digitised material.
There was an error within the GoobiScripts addStep
that prevented its execution. The GoobiScript has now been revised and is working again.
Over the last few weeks, we've worked hard to ensure that Goobi workflow now supports audio and video data directly within the METS Editor and also displays and plays back such files. In this way, Goobi now provides even better support for handling audio and video material and also generates the correct file groups for exporting METS files, allowing published digitised material to be displayed directly in the Goobi viewer, for example.
To ensure that Goobi handles audio and video data correctly, some minor adjustments are required within the ruleset used to enable audio
and video
within an object in addition to pages
, image areas
and 3D objects
. An example of such an adjustment in the ruleset is shown below:
Depending on which audio and video formats you are working with at this point, they can be played back within the web browser without the need for any additional plugins. However, as this varies from browser to browser, it has proven to be best to use the derivatives to mp3 for audio files and mp4 for video files. The following is a list of which browsers directly support which file formats:
Video formats:
Audio formats:
The already existing plugin for the uniform adaptation of anchor data sets was thoroughly revised and documented. It allows you to select a central Goobi process, e.g. for a multi-volume work or a journal, which should form the master process for all other Goobi processes. Changes within its anchor file in the Mets Editor therefore mean that all the associated Goobi processes can be updated with the identical data in the central anchor record.
Besides some small optical adjustments, a detailed documentation has been created for this plugin. This is available here:
The entire data stock of the Duderstadt city archive has also already been prepared for publication within a Goobi viewer and is already usable as a prototype. Before the URL is announced, however, some primarily visual work needs to be completed here. This will take place relatively soon, however, and will then be documented here once again.
Goobi workflow has long had an extendable REST interface to allow external systems to communicate with Goobi. The existing documentation for this within the manual has been revised. This means that an up-to-date version of the documentation on how to activate the interface for selected endpoints specifically for selected IP addresses is now available at the following address
The City Archive Duderstadt was very progressive very early on and in the 1990s digitized the entire archive and created an enormous . We have been working with this data for a long time and have now imported all data. The proprietary data was converted into an EAD format and the individual objects were described in a METS file, so that all deeply indexed metadata can now be republished.
NONE
Plugins completely without user interface
PART
Plugins with a partial user interface, integrated into an accepted task (example: File Upload Plugin)
FULL
Plugins with a complete user interface, which are entered from an accepted task (example: Image-QA-Plugin)
PART_AND_FULL
Plugins with partial and complete user interface at the same time (example: revised Image-QA-Plugin)
Edge/Internet Explorer
YES
NO
NO
Chrome
YES
YES
YES
Firefox
YES
YES
YES
Safari
YES
NO
NO
Opera
YES
YES
YES
Edge/Internet Explorer
YES
NO
NO
Chrome
YES
YES
YES
Firefox
YES
YES
YES
Safari
YES
YES
NO
Opera
YES
YES
YES
Developments and news about Goobi workflow
A file can now be copied to one of the image folders of an operation via multipart POST. The endpoint looks like this:
POST https://mygoobi.tld/goobi/api/processes/{processId}/images/{folder}
If {folder}
is set to "master", it will be uploaded to the master folder, otherwise to the derivatives folder.
https://github.com/intranda/goobi/commit/403d970d4ba95ecf87a710ec9357ed9bc2c27a13
Further queries have been optimized.
https://github.com/intranda/goobi/commit/7fddc8b303eca3a057dd070bf668293e2571f52a
Travis is now building Goobi releases that will be released on Github.
For better performance, GLB objects are now supported in the 3D view of the METS editor.
https://github.com/intranda/goobi/commit/0250f80d3685a2698c15e1ff6ed3a2aad7579050
The extended dashboard has been completely redesigned to offer better performance and fewer bugs.
https://github.com/intranda/goobi/commit/fd739050f8b89d04b7d02d9453f16e47f4f09fdb https://github.com/intranda/goobi/commit/83c5abdb4c7d342b50c7454dd0d55a9e64806334 https://github.com/intranda/goobi/commit/e9c4ffd3027eb37a30d5f20089ae59c3d7916cc2
The latest changes to Goobiscript had introduced new bugs that made Goobi unusable in long queues. This has been fixed.
https://github.com/intranda/goobi/commit/826b47d403cd830e2624e11eb7ffcc2a7da3bfee
Developments and news about Goobi workflow
Previously, the entire process was fetched from the database if an image from this process was to be displayed. This has now been optimized so that database queries are no longer necessary.
https://github.com/intranda/goobi/commit/6ea16c3115cbef1fac0428353f59cf7f2def94bd
If several blank lines follow each other in the OCR result, it can quickly become confusing:
From now on, several successive blank lines will be combined into one:
https://github.com/intranda/goobi/commit/eaa0f1c0ee5d5b170d041cfc559259ca2680a9a7
A new GoobiScript has been added that allows mass manipulation of step priorities.
https://github.com/intranda/goobi/commit/a2f27549976cf3fc9af8bdf96c94e118828dec1a
Previously, an error in Goobi left an empty folder in the file system after deleting a process. This error has now been corrected and the folder itself is also deleted.
https://github.com/intranda/goobi/commit/2ee43e3a6cb890416f90f2ff50a44faf707d242f
Developments and news about Goobi workflow
There is a new login screen that better reflects the "workflow" in the name.
https://github.com/intranda/goobi/commit/5a9ed3e75e03cb04ef63ac20b74dda90b9bd8eb6
If you were already logged in as a user and tried this again in another browser or on another computer, an intermediate page was displayed. It asked if the old sessions should be cleaned up. This intermediate page no longer shows up and you are logged in normally.
https://github.com/intranda/goobi/commit/596353f747155ddcde9a8eca854798e30598108a
Since the Goobi days at the end of September there is a new versioning for Goobi workflow. The first release with the new versioning was "Goobi workflow 19.09". The first two figures are for the year, the second for the month in that year. Should there be a bugfix release, another number will be counted up, e.g. 19.09-1, 19.09-2 etc.
https://github.com/intranda/goobi/commit/5a9ed3e75e03cb04ef63ac20b74dda90b9bd8eb6
It is now possible to have automatic steps processed in a queue. Any number of workers can be assigned to the queue so that no load peaks occur on both smaller and larger systems.
https://github.com/intranda/goobi/commit/ee7484fb88313203a9ca699414a2add3f53e149f https://github.com/intranda/goobi/commit/72a6d16bfe33aded4c0434cf68fa7f13584c8a9c https://github.com/intranda/goobi/commit/0d94330938577a9a5897855d536342f629e88fe0
When a user is deleted in Goobi workflow, the following personal information is also deleted:
username
given name
family name
ldap username
https://github.com/intranda/goobi/commit/38d4f2f56d39015ff40bfc6b39e02c7193ded5d8
The REST endpoint for process search now also allows filtering by template IDs. A list with the template IDs to be filtered is passed with the search JSON object:
https://github.com/intranda/goobi/commit/d42389620c1bc93f50b0b3a889645b73f5edd519
Developments and news about Goobi workflow
A search in the VIAF has been integrated into the metadata editor. In this way, the authority databases from 40 countries can be searched and their values transferred to the METS file.
The VIAF search can be activated for a metadata type by editing the goobi_metadataDisplayRules.xml
configuration file and adding a block like the following:
https://github.com/intranda/goobi/commit/d56e244bde8cc5ba844f94f1bf2bb2846215bbb1 https://github.com/intranda/goobi/commit/96fa0656984d6b049e29a8853cf26a7fb94e927a https://github.com/intranda/goobi/commit/6f72039ef2393def29e8750ccb48558f6ec2c0a5
The two buttons to "fast forward" and "rewind" a process below the process list have been replaced by GoobiScripts. This allows a concurrent execution in the GoobiScript queue. A further advantage of processing in the queue is that peak loads are avoided.
https://github.com/intranda/goobi/commit/bd967dfb8b8ea02a1af2af846a770cb09ab595e5
With this fix it is again possible to combine different GoobiScripts and perform a task consisting of several GoobiScript calls with one large command. For example, the screenshot shows adding a new script step to all processes in the search results.
https://github.com/intranda/goobi/commit/74b8ecb7f62875a9e1be8cd47d9705cec7738da3
All input fields in the metadata editor now automatically recognize the text flow direction depending on the content.
https://github.com/intranda/goobi/commit/73a22c71b2165d6ba76241824d792aa7b453cf8c https://github.com/intranda/goobi/commit/d89ed3eff3fbfae453ce67d5c822c2284ddcd618
When using S3 as storage backend, connections have been kept open for too long. These connections are now closed correctly and a memory leak is prevented.
https://github.com/intranda/goobi/commit/c4f9487877d92d6526e6b36e07ae18761e4d7b4f
The new thumbnail folder did not work correctly when using Goobi under Windows. This bug has been fixed and Goobi and GoobiToGo now work on Windows again.
https://github.com/intranda/goobi/commit/a84fe0e5e2f1a2bd28d56cb04ec25f88eb5bb792
Developments and news about Goobi workflow
Already some time ago we added a new queue to Goobi. There hasn't been much of this queue so far, it did its work quietly in the background. This has now been changed. There is a new page where administrators can view the queues and also cancel jobs.
https://github.com/intranda/goobi/commit/38a43c078f403b24cc1fb2910e619ad189e3c4a2 https://github.com/intranda/goobi/commit/e3331d76932a20f1aa750f4be227264c123e7a10 https://github.com/intranda/goobi/commit/e3331d76932a20f1aa750f4be227264c123e7a10
If GoobiScripts were executed and new ones were started in parrallel there was an error, because two methods tried to access the list of GoobiScripts at the same time. This bug is now fixed, the entire GoobiScript administration is thread-safe.
https://github.com/intranda/goobi/commit/349a75d98492779075db61e134783dc34862c9a7 https://github.com/intranda/goobi/commit/5906bcecc0855bc9286c310193e87049131820f6
If a user was assigned a large number of steps (~30,000), it took up to 10 seconds to list the tasks. The same was valid for the submission of tasks. The two responsible SQL queries were optimized and are now also fast for users with more than 30,000 assigned steps.
https://github.com/intranda/goobi/commit/ec5fb70fa8af702f813d58f256ef5808c3cebf77 https://github.com/intranda/goobi/commit/5373c1887509cd34cfdf17060fe7463d4568cb1d
There is a new page listing all installed plugins. There is also information whether the plugins are used in workflows. The new page is accessible via the admin menu.
https://github.com/intranda/goobi/commit/953b733d652c99682b3221e1cea67ea4d67ed21e https://github.com/intranda/goobi/commit/019f9ac744d4690de6427ea57f5cae13a92b4b17 https://github.com/intranda/goobi/commit/aa88a32a873ed1a04e0b79a9a9a7b78d432af2a5
There is a new GoobiScript for renaming tasks. The syntax is:
The system searches for OLDNAME
in the process name of the process to be changed and replaces it with NEWNAME
. If type
is set to full
, the entire process name must match OLDNAME
. If contains
is used, only the part of the process name that matches OLDNAME
is replaced.
https://github.com/intranda/goobi/commit/c1387648d3606304f0fe5f5bdf5532512d2b691f
It is now possible to link files in the process log. You can upload them directly under the input mask for the message.
https://github.com/intranda/goobi/commit/cbbcbdb54c99fee8349296d5f2893cdab7533855 https://github.com/intranda/goobi/commit/1f299436c67fbcf26421bacd3b5bc6e331854c09 https://github.com/intranda/goobi/commit/2032e423fddd3642e3a8876e863ef23ed8914fb5
Along with the file upload to the process log, a list of all image files currently in the process has been added.
There is now the possibility to send emails to users when opening a step to which the user is assigned. Users with extended rights can also have emails sent to them when a step changes to any other status. The configuration is done for each user in his user settings per project and step type. The emails can also be unsubscribed directly via a link in the respective email.
https://github.com/intranda/goobi/commit/16cd4c52679c658b6151e34a9b0b8e37c98a632d
After creating a process, a link is displayed that allows you to jump directly to the process. This link is now only displayed if the user has the necessary rights to see the process.
https://github.com/intranda/goobi/commit/dfbc61977cb856bc1b7e870d9d42f61f82079dcb
The old arithmetic problem caused some frustration for some users, so we changed the query to show the GoobiScript to run and the number of affected operations. All you have to do now is type in the number of affected tasks.
https://github.com/intranda/goobi/commit/f3964314b7d44d763f7fe9fa6b8dcd4151e5603f
There are now public docker images available for Goobi workflow. You can find them at Docker Hub. These images are a basic installation without plugins and are intended as a basis for creating custom images. For the use of the images we have created an instruction under the following link, which also shows the connection to a database:
https://github.com/intranda/goobi/blob/master/DOCKER.md
There is now an installation guide for Goobi workflow. This can be found at the following link:
The manual refers to Ubuntu Linux 16.04
and can be worked through step by step. The installation also covers compiling and installing the most common Goobi plugins.
Developments and news about Goobi workflow
The interface for the mass import of Goobi workflow has been massively revised. Previously, users had to select the correct import mechanism and then import the plugin from the list. And last but not least you had to select the file to be uploaded first and then click on a separate button. All this is now much more intuitive. If you enter the mass import, from now on only those tabs will be displayed for which plugins are installed. If only one plugin is installed, it is already selected. And also the upload of the file is directly possible with Drag & Drop. Thus the handling is simplified by a multiple and requires substantially fewer clicks than before.
​https://github.com/intranda/goobi/commit/41d622981b7ea2ced3cc009a703c78a23c1967c1 https://github.com/intranda/goobi/commit/93d0042cad7f99e480d1fbeb5b961af74702ae92 https://github.com/intranda/goobi/commit/4f23eb2ca69ae7e5d35ae5658e017cae69c1c973 https://github.com/intranda/goobi/commit/b2a8bf88cd9a352ad00ff1571d4465b96a900ba7 https://github.com/intranda/goobi/commit/51ebf28f6deb99d6590c48906500f2d379c28a15​‌
To ensure better compatibility with different character sets and languages, the Goobi workflow database has now been adapted to store all tables internally as UTF8. After installing the new version of Goobi workflow, this update takes place automatically during the first program start, so that no manual intervention in the database is necessary.
​https://github.com/intranda/goobi/commit/d48a075ab4a1db543a38ccce4c486acfe6187bce https://github.com/intranda/goobi/commit/b2fbd68681082e3ccbfc6a24064f8ea55537a270 https://github.com/intranda/goobi/commit/21fdbc7b0479f41dac8c2a922fadfb5d254a7f96​‌
By adapting an SQL query, the speed of listing many steps could be increased. Even with 30,000 steps assigned to a user, waiting times are now less than one second.
​https://github.com/intranda/goobi/commit/80435577b4b0bac5b5c226c17a83907789256ae7​‌
A placeholder text is now displayed in the metadata editor when no media is available for a task. This means that the user can now see immediately whether files belong to a process at all or whether there are only problems with the display of available media under certain circumstances.
Within the File-Upload-Plugin not only files can be uploaded from now on. It is now also possible to download individual files again. In addition, the entire directory content can be downloaded as a zip file.
The Administration Plugin Catalogue Poller now has a mechanism to export updated tasks that have been changed by a periodic query of a library catalog, for example. With this new mechanism, it is now possible for only those records to be re-published, e.g. in the Goobi viewer, for which there is an update. Only the METS file is exported, but not associated images, media or full text files. In this way, the publication process is also correspondingly efficient and current data records are always published.
Further information about the configuration of the Catalogue Poller Plugin can be found in its documentation.
Three plug-ins were developed to connect Goobi workflow to the LZA of the GWDG (CDStar):
One step plugin for the ingest of master images and derivatives in CDStar
A plugin for exporting a METS file with file groups in which the IDs and URLs point to the previously ingested images in CDStar.
A plugin that imports the exported METS file into a Fedora system.
All these plug-ins already work with the Goobi internal queue, avoiding peak loads.
A new plugin for importing newspaper articles from an Endnote export has been created. An explanation and documentation can be found in this portal.
Developments and news about Goobi workflow
If the results of a full-text recognition were displayed within the METS editor, the full-text recognition has been abbreviated for longer texts. This display has now been adapted so that even longer texts can be displayed without problems by making the associated container scrollable from now on.
https://github.com/intranda/goobi/commit/888509510484574b10264ce7929260744515a944
Goobi has long been able to handle the various return values of the called programs and handle the workflow accordingly, especially when communicating with external programs that perform long-running tasks. However, the processing of GoobiScript
to call such external programs in mass for several processes together could not yet correctly handle these return values and mistakenly indicated them as incorrect calls. This has now been corrected so that the return values 98
and 99
are also successfully evaluated and are therefore no longer displayed as errors within GoobiScript.
https://github.com/intranda/goobi/commit/5e713f5d04f936506f351bec51de92e707d19604 https://github.com/intranda/goobi/commit/9ce09f6c6410b820661e1d556364c8dc345101a1 https://github.com/intranda/goobi/commit/a0f1f211566e3e737e4db694395f65b65d1f2b89
Thanks to the collaboration with the National Library of Israel, Goobi workflow is now fully available in Hebrew.
https://github.com/intranda/goobi/commit/b41194ad3ee350177a4ce95f0ec0e27a89f9f608
A number of JavaScript files for handling 3D objects have been standardized for better maintainability and better interaction between Goobi workflow and Goobi viewer. This is particularly beneficial for the maintainability and training of other Goobi developers.
https://github.com/intranda/goobi/commit/eaaac77efd856e05a88f7ac39de9b9c8ffe01ab2 https://github.com/intranda/goobi/commit/32b2e99172a6e31d03b0b3279b01dd02965722de https://github.com/intranda/goobi/commit/76629353b0773e7425203114c65200ac96787e13
Within the GoobiScript for exporting processes to the Goobi viewer, there was a small error that caused OCR results to be exported, even if this was disabled in the call. This behavior has now been corrected and intensively checked again.
https://github.com/intranda/goobi/commit/d7864a6d06a648c20f4f1ec769ec00ffb7b541f8
When generating exports such as Excel files, incorrect results occurred if the search query was filtered by batch title. This behavior is now corrected.
https://github.com/intranda/goobi/commit/9a94b8f63720951316934704dfbbf24eb6944914
Developments and news about Goobi workflow
Within Goobi's METS editor, there were a few minor improvements in usability. For example, the title bars of the boxes can now be clicked across the entire width to open or close them. Previously this was only possible by clicking the icons in the title bar on the right.
As a result of this change, the operating logic for adding people and metadata has also been adapted to the other areas of Goobi workflow. The previous button within the title bar of the boxes is now located within the boxes in the lower right area, as in the other areas before.
https://github.com/intranda/goobi/commit/6aa0ff7145390eb26a724219d65cdee3601d1961 https://github.com/intranda/goobi/commit/10e2d95d5aaca0926260827c7ef48f7961cb4b3b
If changes are made to the sequence of images using the functions provided by Goobi for intervening in the image stack, the display of the opened image is now reloaded correctly. In addition, the logic for browsing through the thumbnail pages has also been revised so that the operation is more intuitive.
https://github.com/intranda/goobi/commit/f7c192c28f12f1c2621de96f2f66a867a68adaaf https://github.com/intranda/goobi/commit/314aea5646bad8452de2a6c16ab6a707640e622c
The correct center point is now used for the correct rotation of 3D objects within the METS Editor. This prevents the object from leaving the visible area of the object display during rotation.
https://github.com/intranda/goobi/commit/c0f24fa18e45a3c7c0a0a3da2ebf80c2fdf0fa63
A behavior error occurred within the processing of properties for batches, so that the processed properties were incorrectly duplicated. This behavior has now been configured.
https://github.com/intranda/goobi/commit/bf2e47d48af47686134fa03d0b4969bea7ed55a8
Due to the increasing distribution of Goobi-to-go, the need for compatibility with different operating systems is also increasing. Especially the operating system Windows has to be considered with some special features. For this reason, some path specifications have been revised, especially for handling images within the METS editor, and are therefore easier to maintain in the long term.
https://github.com/intranda/goobi/commit/1f7f95846e9535bcddc50462b4e81b78e752d079
All user interface texts that have not yet been translated into English have been checked, translated and imported by the English translator.
https://github.com/intranda/goobi/commit/1d55539c2c3ccd114ce65c48eb6e91897424420b https://github.com/intranda/goobi/commit/5c614ed06f7cbca2959f1285c282867a187e80ee
Developments and news about Goobi workflow
If a GoobiScript was faulty, the red error status was a good indicator, but the cause was often not visible. Therefore the display was extended to show the feedback of the scripts or plugins. These messages can also be downloaded as Excel files and are written to the process log.
The Export search result area has also been adjusted. There it is now possible to export the last saved error message from the process log. The column Last error message
must be selected for this. If no error message exists for a task, the cell remains empty. The corresponding commits can be found here:
https://github.com/intranda/goobi/commit/329487de6fa1e68e4da204a19c70516b2c73288b https://github.com/intranda/goobi/commit/af6930ab091653658003908458c05ced4215b84chttps://github.com/intranda/goobi/commit/3344487fa53943a6cf7424e475493e3805fd5841
The already existing Excel Import Plugin for importing metadata has been extended to work with the column header instead of the column order. This allows you to make minor changes to the Excel files without having to change the configuration each time because individual columns have changed or the order is now different.
In Goobi the plugin intranda_import_excel_read_headerdata
must be selected during the import.
The configuration file plugin_intranda_import_excel_read_headerdata.xml
is based on the previous configuration, but allows a definition of the metadata fields according to the following scheme:
If the Excel file contains a column that contains the value PPN-Digital
in the first row, the value from this column is then written to the metadata CatalogIDDigital
in each data record.
Persons can be imported in several ways. If the first and last names are in separate columns, the field looks like this:
If the full name is provided in a column, the following configuration must be selected:
The value found is split at the configured <splitChar>
and divided into first name and last name. Optionally, it is also possible to specify authority data for a metadata:
The already existing plugin for periodically updating the METS files within Goobi from a catalogue has been slightly revised. The main need for action here was to be able to determine more precisely which metadata should not be overwritten with changed values and how to deal with omitted metadata.
In this context, the logging of the plugin activity has also been improved. In the Goobi process log, it is now easy to see at any time what has changed in the data record and exactly when this took place.
Finally, we took the opportunity to create a detailed documentation for the plugin. This can be found at the following address:
The new XMP plugin makes it possible to write various metadata from Goobi into the XMP headers of image files. Metadata can be written at the factory level as well as metadata at the image level (e.g. belonging to structural elements).
A complete documentation can be viewed here:
With this plugin you can define on a single page basis which images from a process are sent with which font to the OCR.
The documentation of the two plugins can be found in this portal:
The merging of the two GBV and SWB catalogue databases to form the K10plus database resulted in changes. Goobi can already deal with these. It is irrelevant whether the query is made via SRU or the XML interface, whether pica+
or marcxml
or which database is used. In the file goobi_opac.xml
the following catalog connections have to be configured:
Since the assignment of some fields has also changed, it may also be necessary to make adjustments to the rulesets. Depending on the format, these can also be more extensive. With pica
, the most serious change seems to be that the GND identifiers
are now in subfield 7
and all PPNs
, which have been entered in the new catalog for the first time, have received a prefix KXP
in some fields.
A number of statistical evaluations have been created to evaluate the progress, throughput or current status of the operations. Since these evaluations can be broken down to user groups and even to individual users, personal statements can be made. For this reason, these statistics are located in an independent plug-in and are only installed within Goobi on request.
The display of the progress bars for the tasks should be more informative. For this reason, Goobi has been enhanced to display a popup when the mouse is moved over the progress bar. From now on, it will visualize which concrete work steps are currently in the status over which the mouse pointer is currently positioned.
In this way it is now possible to see which tasks have already been completed, are currently being processed or are still locked without unfolding the tasks or opening the task details.
The commit for this can be seen here:
https://github.com/intranda/goobi/commit/68b1c9ad05a63cdef2e7dfd75a473e03a062a53f
The community expressed the wish that it should be possible to create processes directly from the Goobi homepage within the standard dashboard. This has already been implemented in a first draft and can now be put into operation. All those production templates are listed for which the respective user actually has access.
Developments and news about Goobi workflow
In addition to the metadata fields for texttareas, select menus, read-only fields or the connection of GeoNames and GND, which have been available for a long time, the GBV DANTE standard data service has been connected. Dante currently provides about 90 different vocabularies which can all be used with this revised implementation.
To use the DANTE API the file goobi_metadataDisplayRules.xml
must be extended by the following configuration:
The field configured in each case is then available in the METS editor. The search form is opened by means of the magnifying glass icon so that the desired value can be entered within the selected standard data vocabulary. The desired hit can then be selected from the displayed search hit list. Within the desired hit, the value to be imported can also be selected from a selection list and confirmed by clicking on the green button.
https://github.com/intranda/goobi/commit/b330b9b481939a48cdaca470d353ae2507beb753 https://github.com/intranda/goobi/commit/d61f25f75fd4398e4c3843232500ce8bf2be763c https://github.com/intranda/goobi/commit/24443bafcef10212d99c4ad33cfa23e11ed03793 https://github.com/intranda/goobi/commit/cf9b0993f64cf807e9c039657008425c207ad5cb
The integration of Amazon S3 as a storage system for storing large amounts of data has already made massive progress in recent months. During this work, further improvements and error corrections were always necessary. In addition to a reduction of file accesses, the determination of directory sizes, which did not always provide correct results when using S3, has also been revised.
https://github.com/intranda/goobi/commit/152e3787d5dd9651b5e9f65a0be8cb454e0b0c54 https://github.com/intranda/goobi/commit/8c8d6e48660e78058751fa3da688453024c08ba5
If province data have already been entered in the GBV catalogue, they can now be imported as well. Since this metadata is not contained within the MARC record, it cannot be imported during the initial import of the metadata. The import therefore takes place in a second step. For this purpose, the EPN
of the A-record
is used to search for the corresponding Pica+
record. The system then checks whether provenance data is available for the copy used. This check takes place by matching the EPN
in field 092B$2
and the library symbol in field 092B$1
.
To be able to use the plugin, a metadata group Provenience
must exist in the rule record:
Further adjustments are not necessary. The plugin itself is part of the collection goobi-plugin-opac-marc.jar
and can be accessed via the name HaabProvenienceOpac
. An activation within the configuration file goobi_opac.xml
is not possible, because the plugin only delivers the provenance metadata and no structural elements are created. To integrate it into the workflow as a step after the initial import, the step plug-in intranda_step_provenience_request
from the goobi-plugin-step-catalogue-request
repository is also required.
Goobi is now able to import individual records from EAD find books. To do this, the EAD data records available in XML are periodically imported into the BaseX XML database. From now on, this database serves as a dynamically updated EAD memory and can be queried with the help of a special OPAC plug-in via the RESTXQ
query language instead of a typical library catalog.
The special feature compared to a normal XML-based import is that the tectonics of the find book are preserved, since they are also stored within the XML database. If the tectonics is changed and the previously imported data record is moved to another structure, then only the EAD file must be read into the XML database in updated form. Since the identifiers of the data records are retained, presentation software such as the Goobi viewer, which also has access to this EAD memory, can query the current status of the tectonics live.
Further detailed information about the implementation including installation instructions can be found here:
https://docs.intranda.com/goobi-workflow-plugins-de/opac-plugins/opac-ead
Goobi workflow has been enhanced to allow you to display specific metadata from the METS file within individual accepted tasks as well as properties.
The display of this metadata integrates itself into the range of properties that can also be displayed and edited and can be individually configured for each task of individual workflows. Such a configuration looks like the following within the file goobi_processProperties.xml
:
The display of descriptive metadata is also possible within the process details. For this purpose, a new area has been created below the tasks that lists these metadata.
With the help of this new functionality and future developments, redundant storage of some metadata will become superfluous in the future. From now on, information that is currently still available as a property as well as within the METS file can only be stored in the METS file and read from there. It is important that the checkbox Update metadata index when finishing
is activated within the individual tasks of the workflow to ensure efficient caching of the data from the METS file for display.
For a complete update of the cache for the fast display of this metadata within the web interface, the existing GoobiScript updateDatabaseCache
can of course also be called for several processes simultaneously.
https://github.com/intranda/goobi/commit/0314dfccedf39d3d5d082c66562d1af3a62d47a4 https://github.com/intranda/goobi/commit/6218226341bdce689b178fdb3aef0bdf297f9b59 https://github.com/intranda/goobi/commit/2a278d03a20c3ce22f494b22fbab74a6ef67c36e https://github.com/intranda/goobi/commit/0c50c0401606eeadfc9b3ab33fa55d29b16c7346 https://github.com/intranda/goobi/commit/68750e1858ec0a51353110e31c863db02be2291d
Developments and news about Goobi workflow
After extensive testing, the internal management of program libraries and interaction with the 170 plug-ins currently available were converted to . This allows for easier use of repeatedly required functionalities via integrated modules and libraries. As in the past, the switch from to Maven still allows the *.war
file and a *.jar
file to be compiled that can be installed in an application server such as .
With the pom.xml available within Maven projects, it is now relatively easy for anyone interested to download and compile a Goobi from Github themselves, or to develop one themselves with commands such as:
These calls download the source code of Goobi from Github and compile it afterwards. The file goobi.war
existing in the module-war/target/
directory can then be installed in the application server.
Goobi has been enhanced for a new step type: the HTTP step
. GET
, POST
and PUT
requests can be executed automatically here.
If the call is successful and the status code 20x
is returned, the work step (if configured in this way) is closed. Any error messages that occur are stored in the process log and can therefore be traced afterwards.
The following screenshot shows an example configuration for calling the TaskManager OCR plugin:
The configuration used here uses POST and sends it to the address http://localhost:8080/itm/service
:
Goobi workflow now supports the ability to create JSON Web Tokens (JWT) that allow access to the API for a specified time. These JWTs are provided as variables within HTTP calls. So far the JWT {changesteptoken}
already exists, which allows to change a certain work step.
Developments and news about Goobi workflow
After several months of work on support for processing and displaying 3D objects, the first milestone has now been reached. 3D objects are now supported in the entire workflow. This applies both to the upload of files and the display within the Image QA plug-in as well as the METS editor and the export to the Goobi viewer. This means that both Goobi workflow and Goobi viewer can now be used for 3D objects.
Developments and news about Goobi workflow
There are now several new GoobiScripts for manipulating metadata within METS files. This GoobiScript, like all others, can be called and executed simultaneously for multiple operations. Among other things, it is possible to change, supplement or delete existing metadata in mass.
The new GoobiScripts look like the following:
In order to configure a process afterwards to another workflow, it is now possible to execute this directly via a button without having to change a process manually step by step. Also the process does not have to be created again. Instead, if the user has the appropriate rights, the new workflow to be used is simply selected. All workflow steps already executed are set to the same status in their status in the new workflow, provided that they are also represented there with the same name.
It should be noted that the user must be a member of a user group that has the right Change process template later on
. If this right is missing, it must first be added to one of the user groups.
A new GoobiScript has been introduced in order to be able to change the workflow for several processes at the same time. The call of this GoobiScript is as follows:
The image display within the METS editor has been extended to allow zoom using the zoom slider. At the same time, the current zoom level is displayed as a percentage value next to the zoom slider. In addition, the percentage value for the zoom can also be entered using the keyboard to directly obtain the desired magnification.
Developments and news about Goobi workflow
After several months of development, support for S3 as a storage system for Goobi workflow has now been integrated. This means that Goobi can now be operated within the Amazon Cloud using the appropriate storage structure.
In addition to the existing editing fields such as InputBox, SelectBox, MultiSelectBox, TextArea and some others, a new type for editing metadata has been added to the METS Editor. This serves for the treatment of RichText data and permits thus a collection of texts including formatting defaults. The storage takes place thereby within the METS file as HTML.
The configuration of this new field type takes place within the file goobi_metadataDisplayRules.xml
as an example:
In order to ensure that the Common Authority File (GND) of the German National Library continues to function correctly in the event that it cannot be accessed, the GND will now only be queried with a maximum of three attempts. In the event of faulty communication, further attempts and a further waiting period for the user are thus avoided.
In addition to the existing GoobiScripts, there are now several new scripts for editing process properties. With these new calls, it is now possible to change or delete existing properties and add new properties for multiple tasks together.
Within the METS editor, Goobi suggests content to the user for several fields. This suggestion list has now been optically limited to a certain height, so that it is still easy to use even with a large number of suggestions.
Developments and news about Goobi workflow
Goobi has been enhanced so that users can now influence the visual design. Using smaller CSS instructions, each user can now adjust colors, fonts, spacing and much more for his or her own interface.
The example configuration shown here is displayed within the user settings inside of the help text and results in a visual appearance as follows:
In addition to the table columns that Goobi usually displays, additional columns can now be displayed for each user. Each user can define this for himself within his own user configuration.
The individual columns defined there are then used for the user within the process listing.
This setting is also used within the list of your own tasks.
By optimizing the database operations and massively reducing the number of checks within the file system, the overall speed of the Goobi user interface was drastically increased. This is particularly noticeable within the process list as well as in the task list.
When reading the data for the metadata editor, some nested loops with file system operations were removed. This has made opening the Metadata Editor much faster, especially for large items.
Printing the dockets is now not only possible after creating processes, but can now be done as a separate step. The checkbox Print docket
must be activated in the step details.
In the accepted task, an additional button for printing the docket is now available.
The METS Editor has been redesigned so that the image display makes optimum use of the available space. For this purpose, the entire structure of the METS Editor has been adapted so that all elements are displayed responsive. This allows not only a better display of the image container, but also an operation on mobile devices with smaller screen sizes.
Developments and news about Goobi workflow
The metadata editor has been reworked for a better image display. In particular for the ideal display with consideration of image height and image width an optimization was once again carried out. Among other things, the zoom as well as a percentage display of the image size has been made possible.
A completely new and much more flexible authentication configuration has been created for the REST API
. From now on, this configuration allows the locking and releasing of individual HTTP methods (GET
, POST
, etc.).
A sample configuration with a regular expression
for the path and the corresponding netmasks can be seen here. It only allows PUT requests against any path that matches the regular expression.
The new configuration also allows the easy acceptance of cross-origin
requests from the browser. The following example configuration shows the activation of CORS requests from the domain as for example https://intranda.com
with the methods GET
and POST
.
The actual GET
and POST
calls are allowed without IP and token restrictions.
The plugin for the quality control of digitized material has been reworked so that now the full text can be displayed in addition to the images, if it already exists. For this, the workflow must of course be configured in such a way that full text recognition must have taken place beforehand.
Developments and news about Goobi workflow
In order to guarantee the possibility to generate further individual statistics, from now on the respective storage space within the database is also cached for the individual folders of each process. This avoids the repeated retrieval of memory sizes from the file system and thus ensures better support for storage systems such as S3.
https://github.com/intranda/goobi/commit/90f694e5e41ee7c3eb4c86e7c7027c3461c3f43d
Until now, batches could only have one identifier. With the new developments, additional speaking and searchable titles can now be assigned.
These titles are thus also listed within the column for batches both in the processes and in the own tasks and can be filtered via the search filter batch
.
If, in addition to a title, dates for start and end of runtime are also entered for batches, these batches are automatically visualized within the Goobi dashboard depending on your runtime and your actual progress.
https://github.com/intranda/goobi/commit/1854d76fbfb8c6b268a8697c87e6fd1bb82c9bf4 https://github.com/intranda/goobi/commit/fb00653ddf3474a5a09ee7a282965d0bdf6efbc0 https://github.com/intranda/goobi/commit/35c181677742380a4f195088379a0503d91b4d6e
Until now, a process template always belonged to a single project. As a result, the same process templates often had to exist several times for each project, even if their content was identical. With the new change within the user interface, this is no longer necessary. Within the button for using a process template, it is now possible to use the same process template for another project. Only those projects for which the current user has authorization are listed.
https://github.com/intranda/goobi/commit/4437ceab503cee708b7a4e40497bd364b86d3242 https://github.com/intranda/goobi/commit/c9edc5db6ba0ef810c4f49e0394577e527e8abd8 https://github.com/intranda/goobi/commit/5f99d3810c940ad1f38b568eaecdcc4514b197dd