NewsletterListingRepository.php
359 lines
| 1 | <?php declare(strict_types = 1); |
| 2 | |
| 3 | namespace MailPoet\Newsletter\Listing; |
| 4 | |
| 5 | if (!defined('ABSPATH')) exit; |
| 6 | |
| 7 | |
| 8 | use MailPoet\Entities\NewsletterEntity; |
| 9 | use MailPoet\Listing\ListingDefinition; |
| 10 | use MailPoet\Listing\ListingRepository; |
| 11 | use MailPoet\Util\Helpers; |
| 12 | use MailPoetVendor\Doctrine\ORM\QueryBuilder; |
| 13 | |
| 14 | class NewsletterListingRepository extends ListingRepository { |
| 15 | private static $supportedStatuses = [ |
| 16 | NewsletterEntity::STATUS_DRAFT, |
| 17 | NewsletterEntity::STATUS_SCHEDULED, |
| 18 | NewsletterEntity::STATUS_SENDING, |
| 19 | NewsletterEntity::STATUS_SENT, |
| 20 | NewsletterEntity::STATUS_ACTIVE, |
| 21 | ]; |
| 22 | |
| 23 | private static $supportedTypes = [ |
| 24 | NewsletterEntity::TYPE_STANDARD, |
| 25 | NewsletterEntity::TYPE_RE_ENGAGEMENT, |
| 26 | NewsletterEntity::TYPE_WELCOME, |
| 27 | NewsletterEntity::TYPE_AUTOMATIC, |
| 28 | NewsletterEntity::TYPE_NOTIFICATION, |
| 29 | NewsletterEntity::TYPE_NOTIFICATION_HISTORY, |
| 30 | ]; |
| 31 | |
| 32 | public function getFilters(ListingDefinition $definition): array { |
| 33 | $group = $definition->getGroup(); |
| 34 | $typeParam = $definition->getParameters()['type'] ?? null; |
| 35 | $groupParam = $definition->getParameters()['group'] ?? null; |
| 36 | |
| 37 | // newsletter types without filters |
| 38 | if (in_array($typeParam, [NewsletterEntity::TYPE_NOTIFICATION_HISTORY])) { |
| 39 | return []; |
| 40 | } |
| 41 | |
| 42 | $queryBuilder = clone $this->queryBuilder; |
| 43 | $this->applyFromClause($queryBuilder); |
| 44 | |
| 45 | if ($group) { |
| 46 | $this->applyGroup($queryBuilder, $group); |
| 47 | } |
| 48 | |
| 49 | if ($typeParam) { |
| 50 | $this->applyType($queryBuilder, $typeParam, $groupParam); |
| 51 | } |
| 52 | |
| 53 | $queryBuilder |
| 54 | ->select('s.id, s.name, COUNT(n) AS newsletterCount') |
| 55 | ->join('n.newsletterSegments', 'ns') |
| 56 | ->join('ns.segment', 's') |
| 57 | ->groupBy('s.id') |
| 58 | ->addGroupBy('s.name') |
| 59 | ->orderBy('s.name') |
| 60 | ->having('COUNT(n) > 0'); |
| 61 | |
| 62 | // format segment list |
| 63 | $segmentList = [ |
| 64 | [ |
| 65 | 'label' => __('All Lists', 'mailpoet'), |
| 66 | 'value' => '', |
| 67 | ], |
| 68 | ]; |
| 69 | |
| 70 | foreach ($queryBuilder->getQuery()->getResult() as $item) { |
| 71 | $segmentList[] = [ |
| 72 | 'label' => sprintf('%s (%d)', $item['name'], $item['newsletterCount']), |
| 73 | 'value' => $item['id'], |
| 74 | ]; |
| 75 | } |
| 76 | return ['segment' => $segmentList]; |
| 77 | } |
| 78 | |
| 79 | public function getGroups(ListingDefinition $definition): array { |
| 80 | $queryBuilder = clone $this->queryBuilder; |
| 81 | $this->applyFromClause($queryBuilder); |
| 82 | $this->applyParameters($queryBuilder, $definition->getParameters()); |
| 83 | |
| 84 | // total count |
| 85 | $countQueryBuilder = clone $queryBuilder; |
| 86 | $countQueryBuilder->select('COUNT(n) AS newsletterCount'); |
| 87 | $countQueryBuilder->andWhere('n.deletedAt IS NULL'); |
| 88 | $totalCount = (int)$countQueryBuilder->getQuery()->getSingleScalarResult(); |
| 89 | |
| 90 | // trashed count |
| 91 | $trashedCountQueryBuilder = clone $queryBuilder; |
| 92 | $trashedCountQueryBuilder->select('COUNT(n) AS newsletterCount'); |
| 93 | $trashedCountQueryBuilder->andWhere('n.deletedAt IS NOT NULL'); |
| 94 | $trashedCount = (int)$trashedCountQueryBuilder->getQuery()->getSingleScalarResult(); |
| 95 | |
| 96 | // count-by-status query |
| 97 | $queryBuilder->select('n.status, COUNT(n) AS newsletterCount'); |
| 98 | $queryBuilder->andWhere('n.deletedAt IS NULL'); |
| 99 | $queryBuilder->groupBy('n.status'); |
| 100 | |
| 101 | $map = []; |
| 102 | foreach ($queryBuilder->getQuery()->getResult() as $item) { |
| 103 | $map[$item['status']] = (int)$item['newsletterCount']; |
| 104 | } |
| 105 | |
| 106 | $groups = [ |
| 107 | [ |
| 108 | 'name' => 'all', |
| 109 | 'label' => __('All', 'mailpoet'), |
| 110 | 'count' => $totalCount, |
| 111 | ], |
| 112 | ]; |
| 113 | |
| 114 | $type = $definition->getParameters()['type'] ?? null; |
| 115 | switch ($type) { |
| 116 | case NewsletterEntity::TYPE_STANDARD: |
| 117 | $groups = array_merge($groups, [ |
| 118 | [ |
| 119 | 'name' => NewsletterEntity::STATUS_DRAFT, |
| 120 | 'label' => __('Draft', 'mailpoet'), |
| 121 | 'count' => $map[NewsletterEntity::STATUS_DRAFT] ?? 0, |
| 122 | ], |
| 123 | [ |
| 124 | 'name' => NewsletterEntity::STATUS_SCHEDULED, |
| 125 | 'label' => __('Scheduled', 'mailpoet'), |
| 126 | 'count' => $map[NewsletterEntity::STATUS_SCHEDULED] ?? 0, |
| 127 | ], |
| 128 | [ |
| 129 | 'name' => NewsletterEntity::STATUS_SENDING, |
| 130 | 'label' => __('Sending', 'mailpoet'), |
| 131 | 'count' => $map[NewsletterEntity::STATUS_SENDING] ?? 0, |
| 132 | ], |
| 133 | [ |
| 134 | 'name' => NewsletterEntity::STATUS_SENT, |
| 135 | 'label' => __('Sent', 'mailpoet'), |
| 136 | 'count' => $map[NewsletterEntity::STATUS_SENT] ?? 0, |
| 137 | ], |
| 138 | ]); |
| 139 | break; |
| 140 | |
| 141 | case NewsletterEntity::TYPE_NOTIFICATION_HISTORY: |
| 142 | $groups = array_merge($groups, [ |
| 143 | [ |
| 144 | 'name' => NewsletterEntity::STATUS_SENDING, |
| 145 | 'label' => __('Sending', 'mailpoet'), |
| 146 | 'count' => $map[NewsletterEntity::STATUS_SENDING] ?? 0, |
| 147 | ], |
| 148 | [ |
| 149 | 'name' => NewsletterEntity::STATUS_SENT, |
| 150 | 'label' => __('Sent', 'mailpoet'), |
| 151 | 'count' => $map[NewsletterEntity::STATUS_SENT] ?? 0, |
| 152 | ], |
| 153 | ]); |
| 154 | break; |
| 155 | |
| 156 | case NewsletterEntity::TYPE_WELCOME: |
| 157 | case NewsletterEntity::TYPE_RE_ENGAGEMENT: |
| 158 | case NewsletterEntity::TYPE_NOTIFICATION: |
| 159 | case NewsletterEntity::TYPE_AUTOMATIC: |
| 160 | $groups = array_merge($groups, [ |
| 161 | [ |
| 162 | 'name' => NewsletterEntity::STATUS_ACTIVE, |
| 163 | 'label' => __('Active', 'mailpoet'), |
| 164 | 'count' => $map[NewsletterEntity::STATUS_ACTIVE] ?? 0, |
| 165 | ], |
| 166 | [ |
| 167 | 'name' => NewsletterEntity::STATUS_DRAFT, |
| 168 | 'label' => __('Not active', 'mailpoet'), |
| 169 | 'count' => $map[NewsletterEntity::STATUS_DRAFT] ?? 0, |
| 170 | ], |
| 171 | ]); |
| 172 | break; |
| 173 | } |
| 174 | |
| 175 | $groups[] = [ |
| 176 | 'name' => 'trash', |
| 177 | 'label' => __('Trash', 'mailpoet'), |
| 178 | 'count' => $trashedCount, |
| 179 | ]; |
| 180 | |
| 181 | return $groups; |
| 182 | } |
| 183 | |
| 184 | protected function applySelectClause(QueryBuilder $queryBuilder) { |
| 185 | $queryBuilder->select("PARTIAL n.{id,subject,hash,type,status,sentAt,updatedAt,deletedAt}, PARTIAL wpPost.{id,postTitle}"); |
| 186 | } |
| 187 | |
| 188 | protected function applyFromClause(QueryBuilder $queryBuilder) { |
| 189 | $queryBuilder->from(NewsletterEntity::class, 'n') |
| 190 | ->leftJoin('n.wpPost', 'wpPost'); |
| 191 | } |
| 192 | |
| 193 | protected function applyGroup(QueryBuilder $queryBuilder, string $group) { |
| 194 | // include/exclude deleted |
| 195 | if ($group === 'trash') { |
| 196 | $queryBuilder->andWhere('n.deletedAt IS NOT NULL'); |
| 197 | } else { |
| 198 | $queryBuilder->andWhere('n.deletedAt IS NULL'); |
| 199 | } |
| 200 | |
| 201 | if (!in_array($group, self::$supportedStatuses)) { |
| 202 | return; |
| 203 | } |
| 204 | |
| 205 | $queryBuilder |
| 206 | ->andWhere('n.status = :status') |
| 207 | ->setParameter('status', $group); |
| 208 | } |
| 209 | |
| 210 | protected function applySearch(QueryBuilder $queryBuilder, string $search, array $parameters = []) { |
| 211 | $search = Helpers::escapeSearch($search); |
| 212 | |
| 213 | $type = $parameters['type'] ?? null; |
| 214 | |
| 215 | if ($type && $type === NewsletterEntity::TYPE_NOTIFICATION_HISTORY) { |
| 216 | $queryBuilder |
| 217 | ->leftJoin('n.queues', 'sq') |
| 218 | ->andWhere('sq.newsletterRenderedSubject LIKE :search or n.subject LIKE :search') |
| 219 | ->setParameter('search', "%$search%"); |
| 220 | } else { |
| 221 | $queryBuilder |
| 222 | ->andWhere('n.subject LIKE :search') |
| 223 | ->setParameter('search', "%$search%"); |
| 224 | } |
| 225 | } |
| 226 | |
| 227 | protected function applyFilters(QueryBuilder $queryBuilder, array $filters) { |
| 228 | $segmentId = $filters['segment'] ?? null; |
| 229 | if ($segmentId && is_numeric($segmentId)) { |
| 230 | $queryBuilder |
| 231 | ->join('n.newsletterSegments', 'ns') |
| 232 | ->andWhere('ns.segment = :segmentId') |
| 233 | ->setParameter('segmentId', (int)$segmentId); |
| 234 | } |
| 235 | |
| 236 | // Filter by sent_at/scheduled_at date |
| 237 | $sentAtFrom = $filters['sent_at_from'] ?? null; |
| 238 | if ($sentAtFrom && is_string($sentAtFrom) && $this->isValidDateTime($sentAtFrom)) { |
| 239 | $subQueryFrom = $queryBuilder->getEntityManager()->createQueryBuilder() |
| 240 | ->select('1') |
| 241 | ->from('MailPoet\Entities\SendingQueueEntity', 'queueFrom') |
| 242 | ->join('queueFrom.task', 'taskFrom') |
| 243 | ->where('queueFrom.newsletter = n.id') |
| 244 | ->andWhere('taskFrom.scheduledAt >= :sentAtFrom') |
| 245 | ->getDQL(); |
| 246 | |
| 247 | $queryBuilder |
| 248 | ->andWhere('(n.sentAt >= :sentAtFrom OR EXISTS (' . $subQueryFrom . '))') |
| 249 | ->setParameter('sentAtFrom', $sentAtFrom); |
| 250 | } |
| 251 | |
| 252 | $sentAtTo = $filters['sent_at_to'] ?? null; |
| 253 | if ($sentAtTo && is_string($sentAtTo) && $this->isValidDateTime($sentAtTo)) { |
| 254 | $subQueryTo = $queryBuilder->getEntityManager()->createQueryBuilder() |
| 255 | ->select('1') |
| 256 | ->from('MailPoet\Entities\SendingQueueEntity', 'queueTo') |
| 257 | ->join('queueTo.task', 'taskTo') |
| 258 | ->where('queueTo.newsletter = n.id') |
| 259 | ->andWhere('taskTo.scheduledAt <= :sentAtTo') |
| 260 | ->getDQL(); |
| 261 | |
| 262 | $queryBuilder |
| 263 | ->andWhere('(n.sentAt <= :sentAtTo OR EXISTS (' . $subQueryTo . '))') |
| 264 | ->setParameter('sentAtTo', $sentAtTo); |
| 265 | } |
| 266 | |
| 267 | // Filter by segment IDs with advanced operators |
| 268 | $segmentIds = $filters['segment_ids'] ?? null; |
| 269 | if (!$segmentIds || !is_array($segmentIds)) { |
| 270 | return; |
| 271 | } |
| 272 | $segmentIds = array_filter($segmentIds, 'is_numeric'); |
| 273 | $segmentIds = array_map('intval', $segmentIds); |
| 274 | if (empty($segmentIds)) { |
| 275 | return; |
| 276 | } |
| 277 | |
| 278 | $segmentOperator = $filters['segment_operator'] ?? null; |
| 279 | if (!in_array($segmentOperator, ['isAny', 'isNone'], true)) { |
| 280 | return; |
| 281 | } |
| 282 | |
| 283 | if ($segmentOperator === 'isAny') { |
| 284 | $queryBuilder |
| 285 | ->join('n.newsletterSegments', 'ns2') |
| 286 | ->andWhere('ns2.segment IN (:segmentIds)') |
| 287 | ->setParameter('segmentIds', $segmentIds); |
| 288 | } elseif ($segmentOperator === 'isNone') { |
| 289 | $subQuery = $queryBuilder->getEntityManager()->createQueryBuilder() |
| 290 | ->select('1') |
| 291 | ->from(NewsletterEntity::class, 'nNone') |
| 292 | ->join('nNone.newsletterSegments', 'nsNone') |
| 293 | ->where('nNone.id = n.id') |
| 294 | ->andWhere('nsNone.segment IN (:segmentIdsNone)') |
| 295 | ->getDQL(); |
| 296 | $queryBuilder |
| 297 | ->andWhere('NOT EXISTS (' . $subQuery . ')') |
| 298 | ->setParameter('segmentIdsNone', $segmentIds); |
| 299 | } |
| 300 | } |
| 301 | |
| 302 | private function isValidDateTime(string $dateTime): bool { |
| 303 | try { |
| 304 | new \DateTime($dateTime); |
| 305 | return true; |
| 306 | } catch (\Exception $e) { |
| 307 | return false; |
| 308 | } |
| 309 | } |
| 310 | |
| 311 | protected function applyParameters(QueryBuilder $queryBuilder, array $parameters) { |
| 312 | $type = $parameters['type'] ?? null; |
| 313 | $group = $parameters['group'] ?? null; |
| 314 | $parentId = $parameters['parentId'] ?? null; |
| 315 | |
| 316 | if ($type) { |
| 317 | $this->applyType($queryBuilder, $type, $group); |
| 318 | } |
| 319 | |
| 320 | if ($parentId) { |
| 321 | $queryBuilder |
| 322 | ->andWhere('n.parent = :parentId') |
| 323 | ->setParameter('parentId', $parentId); |
| 324 | } |
| 325 | } |
| 326 | |
| 327 | protected function applySorting(QueryBuilder $queryBuilder, string $sortBy, string $sortOrder) { |
| 328 | if ($sortBy === 'name') { |
| 329 | $queryBuilder->addSelect('CONCAT(COALESCE(wpPost.postTitle, \'\'), n.subject) AS HIDDEN sortingName'); |
| 330 | $queryBuilder->addOrderBy("sortingName", $sortOrder); |
| 331 | return; |
| 332 | } |
| 333 | if ($sortBy === 'sentAt') { |
| 334 | $queryBuilder->addSelect('CASE WHEN n.sentAt IS NULL THEN 1 ELSE 0 END AS HIDDEN sentAtIsNull'); |
| 335 | $queryBuilder->addOrderBy('sentAtIsNull', 'DESC'); |
| 336 | } |
| 337 | $queryBuilder->addOrderBy("n.$sortBy", $sortOrder); |
| 338 | } |
| 339 | |
| 340 | private function applyType(QueryBuilder $queryBuilder, string $type, ?string $group = null) { |
| 341 | if (!in_array($type, self::$supportedTypes)) { |
| 342 | return; |
| 343 | } |
| 344 | |
| 345 | if ($type === NewsletterEntity::TYPE_AUTOMATIC && $group) { |
| 346 | $queryBuilder |
| 347 | ->join('n.options', 'o') |
| 348 | ->join('o.optionField', 'opf') |
| 349 | ->andWhere('o.value = :group') |
| 350 | ->setParameter('group', $group) |
| 351 | ->andWhere('opf.newsletterType = n.type'); |
| 352 | } else { |
| 353 | $queryBuilder |
| 354 | ->andWhere('n.type = :type') |
| 355 | ->setParameter('type', $type); |
| 356 | } |
| 357 | } |
| 358 | } |
| 359 |