Mirrors/sysPass
2
0
Fork 0
mirror of https://github.com/nuxsmin/sysPass.git synced 2026-03-12 03:16:54 +01:00
Code Issues Packages Projects Releases Wiki Activity

test(refactor): Extract duplicated code

Browse Source 
Signed-off-by: Rubén D <nuxsmin@syspass.org>
This commit is contained in:
Rubén D
2024-09-01 17:39:02 +02:00
parent 419915a866
commit 4d1708ed90
20 changed files with 441 additions and 606 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
app/modules/web/Controllers/ConfigEncryption/RefreshController.php
View File

@@ -24,89 +24,74 @@
namespace SP\Modules\Web\Controllers\ConfigEncryption;
use Exception;
use JsonException;
use SP\Core\Application;
use SP\Core\Crypt\Hash;
use SP\Core\Crypt\Session as CryptSession;
use SP\Core\Events\Event;
use SP\Core\Events\EventMessage;
use SP\Domain\Common\Attributes\Action;
use SP\Domain\Common\Dtos\ActionResponse;
use SP\Domain\Common\Enums\ResponseType;
use SP\Domain\Core\Acl\AclActionsInterface;
use SP\Domain\Core\Acl\UnauthorizedPageException;
use SP\Domain\Core\Exceptions\ConstraintException;
use SP\Domain\Core\Exceptions\CryptException;
use SP\Domain\Core\Exceptions\QueryException;
use SP\Domain\Core\Exceptions\SessionTimeout;
use SP\Domain\Core\Exceptions\SPException;
use SP\Domain\Crypt\Ports\MasterPassService;
use SP\Domain\Http\Dtos\JsonMessage;
use SP\Modules\Web\Controllers\SimpleControllerBase;
use SP\Modules\Web\Controllers\Traits\JsonTrait;
use SP\Mvc\Controller\SimpleControllerHelper;
use function SP\__u;
/**
* Class RefreshController
*/
final class RefreshController extends SimpleControllerBase
{
use JsonTrait;
private MasterPassService $masterPassService;
public function __construct(
Application $application,
SimpleControllerHelper $simpleControllerHelper,
MasterPassService $masterPassService
Application $application,
SimpleControllerHelper $simpleControllerHelper,
private readonly MasterPassService $masterPassService
) {
parent::__construct($application, $simpleControllerHelper);
$this->masterPassService = $masterPassService;
}
/**
* Refresh master password hash
*
* @return bool
* @throws JsonException
* @return ActionResponse
* @throws ConstraintException
* @throws CryptException
* @throws QueryException
*/
public function refreshAction(): bool
#[Action(ResponseType::JSON)]
public function refreshAction(): ActionResponse
{
try {
if ($this->config->getConfigData()->isDemoEnabled()) {
return $this->returnJsonResponse(JsonMessage::JSON_WARNING, __u('Ey, this is a DEMO!!'));
}
$this->masterPassService->updateConfig(Hash::hashKey(CryptSession::getSessionKey($this->session)));
$this->eventDispatcher->notify(
'refresh.masterPassword.hash',
new Event($this, EventMessage::build()->addDescription(__u('Master password hash updated')))
);
return $this->returnJsonResponse(JsonMessage::JSON_SUCCESS, __u('Master password hash updated'));
} catch (Exception $e) {
processException($e);
$this->eventDispatcher->notify('exception', new Event($e));
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('Error while updating the master password hash')
);
if ($this->config->getConfigData()->isDemoEnabled()) {
return ActionResponse::warning(__u('Ey, this is a DEMO!!'));
}
$this->masterPassService->updateConfig(Hash::hashKey(CryptSession::getSessionKey($this->session)));
$this->eventDispatcher->notify(
'refresh.masterPassword.hash',
new Event($this, EventMessage::build()->addDescription(__u('Master password hash updated')))
);
return ActionResponse::ok(__u('Master password hash updated'));
}
/**
* @return void
* @throws JsonException
* @throws SessionTimeout
* @throws UnauthorizedPageException
* @throws SPException
*/
protected function initialize(): void
{
try {
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
} catch (UnauthorizedPageException $e) {
$this->eventDispatcher->notify('exception', new Event($e));
$this->returnJsonResponseException($e);
}
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
}
}

