Entity::unpublishOtherRevisions() - Code Metrics - Inspection of "Code style and documentation updates" - RocketPropelledTortoise/Core - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8a4d0b...126fd8 )

by Stéphane

created 2016-06-06 19:24 UTC

Entity::unpublishOtherRevisions() A

↳ Parent: Entity

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	7
c	1
b	0
f	0
nc	2
nop	0
dl	0
loc	12
ccs	8
cts	8
cp	1
crap	2
rs	9.4285

<?php namespace Rocket\Entities;

use Illuminate\Support\Collection;
use Illuminate\Support\Facades\DB;
use InvalidArgumentException;
use Rocket\Entities\Exceptions\InvalidFieldTypeException;
use Rocket\Entities\Exceptions\NonExistentFieldException;
use Rocket\Entities\Exceptions\ReservedFieldNameException;

/**
 * Entity manager
 *
 * @property int $id The content ID
 * @property int $language_id The language in which this entity is
 * @property string $type The type of the Entity
 * @property boolean $published Is this content published
 * @property array<Rocket\Entities\Revision> $revisions all revisions in this content
 * @property-read \DateTime $created_at
 * @property-read \DateTime $updated_at
 */
abstract class Entity
{
    /**
     * @var array<class> The list of field types, filled with the configuration
     */
    public static $types;

    /**
     * The content represented by this entity
     *
     * @var Content
     */
    protected $content; //id, created_at, type, published

    /**
     * The revision represented by this entity
     *
     * @var Revision
     */
    protected $revision; //language_id, updated_at, type, published

    /**
     * The fields in this entity
     *
     * @var array<FieldCollection>
     */
    protected $data;

    /**
     * Entity constructor.
     *
     * @param int $language_id The language this specific entity is in
     */
    public function __construct($language_id)
    {
        if (!is_int($language_id) || $language_id == 0) {
            throw new InvalidArgumentException("You must set a valid 'language_id'.");
        }

        $fields = $this->getFields();

        $this->initialize($fields);

        $this->type = $this->getContentType();
        $this->language_id = $language_id;
    }

    /**
     * Creates the Content, Revision and FieldCollections
     *
     * @param array $fields The fields and their configurations
     * @throws InvalidFieldTypeException
     * @throws ReservedFieldNameException
     */
    protected function initialize(array $fields)
    {
        $this->content = new Content;
        $this->revision = new Revision;

        foreach ($fields as $field => $settings) {
            $this->data[$field] = $this->initializeField($field, $settings);
        }
    }

    /**
     * Validate configuration and prepare a FieldCollection
     *
     * @param string $field
     * @param array $settings
     * @throws InvalidFieldTypeException
     * @throws ReservedFieldNameException
     * @return FieldCollection
     */
    protected function initializeField($field, $settings)
    {
        if ($this->isContentField($field) || $this->isRevisionField($field)) {
            throw new ReservedFieldNameException(
                "The field '$field' cannot be used in '" . get_class($this) . "' as it is a reserved name"
            );
        }

        $type = $settings['type'];

        if (!array_key_exists($type, self::$types)) {
            throw new InvalidFieldTypeException("Unkown type '$type' in '" . get_class($this) . "'");
        }

        $settings['type'] = self::$types[$settings['type']];

        return FieldCollection::initField($settings);
    }

    /**
     * Return the fields in this entity
     *
     * @return array
     */
    abstract public function getFields();

    /**
     * Get the database friendly content type
     *
     * @return string
     */
    public static function getContentType()
    {
        return str_replace('\\', '', snake_case((new \ReflectionClass(get_called_class()))->getShortName()));
    }

    /**
     * Create a new revision based on the same content ID but without the content.
     * Very useful if you want to add a new language
     *
     * @param int $language_id
     * @return static
     */
    public function newRevision($language_id = null)
    {
        $created = new static($language_id ?: $this->language_id);
        $created->content = $this->content;

        return $created;
    }

    /**
     * Check if the field is related to the content
     *
     * @param string $field
     * @return bool
     */
    protected function isContentField($field)
    {
        return in_array($field, ['id', 'created_at', 'type', 'published']);
    }

    /**
     * Check if the field exists on the entity
     *
     * @param string $field
     * @return bool
     */
    public function hasField($field)
    {
        return array_key_exists($field, $this->data);
    }

    /**
     * @param string $field
     * @return FieldCollection
     */
    public function getField($field)
    {
        return $this->data[$field];
    }

