Simple::getSourceDir() - Code Metrics - Inspection of "Merge pull request #11 from wagnert/master" - techdivision/import-cli-simple - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 30c79d...a5e792 )

by Tim

created 2017-01-02 17:12 UTC

Simple::getSourceDir() A

↳ Parent: Simple

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
crap	2

<?php

/**
 * TechDivision\Import\Cli\Simple
 *
 * NOTICE OF LICENSE
 *
 * This source file is subject to the Open Software License (OSL 3.0)
 * that is available through the world-wide-web at this URL:
 * http://opensource.org/licenses/osl-3.0.php
 *
 * PHP version 5
 *
 * @author    Tim Wagner <[email protected]>
 * @copyright 2016 TechDivision GmbH <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import-cli-simple
 * @link      http://www.techdivision.com
 */

namespace TechDivision\Import\Cli;

use Rhumsaa\Uuid\Uuid;
use Psr\Log\LoggerInterface;
use TechDivision\Import\Utils\MemberNames;
use TechDivision\Import\Utils\RegistryKeys;
use TechDivision\Import\ConfigurationInterface;
use TechDivision\Import\Subjects\SubjectInterface;
use TechDivision\Import\Cli\Callbacks\CallbackVisitor;
use TechDivision\Import\Cli\Observers\ObserverVisitor;
use TechDivision\Import\Services\ImportProcessorInterface;
use TechDivision\Import\Services\RegistryProcessorInterface;

/**
 * A SLSB that handles the product import process.
 *
 * @author    Tim Wagner <[email protected]>
 * @copyright 2016 TechDivision GmbH <[email protected]>
 * @license   http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
 * @link      https://github.com/techdivision/import-cli-simple
 * @link      http://www.techdivision.com
 */
class Simple
{

    /**
     * The actions unique serial.
     *
     * @var string
     */
    protected $serial;

    /**
     * The system logger implementation.
     *
     * @var \Psr\Log\LoggerInterface
     */
    protected $systemLogger;

    /**
     * The RegistryProcessor instance to handle running threads.
     *
     * @var \TechDivision\Import\Services\RegistryProcessorInterface
     */
    protected $registryProcessor;

    /**
     * The processor to read/write the necessary import data.
     *
     * @var \TechDivision\Import\Services\ImportProcessorInterface
     */
    protected $importProcessor;

    /**
     * The system configuration.
     *
     * @var \TechDivision\Import\ConfigurationInterface
     */
    protected $configuration;

    /**
     * Set's the unique serial for this import process.
     *
     * @param string $serial The unique serial
     *
     * @return void
     */
    public function setSerial($serial)
    {
        $this->serial = $serial;
    }

    /**
     * Return's the unique serial for this import process.
     *
     * @return string The unique serial
     */
    public function getSerial()
    {
        return $this->serial;
    }

    /**
     * Set's the system logger.
     *
     * @param \Psr\Log\LoggerInterface $systemLogger The system logger
     *
     * @return void
     */
    public function setSystemLogger(LoggerInterface $systemLogger)
    {
        $this->systemLogger = $systemLogger;
    }

    /**
     * Return's the system logger.
     *
     * @return \Psr\Log\LoggerInterface The system logger instance
     */
    public function getSystemLogger()
    {
        return $this->systemLogger;
    }

    /**
     * Sets's the RegistryProcessor instance to handle the running threads.
     *
     * @param \TechDivision\Import\Services\RegistryProcessorInterface $registryProcessor The registry processor instance
     *
     * @return void
     */
    public function setRegistryProcessor(RegistryProcessorInterface $registryProcessor)
    {
        $this->registryProcessor = $registryProcessor;
    }

    /**
     * Return's the RegistryProcessor instance to handle the running threads.
     *
     * @return \TechDivision\Import\Services\RegistryProcessor The registry processor instance
     */
    public function getRegistryProcessor()
    {
        return $this->registryProcessor;
    }

    /**
     * Set's the import processor instance.
     *
     * @param \TechDivision\Import\Services\ImportProcessorInterface $importProcessor The import processor instance
     *
     * @return void
     */
    public function setImportProcessor(ImportProcessorInterface $importProcessor)
    {
        $this->importProcessor = $importProcessor;
    }

    /**
     * Return's the import processor instance.
     *
     * @return \TechDivision\Import\Services\ImportProcessorInterface The import processor instance
     */
    public function getImportProcessor()
    {
        return $this->importProcessor;
    }

