NewsletterListingRepository.php
268 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 MailPoet\WP\Functions as WPFunctions; |
| 13 | use MailPoetVendor\Doctrine\ORM\QueryBuilder; |
| 14 | |
| 15 | class NewsletterListingRepository extends ListingRepository { |
| 16 | private static $supportedStatuses = [ |
| 17 | NewsletterEntity::STATUS_DRAFT, |
| 18 | NewsletterEntity::STATUS_SCHEDULED, |
| 19 | NewsletterEntity::STATUS_SENDING, |
| 20 | NewsletterEntity::STATUS_SENT, |
| 21 | NewsletterEntity::STATUS_ACTIVE, |
| 22 | ]; |
| 23 | |
| 24 | private static $supportedTypes = [ |
| 25 | NewsletterEntity::TYPE_STANDARD, |
| 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' => WPFunctions::get()->__('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' => WPFunctions::get()->__('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' => WPFunctions::get()->__('Draft', 'mailpoet'), |
| 121 | 'count' => $map[NewsletterEntity::STATUS_DRAFT] ?? 0, |
| 122 | ], |
| 123 | [ |
| 124 | 'name' => NewsletterEntity::STATUS_SCHEDULED, |
| 125 | 'label' => WPFunctions::get()->__('Scheduled', 'mailpoet'), |
| 126 | 'count' => $map[NewsletterEntity::STATUS_SCHEDULED] ?? 0, |
| 127 | ], |
| 128 | [ |
| 129 | 'name' => NewsletterEntity::STATUS_SENDING, |
| 130 | 'label' => WPFunctions::get()->__('Sending', 'mailpoet'), |
| 131 | 'count' => $map[NewsletterEntity::STATUS_SENDING] ?? 0, |
| 132 | ], |
| 133 | [ |
| 134 | 'name' => NewsletterEntity::STATUS_SENT, |
| 135 | 'label' => WPFunctions::get()->__('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' => WPFunctions::get()->__('Sending', 'mailpoet'), |
| 146 | 'count' => $map[NewsletterEntity::STATUS_SENDING] ?? 0, |
| 147 | ], |
| 148 | [ |
| 149 | 'name' => NewsletterEntity::STATUS_SENT, |
| 150 | 'label' => WPFunctions::get()->__('Sent', 'mailpoet'), |
| 151 | 'count' => $map[NewsletterEntity::STATUS_SENT] ?? 0, |
| 152 | ], |
| 153 | ]); |
| 154 | break; |
| 155 | |
| 156 | case NewsletterEntity::TYPE_WELCOME: |
| 157 | case NewsletterEntity::TYPE_NOTIFICATION: |
| 158 | case NewsletterEntity::TYPE_AUTOMATIC: |
| 159 | $groups = array_merge($groups, [ |
| 160 | [ |
| 161 | 'name' => NewsletterEntity::STATUS_ACTIVE, |
| 162 | 'label' => WPFunctions::get()->__('Active', 'mailpoet'), |
| 163 | 'count' => $map[NewsletterEntity::STATUS_ACTIVE] ?? 0, |
| 164 | ], |
| 165 | [ |
| 166 | 'name' => NewsletterEntity::STATUS_DRAFT, |
| 167 | 'label' => WPFunctions::get()->__('Not active', 'mailpoet'), |
| 168 | 'count' => $map[NewsletterEntity::STATUS_DRAFT] ?? 0, |
| 169 | ], |
| 170 | ]); |
| 171 | break; |
| 172 | } |
| 173 | |
| 174 | $groups[] = [ |
| 175 | 'name' => 'trash', |
| 176 | 'label' => WPFunctions::get()->__('Trash', 'mailpoet'), |
| 177 | 'count' => $trashedCount, |
| 178 | ]; |
| 179 | |
| 180 | return $groups; |
| 181 | } |
| 182 | |
| 183 | protected function applySelectClause(QueryBuilder $queryBuilder) { |
| 184 | $queryBuilder->select("PARTIAL n.{id,subject,hash,type,status,sentAt,updatedAt,deletedAt}"); |
| 185 | } |
| 186 | |
| 187 | protected function applyFromClause(QueryBuilder $queryBuilder) { |
| 188 | $queryBuilder->from(NewsletterEntity::class, 'n'); |
| 189 | } |
| 190 | |
| 191 | protected function applyGroup(QueryBuilder $queryBuilder, string $group) { |
| 192 | // include/exclude deleted |
| 193 | if ($group === 'trash') { |
| 194 | $queryBuilder->andWhere('n.deletedAt IS NOT NULL'); |
| 195 | } else { |
| 196 | $queryBuilder->andWhere('n.deletedAt IS NULL'); |
| 197 | } |
| 198 | |
| 199 | if (!in_array($group, self::$supportedStatuses)) { |
| 200 | return; |
| 201 | } |
| 202 | |
| 203 | $queryBuilder |
| 204 | ->andWhere('n.status = :status') |
| 205 | ->setParameter('status', $group); |
| 206 | } |
| 207 | |
| 208 | protected function applySearch(QueryBuilder $queryBuilder, string $search) { |
| 209 | $search = Helpers::escapeSearch($search); |
| 210 | $queryBuilder |
| 211 | ->andWhere('n.subject LIKE :search') |
| 212 | ->setParameter('search', "%$search%"); |
| 213 | } |
| 214 | |
| 215 | protected function applyFilters(QueryBuilder $queryBuilder, array $filters) { |
| 216 | $segmentId = $filters['segment'] ?? null; |
| 217 | if ($segmentId) { |
| 218 | $queryBuilder |
| 219 | ->join('n.newsletterSegments', 'ns') |
| 220 | ->andWhere('ns.segment = :segmentId') |
| 221 | ->setParameter('segmentId', $segmentId); |
| 222 | } |
| 223 | } |
| 224 | |
| 225 | protected function applyParameters(QueryBuilder $queryBuilder, array $parameters) { |
| 226 | $type = $parameters['type'] ?? null; |
| 227 | $group = $parameters['group'] ?? null; |
| 228 | $parentId = $parameters['parentId'] ?? null; |
| 229 | |
| 230 | if ($type) { |
| 231 | $this->applyType($queryBuilder, $type, $group); |
| 232 | } |
| 233 | |
| 234 | if ($parentId) { |
| 235 | $queryBuilder |
| 236 | ->andWhere('n.parent = :parentId') |
| 237 | ->setParameter('parentId', $parentId); |
| 238 | } |
| 239 | } |
| 240 | |
| 241 | protected function applySorting(QueryBuilder $queryBuilder, string $sortBy, string $sortOrder) { |
| 242 | if ($sortBy === 'sentAt') { |
| 243 | $queryBuilder->addSelect('CASE WHEN n.sentAt IS NULL THEN 1 ELSE 0 END AS HIDDEN sentAtIsNull'); |
| 244 | $queryBuilder->addOrderBy('sentAtIsNull', 'DESC'); |
| 245 | } |
| 246 | $queryBuilder->addOrderBy("n.$sortBy", $sortOrder); |
| 247 | } |
| 248 | |
| 249 | private function applyType(QueryBuilder $queryBuilder, string $type, string $group = null) { |
| 250 | if (!in_array($type, self::$supportedTypes)) { |
| 251 | return; |
| 252 | } |
| 253 | |
| 254 | if ($type === NewsletterEntity::TYPE_AUTOMATIC && $group) { |
| 255 | $queryBuilder |
| 256 | ->join('n.options', 'o') |
| 257 | ->join('o.optionField', 'opf') |
| 258 | ->andWhere('o.value = :group') |
| 259 | ->setParameter('group', $group) |
| 260 | ->andWhere('opf.newsletterType = n.type'); |
| 261 | } else { |
| 262 | $queryBuilder |
| 263 | ->andWhere('n.type = :type') |
| 264 | ->setParameter('type', $type); |
| 265 | } |
| 266 | } |
| 267 | } |
| 268 |