Types 

Each table link has one of the following types:

Simple synchronisation 

The data sets of the JobData table are synchronised in a table provided by this extension. This is the recommended type if you only want to display data, for example, with the content element. Have a look at the developer corner to see the schema of the table and how to use it in your code. The synchronisation is done with the available synchronisation command.

The following fields are available:

Synchronisation in custom table 

You have to define a table yourself in an extension with the needed columns from the JobData table. This is the recommended way when you want to display the data yourself, for example, with filtering by some columns or with joins to other data. The synchronisation is carried out with the available synchronisation command.

The following fields are available:

Form finisher 

The fields from a form are stored into a JobData table. An intermediate transfer table is used, so you have to activate the transmit command.

The following fields are available:

Other usage 

You only define the link to a JobData table – there is no automatic synchronisation. This type can be used for the TYPO3 JobRouter Form extension to push the field values of a submitted form into a JobData table. Also you can synchronise data sets yourself and enrich the data with additional information.

The following fields are available:

Transmit to a JobData table 

So, let's start with an example. The form finisher is defined in the YAML configuration of the specific form:

finishers:
   -
      identifier: JobRouterTransmitData
      options:
         handle: 'website_contact'
         columns:
            name: '{preName} {lastName}'
            company: '{company}'
            email_address: '{email}'
            phone_number: '{phone}'
            message: '{message}'
            source: 'Website'

The handle is required as it connects the fields to the appropriate table link.

You can map the form fields to the JobData columns. As you can see in the example above, you define the JobData column as the key (for example, email_address) and then map it with the value to be stored. This can be the form field identifier which is enclosed in curly brackets (for example, {email}), a static value, a combination of a static value with a form field or even multiple form fields.

Start multiple transmissions 

It is also possible to start multiple transmissions – even on different JobRouter® installations. Just use the array notation in options:

finishers:
   -
      identifier: JobRouterTransmitData
      options:
         -
            handle: 'website_contact'
            columns:
               name: '{preName} {lastName}'
               company: '{company}'
               email_address: '{email}'
               phone_number: '{phone}'
               message: '{message}'
               source: 'Website'
         -
            handle: 'anonymous_messages'
            columns:
               ANON_MESSAGE: '{message}'
               FROM_URL: 'https://www.example.com/demo'

Variables 

You can use variables as column values. For more information have a look into the available variable resolvers. You can also write your own variable resolvers.

Example 

A PSR-14 event listener can be used for this case. In the following example, a record is rejected under a certain condition and a static string is added to each "position" column value.

1. Create the event listener

   EXT:my_extension/Classes/EventListener/AdjustJobsDataset.php

   <?php
   declare(strict_types=1);
   
   namespace MyVendor\MyExtension\EventListener;
   
   use JobRouter\AddOn\Typo3Data\Event\ModifyDatasetOnSynchronisationEvent;
   
   final class AdjustJobsDataset
   {
      public function __invoke(ModifyDatasetOnSynchronisationEvent $event): void
      {
         // Only the table with the handle "jobs" should be considered
         if ($event->getTable()->handle !== 'jobs') {
            return;
         }
   
         $dataset = $event->getDataset();
         if ($dataset['jrid'] === 3) {
            // For some reason we don't like jrid = 3, so we reject it
            // and it doesn't get synchronised
            $event->setRejected();
         }
   
         $dataset['POSITION'] .= ' (approved by me™)';
         $event->setDataset($dataset);
      }
   }

   Copied!

2. Register your event listener

   EXT:my_extension/Configuration/Services.yaml

   services:
      MyVendor\MyExtension\EventListener\AdjustJobsDataset:
         tags:
            - name: event.listener
              identifier: 'adjustJobsDataset'

   Copied!

Simple synchronisation table 

When a JobData table is synchronised with the Simple synchronisation type, the data sets are stored in a table provided by this extension. This is the simplest type, as no programming knowledge is required. The data sets are stored JSON-encoded in a provided table and can be displayed on the website with a content element.

However, you can also retrieve the data sets independently.

<?php
declare(strict_types = 1);

namespace MyVendor\MyExtension;

use JobRouter\AddOn\Typo3Data\Domain\Entity\Dataset;
use JobRouter\AddOn\Typo3Data\Domain\Repository\DatasetRepository;

final class MyClass
{
   public function __construct(
      private readonly DatasetRepository $datasetRepository,
   ) {
   }

   public function doSomething(): void
   {
      /** @var Dataset[] $datasets */
      $datasets = $this->datasetRepository->findByTableUid(1);

      foreach ($datasets as $dataset) {
         // Show the jrid
         var_dump($dataset->jrid);

         // Get the content of the column "TRAINING"
         var_dump($dataset->dataset('TRAINING'));
      }
   }
}

Custom table 

Synchronising a JobData table into a custom table has some advantages and disadvantages compared to the simple synchronisation type described above:

• Flexibility: You can filter the content of a synchronised table with specific SQL queries, because all JobData columns are stored in separate columns in the TYPO3 table.
• Joining data: You can join the table with other tables in your domain.
• Easy usage: for example, in TCA select boxes against the simple synchronisation.
• More Work: You have to implement the logic yourself.

