AFile::createAccount() - Code Metrics - Inspection of "kw_auth - test for some edge cases, non-existent f..." - alex-kalanis/kw_auth - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( d309df...7ec489 )

by Petr

created 2022-08-28 23:34 UTC

AFile::createAccount() B

↳ Parent: AFile

Complexity

Conditions	9
Paths	65

Size

Total Lines	45
Code Lines	30

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	24
CRAP Score	9

Importance

Changes

Metric	Value
cc	9
eloc	30
c	0
b	0
f	0
nc	65
nop	2
dl	0
loc	45
ccs	24
cts	24
cp	1
crap	9
rs	8.0555

<?php

namespace kalanis\kw_auth\Sources\Files;


use kalanis\kw_auth\AuthException;
use kalanis\kw_auth\Data\FileUser;
use kalanis\kw_auth\Interfaces;
use kalanis\kw_auth\Sources\TAuthLock;
use kalanis\kw_locks\Interfaces\ILock;
use kalanis\kw_locks\LockException;


/**
 * Class AFile
 * @package kalanis\kw_auth\Sources\Files
 * Authenticate via single file
 */
abstract class AFile implements Interfaces\IAuth, Interfaces\IAccessAccounts
{
    use TAuthLock;
    use TLines;
    use TStore;

    const PW_ID = 0;
    const PW_NAME = 1;
    const PW_PASS = 2;
    const PW_GROUP = 3;
    const PW_CLASS = 4;
    const PW_DISPLAY = 5;
    const PW_DIR = 6;
    const PW_FEED = 7;

    /** @var Interfaces\IMode */
    protected $mode = null;
    /** @var string */
    protected $path = '';

    /**
     * @param Interfaces\IMode $mode hashing mode
     * @param ILock $lock file lock
     * @param string $path use full path with file name
     * @param Interfaces\IKATranslations|null $lang
     */
    public function __construct(Interfaces\IMode $mode, ILock $lock, string $path, ?Interfaces\IKATranslations $lang = null)
    {
        $this->setLang($lang);
        $this->mode = $mode;
        $this->path = $path;
        $this->initAuthLock($lock);
    }

    public function authenticate(string $userName, array $params = []): ?Interfaces\IUser
    {
        if (empty($params['password'])) {
            throw new AuthException($this->getLang()->kauPassMustBeSet());
        }
        $name = $this->stripChars($userName);
        $pass = strval($params['password']);

        $this->checkLock();
        try {
            $passLines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            // silence the problems on storage
            return null;
        }
        foreach ($passLines as &$line) {
            if ($line[static::PW_NAME] == $name) {
                if ($this->mode->check($pass, strval($line[static::PW_PASS]))) {
                    return $this->getUserClass($line);
                }
            }
        }
        return null;
    }

    public function getDataOnly(string $userName): ?Interfaces\IUser
    {
        $name = $this->stripChars($userName);

        // load from password
        $this->checkLock();
        try {
            $passwordLines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            // silence the problems on storage
            return null;
        }
        foreach ($passwordLines as &$line) {
            if ($line[static::PW_NAME] == $name) {
                return $this->getUserClass($line);
            }
        }
        return null;
    }

    /**
     * @param array<int, string|int|float> $line
     * @return Interfaces\IUser
     */
    protected function getUserClass(array &$line): Interfaces\IUser
    {
        $user = new FileUser();
        $user->setData(
            intval($line[static::PW_ID]),
            strval($line[static::PW_NAME]),
            intval($line[static::PW_GROUP]),
            intval($line[static::PW_CLASS]),
            strval($line[static::PW_DISPLAY]),
            strval($line[static::PW_DIR])
        );
        return $user;
    }

