cief/exchange-2.0
1
0
Fork 0
mirror of https://gitlab.com/CIEFWorldwideSdnBhd/exchange-2.0.git synced 2026-08-19 04:23:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'document' into 'master'

Browse Source 
Document

See merge request CIEFWorldwideSdnBhd/exchange-2.0!3
This commit is contained in:
omair saleh
2020-11-18 13:42:28 +00:00
parent c13b2f1e23 98b354d6b2
commit 9daca7efb1
90 changed files with 3763 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/Classes/General/Eloquent/Filters/SegmentId.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Classes\General\Eloquent\Filters;
use Illuminate\Database\Eloquent\Builder;
class SegmentId implements Filter
{
/**
* @param Builder $builder
* @param $value
* @return Builder|mixed
*/
public static function apply(Builder $builder, $value)
{
return $builder->where('segment_id', $value);
}
}
app/Classes/Modules/Accounts/ControllerLogic/CreateUserLogic.php
+27 -5
View File
@@ -12,17 +12,18 @@ use App\Http\Resources\UserResource;
use App\Classes\Modules\Companies\Standards\Rules\CanCreateCompany;
use App\Classes\Modules\Companies\Services\CreatesCompany;
use App\Classes\Modules\Companies\DataTransferObjects\CompanyObject;
use App\Http\Resources\CompanyResource;
use App\Classes\Modules\Contacts\Standards\Rules\CanCreateContact;
use App\Classes\Modules\Contacts\Services\CreatesContact;
use App\Classes\Modules\Contacts\DataTransferObjects\ContactObject;
use App\Http\Resources\ContactResource;
use App\Classes\Modules\CompanyEmployees\Standards\Rules\CanCreateCompanyEmployee;
use App\Classes\Modules\CompanyEmployees\Services\CreatesCompanyEmployee;
use App\Classes\Modules\CompanyEmployees\DataTransferObjects\CompanyEmployeeObject;
use App\Http\Resources\CompanyEmployeeResource;
use App\Classes\Modules\SegmentCompanies\Standards\Rules\CanCreateSegmentCompany;
use App\Classes\Modules\SegmentCompanies\Services\CreatesSegmentCompany;
use App\Classes\Modules\SegmentCompanies\DataTransferObjects\SegmentCompanyObject;
use ErrorException;
use Illuminate\Http\JsonResponse;
@@ -65,6 +66,12 @@ class CreateUserLogic extends AbstractControllerLogic
/** @var CreatesCompanyEmployee */
private $createsCompanyEmployee;
/** @var CanCreateSegmentCompany */
private $canCreateSegmentCompany;
/** @var CreatesSegmentCompany */
private $createsSegmentCompany;
/**
* CreateUserControllerLogic constructor.
* @param CanCreateUser $canCreateUser
@@ -75,6 +82,8 @@ class CreateUserLogic extends AbstractControllerLogic
* @param CreatesContact $createsContact
* @param CanCreateCompanyEmployee $canCreateCompanyEmployee
* @param CreatesCompanyEmployee $createsCompanyEmployee
* @param CanCreateSegmentCompany $canCreateSegmentCompany
* @param CreatesSegmentCompany $createsSegmentCompany
*/
public function __construct(
CanCreateUser $canCreateUser,
@@ -84,7 +93,9 @@ class CreateUserLogic extends AbstractControllerLogic
CanCreateContact $canCreateContact,
CreatesContact $createsContact,
CanCreateCompanyEmployee $canCreateCompanyEmployee,
CreatesCompanyEmployee $createsCompanyEmployee
CreatesCompanyEmployee $createsCompanyEmployee,
CanCreateSegmentCompany $canCreateSegmentCompany,
CreatesSegmentCompany $createsSegmentCompany
)
{
$this->canCreateUser = $canCreateUser;
@@ -95,6 +106,8 @@ class CreateUserLogic extends AbstractControllerLogic
$this->createsContact = $createsContact;
$this->canCreateCompanyEmployee = $canCreateCompanyEmployee;
$this->createsCompanyEmployee = $createsCompanyEmployee;
$this->canCreateSegmentCompany = $canCreateSegmentCompany;
$this->createsSegmentCompany = $createsSegmentCompany;
}
/**
@@ -140,7 +153,6 @@ class CreateUserLogic extends AbstractControllerLogic
$this->canCreateContact->passes($contact_object);
$contact_query = $this->createsContact->execute($contact_object);
$company_employee_object = new CompanyEmployeeObject(
$company_query->id,
$user_query->id
@@ -149,11 +161,21 @@ class CreateUserLogic extends AbstractControllerLogic
$this->canCreateCompanyEmployee->passes($company_employee_object);
$company_employee_query = $this->createsCompanyEmployee->execute($user_query, $company_employee_object);
$segment_company_object = new SegmentCompanyObject(
1,
$company_query->id
);
$this->canCreateSegmentCompany->passes($segment_company_object);
$segment_company_query = $this->createsSegmentCompany->execute($company_query, $segment_company_object);
DB::commit();
return $this->resourceResponse(new UserResource($user_query));
} catch (\Exception $exception) {
dd($exception);
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
app/Classes/Modules/Documents/ControllerLogic/ApproveDocumentLogic.php
+97
View File
@@ -0,0 +1,97 @@
<?php
namespace App\Classes\Modules\Documents\ControllersLogic;
use App\Http\Resources\DocumentResource;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Documents\Services\FetchesDocument;
use App\Classes\Modules\Documents\Standards\Rules\CanUpdateDocument;
use App\Classes\Modules\Documents\Services\ApprovesDocument;
use App\Classes\Modules\Documents\DataTransferObjects\DocumentObject;
use App\Classes\ValueObjects\Constants\ObjectStatus;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class ApproveDocumentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Approve Document',
'message' => 'You have successfully approved the Document'
];
}
/** @var CanUpdateDocument */
private $canUpdateDocument;
/** @var ApprovesDocument */
private $approvesDocument;
/** @var FetchesDocument */
private $fetchesDocument;
/**
* UpdateStandardSegmentConstantLogic constructor.
* @param CanUpdateDocument $canUpdateDocument
* @param ApprovesDocument $approvesDocument
* @param FetchesDocument $fetchesDocument
*/
public function __construct(
canUpdateDocument $canUpdateDocument,
ApprovesDocument $approvesDocument,
FetchesDocument $fetchesDocument
)
{
$this->canUpdateDocument = $canUpdateDocument;
$this->approvesDocument = $approvesDocument;
$this->fetchesDocument = $fetchesDocument;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$document_query = $this->fetchesDocument->execute(['id' => $request->route('id')]);
$document_object = new DocumentObject(
$document_query->owner_id,
$document_query->owner_type,
$document_query->document_type,
$document_query->reference,
ObjectStatus::ACTIVE,
\Auth::user()->id,
$document_query->issued_date,
$document_query->expired_date,
$document_query->approved_date
);
$this->canUpdateDocument->passes($document_object);
$document_query = $this->approvesDocument->execute($document_query, $document_object);
DB::commit();
return $this->resourceResponse(new DocumentResource($document_query));
} catch (\Exception $exception){
dd($exception);
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Documents/ControllerLogic/ListDocumentLogic.php
+82
View File
@@ -0,0 +1,82 @@
<?php
namespace App\Classes\Modules\Documents\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Documents\Services\ListsDocuments;
use App\Classes\Modules\Documents\Standards\Rules\CanListDocuments;
use App\Http\Resources\DocumentResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListDocumentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Retrieved Document',
'message' => 'You have successfully retrieved a list of Document'
];
}
/** @var CanListDocuments */
private $canListDocuments;
/** @var ListsDocuments */
private $listsDocuments;
/**
* ListStandardSegmentLogic constructor.
* @param CanListDocuments $canListDocuments
* @param ListsDocuments $listsDocuments
*/
public function __construct(CanListDocuments $canListDocuments, ListsDocuments $listsDocuments)
{
$this->canListDocuments = $canListDocuments;
$this->listsDocuments = $listsDocuments;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
$document_type = $request->input('document_type');
$reference = $request->input('reference');
$status = $request->input('status');
$data = [];
if ($document_type) {
$data['document_type'] = $document_type;
}
if ($reference) {
$data['reference'] = $reference;
}
if ($status) {
$data['status'] = $status;
}
$this->canListDocuments->passes();
$query = $this->listsDocuments->execute($data);
return $this->collectionResponse(DocumentResource::collection($query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Documents/Services/ApprovesDocument.php
+23
View File
@@ -0,0 +1,23 @@
<?php
namespace App\Classes\Modules\Documents\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Documents\DataTransferObjects\DocumentObject;
use App\Models\Document;
class ApprovesDocument extends AbstractUpdateRecord
{
/**
* @param DocumentObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Document $model, DocumentObject $object)
{
$model->status = $object->getStatus();
$model->approved_by = $object->getApprovedBy();
return $this->handler($model);
}
}
app/Classes/Modules/Documents/Services/FetchesDocument.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Documents\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\Document;
class FetchesDocument extends AbstractFetchRecord
{
/** @var Document */
private $repository;
/**
* FetchesUser constructor.
* @param Document $repository
*/
public function __construct(Document $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/Documents/Services/ListsDocuments.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Documents\Services;
use App\Classes\General\Eloquent\AbstractListRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\Document;
class ListsDocuments extends AbstractListRecord
{
/** @var Document */
private $repository;
/**
* ListsDocuments constructor.
* @param Document $repository
*/
public function __construct(Document $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/Documents/Standards/Rules/CanListDocuments.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace App\Classes\Modules\Documents\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Documents\DataTransferObjects\DocumentObject;
class CanListDocuments extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('view document')) {
return false;
}
return true;
}
/**
* @param DocumentObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param DocumentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/Documents/Standards/Rules/CanUpdateDocument.php
+53
View File
@@ -0,0 +1,53 @@
<?php
namespace App\Classes\Modules\Documents\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Documents\DataTransferObjects\DocumentObject;
use App\Classes\Modules\Documents\Standards\Validators\DocumentValidation;
class CanUpdateDocument extends AbstractRule
{
/** @var DocumentValidation */
private $documentValidation;
/**
* CanCreateAddress constructor.
* @param DocumentValidation $documentValidation
*/
public function __construct(DocumentValidation $documentValidation)
{
$this->documentValidation = $documentValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param DocumentObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->documentValidation->validate($object);
}
/**
* @param DocumentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/SegmentCompanies/DataTransferObjects/SegmentCompanyObject.php
+44
View File
@@ -0,0 +1,44 @@
<?php
namespace App\Classes\Modules\SegmentCompanies\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentCompanyObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var int|null */
private $company_id;
/**
* CompanyObject constructor.
* @param int|null $segment_id
* @param int|null $company_id
*/
public function __construct(
?int $segment_id,
?int $company_id
)
{
$this->segment_id = $segment_id;
$this->company_id = $company_id;
}
/**
* @return int|null
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return int|null
*/
public function getCompanyId(): ?int
{
return $this->company_id;
}
}
app/Classes/Modules/SegmentCompanies/Services/CreatesSegmentCompany.php
+21
View File
@@ -0,0 +1,21 @@
<?php
namespace App\Classes\Modules\SegmentCompanies\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentCompanies\DataTransferObjects\SegmentCompanyObject;
use App\Models\Company;
class CreatesSegmentCompany extends AbstractUpdateRecord
{
/**
* @param SegmentCompanyObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Company $model, SegmentCompanyObject $object)
{
$model->segment()->sync($object->getSegmentId());
return $model;
}
}
app/Classes/Modules/SegmentCompanies/Standards/Rules/CanCreateSegmentCompany.php
+53
View File
@@ -0,0 +1,53 @@
<?php
namespace App\Classes\Modules\SegmentCompanies\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\SegmentCompanies\DataTransferObjects\SegmentCompanyObject;
use App\Classes\Modules\SegmentCompanies\Standards\Validators\SegmentCompanyValidation;
class CanCreateSegmentCompany extends AbstractRule
{
/** @var SegmentCompanyValidation */
private $segmentCompanyValidation;
/**
* CanCreateAddress constructor.
* @param SegmentCompanyValidation $segmentCompanyValidation
*/
public function __construct(SegmentCompanyValidation $segmentCompanyValidation)
{
$this->segmentCompanyValidation = $segmentCompanyValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
return true;
}
/**
* @param SegmentCompanyValidation $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->segmentCompanyValidation->validate($object);
}
/**
* @param SegmentCompanyValidation $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/SegmentCompanies/Standards/Validators/SegmentCompanyValidation.php
+40
View File
@@ -0,0 +1,40 @@
<?php
namespace App\Classes\Modules\SegmentCompanies\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\SegmentCompanies\DataTransferObjects\CompanyEmployeeObject;
class SegmentCompanyValidation extends AbstractValidation
{
/**
* @param CompanyEmployeeObject $object
* @return array
*/
protected function data($object): array
{
return [
'segment_id' => $object->getSegmentId(),
'company_id' => $object->getCompanyId(),
];
}
/**
* @return array
*/
protected function rules(): array
{
return [
'segment_id' => 'required',
'company_id' => 'required',
];
}
/**
* @return array
*/
protected function messages(): array
{
return [];
}
}
app/Classes/Modules/SegmentConstants/ControllerLogic/CreateSegmentConstantLogic.php
+187
View File
@@ -0,0 +1,187 @@
<?php
namespace App\Classes\Modules\SegmentConstants\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\SegmentConstants\Services\FetchesSegmentConstant;
use App\Classes\Modules\Segments\Services\FetchesSegment;
use App\Classes\Modules\SegmentConstants\Standards\Rules\CanCreateSegmentConstant;
use App\Classes\Modules\SegmentConstants\Services\CreatesSegmentConstantTax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantTaxObject;
use App\Classes\Modules\SegmentConstants\Services\CreatesSegmentConstantBillingFee;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBillingFeeObject;
use App\Classes\Modules\SegmentConstants\Services\CreatesSegmentConstantServiceCharge;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantServiceChargeObject;
use App\Classes\Modules\SegmentConstants\Services\CreatesSegmentConstantBookingAmountMax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBookingAmountMaxObject;
use App\Classes\Modules\SegmentConstants\Services\CreatesSegmentConstantPaymentAttemptExpiryTime;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantPaymentAttemptExpiryTimeObject;
use App\Http\Resources\SegmentConstantResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class CreateSegmentConstantLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Created Segment Constant',
'message' => 'You have successfully created a new Segment Constant'
];
}
/** @var CanCreateSegmentConstant */
private $canCreateSegmentConstant;
/** @var CreatesSegmentConstantTax */
private $createsSegmentConstantTax;
/** @var CreatesSegmentConstantBillingFee */
private $createsSegmentConstantBillingFee;
/** @var CreatesSegmentConstantServiceCharge */
private $createsSegmentConstantServiceCharge;
/** @var CreatesSegmentConstantBookingAmountMax */
private $createsSegmentConstantBookingAmountMax;
/** @var CreatesSegmentConstantPaymentAttemptExpiryTime */
private $createsSegmentConstantPaymentAttemptExpiryTime;
/** @var FetchesSegmentConstant */
private $fetchesSegmentConstant;
/** @var FetchesSegment */
private $fetchesSegment;
/**
* CreateSegmentConstantLogic constructor.
* @param CanCreateSegmentConstant $canCreateSegmentConstant
* @param CreatesSegmentConstantTax $createsSegmentConstantTax
* @param CreatesSegmentConstantBillingFee $createsSegmentConstantBillingFee
* @param CreatesSegmentConstantServiceCharge $createsSegmentConstantServiceCharge
* @param CreatesSegmentConstantBookingAmountMax $createsSegmentConstantBookingAmountMax
* @param CreatesSegmentConstantPaymentAttemptExpiryTime $createsSegmentConstantPaymentAttemptExpiryTime
* @param FetchesSegmentConstant $fetchesSegmentConstant
* @param FetchesSegment $fetchesSegment
*/
public function __construct(
CanCreateSegmentConstant $canCreateSegmentConstant,
CreatesSegmentConstantTax $createsSegmentConstantTax,
CreatesSegmentConstantBillingFee $createsSegmentConstantBillingFee,
CreatesSegmentConstantServiceCharge $createsSegmentConstantServiceCharge,
CreatesSegmentConstantBookingAmountMax $createsSegmentConstantBookingAmountMax,
CreatesSegmentConstantPaymentAttemptExpiryTime $createsSegmentConstantPaymentAttemptExpiryTime,
FetchesSegmentConstant $fetchesSegmentConstant,
FetchesSegment $fetchesSegment
)
{
$this->canCreateSegmentConstant = $canCreateSegmentConstant;
$this->createsSegmentConstantTax = $createsSegmentConstantTax;
$this->createsSegmentConstantBillingFee = $createsSegmentConstantBillingFee;
$this->createsSegmentConstantServiceCharge = $createsSegmentConstantServiceCharge;
$this->createsSegmentConstantBookingAmountMax = $createsSegmentConstantBookingAmountMax;
$this->createsSegmentConstantPaymentAttemptExpiryTime = $createsSegmentConstantPaymentAttemptExpiryTime;
$this->fetchesSegmentConstant = $fetchesSegmentConstant;
$this->fetchesSegment = $fetchesSegment;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_query = $this->fetchesSegment->execute([
'id' => $request->input('segment_id'),
]);
$segment_constant_query = $this->fetchesSegmentConstant->execute([
'id' => $request->input('standard_segment_constant_id'),
]);
if ($segment_constant_query->reference == 'TAX') {
$segment_constant_object = new SegmentConstantTaxObject(
$request->input('segment_id'),
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canCreateSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->createsSegmentConstantTax->execute($segment_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BILLING_FEE') {
$segment_constant_object = new SegmentConstantBillingFeeObject(
$request->input('segment_id'),
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canCreateSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->createsSegmentConstantBillingFee->execute($segment_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'SERVICE_CHARGE') {
$segment_constant_object = new SegmentConstantServiceChargeObject(
$request->input('segment_id'),
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canCreateSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->createsSegmentConstantServiceCharge->execute($segment_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BOOKING_AMOUNT_MAX') {
$segment_constant_object = new SegmentConstantBookingAmountMaxObject(
$request->input('segment_id'),
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value'),
$segment_constant_query->detail->currency_id
);
$this->canCreateSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->createsSegmentConstantBookingAmountMax->execute($segment_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'PAYMENT_ATTEMP_EXPIRY_TIME') {
$segment_constant_object = new SegmentConstantPaymentAttemptExpiryTimeObject(
$request->input('segment_id'),
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canCreateSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->createsSegmentConstantPaymentAttemptExpiryTime->execute($segment_query, $segment_constant_object);
}
DB::commit();
return $this->resourceResponse(new SegmentConstantResource($segment_constant_query));
} catch (\Exception $exception) {
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/SegmentConstants/ControllerLogic/ListStandardSegmentConstantLogic.php
+69
View File
@@ -0,0 +1,69 @@
<?php
namespace App\Classes\Modules\SegmentConstants\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\SegmentConstants\Services\ListsSegmentConstants;
use App\Classes\Modules\SegmentConstants\Standards\Rules\CanListStandardSegmentConstants;
use App\Http\Resources\SegmentResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListStandardSegmentConstantLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Retrieved Standard Segment Constant',
'message' => 'You have successfully retrieved a list of Standard Segment Constant'
];
}
/** @var CanListStandardSegmentConstants */
private $canListStandardSegmentConstants;
/** @var ListsSegmentConstants */
private $listsSegmentConstants;
/**
* ListStandardSegmentConstantLogic constructor.
* @param CanListStandardSegmentConstants $canListStandardSegmentConstants
* @param ListsSegmentConstants $listsSegmentConstants
*/
public function __construct(CanListStandardSegmentConstants $canListStandardSegmentConstants, ListsSegmentConstants $listsSegmentConstants)
{
$this->canListStandardSegmentConstants = $canListStandardSegmentConstants;
$this->listsSegmentConstants = $listsSegmentConstants;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
$this->canListStandardSegmentConstants->passes();
$query = $this->listsSegmentConstants->execute(
[
'segment_id' => 1
]
);
return $this->collectionResponse(SegmentResource::collection($query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/SegmentConstants/ControllerLogic/UpdateSegmentConstantLogic.php
+175
View File
@@ -0,0 +1,175 @@
<?php
namespace App\Classes\Modules\SegmentConstants\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\SegmentConstants\Services\FetchesSegmentConstant;
use App\Classes\Modules\SegmentConstants\Standards\Rules\CanUpdateStandardSegmentConstant;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantTax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantTaxObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantBillingFee;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBillingFeeObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantServiceCharge;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantServiceChargeObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantBookingAmountMax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBookingAmountMaxObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantPaymentAttemptExpiryTime;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantPaymentAttemptExpiryTimeObject;
use App\Http\Resources\SegmentConstantResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class UpdateSegmentConstantLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Updated Segment Constant',
'message' => 'You have successfully updated the Segment Constant'
];
}
/** @var CanUpdateStandardSegmentConstant */
private $canUpdateStandardSegmentConstant;
/** @var UpdatesSegmentConstantTax */
private $updatesSegmentConstantTax;
/** @var UpdatesSegmentConstantBillingFee */
private $updatesSegmentConstantBillingFee;
/** @var UpdatesSegmentConstantServiceCharge */
private $updatesSegmentConstantServiceCharge;
/** @var UpdatesSegmentConstantBookingAmountMax */
private $updatesSegmentConstantBookingAmountMax;
/** @var UpdatesSegmentConstantPaymentAttemptExpiryTime */
private $updatesSegmentConstantPaymentAttemptExpiryTime;
/** @var FetchesSegmentConstant */
private $fetchesSegmentConstant;
/**
* UpdateStandardSegmentConstantLogic constructor.
* @param CanUpdateStandardSegmentConstant $canUpdateStandardSegmentConstant
* @param UpdatesSegmentConstantTax $updatesSegmentConstantTax
* @param UpdatesSegmentConstantBillingFee $updatesSegmentConstantBillingFee
* @param UpdatesSegmentConstantServiceCharge $updatesSegmentConstantServiceCharge
* @param UpdatesSegmentConstantBookingAmountMax $updatesSegmentConstantBookingAmountMax
* @param UpdatesSegmentConstantPaymentAttemptExpiryTime $updatesSegmentConstantPaymentAttemptExpiryTime
* @param FetchesSegmentConstant $fetchesSegmentConstant
*/
public function __construct(
CanUpdateStandardSegmentConstant $canUpdateStandardSegmentConstant,
UpdatesSegmentConstantTax $updatesSegmentConstantTax,
UpdatesSegmentConstantBillingFee $updatesSegmentConstantBillingFee,
UpdatesSegmentConstantServiceCharge $updatesSegmentConstantServiceCharge,
UpdatesSegmentConstantBookingAmountMax $updatesSegmentConstantBookingAmountMax,
UpdatesSegmentConstantPaymentAttemptExpiryTime $updatesSegmentConstantPaymentAttemptExpiryTime,
FetchesSegmentConstant $fetchesSegmentConstant
)
{
$this->canUpdateStandardSegmentConstant = $canUpdateStandardSegmentConstant;
$this->updatesSegmentConstantTax = $updatesSegmentConstantTax;
$this->updatesSegmentConstantBillingFee = $updatesSegmentConstantBillingFee;
$this->updatesSegmentConstantServiceCharge = $updatesSegmentConstantServiceCharge;
$this->updatesSegmentConstantBookingAmountMax = $updatesSegmentConstantBookingAmountMax;
$this->updatesSegmentConstantPaymentAttemptExpiryTime = $updatesSegmentConstantPaymentAttemptExpiryTime;
$this->fetchesSegmentConstant = $fetchesSegmentConstant;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_constant_query = $this->fetchesSegmentConstant->execute(['id' => $request->route('id')]);
if ($segment_constant_query->reference == 'TAX') {
$segment_constant_object = new SegmentConstantTaxObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantTax->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BILLING_FEE') {
$segment_constant_object = new SegmentConstantBillingFeeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantBillingFee->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'SERVICE_CHARGE') {
$segment_constant_object = new SegmentConstantServiceChargeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantServiceCharge->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BOOKING_AMOUNT_MAX') {
$segment_constant_object = new SegmentConstantBookingAmountMaxObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value'),
$segment_constant_query->detail->currency_id
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantBookingAmountMax->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'PAYMENT_ATTEMP_EXPIRY_TIME') {
$segment_constant_object = new SegmentConstantPaymentAttemptExpiryTimeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantPaymentAttemptExpiryTime->execute($segment_constant_query, $segment_constant_object);
}
DB::commit();
return $this->resourceResponse(new SegmentConstantResource($segment_constant_query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/SegmentConstants/ControllerLogic/UpdateStandardSegmentConstantLogic.php
+175
View File
@@ -0,0 +1,175 @@
<?php
namespace App\Classes\Modules\SegmentConstants\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\SegmentConstants\Services\FetchesSegmentConstant;
use App\Classes\Modules\SegmentConstants\Standards\Rules\CanUpdateStandardSegmentConstant;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantTax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantTaxObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantBillingFee;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBillingFeeObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantServiceCharge;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantServiceChargeObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantBookingAmountMax;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBookingAmountMaxObject;
use App\Classes\Modules\SegmentConstants\Services\UpdatesSegmentConstantPaymentAttemptExpiryTime;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantPaymentAttemptExpiryTimeObject;
use App\Http\Resources\SegmentConstantResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class UpdateStandardSegmentConstantLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Updated Standard Segment Constant',
'message' => 'You have successfully updated the Standard Segment Constant'
];
}
/** @var CanUpdateStandardSegmentConstant */
private $canUpdateStandardSegmentConstant;
/** @var UpdatesSegmentConstantTax */
private $updatesSegmentConstantTax;
/** @var UpdatesSegmentConstantBillingFee */
private $updatesSegmentConstantBillingFee;
/** @var UpdatesSegmentConstantServiceCharge */
private $updatesSegmentConstantServiceCharge;
/** @var UpdatesSegmentConstantBookingAmountMax */
private $updatesSegmentConstantBookingAmountMax;
/** @var UpdatesSegmentConstantPaymentAttemptExpiryTime */
private $updatesSegmentConstantPaymentAttemptExpiryTime;
/** @var FetchesSegmentConstant */
private $fetchesSegmentConstant;
/**
* UpdateStandardSegmentConstantLogic constructor.
* @param CanUpdateStandardSegmentConstant $canUpdateStandardSegmentConstant
* @param UpdatesSegmentConstantTax $updatesSegmentConstantTax
* @param UpdatesSegmentConstantBillingFee $updatesSegmentConstantBillingFee
* @param UpdatesSegmentConstantServiceCharge $updatesSegmentConstantServiceCharge
* @param UpdatesSegmentConstantBookingAmountMax $updatesSegmentConstantBookingAmountMax
* @param UpdatesSegmentConstantPaymentAttemptExpiryTime $updatesSegmentConstantPaymentAttemptExpiryTime
* @param FetchesSegmentConstant $fetchesSegmentConstant
*/
public function __construct(
CanUpdateStandardSegmentConstant $canUpdateStandardSegmentConstant,
UpdatesSegmentConstantTax $updatesSegmentConstantTax,
UpdatesSegmentConstantBillingFee $updatesSegmentConstantBillingFee,
UpdatesSegmentConstantServiceCharge $updatesSegmentConstantServiceCharge,
UpdatesSegmentConstantBookingAmountMax $updatesSegmentConstantBookingAmountMax,
UpdatesSegmentConstantPaymentAttemptExpiryTime $updatesSegmentConstantPaymentAttemptExpiryTime,
FetchesSegmentConstant $fetchesSegmentConstant
)
{
$this->canUpdateStandardSegmentConstant = $canUpdateStandardSegmentConstant;
$this->updatesSegmentConstantTax = $updatesSegmentConstantTax;
$this->updatesSegmentConstantBillingFee = $updatesSegmentConstantBillingFee;
$this->updatesSegmentConstantServiceCharge = $updatesSegmentConstantServiceCharge;
$this->updatesSegmentConstantBookingAmountMax = $updatesSegmentConstantBookingAmountMax;
$this->updatesSegmentConstantPaymentAttemptExpiryTime = $updatesSegmentConstantPaymentAttemptExpiryTime;
$this->fetchesSegmentConstant = $fetchesSegmentConstant;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_constant_query = $this->fetchesSegmentConstant->execute(['id' => $request->route('id')]);
if ($segment_constant_query->reference == 'TAX') {
$segment_constant_object = new SegmentConstantTaxObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantTax->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BILLING_FEE') {
$segment_constant_object = new SegmentConstantBillingFeeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantBillingFee->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'SERVICE_CHARGE') {
$segment_constant_object = new SegmentConstantServiceChargeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantServiceCharge->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'BOOKING_AMOUNT_MAX') {
$segment_constant_object = new SegmentConstantBookingAmountMaxObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value'),
$segment_constant_query->detail->currency_id
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantBookingAmountMax->execute($segment_constant_query, $segment_constant_object);
}
elseif ($segment_constant_query->reference == 'PAYMENT_ATTEMP_EXPIRY_TIME') {
$segment_constant_object = new SegmentConstantPaymentAttemptExpiryTimeObject(
$segment_constant_query->segment_id,
$segment_constant_query->name,
$segment_constant_query->reference,
$segment_constant_query->detail->type,
$request->input('value')
);
$this->canUpdateStandardSegmentConstant->passes($segment_constant_object);
$segment_constant_query = $this->updatesSegmentConstantPaymentAttemptExpiryTime->execute($segment_constant_query, $segment_constant_object);
}
DB::commit();
return $this->resourceResponse(new SegmentConstantResource($segment_constant_query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/SegmentConstants/DataTransferObjects/SegmentConstantBillingFeeObject.php
+86
View File
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\SegmentConstants\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentConstantBillingFeeObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var string|null */
private $name;
/** @var string|null */
private $reference;
/** @var int */
private $type;
/** @var int */
private $value;
/**
* SegmentConstantObject constructor.
* @param string|null $segment_id
* @param string|null $name
* @param string|null $reference
* @param string|null $type
* @param int|null $value
*/
public function __construct(
?int $segment_id,
?string $name,
?string $reference,
?string $type,
?int $value
)
{
$this->segment_id = $segment_id;
$this->name = $name;
$this->reference = $reference;
$this->type = $type;
$this->value = $value;
}
/**
* @return int
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): ?string
{
return $this->reference;
}
/**
* @return string
*/
public function getType(): ?string
{
return $this->type;
}
/**
* @return int
*/
public function getValue(): ?int
{
return $this->value;
}
}
app/Classes/Modules/SegmentConstants/DataTransferObjects/SegmentConstantBookingAmountMaxObject.php
+100
View File
@@ -0,0 +1,100 @@
<?php
namespace App\Classes\Modules\SegmentConstants\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentConstantBookingAmountMaxObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var string|null */
private $name;
/** @var string|null */
private $reference;
/** @var int */
private $type;
/** @var int */
private $value;
/** @var int */
private $currency_id;
/**
* SegmentConstantObject constructor.
* @param string|null $segment_id
* @param string|null $name
* @param string|null $reference
* @param string|null $type
* @param int|null $value
* @param int|null $currency_id
*/
public function __construct(
?int $segment_id,
?string $name,
?string $reference,
?string $type,
?int $value,
?int $currency_id
)
{
$this->segment_id = $segment_id;
$this->name = $name;
$this->reference = $reference;
$this->type = $type;
$this->value = $value;
$this->currency_id = $currency_id;
}
/**
* @return int
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): ?string
{
return $this->reference;
}
/**
* @return string
*/
public function getType(): ?string
{
return $this->type;
}
/**
* @return int
*/
public function getValue(): ?int
{
return $this->value;
}
/**
* @return int
*/
public function getCurrencyId(): ?int
{
return $this->currency_id;
}
}
app/Classes/Modules/SegmentConstants/DataTransferObjects/SegmentConstantPaymentAttemptExpiryTimeObject.php
+86
View File
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\SegmentConstants\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentConstantPaymentAttemptExpiryTimeObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var string|null */
private $name;
/** @var string|null */
private $reference;
/** @var int */
private $type;
/** @var int */
private $value;
/**
* SegmentConstantObject constructor.
* @param string|null $segment_id
* @param string|null $name
* @param string|null $reference
* @param string|null $type
* @param int|null $value
*/
public function __construct(
?int $segment_id,
?string $name,
?string $reference,
?string $type,
?int $value
)
{
$this->segment_id = $segment_id;
$this->name = $name;
$this->reference = $reference;
$this->type = $type;
$this->value = $value;
}
/**
* @return int
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): ?string
{
return $this->reference;
}
/**
* @return string
*/
public function getType(): ?string
{
return $this->type;
}
/**
* @return int
*/
public function getValue(): ?int
{
return $this->value;
}
}
app/Classes/Modules/SegmentConstants/DataTransferObjects/SegmentConstantServiceChargeObject.php
+86
View File
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\SegmentConstants\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentConstantServiceChargeObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var string|null */
private $name;
/** @var string|null */
private $reference;
/** @var int */
private $type;
/** @var int */
private $value;
/**
* SegmentConstantObject constructor.
* @param string|null $segment_id
* @param string|null $name
* @param string|null $reference
* @param string|null $type
* @param int|null $value
*/
public function __construct(
?int $segment_id,
?string $name,
?string $reference,
?string $type,
?int $value
)
{
$this->segment_id = $segment_id;
$this->name = $name;
$this->reference = $reference;
$this->type = $type;
$this->value = $value;
}
/**
* @return int
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): ?string
{
return $this->reference;
}
/**
* @return string
*/
public function getType(): ?string
{
return $this->type;
}
/**
* @return int
*/
public function getValue(): ?int
{
return $this->value;
}
}
app/Classes/Modules/SegmentConstants/DataTransferObjects/SegmentConstantTaxObject.php
+86
View File
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\SegmentConstants\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentConstantTaxObject implements DataTransferObject
{
/** @var int|null */
private $segment_id;
/** @var string|null */
private $name;
/** @var string|null */
private $reference;
/** @var int */
private $type;
/** @var int */
private $value;
/**
* SegmentConstantObject constructor.
* @param string|null $segment_id
* @param string|null $name
* @param string|null $reference
* @param string|null $type
* @param int|null $value
*/
public function __construct(
?int $segment_id,
?string $name,
?string $reference,
?string $type,
?int $value
)
{
$this->segment_id = $segment_id;
$this->name = $name;
$this->reference = $reference;
$this->type = $type;
$this->value = $value;
}
/**
* @return int
*/
public function getSegmentId(): ?int
{
return $this->segment_id;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
/**
* @return string
*/
public function getReference(): ?string
{
return $this->reference;
}
/**
* @return string
*/
public function getType(): ?string
{
return $this->type;
}
/**
* @return int
*/
public function getValue(): ?int
{
return $this->value;
}
}
app/Classes/Modules/SegmentConstants/Services/CreatesSegmentConstantBillingFee.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBillingFeeObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesSegmentConstantBillingFee extends AbstractUpdateRecord
{
/**
* @param SegmentConstantBillingFeeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, SegmentConstantBillingFeeObject $object)
{
$model = new SegmentConstant();
$model->segment_id = $segment->id;
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/CreatesSegmentConstantBookingAmountMax.php
+31
View File
@@ -0,0 +1,31 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBookingAmountMaxObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesSegmentConstantBookingAmountMax extends AbstractUpdateRecord
{
/**
* @param SegmentConstantBookingAmountMaxObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, SegmentConstantBookingAmountMaxObject $object)
{
$model = new SegmentConstant();
$model->segment_id = $segment->id;
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue(),
'currency_id' => $object->getCurrencyId()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/CreatesSegmentConstantPaymentAttemptExpiryTime.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantPaymentAttempExpiryTimeObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesSegmentConstantPaymentAttemptExpiryTime extends AbstractUpdateRecord
{
/**
* @param SegmentConstantPaymentAttempExpiryTimeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, SegmentConstantPaymentAttempExpiryTimeObject $object)
{
$model = new SegmentConstant();
$model->segment_id = $object->getSegmentId();
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue(),
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/CreatesSegmentConstantServiceCharge.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantServiceChargeObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesSegmentConstantServiceCharge extends AbstractUpdateRecord
{
/**
* @param SegmentConstantServiceChargeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, SegmentConstantServiceChargeObject $object)
{
$model = new SegmentConstant();
$model->segment_id = $object->getSegmentId();
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/CreatesSegmentConstantTax.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantTaxObject;
use App\Models\SegmentConstant;
use App\Models\Segment;
class CreatesSegmentConstantTax extends AbstractUpdateRecord
{
/**
* @param SegmentConstantTaxObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $segment, SegmentConstantTaxObject $object)
{
$model = new SegmentConstant();
$model->segment_id = $object->getSegmentId();
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/FetchesSegmentConstant.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractFetchRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\SegmentConstant;
class FetchesSegmentConstant extends AbstractFetchRecord
{
/** @var SegmentConstant */
private $repository;
/**
* FetchesSegmentConstant constructor.
* @param SegmentConstant $repository
*/
public function __construct(SegmentConstant $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/SegmentConstants/Services/ListsSegmentConstants.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractListRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\SegmentConstant;
class ListsSegmentConstants extends AbstractListRecord
{
/** @var SegmentConstant */
private $repository;
/**
* ListsSegmentConstants constructor.
* @param SegmentConstant $repository
*/
public function __construct(SegmentConstant $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/SegmentConstants/Services/UpdatesSegmentConstantBillingFee.php
+28
View File
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBillingFeeObject;
use App\Models\SegmentConstant;
class UpdatesSegmentConstantBillingFee extends AbstractUpdateRecord
{
/**
* @param SegmentConstantBillingFeeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentConstant $model, SegmentConstantBillingFeeObject $object)
{
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/UpdatesSegmentConstantBookingAmountMax.php
+29
View File
@@ -0,0 +1,29 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantBookingAmountMaxObject;
use App\Models\SegmentConstant;
class UpdatesSegmentConstantBookingAmountMax extends AbstractUpdateRecord
{
/**
* @param SegmentConstantBookingAmountMaxObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentConstant $model, SegmentConstantBookingAmountMaxObject $object)
{
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue(),
'currency_id' => $object->getCurrencyId(),
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/UpdatesSegmentConstantPaymentAttemptExpiryTime.php
+28
View File
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantPaymentAttemptExpiryTimeObject;
use App\Models\SegmentConstant;
class UpdatesSegmentConstantPaymentAttemptExpiryTime extends AbstractUpdateRecord
{
/**
* @param SegmentConstantPaymentAttemptExpiryTimeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentConstant $model, SegmentConstantPaymentAttemptExpiryTimeObject $object)
{
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/UpdatesSegmentConstantServiceCharge.php
+28
View File
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantServiceChargeObject;
use App\Models\SegmentConstant;
class UpdatesSegmentConstantServiceCharge extends AbstractUpdateRecord
{
/**
* @param SegmentConstantServiceChargeObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentConstant $model, SegmentConstantServiceChargeObject $object)
{
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Services/UpdatesSegmentConstantTax.php
+28
View File
@@ -0,0 +1,28 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantTaxObject;
use App\Models\SegmentConstant;
class UpdatesSegmentConstantTax extends AbstractUpdateRecord
{
/**
* @param SegmentConstantTaxObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentConstant $model, SegmentConstantTaxObject $object)
{
$model->name = $object->getName();
$model->reference = $object->getReference();
$model->detail = json_encode([
'type' => $object->getType(),
'value' => $object->getValue()
]);
return $this->handler($model);
}
}
app/Classes/Modules/SegmentConstants/Standards/Rules/CanCreateSegmentConstant.php
+55
View File
@@ -0,0 +1,55 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentObject;
use App\Classes\Modules\SegmentConstants\Standards\Validators\SegmentConstantValidation;
class CanCreateSegmentConstant extends AbstractRule
{
/** @var SegmentConstantValidation */
private $segmentConstantValidation;
/**
* CanCreateSegmentConstant constructor.
* @param SegmentConstantValidation $segmentConstantValidation
*/
public function __construct(SegmentConstantValidation $segmentConstantValidation)
{
$this->segmentConstantValidation = $segmentConstantValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('add segment_constant')) {
return false;
}
return true;
}
/**
* @param SegmentObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->segmentConstantValidation->validate($object, 'POST');
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/SegmentConstants/Standards/Rules/CanListStandardSegmentConstants.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
class CanListStandardSegmentConstants extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('view standard_segment_constant')) {
return false;
}
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/SegmentConstants/Standards/Rules/CanUpdateStandardSegmentConstant.php
+58
View File
@@ -0,0 +1,58 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentCompanyObject;
use App\Classes\Modules\SegmentConstants\Standards\Validators\SegmentConstantValidation;
class CanUpdateStandardSegmentConstant extends AbstractRule
{
/** @var SegmentConstantValidation */
private $segmentConstantValidation;
/**
* CanCreateAddress constructor.
* @param SegmentConstantValidation $segmentConstantValidation
*/
public function __construct(SegmentConstantValidation $segmentConstantValidation)
{
$this->segmentConstantValidation = $segmentConstantValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('view standard_segment_constant')) {
return false;
}
return true;
}
/**
* @param SegmentConstantValidation $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->segmentConstantValidation->validate($object, 'PUT');
}
/**
* @param SegmentConstantValidation $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/SegmentConstants/Standards/Validators/SegmentConstantValidation.php
+126
View File
@@ -0,0 +1,126 @@
<?php
namespace App\Classes\Modules\SegmentConstants\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\SegmentConstants\DataTransferObjects\SegmentConstantObject;
class SegmentConstantValidation extends AbstractValidation
{
/**
* @param SegmentConstantObject $object
* @return array
*/
protected function data($object): array {
$this->reference = $object->getReference();
if ($this->reference == 'TAX') {
return [
'segment_id'=> $object->getSegmentId(),
'name' => $object->getName(),
'reference' => $object->getReference(),
'type' => $object->getType(),
'value' => $object->getValue()
];
}
elseif ($this->reference == 'BILLING_FEE') {
return [
'segment_id' => $object->getSegmentId(),
'name' => $object->getName(),
'reference' => $object->getReference(),
'type' => $object->getType(),
'value' => $object->getValue()
];
}
elseif ($this->reference == 'SERVICE_CHARGE') {
return [
'segment_id' => $object->getSegmentId(),
'name' => $object->getName(),
'reference' => $object->getReference(),
'type' => $object->getType(),
'value' => $object->getValue()
];
}
elseif ($this->reference == 'BOOKING_AMOUNT_MAX') {
return [
'segment_id' => $object->getSegmentId(),
'name' => $object->getName(),
'reference' => $object->getReference(),
'type' => $object->getType(),
'value' => $object->getValue(),
'currency_id' => $object->getCurrencyId()
];
}
elseif ($this->reference == 'PAYMENT_ATTEMP_EXPIRY_TIME') {
return [
'segment_id' => $object->getSegmentId(),
'name' => $object->getName(),
'reference' => $object->getReference(),
'type' => $object->getType(),
'value' => $object->getValue()
];
}
}
/**
* @return array
*/
protected function rules(?string $type = 'POST'): array {
if ($this->reference == 'TAX') {
return [
'segment_id' => $type == 'POST' ? 'required' : '',
'name' => 'required',
'reference' => 'required',
'type' => 'required',
'value' => 'required'
];
}
elseif ($this->reference == 'BILLING_FEE') {
return [
'segment_id' => $type == 'POST' ? 'required' : '',
'name' => 'required',
'reference' => 'required',
'type' => 'required',
'value' => 'required'
];
}
elseif ($this->reference == 'SERVICE_CHARGE') {
return [
'segment_id' => $type == 'POST' ? 'required' : '',
'name' => 'required',
'reference' => 'required',
'type' => 'required',
'value' => 'required'
];
}
elseif ($this->reference == 'BOOKING_AMOUNT_MAX') {
return [
'segment_id' => $type == 'POST' ? 'required' : '',
'name' => 'required',
'reference' => 'required',
'type' => 'required',
'value' => 'required',
'currency_id' => 'required'
];
}
elseif ($this->reference == 'PAYMENT_ATTEMP_EXPIRY_TIME') {
return [
'segment_id' => $type == 'POST' ? 'required' : '',
'name' => 'required',
'reference' => 'required',
'type' => 'required',
'value' => 'required',
];
}
}
/**
* @return array
*/
protected function messages(): array {
return [];
}
}
app/Classes/Modules/Segments/ControllerLogic/CreateSegmentLogic.php
+75
View File
@@ -0,0 +1,75 @@
<?php
namespace App\Classes\Modules\Segments\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Segments\Standards\Rules\CanCreateSegment;
use App\Classes\Modules\Segments\Services\CreatesSegment;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use App\Http\Resources\SegmentResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class CreateSegmentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Created Segment',
'message' => 'You have successfully created a new Segment'
];
}
/** @var CanCreateSegment */
private $canCreateSegment;
/** @var CreatesSegment */
private $createsSegment;
/**
* CreateSegmentLogic constructor.
* @param CanCreateSegment $canCreateSegment
* @param CreatesSegment $createsSegment
*/
public function __construct(
CanCreateSegment $canCreateSegment,
CreatesSegment $createsSegment
)
{
$this->canCreateSegment = $canCreateSegment;
$this->createsSegment = $createsSegment;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_object = new SegmentObject(
$request->input('name')
);
$this->canCreateSegment->passes($segment_object);
$segment_query = $this->createsSegment->execute($segment_object);
DB::commit();
return $this->resourceResponse(new SegmentResource($segment_query));
} catch (\Exception $exception) {
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Segments/ControllerLogic/DeleteSegmentLogic.php
+83
View File
@@ -0,0 +1,83 @@
<?php
namespace App\Classes\Modules\Segments\ControllersLogic;
use App\Http\Resources\SegmentResource;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Segments\Services\FetchesSegment;
use App\Classes\Modules\Segments\Standards\Rules\CanDeleteSegment;
use App\Classes\Modules\Segments\Services\DeletesSegment;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class DeleteSegmentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Delete Segment',
'message' => 'You have successfully deleted the Segment'
];
}
/** @var CanDeleteSegment */
private $canDeleteSegment;
/** @var DeletesSegment */
private $deletesSegment;
/** @var FetchesSegment */
private $fetchesSegment;
/**
* UpdateStandardSegmentConstantLogic constructor.
* @param CanUpdateSegment $canDeleteSegment
* @param UpdatesSegment $deletesSegment
* @param FetchesSegment $fetchesSegment
*/
public function __construct(
CanDeleteSegment $canDeleteSegment,
DeletesSegment $deletesSegment,
FetchesSegment $fetchesSegment
)
{
$this->canDeleteSegment = $canDeleteSegment;
$this->deletesSegment = $deletesSegment;
$this->fetchesSegment = $fetchesSegment;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_query = $this->fetchesSegment->execute(['id' => $request->route('id')]);
$this->canDeleteSegment->passes();
$this->deletesSegment->execute($segment_query);
DB::commit();
return $this->resourceResponse(new SegmentResource($segment_query));
} catch (\Exception $exception){
dd($exception);
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Segments/ControllerLogic/ListStandardSegmentLogic.php
+65
View File
@@ -0,0 +1,65 @@
<?php
namespace App\Classes\Modules\Segments\ControllersLogic;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Segments\Services\ListsSegments;
use App\Classes\Modules\Segments\Standards\Rules\CanListStandardSegments;
use App\Http\Resources\SegmentResource;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListStandardSegmentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Retrieved Segment',
'message' => 'You have successfully retrieved a list of Segment'
];
}
/** @var CanListStandardSegments */
private $canListStandardSegments;
/** @var ListsSegments */
private $listsSegments;
/**
* ListStandardSegmentLogic constructor.
* @param CanListStandardSegments $canListStandardSegments
* @param ListsSegments $listsSegments
*/
public function __construct(CanListStandardSegments $canListStandardSegments, ListsSegments $listsSegments)
{
$this->canListStandardSegments = $canListStandardSegments;
$this->listsSegments = $listsSegments;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
$this->canListStandardSegments->passes();
$query = $this->listsSegments->execute(['id' => 1]);
return $this->collectionResponse(SegmentResource::collection($query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Segments/ControllerLogic/UpdateSegmentLogic.php
+86
View File
@@ -0,0 +1,86 @@
<?php
namespace App\Classes\Modules\Segments\ControllersLogic;
use App\Http\Resources\SegmentResource;
use App\Classes\General\Abstracts\AbstractControllerLogic;
use App\Classes\Modules\Segments\Services\FetchesSegment;
use App\Classes\Modules\Segments\Standards\Rules\CanUpdateSegment;
use App\Classes\Modules\Segments\Services\UpdatesSegment;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use ErrorException;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
class UpdateSegmentLogic extends AbstractControllerLogic
{
/**
* @return array
*/
protected function notification():array {
return [
'title' => 'Updated Segment',
'message' => 'You have successfully updated the Segment'
];
}
/** @var CanUpdateSegment */
private $canUpdateSegment;
/** @var UpdatesSegment */
private $updatesSegment;
/** @var FetchesSegment */
private $fetchesSegment;
/**
* UpdateStandardSegmentConstantLogic constructor.
* @param CanUpdateSegment $canUpdateSegment
* @param UpdatesSegment $updatesSegment
* @param FetchesSegment $fetchesSegment
*/
public function __construct(
CanUpdateSegment $canUpdateSegment,
UpdatesSegment $updatesSegment,
FetchesSegment $fetchesSegment
)
{
$this->canUpdateSegment = $canUpdateSegment;
$this->updatesSegment = $updatesSegment;
$this->fetchesSegment = $fetchesSegment;
}
/**
* @param Request $request
* @return JsonResponse
* @throws ErrorException
*/
public function logic(Request $request) : JsonResponse
{
try {
DB::beginTransaction();
$segment_query = $this->fetchesSegment->execute(['id' => $request->route('id')]);
$segment_object = new SegmentObject(
$request->input('name', $segment_query->name)
);
$this->canUpdateSegment->passes($segment_object);
$segment_query = $this->updatesSegment->execute($segment_query, $segment_object);
DB::commit();
return $this->resourceResponse(new SegmentResource($segment_query));
} catch (\Exception $exception){
throw new ErrorException($exception->getMessage(), $exception->getCode());
}
}
}
app/Classes/Modules/Segments/DataTransferObjects/SegmentObject.php
+30
View File
@@ -0,0 +1,30 @@
<?php
namespace App\Classes\Modules\Segments\DataTransferObjects;
use App\Classes\Interfaces\DataTransferObject;
class SegmentObject implements DataTransferObject
{
/** @var string|null */
private $name;
/**
* SegmentObject constructor.
* @param string|null $name
*/
public function __construct(
?string $name
)
{
$this->name = $name;
}
/**
* @return string
*/
public function getName(): ?string
{
return $this->name;
}
}
app/Classes/Modules/Segments/Services/CreatesSegment.php
+23
View File
@@ -0,0 +1,23 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use App\Models\Segment;
class CreatesSegment extends AbstractUpdateRecord
{
/**
* @param SegmentObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(SegmentObject $object) {
$model = new Segment();
$model->name = $object->getName();
return $this->handler($model);
}
}
app/Classes/Modules/Segments/Services/DeletesSegment.php
+14
View File
@@ -0,0 +1,14 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractDeleteRecord;
use App\Models\Segment;
class DeletesSegment extends AbstractDeleteRecord
{
public function execute(Segment $model) {
return $this->handler($model);
}
}
app/Classes/Modules/Segments/Services/FetchesSegment.php
+33
View File
@@ -0,0 +1,33 @@
<?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;
/**
* FetchesUser constructor.
* @param Segment $repository
*/
public function __construct(Segment $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
public function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/Segments/Services/ListsSegments.php
+33
View File
@@ -0,0 +1,33 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractListRecord;
use Illuminate\Database\Eloquent\Builder;
use App\Models\Segment;
class ListsSegments extends AbstractListRecord
{
/** @var Segment */
private $repository;
/**
* ListsSegments constructor.
* @param Segment $repository
*/
public function __construct(Segment $repository)
{
$this->repository = $repository;
}
/**
* @return Builder
*/
function getRepository(): Builder
{
return $this->repository->newQuery();
}
}
app/Classes/Modules/Segments/Services/UpdatesSegment.php
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Classes\Modules\Segments\Services;
use App\Classes\General\Eloquent\AbstractUpdateRecord;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use App\Models\Segment;
class UpdatesSegment extends AbstractUpdateRecord
{
/**
* @param SegmentObject $object
* @return \Illuminate\Database\Eloquent\Model
* @throws \App\Classes\Exceptions\MalformedRequestException
*/
public function execute(Segment $model, SegmentObject $object)
{
$model->name = $object->getName();
return $this->handler($model);
}
}
app/Classes/Modules/Segments/Standards/Rules/CanCreateSegment.php
+55
View File
@@ -0,0 +1,55 @@
<?php
namespace App\Classes\Modules\Segments\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use App\Classes\Modules\Segments\Standards\Validators\SegmentValidation;
class CanCreateSegment extends AbstractRule
{
/** @var SegmentValidation */
private $segmentValidation;
/**
* CanCreateSegment constructor.
* @param SegmentValidation $segmentValidation
*/
public function __construct(SegmentValidation $segmentValidation)
{
$this->segmentValidation = $segmentValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('add segment')) {
return false;
}
return true;
}
/**
* @param SegmentObject $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->segmentValidation->validate($object);
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/Segments/Standards/Rules/CanDeleteSegments.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace App\Classes\Modules\Segments\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
class CanDeleteSegment extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('delete segment')) {
return false;
}
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/Segments/Standards/Rules/CanListStandardSegments.php
+45
View File
@@ -0,0 +1,45 @@
<?php
namespace App\Classes\Modules\Segments\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
class CanListStandardSegments extends AbstractRule
{
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('view standard_segment')) {
return false;
}
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function validators($object): bool
{
return true;
}
/**
* @param SegmentObject $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/Segments/Standards/Rules/CanUpdateSegment.php
+58
View File
@@ -0,0 +1,58 @@
<?php
namespace App\Classes\Modules\Segments\Standards\Rules;
use App\Classes\General\Abstracts\AbstractRule;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
use App\Classes\Modules\Segments\Standards\Validators\SegmentValidation;
class CanUpdateSegment extends AbstractRule
{
/** @var SegmentValidation */
private $segmentValidation;
/**
* CanCreateAddress constructor.
* @param SegmentValidation $segmentValidation
*/
public function __construct(SegmentValidation $segmentValidation)
{
$this->segmentValidation = $segmentValidation;
}
/**
* @return bool
*/
protected function authorized(): bool
{
// TODO Set Authorization rules
if (!\Auth::user()->can('edit segment')) {
return false;
}
return true;
}
/**
* @param SegmentValidation $object
* @return bool
* @throws \App\Classes\Exceptions\RequestValidationException
*/
protected function validators($object): bool
{
return $this->segmentValidation->validate($object);
}
/**
* @param SegmentValidation $object
* @return bool
*/
protected function criteria($object): bool
{
return true;
}
}
app/Classes/Modules/Segments/Standards/Validators/SegmentValidation.php
+38
View File
@@ -0,0 +1,38 @@
<?php
namespace App\Classes\Modules\Segments\Standards\Validators;
use App\Classes\General\Abstracts\AbstractValidation;
use App\Classes\Modules\Segments\DataTransferObjects\SegmentObject;
class SegmentValidation extends AbstractValidation
{
/**
* @param SegmentObject $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 [];
}
}
app/Classes/ValueObjects/Constants/ObjectStatus.php
+1
View File
@@ -3,5 +3,6 @@
namespace App\Classes\ValueObjects\Constants;
final class ObjectStatus {
public const ACTIVE = 1;
public const PENDING = 9;
}
app/Http/Controllers/Documents/ApproveDocumentController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\Documents;
use App\Classes\Modules\Documents\ControllersLogic\ApproveDocumentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ApproveDocumentController
{
/**
* @param Request $request
* @param ApproveDocumentLogic $logic
* @return JsonResponse
*/
public function approve(Request $request, ApproveDocumentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/Documents/ListDocumentsController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\Documents;
use App\Classes\Modules\Documents\ControllersLogic\ListDocumentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListDocumentsController
{
/**
* @param Request $request
* @param ListDocumentLogic $logic
* @return JsonResponse
*/
public function list(Request $request, ListDocumentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/SegmentConstants/CreateSegmentConstantController.php
+19
View File
@@ -0,0 +1,19 @@
<?php
namespace App\Http\Controllers\SegmentConstants;
use App\Classes\Modules\SegmentConstants\ControllersLogic\CreateSegmentConstantLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CreateSegmentConstantController
{
/**
* @param Request $request
* @param CreateSegmentConstantLogic $logic
* @return JsonResponse
*/
public function create(Request $request, CreateSegmentConstantLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/SegmentConstants/UpdateSegmentConstantController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\SegmentConstants;
use App\Classes\Modules\SegmentConstants\ControllersLogic\UpdateSegmentConstantLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class UpdateSegmentConstantController
{
/**
* @param Request $request
* @param UpdateSegmentConstantLogic $logic
* @return JsonResponse
*/
public function update(Request $request, UpdateSegmentConstantLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/Segments/CreateSegmentController.php
+19
View File
@@ -0,0 +1,19 @@
<?php
namespace App\Http\Controllers\Segments;
use App\Classes\Modules\Segments\ControllersLogic\CreateSegmentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class CreateSegmentController
{
/**
* @param Request $request
* @param CreateSegmentLogic $logic
* @return JsonResponse
*/
public function create(Request $request, CreateSegmentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/Segments/DeleteSegmentController.php
+19
View File
@@ -0,0 +1,19 @@
<?php
namespace App\Http\Controllers\Segments;
use App\Classes\Modules\Segments\ControllersLogic\DeleteSegmentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class DeleteSegmentController
{
/**
* @param Request $request
* @param DeleteSegmentLogic $logic
* @return JsonResponse
*/
public function delete(Request $request, DeleteSegmentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/Segments/UpdateSegmentController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\Segments;
use App\Classes\Modules\Segments\ControllersLogic\UpdateSegmentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class UpdateSegmentController
{
/**
* @param Request $request
* @param UpdateSegmentLogic $logic
* @return JsonResponse
*/
public function update(Request $request, UpdateSegmentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/StandardSegmentConstants/ListStandardSegmentConstantsController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\StandardSegmentConstants;
use App\Classes\Modules\SegmentConstants\ControllersLogic\ListStandardSegmentConstantLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListStandardSegmentConstantsController
{
/**
* @param Request $request
* @param ListStandardSegmentConstantLogic $logic
* @return JsonResponse
*/
public function list(Request $request, ListStandardSegmentConstantLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/StandardSegmentConstants/UpdateStandardSegmentConstantController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\StandardSegmentConstants;
use App\Classes\Modules\SegmentConstants\ControllersLogic\UpdateStandardSegmentConstantLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class UpdateStandardSegmentConstantController
{
/**
* @param Request $request
* @param UpdateStandardSegmentConstantLogic $logic
* @return JsonResponse
*/
public function update(Request $request, UpdateStandardSegmentConstantLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Controllers/StandardSegments/ListStandardSegmentsController.php
+20
View File
@@ -0,0 +1,20 @@
<?php
namespace App\Http\Controllers\StandardSegments;
use App\Classes\Modules\Segments\ControllersLogic\ListStandardSegmentLogic;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
class ListStandardSegmentsController
{
/**
* @param Request $request
* @param ListStandardSegmentLogic $logic
* @return JsonResponse
*/
public function list(Request $request, ListStandardSegmentLogic $logic): JsonResponse {
return $logic->execute($request);
}
}
app/Http/Resources/DocumentResource.php
+26
View File
@@ -0,0 +1,26 @@
<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class DocumentResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request $request
* @return array
*/
public function toArray($request)
{
return [
'id' => $this->id,
'document_type' => $this->document_type,
'reference' => $this->reference,
'status' => (int) $this->status,
'approved_by' => (int) $this->approved_by,
'files' => $this->files()->get()
];
}
}
app/Http/Resources/SegmentConstantResource.php
+23
View File
@@ -0,0 +1,23 @@
<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class SegmentConstantResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request $request
* @return array
*/
public function toArray($request)
{
return [
'id' => $this->id,
'name' => $this->name,
'detail' => $this->detail
];
}
}
app/Http/Resources/SegmentResource.php
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Http\Resources;
use Illuminate\Http\Resources\Json\JsonResource;
class SegmentResource extends JsonResource
{
/**
* Transform the resource into an array.
*
* @param \Illuminate\Http\Request $request
* @return array
*/
public function toArray($request)
{
return [
'id' => $this->id,
'name' => $this->name,
];
}
}
app/Models/Company.php
+9
View File
@@ -1,6 +1,7 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\SoftDeletes;
@@ -24,6 +25,14 @@ class Company extends AbstractModel
protected $table = 'companies';
protected $dates = ['deleted_at'];
/**
* @return belongsToMany
*/
public function segment(): belongsToMany
{
return $this->belongsToMany(Segment::class, 'segment_company', 'company_id', 'segment_id');
}
}
app/Models/Document.php
+16 -1
View File
@@ -5,6 +5,8 @@ namespace App\Models;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Database\Eloquent\Relations\hasMany;
/**
* Class Document
* @package App\Models
@@ -22,5 +24,18 @@ use Illuminate\Database\Eloquent\SoftDeletes;
*/
class Document extends AbstractModel
{
//
use SoftDeletes;
protected $table = 'documents';
protected $dates = ['deleted_at'];
/**
* @return hasMany
*/
public function files(): hasMany
{
return $this->hasMany(File::class, 'document_id');
}
}
app/Models/File.php
+5
View File
@@ -21,4 +21,9 @@ class File extends AbstractModel
protected $table = 'files';
protected $dates = ['deleted_at'];
public function getFileAttribute($value)
{
return $value ? json_decode($value) : [];
}
}
app/Models/Permission.php
+9
View File
@@ -0,0 +1,9 @@
<?php
namespace App\Models;
class Permission extends AbstractModel
{
protected $table = 'permissions';
}
app/Models/Role.php
+11
View File
@@ -0,0 +1,11 @@
<?php
namespace App\Models;
use Spatie\Permission\Models\Role as SpatieRole;
use Spatie\Permission\Models\Permission;
class Role extends AbstractModel
{
protected $table = 'roles';
}
app/Models/Segment.php
+22
View File
@@ -0,0 +1,22 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\SoftDeletes;
/**
* Class Segment
* @package App\Models
* @version August 4, 2020, 4:36 am
*
* @property string name
* @property string reference
*/
class Segment extends AbstractModel
{
use SoftDeletes;
protected $table = 'segments';
protected $dates = ['deleted_at'];
}
app/Models/SegmentCompany.php
+18
View File
@@ -0,0 +1,18 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\Model;
/**
* Class SegmentCompany
* @package App\Models
* @version August 4, 2020, 4:36 am
*
* @property \App\Models\Segment segment_id
* @property \App\Models\CPmpany company_id
*/
class SegmentCompany extends AbstractModel
{
protected $table = 'segment_company';
}
app/Models/SegmentConstant.php
+28
View File
@@ -0,0 +1,28 @@
<?php
namespace App\Models;
use Illuminate\Database\Eloquent\SoftDeletes;
/**
* Class SegmentConstant
* @package App\Models
* @version August 4, 2020, 4:36 am
*
* @property \App\Models\Segment segment_id
* @property text detail
*/
class SegmentConstant extends AbstractModel
{
use SoftDeletes;
protected $table = 'segment_constants';
protected $dates = ['deleted_at'];
public function getDetailAttribute($value)
{
return $value ? json_decode($value) : [];
}
}
app/Models/User.php
+4 -10
View File
@@ -4,6 +4,9 @@ namespace App\Models;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Spatie\Permission\Traits\HasRoles;
use Tymon\JWTAuth\Contracts\JWTSubject;
use Illuminate\Notifications\Notifiable;
use Illuminate\Auth\Authenticatable;
@@ -20,7 +23,7 @@ class User extends AbstractModel implements
AuthorizableContract,
CanResetPasswordContract
{
use Notifiable, Authenticatable, Authorizable, CanResetPassword, MustVerifyEmail;
use HasRoles, Notifiable, Authenticatable, Authorizable, CanResetPassword, MustVerifyEmail;
/**
@@ -54,15 +57,6 @@ class User extends AbstractModel implements
return $this->hasMany(PasswordReset::class, 'user_id', 'id');
}
// public function employers(): belongsToMany {
// return $this->belongsToMany(CompanyModule::class, (new CompanyEmployee())->getTable(), 'user_id', 'module_id');
// }
// public function tweets(): hasMany {
// return $this->hasMany(Order::class, 'user_id', 'id');
// }
/**
* @return belongsToMany
*/
database/migrations/2020_11_03_122319_create_documents_table.php
+2 -2
View File
@@ -20,8 +20,8 @@ class CreateDocumentsTable extends Migration
$table->string('document_type')->nullable();
$table->string('reference')->nullable();
$table->integer('status')->nullable();
$table->bigInteger('approved_by')->unsigned();
$table->foreign('approved_by')->references('id')->on('users')->onDelete('cascade')->nullable();
$table->bigInteger('approved_by')->unsigned()->nullable();
$table->foreign('approved_by')->references('id')->on('users')->onDelete('cascade');
$table->timestamp('issued_date')->nullable();
$table->timestamp('expired_date')->nullable();
$table->timestamp('approved_date')->nullable();
database/migrations/2020_11_11_065757_create_segments_table.php
+33
View File
@@ -0,0 +1,33 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateSegmentsTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('segments', function (Blueprint $table) {
$table->id();
$table->string('name')->nullable();
$table->timestamps();
$table->softDeletes();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('segments');
}
}
database/migrations/2020_11_11_065838_create_segment_constants_table.php
+38
View File
@@ -0,0 +1,38 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateSegmentConstantsTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('segment_constants', function (Blueprint $table) {
$table->id();
$table->bigInteger('segment_id')->unsigned()->nullable();
$table->foreign('segment_id')->references('id')->on('segments')->onDelete('cascade');
$table->string('name')->nullable();
$table->string('reference')->nullable();
$table->text('detail')->nullable();
$table->timestamps();
$table->integer('type')->nullable();
$table->softDeletes();
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('segment_constants');
}
}
database/migrations/2020_11_11_065851_create_segment_companies_table.php
+34
View File
@@ -0,0 +1,34 @@
<?php
use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;
class CreateSegmentCompaniesTable extends Migration
{
/**
* Run the migrations.
*
* @return void
*/
public function up()
{
Schema::create('segment_company', function (Blueprint $table) {
$table->bigInteger('segment_id')->unsigned();
$table->foreign('segment_id')->references('id')->on('segments')->onDelete('cascade');
$table->bigInteger('company_id')->unsigned();
$table->foreign('company_id')->references('id')->on('companies')->onDelete('cascade');
$table->primary(['segment_id', 'company_id']);
});
}
/**
* Reverse the migrations.
*
* @return void
*/
public function down()
{
Schema::dropIfExists('segment_company');
}
}
database/seeds/AdminUserPermissionsTableSeeder.php
+76
View File
@@ -0,0 +1,76 @@
<?php
use Illuminate\Database\Seeder;
use Spatie\Permission\Models\Role;
use Spatie\Permission\Models\Permission;
use App\Models\User;
class AdminUserPermissionsTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
// Reset cached roles and permissions
app()['cache']->forget('spatie.permission.cache');
// admin permissions
Permission::create(['name' => 'view document', 'guard_name' => 'web']);
Permission::create(['name' => 'add document', 'guard_name' => 'web']);
Permission::create(['name' => 'edit document', 'guard_name' => 'web']);
Permission::create(['name' => 'delete document', 'guard_name' => 'web']);
Permission::create(['name' => 'view standard_segment', 'guard_name' => 'web']);
Permission::create(['name' => 'add standard_segment', 'guard_name' => 'web']);
Permission::create(['name' => 'edit standard_segment', 'guard_name' => 'web']);
Permission::create(['name' => 'delete standard_segment', 'guard_name' => 'web']);
Permission::create(['name' => 'view standard_segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'add standard_segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'edit standard_segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'delete standard_segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'view segment', 'guard_name' => 'web']);
Permission::create(['name' => 'add segment', 'guard_name' => 'web']);
Permission::create(['name' => 'edit segment', 'guard_name' => 'web']);
Permission::create(['name' => 'delete segment', 'guard_name' => 'web']);
Permission::create(['name' => 'view segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'add segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'edit segment_constant', 'guard_name' => 'web']);
Permission::create(['name' => 'delete segment_constant', 'guard_name' => 'web']);
///////////////////////////////////////////////////////////////////////
$shadow_admin_role = Role::create([
'name' => 'Shadow Admin',
'guard_name' => 'web',
'type' => 1,
]);
$shadow_admin_role->givePermissionTo(Permission::all());
$admin = User::find(1);
$admin->assignRole($shadow_admin_role);
///////////////////////////////////////////////////////////////////////
$ultimate_admin_role = Role::create([
'name' => 'Ultimate Admin',
'guard_name' => 'web',
'type' => 1,
]);
$ultimate_admin_role->givePermissionTo(Permission::all());
$admin = User::find(2);
$admin->assignRole($ultimate_admin_role);
///////////////////////////////////////////////////////////////////////
}
}
database/seeds/AdminUserTableSeeder.php
+42
View File
@@ -0,0 +1,42 @@
<?php
use Illuminate\Database\Seeder;
use Illuminate\Support\Str;
class AdminUserTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('users')->insert([
[
'id' => 1,
'name' => 'The One',
'email' => 'admin@exchange.com',
'password' => bcrypt('pass123'),
'type' => 1,
'status' => 1,
'remember_token' => (string) Str::uuid(),
'active_at' => date('Y-m-d H:i:s'),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
[
'id' => 2,
'name' => 'The Admin',
'email' => 'admin2@exchange.com',
'password' => bcrypt('pass123'),
'type' => 1,
'status' => 1,
'remember_token' => (string) Str::uuid(),
'active_at' => date('Y-m-d H:i:s'),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
]
]);
}
}
database/seeds/DatabaseSeeder.php
+7
View File
@@ -19,6 +19,13 @@ class DatabaseSeeder extends Seeder
$this->call(StatesTableSeeder::class);
$this->call(DistrictsTableSeeder::class);
$this->call(SegmentsTableSeeder::class);
$this->call(SegmentConstantsTableSeeder::class);
// Admin
$this->call(AdminUserTableSeeder::class);
$this->call(AdminUserPermissionsTableSeeder::class);
DB::commit();
}
}
database/seeds/SegmentConstantsTableSeeder.php
+79
View File
@@ -0,0 +1,79 @@
<?php
use Illuminate\Database\Seeder;
use Illuminate\Support\Str;
class SegmentConstantsTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('segment_constants')->insert([
[
'id' => 1,
'segment_id' => 1,
'name' => 'Tax',
'reference' => 'TAX',
'detail' => json_encode([
'type' => 'percentage',
'value' => '10'
]),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
[
'id' => 2,
'segment_id' => 1,
'name' => 'Billing Fee',
'reference' => 'BILLING_FEE',
'detail' => json_encode([
'type' => 'fix_rate',
'value' => '10'
]),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
[
'id' => 3,
'segment_id' => 1,
'name' => 'Service Charge',
'reference' => 'SERVICE_CHARGE',
'detail' => json_encode([
'type' => 'fix_rate',
'value' => '10'
]),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
[
'id' => 4,
'segment_id' => 1,
'name' => 'Booking Amount Max',
'reference' => 'BOOKING_AMOUNT_MAX',
'detail' => json_encode([
'type' => 'fix_rate',
'value' => '10',
'currency_id' => 1
]),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
[
'id' => 5,
'segment_id' => 1,
'name' => 'Payment Attempt Expiry Time',
'reference' => 'PAYMENT_ATTEMP_EXPIRY_TIME',
'detail' => json_encode([
'type' => 'day',
'value' => '10',
]),
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
],
]);
}
}
database/seeds/SegmentsTableSeeder.php
+24
View File
@@ -0,0 +1,24 @@
<?php
use Illuminate\Database\Seeder;
use Illuminate\Support\Str;
class SegmentsTableSeeder extends Seeder
{
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
DB::table('segments')->insert([
[
'id' => 1,
'name' => 'Standard Segment',
'created_at' => date('Y-m-d H:i:s'),
'updated_at' => date('Y-m-d H:i:s'),
]
]);
}
}
resources/assets/vue/components/accounts/forms/LoginFormComponent.vue
+7 -4
View File
@@ -79,12 +79,15 @@
methods:{
successHandler(response){
localStorage.setItem('user-token', response.payload.access_token);
console.log(response.payload.access_token);
this.$store.dispatch('userAuthentication', {access_token: response.payload.access_token});
this.error = '';
this.$store.dispatch('toggleSection', {name: 'loginSuccess', status: true})
setTimeout(function(){
window.location.href = response.payload.redirect_url;
}, 2000);
// this.$store.dispatch('toggleSection', {name: 'loginSuccess', status: true})
// setTimeout(function(){
// window.location.href = response.payload.redirect_url;
// }, 2000);
},
errorHandler(error){
this.$store.dispatch('userAuthentication', {access_token: ''});
routes/api.php
+6
View File
@@ -18,6 +18,12 @@ Route::group(['middleware' => 'api', 'prefix' => 'v1', 'as' => 'api.'], function
require __DIR__ . '/account.php';
require __DIR__ . '/document.php';
require __DIR__ . '/segment.php';
require __DIR__ . '/segment_constant.php';
Route::group(['middleware' => 'valid.token'], function () {
require __DIR__ . '/crud.php';
});
routes/document.php
+12
View File
@@ -0,0 +1,12 @@
<?php
use Illuminate\Support\Facades\Route;
Route::group(['namespace' => 'Documents'], function () {
Route::group(['middleware' => 'valid.token'], function () {
Route::group(['prefix' => 'document'], function () {
Route::get('/list', 'ListDocumentsController@list')->name('document.list');
Route::put('/approve/{id}', 'ApproveDocumentController@approve')->name('document.approve');
});
});
});
routes/segment.php
+21
View File
@@ -0,0 +1,21 @@
<?php
use Illuminate\Support\Facades\Route;
Route::group(['namespace' => 'StandardSegments'], function () {
Route::group(['middleware' => 'valid.token'], function () {
Route::group(['prefix' => 'standard-segment'], function () {
Route::get('/list', 'ListStandardSegmentsController@list')->name('standard_segment.update');
});
});
});
Route::group(['namespace' => 'Segments'], function () {
Route::group(['middleware' => 'valid.token'], function () {
Route::group(['prefix' => 'segment'], function () {
Route::post('/create', 'CreateSegmentController@create')->name('segment.create');
Route::put('/update/{id}', 'UpdateSegmentController@update')->name('segment.update');
Route::delete('/delete/{id}', 'DeleteSegmentController@delete')->name('segment.delete');
});
});
});
routes/segment_constant.php
+23
View File
@@ -0,0 +1,23 @@
<?php
use Illuminate\Support\Facades\Route;
Route::group(['namespace' => 'StandardSegmentConstants'], function () {
Route::group(['middleware' => 'valid.token'], function () {
Route::group(['prefix' => 'standard-segment-constant'], function () {
Route::get('/list', 'ListStandardSegmentConstantsController@list')->name('standard_segment.update');
Route::put('/update/{id}', 'UpdateStandardSegmentConstantController@update')->name('standard_segment_constant.update');
});
});
});
Route::group(['namespace' => 'SegmentConstants'], function () {
Route::group(['middleware' => 'valid.token'], function () {
Route::group(['prefix' => 'segment-constant'], function () {
// Route::get('/list', 'ListStandardSegmentConstantsController@list')->name('standard_segment.update');
Route::post('/create', 'CreateSegmentConstantController@create')->name('segment_constant.create');
Route::put('/update/{id}', 'UpdateSegmentConstantController@update')->name('segment_constant.update');
});
});
});