Shell Bypass 403 GE-C666C

Ghost Exploiter Team Official

Directory >> /var/www/html/back/app/Repositories/Integrations/Interfaces/

File / Folder	Size	Action
.	-
AppServiceProvider.php	0KB	edt ren
ArticleToGroup.php	0.453KB	edt ren
AuthService.php	0.683KB	edt ren
BankService.php	0KB	edt ren
BaseService.php	0.099KB	edt ren
ClockInterface.php	0.546KB	edt ren
CqrsServiceProvider.php	1.188KB	edt ren
Dto.php	0KB	edt ren
IntegrationInterface.php	0.554KB	edt ren
IntegrationRepository-2...	11.166KB	edt ren
IntegrationRepository.php	11.166KB	edt ren
OpenApiPaginatedRespons...	0KB	edt ren
OpenApiPaginatedRespons...	0KB	edt ren
OpenApiPaginatedRespons...	0KB	edt ren
OpenApiValidationErrorR...	0.709KB	edt ren
OpenApiValidationErrorR...	0.709KB	edt ren
PaginationDto-202601281...	0KB	edt ren
PaginationDto.php	0KB	edt ren
ResourceResponse-202601...	0KB	edt ren
ResourceResponse.php	0KB	edt ren
ResponseDto-20260128224...	0KB	edt ren
ResponseDto.php	0KB	edt ren
ResponseService.php	0.823KB	edt ren
TokenResponse.php	0KB	edt ren
api.php	0KB	edt ren
auth.php	3.935KB	edt ren
cache.php	3.395KB	edt ren
integrations.php	0.694KB	edt ren
services.php	0KB	edt ren
users.php	0.828KB	edt ren

<?php

namespace App\Repositories\Integrations;

use App\Domain\Payment\Enums\PaymentStatusEnum;
use App\Domain\Payment\Enums\PaymentTypeEnum;
use App\Domain\Payment\PaymentLogService;
use App\DTO\IntegrationPaymentDTO;
use App\Models\Account;
use App\Models\Counterparty;
use App\Models\Organization;
use App\Models\Payment;
use App\Repositories\Integrations\Interfaces\IntegrationInterface;
use Carbon\Carbon;
use Illuminate\Support\Facades\DB;

