techdivision /
import
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like AbstractSubject often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use AbstractSubject, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 48 | abstract class AbstractSubject implements SubjectInterface |
||
| 49 | { |
||
| 50 | |||
| 51 | /** |
||
| 52 | * The trait that provides basic filesystem handling functionality. |
||
| 53 | * |
||
| 54 | * @var TechDivision\Import\Subjects\FilesystemTrait |
||
| 55 | */ |
||
| 56 | use FilesystemTrait; |
||
| 57 | |||
| 58 | /** |
||
| 59 | * The trait that provides basic filesystem handling functionality. |
||
| 60 | * |
||
| 61 | * @var TechDivision\Import\SystemLoggerTrait |
||
| 62 | */ |
||
| 63 | use SystemLoggerTrait; |
||
| 64 | |||
| 65 | /** |
||
| 66 | * The trait that provides header handling functionality. |
||
| 67 | * |
||
| 68 | * @var TechDivision\Import\HeaderTrait |
||
| 69 | */ |
||
| 70 | use HeaderTrait; |
||
| 71 | |||
| 72 | /** |
||
| 73 | * The trait that provides row handling functionality. |
||
| 74 | * |
||
| 75 | * @var TechDivision\Import\RowTrait |
||
| 76 | */ |
||
| 77 | use RowTrait; |
||
| 78 | |||
| 79 | /** |
||
| 80 | * The name of the file to be imported. |
||
| 81 | * |
||
| 82 | * @var string |
||
| 83 | */ |
||
| 84 | protected $filename; |
||
| 85 | |||
| 86 | /** |
||
| 87 | * The actual line number. |
||
| 88 | * |
||
| 89 | * @var integer |
||
| 90 | */ |
||
| 91 | protected $lineNumber = 0; |
||
| 92 | |||
| 93 | /** |
||
| 94 | * The actual operation name. |
||
| 95 | * |
||
| 96 | * @var string |
||
| 97 | */ |
||
| 98 | protected $operationName ; |
||
| 99 | |||
| 100 | /** |
||
| 101 | * The flag that stop's overserver execution on the actual row. |
||
| 102 | * |
||
| 103 | * @var boolean |
||
| 104 | */ |
||
| 105 | protected $skipRow = false; |
||
| 106 | |||
| 107 | /** |
||
| 108 | * The import adapter instance. |
||
| 109 | * |
||
| 110 | * @var \TechDivision\Import\Adapter\ImportAdapterInterface |
||
| 111 | */ |
||
| 112 | protected $importAdapter; |
||
| 113 | |||
| 114 | /** |
||
| 115 | * The system configuration. |
||
| 116 | * |
||
| 117 | * @var \TechDivision\Import\Configuration\SubjectConfigurationInterface |
||
| 118 | */ |
||
| 119 | protected $configuration; |
||
| 120 | |||
| 121 | /** |
||
| 122 | * The RegistryProcessor instance to handle running threads. |
||
| 123 | * |
||
| 124 | * @var \TechDivision\Import\Services\RegistryProcessorInterface |
||
| 125 | */ |
||
| 126 | protected $registryProcessor; |
||
| 127 | |||
| 128 | /** |
||
| 129 | * The actions unique serial. |
||
| 130 | * |
||
| 131 | * @var string |
||
| 132 | */ |
||
| 133 | protected $serial; |
||
| 134 | |||
| 135 | /** |
||
| 136 | * Array with the subject's observers. |
||
| 137 | * |
||
| 138 | * @var array |
||
| 139 | */ |
||
| 140 | protected $observers = array(); |
||
| 141 | |||
| 142 | /** |
||
| 143 | * Array with the subject's callbacks. |
||
| 144 | * |
||
| 145 | * @var array |
||
| 146 | */ |
||
| 147 | protected $callbacks = array(); |
||
| 148 | |||
| 149 | /** |
||
| 150 | * The subject's callback mappings. |
||
| 151 | * |
||
| 152 | * @var array |
||
| 153 | */ |
||
| 154 | protected $callbackMappings = array(); |
||
| 155 | |||
| 156 | /** |
||
| 157 | * The available root categories. |
||
| 158 | * |
||
| 159 | * @var array |
||
| 160 | */ |
||
| 161 | protected $rootCategories = array(); |
||
| 162 | |||
| 163 | /** |
||
| 164 | * The Magento configuration. |
||
| 165 | * |
||
| 166 | * @var array |
||
| 167 | */ |
||
| 168 | protected $coreConfigData = array(); |
||
| 169 | |||
| 170 | /** |
||
| 171 | * The available stores. |
||
| 172 | * |
||
| 173 | * @var array |
||
| 174 | */ |
||
| 175 | protected $stores = array(); |
||
| 176 | |||
| 177 | /** |
||
| 178 | * The available websites. |
||
| 179 | * |
||
| 180 | * @var array |
||
| 181 | */ |
||
| 182 | protected $storeWebsites = array(); |
||
| 183 | |||
| 184 | /** |
||
| 185 | * The default store. |
||
| 186 | * |
||
| 187 | * @var array |
||
| 188 | */ |
||
| 189 | protected $defaultStore; |
||
| 190 | |||
| 191 | /** |
||
| 192 | * The store view code the create the product/attributes for. |
||
| 193 | * |
||
| 194 | * @var string |
||
| 195 | */ |
||
| 196 | protected $storeViewCode; |
||
| 197 | |||
| 198 | /** |
||
| 199 | * The UID generator for the core config data. |
||
| 200 | * |
||
| 201 | * @var \TechDivision\Import\Utils\Generators\GeneratorInterface |
||
| 202 | */ |
||
| 203 | protected $coreConfigDataUidGenerator; |
||
| 204 | |||
| 205 | /** |
||
| 206 | * Initialize the subject instance. |
||
| 207 | * |
||
| 208 | * @param \TechDivision\Import\Services\RegistryProcessorInterface $registryProcessor The registry processor instance |
||
| 209 | * @param \TechDivision\Import\Utils\Generators\GeneratorInterface $coreConfigDataUidGenerator The UID generator for the core config data |
||
| 210 | * @param \Doctrine\Common\Collections\Collection $systemLoggers The array with the system loggers instances |
||
| 211 | */ |
||
| 212 | 77 | public function __construct( |
|
| 221 | |||
| 222 | /** |
||
| 223 | * Set's the name of the file to import |
||
| 224 | * |
||
| 225 | * @param string $filename The filename |
||
| 226 | * |
||
| 227 | * @return void |
||
| 228 | */ |
||
| 229 | 10 | public function setFilename($filename) |
|
| 233 | |||
| 234 | /** |
||
| 235 | * Return's the name of the file to import. |
||
| 236 | * |
||
| 237 | * @return string The filename |
||
| 238 | */ |
||
| 239 | 8 | public function getFilename() |
|
| 243 | |||
| 244 | /** |
||
| 245 | * Set's the actual operation name. |
||
| 246 | * |
||
| 247 | * @param string $operationName The actual operation name |
||
| 248 | * |
||
| 249 | * @return void |
||
| 250 | */ |
||
| 251 | 1 | public function setOperationName($operationName) |
|
| 255 | |||
| 256 | /** |
||
| 257 | * Return's the actual operation name. |
||
| 258 | * |
||
| 259 | * @return string |
||
| 260 | */ |
||
| 261 | 1 | public function getOperationName() |
|
| 265 | |||
| 266 | /** |
||
| 267 | * Set's the actual line number. |
||
| 268 | * |
||
| 269 | * @param integer $lineNumber The line number |
||
| 270 | * |
||
| 271 | * @return void |
||
| 272 | */ |
||
| 273 | 1 | public function setLineNumber($lineNumber) |
|
| 277 | |||
| 278 | /** |
||
| 279 | * Return's the actual line number. |
||
| 280 | * |
||
| 281 | * @return integer The line number |
||
| 282 | */ |
||
| 283 | 9 | public function getLineNumber() |
|
| 287 | |||
| 288 | /** |
||
| 289 | * Stop's observer execution on the actual row. |
||
| 290 | * |
||
| 291 | * @return void |
||
| 292 | */ |
||
| 293 | 1 | public function skipRow() |
|
| 297 | |||
| 298 | /** |
||
| 299 | * Return's the default callback mappings. |
||
| 300 | * |
||
| 301 | * @return array The default callback mappings |
||
| 302 | */ |
||
| 303 | 1 | public function getDefaultCallbackMappings() |
|
| 307 | |||
| 308 | /** |
||
| 309 | * Tries to format the passed value to a valid date with format 'Y-m-d H:i:s'. |
||
| 310 | * If the passed value is NOT a valid date, NULL will be returned. |
||
| 311 | * |
||
| 312 | * @param string $value The value to format |
||
| 313 | * |
||
| 314 | * @return string|null The formatted date or NULL if the date is not valid |
||
| 315 | */ |
||
| 316 | 2 | public function formatDate($value) |
|
| 327 | |||
| 328 | /** |
||
| 329 | * Extracts the elements of the passed value by exploding them |
||
| 330 | * with the also passed delimiter. |
||
| 331 | * |
||
| 332 | * @param string $value The value to extract |
||
| 333 | * @param string|null $delimiter The delimiter used to extrace the elements |
||
| 334 | * |
||
| 335 | * @return array The exploded values |
||
| 336 | */ |
||
| 337 | 2 | public function explode($value, $delimiter = null) |
|
| 350 | |||
| 351 | /** |
||
| 352 | * Queries whether or not debug mode is enabled or not, default is TRUE. |
||
| 353 | * |
||
| 354 | * @return boolean TRUE if debug mode is enabled, else FALSE |
||
| 355 | */ |
||
| 356 | 1 | public function isDebugMode() |
|
| 360 | |||
| 361 | /** |
||
| 362 | * Set's the subject configuration. |
||
| 363 | * |
||
| 364 | * @param \TechDivision\Import\Configuration\SubjectConfigurationInterface $configuration The subject configuration |
||
| 365 | * |
||
| 366 | * @return void |
||
| 367 | */ |
||
| 368 | 77 | public function setConfiguration(SubjectConfigurationInterface $configuration) |
|
| 372 | |||
| 373 | /** |
||
| 374 | * Return's the subject configuration. |
||
| 375 | * |
||
| 376 | * @return \TechDivision\Import\Configuration\SubjectConfigurationInterface The subject configuration |
||
| 377 | */ |
||
| 378 | 77 | public function getConfiguration() |
|
| 382 | |||
| 383 | /** |
||
| 384 | * Set's the import adapter instance. |
||
| 385 | * |
||
| 386 | * @param \TechDivision\Import\Adapter\ImportAdapterInterface $importAdapter The import adapter instance |
||
| 387 | * |
||
| 388 | * @return void |
||
| 389 | */ |
||
| 390 | 3 | public function setImportAdapter(ImportAdapterInterface $importAdapter) |
|
| 394 | |||
| 395 | /** |
||
| 396 | * Return's the import adapter instance. |
||
| 397 | * |
||
| 398 | * @return \TechDivision\Import\Adapter\ImportAdapterInterface The import adapter instance |
||
| 399 | */ |
||
| 400 | 3 | public function getImportAdapter() |
|
| 404 | |||
| 405 | /** |
||
| 406 | * Return's the RegistryProcessor instance to handle the running threads. |
||
| 407 | * |
||
| 408 | * @return \TechDivision\Import\Services\RegistryProcessorInterface The registry processor instance |
||
| 409 | */ |
||
| 410 | 77 | public function getRegistryProcessor() |
|
| 414 | |||
| 415 | /** |
||
| 416 | * Set's the unique serial for this import process. |
||
| 417 | * |
||
| 418 | * @param string $serial The unique serial |
||
| 419 | * |
||
| 420 | * @return void |
||
| 421 | */ |
||
| 422 | 9 | public function setSerial($serial) |
|
| 426 | |||
| 427 | /** |
||
| 428 | * Return's the unique serial for this import process. |
||
| 429 | * |
||
| 430 | * @return string The unique serial |
||
| 431 | */ |
||
| 432 | 4 | public function getSerial() |
|
| 436 | |||
| 437 | /** |
||
| 438 | * Return's the source date format to use. |
||
| 439 | * |
||
| 440 | * @return string The source date format |
||
| 441 | */ |
||
| 442 | 4 | public function getSourceDateFormat() |
|
| 446 | |||
| 447 | /** |
||
| 448 | * Return's the multiple field delimiter character to use, default value is comma (,). |
||
| 449 | * |
||
| 450 | * @return string The multiple field delimiter character |
||
| 451 | */ |
||
| 452 | 1 | public function getMultipleFieldDelimiter() |
|
| 456 | |||
| 457 | /** |
||
| 458 | * Return's the multiple value delimiter character to use, default value is comma (|). |
||
| 459 | * |
||
| 460 | * @return string The multiple value delimiter character |
||
| 461 | */ |
||
| 462 | 1 | public function getMultipleValueDelimiter() |
|
| 466 | |||
| 467 | /** |
||
| 468 | * Intializes the previously loaded global data for exactly one bunch. |
||
| 469 | * |
||
| 470 | * @param string $serial The serial of the actual import |
||
| 471 | * |
||
| 472 | * @return void |
||
| 473 | */ |
||
| 474 | 77 | public function setUp($serial) |
|
| 475 | { |
||
| 476 | |||
| 477 | // load the status of the actual import |
||
| 478 | 77 | $status = $this->getRegistryProcessor()->getAttribute($serial); |
|
| 479 | |||
| 480 | // load the global data we've prepared initially |
||
| 481 | 77 | $this->stores = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::STORES]; |
|
| 482 | 77 | $this->defaultStore = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::DEFAULT_STORE]; |
|
| 483 | 77 | $this->storeWebsites = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::STORE_WEBSITES]; |
|
| 484 | 77 | $this->rootCategories = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::ROOT_CATEGORIES]; |
|
| 485 | 77 | $this->coreConfigData = $status[RegistryKeys::GLOBAL_DATA][RegistryKeys::CORE_CONFIG_DATA]; |
|
| 486 | |||
| 487 | // initialize the operation name |
||
| 488 | 77 | $this->operationName = $this->getConfiguration()->getConfiguration()->getOperationName(); |
|
| 489 | |||
| 490 | // merge the callback mappings with the mappings from the child instance |
||
| 491 | 77 | $this->callbackMappings = array_merge($this->callbackMappings, $this->getDefaultCallbackMappings()); |
|
| 492 | |||
| 493 | // merge the header mappings with the values found in the configuration |
||
| 494 | 77 | $this->headerMappings = array_merge($this->headerMappings, $this->getConfiguration()->getHeaderMappings()); |
|
| 495 | |||
| 496 | // merge the callback mappings the the one from the configuration file |
||
| 497 | 77 | foreach ($this->getConfiguration()->getCallbacks() as $callbackMappings) { |
|
| 498 | 77 | foreach ($callbackMappings as $attributeCode => $mappings) { |
|
| 499 | // write a log message, that default callback configuration will |
||
| 500 | // be overwritten with the one from the configuration file |
||
| 501 | 77 | if (isset($this->callbackMappings[$attributeCode])) { |
|
| 502 | 72 | $this->getSystemLogger()->notice( |
|
| 503 | 72 | sprintf('Now override callback mappings for attribute %s with values found in configuration file', $attributeCode) |
|
| 504 | 72 | ); |
|
| 505 | 72 | } |
|
| 506 | |||
| 507 | // override the attributes callbacks |
||
| 508 | 77 | $this->callbackMappings[$attributeCode] = $mappings; |
|
| 509 | 77 | } |
|
| 510 | 77 | } |
|
| 511 | 77 | } |
|
| 512 | |||
| 513 | /** |
||
| 514 | * Clean up the global data after importing the variants. |
||
| 515 | * |
||
| 516 | * @param string $serial The serial of the actual import |
||
| 517 | * |
||
| 518 | * @return void |
||
| 519 | */ |
||
| 520 | 1 | public function tearDown($serial) |
|
| 521 | { |
||
| 522 | |||
| 523 | // load the registry processor |
||
| 524 | 1 | $registryProcessor = $this->getRegistryProcessor(); |
|
| 525 | |||
| 526 | // update the source directory for the next subject |
||
| 527 | 1 | $registryProcessor->mergeAttributesRecursive( |
|
| 528 | 1 | $serial, |
|
| 529 | 1 | array(RegistryKeys::SOURCE_DIRECTORY => $newSourceDir = $this->getNewSourceDir($serial)) |
|
| 530 | 1 | ); |
|
| 531 | |||
| 532 | // log a debug message with the new source directory |
||
| 533 | 1 | $this->getSystemLogger()->debug( |
|
| 534 | 1 | sprintf('Subject %s successfully updated source directory to %s', get_class($this), $newSourceDir) |
|
| 535 | 1 | ); |
|
| 536 | 1 | } |
|
| 537 | |||
| 538 | /** |
||
| 539 | * Return's the target directory for the artefact export. |
||
| 540 | * |
||
| 541 | * @return string The target directory for the artefact export |
||
| 542 | */ |
||
| 543 | 1 | public function getTargetDir() |
|
| 547 | |||
| 548 | /** |
||
| 549 | * Return's the next source directory, which will be the target directory |
||
| 550 | * of this subject, in most cases. |
||
| 551 | * |
||
| 552 | * @param string $serial The serial of the actual import |
||
| 553 | * |
||
| 554 | * @return string The new source directory |
||
| 555 | */ |
||
| 556 | 4 | public function getNewSourceDir($serial) |
|
| 560 | |||
| 561 | /** |
||
| 562 | * Register the passed observer with the specific type. |
||
| 563 | * |
||
| 564 | * @param \TechDivision\Import\Observers\ObserverInterface $observer The observer to register |
||
| 565 | * @param string $type The type to register the observer with |
||
| 566 | * |
||
| 567 | * @return void |
||
| 568 | */ |
||
| 569 | 6 | public function registerObserver(ObserverInterface $observer, $type) |
|
| 570 | { |
||
| 571 | |||
| 572 | // query whether or not the array with the callbacks for the |
||
| 573 | // passed type has already been initialized, or not |
||
| 574 | 6 | if (!isset($this->observers[$type])) { |
|
| 575 | 6 | $this->observers[$type] = array(); |
|
| 576 | 6 | } |
|
| 577 | |||
| 578 | // append the callback with the instance of the passed type |
||
| 579 | 6 | $this->observers[$type][] = $observer; |
|
| 580 | 6 | } |
|
| 581 | |||
| 582 | /** |
||
| 583 | * Register the passed callback with the specific type. |
||
| 584 | * |
||
| 585 | * @param \TechDivision\Import\Callbacks\CallbackInterface $callback The subject to register the callbacks for |
||
| 586 | * @param string $type The type to register the callback with |
||
| 587 | * |
||
| 588 | * @return void |
||
| 589 | */ |
||
| 590 | 2 | public function registerCallback(CallbackInterface $callback, $type) |
|
| 591 | { |
||
| 592 | |||
| 593 | // query whether or not the array with the callbacks for the |
||
| 594 | // passed type has already been initialized, or not |
||
| 595 | 2 | if (!isset($this->callbacks[$type])) { |
|
| 596 | 2 | $this->callbacks[$type] = array(); |
|
| 597 | 2 | } |
|
| 598 | |||
| 599 | // append the callback with the instance of the passed type |
||
| 600 | 2 | $this->callbacks[$type][] = $callback; |
|
| 601 | 2 | } |
|
| 602 | |||
| 603 | /** |
||
| 604 | * Return's the array with callbacks for the passed type. |
||
| 605 | * |
||
| 606 | * @param string $type The type of the callbacks to return |
||
| 607 | * |
||
| 608 | * @return array The callbacks |
||
| 609 | */ |
||
| 610 | 1 | public function getCallbacksByType($type) |
|
| 611 | { |
||
| 612 | |||
| 613 | // initialize the array for the callbacks |
||
| 614 | 1 | $callbacks = array(); |
|
| 615 | |||
| 616 | // query whether or not callbacks for the type are available |
||
| 617 | 1 | if (isset($this->callbacks[$type])) { |
|
| 618 | 1 | $callbacks = $this->callbacks[$type]; |
|
| 619 | 1 | } |
|
| 620 | |||
| 621 | // return the array with the type's callbacks |
||
| 622 | 1 | return $callbacks; |
|
| 623 | } |
||
| 624 | |||
| 625 | /** |
||
| 626 | * Return's the array with the available observers. |
||
| 627 | * |
||
| 628 | * @return array The observers |
||
| 629 | */ |
||
| 630 | 6 | public function getObservers() |
|
| 634 | |||
| 635 | /** |
||
| 636 | * Return's the array with the available callbacks. |
||
| 637 | * |
||
| 638 | * @return array The callbacks |
||
| 639 | */ |
||
| 640 | 1 | public function getCallbacks() |
|
| 644 | |||
| 645 | /** |
||
| 646 | * Return's the callback mappings for this subject. |
||
| 647 | * |
||
| 648 | * @return array The array with the subject's callback mappings |
||
| 649 | */ |
||
| 650 | 2 | public function getCallbackMappings() |
|
| 654 | |||
| 655 | /** |
||
| 656 | * Imports the content of the file with the passed filename. |
||
| 657 | * |
||
| 658 | * |
||
| 659 | * @param string $serial The serial of the actual import |
||
| 660 | * @param string $filename The filename to process |
||
| 661 | * |
||
| 662 | * @return void |
||
| 663 | * @throws \Exception Is thrown, if the import can't be processed |
||
| 664 | */ |
||
| 665 | 5 | public function import($serial, $filename) |
|
| 666 | { |
||
| 667 | |||
| 668 | try { |
||
| 669 | // stop processing, if the filename doesn't match |
||
| 670 | 5 | if (!$this->match($filename)) { |
|
| 671 | 1 | return; |
|
| 672 | } |
||
| 673 | |||
| 674 | // load the system logger instance |
||
| 675 | 4 | $systemLogger = $this->getSystemLogger(); |
|
| 676 | |||
| 677 | // prepare the flag filenames |
||
| 678 | 4 | $inProgressFilename = sprintf('%s.inProgress', $filename); |
|
| 679 | 4 | $importedFilename = sprintf('%s.imported', $filename); |
|
| 680 | 4 | $failedFilename = sprintf('%s.failed', $filename); |
|
| 681 | |||
| 682 | // query whether or not the file has already been imported |
||
| 683 | 4 | if ($this->isFile($failedFilename) || |
|
| 684 | 3 | $this->isFile($importedFilename) || |
|
| 685 | 3 | $this->isFile($inProgressFilename) |
|
| 686 | 4 | ) { |
|
| 687 | // log a debug message and exit |
||
| 688 | 1 | $systemLogger->debug(sprintf('Import running, found inProgress file %s', $inProgressFilename)); |
|
| 689 | 1 | return; |
|
| 690 | } |
||
| 691 | |||
| 692 | // flag file as in progress |
||
| 693 | 3 | $this->touch($inProgressFilename); |
|
| 694 | |||
| 695 | // track the start time |
||
| 696 | 3 | $startTime = microtime(true); |
|
| 697 | |||
| 698 | // initialize the serial/filename |
||
| 699 | 3 | $this->setSerial($serial); |
|
| 700 | 3 | $this->setFilename($filename); |
|
| 701 | |||
| 702 | // log a message that the file has to be imported |
||
| 703 | 3 | $systemLogger->info(sprintf('Now start processing file %s', $filename)); |
|
| 704 | |||
| 705 | // let the adapter process the file |
||
| 706 | 3 | $this->getImportAdapter()->import(array($this, 'importRow'), $filename); |
|
| 707 | |||
| 708 | // track the time needed for the import in seconds |
||
| 709 | 1 | $endTime = microtime(true) - $startTime; |
|
| 710 | |||
| 711 | // log a message that the file has successfully been imported |
||
| 712 | 1 | $systemLogger->info(sprintf('Successfully processed file %s with %d lines in %f s', $filename, $this->lineNumber, $endTime)); |
|
| 713 | |||
| 714 | // rename flag file, because import has been successfull |
||
| 715 | 1 | $this->rename($inProgressFilename, $importedFilename); |
|
| 716 | |||
| 717 | 3 | } catch (\Exception $e) { |
|
| 718 | // rename the flag file, because import failed and write the stack trace |
||
| 719 | 2 | $this->rename($inProgressFilename, $failedFilename); |
|
| 720 | 2 | $this->write($failedFilename, $e->__toString()); |
|
| 721 | |||
| 722 | // do not wrap the exception if not already done |
||
| 723 | 2 | if ($e instanceof WrappedColumnException) { |
|
| 724 | 1 | throw $e; |
|
| 725 | } |
||
| 726 | |||
| 727 | // else wrap and throw the exception |
||
| 728 | 1 | throw $this->wrapException(array(), $e); |
|
| 729 | } |
||
| 730 | 1 | } |
|
| 731 | |||
| 732 | /** |
||
| 733 | * This method queries whether or not the passed filename matches |
||
| 734 | * the pattern, based on the subjects configured prefix. |
||
| 735 | * |
||
| 736 | * @param string $filename The filename to match |
||
| 737 | * |
||
| 738 | * @return boolean TRUE if the filename matches, else FALSE |
||
| 739 | */ |
||
| 740 | 5 | protected function match($filename) |
|
| 741 | { |
||
| 742 | |||
| 743 | // prepare the pattern to query whether the file has to be processed or not |
||
| 744 | 5 | $pattern = sprintf( |
|
| 745 | 5 | '/^.*\/%s.*\\.%s$/', |
|
| 746 | 5 | $this->getConfiguration()->getPrefix(), |
|
| 747 | 5 | $this->getConfiguration()->getSuffix() |
|
| 748 | 5 | ); |
|
| 749 | |||
| 750 | // stop processing, if the filename doesn't match |
||
| 751 | 5 | return (boolean) preg_match($pattern, $filename); |
|
| 752 | } |
||
| 753 | |||
| 754 | /** |
||
| 755 | * Imports the passed row into the database. If the import failed, the exception |
||
| 756 | * will be catched and logged, but the import process will be continued. |
||
| 757 | * |
||
| 758 | * @param array $row The row with the data to be imported |
||
| 759 | * |
||
| 760 | * @return void |
||
| 761 | */ |
||
| 762 | 7 | public function importRow(array $row) |
|
| 763 | { |
||
| 764 | |||
| 765 | // initialize the row |
||
| 766 | 7 | $this->row = $row; |
|
| 767 | |||
| 768 | // raise the line number and reset the skip row flag |
||
| 769 | 7 | $this->lineNumber++; |
|
| 770 | 7 | $this->skipRow = false; |
|
| 771 | |||
| 772 | // initialize the headers with the columns from the first line |
||
| 773 | 7 | if (sizeof($this->headers) === 0) { |
|
| 774 | 1 | foreach ($this->row as $value => $key) { |
|
| 775 | 1 | $this->headers[$this->mapAttributeCodeByHeaderMapping($key)] = $value; |
|
| 776 | 1 | } |
|
| 777 | 1 | return; |
|
| 778 | } |
||
| 779 | |||
| 780 | // process the observers |
||
| 781 | 6 | foreach ($this->getObservers() as $observers) { |
|
| 782 | // invoke the pre-import/import and post-import observers |
||
| 783 | 6 | foreach ($observers as $observer) { |
|
| 784 | // query whether or not we have to skip the row |
||
| 785 | 6 | if ($this->skipRow) { |
|
| 786 | 1 | break; |
|
| 787 | } |
||
| 788 | |||
| 789 | // if not, set the subject and process the observer |
||
| 790 | 6 | if ($observer instanceof ObserverInterface) { |
|
| 791 | 6 | $this->row = $observer->handle($this); |
|
| 792 | 6 | } |
|
| 793 | 6 | } |
|
| 794 | 6 | } |
|
| 795 | |||
| 796 | // log a debug message with the actual line nr/file information |
||
| 797 | 6 | $this->getSystemLogger()->debug( |
|
| 798 | 6 | sprintf( |
|
| 799 | 6 | 'Successfully processed operation %s on row %d in file %s', |
|
| 800 | 6 | $this->operationName, |
|
| 801 | 6 | $this->lineNumber, |
|
| 802 | 6 | $this->filename |
|
| 803 | 6 | ) |
|
| 804 | 6 | ); |
|
| 805 | 6 | } |
|
| 806 | |||
| 807 | /** |
||
| 808 | * Queries whether or not that the subject needs an OK file to be processed. |
||
| 809 | * |
||
| 810 | * @return boolean TRUE if the subject needs an OK file, else FALSE |
||
| 811 | */ |
||
| 812 | 1 | public function isOkFileNeeded() |
|
| 816 | |||
| 817 | /** |
||
| 818 | * Return's the default store. |
||
| 819 | * |
||
| 820 | * @return array The default store |
||
| 821 | */ |
||
| 822 | public function getDefaultStore() |
||
| 826 | |||
| 827 | /** |
||
| 828 | * Return's the default store view code. |
||
| 829 | * |
||
| 830 | * @return array The default store view code |
||
| 831 | */ |
||
| 832 | 5 | public function getDefaultStoreViewCode() |
|
| 836 | |||
| 837 | /** |
||
| 838 | * Set's the store view code the create the product/attributes for. |
||
| 839 | * |
||
| 840 | * @param string $storeViewCode The store view code |
||
| 841 | * |
||
| 842 | * @return void |
||
| 843 | */ |
||
| 844 | 4 | public function setStoreViewCode($storeViewCode) |
|
| 848 | |||
| 849 | /** |
||
| 850 | * Return's the store view code the create the product/attributes for. |
||
| 851 | * |
||
| 852 | * @param string|null $default The default value to return, if the store view code has not been set |
||
| 853 | * |
||
| 854 | * @return string The store view code |
||
| 855 | */ |
||
| 856 | 8 | public function getStoreViewCode($default = null) |
|
| 873 | |||
| 874 | /** |
||
| 875 | * Prepare's the store view code in the subject. If the store_view_code row doesn't contain |
||
| 876 | * any value, the default code of the default store view will be set. |
||
| 877 | * |
||
| 878 | * @return void |
||
| 879 | */ |
||
| 880 | 2 | public function prepareStoreViewCode() |
|
| 881 | { |
||
| 882 | |||
| 883 | // re-set the store view code |
||
| 884 | 2 | $this->setStoreViewCode(null); |
|
| 885 | |||
| 886 | // initialize the store view code |
||
| 887 | 2 | if ($storeViewCode = $this->getValue(ColumnKeys::STORE_VIEW_CODE)) { |
|
| 888 | 2 | $this->setStoreViewCode($storeViewCode); |
|
| 889 | 2 | } |
|
| 890 | 2 | } |
|
| 891 | |||
| 892 | /** |
||
| 893 | * Return's the store ID of the store with the passed store view code |
||
| 894 | * |
||
| 895 | * @param string $storeViewCode The store view code to return the store ID for |
||
| 896 | * |
||
| 897 | * @return integer The ID of the store with the passed ID |
||
| 898 | * @throws \Exception Is thrown, if the store with the actual code is not available |
||
| 899 | */ |
||
| 900 | 4 | public function getStoreId($storeViewCode) |
|
| 901 | { |
||
| 902 | |||
| 903 | // query whether or not, the requested store is available |
||
| 904 | 4 | if (isset($this->stores[$storeViewCode])) { |
|
| 905 | 3 | return (integer) $this->stores[$storeViewCode][MemberNames::STORE_ID]; |
|
| 906 | } |
||
| 907 | |||
| 908 | // throw an exception, if not |
||
| 909 | 1 | throw new \Exception( |
|
| 910 | 1 | sprintf( |
|
| 911 | 1 | 'Found invalid store view code %s in file %s on line %d', |
|
| 912 | 1 | $storeViewCode, |
|
| 913 | 1 | $this->getFilename(), |
|
| 914 | 1 | $this->getLineNumber() |
|
| 915 | 1 | ) |
|
| 916 | 1 | ); |
|
| 917 | } |
||
| 918 | |||
| 919 | /** |
||
| 920 | * Return's the store ID of the actual row, or of the default store |
||
| 921 | * if no store view code is set in the CSV file. |
||
| 922 | * |
||
| 923 | * @param string|null $default The default store view code to use, if no store view code is set in the CSV file |
||
| 924 | * |
||
| 925 | * @return integer The ID of the actual store |
||
| 926 | * @throws \Exception Is thrown, if the store with the actual code is not available |
||
| 927 | */ |
||
| 928 | 2 | public function getRowStoreId($default = null) |
|
| 929 | { |
||
| 930 | |||
| 931 | // initialize the default store view code, if not passed |
||
| 932 | 2 | if ($default === null) { |
|
| 933 | 2 | $default = $this->getDefaultStoreViewCode(); |
|
| 934 | 2 | } |
|
| 935 | |||
| 936 | // load the store view code the create the product/attributes for |
||
| 937 | 2 | return $this->getStoreId($this->getStoreViewCode($default)); |
|
| 938 | } |
||
| 939 | |||
| 940 | /** |
||
| 941 | * Return's the root category for the actual view store. |
||
| 942 | * |
||
| 943 | * @return array The store's root category |
||
| 944 | * @throws \Exception Is thrown if the root category for the passed store code is NOT available |
||
| 945 | */ |
||
| 946 | 2 | public function getRootCategory() |
|
| 960 | |||
| 961 | /** |
||
| 962 | * Return's the Magento configuration value. |
||
| 963 | * |
||
| 964 | * @param string $path The Magento path of the requested configuration value |
||
| 965 | * @param mixed $default The default value that has to be returned, if the requested configuration value is not set |
||
| 966 | * @param string $scope The scope the configuration value has been set |
||
| 967 | * @param integer $scopeId The scope ID the configuration value has been set |
||
| 968 | * |
||
| 969 | * @return mixed The configuration value |
||
| 970 | * @throws \Exception Is thrown, if nor a value can be found or a default value has been passed |
||
| 971 | */ |
||
| 972 | 5 | public function getCoreConfigData($path, $default = null, $scope = ScopeKeys::SCOPE_DEFAULT, $scopeId = 0) |
|
| 973 | { |
||
| 974 | |||
| 975 | // initialize the core config data |
||
| 976 | $coreConfigData = array( |
||
| 977 | 5 | MemberNames::PATH => $path, |
|
| 978 | 5 | MemberNames::SCOPE => $scope, |
|
| 979 | 5 | MemberNames::SCOPE_ID => $scopeId |
|
| 980 | 5 | ); |
|
| 981 | |||
| 982 | // generate the UID from the passed data |
||
| 983 | 5 | $uniqueIdentifier = $this->coreConfigDataUidGenerator->generate($coreConfigData); |
|
| 984 | |||
| 985 | // iterate over the core config data and try to find the requested configuration value |
||
| 986 | 5 | if (isset($this->coreConfigData[$uniqueIdentifier])) { |
|
| 987 | 1 | return $this->coreConfigData[$uniqueIdentifier][MemberNames::VALUE]; |
|
| 988 | } |
||
| 989 | |||
| 990 | // query whether or not we've to query for the configuration value on fallback level 'websites' also |
||
| 991 | 4 | if ($scope === ScopeKeys::SCOPE_STORES) { |
|
| 992 | // query whether or not the website with the passed ID is available |
||
| 993 | 2 | foreach ($this->storeWebsites as $storeWebsite) { |
|
| 994 | 2 | if ($storeWebsite[MemberNames::WEBSITE_ID] === $scopeId) { |
|
| 995 | // replace scope with 'websites' and website ID |
||
| 996 | 2 | $coreConfigData = array_merge( |
|
| 997 | 2 | $coreConfigData, |
|
| 998 | array( |
||
| 999 | 2 | MemberNames::SCOPE => ScopeKeys::SCOPE_WEBSITES, |
|
| 1000 | 2 | MemberNames::SCOPE_ID => $storeWebsite[MemberNames::WEBSITE_ID] |
|
| 1001 | 2 | ) |
|
| 1002 | 2 | ); |
|
| 1003 | |||
| 1004 | // generate the UID from the passed data, merged with the 'websites' scope and ID |
||
| 1005 | 2 | $uniqueIdentifier = $this->coreConfigDataUidGenerator->generate($coreConfigData); |
|
| 1006 | |||
| 1007 | // query whether or not, the configuration value on 'websites' level |
||
| 1008 | 2 | View Code Duplication | if (isset($this->coreConfigData[$uniqueIdentifier][MemberNames::VALUE])) { |
| 1009 | 1 | return $this->coreConfigData[$uniqueIdentifier][MemberNames::VALUE]; |
|
| 1010 | } |
||
| 1011 | 1 | } |
|
| 1012 | 2 | } |
|
| 1013 | 1 | } |
|
| 1014 | |||
| 1015 | // replace scope with 'default' and scope ID '0' |
||
| 1016 | 3 | $coreConfigData = array_merge( |
|
| 1017 | 3 | $coreConfigData, |
|
| 1018 | array( |
||
| 1019 | 3 | MemberNames::SCOPE => ScopeKeys::SCOPE_DEFAULT, |
|
| 1020 | 3 | MemberNames::SCOPE_ID => 0 |
|
| 1021 | 3 | ) |
|
| 1022 | 3 | ); |
|
| 1023 | |||
| 1024 | // generate the UID from the passed data, merged with the 'default' scope and ID 0 |
||
| 1025 | 3 | $uniqueIdentifier = $this->coreConfigDataUidGenerator->generate($coreConfigData); |
|
| 1026 | |||
| 1027 | // query whether or not, the configuration value on 'default' level |
||
| 1028 | 3 | View Code Duplication | if (isset($this->coreConfigData[$uniqueIdentifier][MemberNames::VALUE])) { |
| 1029 | 1 | return $this->coreConfigData[$uniqueIdentifier][MemberNames::VALUE]; |
|
| 1030 | } |
||
| 1031 | |||
| 1032 | // if not, return the passed default value |
||
| 1033 | 2 | if ($default !== null) { |
|
| 1034 | 1 | return $default; |
|
| 1035 | } |
||
| 1036 | |||
| 1037 | // throw an exception if no value can be found |
||
| 1038 | // in the Magento configuration |
||
| 1039 | 1 | throw new \Exception( |
|
| 1040 | 1 | sprintf( |
|
| 1041 | 1 | 'Can\'t find a value for configuration "%s-%s-%d" in "core_config_data"', |
|
| 1042 | 1 | $path, |
|
| 1043 | 1 | $scope, |
|
| 1044 | $scopeId |
||
| 1045 | 1 | ) |
|
| 1046 | 1 | ); |
|
| 1047 | } |
||
| 1048 | |||
| 1049 | /** |
||
| 1050 | * Resolve the original column name for the passed one. |
||
| 1051 | * |
||
| 1052 | * @param string $columnName The column name that has to be resolved |
||
| 1053 | * |
||
| 1054 | * @return string|null The original column name |
||
| 1055 | */ |
||
| 1056 | 2 | public function resolveOriginalColumnName($columnName) |
|
| 1057 | { |
||
| 1058 | |||
| 1059 | // try to load the original data |
||
| 1060 | 2 | $originalData = $this->getOriginalData(); |
|
| 1061 | |||
| 1062 | // query whether or not original data is available |
||
| 1063 | 2 | if (isset($originalData[ColumnKeys::ORIGINAL_COLUMN_NAMES])) { |
|
| 1064 | // query whether or not the original column name is available |
||
| 1065 | 1 | if (isset($originalData[ColumnKeys::ORIGINAL_COLUMN_NAMES][$columnName])) { |
|
| 1066 | 1 | return $originalData[ColumnKeys::ORIGINAL_COLUMN_NAMES][$columnName]; |
|
| 1067 | } |
||
| 1068 | |||
| 1069 | // query whether or a wildcard column name is available |
||
| 1070 | 1 | if (isset($originalData[ColumnKeys::ORIGINAL_COLUMN_NAMES]['*'])) { |
|
| 1071 | 1 | return $originalData[ColumnKeys::ORIGINAL_COLUMN_NAMES]['*']; |
|
| 1072 | } |
||
| 1073 | } |
||
| 1074 | |||
| 1075 | // return the original column name |
||
| 1076 | 1 | return $columnName; |
|
| 1077 | } |
||
| 1078 | |||
| 1079 | /** |
||
| 1080 | * Return's the original data if available, or an empty array. |
||
| 1081 | * |
||
| 1082 | * @return array The original data |
||
| 1083 | */ |
||
| 1084 | 2 | public function getOriginalData() |
|
| 1085 | { |
||
| 1086 | |||
| 1087 | // initialize the array for the original data |
||
| 1088 | 2 | $originalData = array(); |
|
| 1089 | |||
| 1090 | // query whether or not the column contains original data |
||
| 1091 | 2 | if ($this->hasOriginalData()) { |
|
| 1092 | // unerialize the original data from the column |
||
| 1093 | 1 | $originalData = unserialize($this->row[$this->headers[ColumnKeys::ORIGINAL_DATA]]); |
|
| 1094 | 1 | } |
|
| 1095 | |||
| 1096 | // return an empty array, if not |
||
| 1097 | 2 | return $originalData; |
|
| 1098 | } |
||
| 1099 | |||
| 1100 | /** |
||
| 1101 | * Query's whether or not the actual column contains original data like |
||
| 1102 | * filename, line number and column names. |
||
| 1103 | * |
||
| 1104 | * @return boolean TRUE if the actual column contains origin data, else FALSE |
||
| 1105 | */ |
||
| 1106 | 3 | public function hasOriginalData() |
|
| 1110 | |||
| 1111 | /** |
||
| 1112 | * Wraps the passed exeception into a new one by trying to resolve the original filname, |
||
| 1113 | * line number and column names and use it for a detailed exception message. |
||
| 1114 | * |
||
| 1115 | * @param array $columnNames The column names that should be resolved and wrapped |
||
| 1116 | * @param \Exception $parent The exception we want to wrap |
||
| 1117 | * @param string $className The class name of the exception type we want to wrap the parent one |
||
| 1118 | * |
||
| 1119 | * @return \Exception the wrapped exception |
||
| 1120 | */ |
||
| 1121 | 2 | public function wrapException( |
|
| 1122 | array $columnNames = array(), |
||
| 1123 | \Exception $parent = null, |
||
| 1124 | $className = '\TechDivision\Import\Exceptions\WrappedColumnException' |
||
| 1125 | ) { |
||
| 1126 | |||
| 1127 | // initialize the message |
||
| 1128 | 2 | $message = $parent->getMessage(); |
|
| 1129 | |||
| 1130 | // query whether or not has been a result of invalid data of a previous column of a CSV file |
||
| 1131 | 2 | if ($this->hasOriginalData()) { |
|
| 1132 | // load the original data |
||
| 1133 | 1 | $originalData = $this->getOriginalData(); |
|
| 1134 | |||
| 1135 | // replace old filename and line number of the original message |
||
| 1136 | 1 | $message = $this->appendExceptionSuffix( |
|
| 1137 | 1 | $this->stripExceptionSuffix($message), |
|
| 1138 | 1 | $originalData[ColumnKeys::ORIGINAL_FILENAME], |
|
| 1139 | 1 | $originalData[ColumnKeys::ORIGINAL_LINE_NUMBER] |
|
| 1140 | 1 | ); |
|
| 1141 | |||
| 1142 | 1 | } else { |
|
| 1143 | // append filename and line number to the original message |
||
| 1144 | 1 | $message = $this->appendExceptionSuffix( |
|
| 1145 | 1 | $this->stripExceptionSuffix($message), |
|
| 1146 | 1 | $this->filename, |
|
| 1147 | 1 | $this->lineNumber |
|
| 1148 | 1 | ); |
|
| 1149 | } |
||
| 1150 | |||
| 1151 | // query whether or not, column names has been passed |
||
| 1152 | 2 | if (sizeof($columnNames) > 0) { |
|
| 1153 | // prepare the original column names |
||
| 1154 | 1 | $originalColumnNames = array(); |
|
| 1155 | 1 | foreach ($columnNames as $columnName) { |
|
| 1156 | 1 | $originalColumnNames[] = $this->resolveOriginalColumnName($columnName); |
|
| 1157 | 1 | } |
|
| 1158 | |||
| 1159 | // append the column information |
||
| 1160 | 1 | $message = sprintf('%s in column(s) %s', $message, implode(', ', $originalColumnNames)); |
|
| 1161 | 1 | } |
|
| 1162 | |||
| 1163 | // create a new exception and wrap the parent one |
||
| 1164 | 2 | return new $className($message, null, $parent); |
|
| 1165 | } |
||
| 1166 | |||
| 1167 | /** |
||
| 1168 | * Strip's the exception suffix containing filename and line number from the |
||
| 1169 | * passed message. |
||
| 1170 | * |
||
| 1171 | * @param string $message The message to strip the exception suffix from |
||
| 1172 | * |
||
| 1173 | * @return mixed The message without the exception suffix |
||
| 1174 | */ |
||
| 1175 | 2 | public function stripExceptionSuffix($message) |
|
| 1179 | |||
| 1180 | /** |
||
| 1181 | * Append's the exception suffix containing filename and line number to the |
||
| 1182 | * passed message. If no message has been passed, only the suffix will be |
||
| 1183 | * returned |
||
| 1184 | * |
||
| 1185 | * @param string|null $message The message to append the exception suffix to |
||
| 1186 | * @param string|null $filename The filename used to create the suffix |
||
| 1187 | * @param string|null $lineNumber The line number used to create the suffx |
||
| 1188 | * |
||
| 1189 | * @return string The message with the appended exception suffix |
||
| 1190 | */ |
||
| 1191 | 7 | public function appendExceptionSuffix($message = null, $filename = null, $lineNumber = null) |
|
| 1192 | { |
||
| 1193 | |||
| 1194 | // query whether or not a filename has been passed |
||
| 1195 | 7 | if ($filename === null) { |
|
| 1196 | 7 | $filename = $this->getFilename(); |
|
| 1197 | 7 | } |
|
| 1198 | |||
| 1199 | // query whether or not a line number has been passed |
||
| 1200 | 7 | if ($lineNumber === null) { |
|
| 1201 | 7 | $lineNumber = $this->getLineNumber(); |
|
| 1202 | 7 | } |
|
| 1203 | |||
| 1204 | // if no message has been passed, only return the suffix |
||
| 1205 | 7 | if ($message === null) { |
|
| 1206 | 2 | return sprintf(' in file %s on line %d', $filename, $lineNumber); |
|
| 1207 | } |
||
| 1208 | |||
| 1209 | // concatenate the message with the suffix and return it |
||
| 1210 | 7 | return sprintf('%s in file %s on line %d', $message, $filename, $lineNumber); |
|
| 1211 | } |
||
| 1212 | |||
| 1213 | /** |
||
| 1214 | * Raises the value for the counter with the passed key by one. |
||
| 1215 | * |
||
| 1216 | * @param mixed $counterName The name of the counter to raise |
||
| 1217 | * |
||
| 1218 | * @return integer The counter's new value |
||
| 1219 | */ |
||
| 1220 | 1 | public function raiseCounter($counterName) |
|
| 1229 | |||
| 1230 | /** |
||
| 1231 | * Merge the passed array into the status of the actual import. |
||
| 1232 | * |
||
| 1233 | * @param array $status The status information to be merged |
||
| 1234 | * |
||
| 1235 | * @return void |
||
| 1236 | */ |
||
| 1237 | 1 | public function mergeAttributesRecursive(array $status) |
|
| 1246 | } |
||
| 1247 |
Loading history...
Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property.
Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property..