strprfcrm/app/Http/Controllers/CommonCatalogController.php

<?php

declare(strict_types=1);

namespace App\Http\Controllers;

use App\Http\Requests\StoreCommonCatalogItemRequest;
use App\Jobs\Export\ExportCommonCatalogJob;
use App\Jobs\Export\ExportTechnicalDescriptionsJob;
use App\Jobs\Import\ImportJob;
use App\Models\CommonCatalogItem;
use App\Models\File;
use App\Models\Import;
use App\Models\Role;
use App\Models\Setting;
use App\Services\Access\AccessService;
use App\Services\Access\FieldAccessService;
use App\Services\FileService;
use App\Services\TechnicalDescriptionService;
use Illuminate\Contracts\View\View;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Illuminate\Validation\Rule;
use Symfony\Component\HttpFoundation\StreamedResponse;
use Throwable;

class CommonCatalogController extends Controller
{
    protected array $data = [
        'active' => 'common_catalog',
        'title' => 'Каталог общий',
        'id' => 'common_catalog_items',
        'header' => [
            'id' => 'ID',
            'image' => 'Внешний вид',
            'article' => 'Артикул',
            'calculator_name' => 'Наименование',
            'kind' => 'Вид',
            'dimension_length' => 'Габариты: длина',
            'dimension_width' => 'Габариты: ширина',
            'dimension_height' => 'Габариты: высота',
            'site_length' => 'Участок: длина',
            'site_width' => 'Участок: ширина',
            'fall_height' => 'Высота падения',
            'additional_info' => 'Дополнительные сведения',
            'dimension_unit' => 'Единица измерения габаритов',
            'weight' => 'Вес, кг.',
            'volume' => 'Объем, м3',
            'places' => 'Места',
            'composition' => 'Состав',
            'age_group' => 'Возрастная группа',
            'max_users' => 'Макс. кол-во пользователей',
            'unit' => 'Ед.',
            'series' => 'Серия',
            'trademark' => 'ТМ',
            'calculator_enabled_txt' => 'Калькулятор',
            'builders_price_txt' => 'строители',
            'wholesale_price_txt' => 'опт',
            'recommended_price_txt' => 'рек',
            'retail_price_txt' => 'розница',
            'project_price_txt' => 'проект',
            'project_with_installation_price_txt' => 'проект+м',
            'pik_price_txt' => 'пик',
            'recommended_plus_10_price_txt' => 'рек+10',
        ],
        'searchFields' => [
            'article',
            'calculator_name',
            'kind',
            'dimension_length',
            'dimension_width',
            'dimension_height',
            'site_length',
            'site_width',
            'additional_info',
            'composition',
            'series',
            'trademark',
        ],
    ];

    public function index(Request $request, FieldAccessService $fieldAccess): View
    {
        session(['gp_common_catalog' => $request->query()]);
        $nav = $this->startNavigationContext($request);
        $model = new CommonCatalogItem;
        $readableFields = $this->readableFields($request, $fieldAccess);
        $request = $this->sanitizeListRequest($request, $readableFields);
        $this->data['header'] = $fieldAccess->visibleHeaders(
            $request->user(),
            'common-catalog',
            $this->data['header'],
        );
        $this->data['searchFields'] = array_values(array_intersect(
            $this->data['searchFields'],
            $readableFields,
        ));

        $this->createFilters(
            $model,
            ...array_values(array_intersect([
                'kind',
                'dimension_unit',
                'age_group',
                'unit',
                'series',
                'trademark',
            ], $readableFields)),
        );
        $this->createRangeFilters(
            $model,
            ...array_values(array_intersect([
                'fall_height',
                'weight',
                'volume',
                'places',
                'max_users',
                'builders_price',
                'wholesale_price',
                'recommended_price',
                'retail_price',
                'project_price',
                'project_with_installation_price',
                'pik_price',
                'recommended_plus_10_price',
            ], $readableFields)),
        );

        $query = CommonCatalogItem::query()->with('imageFile');
        $this->acceptFilters($query, $request);
        $this->acceptSearch($query, $request);
        $this->setSortAndOrderBy($model, $request);
        $this->applyStableSorting($query);

        $this->data['items'] = $query->paginate($this->data['per_page'])->withQueryString();
        $this->data['nav'] = $nav;
        $priceField = Setting::technicalDescriptionPriceField();
        $this->data['technicalDescriptionModes'] = TechnicalDescriptionService::DESCRIPTION_MODES;
        $this->data['canExportTechnicalDescriptions'] = $request->user()->canViewField(
            'common-catalog',
            $priceField,
        );

        return view('common_catalog.index', $this->data);
    }

    public function create(Request $request, FieldAccessService $fieldAccess): View
    {
        return $this->itemView($request, $fieldAccess);
    }

    public function show(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        FieldAccessService $fieldAccess,
    ): View
    {
        return $this->itemView(
            $request,
            $fieldAccess,
            $commonCatalogItem->load(['imageFile', 'documents']),
        );
    }

