Merge branch '202-authentication-apis' into 'master'

add registration , user and authentication related api.

See merge request CIEFWorldwideSdnBhd/shipping-portal!4
This commit is contained in:
Fairuz
2021-06-28 13:10:03 +00:00
149 changed files with 5977 additions and 19 deletions
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Jobs;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\Modules\Accounts\Services\ExpiresEmailVerificationAttempt;
use App\Classes\Modules\Accounts\Services\ExpiresPasswordReset;
use App\Models\PasswordReset;
use App\Models\UserEmailVerification;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
class EmailVerificationAttemptExpiration implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/** @var UserEmailVerification */
private $attempt;
/**
* EmailVerificationAttemptExpiration constructor.
* @param UserEmailVerification $attempt
*/
public function __construct(UserEmailVerification $attempt)
{
$this->attempt = $attempt;
}
/**
* @throws MalformedRequestException
*/
public function handle()
{
(new ExpiresEmailVerificationAttempt())->execute($this->attempt);
}
}
@@ -0,0 +1,39 @@
<?php
namespace App\Classes\Jobs;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\Modules\Accounts\Services\ExpiresPasswordReset;
use App\Models\PasswordReset;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
class PasswordResetTokenExpiration implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/** @var PasswordReset */
private $attempt;
/**
* PasswordResetTokenExpiration constructor.
* @param PasswordReset $attempt
*/
public function __construct(PasswordReset $attempt)
{
$this->attempt = $attempt;
}
/**
* @throws MalformedRequestException
*/
public function handle()
{
(new ExpiresPasswordReset())->execute($this->attempt);
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Jobs;
use App\Classes\Notifications\ResetPasswordEmail;
use App\Models\PasswordReset;
use App\Models\User;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
class SendResetPasswordEmail implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/** @var User */
private $user;
/** @var PasswordReset */
private $attempt;
/**
* SendResetPasswordEmail constructor.
* @param User $user
* @param PasswordReset $attempt
*/
public function __construct(User $user, PasswordReset $attempt)
{
$this->user = $user;
$this->attempt = $attempt;
}
public function handle()
{
$this->user->notify(new ResetPasswordEmail($this->user, $this->attempt));
}
}
@@ -0,0 +1,41 @@
<?php
namespace App\Classes\Jobs;
use App\Classes\Notifications\UserVerificationEmail;
use App\Models\User;
use App\Models\UserEmailVerification;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
class SendUserVerificationEmail implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
/** @var User */
private $user;
/** @var UserEmailVerification */
private $attempt;
/**
* SendUserVerificationEmail constructor.
* @param User $user
* @param UserEmailVerification $attempt
*/
public function __construct(User $user, UserEmailVerification $attempt)
{
$this->user = $user;
$this->attempt = $attempt;
}
public function handle()
{
$this->user->notify(new UserVerificationEmail($this->user, $this->attempt));
}
}
@@ -0,0 +1,46 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Modules\Accounts\Processors\AuthenticationProcessor;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class AuthenticateUserLogic extends AbstractControllerLogic
{
protected function notification():array {
return [
'title' => 'Authentication',
'message' => 'You have successfully logged in to your account'
];
}
/** @var AuthenticationProcessor */
private $authenticationProcessor;
/**
* AuthenticateUserLogic constructor.
* @param AuthenticationProcessor $authenticationProcessor
*/
public function __construct(AuthenticationProcessor $authenticationProcessor)
{
$this->authenticationProcessor = $authenticationProcessor;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\AccessUnauthorisedException
* @throws \App\Classes\Exceptions\InternalServerErrorException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function logic(Request $request): JsonResponse {
return $this->response($this->authenticationProcessor->execute($request));
}
}
@@ -0,0 +1,54 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CheckEmailLogic extends AbstractControllerLogic
{
protected function notification():array {
return [
'title' => 'User found',
'message' => 'Account Already Exists'
];
}
/** @var FetchesUser */
private $fetchesUser;
/**
* CheckEmailLogic constructor.
* @param FetchesUser $fetchesUser
*/
public function __construct(FetchesUser $fetchesUser)
{
$this->fetchesUser = $fetchesUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
protected function logic(Request $request): JsonResponse {
try {
$this->fetchesUser->execute(['email' => $request->input('email')]);
return $this->response();
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
@@ -0,0 +1,73 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Standards\Rules\CanCreateUser;
use App\Classes\Modules\Accounts\Services\CreatesUser;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
use App\Http\Resources\UserResource;
use App\Classes\ValueObjects\Constants\RoleTypes;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class CreateAdminUserLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Created Account',
'message' => 'You have successfully created a new Account'
];
}
/** @var CanCreateUser */
private $canCreateUser;
/** @var CreatesUser */
private $createsUser;
/**
* CreateUserLogic constructor.
* @param CanCreateUser $canCreateUser
* @param CreatesUser $createsUser
*/
public function __construct(
CanCreateUser $canCreateUser,
CreatesUser $createsUser
)
{
$this->canCreateUser = $canCreateUser;
$this->createsUser = $createsUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function logic(Request $request) : JsonResponse
{
$user_object = new RegistrationObject($request->input('name'), $request->input('email'),
$request->input('password'), $request->input('password_confirmation'),
RoleTypes::ADMIN, ApprovalStatus::APPROVED);
$this->canCreateUser->passes($user_object);
$user = $this->createsUser->execute($user_object);
return $this->resourceResponse(new UserResource($user));
}
}
@@ -0,0 +1,108 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Processors\AuthenticationProcessor;
use App\Classes\Modules\Accounts\Processors\CreateUserProcessor;
use App\Classes\Modules\Accounts\Processors\GenerateEmailVerificationAttemptProcessor;
use App\Classes\Modules\Companies\Processors\AssignEmployeeProcessor;
use App\Classes\Modules\Companies\Processors\AssignSegmentProcessor;
use App\Classes\Modules\Companies\Processors\CreateCompanyProcessor;
use App\Classes\Modules\Companies\DataTransferObjects\EmploymentObject;
use App\Classes\Modules\Contacts\Processors\CreateContactProcessor;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Classes\ValueObjects\Constants\BusinessType;
use App\Classes\ValueObjects\Constants\RoleTypes;
use App\Models\Company;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\App;
class CreateCustomerLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification(): array
{
return [
'title' => 'Created User',
'message' => 'You have successfully created a new User'
];
}
/** @var CreateUserProcessor */
private $createUserProcessor;
/** @var CreateCompanyProcessor */
private $createCompanyProcessor;
/** @var CreateContactProcessor */
private $createContactProcessor;
/** @var AssignEmployeeProcessor */
private $assignEmployeeProcessor;
/** @var AssignSegmentProcessor */
private $assignSegmentProcessor;
/** @var AuthenticationProcessor */
private $authenticationProcessor;
/** @var GenerateEmailVerificationAttemptProcessor */
private $generateEmailVerificationAttemptProcessor;
/**
* CreateCustomerLogic constructor.
* @param CreateUserProcessor $createUserProcessor
* @param CreateCompanyProcessor $createCompanyProcessor
* @param CreateContactProcessor $createContactProcessor
* @param AssignEmployeeProcessor $assignEmployeeProcessor
* @param AssignSegmentProcessor $assignSegmentProcessor
* @param AuthenticationProcessor $authenticationProcessor
* @param GenerateEmailVerificationAttemptProcessor $generateEmailVerificationAttemptProcessor
*/
public function __construct(CreateUserProcessor $createUserProcessor, CreateCompanyProcessor $createCompanyProcessor, CreateContactProcessor $createContactProcessor, AssignEmployeeProcessor $assignEmployeeProcessor, AssignSegmentProcessor $assignSegmentProcessor, AuthenticationProcessor $authenticationProcessor, GenerateEmailVerificationAttemptProcessor $generateEmailVerificationAttemptProcessor)
{
$this->createUserProcessor = $createUserProcessor;
$this->createCompanyProcessor = $createCompanyProcessor;
$this->createContactProcessor = $createContactProcessor;
$this->assignEmployeeProcessor = $assignEmployeeProcessor;
$this->assignSegmentProcessor = $assignSegmentProcessor;
$this->authenticationProcessor = $authenticationProcessor;
$this->generateEmailVerificationAttemptProcessor = $generateEmailVerificationAttemptProcessor;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\AccessUnauthorisedException
* @throws \App\Classes\Exceptions\InternalServerErrorException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function logic(Request $request): JsonResponse
{
/** @var User $user */
$user = $this->createUserProcessor->execute($request, RoleTypes::USER, App::environment(['local']) ? ApprovalStatus::APPROVED : ApprovalStatus::PENDING_VERIFICATION);
/** @var Company $company */
$company = $this->createCompanyProcessor->execute($request, BusinessType::IMPORTER, $request->input('type'), ApprovalStatus::PENDING_SUBMISSION);
$this->createContactProcessor->execute($request, $company);
$Object = new EmploymentObject($company, $user);
$this->assignEmployeeProcessor->execute($Object);
$this->assignSegmentProcessor->execute($company);
$this->generateEmailVerificationAttemptProcessor->execute($user);
return $this->response($this->authenticationProcessor->execute($request));
}
}
@@ -0,0 +1,74 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Http\Resources\UserResource;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\Modules\Accounts\Standards\Rules\CanDeleteUser;
use App\Classes\Modules\Accounts\Services\DeletesUser;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class DeleteUserLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification(): array
{
return [
'title' => 'Delete User',
'message' => 'You have successfully deleted the User'
];
}
/** @var CanDeleteUser */
private $canDeleteUser;
/** @var DeletesUser */
private $deletesUser;
/** @var FetchesUser */
private $fetchesUser;
public function __construct(
CanDeleteUser $canDeleteUser,
DeletesUser $deletesUser,
FetchesUser $fetchesUser
) {
$this->canDeleteUser = $canDeleteUser;
$this->deletesUser = $deletesUser;
$this->fetchesUser = $fetchesUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request): JsonResponse
{
try {
DB::beginTransaction();
$user = $this->fetchesUser->execute(['id' => $request->route('id')]);
$this->canDeleteUser->passes();
$this->deletesUser->execute($user);
DB::commit();
return $this->resourceResponse(new UserResource($user));
} catch (\Exception $exception) {
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
@@ -0,0 +1,63 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\Modules\Accounts\Standards\Rules\CanFetchUser;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Http\Resources\UserResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class FetchUserLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Fetch Users',
'message' => 'You have successfully retrieved the user'
];
}
/** @var CanFetchUser */
private $canFetchUser;
/** @var FetchesUser */
private $fetchessUser;
/**
* FetchUserLogic constructor.
* @param CanFetchUser $canFetchUser
* @param FetchesUser $fetchessUser
*/
public function __construct(CanFetchUser $canFetchUser, FetchesUser $fetchessUser)
{
$this->canFetchUser = $canFetchUser;
$this->fetchessUser = $fetchessUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
$this->canFetchUser->passes();
$query = $this->fetchessUser->execute(['id' => $request->input('user_id')]);
return $this->resourceResponse(new UserResource($query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Jobs\PasswordResetTokenExpiration;
use App\Classes\Jobs\SendResetPasswordEmail;
use App\Classes\Modules\Accounts\DataTransferObjects\GeneratePasswordResetObject;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\Modules\Accounts\Services\GeneratesPasswordReset;
use App\Classes\Modules\Accounts\Standards\Rules\CanGeneratePasswordReset;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\ValueObjects\Constants\Notifications;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class GeneratePasswordResetLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Reset Password',
'message' => 'You have successfully sent you an email to reset your password'
];
}
/** @var CanGeneratePasswordReset */
private $canGeneratePasswordReset;
/** @var FetchesUser */
private $fetchesUser;
/** @var GeneratesPasswordReset */
private $generatesPasswordReset;
/** @var PasswordResetTokenExpiration */
private $passwordResetTokenExpiration;
/** @var SendResetPasswordEmail */
private $sendResetPasswordEmail;
/**
* GeneratePasswordResetLogic constructor.
* @param CanGeneratePasswordReset $canGeneratePasswordReset
* @param FetchesUser $fetchesUser
* @param GeneratesPasswordReset $generatesPasswordReset
* @param PasswordResetTokenExpiration $passwordResetTokenExpiration
* @param SendResetPasswordEmail $sendResetPasswordEmail
*/
public function __construct(CanGeneratePasswordReset $canGeneratePasswordReset, FetchesUser $fetchesUser, GeneratesPasswordReset $generatesPasswordReset, PasswordResetTokenExpiration $passwordResetTokenExpiration, SendResetPasswordEmail $sendResetPasswordEmail)
{
$this->canGeneratePasswordReset = $canGeneratePasswordReset;
$this->fetchesUser = $fetchesUser;
$this->generatesPasswordReset = $generatesPasswordReset;
$this->passwordResetTokenExpiration = $passwordResetTokenExpiration;
$this->sendResetPasswordEmail = $sendResetPasswordEmail;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function logic(Request $request): JsonResponse {
$object = new GeneratePasswordResetObject($request->input('email'));
if($this->canGeneratePasswordReset->passes($object)) {
$user = $this->fetchesUser->execute(['email' => $object->getEmail()]);
$attempt = $this->generatesPasswordReset->execute($user);
$this->passwordResetTokenExpiration::dispatch($attempt)->delay(now()->addHours(24));
$this->sendResetPasswordEmail::dispatch($user, $attempt);
return $this->response(['email' => $object->getEmail()]);
}
}
}
@@ -0,0 +1,60 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Modules\Accounts\Services\ListsUsers;
use App\Classes\Modules\Accounts\Standards\Rules\CanListUsers;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Http\Resources\UserResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListUsersLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'List Users',
'message' => 'You have successfully retrieved a list of users'
];
}
/** @var CanListUsers */
private $canListUsers;
/** @var ListsUsers */
private $listsUsers;
/**
* ListUsersLogic constructor.
* @param CanListUsers $canListUsers
* @param ListsUsers $listsUsers
*/
public function __construct(CanListUsers $canListUsers, ListsUsers $listsUsers)
{
$this->canListUsers = $canListUsers;
$this->listsUsers = $listsUsers;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function logic(Request $request) : JsonResponse
{
$this->canListUsers->passes();
$query = $this->listsUsers->execute($this->listsUsers->deserializeFilters($request->input('filters')));
return $this->collectionResponse(UserResource::collection($query));
}
}
@@ -0,0 +1,46 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Services\InvalidatesAuthenticationToken;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class LogoutUserLogic extends AbstractControllerLogic
{
protected function notification():array {
return [
'title' => 'Logout',
'message' => 'You have successfully logged out of your account'
];
}
/** @var InvalidatesAuthenticationToken */
private $invalidatesAuthenticationToken;
/**
* LogoutUserLogic constructor.
* @param InvalidatesAuthenticationToken $invalidatesAuthenticationToken
*/
public function __construct(InvalidatesAuthenticationToken $invalidatesAuthenticationToken)
{
logger("logout user logic");
$this->invalidatesAuthenticationToken = $invalidatesAuthenticationToken;
}
/**
* @param Request $request
* @return JsonResponse
*/
protected function logic(Request $request): JsonResponse {
logger("logout");
$this->invalidatesAuthenticationToken->execute();
return $this->response();
}
}
@@ -0,0 +1,47 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Processors\RefreshAuthenticationTokenProcessor;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class RefreshAuthenticationTokenLogic extends AbstractControllerLogic
{
protected function notification():array {
return [
'title' => 'Refresh Authentication',
'message' => 'You have successfully your account authentication'
];
}
/** @var RefreshAuthenticationTokenProcessor */
private $refreshAuthenticationTokenProcessor;
/**
* RefreshAuthenticationTokenLogic constructor.
* @param RefreshAuthenticationTokenProcessor $refreshAuthenticationTokenProcessor
*/
public function __construct(RefreshAuthenticationTokenProcessor $refreshAuthenticationTokenProcessor)
{
$this->refreshAuthenticationTokenProcessor = $refreshAuthenticationTokenProcessor;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\InternalServerErrorException
*/
protected function logic(Request $request): JsonResponse {
/** @var User $user */
$user = Auth()->user();
return $this->response($this->refreshAuthenticationTokenProcessor->execute($user));
}
}
@@ -0,0 +1,51 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Processors\GenerateEmailVerificationAttemptProcessor;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ResendEmailVerificationLogic extends AbstractControllerLogic
{
public function notification(): array
{
return [
'title' => 'Resend Verification Email',
'message' => 'Successfully resent a new verification email'
];
}
/** @var FetchesUser */
private $fetchesUser;
/** @var GenerateEmailVerificationAttemptProcessor */
private $generateEmailVerificationAttemptProcessor;
/**
* ResendEmailVerificationLogic constructor.
* @param FetchesUser $fetchesUser
* @param GenerateEmailVerificationAttemptProcessor $generateEmailVerificationAttemptProcessor
*/
public function __construct(FetchesUser $fetchesUser, GenerateEmailVerificationAttemptProcessor $generateEmailVerificationAttemptProcessor)
{
$this->fetchesUser = $fetchesUser;
$this->generateEmailVerificationAttemptProcessor = $generateEmailVerificationAttemptProcessor;
}
public function logic(Request $request) : JsonResponse {
/** @var User $user */
$user = $this->fetchesUser->execute(['id' => $request->input('user_id')]);
$this->generateEmailVerificationAttemptProcessor->execute($user);
return $this->response([]);
}
}
@@ -0,0 +1,80 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Modules\Accounts\DataTransferObjects\NewPasswordObject;
use App\Classes\Modules\Accounts\DataTransferObjects\PasswordResetObject;
use App\Classes\Modules\Accounts\Services\ChangesPassword;
use App\Classes\Modules\Accounts\Services\CompletesPasswordReset;
use App\Classes\Modules\Accounts\Services\FetchesPasswordReset;
use App\Classes\Modules\Accounts\Standards\Rules\CanResetPassword;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Models\PasswordReset;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ResetPasswordLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Password Change',
'message' => 'You have successfully changed your account\'t password'
];
}
/** @var CanResetPassword */
private $canResetPassword;
/** @var FetchesPasswordReset */
private $fetchesPasswordReset;
/** @var ChangesPassword */
private $changePassword;
/** @var CompletesPasswordReset */
private $completesPasswordResetToken;
/**
* ResetPasswordLogic constructor.
* @param CanResetPassword $canResetPassword
* @param FetchesPasswordReset $fetchesPasswordReset
* @param ChangesPassword $changePassword
* @param CompletesPasswordReset $completesPasswordResetToken
*/
public function __construct(CanResetPassword $canResetPassword, FetchesPasswordReset $fetchesPasswordReset, ChangesPassword $changePassword, CompletesPasswordReset $completesPasswordResetToken)
{
$this->canResetPassword = $canResetPassword;
$this->fetchesPasswordReset = $fetchesPasswordReset;
$this->changePassword = $changePassword;
$this->completesPasswordResetToken = $completesPasswordResetToken;
}
/**
* @param Request $request
* @return JsonResponse
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\InternalServerErrorException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function logic(Request $request): JsonResponse {
$object = new PasswordResetObject($request->input('token'),
new NewPasswordObject($request->input('password'), $request->input('confirmPassword')));
$this->canResetPassword->passes($object);
/** @var PasswordReset $passwordReset */
$passwordReset = $this->fetchesPasswordReset->execute(['token' => $object->getToken(), 'with_user']);
$this->changePassword->execute($passwordReset->user, $object->getNewPassword());
$this->completesPasswordResetToken->execute($passwordReset);
return $this->response();
}
}
@@ -0,0 +1,78 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Services\UpdatesUser;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\Modules\Accounts\Standards\Rules\CanUpdateUser;
use App\Classes\Modules\Accounts\DataTransferObjects\FullNameObject;
use App\Http\Resources\UserResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class UpdateUserLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Updated User Profile',
'message' => 'You have successfully updated the User Profile'
];
}
/** @var CanUpdateUser */
private $canUpdateUser;
/** @var UpdatesUser */
private $updatesUser;
/** @var FetchesUser */
private $fetchesUser;
/**
* UpdateAddressLogic constructor.
* @param CanUpdateUser $canUpdateUser
* @param UpdatesUser $updatesUser
* @param FetchesUser $fetchesUSer
*/
public function __construct(CanUpdateUser $canUpdateUser, UpdatesUser $updatesUser, FetchesUser $fetchesUser)
{
$this->canUpdateUser = $canUpdateUser;
$this->updatesUser = $updatesUser;
$this->fetchesUser = $fetchesUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
logger("user update logic");
$object = new FullNameObject($request->input('name'));
$this->canUpdateUser->passes($object);
$query = $this->fetchesUser->execute(['id' => $request->route('id')]);
$query = $this->updatesUser->execute($query, $object);
return $this->resourceResponse(new UserResource($query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
@@ -0,0 +1,76 @@
<?php
namespace App\Classes\Modules\Accounts\ControllersLogic;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Accounts\Services\CompletesEmailVerificationAttempt;
use App\Classes\Modules\Accounts\Services\FetchesEmailVerificationAttempt;
use App\Classes\Modules\Accounts\Services\VerifiesUser;
use App\Classes\Modules\Accounts\Standards\Criteria\EmailVerificationActiveAttemptExists;
use App\Models\UserEmailVerification;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class UserEmailVerificationLogic extends AbstractControllerLogic
{
public function notification(): array
{
return [
'title' => 'Email Verification',
'message' => 'You have successfully verified your email address'
];
}
/** @var emailVerificationActiveAttemptExists */
private $emailVerificationActiveAttemptExists;
/** @var CompletesEmailVerificationAttempt */
private $completesEmailVerificationAttempt;
/** @var FetchesEmailVerificationAttempt */
private $fetchesEmailVerificationAttempt;
/** @var VerifiesUser */
private $verifiesUser;
/**
* UserEmailVerificationLogic constructor.
* @param EmailVerificationActiveAttemptExists $emailVerificationActiveAttemptExists
* @param CompletesEmailVerificationAttempt $completesEmailVerificationAttempt
* @param FetchesEmailVerificationAttempt $fetchesEmailVerificationAttempt
* @param VerifiesUser $verifiesUser
*/
public function __construct(EmailVerificationActiveAttemptExists $emailVerificationActiveAttemptExists, CompletesEmailVerificationAttempt $completesEmailVerificationAttempt, FetchesEmailVerificationAttempt $fetchesEmailVerificationAttempt, VerifiesUser $verifiesUser)
{
$this->emailVerificationActiveAttemptExists = $emailVerificationActiveAttemptExists;
$this->completesEmailVerificationAttempt = $completesEmailVerificationAttempt;
$this->fetchesEmailVerificationAttempt = $fetchesEmailVerificationAttempt;
$this->verifiesUser = $verifiesUser;
}
/**
* @param Request $request
* @return JsonResponse
* @throws MalformedRequestException
* @throws ResourceNotFoundException
*/
public function logic(Request $request) : JsonResponse {
$token = $request->input('token');
$this->emailVerificationActiveAttemptExists->execute($token);
/** @var UserEmailVerification $attempt */
$attempt = $this->fetchesEmailVerificationAttempt->execute(['token' => $token]);
$this->completesEmailVerificationAttempt->execute($attempt);
$this->verifiesUser->execute($attempt->user);
return $this->response([]);
}
}
@@ -0,0 +1,60 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class AuthenticationCredentialsObject implements DataTransferObject
{
/** @var string */
private $email;
/** @var string */
private $password;
/** @var boolean */
private $rememberUser;
/**
* AuthenticationCredentialsObject constructor.
* @param string $email
* @param string $password
* @param bool|null $rememberUser
*/
public function __construct(string $email, string $password, ?bool $rememberUser = false)
{
$this->email = $email;
$this->password = $password;
$this->rememberUser = $rememberUser;
}
/**
* @return string
*/
public function getEmail(): string
{
return $this->email;
}
/**
* @return string
*/
public function getPassword(): string
{
return $this->password;
}
/**
* @return bool
*/
public function isRememberUser(): bool
{
return $this->rememberUser;
}
}
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class FullnameObject implements DataTransferObject
{
/** @var string */
private $name;
/**
* UserObject constructor.
* @param string $name
* @param string $email
* @param string $password
* @param string $passwordConfirmation
* @param int|null $type
* @param int|null $status
*/
public function __construct(string $name)
{
$this->name = $name;
}
/**
* @return string
*/
public function getName(): string
{
return $this->name;
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class GeneratePasswordResetObject implements DataTransferObject
{
/** @var string */
private $email;
/**
* GeneratePasswordResetObject constructor.
* @param string $email
*/
public function __construct(string $email)
{
$this->email = $email;
}
/**
* @return string
*/
public function getEmail(): string
{
return $this->email;
}
}
@@ -0,0 +1,45 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class NewPasswordObject implements DataTransferObject
{
/** @var String */
private $password;
/** @var String */
private $ConfirmPassword;
/**
* NewPassword constructor.
* @param String $password
* @param String $ConfirmPassword
*/
public function __construct(String $password, String $ConfirmPassword)
{
$this->password = $password;
$this->ConfirmPassword = $ConfirmPassword;
}
/**
* @return String
*/
public function getPassword(): String
{
return $this->password;
}
/**
* @return String
*/
public function getConfirmPassword(): String
{
return $this->ConfirmPassword;
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class PasswordResetObject implements DataTransferObject
{
/** @var String */
private $token;
/** @var NewPasswordObject */
private $newPassword;
/**
* PasswordResetObject constructor.
* @param String $token
* @param NewPasswordObject $newPassword
*/
public function __construct(String $token, NewPasswordObject $newPassword)
{
$this->token = $token;
$this->newPassword = $newPassword;
}
/**
* @return String
*/
public function getToken(): String
{
return $this->token;
}
/**
* @return NewPasswordObject
*/
public function getNewPassword(): NewPasswordObject
{
return $this->newPassword;
}
}
@@ -0,0 +1,99 @@
<?php
namespace App\Classes\Modules\Accounts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Classes\ValueObjects\Constants\RoleTypes;
class RegistrationObject implements DataTransferObject
{
/** @var string */
private $name;
/** @var string */
private $email;
/** @var string */
private $password;
/** @var string */
private $passwordConfirmation;
/** @var int|null */
private $type;
/** @var int|null */
private $status;
/**
* UserObject constructor.
* @param string $name
* @param string $email
* @param string $password
* @param string $passwordConfirmation
* @param int|null $type
* @param int|null $status
*/
public function __construct(string $name, string $email, string $password, string $passwordConfirmation, ?int $type = RoleTypes::USER, ?int $status = ApprovalStatus::PENDING_VERIFICATION)
{
$this->name = $name;
$this->email = $email;
$this->password = $password;
$this->passwordConfirmation = $passwordConfirmation;
$this->type = $type;
$this->status = $status;
}
/**
* @return string
*/
public function getName(): string
{
return $this->name;
}
/**
* @return string
*/
public function getEmail(): string
{
return $this->email;
}
/**
* @return string
*/
public function getPassword(): string
{
return $this->password;
}
/**
* @return string
*/
public function getPasswordConfirmation(): string
{
return $this->passwordConfirmation;
}
/**
* @return int
*/
public function getType(): int
{
return $this->type;
}
/**
* @return int
*/
public function getStatus(): int
{
return $this->status;
}
}
@@ -0,0 +1,70 @@
<?php
namespace App\Classes\Modules\Accounts\Processors;
use App\Classes\Modules\Accounts\DataTransferObjects\AuthenticationCredentialsObject;
use App\Classes\Modules\Accounts\Services\AuthenticatesUser;
use App\Classes\Modules\Accounts\Services\AuthenticationRedirect;
use App\Classes\Modules\Accounts\Services\FetchesUser;
use App\Classes\Modules\Accounts\Services\GeneratesAuthenticationToken;
use App\Classes\Modules\Accounts\Standards\Rules\CanAuthenticateUser;
use Illuminate\Http\Request;
class AuthenticationProcessor
{
/** @var CanAuthenticateUser */
private $canAuthenticateUser;
/** @var AuthenticatesUser */
private $authenticatesUser;
/** @var GeneratesAuthenticationToken */
private $generatesAuthenticationToken;
/** @var FetchesUser */
private $fetchesUser;
/** @var AuthenticationRedirect */
private $authenticationRedirect;
/**
* AuthenticationProcessor constructor.
* @param CanAuthenticateUser $canAuthenticateUser
* @param AuthenticatesUser $authenticatesUser
* @param GeneratesAuthenticationToken $generatesAuthenticationToken
* @param FetchesUser $fetchesUser
* @param AuthenticationRedirect $authenticationRedirect
*/
public function __construct(CanAuthenticateUser $canAuthenticateUser, AuthenticatesUser $authenticatesUser, GeneratesAuthenticationToken $generatesAuthenticationToken, FetchesUser $fetchesUser, AuthenticationRedirect $authenticationRedirect)
{
$this->canAuthenticateUser = $canAuthenticateUser;
$this->authenticatesUser = $authenticatesUser;
$this->generatesAuthenticationToken = $generatesAuthenticationToken;
$this->fetchesUser = $fetchesUser;
$this->authenticationRedirect = $authenticationRedirect;
}
/**
* @param Request $request
* @return array
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\AccessUnauthorisedException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(Request $request): array {
$object = new AuthenticationCredentialsObject($request->input('email'), $request->input('password'));
$this->canAuthenticateUser->passes($object);
$this->authenticatesUser->execute($object);
$user = $this->fetchesUser->execute(['email' => $object->getEmail()]);
return ['access_token' => $this->generatesAuthenticationToken->execute($user), 'redirect_url' => $this->authenticationRedirect->url($user)];
}
}
@@ -0,0 +1,54 @@
<?php
namespace App\Classes\Modules\Accounts\Processors;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
use App\Classes\Modules\Accounts\Services\CreatesUser;
use App\Classes\Modules\Accounts\Standards\Rules\CanRegisterUser;
use App\Models\User;
use Illuminate\Http\Request;
use Illuminate\Database\Eloquent\Model;
class CreateUserProcessor
{
/** @var CanRegisterUser */
private $canRegisterUser;
/** @var CreatesUser */
private $createsUser;
/**
* CreateUserProcessor constructor.
* @param CanRegisterUser $canRegisterUser
* @param CreatesUser $createsUser
*/
public function __construct(CanRegisterUser $canRegisterUser, CreatesUser $createsUser)
{
$this->canRegisterUser = $canRegisterUser;
$this->createsUser = $createsUser;
}
/**
* @param Request $request
* @param $roleType
* @param $status
* @return Model
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(Request $request, $roleType, $status): Model {
$userObject = new RegistrationObject($request->input('name'), $request->input('email'),
$request->input('password'), $request->input('password_confirmation'),
$roleType, $status);
$this->canRegisterUser->passes($userObject);
/** @var User $user_query */
return $this->createsUser->execute($userObject);
}
}
@@ -0,0 +1,59 @@
<?php
namespace App\Classes\Modules\Accounts\Processors;
use App\Classes\Jobs\EmailVerificationAttemptExpiration;
use App\Classes\Jobs\SendUserVerificationEmail;
use App\Classes\Modules\Accounts\Services\GeneratesEmailVerificationAttempt;
use App\Classes\Modules\Accounts\Services\InvalidatesActiveEmailVerificationAttempts;
use App\Models\User;
class GenerateEmailVerificationAttemptProcessor
{
/** @var InvalidatesActiveEmailVerificationAttempts */
private $invalidatesActiveEmailVerificationAttempts;
/** @var GeneratesEmailVerificationAttempt */
private $generatesEmailVerificationAttempt;
/** @var EmailVerificationAttemptExpiration */
private $emailVerificationAttemptExpiration;
/** @var SendUserVerificationEmail */
private $sendUserVerificationEmail;
/**
* GenerateEmailVerificationAttemptProcessor constructor.
* @param InvalidatesActiveEmailVerificationAttempts $invalidatesActiveEmailVerificationAttempts
* @param GeneratesEmailVerificationAttempt $generatesEmailVerificationAttempt
* @param EmailVerificationAttemptExpiration $emailVerificationAttemptExpiration
* @param SendUserVerificationEmail $sendUserVerificationEmail
*/
public function __construct(InvalidatesActiveEmailVerificationAttempts $invalidatesActiveEmailVerificationAttempts, GeneratesEmailVerificationAttempt $generatesEmailVerificationAttempt, EmailVerificationAttemptExpiration $emailVerificationAttemptExpiration, SendUserVerificationEmail $sendUserVerificationEmail)
{
$this->invalidatesActiveEmailVerificationAttempts = $invalidatesActiveEmailVerificationAttempts;
$this->generatesEmailVerificationAttempt = $generatesEmailVerificationAttempt;
$this->emailVerificationAttemptExpiration = $emailVerificationAttemptExpiration;
$this->sendUserVerificationEmail = $sendUserVerificationEmail;
}
/**
* @param User $user
* @return void
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(User $user) {
$this->invalidatesActiveEmailVerificationAttempts->execute($user);
$attempt = $this->generatesEmailVerificationAttempt->execute($user);
$this->emailVerificationAttemptExpiration::dispatch($attempt)->delay(now()->addHours(48));
$this->sendUserVerificationEmail::dispatch($user, $attempt);
}
}
@@ -0,0 +1,43 @@
<?php
namespace App\Classes\Modules\Accounts\Processors;
use App\Classes\Modules\Accounts\Services\GeneratesAuthenticationToken;
use App\Classes\Modules\Accounts\Services\InvalidatesAuthenticationToken;
use App\Models\User;
class RefreshAuthenticationTokenProcessor
{
/** @var InvalidatesAuthenticationToken */
private $invalidatesAuthenticationToken;
/** @var GeneratesAuthenticationToken */
private $generatesAuthenticationToken;
/**
* RefreshAuthenticationTokenLogic constructor.
* @param InvalidatesAuthenticationToken $invalidatesAuthenticationToken
* @param GeneratesAuthenticationToken $generatesAuthenticationToken
*/
public function __construct(InvalidatesAuthenticationToken $invalidatesAuthenticationToken, GeneratesAuthenticationToken $generatesAuthenticationToken)
{
$this->invalidatesAuthenticationToken = $invalidatesAuthenticationToken;
$this->generatesAuthenticationToken = $generatesAuthenticationToken;
}
/**
* @param User $user
* @return array
* @throws \App\Classes\Exceptions\InternalServerErrorException
*/
public function execute(User $user): array {
$this->invalidatesAuthenticationToken->execute();
return ['refresh_token' => $this->generatesAuthenticationToken->execute($user)];
}
}
@@ -0,0 +1,26 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\AccessUnauthorisedException;
use App\Classes\Modules\Accounts\DataTransferObjects\AuthenticationCredentialsObject;
class AuthenticatesUser
{
/**
* @param AuthenticationCredentialsObject $object
* @return false|string
* @throws AccessUnauthorisedException
*/
public function execute(AuthenticationCredentialsObject $object){
if (! auth()->validate(['email' => $object->getEmail(), 'password' => $object->getPassword()])) {
throw new AccessUnauthorisedException('These credentials do not match our records.');
}
return true;
}
}
@@ -0,0 +1,20 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\ValueObjects\Constants\RoleTypes;
use App\Models\User;
class AuthenticationRedirect
{
public function url(User $user){
if($user->type === RoleTypes::USER){
return route('dashboard');
}
return route('dashboard');
}
}
@@ -0,0 +1,32 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\InternalServerErrorException;
use App\Classes\Modules\Accounts\DataTransferObjects\NewPasswordObject;
use App\Models\User;
use Illuminate\Database\QueryException;
use Illuminate\Support\Facades\Hash;
class ChangesPassword
{
/**
* @param User $user
* @param NewPasswordObject $object
* @return bool
* @throws InternalServerErrorException
*/
public function execute(User $user, NewPasswordObject $object): bool {
try {
$user->password = Hash::make($object->getPassword());
return $user->save();
} catch (QueryException $exception){
throw new InternalServerErrorException($exception->getMessage());
}
}
}
@@ -0,0 +1,24 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Models\UserEmailVerification;
use Illuminate\Database\Eloquent\Model;
class CompletesEmailVerificationAttempt extends AbstractUpdateRecord
{
/**
* @param UserEmailVerification $model
* @return Model
* @throws MalformedRequestException
*/
public function execute(UserEmailVerification $model): Model {
$model->is_complete = true;
return $this->handler($model);
}
}
@@ -0,0 +1,26 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Models\PasswordReset;
class CompletesPasswordReset extends AbstractUpdateRecord
{
/**
* @param PasswordReset $model
* @return \Illuminate\Database\Eloquent\Model
* @throws MalformedRequestException
*/
public function execute(PasswordReset $model){
$model->is_complete = true;
return $this->handler($model);
}
}
@@ -0,0 +1,27 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
use App\Models\User;
class CreatesUser extends AbstractUpdateRecord
{
/**
* @param RegistrationObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(RegistrationObject $object) {
$model = new User();
$model->name = $object->getName();
$model->email = $object->getEmail();
$model->password = bcrypt($object->getPassword());
$model->type = $object->getType();
$model->status = $object->getStatus();
return $this->handler($model);
}
}
@@ -0,0 +1,19 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractDeleteRecord;
use App\Models\User;
class DeletesUser extends AbstractDeleteRecord
{
/**
* @param User $model
* @return mixed
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(User $model) {
return $this->handler($model);
}
}
@@ -0,0 +1,29 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Models\PasswordReset;
use App\Models\UserEmailVerification;
class ExpiresEmailVerificationAttempt extends AbstractUpdateRecord
{
/**
* @param UserEmailVerification $model
* @return \Illuminate\Database\Eloquent\Model
* @throws MalformedRequestException
*/
public function execute(UserEmailVerification $model){
$model->is_active = false;
return $this->handler($model);
}
}
@@ -0,0 +1,35 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use App\Models\PasswordReset;
use App\Models\UserEmailVerification;
use Illuminate\Database\Eloquent\Builder;
class FetchesEmailVerificationAttempt extends AbstractFetchRecord
{
/** @var UserEmailVerification */
private $repository;
/**
* FetchesResetPasswordToken constructor.
* @param UserEmailVerification $repository
*/
public function __construct(UserEmailVerification $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use App\Models\PasswordReset;
use Illuminate\Database\Eloquent\Builder;
class FetchesPasswordReset extends AbstractFetchRecord
{
/** @var PasswordReset */
private $repository;
/**
* FetchesResetPasswordToken constructor.
* @param PasswordReset $repository
*/
public function __construct(PasswordReset $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\User;
class FetchesUser extends AbstractFetchRecord
{
/** @var User */
private $repository;
/**
* FetchesUser constructor.
* @param User $repository
*/
public function __construct(User $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,79 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\InternalServerErrorException;
use App\Classes\ValueObjects\Constants\RoleTypes;
use App\Models\Company;
use App\Models\Role;
use App\Models\User;
use Carbon\Carbon;
use Tymon\JWTAuth\JWT;
class GeneratesAuthenticationToken {
/** @var JWT */
private $builder;
/**
* GeneratesAuthenticationToken constructor.
* @param JWT $builder
*/
public function __construct(JWT $builder) {
$this->builder = $builder;
}
/**
* @param User $user
* @param bool $rememberUser
* @return string
*/
public function execute(User $user, bool $rememberUser = false): string {
$this->builder->manager()->setBlacklistEnabled(false);
// generate token for the customer
$this->builder->factory()->setTTL(Carbon::now()->addDay()->timestamp);
if ($rememberUser === true) {
$this->builder->factory()->setTTL(Carbon::now()->addWeek()->timestamp);
}
// set the claim based on the object
$this->setTokenClaims($user);
return $this->builder->fromUser($user);
}
/**
* @param User $user
*/
private function setTokenClaims(User $user): void {
/** @var Company $company */
$company = $user->company()->first();
$claims = [
'id' => $user->id,
'name' => $user->name,
'email' => $user->email,
'type' => $user->type,
'status' => $user->status
];
if($user->type === RoleTypes::USER) {
$claims = array_merge($claims, [
'company_id' => $company->id
]);
}
$this->builder->factory()->customClaims(['user' => $claims]);
$this->builder->factory()->buildClaimsCollection();
}
}
@@ -0,0 +1,32 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRelationshipRecord;
use App\Models\User;
use App\Models\UserEmailVerification;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\QueryException;
use Illuminate\Support\Str;
class GeneratesEmailVerificationAttempt extends AbstractUpdateRelationshipRecord
{
/**
* @param User $user
* @return Model
* @throws MalformedRequestException
*/
public function execute(User $user): Model {
$model = new UserEmailVerification();
$model->token = Str::random(25);
$model->is_complete = false;
$model->is_active = true;
$model->is_sent = true;
return $this->handler($user->emailVerification(), $model);
}
}
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRelationshipRecord;
use App\Models\PasswordReset;
use App\Models\User;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Str;
class GeneratesPasswordReset extends AbstractUpdateRelationshipRecord
{
/**
* @param User $user
* @return \Illuminate\Database\Eloquent\Model
* @throws MalformedRequestException
*/
public function execute(User $user): Model {
$model = new PasswordReset();
$model->token = Str::random(60);
$model->is_expired = false;
$model->is_complete = false;
return $this->handler($user->passwordReset(), $model);
}
}
@@ -0,0 +1,22 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Models\User;
class InvalidatesActiveEmailVerificationAttempts
{
/**
* @param User $user
* @return void
*/
public function execute(User $user) {
$user->emailVerification()->active()->update([
'is_active' => false
]);
}
}
@@ -0,0 +1,15 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
class InvalidatesAuthenticationToken
{
/**
* @return false|string
*/
public function execute(){
auth()->logout();
}
}
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractListRecord;
use App\Models\User;
use Illuminate\Database\Eloquent\Builder;
class ListsUsers extends AbstractListRecord
{
/** @var User */
private $repository;
/**
* ListsUsers constructor.
* @param User $repository
*/
public function __construct(User $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,24 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Accounts\DataTransferObjects\FullnameObject;
use App\Models\User;
class UpdatesUser extends AbstractUpdateRecord
{
/**
* @param User $model
* @param UserObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(User $model, FullNameObject $object) {
$model->name = $object->getName();
return $this->handler($model);
}
}
@@ -0,0 +1,29 @@
<?php
namespace App\Classes\Modules\Accounts\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Models\User;
use App\Models\UserEmailVerification;
use Illuminate\Database\Eloquent\Model;
class VerifiesUser extends AbstractUpdateRecord
{
/**
* @param User $model
* @return Model
* @throws MalformedRequestException
*/
public function execute(User $model): Model {
$model->status = ApprovalStatus::APPROVED;
return $this->handler($model);
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Criteria;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Models\UserEmailVerification;
class EmailVerificationActiveAttemptExists
{
/** @var UserEmailVerification */
private $repository;
/**
* TokenExistsValidation constructor.
* @param UserEmailVerification $repository
*/
public function __construct(UserEmailVerification $repository)
{
$this->repository = $repository;
}
/**
* @param string $token
* @return bool
* @throws ResourceNotFoundException
*/
public function execute(string $token){
if(!$this->repository->active()->where('token', $token)->first()){
throw new ResourceNotFoundException('The email verification token has expired or doesn\'t exist');
}
return true;
}
}
@@ -0,0 +1,39 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Criteria;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Models\PasswordReset;
class PasswordResetTokenExists
{
/** @var PasswordReset */
private $repository;
/**
* TokenExistsValidation constructor.
* @param PasswordReset $repository
*/
public function __construct(PasswordReset $repository)
{
$this->repository = $repository;
}
/**
* @param string $token
* @return bool
* @throws ResourceNotFoundException
*/
public function execute(string $token){
if(!$this->repository->active()->where('token', $token)->first()){
throw new ResourceNotFoundException('The reset password token has expired or doesn\'t exist');
}
return true;
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Criteria;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Models\User;
class UserEmailExists
{
/** @var User */
private $repository;
/**
* UserEmailExists constructor.
* @param User $repository
*/
public function __construct(User $repository)
{
$this->repository = $repository;
}
/**
* @param string $email
* @return bool
* @throws ResourceNotFoundException
*/
public function execute(string $email){
if(!$this->repository->where('email', $email)->first()){
throw new ResourceNotFoundException('Unable to find any record that matches the email address provided');
}
return true;
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Exceptions\RequestValidationException;
use App\Classes\Modules\Accounts\DataTransferObjects\AuthenticationCredentialsObject;
use App\Classes\Modules\Accounts\Standards\Validators\UserAuthenticationValidation;
class CanAuthenticateUser extends AbstractRule
{
/** @var UserAuthenticationValidation */
private $userAuthenticationValidation;
/**
* CanAuthenticateUser constructor.
* @param UserAuthenticationValidation $userAuthenticationValidation
*/
public function __construct(UserAuthenticationValidation $userAuthenticationValidation)
{
$this->userAuthenticationValidation = $userAuthenticationValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
return true;
}
/**
* @param AuthenticationCredentialsObject $object
* @return bool
* @throws RequestValidationException
*/
protected function validators($object): bool
{
return $this->userAuthenticationValidation->validate($object);
}
/**
* @param AuthenticationCredentialsObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
use App\Classes\Modules\Accounts\Standards\Validators\UserCreateValidation;
class CanCreateUser extends AbstractRule
{
/** @var UserCreateValidation */
private $userCreateValidation;
/**
* CanCreateAddress constructor.
* @param UserCreateValidation $userCreateValidation
*/
public function __construct(UserCreateValidation $userCreateValidation)
{
$this->userCreateValidation = $userCreateValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param RegistrationObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->userCreateValidation->validate($object);
}
/**
* @param AddressObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Accounts\DataTransferObjects\UserObject;
class CanDeleteUser extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param UserObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param UserObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
class CanFetchUser extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
return true;
}
/**
* @param $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,65 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Exceptions\RequestValidationException;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Classes\Modules\Accounts\DataTransferObjects\GeneratePasswordResetObject;
use App\Classes\Modules\Accounts\Standards\Criteria\UserEmailExists;
use App\Classes\Modules\Accounts\Standards\Validators\GeneratePasswordResetValidation;
class CanGeneratePasswordReset extends AbstractRule
{
/** @var GeneratePasswordResetValidation */
private $generatePasswordResetValidation;
/** @var UserEmailExists */
private $userEmailExists;
/**
* CanGeneratePasswordReset constructor.
* @param GeneratePasswordResetValidation $generatePasswordResetValidation
* @param UserEmailExists $userEmailExists
*/
public function __construct(GeneratePasswordResetValidation $generatePasswordResetValidation, UserEmailExists $userEmailExists)
{
$this->generatePasswordResetValidation = $generatePasswordResetValidation;
$this->userEmailExists = $userEmailExists;
}
/**
* @return bool
*/
protected function authorized(): bool
{
return true;
}
/**
* @param GeneratePasswordResetObject $object
* @return bool
* @throws RequestValidationException
*/
protected function validators($object): bool
{
return $this->generatePasswordResetValidation->validate($object);
}
/**
* @param GeneratePasswordResetObject $object
* @return bool
* @throws ResourceNotFoundException
*/
protected function criteria($object): bool
{
return $this->userEmailExists->execute($object->getEmail());
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Accounts\DataTransferObjects\UserObject;
class CanListUsers extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
return true;
}
/**
* @param UserObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param UserObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,51 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
use App\Classes\Modules\Accounts\Standards\Validators\UserRegistrationValidation;
class CanRegisterUser extends AbstractRule
{
/** @var UserRegistrationValidation */
private $userValidation;
/**
* CanCreateUser constructor.
* @param UserRegistrationValidation $userValidation
*/
public function __construct(UserRegistrationValidation $userValidation)
{
$this->userValidation = $userValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param RegistrationObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->userValidation->validate($object);
}
/**
* @param RegistrationObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,65 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Exceptions\RequestValidationException;
use App\Classes\Exceptions\ResourceNotFoundException;
use App\Classes\Modules\Accounts\DataTransferObjects\PasswordResetObject;
use App\Classes\Modules\Accounts\Standards\Criteria\PasswordResetTokenExists;
use App\Classes\Modules\Accounts\Standards\Validators\ResetPasswordValidation;
class CanResetPassword extends AbstractRule
{
/** @var ResetPasswordValidation */
private $resetPasswordValidation;
/** @var PasswordResetTokenExists */
private $passwordResetTokenExists;
/**
* CanResetPassword constructor.
* @param ResetPasswordValidation $resetPasswordValidation
* @param PasswordResetTokenExists $passwordResetTokenExists
*/
public function __construct(ResetPasswordValidation $resetPasswordValidation, PasswordResetTokenExists $passwordResetTokenExists)
{
$this->resetPasswordValidation = $resetPasswordValidation;
$this->passwordResetTokenExists = $passwordResetTokenExists;
}
/**
* @return bool
*/
protected function authorized(): bool
{
return true;
}
/**
* @param PasswordResetObject $object
* @return bool
* @throws RequestValidationException
*/
protected function validators($object): bool
{
return $this->resetPasswordValidation->validate($object);
}
/**
* @param PasswordResetObject $object
* @return bool
* @throws ResourceNotFoundException
*/
protected function criteria($object): bool
{
return $this->passwordResetTokenExists->execute($object->getToken());
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Accounts\DataTransferObjects\UserObject;
use App\Classes\Modules\Accounts\Standards\Validators\UserUpdateValidation;
class CanUpdateUser extends AbstractRule
{
/** @var UserUpdateValidation */
private $userUpdateValidation;
/**
* CanUpdateAddress constructor.
* @param UserUpdateValidation $userUpdateValidation
*/
public function __construct(UserUpdateValidation $userUpdateValidation)
{
$this->userUpdateValidation = $userUpdateValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param UserObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->userUpdateValidation->validate($object);
}
/**
* @param AddressObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,42 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\GeneratePasswordResetObject;
class GeneratePasswordResetValidation extends AbstractValidation
{
/**
* @param GeneratePasswordResetObject $object
* @return array
*/
protected function data($object): array {
return [
'email' => $object->getEmail()
];
}
/**
* @return array
*/
protected function rules(): array {
return [
'email' => 'required|email'
];
}
/**
* @return array
*/
protected function messages(): array {
return [];
}
}
@@ -0,0 +1,50 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\PasswordResetObject;
class ResetPasswordValidation extends AbstractValidation
{
/**
* @param PasswordResetObject $object
* @return array
*/
protected function data($object): array {
return [
'token' => $object->getToken(),
'password' => $object->getNewPassword()->getPassword(),
'confirm_password' => $object->getNewPassword()->getConfirmPassword()
];
}
/**
* @return array
*/
protected function rules(): array {
return [
'token' => 'required',
'password' => 'required|min:6',
'confirm_password' => 'same:password'
];
}
/**
* @return array
*/
protected function messages(): array {
return [
'confirm_password' => [
'same' => 'The :attribute and :other must match.'
]
];
}
}
@@ -0,0 +1,43 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\AuthenticationCredentialsObject;
class UserAuthenticationValidation extends AbstractValidation
{
/**
* @param AuthenticationCredentialsObject $object
* @return array
*/
protected function data($object): array {
return [
'email' => $object->getEmail(),
'password' => $object->getPassword()
];
}
/**
* @return array
*/
protected function rules(): array {
return [
'email' => 'required|email',
'password' => 'required'
];
}
/**
* @return array
*/
protected function messages(): array {
return [];
}
}
@@ -0,0 +1,44 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\UserObject;
class UserCreateValidation extends AbstractValidation
{
/**
* @param UserObject $object
* @return array
*/
protected function data($object): array
{
return [
'name' => $object->getName(),
'email' => $object->getEmail(),
'password' => $object->getPassword(),
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'name' => 'required',
'email' => 'required|unique:users',
'password' => 'required',
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,49 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\RegistrationObject;
class UserRegistrationValidation extends AbstractValidation
{
/**
* @param RegistrationObject $object
* @return array
*/
protected function data($object): array
{
return [
'name' => $object->getName(),
'email' => $object->getEmail(),
'password' => $object->getPassword(),
'password_confirmation' => $object->getPasswordConfirmation(),
'type' => $object->getType(),
'status' => $object->getStatus(),
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'name' => 'required',
'email' => 'required|email|max:255|unique:users,email',
'password' => 'required|min:6|confirmed',
'type' => 'required',
'status' => 'required'
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Accounts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Accounts\DataTransferObjects\UserObject;
class UserUpdateValidation extends AbstractValidation
{
/**
* @param UserObject $object
* @return array
*/
protected function data($object): array
{
return [
'name' => $object->getName(),
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'name' => 'required',
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\Companies\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Classes\ValueObjects\Constants\BusinessType;
class CompanyObject implements DataTransferObject
{
/** @var string */
private $name;
/** @var string */
private $reference;
/** @var int|null */
private $businessType;
/** @var int|null */
private $type;
/** @var int|null */
private $status;
/**
* CompanyObject constructor.
* @param string $name
* @param string $reference
* @param int|null $businessType
* @param int|null $type
* @param int|null $status
*/
public function __construct(string $name, string $reference, ?int $businessType = BusinessType::IMPORTER, ?int $type = BusinessType::IMPORTER, ?int $status = ApprovalStatus::PENDING_SUBMISSION)
{
$this->name = $name;
$this->reference = $reference;
$this->businessType = $businessType;
$this->type = $type;
$this->status = $status;
}
/**
* @return string
*/
public function getName(): string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): string
{
return $this->reference;
}
/**
* @return int
*/
public function getBusinessType(): int
{
return $this->businessType;
}
/**
* @return int
*/
public function getType(): int
{
return $this->type;
}
/**
* @return int
*/
public function getStatus(): int
{
return $this->status;
}
}
@@ -0,0 +1,58 @@
<?php
namespace App\Classes\Modules\Companies\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Models\Company;
use App\Models\User;
class EmploymentObject implements DataTransferObject
{
/** @var Company */
private $company;
/** @var User */
private $user;
/** @var int|null */
private $status;
/**
* EmploymentObject constructor.
* @param Company $company
* @param User $user
* @param int|null $status
*/
public function __construct(Company $company, User $user, ?int $status = ApprovalStatus::APPROVED)
{
$this->company = $company;
$this->user = $user;
$this->status = $status;
}
/**
* @return Company
*/
public function getCompany(): Company
{
return $this->company;
}
/**
* @return User
*/
public function getUser(): User
{
return $this->user;
}
/**
* @return int
*/
public function getStatus(): int
{
return $this->status;
}
}
@@ -0,0 +1,44 @@
<?php
namespace App\Classes\Modules\Companies\Processors;
use App\Classes\Modules\Companies\Services\AssignsEmployee;
use App\Classes\Modules\Companies\Standards\Rules\CanAssignEmployee;
use App\Classes\Modules\Companies\DataTransferObjects\EmploymentObject;
use Illuminate\Database\Eloquent\Model;
class AssignEmployeeProcessor
{
/** @var CanAssignEmployee */
private $canAssignEmployee;
/** @var AssignsEmployee */
private $assignsEmployee;
/**
* AssignEmployeeProcessor constructor.
* @param CanAssignEmployee $canAssignEmployee
* @param AssignsEmployee $assignsEmployee
*/
public function __construct(CanAssignEmployee $canAssignEmployee, AssignsEmployee $assignsEmployee)
{
$this->canAssignEmployee = $canAssignEmployee;
$this->assignsEmployee = $assignsEmployee;
}
/**
* @param EmploymentObject $object
* @return Model
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(EmploymentObject $object): Model {
$this->canAssignEmployee->passes($object);
return $this->assignsEmployee->execute($object);
}
}
@@ -0,0 +1,56 @@
<?php
namespace App\Classes\Modules\Companies\Processors;
use App\Classes\Modules\Companies\Services\AssignsCompanyToSegment;
use App\Classes\Modules\Companies\Standards\Rules\CanAssignSegment;
use App\Classes\Modules\Segments\Services\FetchesSegment;
use App\Classes\ValueObjects\Constants\SegmentConstants;
use App\Models\Company;
use Illuminate\Database\Eloquent\Model;
class AssignSegmentProcessor
{
/** @var CanAssignSegment */
private $canAssignSegment;
/** @var AssignsCompanyToSegment */
private $assignsSegment;
/** @var FetchesSegment */
private $fetchesSegment;
/**
* AssignCompanyToSegmentProcessor constructor.
* @param CanAssignSegment $canAssignSegment
* @param AssignsCompanyToSegment $assignsSegment
* @param FetchesSegment $fetchesSegment
*/
public function __construct(CanAssignSegment $canAssignSegment, AssignsCompanyToSegment $assignsSegment, FetchesSegment $fetchesSegment)
{
$this->canAssignSegment = $canAssignSegment;
$this->assignsSegment = $assignsSegment;
$this->fetchesSegment = $fetchesSegment;
}
/**
* @param Company $company
* @param int|null $segmentId
* @return Model
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(Company $company, ?int $segmentId = SegmentConstants::STANDARD_SEGMENT): Model {
$segment = $this->fetchesSegment->execute(['id' => $segmentId]);
$this->canAssignSegment->passes();
return $this->assignsSegment->execute($company, $segment);
}
}
@@ -0,0 +1,60 @@
<?php
namespace App\Classes\Modules\Companies\Processors;
use App\Classes\General\Services\GeneratesInitials;
use App\Classes\Modules\Companies\DataTransferObjects\CompanyObject;
use App\Classes\Modules\Companies\Services\CreatesCompany;
use App\Classes\Modules\Companies\Standards\Rules\CanCreateCompany;
use App\Classes\ValueObjects\Constants\ApprovalStatus;
use App\Classes\ValueObjects\Constants\BusinessType;
use App\Classes\ValueObjects\Constants\CompanyType;
use Illuminate\Http\Request;
use Illuminate\Database\Eloquent\Model;
class CreateCompanyProcessor
{
/** @var CanCreateCompany */
private $canCreateCompany;
/** @var CreatesCompany */
private $createsCompany;
/**
* CreateUserProcessor constructor.
* @param CanCreateCompany $canCreateCompany
* @param CreatesCompany $createsCompany
*/
public function __construct(CanCreateCompany $canCreateCompany, CreatesCompany $createsCompany)
{
$this->canCreateCompany = $canCreateCompany;
$this->createsCompany = $createsCompany;
}
/**
* @param Request $request
* @param int $businessType
* @param int|null $companyType
* @param int|null $status
* @return Model
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(Request $request, int $businessType = BusinessType::IMPORTER, ?int $companyType = CompanyType::COMPANY_BUSINESS, ?int $status = ApprovalStatus::PENDING_SUBMISSION): Model {
$companyName = $companyType === CompanyType::COMPANY_BUSINESS ? $request->input('company_name') : $request->input('name');
$company_object = new CompanyObject(
$companyName,
mt_rand(1000, 9999).(new GeneratesInitials())->name($companyName)->length(3)->generate(),
$businessType, $companyType, $status);
$this->canCreateCompany->passes($company_object);
return $this->createsCompany->execute($company_object);
}
}
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Companies\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Models\Company;
use App\Models\Segment;
use Illuminate\Database\QueryException;
class AssignsCompanyToSegment extends AbstractUpdateRecord
{
/**
* @param Company $company
* @param Segment $segment
* @return \Illuminate\Database\Eloquent\Model
* @throws MalformedRequestException
*/
public function execute(Company $company, Segment $segment)
{
try {
$company->segments()->attach($segment);
return $company;
} catch (QueryException $exception){
throw new MalformedRequestException($exception);
}
}
}
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\Companies\Services;
use App\Classes\Exceptions\MalformedRequestException;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Companies\DataTransferObjects\EmploymentObject;
use Illuminate\Database\QueryException;
class AssignsEmployee extends AbstractUpdateRecord
{
/**
* @param EmploymentObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws MalformedRequestException
*/
public function execute(EmploymentObject $object)
{
try {
$object->getCompany()->employees()->attach($object->getUser(), ['status' => $object->getStatus()]);
return $object->getCompany();
} catch (QueryException $exception){
throw new MalformedRequestException($exception);
}
}
}
@@ -0,0 +1,27 @@
<?php
namespace App\Classes\Modules\Companies\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Companies\DataTransferObjects\CompanyObject;
use App\Models\Company;
class CreatesCompany extends AbstractUpdateRecord
{
/**
* @param CompanyObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(CompanyObject $object)
{
$model = new Company();
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->type = $object->getType();
$model->business_type = $object->getBusinessType();
return $this->handler($model);
}
}
@@ -0,0 +1,54 @@
<?php
namespace App\Classes\Modules\Companies\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Companies\Standards\Validators\CompanyEmployeeValidation;
use App\Classes\Modules\Companies\DataTransferObjects\EmploymentObject;
class CanAssignEmployee extends AbstractRule
{
/** @var CompanyEmployeeValidation */
private $companyEmployeeValidation;
/**
* CanCreateCompanyEmployee constructor.
* @param CompanyEmployeeValidation $companyEmployeeValidation
*/
public function __construct(CompanyEmployeeValidation $companyEmployeeValidation)
{
$this->companyEmployeeValidation = $companyEmployeeValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param EmploymentObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->companyEmployeeValidation->validate($object);
}
/**
* @param EmploymentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Companies\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantObject;
use App\Classes\Modules\Segments\DataTransferObjects\ConstantObject;
class CanAssignSegment extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param ConstantObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param ConstantObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,51 @@
<?php
namespace App\Classes\Modules\Companies\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Companies\DataTransferObjects\CompanyObject;
use App\Classes\Modules\Companies\Standards\Validators\CompanyValidation;
class CanCreateCompany extends AbstractRule
{
/** @var CompanyValidation */
private $companyValidation;
/**
* CanCreateCompany constructor.
* @param CompanyValidation $companyValidation
*/
public function __construct(CompanyValidation $companyValidation)
{
$this->companyValidation = $companyValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param CompanyObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->companyValidation->validate($object);
}
/**
* @param CompanyObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\Companies\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Companies\DataTransferObjects\EmploymentObject;
class CompanyEmployeeValidation extends AbstractValidation
{
/**
* @param EmploymentObject $object
* @return array
*/
protected function data($object): array
{
return [
'company_id' => $object->getCompany()->id,
'user_id' => $object->getUser()->id,
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'company_id' => 'required',
'user_id' => 'required',
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,49 @@
<?php
namespace App\Classes\Modules\Companies\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Companies\DataTransferObjects\CompanyObject;
class CompanyValidation extends AbstractValidation
{
/**
* @param CompanyObject $object
* @return array
*/
protected function data($object): array
{
return [
'company_name' => $object->getName(),
'company_reference' => $object->getReference(),
'type' => $object->getBusinessType()
];
}
/**
* @param string $type
* @return array
*/
protected function rules(?string $type = 'POST'): array
{
if ($type == 'POST') {
return [
'company_name' => 'required',
'company_reference' => '',
'type' => ''
];
} elseif ($type == 'PUT') {
return [
'type' => 'required'
];
}
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,98 @@
<?php
namespace App\Classes\Modules\Contacts\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use App\Classes\ValueObjects\Constants\Countries;
class ContactObject implements DataTransferObject
{
/** @var int */
private $companyId;
/** @var string */
private $reference;
/** @var string|null */
private $phone;
/** @var string|null */
private $email;
/** @var string|null */
private $wechat_id;
/** @var int|null */
private $countryId;
/**
* ContactObject constructor.
* @param int $companyId
* @param string $reference
* @param null|string $phone
* @param null|string $email
* @param null|string $wechat_id
* @param int|null $countryId
*/
public function __construct(int $companyId, string $reference, ?string $phone, ?string $email, ?string $wechat_id, ?int $countryId = Countries::MALAYSIA)
{
$this->companyId = $companyId;
$this->reference = $reference;
$this->phone = $phone;
$this->email = $email;
$this->wechat_id = $wechat_id;
$this->countryId = $countryId;
}
/**
* @return int
*/
public function getCompanyId(): int
{
return $this->companyId;
}
/**
* @return string
*/
public function getReference(): string
{
return $this->reference;
}
/**
* @return null|string
*/
public function getPhone(): ?string
{
return $this->phone;
}
/**
* @return null|string
*/
public function getEmail(): ?string
{
return $this->email;
}
/**
* @return null|string
*/
public function getWechatId(): ?string
{
return $this->wechat_id;
}
/**
* @return int
*/
public function getCountryId(): int
{
return $this->countryId;
}
}
@@ -0,0 +1,55 @@
<?php
namespace App\Classes\Modules\Contacts\Processors;
use App\Classes\Modules\Contacts\DataTransferObjects\ContactObject;
use App\Classes\Modules\Contacts\Services\CreatesContact;
use App\Classes\Modules\Contacts\Standards\Rules\CanCreateContact;
use App\Models\Company;
use Illuminate\Http\Request;
use Illuminate\Database\Eloquent\Model;
class CreateContactProcessor
{
/** @var CanCreateContact */
private $canCreateContact;
/** @var CreatesContact */
private $createsContact;
/**
* CreateContactProcessor constructor.
* @param CanCreateContact $canCreateContact
* @param CreatesContact $createsContact
*/
public function __construct(CanCreateContact $canCreateContact, CreatesContact $createsContact)
{
$this->canCreateContact = $canCreateContact;
$this->createsContact = $createsContact;
}
/**
* @param Request $request
* @param Company $company
* @return Model
* @throws \App\Classes\Exceptions\AccessForbiddenException
* @throws \App\Classes\Exceptions\MalformedRequestException
* @throws \App\Classes\Exceptions\RequestValidationException
*/
public function execute(Request $request, Company $company): Model
{
$contact_object = new ContactObject(
$company->id,
$request->input('name'),
$request->input('phone'),
$request->input('contact_email'),
$request->input('wechat_id')
);
$this->canCreateContact->passes($contact_object);
return $this->createsContact->execute($contact_object);
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\Contacts\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Contacts\DataTransferObjects\ContactObject;
use App\Models\Contact;
class CreatesContact extends AbstractUpdateRecord
{
/**
* @param ContactObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(ContactObject $object)
{
$model = new Contact();
$model->country_id = $object->getCountryId();
$model->company_id = $object->getCompanyId();
$model->reference = $object->getReference();
$model->phone = $object->getPhone();
$model->email = $object->getEmail();
$model->wechat_id = $object->getWechatId();
return $this->handler($model);
}
}
@@ -0,0 +1,54 @@
<?php
namespace App\Classes\Modules\Contacts\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Contacts\DataTransferObjects\ContactObject;
use App\Classes\Modules\Contacts\Standards\Validators\ContactValidation;
class CanCreateContact extends AbstractRule
{
/** @var ContactValidation */
private $contactValidation;
/**
* CanCreateContact constructor.
* @param ContactValidation $contactValidation
*/
public function __construct(ContactValidation $contactValidation)
{
$this->contactValidation = $contactValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param ContactObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->contactValidation->validate($object);
}
/**
* @param ContactObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
@@ -0,0 +1,48 @@
<?php
namespace App\Classes\Modules\Contacts\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Contacts\DataTransferObjects\ContactObject;
class ContactValidation extends AbstractValidation
{
/**
* @param ContactObject $object
* @return array
*/
protected function data($object): array
{
return [
'country_id' => $object->getCountryId(),
'company_id' => $object->getCompanyId(),
'contact_reference' => $object->getReference(),
'phone' => $object->getPhone(),
'contact_email' => $object->getEmail(),
'wechat_id' => $object->getWechatId()
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'country_id' => 'required',
'company_id' => 'required',
'contact_reference' => '',
'phone' => 'required',
'contact_email' => '',
'wechat_id' => ''
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
@@ -0,0 +1,63 @@
<?php
namespace App\Classes\Modules\Countries\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use Rinvex\Country\Country;
class CountryObject implements DataTransferObject
{
/** @var Country */
private $country;
/**
* CountryObject constructor.
* @param Country $country
*/
public function __construct(Country $country)
{
$this->country = $country;
}
/**
* @return Country
*/
public function getCountry(): Country
{
return $this->country;
}
/**
* @return string
*/
public function getName(): string
{
return $this->getCountry()->getName();
}
/**
* @return string
*/
public function getShortCode(): string
{
return $this->getCountry()->getIsoAlpha2();
}
/**
* @return int
*/
public function getPhoneCode(): int
{
return $this->getCountry()->getCallingCode();
}
/**
* @return string
*/
public function getSvg(): string
{
return $this->getCountry()->getFlag();
}
}
@@ -0,0 +1,27 @@
<?php
namespace App\Classes\Modules\Countries\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Countries\DataTransferObjects\CountryObject;
use App\Models\Country;
class CreatesCountry extends AbstractUpdateRecord
{
/**
* @param CountryObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(CountryObject $object) {
$model = new Country();
return $model->firstOrCreate([
'name' => $object->getName(),
'short_code' => $object->getShortCode(),
'phone_code' => $object->getPhoneCode(),
]);
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Classes\Modules\Countries\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use App\Models\Country;
use Illuminate\Database\Eloquent\Builder;
class FetchesCountry extends AbstractFetchRecord
{
/** @var Country */
private $repository;
/**
* FetchesCurrency constructor.
* @param Country $repository
*/
public function __construct(Country $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,58 @@
<?php
namespace App\Classes\Modules\Currencies\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class CurrencyObject implements DataTransferObject
{
/** @var string */
private $name;
/** @var string */
private $short_code;
/** @var string|null */
private $symbol;
/**
* CurrencyObject constructor.
* @param string $name
* @param string $short_code
* @param null|string $symbol
*/
public function __construct(string $name, string $short_code, ?string $symbol = null)
{
$this->name = $name;
$this->short_code = $short_code;
$this->symbol = $symbol;
}
/**
* @return string
*/
public function getName(): string
{
return $this->name;
}
/**
* @return string
*/
public function getShortCode(): string
{
return $this->short_code;
}
/**
* @return null|string
*/
public function getSymbol(): ?string
{
return $this->symbol;
}
}
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\Currencies\Services;
use App\Classes\General\Eloquent\AbstractUpdateRelationshipRecord;
use App\Classes\Modules\Currencies\DataTransferObjects\CurrencyObject;
use App\Models\Country;
use App\Models\Currency;
class CreatesCurrency extends AbstractUpdateRelationshipRecord
{
/**
* @param Country $country
* @param CurrencyObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Country $country, CurrencyObject $object) {
$model = new Currency();
$model->name = $object->getName();
$model->short_code = $object->getShortCode();
$model->symbol = $object->getSymbol();
return $this->handler($country->currencies(), $model);
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Classes\Modules\Currencies\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\Currency;
class FetchesCurrency extends AbstractFetchRecord
{
/** @var Currency */
private $repository;
/**
* FetchesCurrency constructor.
* @param Currency $repository
*/
public function __construct(Currency $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,57 @@
<?php
namespace App\Classes\Modules\Segments\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
class ConstantObject implements DataTransferObject
{
/** @var string */
private $name;
/** @var string */
private $reference;
/** @var array */
private $detail;
/**
* ConstantObject constructor.
* @param string $name
* @param string $reference
* @param array $detail
*/
public function __construct(string $name, string $reference, array $detail)
{
$this->name = $name;
$this->reference = $reference;
$this->detail = $detail;
}
/**
* @return string
*/
public function getName(): string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): string
{
return $this->reference;
}
/**
* @return array
*/
public function getDetail(): array
{
return $this->detail;
}
}
@@ -0,0 +1,27 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractUpdateRelationshipRecord;
use App\Classes\Modules\Segments\DataTransferObjects\ConstantObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesConstant extends AbstractUpdateRelationshipRecord
{
/**
* @param Segment $segment
* @param ConstantObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, ConstantObject $object)
{
$model = new SegmentConstant();
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode($object->getDetail());
return $this->handler($segment->constants(), $model);
}
}
@@ -0,0 +1,34 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\Segment;
class FetchesSegment extends AbstractFetchRecord
{
/** @var Segment */
private $repository;
/**
* FetchesSegment constructor.
* @param Segment $repository
*/
public function __construct(Segment $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
@@ -0,0 +1,71 @@
<?php
namespace App\Classes\Modules\ServiceTypes\DataTransferObjects;
use App\Classes\General\Interfaces\DataTransferObject;
use App\Classes\Modules\ServiceTypes\Services\FetchesServiceCurrenciesConfigurations;
use App\Classes\ValueObjects\Constants\SegmentConstants;
use App\Models\SegmentConstant;
use App\Models\ServiceType;
use Illuminate\Support\Collection;
class ServiceConfigurationsObject implements DataTransferObject
{
/** @var ServiceType */
private $service;
/** @var SegmentConstant */
private $configurations;
/** @var Collection */
private $customOptions;
/**
* ServiceConfigurationsObject constructor.
* @param ServiceType $service
* @param SegmentConstant $configurations
* @param Collection $customOptions
*/
public function __construct(ServiceType $service, SegmentConstant $configurations, Collection $customOptions)
{
$this->service = $service;
$this->configurations = $configurations;
$this->customOptions = $customOptions;
}
/**
* @return ServiceType
*/
public function getService(): ServiceType
{
return $this->service;
}
/**
* @return SegmentConstant
*/
public function getConfigurations(): SegmentConstant
{
return $this->configurations;
}
/**
* @return Collection
*/
public function getCustomOptions(): Collection
{
return $this->customOptions->map(function($value){
return new CustomConfigurationsObject($this->getConfigurations(), $value);
});
}
public function getBaseCurrencyRates(){
return (App()->make(FetchesServiceCurrenciesConfigurations::class))->execute($this->configurations, SegmentConstants::SERVICE_TYPE);
}
}
@@ -0,0 +1,38 @@
<?php
namespace App\Classes\Notifications;
use App\Models\PasswordReset;
use App\Models\User;
use Illuminate\Notifications\Messages\MailMessage;
class ResetPasswordEmail extends AbstractEmail
{
/** @var User */
private $user;
/** @var PasswordReset */
private $attempt;
/**
* SendResetPasswordEmail constructor.
* @param User $user
* @param PasswordReset $attempt
*/
public function __construct(User $user, PasswordReset $attempt)
{
$this->user = $user;
$this->attempt = $attempt;
}
public function toMail()
{
return (new MailMessage)
->subject('Reset Password')
->view('emails.accounts.reset_password', ['user' => $this->user, 'attempt' => $this->attempt]);
}
}
@@ -0,0 +1,39 @@
<?php
namespace App\Classes\Notifications;
use App\Models\User;
use App\Models\UserEmailVerification;
use Illuminate\Notifications\Messages\MailMessage;
class UserVerificationEmail extends AbstractEmail
{
/** @var User */
private $user;
/** @var UserEmailVerification */
private $attempt;
/**
* UserVerificationEmail constructor.
* @param User $user
* @param UserEmailVerification $attempt
*/
public function __construct(User $user, UserEmailVerification $attempt)
{
$this->user = $user;
$this->attempt = $attempt;
}
public function toMail()
{
return (new MailMessage)
->subject('Email Verification')
->view('emails.accounts.user_verification', ['user' => $this->user, 'attempt' => $this->attempt]);
}
}
@@ -0,0 +1,19 @@
<?php
namespace App\Classes\ValueObjects\Constants;
final class RoleTypes
{
public const SHADOW_ADMIN = 0;
public const SUPER_ADMIN = 1;
public const ADMIN = 2;
public const ADMIN_ROLES = [self::SHADOW_ADMIN, self::SUPER_ADMIN, self::ADMIN];
public const USER = 3;
}
@@ -0,0 +1,23 @@
<?php
namespace App\Classes\ValueObjects\Constants;
class SegmentConstants
{
public const STANDARD_SEGMENT = 1;
public const CUSTOM_SEGMENT = 2;
public const SYSTEM_PRIMARY_CURRENCY = 'SYSTEM_PRIMARY_CURRENCY';
public const SUPPLIER_CURRENCIES = 'SUPPLIER_CURRENCIES';
public const PAYMENT_ATTEMPT_DURATION_LIMIT = 'PAYMENT_ATTEMPT_DURATION_LIMIT';
public const SERVICE_TYPE = 'SERVICE_TYPE';
public const CUSTOM_SERVICE_TYPE = 'CUSTOM_SERVICE_TYPE';
}
@@ -0,0 +1,21 @@
<?php
namespace App\Http\Controllers\Accounts;
use App\Classes\Modules\Accounts\ControllersLogic\CheckEmailLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CheckEmailController
{
/**
* @param Request $request
* @param CheckEmailLogic $logic
* @return JsonResponse
*/
public function check(Request $request, CheckEmailLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
@@ -0,0 +1,22 @@
<?php
namespace App\Http\Controllers\Accounts;
use App\Classes\Modules\Accounts\ControllersLogic\CreateAdminUserLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CreateAdminUserController
{
/**
* @param Request $request
* @param CreateAdminUserLogic $logic
* @return JsonResponse
*/
public function create(Request $request, CreateAdminUserLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\Accounts;
use App\Classes\Modules\Accounts\ControllersLogic\CreateCustomerLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CreateCustomerController
{
/**
* @param Request $request
* @param CreateCustomerLogic $logic
* @return JsonResponse
*/
public function create(Request $request, CreateCustomerLogic $createCustomerLogic): JsonResponse
{
return $createCustomerLogic->execute($request);
}
}

Some files were not shown because too many files have changed in this diff Show More