| 1 | <?php |
| 2 | /* |
| 3 | +--------------------------------------------------------------------+ |
| 4 | | CiviCRM version 5 | |
| 5 | +--------------------------------------------------------------------+ |
| 6 | | Copyright CiviCRM LLC (c) 2004-2019 | |
| 7 | +--------------------------------------------------------------------+ |
| 8 | | This file is a part of CiviCRM. | |
| 9 | | | |
| 10 | | CiviCRM is free software; you can copy, modify, and distribute it | |
| 11 | | under the terms of the GNU Affero General Public License | |
| 12 | | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. | |
| 13 | | | |
| 14 | | CiviCRM is distributed in the hope that it will be useful, but | |
| 15 | | WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 16 | | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. | |
| 17 | | See the GNU Affero General Public License for more details. | |
| 18 | | | |
| 19 | | You should have received a copy of the GNU Affero General Public | |
| 20 | | License and the CiviCRM Licensing Exception along | |
| 21 | | with this program; if not, contact CiviCRM LLC | |
| 22 | | at info[AT]civicrm[DOT]org. If you have questions about the | |
| 23 | | GNU Affero General Public License or the licensing of CiviCRM, | |
| 24 | | see the CiviCRM license FAQ at http://civicrm.org/licensing | |
| 25 | +--------------------------------------------------------------------+ |
| 26 | */ |
| 27 | |
| 28 | /** |
| 29 | * |
| 30 | * @package CRM |
| 31 | * @copyright CiviCRM LLC (c) 2004-2019 |
| 32 | */ |
| 33 | |
| 34 | /** |
| 35 | * BAO object for civicrm_prevnext_cache table. |
| 36 | */ |
| 37 | class CRM_Core_BAO_PrevNextCache extends CRM_Core_DAO_PrevNextCache { |
| 38 | |
| 39 | /** |
| 40 | * Get the previous and next keys. |
| 41 | * |
| 42 | * @param string $cacheKey |
| 43 | * @param int $id1 |
| 44 | * @param int $id2 |
| 45 | * @param int $mergeId |
| 46 | * @param string $join |
| 47 | * @param string $where |
| 48 | * @param bool $flip |
| 49 | * |
| 50 | * @return array |
| 51 | */ |
| 52 | public static function getPositions($cacheKey, $id1, $id2, &$mergeId = NULL, $join = NULL, $where = NULL, $flip = FALSE) { |
| 53 | if ($flip) { |
| 54 | list($id1, $id2) = [$id2, $id1]; |
| 55 | } |
| 56 | |
| 57 | if ($mergeId == NULL) { |
| 58 | $query = " |
| 59 | SELECT id |
| 60 | FROM civicrm_prevnext_cache |
| 61 | WHERE cachekey = %3 AND |
| 62 | entity_id1 = %1 AND |
| 63 | entity_id2 = %2 AND |
| 64 | entity_table = 'civicrm_contact' |
| 65 | "; |
| 66 | |
| 67 | $params = [ |
| 68 | 1 => [$id1, 'Integer'], |
| 69 | 2 => [$id2, 'Integer'], |
| 70 | 3 => [$cacheKey, 'String'], |
| 71 | ]; |
| 72 | |
| 73 | $mergeId = CRM_Core_DAO::singleValueQuery($query, $params); |
| 74 | } |
| 75 | |
| 76 | $pos = ['foundEntry' => 0]; |
| 77 | if ($mergeId) { |
| 78 | $pos['foundEntry'] = 1; |
| 79 | |
| 80 | if ($where) { |
| 81 | |
| 82 | $where = " AND {$where}"; |
| 83 | |
| 84 | } |
| 85 | $p = [ |
| 86 | 1 => [$mergeId, 'Integer'], |
| 87 | 2 => [$cacheKey, 'String'], |
| 88 | ]; |
| 89 | $sql = "SELECT pn.id, pn.entity_id1, pn.entity_id2, pn.data FROM civicrm_prevnext_cache pn {$join} "; |
| 90 | $wherePrev = " WHERE pn.id < %1 AND pn.cachekey = %2 {$where} ORDER BY ID DESC LIMIT 1"; |
| 91 | $sqlPrev = $sql . $wherePrev; |
| 92 | |
| 93 | $dao = CRM_Core_DAO::executeQuery($sqlPrev, $p); |
| 94 | if ($dao->fetch()) { |
| 95 | $pos['prev']['id1'] = $dao->entity_id1; |
| 96 | $pos['prev']['id2'] = $dao->entity_id2; |
| 97 | $pos['prev']['mergeId'] = $dao->id; |
| 98 | $pos['prev']['data'] = $dao->data; |
| 99 | } |
| 100 | |
| 101 | $whereNext = " WHERE pn.id > %1 AND pn.cachekey = %2 {$where} ORDER BY ID ASC LIMIT 1"; |
| 102 | $sqlNext = $sql . $whereNext; |
| 103 | |
| 104 | $dao = CRM_Core_DAO::executeQuery($sqlNext, $p); |
| 105 | if ($dao->fetch()) { |
| 106 | $pos['next']['id1'] = $dao->entity_id1; |
| 107 | $pos['next']['id2'] = $dao->entity_id2; |
| 108 | $pos['next']['mergeId'] = $dao->id; |
| 109 | $pos['next']['data'] = $dao->data; |
| 110 | } |
| 111 | } |
| 112 | return $pos; |
| 113 | } |
| 114 | |
| 115 | /** |
| 116 | * Delete an item from the prevnext cache table based on the entity. |
| 117 | * |
| 118 | * @param int $id |
| 119 | * @param string $cacheKey |
| 120 | * @param string $entityTable |
| 121 | */ |
| 122 | public static function deleteItem($id = NULL, $cacheKey = NULL, $entityTable = 'civicrm_contact') { |
| 123 | |
| 124 | //clear cache |
| 125 | $sql = "DELETE FROM civicrm_prevnext_cache WHERE entity_table = %1"; |
| 126 | $params = [1 => [$entityTable, 'String']]; |
| 127 | |
| 128 | if (is_numeric($id)) { |
| 129 | $sql .= " AND ( entity_id1 = %2 OR entity_id2 = %2 )"; |
| 130 | $params[2] = [$id, 'Integer']; |
| 131 | } |
| 132 | |
| 133 | if (isset($cacheKey)) { |
| 134 | $sql .= " AND cachekey LIKE %3"; |
| 135 | $params[3] = ["{$cacheKey}%", 'String']; |
| 136 | } |
| 137 | CRM_Core_DAO::executeQuery($sql, $params); |
| 138 | } |
| 139 | |
| 140 | /** |
| 141 | * Delete pair from the previous next cache table to remove it from further merge consideration. |
| 142 | * |
| 143 | * The pair may have been flipped, so make sure we delete using both orders |
| 144 | * |
| 145 | * @param int $id1 |
| 146 | * @param int $id2 |
| 147 | * @param string $cacheKey |
| 148 | */ |
| 149 | public static function deletePair($id1, $id2, $cacheKey = NULL) { |
| 150 | $sql = "DELETE FROM civicrm_prevnext_cache WHERE entity_table = 'civicrm_contact'"; |
| 151 | |
| 152 | $pair = "(entity_id1 = %2 AND entity_id2 = %3) OR (entity_id1 = %3 AND entity_id2 = %2)"; |
| 153 | $sql .= " AND ( {$pair} )"; |
| 154 | $params[2] = [$id1, 'Integer']; |
| 155 | $params[3] = [$id2, 'Integer']; |
| 156 | |
| 157 | if (isset($cacheKey)) { |
| 158 | $sql .= " AND cachekey LIKE %4"; |
| 159 | // used % to address any row with conflict-cacheKey e.g "merge Individual_8_0_conflicts" |
| 160 | $params[4] = ["{$cacheKey}%", 'String']; |
| 161 | } |
| 162 | |
| 163 | CRM_Core_DAO::executeQuery($sql, $params); |
| 164 | } |
| 165 | |
| 166 | /** |
| 167 | * Mark contacts as being in conflict. |
| 168 | * |
| 169 | * @param int $id1 |
| 170 | * @param int $id2 |
| 171 | * @param string $cacheKey |
| 172 | * @param array $conflicts |
| 173 | * @param string $mode |
| 174 | * |
| 175 | * @return bool |
| 176 | * @throws CRM_Core_Exception |
| 177 | */ |
| 178 | public static function markConflict($id1, $id2, $cacheKey, $conflicts, $mode) { |
| 179 | if (empty($cacheKey) || empty($conflicts)) { |
| 180 | return FALSE; |
| 181 | } |
| 182 | |
| 183 | $sql = "SELECT pn.* |
| 184 | FROM civicrm_prevnext_cache pn |
| 185 | WHERE |
| 186 | ((pn.entity_id1 = %1 AND pn.entity_id2 = %2) OR (pn.entity_id1 = %2 AND pn.entity_id2 = %1)) AND |
| 187 | (cachekey = %3 OR cachekey = %4)"; |
| 188 | $params = [ |
| 189 | 1 => [$id1, 'Integer'], |
| 190 | 2 => [$id2, 'Integer'], |
| 191 | 3 => ["{$cacheKey}", 'String'], |
| 192 | 4 => ["{$cacheKey}_conflicts", 'String'], |
| 193 | ]; |
| 194 | $pncFind = CRM_Core_DAO::executeQuery($sql, $params); |
| 195 | |
| 196 | $conflictTexts = []; |
| 197 | |
| 198 | foreach ($conflicts as $entity => $entityConflicts) { |
| 199 | if ($entity === 'contact') { |
| 200 | foreach ($entityConflicts as $conflict) { |
| 201 | $conflictTexts[] = "{$conflict['title']}: '{$conflict[$id1]}' vs. '{$conflict[$id2]}'"; |
| 202 | } |
| 203 | } |
| 204 | else { |
| 205 | foreach ($entityConflicts as $locationConflict) { |
| 206 | if (!is_array($locationConflict)) { |
| 207 | continue; |
| 208 | } |
| 209 | $displayField = CRM_Dedupe_Merger::getLocationBlockInfo()[$entity]['displayField']; |
| 210 | $conflictTexts[] = "{$locationConflict['title']}: '{$locationConflict[$displayField][$id1]}' vs. '{$locationConflict[$displayField][$id2]}'"; |
| 211 | } |
| 212 | } |
| 213 | } |
| 214 | $conflictString = implode(', ', $conflictTexts); |
| 215 | |
| 216 | while ($pncFind->fetch()) { |
| 217 | $data = $pncFind->data; |
| 218 | if (!empty($data)) { |
| 219 | $data = CRM_Core_DAO::unSerializeField($data, CRM_Core_DAO::SERIALIZE_PHP); |
| 220 | $data['conflicts'] = $conflictString; |
| 221 | $data[$mode]['conflicts'] = $conflicts; |
| 222 | |
| 223 | $pncUp = new CRM_Core_DAO_PrevNextCache(); |
| 224 | $pncUp->id = $pncFind->id; |
| 225 | if ($pncUp->find(TRUE)) { |
| 226 | $pncUp->data = serialize($data); |
| 227 | $pncUp->cachekey = "{$cacheKey}_conflicts"; |
| 228 | $pncUp->save(); |
| 229 | } |
| 230 | } |
| 231 | } |
| 232 | return TRUE; |
| 233 | } |
| 234 | |
| 235 | /** |
| 236 | * Retrieve from prev-next cache. |
| 237 | * |
| 238 | * This function is used from a variety of merge related functions, although |
| 239 | * it would probably be good to converge on calling CRM_Dedupe_Merger::getDuplicatePairs. |
| 240 | * |
| 241 | * We seem to currently be storing stats in this table too & they might make more sense in |
| 242 | * the main cache table. |
| 243 | * |
| 244 | * @param string $cacheKey |
| 245 | * @param string $join |
| 246 | * @param string $whereClause |
| 247 | * @param int $offset |
| 248 | * @param int $rowCount |
| 249 | * @param array $select |
| 250 | * @param string $orderByClause |
| 251 | * @param bool $includeConflicts |
| 252 | * Should we return rows that have already been idenfified as having a conflict. |
| 253 | * When this is TRUE you should be careful you do not set up a loop. |
| 254 | * @param array $params |
| 255 | * |
| 256 | * @return array |
| 257 | */ |
| 258 | public static function retrieve($cacheKey, $join = NULL, $whereClause = NULL, $offset = 0, $rowCount = 0, $select = [], $orderByClause = '', $includeConflicts = TRUE, $params = []) { |
| 259 | $selectString = 'pn.*'; |
| 260 | |
| 261 | if (!empty($select)) { |
| 262 | $aliasArray = []; |
| 263 | foreach ($select as $column => $alias) { |
| 264 | $aliasArray[] = $column . ' as ' . $alias; |
| 265 | } |
| 266 | $selectString .= " , " . implode(' , ', $aliasArray); |
| 267 | } |
| 268 | |
| 269 | $params = [ |
| 270 | 1 => [$cacheKey, 'String'], |
| 271 | ] + $params; |
| 272 | |
| 273 | if (!empty($whereClause)) { |
| 274 | $whereClause = " AND " . $whereClause; |
| 275 | } |
| 276 | if ($includeConflicts) { |
| 277 | $where = ' WHERE (pn.cachekey = %1 OR pn.cachekey = %2)' . $whereClause; |
| 278 | $params[2] = ["{$cacheKey}_conflicts", 'String']; |
| 279 | } |
| 280 | else { |
| 281 | $where = ' WHERE (pn.cachekey = %1)' . $whereClause; |
| 282 | } |
| 283 | |
| 284 | $query = " |
| 285 | SELECT SQL_CALC_FOUND_ROWS {$selectString} |
| 286 | FROM civicrm_prevnext_cache pn |
| 287 | {$join} |
| 288 | $where |
| 289 | $orderByClause |
| 290 | "; |
| 291 | |
| 292 | if ($rowCount) { |
| 293 | $offset = CRM_Utils_Type::escape($offset, 'Int'); |
| 294 | $rowCount = CRM_Utils_Type::escape($rowCount, 'Int'); |
| 295 | |
| 296 | $query .= " LIMIT {$offset}, {$rowCount}"; |
| 297 | } |
| 298 | |
| 299 | $dao = CRM_Core_DAO::executeQuery($query, $params); |
| 300 | |
| 301 | $main = []; |
| 302 | $count = 0; |
| 303 | while ($dao->fetch()) { |
| 304 | if (self::is_serialized($dao->data)) { |
| 305 | $main[$count] = unserialize($dao->data); |
| 306 | } |
| 307 | else { |
| 308 | $main[$count] = $dao->data; |
| 309 | } |
| 310 | |
| 311 | if (!empty($select)) { |
| 312 | $extraData = []; |
| 313 | foreach ($select as $sfield) { |
| 314 | $extraData[$sfield] = $dao->$sfield; |
| 315 | } |
| 316 | $main[$count] = [ |
| 317 | 'prevnext_id' => $dao->id, |
| 318 | 'is_selected' => $dao->is_selected, |
| 319 | 'entity_id1' => $dao->entity_id1, |
| 320 | 'entity_id2' => $dao->entity_id2, |
| 321 | 'data' => $main[$count], |
| 322 | ]; |
| 323 | $main[$count] = array_merge($main[$count], $extraData); |
| 324 | } |
| 325 | $count++; |
| 326 | } |
| 327 | |
| 328 | return $main; |
| 329 | } |
| 330 | |
| 331 | /** |
| 332 | * @param $string |
| 333 | * |
| 334 | * @return bool |
| 335 | */ |
| 336 | public static function is_serialized($string) { |
| 337 | return (@unserialize($string) !== FALSE); |
| 338 | } |
| 339 | |
| 340 | /** |
| 341 | * @param string $sqlValues string of SQLValues to insert |
| 342 | * @return array |
| 343 | */ |
| 344 | public static function convertSetItemValues($sqlValues) { |
| 345 | $closingBrace = strpos($sqlValues, ')') - strlen($sqlValues); |
| 346 | $valueArray = array_map('trim', explode(', ', substr($sqlValues, strpos($sqlValues, '(') + 1, $closingBrace - 1))); |
| 347 | foreach ($valueArray as $key => &$value) { |
| 348 | // remove any quotes from values. |
| 349 | if (substr($value, 0, 1) == "'") { |
| 350 | $valueArray[$key] = substr($value, 1, -1); |
| 351 | } |
| 352 | } |
| 353 | return $valueArray; |
| 354 | } |
| 355 | |
| 356 | /** |
| 357 | * @param array|string $entity_table |
| 358 | * @param int $entity_id1 |
| 359 | * @param int $entity_id2 |
| 360 | * @param string $cacheKey |
| 361 | * @param string $data |
| 362 | */ |
| 363 | public static function setItem($entity_table = NULL, $entity_id1 = NULL, $entity_id2 = NULL, $cacheKey = NULL, $data = NULL) { |
| 364 | // If entity table is an array we are passing in an older format where this function only had 1 param $values. We put a deprecation warning. |
| 365 | if (!empty($entity_table) && is_array($entity_table)) { |
| 366 | Civi::log()->warning('Deprecated code path. Values should not be set this is going away in the future in favour of specific function params for each column.', array('civi.tag' => 'deprecated')); |
| 367 | foreach ($values as $value) { |
| 368 | $valueArray = self::convertSetItemValues($value); |
| 369 | self::setItem($valueArray[0], $valueArray[1], $valueArray[2], $valueArray[3], $valueArray[4]); |
| 370 | } |
| 371 | } |
| 372 | else { |
| 373 | CRM_Core_DAO::executeQuery("INSERT INTO civicrm_prevnext_cache (entity_table, entity_id1, entity_id2, cacheKey, data) VALUES |
| 374 | (%1, %2, %3, %4, '{$data}')", [ |
| 375 | 1 => [$entity_table, 'String'], |
| 376 | 2 => [$entity_id1, 'Integer'], |
| 377 | 3 => [$entity_id2, 'Integer'], |
| 378 | 4 => [$cacheKey, 'String'], |
| 379 | ]); |
| 380 | } |
| 381 | } |
| 382 | |
| 383 | /** |
| 384 | * Get count of matching rows. |
| 385 | * |
| 386 | * @param string $cacheKey |
| 387 | * @param string $join |
| 388 | * @param string $where |
| 389 | * @param string $op |
| 390 | * @param array $params |
| 391 | * Extra query params to parse into the query. |
| 392 | * |
| 393 | * @return int |
| 394 | */ |
| 395 | public static function getCount($cacheKey, $join = NULL, $where = NULL, $op = "=", $params = []) { |
| 396 | $query = " |
| 397 | SELECT COUNT(*) FROM civicrm_prevnext_cache pn |
| 398 | {$join} |
| 399 | WHERE (pn.cachekey $op %1 OR pn.cachekey $op %2) |
| 400 | "; |
| 401 | if ($where) { |
| 402 | $query .= " AND {$where}"; |
| 403 | } |
| 404 | |
| 405 | $params = [ |
| 406 | 1 => [$cacheKey, 'String'], |
| 407 | 2 => ["{$cacheKey}_conflicts", 'String'], |
| 408 | ] + $params; |
| 409 | return (int) CRM_Core_DAO::singleValueQuery($query, $params, TRUE, FALSE); |
| 410 | } |
| 411 | |
| 412 | /** |
| 413 | * Repopulate the cache of merge prospects. |
| 414 | * |
| 415 | * @param int $rgid |
| 416 | * @param int $gid |
| 417 | * @param array $criteria |
| 418 | * Additional criteria to filter by. |
| 419 | * |
| 420 | * @param bool $checkPermissions |
| 421 | * Respect logged in user's permissions. |
| 422 | * |
| 423 | * @param int $searchLimit |
| 424 | * Limit for the number of contacts to be used for comparison. |
| 425 | * The search methodology finds all matches for the searchedContacts so this limits |
| 426 | * the number of searched contacts, not the matches found. |
| 427 | * |
| 428 | * @throws \CRM_Core_Exception |
| 429 | * @throws \CiviCRM_API3_Exception |
| 430 | */ |
| 431 | public static function refillCache($rgid, $gid, $criteria, $checkPermissions, $searchLimit = 0) { |
| 432 | $cacheKeyString = CRM_Dedupe_Merger::getMergeCacheKeyString($rgid, $gid, $criteria, $checkPermissions); |
| 433 | |
| 434 | // 1. Clear cache if any |
| 435 | $sql = "DELETE FROM civicrm_prevnext_cache WHERE cachekey LIKE %1"; |
| 436 | CRM_Core_DAO::executeQuery($sql, [1 => ["{$cacheKeyString}%", 'String']]); |
| 437 | |
| 438 | // FIXME: we need to start using temp tables / queries here instead of arrays. |
| 439 | // And cleanup code in CRM/Contact/Page/DedupeFind.php |
| 440 | |
| 441 | // 2. FILL cache |
| 442 | $foundDupes = []; |
| 443 | if ($rgid && $gid) { |
| 444 | $foundDupes = CRM_Dedupe_Finder::dupesInGroup($rgid, $gid, $searchLimit); |
| 445 | } |
| 446 | elseif ($rgid) { |
| 447 | $contactIDs = []; |
| 448 | // The thing we really need to filter out is any chaining that would 'DO SOMETHING' to the DB. |
| 449 | // criteria could be passed in via url so we want to ensure nothing could be in that url that |
| 450 | // would chain to a delete. Limiting to getfields for 'get' limits us to declared fields, |
| 451 | // although we might wish to revisit later to allow joins. |
| 452 | $validFieldsForRetrieval = civicrm_api3('Contact', 'getfields', ['action' => 'get'])['values']; |
| 453 | if (!empty($criteria)) { |
| 454 | $contacts = civicrm_api3('Contact', 'get', array_merge([ |
| 455 | 'options' => ['limit' => 0], |
| 456 | 'return' => 'id', |
| 457 | 'check_permissions' => TRUE, |
| 458 | ], array_intersect_key($criteria['contact'], $validFieldsForRetrieval))); |
| 459 | $contactIDs = array_keys($contacts['values']); |
| 460 | } |
| 461 | $foundDupes = CRM_Dedupe_Finder::dupes($rgid, $contactIDs, $checkPermissions, $searchLimit); |
| 462 | } |
| 463 | |
| 464 | if (!empty($foundDupes)) { |
| 465 | CRM_Dedupe_Finder::parseAndStoreDupePairs($foundDupes, $cacheKeyString); |
| 466 | } |
| 467 | } |
| 468 | |
| 469 | public static function cleanupCache() { |
| 470 | Civi::service('prevnext')->cleanup(); |
| 471 | } |
| 472 | |
| 473 | /** |
| 474 | * Get the selections. |
| 475 | * |
| 476 | * NOTE: This stub has been preserved because one extension in `universe` |
| 477 | * was referencing the function. |
| 478 | * |
| 479 | * @deprecated |
| 480 | * @see CRM_Core_PrevNextCache_Sql::getSelection() |
| 481 | */ |
| 482 | public static function getSelection($cacheKey, $action = 'get') { |
| 483 | return Civi::service('prevnext')->getSelection($cacheKey, $action); |
| 484 | } |
| 485 | |
| 486 | /** |
| 487 | * Flip 2 contacts in the prevNext cache. |
| 488 | * |
| 489 | * @param array $prevNextId |
| 490 | * @param bool $onlySelected |
| 491 | * Only flip those which have been marked as selected. |
| 492 | */ |
| 493 | public static function flipPair(array $prevNextId, $onlySelected) { |
| 494 | $dao = new CRM_Core_DAO_PrevNextCache(); |
| 495 | if ($onlySelected) { |
| 496 | $dao->is_selected = 1; |
| 497 | } |
| 498 | foreach ($prevNextId as $id) { |
| 499 | $dao->id = $id; |
| 500 | if ($dao->find(TRUE)) { |
| 501 | $originalData = unserialize($dao->data); |
| 502 | $srcFields = ['ID', 'Name']; |
| 503 | $swapFields = ['srcID', 'srcName', 'dstID', 'dstName']; |
| 504 | $data = array_diff_assoc($originalData, array_fill_keys($swapFields, 1)); |
| 505 | foreach ($srcFields as $key) { |
| 506 | $data['src' . $key] = $originalData['dst' . $key]; |
| 507 | $data['dst' . $key] = $originalData['src' . $key]; |
| 508 | } |
| 509 | $dao->data = serialize($data); |
| 510 | $dao->entity_id1 = $data['dstID']; |
| 511 | $dao->entity_id2 = $data['srcID']; |
| 512 | $dao->save(); |
| 513 | } |
| 514 | } |
| 515 | } |
| 516 | |
| 517 | /** |
| 518 | * Get a list of available backend services. |
| 519 | * |
| 520 | * @return array |
| 521 | * Array(string $id => string $label). |
| 522 | */ |
| 523 | public static function getPrevNextBackends() { |
| 524 | return [ |
| 525 | 'default' => ts('Default (Auto-detect)'), |
| 526 | 'sql' => ts('SQL'), |
| 527 | 'redis' => ts('Redis'), |
| 528 | ]; |
| 529 | } |
| 530 | |
| 531 | /** |
| 532 | * Generate and assign an arbitrary value to a field of a test object. |
| 533 | * |
| 534 | * This specifically supports testing the dedupe use case. |
| 535 | * |
| 536 | * @param string $fieldName |
| 537 | * @param array $fieldDef |
| 538 | * @param int $counter |
| 539 | * The globally-unique ID of the test object. |
| 540 | */ |
| 541 | protected function assignTestValue($fieldName, &$fieldDef, $counter) { |
| 542 | if ($fieldName === 'cachekey') { |
| 543 | $this->cachekey = 'merge_' . rand(); |
| 544 | return; |
| 545 | } |
| 546 | if ($fieldName === 'data') { |
| 547 | $this->data = serialize([]); |
| 548 | return; |
| 549 | } |
| 550 | parent::assignTestValue($fieldName, $fieldDef, $counter); |
| 551 | } |
| 552 | |
| 553 | } |