151
app/modules/web/Controllers/ConfigEncryption/SaveController.php
View File

@@ -24,30 +24,31 @@
namespace SP\Modules\Web\Controllers\ConfigEncryption;
use Exception;
use JsonException;
use SP\Core\Application;
use SP\Core\Crypt\Hash;
use SP\Core\Events\Event;
use SP\Domain\Common\Attributes\Action;
use SP\Domain\Common\Dtos\ActionResponse;
use SP\Domain\Common\Enums\ResponseType;
use SP\Domain\Common\Services\ServiceException;
use SP\Domain\Config\Ports\ConfigService;
use SP\Domain\Core\Acl\AclActionsInterface;
use SP\Domain\Core\Acl\UnauthorizedPageException;
use SP\Domain\Core\Exceptions\ConstraintException;
use SP\Domain\Core\Exceptions\QueryException;
use SP\Domain\Core\Exceptions\SessionTimeout;
use SP\Domain\Core\Exceptions\SPException;
use SP\Domain\Crypt\Dtos\UpdateMasterPassRequest;
use SP\Domain\Crypt\Ports\MasterPassService;
use SP\Domain\Crypt\Services\MasterPass;
use SP\Domain\Http\Dtos\JsonMessage;
use SP\Domain\Task\Ports\TaskInterface;
use SP\Domain\Task\Services\Task;
use SP\Domain\Task\Services\TaskFactory;
use SP\Infrastructure\Common\Repositories\NoSuchItemException;
use SP\Infrastructure\File\FileException;
use SP\Modules\Web\Controllers\SimpleControllerBase;
use SP\Modules\Web\Controllers\Traits\JsonTrait;
use SP\Mvc\Controller\SimpleControllerHelper;
use function SP\__u;
/**
* Class SaveController
*/
@@ -55,28 +56,25 @@ final class SaveController extends SimpleControllerBase
{
use JsonTrait;
private MasterPassService $masterPassService;
private ConfigService $configService;
public function __construct(
Application $application,
SimpleControllerHelper $simpleControllerHelper,
MasterPassService $masterPassService,
ConfigService $configService
Application $application,
SimpleControllerHelper $simpleControllerHelper,
private readonly MasterPassService $masterPassService,
private readonly ConfigService $configService
) {
parent::__construct($application, $simpleControllerHelper);
$this->masterPassService = $masterPassService;
$this->configService = $configService;
}
/**
* @return bool
* @throws JsonException
* @return ActionResponse
* @throws NoSuchItemException
* @throws ServiceException
* @throws ConstraintException
* @throws QueryException
* @throws Exception
*/
public function saveAction(): bool
#[Action(ResponseType::JSON)]
public function saveAction(): ActionResponse
{
$currentMasterPass = $this->request->analyzeEncrypted('current_masterpass');
$newMasterPass = $this->request->analyzeEncrypted('new_masterpass');
@@ -85,134 +83,71 @@ final class SaveController extends SimpleControllerBase
$noAccountPassChange = $this->request->analyzeBool('no_account_change', false);
if (!$this->masterPassService->checkUserUpdateMPass($this->session->getUserData()->getLastUpdateMPass())) {
return $this->returnJsonResponse(
JsonMessage::JSON_SUCCESS_STICKY,
__u('Master password updated'),
[__u('Please, restart the session for update it')]
);
if (!$this->masterPassService->checkUserUpdateMPass($this->session->getUserData()->lastUpdateMPass)) {
return ActionResponse::ok(__u('Master password updated'), __u('Please, restart the session for update it'));
}
if (empty($newMasterPass) || empty($currentMasterPass)) {
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('Master password not entered')
);
return ActionResponse::error(__u('Master password not entered'));
}
if ($confirmPassChange === false) {
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('The password update must be confirmed')
);
return ActionResponse::ok(__u('The password update must be confirmed'));
}
if ($newMasterPass === $currentMasterPass) {
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('Passwords are the same')
);
return ActionResponse::ok(__u('Passwords are the same'));
}
if ($newMasterPass !== $newMasterPassR) {
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('Master passwords do not match')
);
return ActionResponse::ok(__u('Master passwords do not match'));
}
if (!$this->masterPassService->checkMasterPassword($currentMasterPass)) {
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('The current master password does not match')
);
return ActionResponse::ok(__u('The current master password does not match'));
}
if (!$this->config->getConfigData()->isMaintenance()) {
return $this->returnJsonResponse(
JsonMessage::JSON_WARNING,
return ActionResponse::warning(
__u('Maintenance mode not enabled'),
[__u('Please, enable it to avoid unwanted behavior from other sessions')]
__u('Please, enable it to avoid unwanted behavior from other sessions')
);
}
if ($this->config->getConfigData()->isDemoEnabled()) {
return $this->returnJsonResponse(
JsonMessage::JSON_WARNING,
__u('Ey, this is a DEMO!!')
);
return ActionResponse::warning(__u('Ey, this is a DEMO!!'));
}
if (!$noAccountPassChange) {
try {
$request = new UpdateMasterPassRequest(
$currentMasterPass,
$newMasterPass,
$this->configService->getByParam(MasterPass::PARAM_MASTER_PASS_HASH),
);
$request = new UpdateMasterPassRequest(
$currentMasterPass,
$newMasterPass,
$this->configService->getByParam(MasterPass::PARAM_MASTER_PASS_HASH),
);
$this->eventDispatcher->notify('update.masterPassword.start', new Event($this));
$this->eventDispatcher->notify('update.masterPassword.start', new Event($this));
$this->masterPassService->changeMasterPassword($request);
$this->masterPassService->changeMasterPassword($request);
$this->eventDispatcher->notify('update.masterPassword.end', new Event($this));
} catch (Exception $e) {
processException($e);
$this->eventDispatcher->notify('exception', new Event($e));
return $this->returnJsonResponseException($e);
}
$this->eventDispatcher->notify('update.masterPassword.end', new Event($this));
} else {
try {
$this->eventDispatcher->notify('update.masterPassword.hash', new Event($this));
$this->eventDispatcher->notify('update.masterPassword.hash', new Event($this));
$this->masterPassService->updateConfig(Hash::hashKey($newMasterPass));
} catch (Exception $e) {
processException($e);
$this->eventDispatcher->notify('exception', new Event($e));
return $this->returnJsonResponse(
JsonMessage::JSON_ERROR,
__u('Error while saving the Master Password\'s hash')
);
}
$this->masterPassService->updateConfig(Hash::hashKey($newMasterPass));
}
return $this->returnJsonResponse(
JsonMessage::JSON_SUCCESS_STICKY,
__u('Master password updated'),
[__u('Please, restart the session to update it')]
);
return ActionResponse::ok(__u('Master password updated'), __u('Please, restart the session to update it'));
}
/**
* @return void
* @throws JsonException
* @throws SessionTimeout
* @throws UnauthorizedPageException
* @throws SPException
*/
protected function initialize(): void
{
try {
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
} catch (UnauthorizedPageException $e) {
$this->eventDispatcher->notify('exception', new Event($e));
$this->returnJsonResponseException($e);
}
}
/**
* @throws FileException
*/
private function getTask(): ?TaskInterface
{
$taskId = $this->request->analyzeString('taskId');
return $taskId !== null
? TaskFactory::register(new Task(__FUNCTION__, $taskId))
: null;
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
}
}

