• Home
  • Features
  • Pricing
  • Docs
  • Announcements
  • Sign In

tomasnorre / crawler / 23499026960

24 Mar 2026 03:55PM UTC coverage: 68.829% (+0.009%) from 68.82%
23499026960

push

github

web-flow
[TASK] Remove Dependecy for typo3-cms/seo and only enable logic when present (#1268)

16 of 17 new or added lines in 1 file covered. (94.12%)

1899 of 2759 relevant lines covered (68.83%)

3.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.04
/Classes/Domain/Repository/QueueRepository.php
1
<?php
2

3
declare(strict_types=1);
4

5
namespace AOE\Crawler\Domain\Repository;
6

7
/*
8
 * (c) 2021 Tomas Norre Mikkelsen <tomasnorre@gmail.com>
9
 *
10
 * This file is part of the TYPO3 Crawler Extension.
11
 *
12
 * It is free software; you can redistribute it and/or modify it under
13
 * the terms of the GNU General Public License, either version 2
14
 * of the License, or any later version.
15
 *
16
 * For the full copyright and license information, please read the
17
 * LICENSE.txt file that was distributed with this source code.
18
 *
19
 * The TYPO3 project - inspiring people to share!
20
 */
21

22
use AOE\Crawler\Configuration\ExtensionConfigurationProvider;
23
use AOE\Crawler\Domain\Model\Process;
24
use AOE\Crawler\Value\QueueFilter;
25
use Doctrine\DBAL\ArrayParameterType;
26
use Doctrine\DBAL\Exception;
27
use Psr\Log\LoggerAwareInterface;
28
use Psr\Log\LoggerAwareTrait;
29
use Symfony\Contracts\Service\Attribute\Required;
30
use TYPO3\CMS\Core\Database\Connection;
31
use TYPO3\CMS\Core\Database\ConnectionPool;
32
use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
33
use TYPO3\CMS\Core\Utility\GeneralUtility;
34

35
/**
36
 * @internal since v9.2.5
37
 */
38
class QueueRepository implements LoggerAwareInterface
39
{
40
    use LoggerAwareTrait;
41

42
    final public const TABLE_NAME = 'tx_crawler_queue';
43

44
    protected array $extensionSettings;
45

46
    #[Required]
47
    public function setExtensionSettings(): void
48
    {
49
        /** @var ExtensionConfigurationProvider $configurationProvider */
50
        $configurationProvider = GeneralUtility::makeInstance(ExtensionConfigurationProvider::class);
8 ✔
51
        $this->extensionSettings = $configurationProvider->getExtensionConfiguration();
8 ✔
52
    }
53

54
    // TODO: Should be a property on the QueueObject
55
    public function unsetQueueProcessId(string $processId): void
56
    {
57
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
×
58
        $queryBuilder
×
59
            ->update(self::TABLE_NAME)
×
60
            ->where($queryBuilder->expr()->eq('process_id', $queryBuilder->createNamedParameter($processId)))
×
61
            ->set('process_id', '')
×
62
            ->executeStatement();
×
63
    }
64

65
    /**
66
     * This method is used to find the youngest entry for a given process.
67
     */
68
    public function findYoungestEntryForProcess(Process $process): array
69
    {
70
        return $this->getFirstOrLastObjectByProcess($process, 'exec_time');
1 ✔
71
    }
72

73
    /**
74
     * This method is used to find the oldest entry for a given process.
75
     */
76
    public function findOldestEntryForProcess(Process $process): array
77
    {
78
        return $this->getFirstOrLastObjectByProcess($process, 'exec_time', 'DESC');
1 ✔
79
    }
80

81
    /**
82
     * Counts all executed items of a process.
83
     *
84
     * @param Process $process
85
     */
86
    public function countExecutedItemsByProcess($process): int
87
    {
88
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
1 ✔
89

90
        return (int) $queryBuilder
1 ✔
91
            ->count('*')
1 ✔
92
            ->from(self::TABLE_NAME)
1 ✔
93
            ->where(
1 ✔
94
                $queryBuilder->expr()->eq(
1 ✔
95
                    'process_id_completed',
1 ✔
96
                    $queryBuilder->createNamedParameter($process->getProcessId())
1 ✔
97
                ),
1 ✔
98
                $queryBuilder->expr()->gt('exec_time', 0)
1 ✔
99
            )
1 ✔
100
            ->executeQuery()
1 ✔
101
            ->fetchOne();
1 ✔
102
    }
103

104
    /**
105
     * Counts items of a process which yet have not been processed/executed
106
     *
107
     * @param Process $process
108
     */
109
    public function countNonExecutedItemsByProcess($process): int
110
    {
111
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
1 ✔
112

113
        return (int) $queryBuilder
1 ✔
114
            ->count('*')
1 ✔
115
            ->from(self::TABLE_NAME)
1 ✔
116
            ->where(
1 ✔
117
                $queryBuilder->expr()->eq('process_id', $queryBuilder->createNamedParameter($process->getProcessId())),
1 ✔
118
                $queryBuilder->expr()->eq('exec_time', 0)
1 ✔
119
            )
1 ✔
120
            ->executeQuery()
1 ✔
121
            ->fetchOne();
1 ✔
122
    }
123

124
    public function getQueueEntriesByQid(int $queueId, bool $force): array|false
125
    {
126
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
3 ✔
127

128
        $queryBuilder
3 ✔
129
            ->select('*')
3 ✔
130
            ->from(self::TABLE_NAME)
3 ✔
131
            ->where(
3 ✔
132
                $queryBuilder->expr()->eq('qid', $queryBuilder->createNamedParameter($queueId, Connection::PARAM_INT))
3 ✔
133
            );
3 ✔
134
        if (!$force) {
3 ✔
135
            $queryBuilder
2 ✔
136
                ->andWhere('exec_time = 0')
2 ✔
137
                ->andWhere('process_scheduled > 0');
2 ✔
138
        }
139
        return $queryBuilder->executeQuery()->fetchAssociative();
3 ✔
140
    }
141

142
    /**
143
     * get items which have not been processed yet
144
     */
145
    public function getUnprocessedItems(): array
146
    {
147
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
5 ✔
148

149
        return $queryBuilder
5 ✔
150
            ->select('*')
5 ✔
151
            ->from(self::TABLE_NAME)
5 ✔
152
            ->where($queryBuilder->expr()->eq('exec_time', 0))
5 ✔
153
            ->executeQuery()->fetchAllAssociative();
5 ✔
154
    }
155

156
    /**
157
     * This method can be used to count all queue entrys which are
158
     * scheduled for now or a earlier date.
159
     */
160
    public function countAllPendingItems(): int
161
    {
162
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
3 ✔
163

164
        return (int) $queryBuilder
3 ✔
165
            ->count('*')
3 ✔
166
            ->from(self::TABLE_NAME)
3 ✔
167
            ->where(
3 ✔
168
                $queryBuilder->expr()->eq('process_scheduled', 0),
3 ✔
169
                $queryBuilder->expr()->eq('exec_time', 0),
3 ✔
170
                $queryBuilder->expr()->lte('scheduled', time())
3 ✔
171
            )
3 ✔
172
            ->executeQuery()
3 ✔
173
            ->fetchOne();
3 ✔
174
    }
175

176
    /**
177
     * This method can be used to count all queue entries which are
178
     * scheduled for now or an earlier date and are assigned to a process.
179
     */
180
    public function countAllAssignedPendingItems(): int
181
    {
182
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
3 ✔
183

184
        return (int) $queryBuilder
3 ✔
185
            ->count('*')
3 ✔
186
            ->from(self::TABLE_NAME)
3 ✔
187
            ->where(
3 ✔
188
                $queryBuilder->expr()->neq('process_id', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT)),
3 ✔
189
                $queryBuilder->expr()->eq('exec_time', 0),
3 ✔
190
                $queryBuilder->expr()->lte('scheduled', time())
3 ✔
191
            )
3 ✔
192
            ->executeQuery()
3 ✔
193
            ->fetchOne();
3 ✔
194
    }
195

196
    /**
197
     * Determines if a page is queued
198
     */
199
    public function isPageInQueue(
200
        int $uid,
201
        bool $unprocessed_only = true,
202
        bool $timed_only = false,
203
        int $timestamp = 0
204
    ): bool {
205
        $isPageInQueue = false;
4 ✔
206

207
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
4 ✔
208
        $statement = $queryBuilder
4 ✔
209
            ->from(self::TABLE_NAME)
4 ✔
210
            ->count('*')
4 ✔
211
            ->where(
4 ✔
212
                $queryBuilder->expr()->eq(
4 ✔
213
                    'page_id',
4 ✔
214
                    $queryBuilder->createNamedParameter($uid, Connection::PARAM_INT)
4 ✔
215
                )
4 ✔
216
            );
4 ✔
217

218
        if ($unprocessed_only !== false) {
4 ✔
219
            $statement->andWhere($queryBuilder->expr()->eq('exec_time', 0));
1 ✔
220
        }
221

222
        if ($timed_only !== false) {
4 ✔
223
            $statement->andWhere($queryBuilder->expr()->neq('scheduled', 0));
1 ✔
224
        }
225

226
        if ($timestamp) {
4 ✔
227
            $statement->andWhere(
1 ✔
228
                $queryBuilder->expr()->eq(
1 ✔
229
                    'scheduled',
1 ✔
230
                    $queryBuilder->createNamedParameter($timestamp, Connection::PARAM_INT)
1 ✔
231
                )
1 ✔
232
            );
1 ✔
233
        }
234

235
        // TODO: Currently it's not working if page doesn't exists. See tests
236
        $count = $statement
4 ✔
237
            ->executeQuery()
4 ✔
238
            ->fetchOne();
4 ✔
239

240
        if ($count !== false && $count > 0) {
4 ✔
241
            $isPageInQueue = true;
3 ✔
242
        }
243

244
        return $isPageInQueue;
4 ✔
245
    }
246

247
    public function cleanupQueue(): void
248
    {
249
        $extensionSettings = GeneralUtility::makeInstance(
3 ✔
250
            ExtensionConfigurationProvider::class
3 ✔
251
        )->getExtensionConfiguration();
3 ✔
252
        $purgeDays = (int) $extensionSettings['purgeQueueDays'];
3 ✔
253

254
        if ($purgeDays > 0) {
3 ✔
255
            $purgeDate = time() - 24 * 60 * 60 * $purgeDays;
3 ✔
256

257
            $queryBuilderDelete = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(
3 ✔
258
                self::TABLE_NAME
3 ✔
259
            );
3 ✔
260
            $del = $queryBuilderDelete
3 ✔
261
                ->delete(self::TABLE_NAME)
3 ✔
262
                ->where('exec_time != 0 AND exec_time < ' . $purgeDate)->executeStatement();
3 ✔
263

264
            if ($del === 0) {
3 ✔
265
                $this->logger?->info('No records was deleted');
1 ✔
266
            }
267
        }
268
    }
269

270
    /**
271
     * Cleans up entries that stayed for too long in the queue. These are default:
272
     * - processed entries that are over 1.5 days in age
273
     * - scheduled entries that are over 7 days old
274
     */
275
    public function cleanUpOldQueueEntries(): void
276
    {
277
        $extensionSettings = GeneralUtility::makeInstance(
6 ✔
278
            ExtensionConfigurationProvider::class
6 ✔
279
        )->getExtensionConfiguration();
6 ✔
280
        // 24*60*60 Seconds in 24 hours
281
        $processedAgeInSeconds = $extensionSettings['cleanUpProcessedAge'] * 86400;
6 ✔
282
        $scheduledAgeInSeconds = $extensionSettings['cleanUpScheduledAge'] * 86400;
6 ✔
283

284
        $now = time();
6 ✔
285
        $condition = '(exec_time<>0 AND exec_time<' . ($now - $processedAgeInSeconds) . ') OR scheduled<=' . ($now - $scheduledAgeInSeconds);
6 ✔
286

287
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
6 ✔
288
        $del = $queryBuilder
6 ✔
289
            ->delete(self::TABLE_NAME)
6 ✔
290
            ->where($condition)->executeStatement();
6 ✔
291

292
        if ($del === 0) {
6 ✔
293
            $this->logger?->info('No records was deleted.');
6 ✔
294
        }
295
    }
296

297
    public function fetchRecordsToBeCrawled(int $countInARun): array
298
    {
299
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(
4 ✔
300
            self::TABLE_NAME
4 ✔
301
        );
4 ✔
302

303
        $isSeoEnabled = ExtensionManagementUtility::isLoaded('seo');
4 ✔
304
        $fields = ['qid', 'scheduled', 'page_id'];
4 ✔
305
        if ($isSeoEnabled) {
4 ✔
306
            $fields[] = 'sitemap_priority';
4 ✔
307
        }
308

309
        $queryBuilder
4 ✔
310
            ->select(...$fields)
4 ✔
311
            ->from(self::TABLE_NAME)
4 ✔
312
            ->leftJoin(
4 ✔
313
                self::TABLE_NAME,
4 ✔
314
                'pages',
4 ✔
315
                'p',
4 ✔
316
                $queryBuilder->expr()->eq('p.uid', $queryBuilder->quoteIdentifier(self::TABLE_NAME . '.page_id'))
4 ✔
317
            )
4 ✔
318
            ->where(
4 ✔
319
                $queryBuilder->expr()->eq('exec_time', 0),
4 ✔
320
                $queryBuilder->expr()->eq('process_scheduled', 0),
4 ✔
321
                $queryBuilder->expr()->lte('scheduled', time())
4 ✔
322
            );
4 ✔
323

324
        if ($isSeoEnabled) {
4 ✔
325
            $queryBuilder->orderBy('sitemap_priority', 'DESC');
4 ✔
326
            $queryBuilder->addOrderBy('scheduled');
4 ✔
327
        } else {
NEW
328
            $queryBuilder->orderBy('scheduled');
×
329
        }
330

331
        return $queryBuilder
4 ✔
332
            ->addOrderBy('qid')
4 ✔
333
            ->setMaxResults($countInARun)
4 ✔
334
            ->executeQuery()
4 ✔
335
            ->fetchAllAssociative();
4 ✔
336
    }
337

338
    public function updateProcessIdAndSchedulerForQueueIds(array $quidList, string $processId): int
339
    {
340
        $queryBuilderUpdate = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(
3 ✔
341
            self::TABLE_NAME
3 ✔
342
        );
3 ✔
343
        return $queryBuilderUpdate
3 ✔
344
            ->update(self::TABLE_NAME)
3 ✔
345
            ->where($queryBuilderUpdate->expr()->in('qid', $quidList))
3 ✔
346
            ->set('process_scheduled', (string) time())
3 ✔
347
            ->set('process_id', $processId)
3 ✔
348
            ->executeStatement();
3 ✔
349
    }
350

351
    public function unsetProcessScheduledAndProcessIdForQueueEntries(array $processIds): void
352
    {
353
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
3 ✔
354
        $queryBuilder
3 ✔
355
            ->update(self::TABLE_NAME)
3 ✔
356
            ->where(
3 ✔
357
                $queryBuilder->expr()->eq('exec_time', $queryBuilder->createNamedParameter(0, Connection::PARAM_INT)),
3 ✔
358
                $queryBuilder->expr()->in(
3 ✔
359
                    'process_id',
3 ✔
360
                    $queryBuilder->createNamedParameter($processIds, ArrayParameterType::STRING)
3 ✔
361
                )
3 ✔
362
            )
3 ✔
363
            ->set('process_scheduled', '0')
3 ✔
364
            ->set('process_id', '0')
3 ✔
365
            ->executeStatement();
3 ✔
366
    }
367

368
    /**
369
     * This method is used to count if there are ANY unprocessed queue entries
370
     * of a given page_id and the configuration which matches a given hash.
371
     * If there is none, we can skip an inner detail check
372
     */
373
    public function noUnprocessedQueueEntriesForPageWithConfigurationHashExist(
374
        int $uid,
375
        string $configurationHash
376
    ): bool {
377
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
8 ✔
378
        $noUnprocessedQueueEntriesFound = true;
8 ✔
379

380
        $result = $queryBuilder
8 ✔
381
            ->count('*')
8 ✔
382
            ->from(self::TABLE_NAME)
8 ✔
383
            ->where(
8 ✔
384
                $queryBuilder->expr()->eq('page_id', $uid),
8 ✔
385
                $queryBuilder->expr()->eq(
8 ✔
386
                    'configuration_hash',
8 ✔
387
                    $queryBuilder->createNamedParameter($configurationHash)
8 ✔
388
                ),
8 ✔
389
                $queryBuilder->expr()->eq('exec_time', 0)
8 ✔
390
            )
8 ✔
391
            ->executeQuery()
8 ✔
392
            ->fetchOne();
8 ✔
393

394
        if ($result) {
8 ✔
395
            $noUnprocessedQueueEntriesFound = false;
3 ✔
396
        }
397

398
        return $noUnprocessedQueueEntriesFound;
8 ✔
399
    }
400

401
    /**
402
     * Removes queue entries
403
     */
404
    public function flushQueue(QueueFilter $queueFilter): void
405
    {
406
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
8 ✔
407

408
        switch ($queueFilter) {
409
            case 'all':
8 ✔
410
                // No where claus needed delete everything
411
                break;
4 ✔
412
            case 'pending':
4 ✔
413
                $queryBuilder->andWhere($queryBuilder->expr()->eq('exec_time', 0));
2 ✔
414
                break;
2 ✔
415
            case 'finished':
2 ✔
416
            default:
417
                $queryBuilder->andWhere($queryBuilder->expr()->gt('exec_time', 0));
2 ✔
418
                break;
2 ✔
419
        }
420

421
        $queryBuilder
8 ✔
422
            ->delete(self::TABLE_NAME)
8 ✔
423
            ->executeStatement();
8 ✔
424
    }
425

426
    public function getDuplicateQueueItemsIfExists(
427
        bool $enableTimeslot,
428
        int $timestamp,
429
        int $currentTime,
430
        int $pageId,
431
        string $parametersHash
432
    ): array {
433
        $rows = [];
8 ✔
434

435
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
8 ✔
436
        $queryBuilder
8 ✔
437
            ->select('qid')
8 ✔
438
            ->from(self::TABLE_NAME);
8 ✔
439
        //if this entry is scheduled with "now"
440
        if ($timestamp <= $currentTime) {
8 ✔
441
            if ($enableTimeslot) {
3 ✔
442
                $timeBegin = $currentTime - 100;
2 ✔
443
                $timeEnd = $currentTime + 100;
2 ✔
444
                $queryBuilder
2 ✔
445
                    ->where('scheduled BETWEEN ' . $timeBegin . ' AND ' . $timeEnd . ' ')
2 ✔
446
                    ->orWhere($queryBuilder->expr()->lte('scheduled', $currentTime));
2 ✔
447
            } else {
448
                $queryBuilder
1 ✔
449
                    ->where($queryBuilder->expr()->lte('scheduled', $currentTime));
1 ✔
450
            }
451
        } elseif ($timestamp > $currentTime) {
5 ✔
452
            //entry with a timestamp in the future need to have the same schedule time
453
            $queryBuilder
5 ✔
454
                ->where($queryBuilder->expr()->eq('scheduled', $timestamp));
5 ✔
455
        }
456

457
        $queryBuilder
8 ✔
458
            ->andWhere($queryBuilder->expr()->eq('exec_time', 0))
8 ✔
459
            ->andWhere($queryBuilder->expr()->eq('process_id', "''"))
8 ✔
460
            ->andWhere(
8 ✔
461
                $queryBuilder->expr()->eq(
8 ✔
462
                    'page_id',
8 ✔
463
                    $queryBuilder->createNamedParameter($pageId, Connection::PARAM_INT)
8 ✔
464
                )
8 ✔
465
            )
8 ✔
466
            ->andWhere(
8 ✔
467
                $queryBuilder->expr()->eq('parameters_hash', $queryBuilder->createNamedParameter(
8 ✔
468
                    $parametersHash,
8 ✔
469
                    Connection::PARAM_STR
8 ✔
470
                ))
8 ✔
471
            );
8 ✔
472

473
        $statement = $queryBuilder->executeQuery();
8 ✔
474

475
        while ($row = $statement->fetchAssociative()) {
8 ✔
476
            $rows[] = $row['qid'];
2 ✔
477
        }
478

479
        return $rows;
8 ✔
480
    }
481

482
    public function getQueueEntriesForPageId(int $id, int $itemsPerPage, QueueFilter $queueFilter): array
483
    {
484
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
4 ✔
485
        $queryBuilder
4 ✔
486
            ->select('*')
4 ✔
487
            ->from(self::TABLE_NAME)
4 ✔
488
            ->where(
4 ✔
489
                $queryBuilder->expr()->eq('page_id', $queryBuilder->createNamedParameter(
4 ✔
490
                    $id,
4 ✔
491
                    Connection::PARAM_INT
4 ✔
492
                ))
4 ✔
493
            )
4 ✔
494
            ->orderBy('scheduled', 'DESC');
4 ✔
495

496
        $expressionBuilder = GeneralUtility::makeInstance(ConnectionPool::class)
4 ✔
497
            ->getConnectionForTable(self::TABLE_NAME)
4 ✔
498
            ->getExpressionBuilder();
4 ✔
499
        $query = $expressionBuilder->and();
4 ✔
500
        // PHPStorm adds the highlight that the $addWhere is immediately overwritten,
501
        // but the $query = $expressionBuilder->andX() ensures that the $addWhere is written correctly with AND
502
        // between the statements, it's not a mistake in the code.
503
        switch ($queueFilter) {
504
            case 'pending':
4 ✔
505
                $queryBuilder->andWhere($queryBuilder->expr()->eq('exec_time', 0));
1 ✔
506
                break;
1 ✔
507
            case 'finished':
3 ✔
508
                $queryBuilder->andWhere($queryBuilder->expr()->gt('exec_time', 0));
1 ✔
509
                break;
1 ✔
510
        }
511

512
        if ($itemsPerPage > 0) {
4 ✔
513
            $queryBuilder
4 ✔
514
                ->setMaxResults($itemsPerPage);
4 ✔
515
        }
516

517
        return $queryBuilder->executeQuery()->fetchAllAssociative();
4 ✔
518
    }
519

520
    /**
521
     * @throws Exception
522
     */
523
    public function findAll(): array
524
    {
525
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
14 ✔
526
        $queryBuilder
14 ✔
527
            ->select('*')
14 ✔
528
            ->from(self::TABLE_NAME);
14 ✔
529
        return $queryBuilder->executeQuery()->fetchAllAssociative();
14 ✔
530
    }
531

532
    public function findByProcessId(string $processId): array
533
    {
534
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
×
535
        return $queryBuilder
×
536
            ->select('*')
×
537
            ->from(self::TABLE_NAME)
×
538
            ->where(
×
539
                $queryBuilder->expr()->eq('process_id', $queryBuilder->createNamedParameter(
×
540
                    $processId,
×
541
                    Connection::PARAM_INT
×
542
                ))
×
543
            )
×
544
            ->executeQuery()->fetchAllAssociative();
×
545
    }
546

547
    /**
548
     * This internal helper method is used to create an instance of an entry object
549
     *
550
     * @param Process $process
551
     * @param string $orderByField first matching item will be returned as object
552
     * @param string $orderBySorting sorting direction
553
     */
554
    protected function getFirstOrLastObjectByProcess($process, $orderByField, $orderBySorting = 'ASC'): array
555
    {
556
        $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable(self::TABLE_NAME);
5 ✔
557
        $first = $queryBuilder
5 ✔
558
            ->select('*')
5 ✔
559
            ->from(self::TABLE_NAME)
5 ✔
560
            ->where(
5 ✔
561
                $queryBuilder->expr()->eq(
5 ✔
562
                    'process_id_completed',
5 ✔
563
                    $queryBuilder->createNamedParameter($process->getProcessId())
5 ✔
564
                ),
5 ✔
565
                $queryBuilder->expr()->gt('exec_time', 0)
5 ✔
566
            )
5 ✔
567
            ->setMaxResults(1)
5 ✔
568
            ->addOrderBy($orderByField, $orderBySorting)
5 ✔
569
            ->executeQuery()->fetchAssociative();
5 ✔
570

571
        return $first ?: [];
5 ✔
572
    }
573
}
STATUS · Troubleshooting · Open an Issue · Sales · Support · CAREERS · ENTERPRISE · START FREE TRIAL · SCHEDULE DEMO
ANNOUNCEMENTS · TWITTER · TOS & SLA · Supported CI Services · What's a CI service? · Automated Testing

© 2026 Coveralls, Inc