FieldInput - Code Metrics - Inspection of "Default Value jQuery plugin" - symphonycms/symphony-2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — 2.6.x (#2512)

by Nicolas

created 2016-02-18 22:59 UTC

FieldInput C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	385
Duplicated Lines	33.77 %

Coupling/Cohesion

Components	1
Dependencies	9

Metric	Value
wmc	59
lcom	1
cbo	9
dl	130
loc	385
rs	6.1904

23 Methods

Rating	Name	Duplication	Size	Complexity
A	canFilter()	0	4	1
A	canPrePopulate()	0	4	1
A	isSortable()	0	4	1
A	allowDatasourceOutputGrouping()	0	4	1
A	allowDatasourceParamOutput()	0	4	1
A	__replaceAmpersands()	0	4	1
A	commit()	18	18	4
A	__construct()	8	8	1
A	createTable()	0	15	1
A	__applyValidationRules()	0	6	2
A	setFromPOST()	0	8	2
A	displaySettingsPanel()	0	10	1
B	displayPublishPanel()	0	17	5
B	checkPostFieldData()	8	20	6
A	processRawFieldData()	0	16	2
A	appendFormattedElement()	0	21	4
A	getImportModes()	0	7	1
A	prepareImportValue()	13	13	3
A	getExportModes()	0	8	1
B	prepareExportValue()	10	21	7
B	buildDSRetrievalSQL()	48	48	6
A	buildSortingSQL()	0	17	2
B	groupRecords()	25	25	5

How to fix Duplicated Code Complexity

Duplicated Code

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:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like FieldInput 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 FieldInput, and based on these observations, apply Extract Interface, too.

<?php

/**
 * @package toolkit
 */

/**
 * A simple Input field that essentially maps to HTML's `<input type='text'/>`.
 */
class FieldInput extends Field implements ExportableField, ImportableField
{
    public function __construct()
    {
        parent::__construct();
        $this->_name = __('Text Input');
class MyClass { }

$x = new MyClass();
$x->foo = true;
        $this->_required = true;

        $this->set('required', 'no');
    }

    /*-------------------------------------------------------------------------
        Definition:
    -------------------------------------------------------------------------*/

    public function canFilter()
    {
        return true;
    }

    public function canPrePopulate()
    {
        return true;
    }

    public function isSortable()
    {
        return true;
    }

    public function allowDatasourceOutputGrouping()
    {
        return true;
    }

    public function allowDatasourceParamOutput()
    {
        return true;
    }

    /*-------------------------------------------------------------------------
        Setup:
    -------------------------------------------------------------------------*/

    public function createTable()
    {
        return Symphony::Database()->query(
            "CREATE TABLE IF NOT EXISTS `tbl_entries_data_" . $this->get('id') . "` (
              `id` int(11) unsigned NOT null auto_increment,
              `entry_id` int(11) unsigned NOT null,
              `handle` varchar(255) default null,
              `value` varchar(255) default null,
              PRIMARY KEY  (`id`),
              UNIQUE KEY `entry_id` (`entry_id`),
              KEY `handle` (`handle`),
              KEY `value` (`value`)
            ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;"
        );
    }

    /*-------------------------------------------------------------------------
        Utilities:
    -------------------------------------------------------------------------*/

    private function __applyValidationRules($data)
    {
        $rule = $this->get('validator');

        return ($rule ? General::validateString($data, $rule) : true);
    }

    private function __replaceAmpersands($value)
    {
        return preg_replace('/&(?!(#[0-9]+|#x[0-9a-f]+|amp|lt|gt);)/i', '&amp;', trim($value));
    }

    /*-------------------------------------------------------------------------
        Settings:
    -------------------------------------------------------------------------*/

    public function setFromPOST(array $settings = array())
    {
        parent::setFromPOST($settings);

        if ($this->get('validator') == '') {
            $this->remove('validator');
        }
    }

    public function displaySettingsPanel(XMLElement &$wrapper, $errors = null)
    {
        parent::displaySettingsPanel($wrapper, $errors);

        // Validation rule
        $this->buildValidationSelect($wrapper, $this->get('validator'), 'fields['.$this->get('sortorder').'][validator]', 'input', $errors);

        // Requirements and table display
        $this->appendStatusFooter($wrapper);
    }

    public function commit()
    {
        if (!parent::commit()) {
            return false;
        }

        $id = $this->get('id');

        if ($id === false) {
            return false;
        }

        $fields = array('validator'=>null);

        $fields['validator'] = ($fields['validator'] == 'custom' ? null : $this->get('validator'));

        return FieldManager::saveSettings($id, $fields);
    }

    /*-------------------------------------------------------------------------
        Publish:
    -------------------------------------------------------------------------*/

    public function displayPublishPanel(XMLElement &$wrapper, $data = null, $flagWithError = null, $fieldnamePrefix = null, $fieldnamePostfix = null, $entry_id = null)
    {
        $value = General::sanitize(isset($data['value']) ? $data['value'] : null);
        $label = Widget::Label($this->get('label'));

        if ($this->get('required') !== 'yes') {
            $label->appendChild(new XMLElement('i', __('Optional')));
        }

        $label->appendChild(Widget::Input('fields'.$fieldnamePrefix.'['.$this->get('element_name').']'.$fieldnamePostfix, (strlen($value) != 0 ? $value : null)));

        if ($flagWithError != null) {
            $wrapper->appendChild(Widget::Error($label, $flagWithError));
        } else {
            $wrapper->appendChild($label);
        }
    }

    public function checkPostFieldData($data, &$message, $entry_id = null)
    {
        $message = null;

        if (is_array($data) && isset($data['value'])) {
            $data = $data['value'];
        }

        if ($this->get('required') === 'yes' && strlen(trim($data)) == 0) {
            $message = __('‘%s’ is a required field.', array($this->get('label')));
            return self::__MISSING_FIELDS__;
        }

        if (!$this->__applyValidationRules($data)) {
            $message = __('‘%s’ contains invalid data. Please check the contents.', array($this->get('label')));
            return self::__INVALID_FIELDS__;
        }

        return self::__OK__;
    }

    public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)
    {
        $status = self::__OK__;

        if (strlen(trim($data)) == 0) {
            return array();
        }

        $result = array(
            'value' => $data
        );

        $result['handle'] = Lang::createHandle($result['value']);

        return $result;
    }

    /*-------------------------------------------------------------------------
        Output:
    -------------------------------------------------------------------------*/

    public function appendFormattedElement(XMLElement &$wrapper, $data, $encode = false, $mode = null, $entry_id = null)
    {
        $value = $data['value'];

        if ($encode === true) {
            $value = General::sanitize($value);
        } else {
            if (!General::validateXML($data['value'], $errors, false, new XsltProcess)) {
                $value = html_entity_decode($data['value'], ENT_QUOTES, 'UTF-8');
                $value = $this->__replaceAmpersands($value);

                if (!General::validateXML($value, $errors, false, new XsltProcess)) {
                    $value = General::sanitize($data['value']);
                }
            }
        }

        $wrapper->appendChild(
            new XMLElement($this->get('element_name'), $value, array('handle' => $data['handle']))
        );
    }

    /*-------------------------------------------------------------------------
        Import:
    -------------------------------------------------------------------------*/

    public function getImportModes()
    {
        return array(
            'getValue' =>       ImportableField::STRING_VALUE,
            'getPostdata' =>    ImportableField::ARRAY_VALUE
        );
    }

    public function prepareImportValue($data, $mode, $entry_id = null)
    {
        $message = $status = null;
        $modes = (object)$this->getImportModes();

        if ($mode === $modes->getValue) {
            return $data;
        } elseif ($mode === $modes->getPostdata) {
            return $this->processRawFieldData($data, $status, $message, true, $entry_id);
        }

        return null;
    }

    /*-------------------------------------------------------------------------
        Export:
    -------------------------------------------------------------------------*/

    /**
     * Return a list of supported export modes for use with `prepareExportValue`.
     *
     * @return array
     */
    public function getExportModes()
    {
        return array(
            'getHandle' =>      ExportableField::HANDLE,
            'getUnformatted' => ExportableField::UNFORMATTED,
            'getPostdata' =>    ExportableField::POSTDATA
        );
    }

    /**
     * Give the field some data and ask it to return a value using one of many
     * possible modes.
     *
     * @param mixed $data
     * @param integer $mode
     * @param integer $entry_id
     * @return string|null
     */
    public function prepareExportValue($data, $mode, $entry_id = null)
    {
        $modes = (object)$this->getExportModes();

        // Export handles:
        if ($mode === $modes->getHandle) {
            if (isset($data['handle'])) {
                return $data['handle'];
            } elseif (isset($data['value'])) {
                return Lang::createHandle($data['value']);
            }

            // Export unformatted:
        } elseif ($mode === $modes->getUnformatted || $mode === $modes->getPostdata) {
            return isset($data['value'])
                ? $data['value']
                : null;
        }

        return null;
    }

    /*-------------------------------------------------------------------------
        Filtering:
    -------------------------------------------------------------------------*/

    public function buildDSRetrievalSQL($data, &$joins, &$where, $andOperation = false)
    {
        $field_id = $this->get('id');

        if (self::isFilterRegex($data[0])) {
            $this->buildRegexSQL($data[0], array('value', 'handle'), $joins, $where);
        } elseif ($andOperation) {
            foreach ($data as $value) {
                $this->_key++;
                $value = $this->cleanValue($value);
                $joins .= "
                    LEFT JOIN
                        `tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
                        ON (e.id = t{$field_id}_{$this->_key}.entry_id)
                ";
                $where .= "
                    AND (
                        t{$field_id}_{$this->_key}.value = '{$value}'
                        OR t{$field_id}_{$this->_key}.handle = '{$value}'
                    )
                ";
            }
        } else {
            if (!is_array($data)) {
                $data = array($data);
            }

            foreach ($data as &$value) {
                $value = $this->cleanValue($value);
            }

            $this->_key++;
            $data = implode("', '", $data);
            $joins .= "
                LEFT JOIN
                    `tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
                    ON (e.id = t{$field_id}_{$this->_key}.entry_id)
            ";
            $where .= "
                AND (
                    t{$field_id}_{$this->_key}.value IN ('{$data}')
                    OR t{$field_id}_{$this->_key}.handle IN ('{$data}')
                )
            ";
        }

        return true;
    }

    /*-------------------------------------------------------------------------
        Sorting:
    -------------------------------------------------------------------------*/

    public function buildSortingSQL(&$joins, &$where, &$sort, $order = 'ASC')
    {
        if (in_array(strtolower($order), array('random', 'rand'))) {
            $sort = 'ORDER BY RAND()';
        } else {
            $sort = sprintf(
                'ORDER BY (
                    SELECT %s
                    FROM tbl_entries_data_%d AS `ed`
                    WHERE entry_id = e.id
                ) %s',
                '`ed`.value',
                $this->get('id'),
                $order
            );
        }
    }

    /*-------------------------------------------------------------------------
        Grouping:
    -------------------------------------------------------------------------*/

    public function groupRecords($records)
    {
        if (!is_array($records) || empty($records)) {
            return;
        }

        $groups = array($this->get('element_name') => array());

        foreach ($records as $r) {
            $data = $r->getData($this->get('id'));
            $value = General::sanitize($data['value']);

            if (!isset($groups[$this->get('element_name')][$data['handle']])) {
                $groups[$this->get('element_name')][$data['handle']] = array(
                    'attr' => array('handle' => $data['handle'], 'value' => $value),
                    'records' => array(),
                    'groups' => array()
                );
            }

            $groups[$this->get('element_name')][$data['handle']]['records'][] = $r;
        }

        return $groups;
    }
}


