SeederTask::unSeed() - Code Metrics - Firesphere/silverstripe-seeder - Measure and Improve Code Quality continuously with Scrutinizer

SeederTask::unSeed() A
last analyzed 2018-02-26 22:31 UTC

↳ Parent: SeederTask

Complexity

Conditions	4
Paths	5

Size

Total Lines	16
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	10
nc	5
nop	0
dl	0
loc	16
rs	9.2
c	0
b	0
f	0

<?php

namespace Firesphere\Seeder\Tasks;

use \Page;
use SilverStripe\Control\Director;
use SilverStripe\Control\HTTPRequest;
use SilverStripe\Core\Config\Config;
use SilverStripe\Core\Config\Configurable;
use SilverStripe\Core\Injector\Injector;
use SilverStripe\Dev\BuildTask;
use SilverStripe\Dev\Debug;
use SilverStripe\Dev\FixtureFactory;
use SilverStripe\Dev\YamlFixture;
use SilverStripe\ORM\DataList;
use SilverStripe\ORM\DataObject;
use SilverStripe\Security\DefaultAdminService;
use SilverStripe\Security\Security;
use SilverStripe\Versioned\Versioned;
use Symfony\Component\Yaml\Parser;

/**
 * Class SeederTask
 * @package Firesphere\Seeder\Tasks
 */
class SeederTask extends BuildTask
{
    use Configurable;

    /**
     * @var string URLSegment
     */
    private static $segment = 'seeder';


    /**
     * @var string path to fixture
     */
    protected static $fixtureFile;

    /**
     * @var array
     */
    protected $config;

    /**
     * @var FixtureFactory
     */
    protected $factory;

    /**
     * @var YamlFixture
     */
    protected $fixture;

    /**
     * SeederTask constructor.
     * @throws \Psr\Container\NotFoundExceptionInterface
     * @throws \Exception
     */
    public function __construct()
    {
        $this->config = Config::inst()->get(static::class);

        $this->factory = Injector::inst()->get(FixtureFactory::class);
        $seed = $this->config['Seedfile'];

        /** @var YamlFixture $fixture */
        $this->fixture = Injector::inst()->create(YamlFixture::class, $seed);

        // Log in as admin so we can publish and unpublish
        $adminService = Injector::inst()->get(DefaultAdminService::class);
        $admin = $adminService->findOrCreateDefaultAdmin();
        Security::setCurrentUser($admin);
        parent::__construct();
    }

    /**
     * @return string
     */
    public static function getFixtureFile()
    {
        return self::$fixtureFile;
    }

    /**
     * @param string $fixtureFile
     */
    public static function setFixtureFile($fixtureFile)
    {
        self::$fixtureFile = $fixtureFile;
    }

    /**
     * @param HTTPRequest $request
     * @throws \Psr\Container\NotFoundExceptionInterface
     */
    public function run($request)
    {
        if (!Director::isLive()) {
            switch ($request->getVar('type')) {
                case 'seed':
                    $this->seed();
                    break;
                case 'unseed':
                    $this->unSeed();
                    break;
                default:
                    Debug::message('Please tell me what to do? `type=seed` or `type=unseed`', false);
            }
        } else {
            Debug::message('DO NOT RUN ME ON LIVE ENVIRONMENTS', false);
        }
    }


    /**
     * @throws \Symfony\Component\Yaml\Exception\ParseException
     * @throws \Psr\Container\NotFoundExceptionInterface
     */
    public function seed()
    {
        Debug::message('Starting seed', false);
        $this->fixture->writeInto($this->factory);
        Debug::message('Publishing Versioned items', false);
        $this->publishEach();
        Debug::message('Done seeding', false);
    }

    /**
     *
     * @throws \Symfony\Component\Yaml\Exception\ParseException
     * @throws \Psr\Container\NotFoundExceptionInterface
     */
    public function unSeed()
    {
        Debug::message('Starting unseed', false);
        $fixtureContent = $this->parseFixture();
        foreach ($fixtureContent as $class => $items) {
            /** @var DataObject $class */
            $class = Injector::inst()->get($class);
            if ($class->manyMany()) {
                $this->removeManyMany($class);
            }
            if ($class->hasExtension(Versioned::class)) {
                $this->unpublishEach($class);
            }
            $class::get()->removeAll();
        }
        Debug::message('Done Unseeding', false);
    }