class IntegrationRepository implements IntegrationInterface
{

protected PaymentLogService $paymentLogService;

public function __construct()
    {
        $this->paymentLogService = app()->make(PaymentLogService::class);
    }

public function createDataInAccountDb($modelId, $account)
    {
        $searchAccount = null;

$organization = Organization::query()->where(['model_id' => $modelId, 'external_id' => $account['organization_id']])->first();

$searchAccount = Account::query()->where([
            'model_id' => $modelId,
            'external_id' => trim($account['id'])
        ])->first();

if (!$searchAccount) {
            $searchAccount = Account::query()->where([
                'model_id' => $modelId,
                'number' => trim($account['number'])
            ])->first();
        }

if ($searchAccount) {
            $searchAccount->update(['external_id' => $account['id'],
                'deposit' => $account['deposit'],
                'bank_name' => $account['bank_name'],
                'bank_bic' => $account['bank_bic'],
                'bank_city' => $account['bank_city'],
//                'balance_of_the_date' => $account['balance_of_the_date'],
                'cor_number' => $account['cor_number'],
                'name' => $account['name'],
                'added' => $account['added'],
                'archived' => $account['archived'],
                'current_balance' => $account['deposit'],
            ]);
            return $searchAccount;
        } else {
            return Account::query()->create([
                'external_id' => $account['id'],
                'organization_id' => $organization->id,
                'model_id' => $modelId,
                'name' => $account['name'],
                'archived' => $account['archived'],
                'added' => $account['added'],
                'balance_of_the_date' => $account['balance_of_the_date'],
                'bank_name' => $account['bank_name'],
                'bank_bic' => $account['bank_bic'],
                'cor_number' => $account['cor_number'],
                'number' => $account['number'],
                'bank_city' => $account['bank_city'],
                'deposit' => $account['deposit']
            ]);
        }
    }

public function createDataInCounterpartyDb($modelId, $counterparty)
    {
        $searchCounterparty = null;

$searchCounterparty = Counterparty::query()->where([
            'model_id' => $modelId,
            'external_id' => trim($counterparty['id'])
        ])->first();

if (!$searchCounterparty) {
            $searchCounterparty = Counterparty::query()->where([
                'model_id' => $modelId,
                'inn' => trim($counterparty['inn'])
            ])->first();
        }

if ($searchCounterparty) {
            $searchCounterparty->update(['external_id' => $counterparty['id'],
                'name' => $counterparty['name'],
                'comment' => $counterparty['comment'],
                'kpp' => $counterparty['kpp'],
                'archived' => $counterparty['archived'],
            ]);
            return $searchCounterparty;
        } else {
            return Counterparty::query()->create([
                'external_id' => $counterparty['id'],
                'model_id' => $modelId,
                'name' => $counterparty['name'],
                'archived' => $counterparty['archived'],
                'inn' => $counterparty['inn'],
                'kpp' => $counterparty['kpp'],
                'comment' => $counterparty['comment'],
            ]);
        }
    }

public function createDataInOrganizationsDb($modelId, $organization)
    {
        $searchOrganization = null;

$searchOrganization = Organization::query()->where([
            'model_id' => $modelId,
            'external_id' => trim($organization['id'])
        ])->first();

if (!$searchOrganization) {
            $searchOrganization = Organization::query()->where([
                'model_id' => $modelId,
                'inn' => trim($organization['inn'])
            ])->first();
        }

if ($searchOrganization) {
            $searchOrganization->update(['external_id' => $organization['id'],
                'full_name' => $organization['fname'],
                'short_name' => $organization['name'],
                'kpp' => $organization['kpp'],
                'archived' => $organization['archived'],
            ]);
            return $searchOrganization;
        } else {
            return Organization::query()->create([
                'model_id' => $modelId,
                'external_id' => $organization['id'],
                'full_name' => $organization['fname'],
                'short_name' => $organization['name'],
                'inn' => $organization['inn'],
                'kpp' => $organization['kpp'],
                'archived' => $organization['archived'],
            ]);
        }
    }

public function createDataInPaymentsDb($modelId, $payment)
    {
        return DB::transaction(function () use ($modelId, $payment) {

$paymentModel = null;

if (is_numeric($payment['id'])) {
                $paymentModel = Payment::query()->find((int)$payment['id']);
            }

if (is_string($payment['id'])) {
                if (ctype_digit($payment['id'])) {
                    $paymentModel = Payment::query()
                        ->where('external_id', $payment['id'])
                        ->orWhere('id', (int)$payment['id'])
                        ->first();
                } else {
                    $paymentModel = Payment::query()
                        ->where('external_id', $payment['id'])
                        ->first();
                }
            }

if ($paymentModel) {
                $original = $paymentModel->getOriginal();

$account = Account::query()->find($paymentModel->account_id);

$importAccount = Account::query()
                    ->where([
                        'model_id' => $modelId,
                        'external_id' => $payment['account_id']
                    ])
                    ->first();

$status = match ($paymentModel->payment_type) {
                    PaymentTypeEnum::PAYMENT_TYPE_RECEPTION->value => PaymentStatusEnum::STATUS_RECEIVED->value,
                    PaymentTypeEnum::PAYMENT_TYPE_MOVING->value => PaymentStatusEnum::STATUS_MOVING->value,
                    PaymentTypeEnum::PAYMENT_TYPE_ISSUEANCE->value => PaymentStatusEnum::STATUS_ISSUED->value,
                    PaymentTypeEnum::PAYMENT_TYPE_PAYMENT->value => PaymentStatusEnum::STATUS_PAID->value,
                    default => PaymentStatusEnum::STATUS_SENT->value,
                };

if ((!isset($account)) || (($account->number != $importAccount->number) && ($account->external_id != $importAccount->external_id))) {
                    $paymentModel->update(['account_id' => $importAccount->id]);
                }

$paymentModel->update([
                    'status' => $status,
                    'amount' => $payment['amount'],
                    'payment_date' => $payment['date'],
                    'actual_date' => $payment['payment_date'],
                    'purpose_of_payment_1c' => $payment['appointment'] ?? 'Платеж из 1с',
                    'note_1c' => $payment['comment'] ?? '',
                    'account_debit_1c' => $importAccount->name ?? $account?->name ?? null,
                ]);

$distribution = $paymentModel->distributions()->first();
                if ($distribution) {
                    $distribution->update(['amount' => $payment['amount']]);
                }

$this->createLogPayment($paymentModel, $original);
            } else {
                $paymentDTO = IntegrationPaymentDTO::fromArray($modelId, $payment);
                $account = $this->getAccountId($modelId, $payment['account_id']);
                $counterpartyId = $this->getCounterpartyId($modelId, $payment['counterparty_id']);
                $organizationId = $this->getOrganizationId($modelId, $payment['organization_id']);
                $paymentData = $paymentDTO->toArray($account, $counterpartyId, $organizationId);

$paymentModel = Payment::query()->create($paymentData);

//КОСТЫЛЬ ))Привет разрабу, который это разгребает, это было сделано до меня
                $paymentModel->distributions()->create([
                    'amount' => 0.00,
                    'amount_limit' => 0.00,
                ]);

$this->createLogPayment($paymentModel, null);
            }
            return $paymentModel;
        });
    }

public function createLogPayment($payment, $original)
    {
        if (!$original) {
            $original = $payment->getOriginal();
        }

$changes = [];
        foreach ($payment->getAttributes() as $field => $newValue) {
            $oldValue = $original[$field] ?? null;
            if (($field == 'status') || ($field == 'amount') || ($field == 'name') || ($field == 'payment_date') || ($field == 'account_id')) {
                if ($field == 'payment_date') {
                    $oldValue = Carbon::parse($oldValue)->toDateString();
                    $newValue = Carbon::parse($newValue)->toDateString();
                }
                if ($oldValue != $newValue) {
                    if ($field == 'account_id') {
                        if($oldValue != null) {
                            $oldValue = Account::query()->find($oldValue)->name;
                        }
                        $newValue = Account::query()->find($newValue)->name;
                    }

$changes[$field] = [(string)$oldValue ?? null, (string)$newValue];
                }
            }
        }

if (!empty($changes)) {
            $this->paymentLogService->store(
                1,
                $payment,
                $original['status'] instanceof PaymentStatusEnum ? $original['status']->value : $payment['status'],
                null,
                '',
                $changes
            );
        }
    }

public function getOrganizationId($modelId, $organizationExternalId)
    {
        return Organization::query()->where(['model_id' => $modelId, 'external_id' => $organizationExternalId])->first()?->id;
    }

public function getCounterpartyId($modelId, $counterpartyExternalId)
    {
        return Counterparty::query()->where(['model_id' => $modelId, 'external_id' => $counterpartyExternalId])->first()?->id;
    }

public function getAccountId($modelId, $accountExternalId)
    {
        return Account::query()->where(['model_id' => $modelId, 'external_id' => $accountExternalId])->first();
    }
}