1		<?php
2
3		/**
4		* @package toolkit
5		*/
6
7		/**
8		* A simple Input field that essentially maps to HTML's `<input type='text'/>`.
9		*/
10		class FieldInput extends Field implements ExportableField, ImportableField
11		{
12	View Code Duplication	public function __construct()
13		{
14		parent::__construct();
15		$this->_name = __('Text Input');
		0 ignored issues – show Bug introduced 2015-11-22 04:43 UTC by Report Bug Copy Issue Report The property `_name` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
16		$this->_required = true;
17
18		$this->set('required', 'no');
19		}
20
21		/*-------------------------------------------------------------------------
22		Definition:
23		-------------------------------------------------------------------------*/
24
25		public function canFilter()
26		{
27		return true;
28		}
29
30		public function canPrePopulate()
31		{
32		return true;
33		}
34
35		public function isSortable()
36		{
37		return true;
38		}
39
40		public function allowDatasourceOutputGrouping()
41		{
42		return true;
43		}
44
45		public function allowDatasourceParamOutput()
46		{
47		return true;
48		}
49
50		/*-------------------------------------------------------------------------
51		Setup:
52		-------------------------------------------------------------------------*/
53
54		public function createTable()
55		{
56		return Symphony::Database()->query(
57		"CREATE TABLE IF NOT EXISTS `tbl_entries_data_" . $this->get('id') . "` (
58		`id` int(11) unsigned NOT null auto_increment,
59		`entry_id` int(11) unsigned NOT null,
60		`handle` varchar(255) default null,
61		`value` varchar(255) default null,
62		PRIMARY KEY (`id`),
63		UNIQUE KEY `entry_id` (`entry_id`),
64		KEY `handle` (`handle`),
65		KEY `value` (`value`)
66		) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;"
67		);
68		}
69
70		/*-------------------------------------------------------------------------
71		Utilities:
72		-------------------------------------------------------------------------*/
73
74		private function __applyValidationRules($data)
75		{
76		$rule = $this->get('validator');
77
78		return ($rule ? General::validateString($data, $rule) : true);
79		}
80
81		private function __replaceAmpersands($value)
82		{
83		return preg_replace('/&(?!(#[0-9]+\|#x[0-9a-f]+\|amp\|lt\|gt);)/i', '&', trim($value));
84		}
85
86		/*-------------------------------------------------------------------------
87		Settings:
88		-------------------------------------------------------------------------*/
89
90		public function setFromPOST(array $settings = array())
91		{
92		parent::setFromPOST($settings);
93
94		if ($this->get('validator') == '') {
95		$this->remove('validator');
96		}
97		}
98
99		public function displaySettingsPanel(XMLElement &$wrapper, $errors = null)
100		{
101		parent::displaySettingsPanel($wrapper, $errors);
102
103		// Validation rule
104		$this->buildValidationSelect($wrapper, $this->get('validator'), 'fields['.$this->get('sortorder').'][validator]', 'input', $errors);
105
106		// Requirements and table display
107		$this->appendStatusFooter($wrapper);
108		}
109
110	View Code Duplication	public function commit()
111		{
112		if (!parent::commit()) {
113		return false;
114		}
115
116		$id = $this->get('id');
117
118		if ($id === false) {
119		return false;
120		}
121
122		$fields = array('validator'=>null);
123
124		$fields['validator'] = ($fields['validator'] == 'custom' ? null : $this->get('validator'));
125
126		return FieldManager::saveSettings($id, $fields);
127		}
128
129		/*-------------------------------------------------------------------------
130		Publish:
131		-------------------------------------------------------------------------*/
132
133		public function displayPublishPanel(XMLElement &$wrapper, $data = null, $flagWithError = null, $fieldnamePrefix = null, $fieldnamePostfix = null, $entry_id = null)
134		{
135		$value = General::sanitize(isset($data['value']) ? $data['value'] : null);
136		$label = Widget::Label($this->get('label'));
137
138		if ($this->get('required') !== 'yes') {
139		$label->appendChild(new XMLElement('i', __('Optional')));
140		}
141
142		$label->appendChild(Widget::Input('fields'.$fieldnamePrefix.'['.$this->get('element_name').']'.$fieldnamePostfix, (strlen($value) != 0 ? $value : null)));
143
144		if ($flagWithError != null) {
145		$wrapper->appendChild(Widget::Error($label, $flagWithError));
146		} else {
147		$wrapper->appendChild($label);
148		}
149		}
150
151		public function checkPostFieldData($data, &$message, $entry_id = null)
152		{
153		$message = null;
154
155		if (is_array($data) && isset($data['value'])) {
156		$data = $data['value'];
157		}
158
159	View Code Duplication	if ($this->get('required') === 'yes' && strlen(trim($data)) == 0) {
160		$message = __('‘%s’ is a required field.', array($this->get('label')));
161		return self::__MISSING_FIELDS__;
162		}
163
164	View Code Duplication	if (!$this->__applyValidationRules($data)) {
165		$message = __('‘%s’ contains invalid data. Please check the contents.', array($this->get('label')));
166		return self::__INVALID_FIELDS__;
167		}
168
169		return self::__OK__;
170		}
171
172		public function processRawFieldData($data, &$status, &$message = null, $simulate = false, $entry_id = null)
173		{
174		$status = self::__OK__;
175
176		if (strlen(trim($data)) == 0) {
177		return array();
178		}
179
180		$result = array(
181		'value' => $data
182		);
183
184		$result['handle'] = Lang::createHandle($result['value']);
185
186		return $result;
187		}
188
189		/*-------------------------------------------------------------------------
190		Output:
191		-------------------------------------------------------------------------*/
192
193		public function appendFormattedElement(XMLElement &$wrapper, $data, $encode = false, $mode = null, $entry_id = null)
194		{
195		$value = $data['value'];
196
197		if ($encode === true) {
198		$value = General::sanitize($value);
199		} else {
200		if (!General::validateXML($data['value'], $errors, false, new XsltProcess)) {
201		$value = html_entity_decode($data['value'], ENT_QUOTES, 'UTF-8');
202		$value = $this->__replaceAmpersands($value);
203
204		if (!General::validateXML($value, $errors, false, new XsltProcess)) {
205		$value = General::sanitize($data['value']);
206		}
207		}
208		}
209
210		$wrapper->appendChild(
211		new XMLElement($this->get('element_name'), $value, array('handle' => $data['handle']))
212		);
213		}
214
215		/*-------------------------------------------------------------------------
216		Import:
217		-------------------------------------------------------------------------*/
218
219		public function getImportModes()
220		{
221		return array(
222		'getValue' => ImportableField::STRING_VALUE,
223		'getPostdata' => ImportableField::ARRAY_VALUE
224		);
225		}
226
227	View Code Duplication	public function prepareImportValue($data, $mode, $entry_id = null)
228		{
229		$message = $status = null;
230		$modes = (object)$this->getImportModes();
231
232		if ($mode === $modes->getValue) {
233		return $data;
234		} elseif ($mode === $modes->getPostdata) {
235		return $this->processRawFieldData($data, $status, $message, true, $entry_id);
236		}
237
238		return null;
239		}
240
241		/*-------------------------------------------------------------------------
242		Export:
243		-------------------------------------------------------------------------*/
244
245		/**
246		* Return a list of supported export modes for use with `prepareExportValue`.
247		*
248		* @return array
249		*/
250		public function getExportModes()
251		{
252		return array(
253		'getHandle' => ExportableField::HANDLE,
254		'getUnformatted' => ExportableField::UNFORMATTED,
255		'getPostdata' => ExportableField::POSTDATA
256		);
257		}
258
259		/**
260		* Give the field some data and ask it to return a value using one of many
261		* possible modes.
262		*
263		* @param mixed $data
264		* @param integer $mode
265		* @param integer $entry_id
266		* @return string\|null
267		*/
268		public function prepareExportValue($data, $mode, $entry_id = null)
269		{
270		$modes = (object)$this->getExportModes();
271
272		// Export handles:
273		if ($mode === $modes->getHandle) {
274	View Code Duplication	if (isset($data['handle'])) {
275		return $data['handle'];
276		} elseif (isset($data['value'])) {
277		return Lang::createHandle($data['value']);
278		}
279
280		// Export unformatted:
281	View Code Duplication	} elseif ($mode === $modes->getUnformatted \|\| $mode === $modes->getPostdata) {
282		return isset($data['value'])
283		? $data['value']
284		: null;
285		}
286
287		return null;
288		}
289
290		/*-------------------------------------------------------------------------
291		Filtering:
292		-------------------------------------------------------------------------*/
293
294	View Code Duplication	public function buildDSRetrievalSQL($data, &$joins, &$where, $andOperation = false)
295		{
296		$field_id = $this->get('id');
297
298		if (self::isFilterRegex($data[0])) {
299		$this->buildRegexSQL($data[0], array('value', 'handle'), $joins, $where);
300		} elseif ($andOperation) {
301		foreach ($data as $value) {
302		$this->_key++;
303		$value = $this->cleanValue($value);
304		$joins .= "
305		LEFT JOIN
306		`tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
307		ON (e.id = t{$field_id}_{$this->_key}.entry_id)
308		";
309		$where .= "
310		AND (
311		t{$field_id}_{$this->_key}.value = '{$value}'
312		OR t{$field_id}_{$this->_key}.handle = '{$value}'
313		)
314		";
315		}
316		} else {
317		if (!is_array($data)) {
318		$data = array($data);
319		}
320
321		foreach ($data as &$value) {
322		$value = $this->cleanValue($value);
323		}
324
325		$this->_key++;
326		$data = implode("', '", $data);
327		$joins .= "
328		LEFT JOIN
329		`tbl_entries_data_{$field_id}` AS t{$field_id}_{$this->_key}
330		ON (e.id = t{$field_id}_{$this->_key}.entry_id)
331		";
332		$where .= "
333		AND (
334		t{$field_id}_{$this->_key}.value IN ('{$data}')
335		OR t{$field_id}_{$this->_key}.handle IN ('{$data}')
336		)
337		";
338		}
339
340		return true;
341		}
342
343		/*-------------------------------------------------------------------------
344		Sorting:
345		-------------------------------------------------------------------------*/
346
347		public function buildSortingSQL(&$joins, &$where, &$sort, $order = 'ASC')
348		{
349		if (in_array(strtolower($order), array('random', 'rand'))) {
350		$sort = 'ORDER BY RAND()';
351		} else {
352		$sort = sprintf(
353		'ORDER BY (
354		SELECT %s
355		FROM tbl_entries_data_%d AS `ed`
356		WHERE entry_id = e.id
357		) %s',
358		'`ed`.value',
359		$this->get('id'),
360		$order
361		);
362		}
363		}
364
365		/*-------------------------------------------------------------------------
366		Grouping:
367		-------------------------------------------------------------------------*/
368
369	View Code Duplication	public function groupRecords($records)
370		{
371		if (!is_array($records) \|\| empty($records)) {
372		return;
373		}
374
375		$groups = array($this->get('element_name') => array());
376
377		foreach ($records as $r) {
378		$data = $r->getData($this->get('id'));
379		$value = General::sanitize($data['value']);
380
381		if (!isset($groups[$this->get('element_name')][$data['handle']])) {
382		$groups[$this->get('element_name')][$data['handle']] = array(
383		'attr' => array('handle' => $data['handle'], 'value' => $value),
384		'records' => array(),
385		'groups' => array()
386		);
387		}
388
389		$groups[$this->get('element_name')][$data['handle']]['records'][] = $r;
390		}
391
392		return $groups;
393		}
394		}
395

symphonycms / symphony-2

GitHub Access Token became invalid