But let's start:

1. Create a new extension or use an existing one. Consult the TYPO3 manual how to do this.

2. Add or append the table definition to the file ext_tables.sql:

   EXT:my_extension/ext_tables.sql

   CREATE TABLE tx_myextension_domain_model_jobs (
      uid int(11) unsigned NOT NULL AUTO_INCREMENT,
      jrid int(11) unsigned DEFAULT '0' NOT NULL,
      position varchar(255)  DEFAULT '' NOT NULL,
      active smallint(5) unsigned DEFAULT '0' NOT NULL,
   
      PRIMARY KEY (uid),
      UNIQUE KEY tableuid_jrid (table_uid, jrid),
      KEY table_uid (table_uid)
   );

   Copied!

   The table name must start with tx_ to be recognised as an custom table in the module.

   It is recommended to add a primary key to the table. In this example it is calls uid to be in line with TYPO3.

   It must also have a column jrid. Add a unique or primary key for the jrid column.

   Add the columns to be synchronised from the JobData table (in the example position and active in this jobs example. The column type must be named as in the JobData table.

3. Go to the Admin Tools > Maintenance module, click on the Analyse database button and create the table.
4. Add a table link in the backend module.

This is the minimal setup to synchronise a JobData table into a custom TYPO3 table. How you use the table depends on your use case.

Other usage 

Links to JobData tables are also centralised in the JobRouter > Data module, in contrast to the definition in PHP code.

The table link type Other usage can be used to facilitate the access to a JobData table. Links to JobData tables are also centralised in the Data module, in contrast to the definition in PHP code.

Here is an example to get the table link and initialise the JobRouter REST Client:

<?php
declare(strict_types = 1);

namespace MyVendor\MyExtension;

use JobRouter\AddOn\Typo3Connector\RestClient\RestClientFactory;
use JobRouter\AddOn\Typo3Connector\Domain\Entity\Connection;
use JobRouter\AddOn\Typo3Connector\Domain\Repository\ConnectionRepository;
use JobRouter\AddOn\Typo3Connector\Exception\ConnectionNotFoundException;
use JobRouter\AddOn\Typo3Data\Domain\Entity\Table;
use JobRouter\AddOn\Typo3Data\Domain\Repository\TableRepository;
use JobRouter\AddOn\Typo3Data\Exception\TableNotFoundException;

public function MyClass
{
   public function __construct(
      private readonly ConnectionRepository $connectionRepository,
      private readonly TableRepository $tableRepository,
   ) {}

   public function doSomething(): void
   {
      try {
         /** @var Table $table */
         $table = $this->tableRepository->findOneByHandle('contacts');

         /** @var Connection $connection */
         $connection = $this->connectionRepository->findByUid($table->connectionUid);

         // Create a JobRouter Client RestClient object
         $client = (new RestClientFactory())->create($connection);
         $response = $restClient->request(
            'GET',
            sprintf('application/jobdata/tables/%s/datasets', $table->getTableGuid())
         );

         // Do something with the response ...
      } catch (TableNotFoundException|ConnectionNotFoundException) {
      }
   }
}

Have a look into the JobRouter REST Client documentation how to use it. The library eases the access to the JobRouter® REST API.

Preparing the data sets 

If you want to transfer data sets programmatically to a JobRouter® installation, you can use the Preparer class within TYPO3, for example, in an Extbase controller:

<?php
declare(strict_types=1);

namespace MyVendor\MyExtension\Controller;

use JobRouter\AddOn\Typo3Data\Exception\PrepareException;
use JobRouter\AddOn\Typo3Data\Transfer\Preparer;
use TYPO3\CMS\Extbase\Mvc\Controller\ActionController;
use Psr\Http\Message\ResponseInterface;

final class MyController extends ActionController
{
   public function __construct(
      private readonly Preparer $preparer,
   ) {
   }

   public function myAction(): ResponseInterface
   {
      // ... some other code

      try {
         $this-preparer->store(
             // The table link uid
            42,
            // Some descriptive identifier for the source of the dataset
            'some identifier',
            // Your JSON encoded data set
            '{"your": "data", "to": "transfer"}'
         );
      } catch (PrepareException $e) {
         // In some rare cases an exception may be thrown
         var_dump($e->getMessage());
      }

      // ... some other code
   }

The transmit command must be activated with a cron job to periodically transmit the data sets to the JobRouter® installation(s).

Example 

<?php
declare(strict_types=1);

namespace MyVendor\MyExtension\Command;

final class MyCommand extends Command
{
   public function __construct(
      private readonly JobDataRepository $jobDataRepository,
   ) {
     parent::__construct();
   }

   protected function execute(InputInterface $input, OutputInterface $output): int
   {
      $datasets = $this->jobDataRepository->findAll('some_handle');

      // ... your logic

      return 0;
   }
}

Custom formatters 

As a PSR-14 event is dispatched for formatting a cell content, a custom event listener can be used. Have a look into the existing formatter event listeners.

Added 

• Compatibility with TYPO3 v13
• Add site set for TYPO3 v13

Changed 

• TypoScript must now be included/imported

Removed 

• Compatibility with TYPO3 v11

Fixed 

• Long runtime when checking table connection in backend module

Fixed 

• Closing edit view in backend shows empty page
• Disabled table links are not marked in backend list view

Changed 

• Require JobRouter REST Client in version 3
• Namespace from Brotkrueml\JobRouterData to JobRouter\AddOn\Typo3Data

Added 

• Compatibility with TYPO3 v12

Changed 

• Require JobRouter Client in version 2
• Require JobRouter Connector extension in version 2
• Require JobRouter Base extension in version 2
• Constants from Table model are moved into the new TableType enum
• Models are no longer Extbase-based and are moved to the Domain/Entity namespace
• Repositories are no longer Extbase-based
• JobDataRepository is now injectable, method signatures have changed
• ModifyColumnContentEvent->getLocale() might return a different locale in TYPO3 v12

Fixed 

• Error in content element when table link is disabled or deleted

Removed 

• Compatibility with TYPO3 v10 (#14)
• Compatibility with PHP 7.4 and 8.0

Fixed 

• Avoid injecting the query builder

Fixed 

• Exception in frontend using JobData Table plugin in TYPO3 v10 (#22)

Removed 

• Compatibility with PHP 7.3

Fixed 

• Handle multibyte characters correctly when cutting string to given length for transmission

Added 

• Formatters for table columns in content element (#10)
• Alignment for table columns in content element (#11)
• Sorting of table columns in content element (#12)
• PSR-14 event to adjust or reject a dataset on synchronisation (#13)
• Option in sync command for forcing a synchronisation

Changed 

• Store only configured columns with simple synchronisation

Fixed 

• Domain model Table::setHandle() sets the correct property
• Database error in module DB Check > Records Statistics due to wrong labels in TCA

Removed 

• Configuration of log writers in the extension configuration

Added 

• Compatibility with TYPO3 v11 LTS
• Possibility to refresh dashboard widgets (TYPO3 v11+ only)

Changed 

• Rename "own table" to "custom table"
• Use table handle instead of uid as argument in SyncCommand

Deprecated 

• Configuration of log writers in the extension configuration

Fixed 

• Content element cannot be selected from new content element wizard

Removed 

• Compatibility with PHP 7.2

Added 

• Show number of days for available transfers in status widget

Updated 

• TYPO3 JobRouter Connector to version 1.0
• TYPO3 JobRouter Base to version 1.0

Fixed 

• Set crdate in transfer table correctly

Added 

• Dashboard widget "JobData Transmission Errors"

Changed 

• TYPO3 form extension is no longer a requirement

Changed 

• Raise minimum required version to TYPO3 10.4.11
• Throw DatasetNotAvailableException in JobDataRepository when querying a non-existing jrid

Added 

• Form finisher to transmit form fields to a JobData table
• Dashboard widget for JobData transmission status

Changed 

• Use log table from TYPO3 JobRouter Base extension
• Rename "transfer identifier" to "correlation id" in transfer table

Fixed 

• Store jrid correctly in transfer table after transmission
• Lazy load client in JobDataRepository to avoid errors on initialisation

Removed 

• Report

Added 

• Description field to table record
• Introduce the JobDataRepository

Updated 

• TYPO3 JobRouter Connector to version 0.11

Removed 

• RestClientFactory is not available anymore, use from connector extension instead

Added 

• Support for TYPO3 v10 LTS
• Prepare for upcoming major PHP versions
• Introduce a handle field for table links
• Add last run of sync and transmit command to system information toolbar

Changed 

• Rename DeleteOldTransfersCommand to CleanUpTransfersCommand

Removed 

• Support for TYPO3 v9 LTS

Added 

• Command for deleting old transfers
• Use own user agent addition

Updated 

• TYPO3 JobRouter Connector to version 0.9

Fixed 

• Only one command (sync, transmit) can run at a time

Added 

• Implement reports for synchronisation and transfers

Changed 

• Remove plugin in favour of content element
• Use log table from TYPO3 JobRouter Connector

Added 

• Command for transmitting datasets to JobData tables
• Documentation

Changed 

• Renamed table column (local_table => own_table) in table tx_jobrouterdata_domain_model_table
• Revise logging and enable logging into table

Updated 

• TYPO3 JobRouter Connector to version 0.7

Removed 

• Switchable controller actions in plugin

Fixed 

• Sync other tables when one table throws error on synchronisation

Updated 

• TYPO3 JobRouter Connector to version 0.6

Updated 

• TYPO3 JobRouter Connector to version 0.5

Fixed 

• Delete datasets from simple synchronisation when table is deleted (#6)
• Clear cache of a page with plugin after synchronisation (#7)

Updated 

• TYPO3 JobRouter Connector to version 0.4

Added 

• DatasetRepository
• Possibility to add tables for other usage in module

Changed 

• Dataset model

Changed 

• Adjust package name