    public function createAccount(Interfaces\IUser $user, string $password): void
    {
        $userName = $this->stripChars($user->getAuthName());
        $directory = $this->stripChars($user->getDir());
        $displayName = $this->stripChars($user->getDisplayName());

        // not everything necessary is set
        if (empty($userName) || empty($directory) || empty($password)) {
            throw new AuthException($this->getLang()->kauPassMissParam());
        }
        $this->checkLock();

        $uid = Interfaces\IUser::LOWEST_USER_ID;
        $this->getLock()->create();

        // read password
        try {
            $passLines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            // silence the problems on storage
            $passLines = [];
        }
        foreach ($passLines as &$line) {
            $uid = max($uid, intval($line[static::PW_ID]));
        }
        $uid++;

        $newUserPass = [
            static::PW_ID => $uid,
            static::PW_NAME => $userName,
            static::PW_PASS => $this->mode->hash($password),
            static::PW_GROUP => empty($user->getGroup()) ? $uid : $user->getClass() ,
            static::PW_CLASS => empty($user->getClass()) ? Interfaces\IAccessClasses::CLASS_USER : $user->getClass() ,
            static::PW_DISPLAY => empty($displayName) ? $userName : $displayName,
            static::PW_DIR => $directory,
            static::PW_FEED => '',
        ];
        ksort($newUserPass);
        $passLines[] = $newUserPass;

        // now save it
        try {
            $this->saveFile($this->path, $passLines);
        } finally {
            $this->getLock()->delete();
        }
    }

    /**
     * @throws AuthException
     * @throws LockException
     * @return Interfaces\IUser[]
     */
    public function readAccounts(): array
    {
        $this->checkLock();

        $passLines = $this->openFile($this->path);
        $result = [];
        foreach ($passLines as &$line) {
            $result[] = $this->getUserClass($line);
        }

        return $result;
    }

    public function updateAccount(Interfaces\IUser $user): void
    {
        $userName = $this->stripChars($user->getAuthName());
        $directory = $this->stripChars($user->getDir());
        $displayName = $this->stripChars($user->getDisplayName());

        $this->checkLock();

        $this->getLock()->create();
        try {
            $passwordLines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            $this->getLock()->delete();
            throw $ex;
        }
        foreach ($passwordLines as &$line) {
            if ($line[static::PW_NAME] == $userName) {
                // REFILL
                $line[static::PW_GROUP] = !empty($user->getGroup()) ? $user->getGroup() : $line[static::PW_GROUP] ;
                $line[static::PW_CLASS] = !empty($user->getClass()) ? $user->getClass() : $line[static::PW_CLASS] ;
                $line[static::PW_DISPLAY] = !empty($displayName) ? $displayName : $line[static::PW_DISPLAY] ;
                $line[static::PW_DIR] = !empty($directory) ? $directory : $line[static::PW_DIR] ;
            }
        }

        try {
            $this->saveFile($this->path, $passwordLines);
        } finally {
            $this->getLock()->delete();
        }
    }

    public function updatePassword(string $userName, string $passWord): void
    {
        $name = $this->stripChars($userName);
        // load from shadow
        $this->checkLock();

        $changed = false;
        $this->getLock()->create();

        try {
            $lines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            $this->getLock()->delete();
            throw $ex;
        }
        foreach ($lines as &$line) {
            if ($line[static::PW_NAME] == $name) {
                $changed = true;
                $line[static::PW_PASS] = $this->mode->hash($passWord);
            }
        }
        try {
            if ($changed) {
                $this->saveFile($this->path, $lines);
            }
        } finally {
            $this->getLock()->delete();
        }
    }

    public function deleteAccount(string $userName): void
    {
        $name = $this->stripChars($userName);
        $this->checkLock();

        $changed = false;
        $this->getLock()->create();

        // update password
        try {
            $passLines = $this->openFile($this->path);
        } catch (AuthException $ex) {
            // removal on non-existent file is not possible and not necessary
            $this->getLock()->delete();
            return;
        }

        foreach ($passLines as $index => &$line) {
            if ($line[static::PW_NAME] == $name) {
                unset($passLines[$index]);
                $changed = true;
            }
        }

        // now save it all
        try {
            if ($changed) {
                $this->saveFile($this->path, $passLines);
            }
        } finally {
            $this->getLock()->delete();
        }
    }
}