107
app/modules/web/Controllers/ConfigEncryption/SaveTempController.php
View File

@@ -24,108 +24,81 @@
namespace SP\Modules\Web\Controllers\ConfigEncryption;
use Exception;
use JsonException;
use PHPMailer\PHPMailer\Exception;
use SP\Core\Application;
use SP\Core\Events\Event;
use SP\Domain\Common\Attributes\Action;
use SP\Domain\Common\Dtos\ActionResponse;
use SP\Domain\Common\Enums\ResponseType;
use SP\Domain\Common\Services\ServiceException;
use SP\Domain\Core\Acl\AclActionsInterface;
use SP\Domain\Core\Acl\UnauthorizedPageException;
use SP\Domain\Core\Exceptions\ConstraintException;
use SP\Domain\Core\Exceptions\QueryException;
use SP\Domain\Core\Exceptions\SessionTimeout;
use SP\Domain\Core\Exceptions\SPException;
use SP\Domain\Crypt\Ports\TemporaryMasterPassService;
use SP\Domain\Http\Dtos\JsonMessage;
use SP\Modules\Web\Controllers\SimpleControllerBase;
use SP\Modules\Web\Controllers\Traits\JsonTrait;
use SP\Mvc\Controller\SimpleControllerHelper;
use function SP\__u;
/**
* Class ConfigEncryptionController
*
* @package SP\Modules\Web\Controllers
* Class SaveTempController
*/
final class SaveTempController extends SimpleControllerBase
{
use JsonTrait;
private TemporaryMasterPassService $temporaryMasterPassService;
public function __construct(
Application $application,
SimpleControllerHelper $simpleControllerHelper,
TemporaryMasterPassService $temporaryMasterPassService
Application $application,
SimpleControllerHelper $simpleControllerHelper,
private readonly TemporaryMasterPassService $temporaryMasterPassService
) {
parent::__construct($application, $simpleControllerHelper);
$this->temporaryMasterPassService = $temporaryMasterPassService;
}
/**
* Create a temporary master pass
*
* @return bool
* @throws JsonException
* @return ActionResponse
* @throws Exception
* @throws ServiceException
* @throws ConstraintException
* @throws QueryException
*/
public function saveTempAction(): bool
#[Action(ResponseType::JSON)]
public function saveTempAction(): ActionResponse
{
try {
$key =
$this->temporaryMasterPassService->create(
$this->request->analyzeInt('temporary_masterpass_maxtime', 3600)
);
$key =
$this->temporaryMasterPassService->create(
$this->request->analyzeInt('temporary_masterpass_maxtime', 3600)
);
$groupId = $this->request->analyzeInt('temporary_masterpass_group', 0);
$sendEmail = $this->configData->isMailEnabled()
&& $this->request->analyzeBool('temporary_masterpass_email');
$groupId = $this->request->analyzeInt('temporary_masterpass_group', 0);
$sendEmail = $this->configData->isMailEnabled()
&& $this->request->analyzeBool('temporary_masterpass_email');
if ($sendEmail) {
try {
if ($groupId > 0) {
$this->temporaryMasterPassService->sendByEmailForGroup($groupId, $key);
} else {
$this->temporaryMasterPassService->sendByEmailForAllUsers($key);
}
return $this->returnJsonResponse(
JsonMessage::JSON_SUCCESS,
__u('Temporary password generated'),
[__u('Email sent')]
);
} catch (Exception $e) {
processException($e);
$this->eventDispatcher->notify('exception', new Event($e));
return $this->returnJsonResponse(
JsonMessage::JSON_WARNING,
__u('Temporary password generated'),
[__u('Error while sending the email')]
);
}
if ($sendEmail) {
if ($groupId > 0) {
$this->temporaryMasterPassService->sendByEmailForGroup($groupId, $key);
} else {
$this->temporaryMasterPassService->sendByEmailForAllUsers($key);
}
return $this->returnJsonResponse(JsonMessage::JSON_SUCCESS, __u('Temporary password generated'));
} catch (Exception $e) {
processException($e);
$this->eventDispatcher->notify('exception', new Event($e));
return $this->returnJsonResponseException($e);
return ActionResponse::ok(__u('Temporary password generated'), __u('Email sent'));
}
return ActionResponse::ok(__u('Temporary password generated'));
}
/**
* @return void
* @throws JsonException
* @throws SessionTimeout
* @throws UnauthorizedPageException
* @throws SPException
*/
protected function initialize(): void
{
try {
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
} catch (UnauthorizedPageException $e) {
$this->eventDispatcher->notify('exception', new Event($e));
$this->returnJsonResponseException($e);
}
$this->checks();
$this->checkAccess(AclActionsInterface::CONFIG_CRYPT);
}
}