    /**
     * Set's the system configuration.
     *
     * @param \TechDivision\Import\ConfigurationInterface $configuration The system configuration
     *
     * @return void
     */
    public function setConfiguration(ConfigurationInterface $configuration)
    {
        $this->configuration = $configuration;
    }

    /**
     * Return's the system configuration.
     *
     * @return \TechDivision\Import\ConfigurationInterface The system configuration
     */
    public function getConfiguration()
    {
        return $this->configuration;
    }

    /**
     * Return's the prefix for the import files.
     *
     * @return string The prefix
     */
    public function getPrefix()
    {
        return $this->getConfiguration()->getPrefix();

    }

    /**
     * Return's the source directory that has to be watched for new files.
     *
     * @return string The source directory
     */
    public function getSourceDir()
    {
        return $this->getConfiguration()->getSourceDir();

    }

    /**
     * Parse the temporary upload directory for new files to be imported.
     *
     * @return void
     */
    public function import()
    {

        // track the start time
        $startTime = microtime(true);

        // generate the serial for the new job
        $this->setSerial(Uuid::uuid4()->__toString());

        // prepare the global data for the import process
        $this->start();
        $this->setUp();
        $this->processSubjects();
        $this->tearDown();
        $this->finish();

        // track the time needed for the import in seconds
        $endTime = microtime(true) - $startTime;

        // log a message that import has been finished
        $this->getSystemLogger()->info(sprintf('Successfully finished import with serial %s in %f s', $this->getSerial(), $endTime));
    }

    /**
     * This method start's the import process by initializing
     * the status and appends it to the registry.
     *
     * @return void
     */
    public function start()
    {

        // log a message that import has been started
        $this->getSystemLogger()->info(sprintf('Now start import with serial %s', $this->getSerial()));

        // initialize the status
        $status = array(RegistryKeys::STATUS => 1);

        // initialize the status information for the subjects */
        /** @var \TechDivision\Import\Configuration\SubjectInterface $subject */
        foreach ($this->getConfiguration()->getSubjects() as $subject) {
            $status[$subject->getPrefix()] = array();
        }

        // append it to the registry
        $this->getRegistryProcessor()->setAttribute($this->getSerial(), $status);
    }

    /**
     * Prepares the global data for the import process.
     *
     * @return void
     */
    public function setUp()
    {

        try {
            // load the registry
            $importProcessor = $this->getImportProcessor();
            $registryProcessor = $this->getRegistryProcessor();

            // initialize the array for the global data
            $globalData = array();

            // initialize the global data
            $globalData[RegistryKeys::STORES] = $importProcessor->getStores();
            $globalData[RegistryKeys::LINK_TYPES] = $importProcessor->getLinkTypes();
            $globalData[RegistryKeys::TAX_CLASSES] = $importProcessor->getTaxClasses();
            $globalData[RegistryKeys::DEFAULT_STORE] = $importProcessor->getDefaultStore();

            $globalData[RegistryKeys::STORE_WEBSITES] = $importProcessor->getStoreWebsites();
            $globalData[RegistryKeys::ROOT_CATEGORIES] = $importProcessor->getRootCategories();
            $globalData[RegistryKeys::CORE_CONFIG_DATA] = $importProcessor->getCoreConfigData();

            $globalData[RegistryKeys::ATTRIBUTE_SETS] = $eavAttributeSets = $importProcessor->getEavAttributeSetsByEntityTypeId(4);

            // prepare the categories
            $categories = array();
            foreach ($importProcessor->getCategories() as $category) {
                // expload the entity IDs from the category path
                $entityIds = explode('/', $category[MemberNames::PATH]);

                // cut-off the root category
                array_shift($entityIds);

                // continue with the next category if no entity IDs are available
                if (sizeof($entityIds) === 0) {
                    continue;
                }

                // initialize the array for the path elements
                $path = array();
                foreach ($importProcessor->getCategoryVarcharsByEntityIds($entityIds) as $cat) {
                    $path[] = $cat[MemberNames::VALUE];
                }

                // append the catogory with the string path as key
                $categories[implode('/', $path)] = $category;
            }

            // initialize the array with the categories
            $globalData[RegistryKeys::CATEGORIES] = $categories;

            // prepare an array with the EAV attributes grouped by their attribute set name as keys
            $eavAttributes = array();
            foreach (array_keys($eavAttributeSets) as $eavAttributeSetName) {
                $eavAttributes[$eavAttributeSetName] = $importProcessor->getEavAttributesByEntityTypeIdAndAttributeSetName(4, $eavAttributeSetName);
            }

            // initialize the array with the EAV attributes
            $globalData[RegistryKeys::EAV_ATTRIBUTES] = $eavAttributes;

            // add the status with the global data
            $registryProcessor->mergeAttributesRecursive(
                $this->getSerial(),
                array(RegistryKeys::GLOBAL_DATA => $globalData)
            );


        } catch (\Exception $e) {
            $this->getSystemLogger()->error($e->__toString());
        }
    }