1		<?php
2
3		namespace kalanis\kw_auth\Sources\Files;
4
5
6		use kalanis\kw_auth\AuthException;
7		use kalanis\kw_auth\Data\FileUser;
8		use kalanis\kw_auth\Interfaces;
9		use kalanis\kw_auth\Sources\TAuthLock;
10		use kalanis\kw_locks\Interfaces\ILock;
11		use kalanis\kw_locks\LockException;
12
13
14		/**
15		* Class AFile
16		* @package kalanis\kw_auth\Sources\Files
17		* Authenticate via single file
18		*/
19		abstract class AFile implements Interfaces\IAuth, Interfaces\IAccessAccounts
20		{
21		use TAuthLock;
22		use TLines;
23		use TStore;
24
25		const PW_ID = 0;
26		const PW_NAME = 1;
27		const PW_PASS = 2;
28		const PW_GROUP = 3;
29		const PW_CLASS = 4;
30		const PW_DISPLAY = 5;
31		const PW_DIR = 6;
32		const PW_FEED = 7;
33
34		/** @var Interfaces\IMode */
35		protected $mode = null;
36		/** @var string */
37		protected $path = '';
38
39		/**
40		* @param Interfaces\IMode $mode hashing mode
41		* @param ILock $lock file lock
42		* @param string $path use full path with file name
43		* @param Interfaces\IKATranslations\|null $lang
44		*/
45	17	public function __construct(Interfaces\IMode $mode, ILock $lock, string $path, ?Interfaces\IKATranslations $lang = null)
46		{
47	17	$this->setLang($lang);
48	17	$this->mode = $mode;
49	17	$this->path = $path;
50	17	$this->initAuthLock($lock);
51		}
52
53	7	public function authenticate(string $userName, array $params = []): ?Interfaces\IUser
54		{
55	7	if (empty($params['password'])) {
56	2	throw new AuthException($this->getLang()->kauPassMustBeSet());
57		}
58	5	$name = $this->stripChars($userName);
59	5	$pass = strval($params['password']);
60
61	5	$this->checkLock();
62		try {
63	5	$passLines = $this->openFile($this->path);
64	1	} catch (AuthException $ex) {
65		// silence the problems on storage
66	1	return null;
67		}
68	4	foreach ($passLines as &$line) {
69	4	if ($line[static::PW_NAME] == $name) {
70	4	if ($this->mode->check($pass, strval($line[static::PW_PASS]))) {
71	4	return $this->getUserClass($line);
72		}
73		}
74		}
75	4	return null;
76		}
77
78	7	public function getDataOnly(string $userName): ?Interfaces\IUser
79		{
80	7	$name = $this->stripChars($userName);
81
82		// load from password
83	7	$this->checkLock();
84		try {
85	7	$passwordLines = $this->openFile($this->path);
86	2	} catch (AuthException $ex) {
87		// silence the problems on storage
88	2	return null;
89		}
90	5	foreach ($passwordLines as &$line) {
91	5	if ($line[static::PW_NAME] == $name) {
92	5	return $this->getUserClass($line);
93		}
94		}
95	4	return null;
96		}
97
98		/**
99		* @param array<int, string\|int\|float> $line
100		* @return Interfaces\IUser
101		*/
102	9	protected function getUserClass(array &$line): Interfaces\IUser
103		{
104	9	$user = new FileUser();
105	9	$user->setData(
106	9	intval($line[static::PW_ID]),
107	9	strval($line[static::PW_NAME]),
108	9	intval($line[static::PW_GROUP]),
109	9	intval($line[static::PW_CLASS]),
110	9	strval($line[static::PW_DISPLAY]),
111	9	strval($line[static::PW_DIR])
112		);
113	9	return $user;
114		}
115
116	5	public function createAccount(Interfaces\IUser $user, string $password): void
117		{
118	5	$userName = $this->stripChars($user->getAuthName());
119	5	$directory = $this->stripChars($user->getDir());
120	5	$displayName = $this->stripChars($user->getDisplayName());
121
122		// not everything necessary is set
123	5	if (empty($userName) \|\| empty($directory) \|\| empty($password)) {
124	2	throw new AuthException($this->getLang()->kauPassMissParam());
125		}
126	3	$this->checkLock();
127
128	3	$uid = Interfaces\IUser::LOWEST_USER_ID;
129	3	$this->getLock()->create();
130
131		// read password
132		try {
133	3	$passLines = $this->openFile($this->path);
134	1	} catch (AuthException $ex) {
135		// silence the problems on storage
136	1	$passLines = [];
137		}
138	3	foreach ($passLines as &$line) {
139	2	$uid = max($uid, intval($line[static::PW_ID]));
140		}
141	3	$uid++;
142
143		$newUserPass = [
144		static::PW_ID => $uid,
145		static::PW_NAME => $userName,
146	3	static::PW_PASS => $this->mode->hash($password),
147	3	static::PW_GROUP => empty($user->getGroup()) ? $uid : $user->getClass() ,
148	3	static::PW_CLASS => empty($user->getClass()) ? Interfaces\IAccessClasses::CLASS_USER : $user->getClass() ,
149	3	static::PW_DISPLAY => empty($displayName) ? $userName : $displayName,
150		static::PW_DIR => $directory,
151		static::PW_FEED => '',
152		];
153	3	ksort($newUserPass);
154	3	$passLines[] = $newUserPass;
155
156		// now save it
157		try {
158	3	$this->saveFile($this->path, $passLines);
159	3	} finally {
160	3	$this->getLock()->delete();
161		}
162		}
163
164		/**
165		* @throws AuthException
166		* @throws LockException
167		* @return Interfaces\IUser[]
168		*/
169	2	public function readAccounts(): array
170		{
171	2	$this->checkLock();
172
173	2	$passLines = $this->openFile($this->path);
174	2	$result = [];
175	2	foreach ($passLines as &$line) {
176	2	$result[] = $this->getUserClass($line);
177		}
178
179	2	return $result;
180		}
181
182	3	public function updateAccount(Interfaces\IUser $user): void
183		{
184	3	$userName = $this->stripChars($user->getAuthName());
185	3	$directory = $this->stripChars($user->getDir());
186	3	$displayName = $this->stripChars($user->getDisplayName());
187
188	3	$this->checkLock();
189
190	3	$this->getLock()->create();
191		try {
192	3	$passwordLines = $this->openFile($this->path);
193	1	} catch (AuthException $ex) {
194	1	$this->getLock()->delete();
195	1	throw $ex;
196		}
197	2	foreach ($passwordLines as &$line) {
198	2	if ($line[static::PW_NAME] == $userName) {
199		// REFILL
200	2	$line[static::PW_GROUP] = !empty($user->getGroup()) ? $user->getGroup() : $line[static::PW_GROUP] ;
201	2	$line[static::PW_CLASS] = !empty($user->getClass()) ? $user->getClass() : $line[static::PW_CLASS] ;
202	2	$line[static::PW_DISPLAY] = !empty($displayName) ? $displayName : $line[static::PW_DISPLAY] ;
203	2	$line[static::PW_DIR] = !empty($directory) ? $directory : $line[static::PW_DIR] ;
204		}
205		}
206
207		try {
208	2	$this->saveFile($this->path, $passwordLines);
209	2	} finally {
210	2	$this->getLock()->delete();
211		}
212		}
213
214	3	public function updatePassword(string $userName, string $passWord): void
215		{
216	3	$name = $this->stripChars($userName);
217		// load from shadow
218	3	$this->checkLock();
219
220	3	$changed = false;
221	3	$this->getLock()->create();
222
223		try {
224	3	$lines = $this->openFile($this->path);
225	1	} catch (AuthException $ex) {
226	1	$this->getLock()->delete();
227	1	throw $ex;
228		}
229	2	foreach ($lines as &$line) {
230	2	if ($line[static::PW_NAME] == $name) {
231	2	$changed = true;
232	2	$line[static::PW_PASS] = $this->mode->hash($passWord);
233		}
234		}
235		try {
236	2	if ($changed) {
237	2	$this->saveFile($this->path, $lines);
238		}
239	2	} finally {
240	2	$this->getLock()->delete();
241		}
242		}
243
244	3	public function deleteAccount(string $userName): void
245		{
246	3	$name = $this->stripChars($userName);
247	3	$this->checkLock();
248
249	3	$changed = false;
250	3	$this->getLock()->create();
251
252		// update password
253		try {
254	3	$passLines = $this->openFile($this->path);
255	1	} catch (AuthException $ex) {
256		// removal on non-existent file is not possible and not necessary
257	1	$this->getLock()->delete();
258	1	return;
259		}
260
261	2	foreach ($passLines as $index => &$line) {
262	2	if ($line[static::PW_NAME] == $name) {
263	2	unset($passLines[$index]);
264	2	$changed = true;
265		}
266		}
267
268		// now save it all
269		try {
270	2	if ($changed) {
271	2	$this->saveFile($this->path, $passLines);
272		}
273	2	} finally {
274	2	$this->getLock()->delete();
275		}
276		}
277		}
278

alex-kalanis / kw_auth

Push — master ( d309df...7ec489 )

AFile::createAccount() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like