    /**
     * @throws \Symfony\Component\Yaml\Exception\ParseException
     * @throws \Psr\Container\NotFoundExceptionInterface
     */
    public function publishEach()
    {
        Debug::message('Publishing versioned items', false);
        /** @var DataList|\Page[] $pages */
        $pages = Page::get();
        foreach ($pages as $page) {
            $page->publishRecursive();
        }

        $fixtureContent = $this->parseFixture();
        foreach ($fixtureContent as $className => $items) {
            $class = Injector::inst()->get($className);
            if ($class->hasExtension(Versioned::class) && !$class instanceof Page) {
                /** @var DataList|DataObject[] $items */
                $items = Versioned::get_by_stage($className, Versioned::DRAFT);
                foreach ($items as $item) {
                    if (!$item->isPublished()) {
                        $item->publishRecursive();
                        $item->destroy();
                    }
                }
            }
        }
    }

    /**
     * @param DataObject|string $class
     */
    public function removeManyMany($class)
    {
        $items = $class::get();
        Debug::message('Removing relations', false);
        foreach ($items as $obj) {
            foreach ($obj->manyMany() as $name => $className) {
                $obj->$name()->removeAll();
            }
        }
    }

    /**
     * @param DataObject|string $class
     */
    public function unpublishEach($class)
    {
        Debug::message('Unpublishing versioned items', false);
        /** @var DataList|DataObject[] $items */
        $items = $class::get();
        foreach ($items as $item) {
            if ($item->isPublished()) {
                $item->doUnpublish();
                $item->destroy();
            }
        }
    }

    /**
     * @return array|mixed
     * @throws \Symfony\Component\Yaml\Exception\ParseException
     */
    public function parseFixture()
    {
        $parser = new Parser();
        $fixtureContent = [];
        if (file_exists($this->fixture->getFixtureFile())) {
            $contents = file_get_contents($this->fixture->getFixtureFile());
            $fixtureContent = $parser->parse($contents);
        }

        return $fixtureContent;
    }
}


