1
|
|
|
<?php |
2
|
|
|
|
3
|
|
|
/** |
4
|
|
|
* Calendar. |
5
|
|
|
*/ |
6
|
|
|
declare(strict_types=1); |
7
|
|
|
|
8
|
|
|
namespace HDNET\Calendarize\Controller; |
9
|
|
|
|
10
|
|
|
use HDNET\Calendarize\Domain\Model\Index; |
11
|
|
|
use HDNET\Calendarize\Register; |
12
|
|
|
use HDNET\Calendarize\Utility\DateTimeUtility; |
13
|
|
|
use HDNET\Calendarize\Utility\EventUtility; |
14
|
|
|
use HDNET\Calendarize\Utility\ExtensionConfigurationUtility; |
15
|
|
|
use HDNET\Calendarize\Utility\TranslateUtility; |
16
|
|
|
use TYPO3\CMS\Backend\Utility\BackendUtility; |
17
|
|
|
use TYPO3\CMS\Core\Utility\ClassNamingUtility; |
18
|
|
|
use TYPO3\CMS\Core\Utility\GeneralUtility; |
19
|
|
|
use TYPO3\CMS\Core\Utility\MathUtility; |
20
|
|
|
use TYPO3\CMS\Extbase\Configuration\ConfigurationManagerInterface; |
21
|
|
|
use TYPO3\CMS\Extbase\DomainObject\DomainObjectInterface; |
22
|
|
|
use TYPO3\CMS\Extbase\Object\ObjectManager; |
23
|
|
|
use TYPO3\CMS\Extbase\Persistence\QueryInterface; |
24
|
|
|
use TYPO3\CMS\Extbase\Property\TypeConverter\DateTimeConverter; |
25
|
|
|
use TYPO3\CMS\Extbase\SignalSlot\Dispatcher; |
26
|
|
|
|
27
|
|
|
/** |
28
|
|
|
* Calendar. |
29
|
|
|
*/ |
30
|
|
|
class CalendarController extends AbstractController |
31
|
|
|
{ |
32
|
|
|
/** |
33
|
|
|
* Init all actions. |
34
|
|
|
*/ |
35
|
|
|
public function initializeAction() |
36
|
|
|
{ |
37
|
|
|
parent::initializeAction(); |
38
|
|
|
if (isset($this->settings['format'])) { |
39
|
|
|
$this->request->setFormat($this->settings['format']); |
40
|
|
|
} |
41
|
|
|
$this->indexRepository->setIndexTypes(GeneralUtility::trimExplode(',', $this->settings['configuration'], true)); |
42
|
|
|
$additionalSlotArguments = [ |
43
|
|
|
'contentRecord' => $this->configurationManager->getContentObject()->data, |
44
|
|
|
'settings' => $this->settings, |
45
|
|
|
]; |
46
|
|
|
$this->indexRepository->setAdditionalSlotArguments($additionalSlotArguments); |
47
|
|
|
|
48
|
|
|
if (isset($this->settings['sorting'])) { |
49
|
|
|
if (isset($this->settings['sortBy'])) { |
50
|
|
|
$this->indexRepository->setDefaultSortingDirection($this->settings['sorting'], $this->settings['sortBy']); |
51
|
|
|
} else { |
52
|
|
|
$this->indexRepository->setDefaultSortingDirection($this->settings['sorting']); |
53
|
|
|
} |
54
|
|
|
} |
55
|
|
|
|
56
|
|
|
if (isset($this->arguments['startDate'])) { |
57
|
|
|
$this->arguments['startDate']->getPropertyMappingConfiguration() |
58
|
|
|
->setTypeConverterOption( |
59
|
|
|
DateTimeConverter::class, |
60
|
|
|
DateTimeConverter::CONFIGURATION_DATE_FORMAT, |
61
|
|
|
$this->settings['dateFormat'] |
62
|
|
|
); |
63
|
|
|
} |
64
|
|
|
if (isset($this->arguments['endDate'])) { |
65
|
|
|
$this->arguments['endDate']->getPropertyMappingConfiguration() |
66
|
|
|
->setTypeConverterOption( |
67
|
|
|
DateTimeConverter::class, |
68
|
|
|
DateTimeConverter::CONFIGURATION_DATE_FORMAT, |
69
|
|
|
$this->settings['dateFormat'] |
70
|
|
|
); |
71
|
|
|
} |
72
|
|
|
if ($this->request->hasArgument('event') && 'detailAction' === $this->actionMethodName) { |
73
|
|
|
// default configuration |
74
|
|
|
$configurationName = $this->settings['configuration']; |
75
|
|
|
// configuration overwritten by argument? |
76
|
|
|
if ($this->request->hasArgument('extensionConfiguration')) { |
77
|
|
|
$configurationName = $this->request->getArgument('extensionConfiguration'); |
78
|
|
|
} |
79
|
|
|
// get the configuration |
80
|
|
|
$configuration = ExtensionConfigurationUtility::get($configurationName); |
81
|
|
|
|
82
|
|
|
// get Event by Configuration and Uid |
83
|
|
|
$event = EventUtility::getOriginalRecordByConfiguration($configuration, (int) $this->request->getArgument('event')); |
84
|
|
|
$index = $this->indexRepository->findByEventTraversing($event, true, false, 1)->getFirst(); |
85
|
|
|
|
86
|
|
|
// if there is a valid index in the event |
87
|
|
|
if ($index) { |
88
|
|
|
$this->redirect('detail', null, null, ['index' => $index]); |
89
|
|
|
} |
90
|
|
|
} |
91
|
|
|
} |
92
|
|
|
|
93
|
|
|
/** |
94
|
|
|
* Latest action. |
95
|
|
|
* |
96
|
|
|
* @param \HDNET\Calendarize\Domain\Model\Index $index |
97
|
|
|
* @param \DateTime $startDate |
98
|
|
|
* @param \DateTime $endDate |
99
|
|
|
* @param array $customSearch * |
100
|
|
|
* @param int $year |
101
|
|
|
* @param int $month |
102
|
|
|
* @param int $week |
103
|
|
|
* |
104
|
|
|
* @ignorevalidation $startDate |
105
|
|
|
* @ignorevalidation $endDate |
106
|
|
|
* @ignorevalidation $customSearch |
107
|
|
|
* |
108
|
|
|
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\StopActionException |
109
|
|
|
*/ |
110
|
|
|
public function latestAction( |
111
|
|
|
Index $index = null, |
112
|
|
|
\DateTime $startDate = null, |
113
|
|
|
\DateTime $endDate = null, |
114
|
|
|
array $customSearch = [], |
115
|
|
|
$year = null, |
116
|
|
|
$month = null, |
117
|
|
|
$week = null |
118
|
|
|
) { |
119
|
|
|
$this->checkStaticTemplateIsIncluded(); |
120
|
|
|
if (($index instanceof Index) && \in_array('detail', $this->getAllowedActions(), true)) { |
121
|
|
|
$this->forward('detail'); |
122
|
|
|
} |
123
|
|
|
|
124
|
|
|
$search = $this->determineSearch($startDate, $endDate, $customSearch, $year, $month, null, $week); |
125
|
|
|
|
126
|
|
|
$this->slotExtendedAssignMultiple([ |
127
|
|
|
'indices' => $search['indices'], |
128
|
|
|
'searchMode' => $search['searchMode'], |
129
|
|
|
'searchParameter' => [ |
130
|
|
|
'startDate' => $startDate, |
131
|
|
|
'endDate' => $endDate, |
132
|
|
|
'customSearch' => $customSearch, |
133
|
|
|
'year' => $year, |
134
|
|
|
'month' => $month, |
135
|
|
|
'week' => $week, |
136
|
|
|
], |
137
|
|
|
], __CLASS__, __FUNCTION__); |
138
|
|
|
} |
139
|
|
|
|
140
|
|
|
/** |
141
|
|
|
* Result action. |
142
|
|
|
* |
143
|
|
|
* @param \HDNET\Calendarize\Domain\Model\Index $index |
144
|
|
|
* @param \DateTime $startDate |
145
|
|
|
* @param \DateTime $endDate |
146
|
|
|
* @param array $customSearch |
147
|
|
|
* @param int $year |
148
|
|
|
* @param int $month |
149
|
|
|
* @param int $week |
150
|
|
|
* |
151
|
|
|
* @ignorevalidation $startDate |
152
|
|
|
* @ignorevalidation $endDate |
153
|
|
|
* @ignorevalidation $customSearch |
154
|
|
|
* |
155
|
|
|
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\StopActionException |
156
|
|
|
*/ |
157
|
|
|
public function resultAction( |
158
|
|
|
Index $index = null, |
159
|
|
|
\DateTime $startDate = null, |
160
|
|
|
\DateTime $endDate = null, |
161
|
|
|
array $customSearch = [], |
162
|
|
|
$year = null, |
163
|
|
|
$month = null, |
164
|
|
|
$week = null |
165
|
|
|
) { |
166
|
|
|
$this->checkStaticTemplateIsIncluded(); |
167
|
|
|
if (($index instanceof Index) && \in_array('detail', $this->getAllowedActions(), true)) { |
168
|
|
|
$this->forward('detail'); |
169
|
|
|
} |
170
|
|
|
|
171
|
|
|
$search = $this->determineSearch($startDate, $endDate, $customSearch, $year, $month, null, $week); |
172
|
|
|
|
173
|
|
|
$this->slotExtendedAssignMultiple([ |
174
|
|
|
'indices' => $search['indices'], |
175
|
|
|
'searchMode' => $search['searchMode'], |
176
|
|
|
'searchParameter' => [ |
177
|
|
|
'startDate' => $startDate, |
178
|
|
|
'endDate' => $endDate, |
179
|
|
|
'customSearch' => $customSearch, |
180
|
|
|
'year' => $year, |
181
|
|
|
'month' => $month, |
182
|
|
|
'week' => $week, |
183
|
|
|
], |
184
|
|
|
], __CLASS__, __FUNCTION__); |
185
|
|
|
} |
186
|
|
|
|
187
|
|
|
/** |
188
|
|
|
* List action. |
189
|
|
|
* |
190
|
|
|
* @param \HDNET\Calendarize\Domain\Model\Index $index |
191
|
|
|
* @param \DateTime $startDate |
192
|
|
|
* @param \DateTime $endDate |
193
|
|
|
* @param array $customSearch * |
194
|
|
|
* @param int $year |
195
|
|
|
* @param int $month |
196
|
|
|
* @param int $day |
197
|
|
|
* @param int $week |
198
|
|
|
* |
199
|
|
|
* @ignorevalidation $startDate |
200
|
|
|
* @ignorevalidation $endDate |
201
|
|
|
* @ignorevalidation $customSearch |
202
|
|
|
* |
203
|
|
|
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\StopActionException |
204
|
|
|
*/ |
205
|
|
|
public function listAction( |
206
|
|
|
Index $index = null, |
207
|
|
|
\DateTime $startDate = null, |
208
|
|
|
\DateTime $endDate = null, |
209
|
|
|
array $customSearch = [], |
210
|
|
|
$year = null, |
211
|
|
|
$month = null, |
212
|
|
|
$day = null, |
213
|
|
|
$week = null |
214
|
|
|
) { |
215
|
|
|
$this->checkStaticTemplateIsIncluded(); |
216
|
|
|
if (($index instanceof Index) && \in_array('detail', $this->getAllowedActions(), true)) { |
217
|
|
|
$this->forward('detail'); |
218
|
|
|
} |
219
|
|
|
|
220
|
|
|
$search = $this->determineSearch($startDate, $endDate, $customSearch, $year, $month, $day, $week); |
221
|
|
|
|
222
|
|
|
$this->slotExtendedAssignMultiple([ |
223
|
|
|
'indices' => $search['indices'], |
224
|
|
|
'searchMode' => $search['searchMode'], |
225
|
|
|
'searchParameter' => [ |
226
|
|
|
'startDate' => $startDate, |
227
|
|
|
'endDate' => $endDate, |
228
|
|
|
'customSearch' => $customSearch, |
229
|
|
|
'year' => $year, |
230
|
|
|
'month' => $month, |
231
|
|
|
'day' => $day, |
232
|
|
|
'week' => $week, |
233
|
|
|
], |
234
|
|
|
], __CLASS__, __FUNCTION__); |
235
|
|
|
} |
236
|
|
|
|
237
|
|
|
/** |
238
|
|
|
* Shortcut. |
239
|
|
|
*/ |
240
|
|
|
public function shortcutAction() |
241
|
|
|
{ |
242
|
|
|
list($table, $uid) = \explode(':', $GLOBALS['TSFE']->currentRecord); |
243
|
|
|
$register = Register::getRegister(); |
244
|
|
|
|
245
|
|
|
$event = null; |
246
|
|
|
foreach ($register as $key => $value) { |
247
|
|
|
if ($value['tableName'] === $table) { |
248
|
|
|
$repositoryName = ClassNamingUtility::translateModelNameToRepositoryName($value['modelName']); |
249
|
|
|
if (\class_exists($repositoryName)) { |
250
|
|
|
$objectManager = new ObjectManager(); |
251
|
|
|
$repository = $objectManager->get($repositoryName); |
252
|
|
|
$event = $repository->findByUid($uid); |
253
|
|
|
} |
254
|
|
|
} |
255
|
|
|
} |
256
|
|
|
|
257
|
|
|
if (!($event instanceof DomainObjectInterface)) { |
258
|
|
|
return 'Invalid object'; |
259
|
|
|
} |
260
|
|
|
|
261
|
|
|
$fetchEvent = $this->indexRepository->findByEventTraversing($event, true, false, 1); |
262
|
|
|
if (\count($fetchEvent) <= 0) { |
263
|
|
|
$fetchEvent = $this->indexRepository->findByEventTraversing($event, false, true, 1, QueryInterface::ORDER_DESCENDING); |
264
|
|
|
} |
265
|
|
|
|
266
|
|
|
$this->view->assignMultiple([ |
267
|
|
|
'indices' => $fetchEvent, |
268
|
|
|
]); |
269
|
|
|
} |
270
|
|
|
|
271
|
|
|
/** |
272
|
|
|
* Past action. |
273
|
|
|
* |
274
|
|
|
* @param int $limit |
275
|
|
|
* @param string $sort |
276
|
|
|
* |
277
|
|
|
* @throws \TYPO3\CMS\Extbase\Mvc\Exception\StopActionException |
278
|
|
|
*/ |
279
|
|
|
public function pastAction( |
280
|
|
|
$limit = 100, |
|
|
|
|
281
|
|
|
$sort = 'ASC' |
|
|
|
|
282
|
|
|
) { |
283
|
|
|
$limit = (int) ($this->settings['limit']); |
284
|
|
|
$sort = $this->settings['sorting']; |
285
|
|
|
$this->checkStaticTemplateIsIncluded(); |
286
|
|
|
$this->slotExtendedAssignMultiple([ |
287
|
|
|
'indices' => $this->indexRepository->findByPast($limit, $sort), |
288
|
|
|
], __CLASS__, __FUNCTION__); |
289
|
|
|
} |
290
|
|
|
|
291
|
|
|
/** |
292
|
|
|
* Year action. |
293
|
|
|
* |
294
|
|
|
* @param int $year |
295
|
|
|
*/ |
296
|
|
|
public function yearAction($year = null) |
297
|
|
|
{ |
298
|
|
|
$date = DateTimeUtility::normalizeDateTime(1, 1, $year); |
299
|
|
|
|
300
|
|
|
$this->slotExtendedAssignMultiple([ |
301
|
|
|
'indices' => $this->indexRepository->findYear((int) $date->format('Y')), |
302
|
|
|
'date' => $date, |
303
|
|
|
], __CLASS__, __FUNCTION__); |
304
|
|
|
} |
305
|
|
|
|
306
|
|
|
/** |
307
|
|
|
* Quarter action. |
308
|
|
|
* |
309
|
|
|
* @param int $year |
310
|
|
|
* @param int $quarter 1-4 |
311
|
|
|
*/ |
312
|
|
|
public function quarterAction(int $year = null, int $quarter = null) |
313
|
|
|
{ |
314
|
|
|
$quarter = DateTimeUtility::normalizeQuarter($quarter); |
315
|
|
|
$date = DateTimeUtility::normalizeDateTime(1, 1 + (($quarter - 1) * 3), $year); |
316
|
|
|
|
317
|
|
|
$this->slotExtendedAssignMultiple([ |
318
|
|
|
'indices' => $this->indexRepository->findQuarter((int) $date->format('Y'), $quarter), |
319
|
|
|
'date' => $date, |
320
|
|
|
'quarter' => $quarter, |
321
|
|
|
], __CLASS__, __FUNCTION__); |
322
|
|
|
} |
323
|
|
|
|
324
|
|
|
/** |
325
|
|
|
* Month action. |
326
|
|
|
* |
327
|
|
|
* @param int $year |
328
|
|
|
* @param int $month |
329
|
|
|
* @param int $day |
330
|
|
|
*/ |
331
|
|
|
public function monthAction($year = null, $month = null, $day = null) |
332
|
|
|
{ |
333
|
|
|
$date = DateTimeUtility::normalizeDateTime($day, $month, $year); |
334
|
|
|
|
335
|
|
|
$this->slotExtendedAssignMultiple([ |
336
|
|
|
'date' => $date, |
337
|
|
|
'indices' => $this->indexRepository->findMonth((int) $date->format('Y'), (int) $date->format('n')), |
338
|
|
|
], __CLASS__, __FUNCTION__); |
339
|
|
|
} |
340
|
|
|
|
341
|
|
|
/** |
342
|
|
|
* Week action. |
343
|
|
|
* |
344
|
|
|
* @param int $year |
345
|
|
|
* @param int $week |
346
|
|
|
*/ |
347
|
|
|
public function weekAction($year = null, $week = null) |
348
|
|
|
{ |
349
|
|
|
$now = DateTimeUtility::getNow(); |
350
|
|
|
if (null === $year) { |
351
|
|
|
$year = $now->format('o'); // 'o' instead of 'Y': http://php.net/manual/en/function.date.php#106974 |
352
|
|
|
} |
353
|
|
|
if (null === $week) { |
354
|
|
|
$week = $now->format('W'); |
355
|
|
|
} |
356
|
|
|
$weekStart = (int) $this->settings['weekStart']; |
357
|
|
|
$firstDay = DateTimeUtility::convertWeekYear2DayMonthYear((int) $week, $year, $weekStart); |
358
|
|
|
$timezone = DateTimeUtility::getTimeZone(); |
359
|
|
|
$firstDay->setTimezone($timezone); |
360
|
|
|
$firstDay->setTime(0, 0, 0); |
361
|
|
|
|
362
|
|
|
$weekConfiguration = [ |
363
|
|
|
'+0 day' => 2, |
364
|
|
|
'+1 days' => 2, |
365
|
|
|
'+2 days' => 2, |
366
|
|
|
'+3 days' => 2, |
367
|
|
|
'+4 days' => 2, |
368
|
|
|
'+5 days' => 1, |
369
|
|
|
'+6 days' => 1, |
370
|
|
|
]; |
371
|
|
|
|
372
|
|
|
$this->slotExtendedAssignMultiple([ |
373
|
|
|
'firstDay' => $firstDay, |
374
|
|
|
'indices' => $this->indexRepository->findWeek($year, $week, $this->settings['weekStart']), |
375
|
|
|
'weekConfiguration' => $weekConfiguration, |
376
|
|
|
], __CLASS__, __FUNCTION__); |
377
|
|
|
} |
378
|
|
|
|
379
|
|
|
/** |
380
|
|
|
* Day action. |
381
|
|
|
* |
382
|
|
|
* @param int $year |
383
|
|
|
* @param int $month |
384
|
|
|
* @param int $day |
385
|
|
|
*/ |
386
|
|
|
public function dayAction($year = null, $month = null, $day = null) |
387
|
|
|
{ |
388
|
|
|
$date = DateTimeUtility::normalizeDateTime($day, $month, $year); |
389
|
|
|
$date->modify('+12 hours'); |
390
|
|
|
|
391
|
|
|
$previous = clone $date; |
392
|
|
|
$previous->modify('-1 day'); |
393
|
|
|
|
394
|
|
|
$next = clone $date; |
395
|
|
|
$next->modify('+1 day'); |
396
|
|
|
|
397
|
|
|
$this->slotExtendedAssignMultiple([ |
398
|
|
|
'indices' => $this->indexRepository->findDay((int) $date->format('Y'), (int) $date->format('n'), (int) $date->format('j')), |
399
|
|
|
'today' => $date, |
400
|
|
|
'previous' => $previous, |
401
|
|
|
'next' => $next, |
402
|
|
|
], __CLASS__, __FUNCTION__); |
403
|
|
|
} |
404
|
|
|
|
405
|
|
|
/** |
406
|
|
|
* Detail action. |
407
|
|
|
* |
408
|
|
|
* @param \HDNET\Calendarize\Domain\Model\Index $index |
409
|
|
|
* |
410
|
|
|
* @return string |
411
|
|
|
*/ |
412
|
|
|
public function detailAction(Index $index = null) |
413
|
|
|
{ |
414
|
|
|
if (null === $index) { |
415
|
|
|
// handle fallback for "strange language settings" |
416
|
|
|
if ($this->request->hasArgument('index')) { |
417
|
|
|
$indexId = (int) $this->request->getArgument('index'); |
418
|
|
|
if ($indexId > 0) { |
419
|
|
|
$index = $this->indexRepository->findByUid($indexId); |
420
|
|
|
} |
421
|
|
|
} |
422
|
|
|
|
423
|
|
|
if (null === $index) { |
424
|
|
|
if (!MathUtility::canBeInterpretedAsInteger($this->settings['listPid'])) { |
425
|
|
|
return (string) TranslateUtility::get('noEventDetailView'); |
426
|
|
|
} |
427
|
|
|
$this->slottedRedirect(__CLASS__, __FUNCTION__ . 'noEvent'); |
428
|
|
|
} |
429
|
|
|
} |
430
|
|
|
|
431
|
|
|
$this->slotExtendedAssignMultiple([ |
432
|
|
|
'index' => $index, |
433
|
|
|
'domain' => GeneralUtility::getIndpEnv('TYPO3_HOST_ONLY'), |
434
|
|
|
], __CLASS__, __FUNCTION__); |
435
|
|
|
|
436
|
|
|
return $this->view->render(); |
437
|
|
|
} |
438
|
|
|
|
439
|
|
|
/** |
440
|
|
|
* Render the search view. |
441
|
|
|
* |
442
|
|
|
* @param \DateTime $startDate |
443
|
|
|
* @param \DateTime $endDate |
444
|
|
|
* @param array $customSearch |
445
|
|
|
* |
446
|
|
|
* @ignorevalidation $startDate |
447
|
|
|
* @ignorevalidation $endDate |
448
|
|
|
* @ignorevalidation $customSearch |
449
|
|
|
*/ |
450
|
|
|
public function searchAction(\DateTime $startDate = null, \DateTime $endDate = null, array $customSearch = []) |
451
|
|
|
{ |
452
|
|
|
$baseDate = DateTimeUtility::getNow(); |
453
|
|
|
if (!($startDate instanceof \DateTimeInterface)) { |
454
|
|
|
$startDate = clone $baseDate; |
455
|
|
|
} |
456
|
|
|
if (!($endDate instanceof \DateTimeInterface)) { |
457
|
|
|
$endDate = clone $startDate; |
458
|
|
|
$modify = \is_string($this->settings['searchEndModifier']) ? $this->settings['searchEndModifier'] : '+30 days'; |
459
|
|
|
$endDate->modify($modify); |
460
|
|
|
} |
461
|
|
|
|
462
|
|
|
$this->slotExtendedAssignMultiple([ |
463
|
|
|
'startDate' => $startDate, |
464
|
|
|
'endDate' => $endDate, |
465
|
|
|
'customSearch' => $customSearch, |
466
|
|
|
'configurations' => $this->getCurrentConfigurations(), |
467
|
|
|
], __CLASS__, __FUNCTION__); |
468
|
|
|
} |
469
|
|
|
|
470
|
|
|
/** |
471
|
|
|
* Render single items. |
472
|
|
|
*/ |
473
|
|
|
public function singleAction() |
474
|
|
|
{ |
475
|
|
|
$indicies = []; |
476
|
|
|
|
477
|
|
|
// prepare selection |
478
|
|
|
$selections = []; |
479
|
|
|
$configurations = $this->getCurrentConfigurations(); |
480
|
|
|
foreach (GeneralUtility::trimExplode(',', $this->settings['singleItems']) as $item) { |
481
|
|
|
list($table, $uid) = BackendUtility::splitTable_Uid($item); |
482
|
|
|
foreach ($configurations as $configuration) { |
483
|
|
|
if ($configuration['tableName'] === $table) { |
484
|
|
|
$selections[] = [ |
485
|
|
|
'configuration' => $configuration, |
486
|
|
|
'uid' => $uid, |
487
|
|
|
]; |
488
|
|
|
break; |
489
|
|
|
} |
490
|
|
|
} |
491
|
|
|
} |
492
|
|
|
|
493
|
|
|
// fetch index |
494
|
|
|
foreach ($selections as $selection) { |
495
|
|
|
$this->indexRepository->setIndexTypes([$selection['configuration']['uniqueRegisterKey']]); |
496
|
|
|
$dummyIndex = new Index(); |
497
|
|
|
$dummyIndex->setForeignTable($selection['configuration']['tableName']); |
498
|
|
|
$dummyIndex->setForeignUid($selection['uid']); |
499
|
|
|
|
500
|
|
|
$result = $this->indexRepository->findByTraversing($dummyIndex); |
501
|
|
|
$index = $result->getQuery()->setLimit(1)->execute()->getFirst(); |
502
|
|
|
if (\is_object($index)) { |
503
|
|
|
$indicies[] = $index; |
504
|
|
|
} |
505
|
|
|
} |
506
|
|
|
|
507
|
|
|
$this->slotExtendedAssignMultiple([ |
508
|
|
|
'indicies' => $indicies, |
509
|
|
|
'configurations' => $configurations, |
510
|
|
|
], __CLASS__, __FUNCTION__); |
511
|
|
|
} |
512
|
|
|
|
513
|
|
|
/** |
514
|
|
|
* Build the search structure. |
515
|
|
|
* |
516
|
|
|
* @param \DateTime|null $startDate |
517
|
|
|
* @param \DateTime|null $endDate |
518
|
|
|
* @param array $customSearch |
519
|
|
|
* @param int $year |
520
|
|
|
* @param int $month |
521
|
|
|
* @param int $day |
522
|
|
|
* @param int $week |
523
|
|
|
* |
524
|
|
|
* @return array |
525
|
|
|
*/ |
526
|
|
|
protected function determineSearch( |
527
|
|
|
\DateTime $startDate = null, |
528
|
|
|
\DateTime $endDate = null, |
529
|
|
|
array $customSearch = [], |
530
|
|
|
$year = null, |
531
|
|
|
$month = null, |
532
|
|
|
$day = null, |
533
|
|
|
$week = null |
534
|
|
|
) { |
535
|
|
|
$searchMode = false; |
536
|
|
|
if ($startDate || $endDate || !empty($customSearch)) { |
537
|
|
|
$searchMode = true; |
538
|
|
|
$limit = isset($this->settings['limit']) ? (int) $this->settings['limit'] : 0; |
539
|
|
|
$indices = $this->indexRepository->findBySearch($startDate, $endDate, $customSearch, $limit); |
540
|
|
|
} elseif (MathUtility::canBeInterpretedAsInteger($year) && MathUtility::canBeInterpretedAsInteger($month) && MathUtility::canBeInterpretedAsInteger($day)) { |
541
|
|
|
$indices = $this->indexRepository->findDay((int) $year, (int) $month, (int) $day); |
542
|
|
|
} elseif (MathUtility::canBeInterpretedAsInteger($year) && MathUtility::canBeInterpretedAsInteger($month)) { |
543
|
|
|
$indices = $this->indexRepository->findMonth((int) $year, (int) $month); |
544
|
|
|
} elseif (MathUtility::canBeInterpretedAsInteger($year) && MathUtility::canBeInterpretedAsInteger($week)) { |
545
|
|
|
$indices = $this->indexRepository->findWeek($year, $week, $this->settings['weekStart']); |
546
|
|
|
} elseif (MathUtility::canBeInterpretedAsInteger($year)) { |
547
|
|
|
$indices = $this->indexRepository->findYear((int) $year); |
548
|
|
|
} else { |
549
|
|
|
// check if relative dates are enabled |
550
|
|
|
if ((bool)$this->settings['useRelativeDate']) { |
551
|
|
|
$overrideStartDateRelative = trim($this->settings['overrideStartRelative']); |
552
|
|
|
if ($overrideStartDateRelative === '') { |
553
|
|
|
$overrideStartDateRelative = 'now'; |
554
|
|
|
} |
555
|
|
|
try { |
556
|
|
|
$relativeDate = new \DateTime($overrideStartDateRelative); |
557
|
|
|
} catch (\Exception $e) { |
558
|
|
|
$relativeDate = new \DateTime(); |
559
|
|
|
} |
560
|
|
|
$overrideStartDate = $relativeDate->getTimestamp(); |
561
|
|
|
$overrideEndDate = 0; |
562
|
|
|
$overrideEndDateRelative = trim($this->settings['overrideEndRelative']); |
563
|
|
|
if ($overrideStartDateRelative !== '') { |
564
|
|
|
try { |
565
|
|
|
$relativeDate->modify($overrideEndDateRelative); |
566
|
|
|
$overrideEndDate = $relativeDate->getTimestamp(); |
567
|
|
|
} catch (\Exception $e) { |
568
|
|
|
// do nothing $overrideEndDate is 0 |
569
|
|
|
} |
570
|
|
|
} |
571
|
|
|
} else { |
572
|
|
|
$overrideStartDate = (int) $this->settings['overrideStartdate']; |
573
|
|
|
$overrideEndDate = (int) $this->settings['overrideEnddate']; |
574
|
|
|
} |
575
|
|
|
$indices = $this->indexRepository->findList( |
576
|
|
|
(int) $this->settings['limit'], |
577
|
|
|
$this->settings['listStartTime'], |
578
|
|
|
(int) $this->settings['listStartTimeOffsetHours'], |
579
|
|
|
$overrideStartDate, |
580
|
|
|
$overrideEndDate |
581
|
|
|
); |
582
|
|
|
} |
583
|
|
|
|
584
|
|
|
// use this variable in your extension to add more custom variables |
585
|
|
|
$variables = [ |
586
|
|
|
'extended' => [ |
587
|
|
|
'indices' => $indices, |
588
|
|
|
'searchMode' => $searchMode, |
589
|
|
|
'parameters' => [ |
590
|
|
|
'startDate' => $startDate, |
591
|
|
|
'endDate' => $endDate, |
592
|
|
|
'customSearch' => $customSearch, |
593
|
|
|
'year' => $year, |
594
|
|
|
'month' => $month, |
595
|
|
|
'day' => $day, |
596
|
|
|
'week' => $week, |
597
|
|
|
], |
598
|
|
|
], |
599
|
|
|
]; |
600
|
|
|
$variables['settings'] = $this->settings; |
601
|
|
|
|
602
|
|
|
$dispatcher = $this->objectManager->get(Dispatcher::class); |
603
|
|
|
$variables = $dispatcher->dispatch(__CLASS__, __FUNCTION__, $variables); |
604
|
|
|
|
605
|
|
|
return $variables['extended']; |
606
|
|
|
} |
607
|
|
|
|
608
|
|
|
/** |
609
|
|
|
* Get the allowed actions. |
610
|
|
|
* |
611
|
|
|
* @return array |
612
|
|
|
*/ |
613
|
|
|
protected function getAllowedActions(): array |
614
|
|
|
{ |
615
|
|
|
$configuration = $this->configurationManager->getConfiguration(ConfigurationManagerInterface::CONFIGURATION_TYPE_FRAMEWORK); |
616
|
|
|
$allowedActions = []; |
617
|
|
|
foreach ($configuration['controllerConfiguration'] as $controllerName => $controllerActions) { |
618
|
|
|
$allowedActions[$controllerName] = $controllerActions['actions']; |
619
|
|
|
} |
620
|
|
|
|
621
|
|
|
return \is_array($allowedActions['Calendar']) ? $allowedActions['Calendar'] : []; |
622
|
|
|
} |
623
|
|
|
|
624
|
|
|
/** |
625
|
|
|
* Get the current configurations. |
626
|
|
|
* |
627
|
|
|
* @return array |
628
|
|
|
*/ |
629
|
|
|
protected function getCurrentConfigurations() |
630
|
|
|
{ |
631
|
|
|
$configurations = GeneralUtility::trimExplode(',', $this->settings['configuration'], true); |
632
|
|
|
$return = []; |
633
|
|
|
foreach (Register::getRegister() as $key => $configuration) { |
634
|
|
|
if (\in_array($key, $configurations, true)) { |
635
|
|
|
$return[] = $configuration; |
636
|
|
|
} |
637
|
|
|
} |
638
|
|
|
|
639
|
|
|
return $return; |
640
|
|
|
} |
641
|
|
|
|
642
|
|
|
/** |
643
|
|
|
* A redirect that have a slot included. |
644
|
|
|
* |
645
|
|
|
* @param string $signalClassName name of the signal class: __CLASS__ |
646
|
|
|
* @param string $signalName name of the signal: __FUNCTION__ |
647
|
|
|
* @param array $variables optional: if not set use the defaults |
648
|
|
|
*/ |
649
|
|
|
protected function slottedRedirect($signalClassName, $signalName, $variables = null) |
650
|
|
|
{ |
651
|
|
|
// set default variables for the redirect |
652
|
|
|
if (null === $variables) { |
653
|
|
|
$variables['extended'] = [ |
654
|
|
|
'actionName' => 'list', |
655
|
|
|
'controllerName' => null, |
656
|
|
|
'extensionName' => null, |
657
|
|
|
'arguments' => [], |
658
|
|
|
'pageUid' => $this->settings['listPid'], |
659
|
|
|
'delay' => 0, |
660
|
|
|
'statusCode' => 301, |
661
|
|
|
]; |
662
|
|
|
$variables['extended']['pluginHmac'] = $this->calculatePluginHmac(); |
663
|
|
|
$variables['settings'] = $this->settings; |
664
|
|
|
} |
665
|
|
|
|
666
|
|
|
$dispatcher = $this->objectManager->get(Dispatcher::class); |
667
|
|
|
$variables = $dispatcher->dispatch($signalClassName, $signalName, $variables); |
668
|
|
|
|
669
|
|
|
$this->redirect( |
670
|
|
|
$variables['extended']['actionName'], |
671
|
|
|
$variables['extended']['controllerName'], |
672
|
|
|
$variables['extended']['extensionName'], |
673
|
|
|
$variables['extended']['arguments'], |
674
|
|
|
$variables['extended']['pageUid'], |
675
|
|
|
$variables['extended']['delay'], |
676
|
|
|
$variables['extended']['statusCode'] |
677
|
|
|
); |
678
|
|
|
} |
679
|
|
|
} |
680
|
|
|
|
This check looks from parameters that have been defined for a function or method, but which are not used in the method body.