    /**
     * Process all the subjects defined in the system configuration.
     *
     * @return void
     */
    public function processSubjects()
    {

        try {
            // load system logger and registry
            $systemLogger = $this->getSystemLogger();
            $importProcessor = $this->getImportProcessor();

            // load the subjects
            $subjects = $this->getConfiguration()->getSubjects();

            // start the transaction
            $importProcessor->getConnection()->beginTransaction();

            // process all the subjects found in the system configuration
            foreach ($subjects as $subject) {
                $this->processSubject($subject);
            }

            // commit the transaction
            $importProcessor->getConnection()->commit();


        } catch (\Exception $e) {
            // log a message with the stack trace
            $systemLogger->error($e->__toString());

            // rollback the transaction
            $importProcessor->getConnection()->rollBack();
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
        }
    }

    /**
     * Process the subject with the passed name/identifier.
     *
     * @param \TechDivision\Import\Configuration\Subject $subject The subject configuration
     *
     * @return void
     */
    public function processSubject($subject)
    {

        // load the system logger
        $systemLogger = $this->getSystemLogger();

        // init file iterator on deployment directory
        $fileIterator = new \FilesystemIterator($sourceDir = $subject->getSourceDir());

        // clear the filecache
        clearstatcache();

        // prepare the regex to find the files to be imported
        $regex = sprintf('/^.*\/%s.*\\.csv$/', $subject->getPrefix());

        // log a debug message
        $systemLogger->debug(
            sprintf('Now checking directory %s for files with regex %s to import', $sourceDir, $regex)
        );

        // iterate through all CSV files and start import process
        foreach (new \RegexIterator($fileIterator, $regex) as $filename) {
            try {
                // prepare the flag filenames
                $inProgressFilename = sprintf('%s.inProgress', $filename);
                $importedFilename = sprintf('%s.imported', $filename);
                $failedFilename = sprintf('%s.failed', $filename);

                // query whether or not the file has already been imported
                if (is_file($failedFilename) ||
                    is_file($importedFilename) ||
                    is_file($inProgressFilename)
                ) {
                    // log a debug message
                    $systemLogger->debug(
                        sprintf('Import running, found inProgress file %s', $inProgressFilename)
                    );

                    // ignore the file
                    continue;
                }

                // flag file as in progress
                touch($inProgressFilename);

                // process the subject
                $this->subjectFactory($subject)->import($this->getSerial(), $filename->getPathname());

                // rename flag file, because import has been successfull
                rename($inProgressFilename, $importedFilename);


            } catch (\Exception $e) {
                // rename the flag file, because import failed
                rename($inProgressFilename, $failedFilename);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}

                // log a message that the file import failed
                $this->getSystemLogger()->error($e->__toString());

                // re-throw the exception
                throw $e;
            }
        }

        // and and log a message that the subject has been processed
        $systemLogger->info(sprintf('Successfully processed subject %s!', $subject->getClassName()));
    }

    /**
     * Factory method to create new handler instances.
     *
     * @param \TechDivision\Import\Configuration\Subject $subject The subject configuration
     *
     * @return object The handler instance
     */
    public function subjectFactory($subject)
    {

        // load the subject class name
        $className = $subject->getClassName();

        // the database connection to use
        $connection = $this->getImportProcessor()->getConnection();

        // initialize a new handler with the passed class name
        $instance = new $className();

        // $instance the handler instance
        $instance->setConfiguration($subject);
        $instance->setSystemLogger($this->getSystemLogger());
        $instance->setRegistryProcessor($this->getRegistryProcessor());

        // instanciate and set the product processor
        $processorFactory = $subject->getProcessorFactory();
        $productProcessor = $processorFactory::factory($connection, $subject);
        $instance->setProductProcessor($productProcessor);

        // initialize the callbacks/visitors
        CallbackVisitor::get()->visit($instance);
        ObserverVisitor::get()->visit($instance);

        // return the subject instance
        return $instance;
    }

    /**
     * Lifecycle callback that will be inovked after the
     * import process has been finished.
     *
     * @return void
     */
    public function tearDown()
    {
        // clean up here
    }

    /**
     * This method finishes the import process and cleans the registry.
     *
     * @return void
     */
    public function finish()
    {
        $this->getRegistryProcessor()->removeAttribute($this->getSerial());
    }
}