1			<?php
2
3			namespace Firesphere\Seeder\Tasks;
4
5			use \Page;
6			use SilverStripe\Control\Director;
7			use SilverStripe\Control\HTTPRequest;
8			use SilverStripe\Core\Config\Config;
9			use SilverStripe\Core\Config\Configurable;
10			use SilverStripe\Core\Injector\Injector;
11			use SilverStripe\Dev\BuildTask;
12			use SilverStripe\Dev\Debug;
13			use SilverStripe\Dev\FixtureFactory;
14			use SilverStripe\Dev\YamlFixture;
15			use SilverStripe\ORM\DataList;
16			use SilverStripe\ORM\DataObject;
17			use SilverStripe\Security\DefaultAdminService;
18			use SilverStripe\Security\Security;
19			use SilverStripe\Versioned\Versioned;
20			use Symfony\Component\Yaml\Parser;
21
22			/**
23			* Class SeederTask
24			* @package Firesphere\Seeder\Tasks
25			*/
26			class SeederTask extends BuildTask
27			{
28			use Configurable;
29
30			/**
31			* @var string URLSegment
32			*/
33			private static $segment = 'seeder';
			0 ignored issues – show introduced 2018-02-20 08:44 UTC by Report Bug Copy Issue Report The private property `$segment` is not used, and could be removed. Loading history...
34
35			/**
36			* @var string path to fixture
37			*/
38			protected static $fixtureFile;
39
40			/**
41			* @var array
42			*/
43			protected $config;
44
45			/**
46			* @var FixtureFactory
47			*/
48			protected $factory;
49
50			/**
51			* @var YamlFixture
52			*/
53			protected $fixture;
54
55			/**
56			* SeederTask constructor.
57			* @throws \Psr\Container\NotFoundExceptionInterface
58			* @throws \Exception
59			*/
60			public function __construct()
61			{
62			$this->config = Config::inst()->get(static::class);
63
64			$this->factory = Injector::inst()->get(FixtureFactory::class);
65			$seed = $this->config['Seedfile'];
66
67			/** @var YamlFixture $fixture */
68			$this->fixture = Injector::inst()->create(YamlFixture::class, $seed);
69
70			// Log in as admin so we can publish and unpublish
71			$adminService = Injector::inst()->get(DefaultAdminService::class);
72			$admin = $adminService->findOrCreateDefaultAdmin();
73			Security::setCurrentUser($admin);
74			parent::__construct();
75			}
76
77			/**
78			* @return string
79			*/
80			public static function getFixtureFile()
81			{
82			return self::$fixtureFile;
83			}
84
85			/**
86			* @param string $fixtureFile
87			*/
88			public static function setFixtureFile($fixtureFile)
89			{
90			self::$fixtureFile = $fixtureFile;
91			}
92
93			/**
94			* @param HTTPRequest $request
95			* @throws \Psr\Container\NotFoundExceptionInterface
96			*/
97			public function run($request)
98			{
99			if (!Director::isLive()) {
100			switch ($request->getVar('type')) {
101			case 'seed':
102			$this->seed();
103			break;
104			case 'unseed':
105			$this->unSeed();
106			break;
107			default:
108			Debug::message('Please tell me what to do? `type=seed` or `type=unseed`', false);
109			}
110			} else {
111			Debug::message('DO NOT RUN ME ON LIVE ENVIRONMENTS', false);
112			}
113			}
114
115
116			/**
117			* @throws \Symfony\Component\Yaml\Exception\ParseException
118			* @throws \Psr\Container\NotFoundExceptionInterface
119			*/
120			public function seed()
121			{
122			Debug::message('Starting seed', false);
123			$this->fixture->writeInto($this->factory);
124			Debug::message('Publishing Versioned items', false);
125			$this->publishEach();
126			Debug::message('Done seeding', false);
127			}
128
129			/**
130			*
131			* @throws \Symfony\Component\Yaml\Exception\ParseException
132			* @throws \Psr\Container\NotFoundExceptionInterface
133			*/
134			public function unSeed()
135			{
136			Debug::message('Starting unseed', false);
137			$fixtureContent = $this->parseFixture();
138			foreach ($fixtureContent as $class => $items) {
139			/** @var DataObject $class */
140			$class = Injector::inst()->get($class);
141			if ($class->manyMany()) {
142			$this->removeManyMany($class);
143			}
144			if ($class->hasExtension(Versioned::class)) {
145			$this->unpublishEach($class);
146			}
147			$class::get()->removeAll();
148			}
149			Debug::message('Done Unseeding', false);
150			}
151
152			/**
153			* @throws \Symfony\Component\Yaml\Exception\ParseException
154			* @throws \Psr\Container\NotFoundExceptionInterface
155			*/
156			public function publishEach()
157			{
158			Debug::message('Publishing versioned items', false);
159			/** @var DataList\|\Page[] $pages */
160			$pages = Page::get();
161			foreach ($pages as $page) {
162			$page->publishRecursive();
163			}
164
165			$fixtureContent = $this->parseFixture();
166			foreach ($fixtureContent as $className => $items) {
167			$class = Injector::inst()->get($className);
168			if ($class->hasExtension(Versioned::class) && !$class instanceof Page) {
169			/** @var DataList\|DataObject[] $items */
170			$items = Versioned::get_by_stage($className, Versioned::DRAFT);
171			foreach ($items as $item) {
172			if (!$item->isPublished()) {
173			$item->publishRecursive();
174			$item->destroy();
175			}
176			}
177			}
178			}
179			}
180
181			/**
182			* @param DataObject\|string $class
183			*/
184			public function removeManyMany($class)
185			{
186			$items = $class::get();
187			Debug::message('Removing relations', false);
188			foreach ($items as $obj) {
189			foreach ($obj->manyMany() as $name => $className) {
190			$obj->$name()->removeAll();
191			}
192			}
193			}
194
195			/**
196			* @param DataObject\|string $class
197			*/
198			public function unpublishEach($class)
199			{
200			Debug::message('Unpublishing versioned items', false);
201			/** @var DataList\|DataObject[] $items */
202			$items = $class::get();
203			foreach ($items as $item) {
204			if ($item->isPublished()) {
205			$item->doUnpublish();
206			$item->destroy();
207			}
208			}
209			}
210
211			/**
212			* @return array\|mixed
213			* @throws \Symfony\Component\Yaml\Exception\ParseException
214			*/
215			public function parseFixture()
216			{
217			$parser = new Parser();
218			$fixtureContent = [];
219			if (file_exists($this->fixture->getFixtureFile())) {
220			$contents = file_get_contents($this->fixture->getFixtureFile());
221			$fixtureContent = $parser->parse($contents);
222			}
223
224			return $fixtureContent;
225			}
226			}
227

Firesphere / silverstripe-seeder

SeederTask::unSeed() A last analyzed 2018-02-26 22:31 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

SeederTask::unSeed() A
last analyzed 2018-02-26 22:31 UTC