    /**
     * Check if the field is related to the revision
     *
     * @param string $field
     * @return bool
     */
    protected function isRevisionField($field)
    {
        return in_array($field, ['language_id', 'updated_at', 'published']);
    }

    /**
     * Dynamically retrieve attributes on the model.
     *
     * @param string $key
     * @throws NonExistentFieldException
     * @return $this|bool|\Carbon\Carbon|\DateTime|mixed|static
     */
    public function __get($key)
    {
        if ($this->isContentField($key)) {
            return $this->content->getAttribute($key);
        }

        if ($this->isRevisionField($key)) {
            return $this->revision->getAttribute($key);
        }

        if ($this->hasField($key)) {
            return $this->getField($key);
        }

        if ($key == 'revisions') {
            return $this->content->revisions;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        }

        throw new NonExistentFieldException("Field '$key' doesn't exist in '" . get_class($this) . "'");
    }

    /**
     * Dynamically set attributes on the model.
     *
     * @param string $key
     * @param mixed $value
     * @throws NonExistentFieldException
     */
    public function __set($key, $value)
    {
        if ($this->isContentField($key)) {
            $this->content->setAttribute($key, $value);

            return;
        }

        if ($this->isRevisionField($key)) {
            $this->revision->setAttribute($key, $value);

            return;
        }

        if ($this->hasField($key)) {
            $field = $this->getField($key);

            if (is_array($value)) {
                $field->clear();

                // This happens when the array is replaced completely by another array
                if (count($value)) {
                    foreach ($value as $k => $v) {
                        $field->offsetSet($k, $v);
                    }
                }

                return;
            }

            $field->offsetSet(0, $value);

            return;
        }

        throw new NonExistentFieldException("Field '$key' doesn't exist in '" . get_class($this) . "'");
    }

    /**
     * Find the latest valid revision for this entity
     *
     * @param int $id
     * @param int $language_id
     * @return static
     */
    public static function find($id, $language_id)
    {
        $instance = new static($language_id);

        $instance->content = Content::findOrFail($id);

        $instance->revision = Revision::where('content_id', $id)
            ->where('language_id', $language_id)
            ->where('published', true)
            ->firstOrFail();

        (new Collection($instance->getFields()))
            ->map(function ($options) {
                return $options['type'];
            })
            ->values()
            ->unique()
            ->map(function ($type) {
                return self::$types[$type];
            })
            ->each(function ($type) use ($instance) {
                $type::where('revision_id', $instance->revision->id)
                    ->get()
                    ->each(function (Field $value) use ($instance) {
                        $instance->data[$value->name][$value->weight] = $value;
                    });
            });

        return $instance;
    }

    /**
     * Save a revision
     *
     * @param bool $newRevision Should we create a new revision, false by default
     * @param bool $publishRevision Should we immediately publish this revision, true by default
     */
    public function save($newRevision = false, $publishRevision = true)
    {
        if ($newRevision) {
            $revision = new Revision;
            $revision->language_id = $this->revision->language_id;

            $this->revision = $revision;
        }

        DB::transaction(
            function () use ($newRevision, $publishRevision) {
                $this->saveContent();

                $this->saveRevision($publishRevision);

                // Prepare and save fields
                foreach (array_keys($this->data) as $fieldName) {
                    /** @var FieldCollection $field */
                    $field = $this->data[$fieldName];

                    if (!$newRevision) {
                        $field->deleted()->each(function (Field $value) {
                            $value->delete();
                        });
                    }

                    $field->each(function (Field $value, $key) use ($newRevision, $fieldName) {
                        $value->weight = $key;
                        $value->name = $fieldName;
                        $this->saveField($value, $newRevision);
                    });

                    $field->syncOriginal();
                }
            }
        );
    }

    /**
     * Save the content
     */
    protected function saveContent()
    {
        $this->content->save();
    }

    /**
     * Save the revision
     *
     * @param bool $publishRevision Should we immediately publish this revision, true by default
     */
    protected function saveRevision($publishRevision)
    {
        if (!$this->revision->exists && !$publishRevision) {
            $this->revision->published = $publishRevision;
        }

        $this->revision->content_id = $this->content->id;
        $this->revision->save();

        if ($publishRevision) {
            $this->unpublishOtherRevisions();
        }
    }

    /**
     * Unpublish the revisions other than this one.
     * Only for the same content_id and language_id
     */
    protected function unpublishOtherRevisions()
    {
        if ($this->content->wasRecentlyCreated) {
            return;
        }

        // Unpublish all other revisions
        Revision::where('content_id', $this->content->id)
            ->where('language_id', $this->revision->language_id)
            ->where('id', '!=', $this->revision->id)
            ->update(['published' => false]);
    }