Push — master ( 30c79d...a5e792 )

Simple::getSourceDir() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

1		<?php
2
3		/**
4		* TechDivision\Import\Cli\Simple
5		*
6		* NOTICE OF LICENSE
7		*
8		* This source file is subject to the Open Software License (OSL 3.0)
9		* that is available through the world-wide-web at this URL:
10		* http://opensource.org/licenses/osl-3.0.php
11		*
12		* PHP version 5
13		*
14		* @author Tim Wagner <[email protected]>
15		* @copyright 2016 TechDivision GmbH <[email protected]>
16		* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
17		* @link https://github.com/techdivision/import-cli-simple
18		* @link http://www.techdivision.com
19		*/
20
21		namespace TechDivision\Import\Cli;
22
23		use Rhumsaa\Uuid\Uuid;
24		use Psr\Log\LoggerInterface;
25		use TechDivision\Import\Utils\MemberNames;
26		use TechDivision\Import\Utils\RegistryKeys;
27		use TechDivision\Import\ConfigurationInterface;
28		use TechDivision\Import\Subjects\SubjectInterface;
29		use TechDivision\Import\Cli\Callbacks\CallbackVisitor;
30		use TechDivision\Import\Cli\Observers\ObserverVisitor;
31		use TechDivision\Import\Services\ImportProcessorInterface;
32		use TechDivision\Import\Services\RegistryProcessorInterface;
33
34		/**
35		* A SLSB that handles the product import process.
36		*
37		* @author Tim Wagner <[email protected]>
38		* @copyright 2016 TechDivision GmbH <[email protected]>
39		* @license http://opensource.org/licenses/osl-3.0.php Open Software License (OSL 3.0)
40		* @link https://github.com/techdivision/import-cli-simple
41		* @link http://www.techdivision.com
42		*/
43		class Simple
44		{
45
46		/**
47		* The actions unique serial.
48		*
49		* @var string
50		*/
51		protected $serial;
52
53		/**
54		* The system logger implementation.
55		*
56		* @var \Psr\Log\LoggerInterface
57		*/
58		protected $systemLogger;
59
60		/**
61		* The RegistryProcessor instance to handle running threads.
62		*
63		* @var \TechDivision\Import\Services\RegistryProcessorInterface
64		*/
65		protected $registryProcessor;
66
67		/**
68		* The processor to read/write the necessary import data.
69		*
70		* @var \TechDivision\Import\Services\ImportProcessorInterface
71		*/
72		protected $importProcessor;
73
74		/**
75		* The system configuration.
76		*
77		* @var \TechDivision\Import\ConfigurationInterface
78		*/
79		protected $configuration;
80
81		/**
82		* Set's the unique serial for this import process.
83		*
84		* @param string $serial The unique serial
85		*
86		* @return void
87		*/
88		public function setSerial($serial)
89		{
90		$this->serial = $serial;
91		}
92
93		/**
94		* Return's the unique serial for this import process.
95		*
96		* @return string The unique serial
97		*/
98		public function getSerial()
99		{
100		return $this->serial;
101		}
102
103		/**
104		* Set's the system logger.
105		*
106		* @param \Psr\Log\LoggerInterface $systemLogger The system logger
107		*
108		* @return void
109		*/
110		public function setSystemLogger(LoggerInterface $systemLogger)
111		{
112		$this->systemLogger = $systemLogger;
113		}
114
115		/**
116		* Return's the system logger.
117		*
118		* @return \Psr\Log\LoggerInterface The system logger instance
119		*/
120		public function getSystemLogger()
121		{
122		return $this->systemLogger;
123		}
124
125		/**
126		* Sets's the RegistryProcessor instance to handle the running threads.
127		*
128		* @param \TechDivision\Import\Services\RegistryProcessorInterface $registryProcessor The registry processor instance
129		*
130		* @return void
131		*/
132		public function setRegistryProcessor(RegistryProcessorInterface $registryProcessor)
133		{
134		$this->registryProcessor = $registryProcessor;
135		}
136
137		/**
138		* Return's the RegistryProcessor instance to handle the running threads.
139		*
140		* @return \TechDivision\Import\Services\RegistryProcessor The registry processor instance
141		*/
142		public function getRegistryProcessor()
143		{
144		return $this->registryProcessor;
145		}
146
147		/**
148		* Set's the import processor instance.
149		*
150		* @param \TechDivision\Import\Services\ImportProcessorInterface $importProcessor The import processor instance
151		*
152		* @return void
153		*/
154	1	public function setImportProcessor(ImportProcessorInterface $importProcessor)
155		{
156	1	$this->importProcessor = $importProcessor;
157	1	}
158
159		/**
160		* Return's the import processor instance.
161		*
162		* @return \TechDivision\Import\Services\ImportProcessorInterface The import processor instance
163		*/
164	1	public function getImportProcessor()
165		{
166	1	return $this->importProcessor;
167		}
168
169		/**
170		* Set's the system configuration.
171		*
172		* @param \TechDivision\Import\ConfigurationInterface $configuration The system configuration
173		*
174		* @return void
175		*/
176		public function setConfiguration(ConfigurationInterface $configuration)
177		{
178		$this->configuration = $configuration;
179		}
180
181		/**
182		* Return's the system configuration.
183		*
184		* @return \TechDivision\Import\ConfigurationInterface The system configuration
185		*/
186		public function getConfiguration()
187		{
188		return $this->configuration;
189		}
190
191		/**
192		* Return's the prefix for the import files.
193		*
194		* @return string The prefix
195		*/
196		public function getPrefix()
197		{
198		return $this->getConfiguration()->getPrefix();
		0 ignored issues – show Bug introduced 2016-12-09 16:46 UTC by Report Bug Copy Issue Report The method `getPrefix()` does not seem to exist on `object<TechDivision\Impo...ConfigurationInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
199		}
200
201		/**
202		* Return's the source directory that has to be watched for new files.
203		*
204		* @return string The source directory
205		*/
206		public function getSourceDir()
207		{
208		return $this->getConfiguration()->getSourceDir();
		0 ignored issues – show Bug introduced 2016-12-09 16:46 UTC by Report Bug Copy Issue Report The method `getSourceDir()` does not seem to exist on `object<TechDivision\Impo...ConfigurationInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
209		}
210
211		/**
212		* Parse the temporary upload directory for new files to be imported.
213		*
214		* @return void
215		*/
216		public function import()
217		{
218
219		// track the start time
220		$startTime = microtime(true);
221
222		// generate the serial for the new job
223		$this->setSerial(Uuid::uuid4()->__toString());
224
225		// prepare the global data for the import process
226		$this->start();
227		$this->setUp();
228		$this->processSubjects();
229		$this->tearDown();
230		$this->finish();
231
232		// track the time needed for the import in seconds
233		$endTime = microtime(true) - $startTime;
234
235		// log a message that import has been finished
236		$this->getSystemLogger()->info(sprintf('Successfully finished import with serial %s in %f s', $this->getSerial(), $endTime));
237		}
238
239		/**
240		* This method start's the import process by initializing
241		* the status and appends it to the registry.
242		*
243		* @return void
244		*/
245		public function start()
246		{
247
248		// log a message that import has been started
249		$this->getSystemLogger()->info(sprintf('Now start import with serial %s', $this->getSerial()));
250
251		// initialize the status
252		$status = array(RegistryKeys::STATUS => 1);
253
254		// initialize the status information for the subjects */
255		/** @var \TechDivision\Import\Configuration\SubjectInterface $subject */
256		foreach ($this->getConfiguration()->getSubjects() as $subject) {
257		$status[$subject->getPrefix()] = array();
258		}
259
260		// append it to the registry
261		$this->getRegistryProcessor()->setAttribute($this->getSerial(), $status);
262		}
263
264		/**
265		* Prepares the global data for the import process.
266		*
267		* @return void
268		*/
269		public function setUp()
270		{
271
272		try {
273		// load the registry
274		$importProcessor = $this->getImportProcessor();
275		$registryProcessor = $this->getRegistryProcessor();
276
277		// initialize the array for the global data
278		$globalData = array();
279
280		// initialize the global data
281		$globalData[RegistryKeys::STORES] = $importProcessor->getStores();
282		$globalData[RegistryKeys::LINK_TYPES] = $importProcessor->getLinkTypes();
283		$globalData[RegistryKeys::TAX_CLASSES] = $importProcessor->getTaxClasses();
284		$globalData[RegistryKeys::DEFAULT_STORE] = $importProcessor->getDefaultStore();
		0 ignored issues – show Bug introduced 2016-12-22 18:40 UTC by Report Bug Copy Issue Report The method `getDefaultStore()` does not seem to exist on `object<TechDivision\Impo...portProcessorInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
285		$globalData[RegistryKeys::STORE_WEBSITES] = $importProcessor->getStoreWebsites();
286		$globalData[RegistryKeys::ROOT_CATEGORIES] = $importProcessor->getRootCategories();
287		$globalData[RegistryKeys::CORE_CONFIG_DATA] = $importProcessor->getCoreConfigData();
		0 ignored issues – show Bug introduced 2017-01-02 17:12 UTC by Report Bug Copy Issue Report The method `getCoreConfigData()` does not seem to exist on `object<TechDivision\Impo...portProcessorInterface>`. This check looks for calls to methods that do not seem to exist on a given type. It looks for the method on the type itself as well as in inherited classes or implemented interfaces. This is most likely a typographical error or the method has been renamed. Loading history...
288		$globalData[RegistryKeys::ATTRIBUTE_SETS] = $eavAttributeSets = $importProcessor->getEavAttributeSetsByEntityTypeId(4);
289
290		// prepare the categories
291		$categories = array();
292		foreach ($importProcessor->getCategories() as $category) {
293		// expload the entity IDs from the category path
294		$entityIds = explode('/', $category[MemberNames::PATH]);
295
296		// cut-off the root category
297		array_shift($entityIds);
298
299		// continue with the next category if no entity IDs are available
300		if (sizeof($entityIds) === 0) {
301		continue;
302		}
303
304		// initialize the array for the path elements
305		$path = array();
306		foreach ($importProcessor->getCategoryVarcharsByEntityIds($entityIds) as $cat) {
307		$path[] = $cat[MemberNames::VALUE];
308		}
309
310		// append the catogory with the string path as key
311		$categories[implode('/', $path)] = $category;
312		}
313
314		// initialize the array with the categories
315		$globalData[RegistryKeys::CATEGORIES] = $categories;
316
317		// prepare an array with the EAV attributes grouped by their attribute set name as keys
318		$eavAttributes = array();
319		foreach (array_keys($eavAttributeSets) as $eavAttributeSetName) {
320		$eavAttributes[$eavAttributeSetName] = $importProcessor->getEavAttributesByEntityTypeIdAndAttributeSetName(4, $eavAttributeSetName);
321		}
322
323		// initialize the array with the EAV attributes
324		$globalData[RegistryKeys::EAV_ATTRIBUTES] = $eavAttributes;
325
326		// add the status with the global data
327		$registryProcessor->mergeAttributesRecursive(
328		$this->getSerial(),
329		array(RegistryKeys::GLOBAL_DATA => $globalData)
330		);
331
		0 ignored issues – show Coding Style introduced 2017-01-02 17:12 UTC by Report Bug Copy Issue Report Blank line found at end of control structure Loading history...
332		} catch (\Exception $e) {
333		$this->getSystemLogger()->error($e->__toString());
334		}
335		}
336
337		/**
338		* Process all the subjects defined in the system configuration.
339		*
340		* @return void
341		*/
342		public function processSubjects()
343		{
344
345		try {
346		// load system logger and registry
347		$systemLogger = $this->getSystemLogger();
348		$importProcessor = $this->getImportProcessor();
349
350		// load the subjects
351		$subjects = $this->getConfiguration()->getSubjects();
352
353		// start the transaction
354		$importProcessor->getConnection()->beginTransaction();
355
356		// process all the subjects found in the system configuration
357		foreach ($subjects as $subject) {
358		$this->processSubject($subject);
359		}
360
361		// commit the transaction
362		$importProcessor->getConnection()->commit();
363
		0 ignored issues – show Coding Style introduced 2017-01-02 17:12 UTC by Report Bug Copy Issue Report Blank line found at end of control structure Loading history...
364		} catch (\Exception $e) {
365		// log a message with the stack trace
366		$systemLogger->error($e->__toString());
367
368		// rollback the transaction
369		$importProcessor->getConnection()->rollBack();
		0 ignored issues – show Bug introduced 2016-12-09 16:46 UTC by Report Bug Copy Issue Report The variable `$importProcessor` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
370		}
371		}
372
373		/**
374		* Process the subject with the passed name/identifier.
375		*
376		* @param \TechDivision\Import\Configuration\Subject $subject The subject configuration
377		*
378		* @return void
379		*/
380		public function processSubject($subject)
381		{
382
383		// load the system logger
384		$systemLogger = $this->getSystemLogger();
385
386		// init file iterator on deployment directory
387		$fileIterator = new \FilesystemIterator($sourceDir = $subject->getSourceDir());
388
389		// clear the filecache
390		clearstatcache();
391
392		// prepare the regex to find the files to be imported
393		$regex = sprintf('/^.\/%s.\\.csv$/', $subject->getPrefix());
394
395		// log a debug message
396		$systemLogger->debug(
397		sprintf('Now checking directory %s for files with regex %s to import', $sourceDir, $regex)
398		);
399
400		// iterate through all CSV files and start import process
401		foreach (new \RegexIterator($fileIterator, $regex) as $filename) {
402		try {
403		// prepare the flag filenames
404		$inProgressFilename = sprintf('%s.inProgress', $filename);
405		$importedFilename = sprintf('%s.imported', $filename);
406		$failedFilename = sprintf('%s.failed', $filename);
407
408		// query whether or not the file has already been imported
409		if (is_file($failedFilename) \|\|
410		is_file($importedFilename) \|\|
411		is_file($inProgressFilename)
412		) {
413		// log a debug message
414		$systemLogger->debug(
415		sprintf('Import running, found inProgress file %s', $inProgressFilename)
416		);
417
418		// ignore the file
419		continue;
420		}
421
422		// flag file as in progress
423		touch($inProgressFilename);
424
425		// process the subject
426		$this->subjectFactory($subject)->import($this->getSerial(), $filename->getPathname());
427
428		// rename flag file, because import has been successfull
429		rename($inProgressFilename, $importedFilename);
430
		0 ignored issues – show Coding Style introduced 2017-01-02 17:12 UTC by Report Bug Copy Issue Report Blank line found at end of control structure Loading history...
431		} catch (\Exception $e) {
432		// rename the flag file, because import failed
433		rename($inProgressFilename, $failedFilename);
		0 ignored issues – show Bug introduced 2016-12-09 16:46 UTC by Report Bug Copy Issue Report The variable `$failedFilename` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
434
435		// log a message that the file import failed
436		$this->getSystemLogger()->error($e->__toString());
437
438		// re-throw the exception
439		throw $e;
440		}
441		}
442
443		// and and log a message that the subject has been processed
444		$systemLogger->info(sprintf('Successfully processed subject %s!', $subject->getClassName()));
445		}
446
447		/**
448		* Factory method to create new handler instances.
449		*
450		* @param \TechDivision\Import\Configuration\Subject $subject The subject configuration
451		*
452		* @return object The handler instance
453		*/
454		public function subjectFactory($subject)
455		{
456
457		// load the subject class name
458		$className = $subject->getClassName();
459
460		// the database connection to use
461		$connection = $this->getImportProcessor()->getConnection();
462
463		// initialize a new handler with the passed class name
464		$instance = new $className();
465
466		// $instance the handler instance
467		$instance->setConfiguration($subject);
468		$instance->setSystemLogger($this->getSystemLogger());
469		$instance->setRegistryProcessor($this->getRegistryProcessor());
470
471		// instanciate and set the product processor
472		$processorFactory = $subject->getProcessorFactory();
473		$productProcessor = $processorFactory::factory($connection, $subject);
474		$instance->setProductProcessor($productProcessor);
475
476		// initialize the callbacks/visitors
477		CallbackVisitor::get()->visit($instance);
478		ObserverVisitor::get()->visit($instance);
479
480		// return the subject instance
481		return $instance;
482		}
483
484		/**
485		* Lifecycle callback that will be inovked after the
486		* import process has been finished.
487		*
488		* @return void
489		*/
490		public function tearDown()
491		{
492		// clean up here
493		}
494
495		/**
496		* This method finishes the import process and cleans the registry.
497		*
498		* @return void
499		*/
500		public function finish()
501		{
502		$this->getRegistryProcessor()->removeAttribute($this->getSerial());
503		}
504		}
505

techdivision / import-cli-simple

Push — master ( 30c79d...a5e792 )

Simple::getSourceDir() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like