    public function store(
        StoreCommonCatalogItemRequest $request,
        FieldAccessService $fieldAccess,
    ): RedirectResponse
    {
        $item = CommonCatalogItem::query()->create(
            $fieldAccess->filterValidatedPayload(
                $request->user(),
                'common-catalog',
                $request->validated(),
            ),
        );

        return redirect()
            ->route('common-catalog.show', $this->withNav(
                ['commonCatalogItem' => $item],
                $this->resolveNavToken($request),
            ))
            ->with('success', 'Позиция общего каталога создана.');
    }

    public function update(
        StoreCommonCatalogItemRequest $request,
        CommonCatalogItem $commonCatalogItem,
        FieldAccessService $fieldAccess,
    ): RedirectResponse {
        $commonCatalogItem->update($fieldAccess->filterValidatedPayload(
            $request->user(),
            'common-catalog',
            $request->validated(),
        ));

        return $this->redirectToItem($request, $commonCatalogItem)
            ->with('success', 'Позиция общего каталога обновлена.');
    }

    public function destroy(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        FileService $fileService,
    ): RedirectResponse {
        $commonCatalogItem->load(['imageFile', 'documents']);
        $files = $commonCatalogItem->documents;
        if ($commonCatalogItem->imageFile) {
            $files->push($commonCatalogItem->imageFile);
        }

        $commonCatalogItem->documents()->detach();
        $commonCatalogItem->update(['image_file_id' => null]);
        $commonCatalogItem->delete();

        foreach ($files->unique('id') as $file) {
            $fileService->deleteFileWithThumbnail($file);
            $file->delete();
        }

        return redirect()
            ->route('common-catalog.index', session('gp_common_catalog'))
            ->with('success', 'Позиция общего каталога удалена.');
    }

    public function uploadImage(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        FileService $fileService,
    ): RedirectResponse {
        $data = $request->validate([
            'image' => ['required', 'image', 'mimes:jpg,jpeg,png,webp', 'max:10240'],
        ]);

        try {
            $oldImage = $commonCatalogItem->imageFile;
            $image = $fileService->saveUploadedFile(
                "common_catalog/items/{$commonCatalogItem->id}/image",
                $data['image'],
            );
            $commonCatalogItem->update(['image_file_id' => $image->id]);

            if ($oldImage) {
                $fileService->deleteFileWithThumbnail($oldImage);
                $oldImage->delete();
            }
        } catch (Throwable $exception) {
            report($exception);

            return $this->redirectToItem($request, $commonCatalogItem)
                ->with('error', 'Не удалось загрузить изображение.');
        }

        return $this->redirectToItem($request, $commonCatalogItem)
            ->with('success', 'Изображение загружено.');
    }

    public function deleteImage(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        FileService $fileService,
    ): RedirectResponse {
        $image = $commonCatalogItem->imageFile;
        if ($image) {
            $commonCatalogItem->update(['image_file_id' => null]);
            $fileService->deleteFileWithThumbnail($image);
            $image->delete();
        }

        return $this->redirectToItem($request, $commonCatalogItem)
            ->with('success', 'Изображение удалено.');
    }

    public function uploadDocument(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        FileService $fileService,
    ): RedirectResponse {
        $data = $request->validate([
            'document' => ['required', 'file', 'max:20480'],
        ]);

        try {
            $document = $fileService->saveUploadedFile(
                "common_catalog/items/{$commonCatalogItem->id}/documents",
                $data['document'],
            );
            $commonCatalogItem->documents()->attach($document);
        } catch (Throwable $exception) {
            report($exception);

            return $this->redirectToItem($request, $commonCatalogItem)
                ->with('error', 'Не удалось загрузить документ.');
        }

        return $this->redirectToItem($request, $commonCatalogItem)
            ->with('success', 'Документ загружен.');
    }

    public function deleteDocument(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
        File $file,
        FileService $fileService,
    ): RedirectResponse {
        abort_unless($commonCatalogItem->documents()->whereKey($file->getKey())->exists(), 404);

        $commonCatalogItem->documents()->detach($file);
        $fileService->deleteFileWithThumbnail($file);
        $file->delete();

        return $this->redirectToItem($request, $commonCatalogItem)
            ->with('success', 'Документ удалён.');
    }

    public function export(Request $request): RedirectResponse
    {
        ExportCommonCatalogJob::dispatch((int) $request->user()->getKey());

        return redirect()
            ->route('common-catalog.index', session('gp_common_catalog'))
            ->with('success', 'Задача экспорта общего каталога создана.');
    }