    /**
     * Save a single field instance
     *
     * @param Field $field The field instance to save
     * @param boolean $newRevision Should we create a new revision?
     */
    protected function saveField(Field $field, $newRevision)
    {
        // If we create a new revision, this will
        // reinit the field to a non-saved field
        // and create a new row in the database
        if ($newRevision) {
            $field->id = null;
            $field->exists = false;
        }

        $field->revision_id = $this->revision->id;

        $field->save();
    }

    /**
     * Convert the Entity to an array.
     *
     * @return array
     */
    public function toArray()
    {
        $content = [
            '_content' => $this->content->toArray(),
            '_revision' => $this->revision->toArray(),
        ];

        foreach ($this->data as $field => $data) {
            $content[$field] = $data->toArray();
        }

        return $content;
    }
}


1		<?php namespace Rocket\Entities;
2
3		use Illuminate\Support\Collection;
4		use Illuminate\Support\Facades\DB;
5		use InvalidArgumentException;
6		use Rocket\Entities\Exceptions\InvalidFieldTypeException;
7		use Rocket\Entities\Exceptions\NonExistentFieldException;
8		use Rocket\Entities\Exceptions\ReservedFieldNameException;
9
10		/**
11		* Entity manager
12		*
13		* @property int $id The content ID
14		* @property int $language_id The language in which this entity is
15		* @property string $type The type of the Entity
16		* @property boolean $published Is this content published
17		* @property array<Rocket\Entities\Revision> $revisions all revisions in this content
18		* @property-read \DateTime $created_at
19		* @property-read \DateTime $updated_at
20		*/
21		abstract class Entity
22		{
23		/**
24		* @var array<class> The list of field types, filled with the configuration
25		*/
26		public static $types;
27
28		/**
29		* The content represented by this entity
30		*
31		* @var Content
32		*/
33		protected $content; //id, created_at, type, published
34
35		/**
36		* The revision represented by this entity
37		*
38		* @var Revision
39		*/
40		protected $revision; //language_id, updated_at, type, published
41
42		/**
43		* The fields in this entity
44		*
45		* @var array<FieldCollection>
46		*/
47		protected $data;
48
49		/**
50		* Entity constructor.
51		*
52		* @param int $language_id The language this specific entity is in
53		*/
54	57	public function __construct($language_id)
55		{
56	57	if (!is_int($language_id) \|\| $language_id == 0) {
57	3	throw new InvalidArgumentException("You must set a valid 'language_id'.");
58		}
59
60	54	$fields = $this->getFields();
61
62	54	$this->initialize($fields);
63
64	48	$this->type = $this->getContentType();
65	48	$this->language_id = $language_id;
66	48	}
67
68		/**
69		* Creates the Content, Revision and FieldCollections
70		*
71		* @param array $fields The fields and their configurations
72		* @throws InvalidFieldTypeException
73		* @throws ReservedFieldNameException
74		*/
75	54	protected function initialize(array $fields)
76		{
77	54	$this->content = new Content;
78	54	$this->revision = new Revision;
79
80	54	foreach ($fields as $field => $settings) {
81	54	$this->data[$field] = $this->initializeField($field, $settings);
82	48	}
83	48	}
84
85		/**
86		* Validate configuration and prepare a FieldCollection
87		*
88		* @param string $field
89		* @param array $settings
90		* @throws InvalidFieldTypeException
91		* @throws ReservedFieldNameException
92		* @return FieldCollection
93		*/
94	54	protected function initializeField($field, $settings)
95		{
96	54	if ($this->isContentField($field) \|\| $this->isRevisionField($field)) {
97	3	throw new ReservedFieldNameException(
98	3	"The field '$field' cannot be used in '" . get_class($this) . "' as it is a reserved name"
99	3	);
100		}
101
102	51	$type = $settings['type'];
103
104	51	if (!array_key_exists($type, self::$types)) {
105	3	throw new InvalidFieldTypeException("Unkown type '$type' in '" . get_class($this) . "'");
106		}
107
108	48	$settings['type'] = self::$types[$settings['type']];
109
110	48	return FieldCollection::initField($settings);
111		}
112
113		/**
114		* Return the fields in this entity
115		*
116		* @return array
117		*/
118		abstract public function getFields();
119
120		/**
121		* Get the database friendly content type
122		*
123		* @return string
124		*/
125	54	public static function getContentType()
126		{
127	54	return str_replace('\\', '', snake_case((new \ReflectionClass(get_called_class()))->getShortName()));
128		}
129
130		/**
131		* Create a new revision based on the same content ID but without the content.
132		* Very useful if you want to add a new language
133		*
134		* @param int $language_id
135		* @return static
136		*/
137	3	public function newRevision($language_id = null)
138		{
139	3	$created = new static($language_id ?: $this->language_id);
140	3	$created->content = $this->content;
141
142	3	return $created;
143		}
144
145		/**
146		* Check if the field is related to the content
147		*
148		* @param string $field
149		* @return bool
150		*/
151	54	protected function isContentField($field)
152		{
153	54	return in_array($field, ['id', 'created_at', 'type', 'published']);
154		}
155
156		/**
157		* Check if the field exists on the entity
158		*
159		* @param string $field
160		* @return bool
161		*/
162	42	public function hasField($field)
163		{
164	42	return array_key_exists($field, $this->data);
165		}
166
167		/**
168		* @param string $field
169		* @return FieldCollection
170		*/
171	36	public function getField($field)
172		{
173	36	return $this->data[$field];
174		}
175
176		/**
177		* Check if the field is related to the revision
178		*
179		* @param string $field
180		* @return bool
181		*/
182	51	protected function isRevisionField($field)
183		{
184	51	return in_array($field, ['language_id', 'updated_at', 'published']);
185		}
186
187		/**
188		* Dynamically retrieve attributes on the model.
189		*
190		* @param string $key
191		* @throws NonExistentFieldException
192		* @return $this\|bool\|\Carbon\Carbon\|\DateTime\|mixed\|static
193		*/
194	42	public function __get($key)
195		{
196	42	if ($this->isContentField($key)) {
197	18	return $this->content->getAttribute($key);
198		}
199
200	39	if ($this->isRevisionField($key)) {
201	6	return $this->revision->getAttribute($key);
202		}
203
204	36	if ($this->hasField($key)) {
205	33	return $this->getField($key);
206		}
207
208	10	if ($key == 'revisions') {
209	7	return $this->content->revisions;
		0 ignored issues – show Documentation introduced 2016-06-06 13:21 UTC by Report Bug Copy Issue Report The property `revisions` does not exist on `object<Rocket\Entities\Content>`. Since you implemented `__get`, maybe consider adding a @property annotation. Since your code implements the magic getter `_get`, this function will be called for any read access on an undefined variable. You can add the `@property` annotation to your class or interface to document the existence of this variable. <?php /** * @property int $x * @property int $y * @property string $text */ class MyLabel { private $properties; private $allowedProperties = array('x', 'y', 'text'); public function __get($name) { if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) { return $properties[$name]; } else { return null; } } public function __set($name, $value) { if (in_array($name, $this->allowedProperties)) { $properties[$name] = $value; } else { throw new \LogicException("Property $name is not defined."); } } } If the property has read access only, you can use the @property-read annotation instead. Of course, you may also just have mistyped another name, in which case you should fix the error. See also the PhpDoc documentation for @property. Loading history...
210		}
211
212	3	throw new NonExistentFieldException("Field '$key' doesn't exist in '" . get_class($this) . "'");
213		}
214
215		/**
216		* Dynamically set attributes on the model.
217		*
218		* @param string $key
219		* @param mixed $value
220		* @throws NonExistentFieldException
221		*/
222	48	public function __set($key, $value)
223		{
224	48	if ($this->isContentField($key)) {
225	48	$this->content->setAttribute($key, $value);
226
227	48	return;
228		}
229
230	48	if ($this->isRevisionField($key)) {
231	48	$this->revision->setAttribute($key, $value);
232
233	48	return;
234		}
235
236	21	if ($this->hasField($key)) {
237	18	$field = $this->getField($key);
238
239	18	if (is_array($value)) {
240	12	$field->clear();
241
242		// This happens when the array is replaced completely by another array
243	12	if (count($value)) {
244	3	foreach ($value as $k => $v) {
245	3	$field->offsetSet($k, $v);
246	3	}
247	3	}
248
249	12	return;
250		}
251
252	6	$field->offsetSet(0, $value);
253
254	6	return;
255		}
256
257	3	throw new NonExistentFieldException("Field '$key' doesn't exist in '" . get_class($this) . "'");
258		}
259
260		/**
261		* Find the latest valid revision for this entity
262		*
263		* @param int $id
264		* @param int $language_id
265		* @return static
266		*/
267	12	public static function find($id, $language_id)
268		{
269	12	$instance = new static($language_id);
270
271	12	$instance->content = Content::findOrFail($id);
272
273	12	$instance->revision = Revision::where('content_id', $id)
274	12	->where('language_id', $language_id)
275	12	->where('published', true)
276	12	->firstOrFail();
277
278	12	(new Collection($instance->getFields()))
279		->map(function ($options) {
280	12	return $options['type'];
281	12	})
282	12	->values()
283	12	->unique()
284		->map(function ($type) {
285	12	return self::$types[$type];
286	12	})
287		->each(function ($type) use ($instance) {
288	12	$type::where('revision_id', $instance->revision->id)
289	12	->get()
290		->each(function (Field $value) use ($instance) {
291	12	$instance->data[$value->name][$value->weight] = $value;
292	12	});
293	12	});
294
295	12	return $instance;
296		}
297
298		/**
299		* Save a revision
300		*
301		* @param bool $newRevision Should we create a new revision, false by default
302		* @param bool $publishRevision Should we immediately publish this revision, true by default
303		*/
304	15	public function save($newRevision = false, $publishRevision = true)
305		{
306	15	if ($newRevision) {
307	6	$revision = new Revision;
308	6	$revision->language_id = $this->revision->language_id;
309
310	6	$this->revision = $revision;
311	6	}
312
313	15	DB::transaction(
314		function () use ($newRevision, $publishRevision) {
315	15	$this->saveContent();
316
317	15	$this->saveRevision($publishRevision);
318
319		// Prepare and save fields
320	15	foreach (array_keys($this->data) as $fieldName) {
321		/** @var FieldCollection $field */
322	15	$field = $this->data[$fieldName];
323
324	15	if (!$newRevision) {
325		$field->deleted()->each(function (Field $value) {
326	3	$value->delete();
327	15	});
328	15	}
329
330	15	$field->each(function (Field $value, $key) use ($newRevision, $fieldName) {
331	15	$value->weight = $key;
332	15	$value->name = $fieldName;
333	15	$this->saveField($value, $newRevision);
334	15	});
335
336	15	$field->syncOriginal();
337	15	}
338	15	}
339	15	);
340	15	}
341
342		/**
343		* Save the content
344		*/
345	15	protected function saveContent()
346		{
347	15	$this->content->save();
348	15	}
349
350		/**
351		* Save the revision
352		*
353		* @param bool $publishRevision Should we immediately publish this revision, true by default
354		*/
355	15	protected function saveRevision($publishRevision)
356		{
357	15	if (!$this->revision->exists && !$publishRevision) {
358	3	$this->revision->published = $publishRevision;
359	3	}
360
361	15	$this->revision->content_id = $this->content->id;
362	15	$this->revision->save();
363
364	15	if ($publishRevision) {
365	15	$this->unpublishOtherRevisions();
366	15	}
367	15	}
368
369		/**
370		* Unpublish the revisions other than this one.
371		* Only for the same content_id and language_id
372		*/
373	15	protected function unpublishOtherRevisions()
374		{
375	15	if ($this->content->wasRecentlyCreated) {
376	15	return;
377		}
378
379		// Unpublish all other revisions
380	6	Revision::where('content_id', $this->content->id)
381	6	->where('language_id', $this->revision->language_id)
382	6	->where('id', '!=', $this->revision->id)
383	6	->update(['published' => false]);
384	6	}
385
386		/**
387		* Save a single field instance
388		*
389		* @param Field $field The field instance to save
390		* @param boolean $newRevision Should we create a new revision?
391		*/
392	15	protected function saveField(Field $field, $newRevision)
393		{
394		// If we create a new revision, this will
395		// reinit the field to a non-saved field
396		// and create a new row in the database
397	15	if ($newRevision) {
398	6	$field->id = null;
399	6	$field->exists = false;
400	6	}
401
402	15	$field->revision_id = $this->revision->id;
403
404	15	$field->save();
405	15	}
406
407		/**
408		* Convert the Entity to an array.
409		*
410		* @return array
411		*/
412	16	public function toArray()
413		{
414		$content = [
415	16	'_content' => $this->content->toArray(),
416	16	'_revision' => $this->revision->toArray(),
417	16	];
418
419	16	foreach ($this->data as $field => $data) {
420	16	$content[$field] = $data->toArray();
421	16	}
422
423	16	return $content;
424		}
425		}
426

RocketPropelledTortoise / Core

Push — master ( 8a4d0b...126fd8 )

Entity::unpublishOtherRevisions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like