    public function import(Request $request): RedirectResponse
    {
        $data = $request->validate([
            'import_file' => ['required', 'file', 'mimes:xlsx', 'max:20480'],
        ]);

        $path = Str::random(2).'/'.Str::uuid().'.xlsx';
        Storage::disk('upload')->put($path, $data['import_file']->getContent());

        $import = Import::query()->create([
            'type' => 'common_catalog',
            'year' => null,
            'filename' => $path,
            'status' => 'new',
            'user_id' => $request->user()->getKey(),
            'original_filename' => $data['import_file']->getClientOriginalName(),
        ]);

        ImportJob::dispatch($import, (int) $request->user()->getKey());

        return redirect()
            ->route('common-catalog.index', session('gp_common_catalog'))
            ->with('success', 'Задача импорта общего каталога создана.');
    }

    public function exportTechnicalDescriptions(
        Request $request,
        AccessService $accessService,
    ): RedirectResponse {
        $data = $request->validate([
            'item_ids' => ['required', 'array', 'min:1', 'max:1000'],
            'item_ids.*' => ['required', 'integer', 'distinct', 'exists:common_catalog_items,id'],
            'description_mode' => [
                'required',
                'string',
                Rule::in(array_keys(TechnicalDescriptionService::DESCRIPTION_MODES)),
            ],
            'separate_documents' => ['nullable', 'boolean'],
        ]);

        $priceField = Setting::technicalDescriptionPriceField();
        abort_unless(
            $accessService->canViewField($request->user(), 'common-catalog', $priceField),
            403,
            'Нет доступа к выбранному для технических описаний виду цены.',
        );

        ExportTechnicalDescriptionsJob::dispatch(
            array_values(array_map('intval', $data['item_ids'])),
            $data['description_mode'],
            (bool) ($data['separate_documents'] ?? false),
            (int) $request->user()->getKey(),
        );

        return back()->with('success', 'Задача экспорта технических описаний создана.');
    }

    public function downloadTechnicalDescription(Request $request, File $file): StreamedResponse
    {
        abort_unless($file->is_generated, 404);
        abort_unless(
            Str::startsWith((string) $file->path, 'generated/technical-descriptions/'),
            404,
        );
        abort_unless(
            (int) $file->user_id === (int) $request->user()->getKey()
                || $request->user()->hasRole(Role::ADMIN),
            403,
        );
        abort_unless(Storage::disk('local')->exists((string) $file->path), 404);

        return Storage::disk('local')->download(
            (string) $file->path,
            (string) $file->original_name,
        );
    }

    private function itemView(
        Request $request,
        FieldAccessService $fieldAccess,
        ?CommonCatalogItem $item = null,
    ): View
    {
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('common-catalog.index', session('gp_common_catalog')),
        );
        $this->data['item'] = $item;
        $fields = array_keys(config('access.common-catalog.fields', []));
        $this->data['commonCatalogReadableFields'] = array_fill_keys(
            $fieldAccess->filterReadableFields($request->user(), 'common-catalog', $fields),
            true,
        );
        $this->data['commonCatalogWritableFields'] = [];
        foreach ($fields as $field) {
            $this->data['commonCatalogWritableFields'][$field] = $request->user()
                ->canUpdateField('common-catalog', $field);
        }
        $priceField = Setting::technicalDescriptionPriceField();
        $this->data['technicalDescriptionPriceField'] = $priceField;
        $this->data['technicalDescriptionPriceLabel'] = CommonCatalogItem::PRICE_FIELDS[$priceField];
        $this->data['canViewTechnicalDescriptionPrice'] = $request->user()->canViewField(
            'common-catalog',
            $priceField,
        );
        $this->data['technicalDescriptionModes'] = TechnicalDescriptionService::DESCRIPTION_MODES;

        return view('common_catalog.edit', $this->data);
    }

    private function readableFields(Request $request, FieldAccessService $fieldAccess): array
    {
        return $fieldAccess->filterReadableFields(
            $request->user(),
            'common-catalog',
            array_keys(config('access.common-catalog.fields', [])),
        );
    }

    private function sanitizeListRequest(Request $request, array $readableFields): Request
    {
        if (
            $request->filled('sortBy')
            && ! in_array($this->normalizeField($request->string('sortBy')->toString()), $readableFields, true)
        ) {
            $request->merge(['sortBy' => CommonCatalogItem::DEFAULT_SORT_BY]);
        }

        if ($request->has('filters') && is_array($request->input('filters'))) {
            $request->merge([
                'filters' => array_filter(
                    $request->input('filters'),
                    fn (mixed $value, string $field): bool => in_array(
                        $this->normalizeField($field),
                        $readableFields,
                        true,
                    ),
                    ARRAY_FILTER_USE_BOTH,
                ),
            ]);
        }

        return $request;
    }

    private function normalizeField(string $field): string
    {
        $field = preg_replace('/_(from|to)$/', '', $field) ?: $field;

        return str_ends_with($field, '_txt') ? substr($field, 0, -4) : $field;
    }

    private function redirectToItem(
        Request $request,
        CommonCatalogItem $commonCatalogItem,
    ): RedirectResponse {
        return redirect()->route('common-catalog.show', $this->withNav(
            ['commonCatalogItem' => $commonCatalogItem],
            $this->resolveNavToken($request),
        ));
    }
}