api/app/Http/Controllers/LayerController.php - master - petrhlam/project_moon

api/app/Http/Controllers/LayerController.php
371 строка15 KB
Andrey Sukhikh
Added new python service
19 май 2025, 20:30
19 май 2025, 20:30aced71a
<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;
use App\Models\Layer;
use Illuminate\Support\Facades\Storage;

class LayerController extends Controller
{
    public function index()
    {
        $layer = Layer::all();

        return response()->json([
            'maps' => $layer
        ]);
    }

    public function getLayersByMap($mapId)
    {
        $layers = \App\Models\Layer::where('map_id', $mapId)->get();

        if ($layers->isEmpty()) {
            return response()->json(['message' => 'Layers not found for this map'], 404);
        }

        return response()->json([
            'layers' => $layers->map(function ($layer) {
                return [
                    'id' => $layer->id,
                    'type' => $layer->type,
                    'geoserver_path' => $layer->geoserver_path,
                    'url' => $layer->url,
                ];
            }),
        ]);
    }


    public function uploadSpectral(Request $request)
    {
        $UrlGEO = env('GEOSERVER_URL');

        $request->merge([
            'map_id' => (int) $request->input('map_id'),
        ]);
        // dd($request->all());

        $request->validate([
            'file' => 'required|file|mimes:tif,tiff',
            'map_id' => 'required|numeric|exists:maps,id',

        ], [
            'file.required' => 'Файл обязателен для загрузки.',
            'file.file' => 'Некорректный файл.',
            'file.mimes' => 'Разрешены только файлы формата .tif или .tiff.',
        ]);

        $mapId = $request->input('map_id');

        $file = $request->file('file');
        $filename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME); // без расширения

        // Сохраняем файл локально
        $path = $file->storeAs('uploads', $filename . '.tiff', 'public');
        $filePath = storage_path("app/public/$path");
        $fileContent = file_get_contents($filePath);

        $workspace = 'Moon';
        // $geoserverStore = $filename;
        // $layerName = $filename;
        // $filename = pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME);
        $filename = preg_replace('/[^A-Za-z0-9_\-]/', '_', $filename);
        $filename = mb_convert_encoding($filename, 'UTF-8', 'auto');

        $geoserverStore = $filename;
        $layerName = $filename;
        // $geoserverStore = mb_convert_encoding($filename, 'UTF-8', 'auto');
        // $layerName = mb_convert_encoding($filename, 'UTF-8', 'auto');

        // 1. Создание coverage store
        $createStoreUrl = "$UrlGEO/rest/workspaces/$workspace/coveragestores";

        $storeCreatePayload = [
            'coverageStore' => [
                'name' => $geoserverStore,
                'type' => 'GeoTIFF',
                'enabled' => true,
                'workspace' => $workspace
            ]
        ];

        $createStoreResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders([
                'Content-Type' => 'application/json'
            ])
            ->post($createStoreUrl, $storeCreatePayload);

        if (!$createStoreResponse->successful() && $createStoreResponse->status() !== 401) {
            \Log::error('Ошибка при создании хранилища в GeoServer', [
                'status' => $createStoreResponse->status(),
                'body' => $createStoreResponse->body(),
            ]);

            return response()->json([
                'error' => 'Не удалось создать хранилище в GeoServer.',
                'geoserver_response' => $createStoreResponse->body(), // ← покажет точную причину
                'status' => $createStoreResponse->status()
            ], 500);
        }

        // 2. Загрузка GeoTIFF файла
        $uploadUrl = "$UrlGEO/rest/workspaces/$workspace/coveragestores/$geoserverStore/file.geotiff";

        $uploadResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders([
                'Content-Type' => 'application/geotiff'
            ])
            ->withBody($fileContent, 'application/geotiff')
            ->put($uploadUrl);

        if (!$uploadResponse->successful()) {
            \Log::error('Ошибка загрузки GeoTIFF файла в GeoServer', [
                'status' => $uploadResponse->status(),
                'body' => $uploadResponse->body(),
                'headers' => $uploadResponse->headers()
            ]);

            return response()->json([
                'error' => 'Ошибка загрузки GeoTIFF файла в GeoServer.',
                'geoserver_response' => $uploadResponse->body(),
                'status' => $uploadResponse->status()
            ], 500);
        }

        $publishLayerUrl = "$UrlGEO/rest/workspaces/$workspace/coveragestores/$geoserverStore/coverages";

        $coveragePayload = [
            'coverage' => [
                'name' => $layerName,
                'nativeName' => $layerName,
                'title' => $layerName,
                'srs' => 'EPSG:3010',
                'enabled' => true
            ]
        ];

        $coverageResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders([
                'Content-Type' => 'application/json'
            ])
            ->post($publishLayerUrl, $coveragePayload);

        if (!$coverageResponse->successful()) {
            // Обработка ошибки
        }

        // 3. Обновление свойств слоя (coverage) - PUT запрос для установки projectionPolicy и nativeCRS
        $updateCoverageUrl = "$UrlGEO/rest/workspaces/$workspace/coveragestores/$geoserverStore/coverages/$layerName.json";

        $updatePayload = [
            'coverage' => [
                'projectionPolicy' => 'FORCE_DECLARED',
                'nativeCRS' => 'EPSG:3010',
                'srs' => 'EPSG:3010',
                'enabled' => true
            ]
        ];

        $updateResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders([
                'Content-Type' => 'application/json'
            ])
            ->put($updateCoverageUrl, $updatePayload);

        if (!$updateResponse->successful()) {
            \Log::error('Ошибка обновления свойства слоя в GeoServer', [
                'status' => $updateResponse->status(),
                'response' => $updateResponse->body()
            ]);
            return response()->json([
                'error' => 'Ошибка обновления свойства слоя в GeoServer.',
                'details' => $updateResponse->body(),
                'status' => $updateResponse->status()
            ], 500);
        }
        $wmsUrl = "$UrlGEO/$workspace/wms";

        // 4. Сохраняем в БД
        $layer = new Layer();
        $layer->map_id = $mapId;
        $layer->filename = $filename . '.tiff';
        $layer->geoserver_path = "$workspace:$layerName";
        $layer->url = $wmsUrl;
        $layer->type = "Spectral";
        $layer->save();

        return response()->json([
            'message' => 'Файл успешно загружен и опубликован в GeoServer.',
            'layer' => $layer
        ]);
    }

    public function uploadIsolines(Request $request)
    {
        $UrlGEO = env('GEOSERVER_URL');
        $workspace = 'Moon';

        $request->merge([
            'map_id' => (int) $request->input('map_id'),
        ]);

        $request->validate([
            'map_id' => 'required|numeric|exists:maps,id',
            'file' => 'required|file|mimes:zip',
        ], [
            'map_id.required' => 'ID карты обязателен',
            'file.required' => 'ZIP-файл обязателен',
            'file.mimes' => 'Файл должен быть архивом ZIP',
        ]);

        $mapId = $request->input('map_id');
        $uploadedFile = $request->file('file');
        $filename = pathinfo($uploadedFile->getClientOriginalName(), PATHINFO_FILENAME);
        $filename = preg_replace('/[^A-Za-z0-9_\-]/', '_', $filename);
        $filename = mb_convert_encoding($filename, 'UTF-8', 'auto');

        $dataStoreName = $filename;
        $layerName = $filename;

        // Сохраняем zip временно
        $tempPath = storage_path("app/public/uploads/$filename.zip");
        $uploadedFile->move(dirname($tempPath), basename($tempPath));

        // Отправляем zip в GeoServer
        $url = "$UrlGEO/rest/workspaces/$workspace/datastores/$dataStoreName/file.shp";
        $response = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders([
                'Content-Type' => 'application/zip',
            ])
            ->withBody(file_get_contents($tempPath), 'application/zip')
            ->put($url);

        if (!$response->successful()) {
            \Log::error('Ошибка загрузки ZIP в GeoServer', [
                'status' => $response->status(),
                'body' => $response->body(),
            ]);
            return response()->json([
                'error' => 'Не удалось загрузить ZIP-файл в GeoServer.',
                'geoserver_response' => $response->body(),
                'status' => $response->status()
            ], 500);
        }

        $updateFeatureUrl = "$UrlGEO/rest/workspaces/$workspace/datastores/$dataStoreName/featuretypes/$layerName";
        $updatePayload = [
            'featureType' => [
                'srs' => 'EPSG:3010',
                'nativeCRS' => 'EPSG:3010',
                'projectionPolicy' => 'FORCE_DECLARED',
                'enabled' => true
            ]
        ];

        $updateResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
            ->withHeaders(['Content-Type' => 'application/json'])
            ->put($updateFeatureUrl, $updatePayload);

        if (!$updateResponse->successful()) {
            \Log::error('Ошибка обновления featureType в GeoServer', [
                'status' => $updateResponse->status(),
                'body' => $updateResponse->body(),
            ]);
            return response()->json([
                'error' => 'Ошибка обновления свойств слоя в GeoServer.',
                'geoserver_response' => $updateResponse->body(),
                'status' => $updateResponse->status()
            ], 500);
        }

        // Получаем bounding box
        $featureInfoUrl = "$UrlGEO/rest/workspaces/$workspace/datastores/$dataStoreName/featuretypes/$layerName.json";
        $featureInfoResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))->get($featureInfoUrl);

        if (!$featureInfoResponse->successful()) {
            \Log::error('Ошибка получения информации о featureType из GeoServer', [
                'status' => $featureInfoResponse->status(),
                'body' => $featureInfoResponse->body(),
            ]);
            return response()->json([
                'error' => 'Не удалось получить информацию о слое из GeoServer.',
                'geoserver_response' => $featureInfoResponse->body(),
                'status' => $featureInfoResponse->status()
            ], 500);
        }

        $featureInfo = $featureInfoResponse->json();
        $nativeBBox = $featureInfo['featureType']['nativeBoundingBox'] ?? null;
        $latLonBBox = $featureInfo['featureType']['latLonBoundingBox'] ?? null;


        // Сохраняем слой в БД
        $wmsUrl = "$UrlGEO/$workspace/wms";
        $layer = new Layer();
        $layer->map_id = $mapId;
        $layer->filename = $uploadedFile->getClientOriginalName();
        $layer->geoserver_path = "$workspace:$layerName";
        $layer->url = $wmsUrl;
        $layer->type = "Isolines";
        $layer->save();

        return response()->json([
            'message' => 'ZIP-файл успешно опубликован в GeoServer.',
            'layer' => $layer
        ]);
    }
}


// Публикуем слой (feature type)
// $publishLayerUrl = "$UrlGEO/rest/workspaces/$workspace/datastores/$dataStoreName/featuretypes";
// $featurePayload = [
//     'featureType' => [
//         'name' => $layerName,
//         'title' => $layerName,
//         'srs' => 'EPSG:3010',
//         'nativeCRS' => 'EPSG:3010',
//         'enabled' => true,
//         // 'nativeBoundingBox' => $nativeBBox,
//         // 'latLonBoundingBox' => $latLonBBox,
//     ]
// ];

// $featureResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))
//     ->withHeaders(['Content-Type' => 'application/json'])
//     ->post($publishLayerUrl, $featurePayload);

// if (!$featureResponse->successful() && $featureResponse->status() !== 409) {
//     \Log::error('Ошибка публикации слоя shapefile в GeoServer', [
//         'status' => $featureResponse->status(),
//         'body' => $featureResponse->body(),
//     ]);
//     return response()->json([
//         'error' => 'Ошибка публикации слоя в GeoServer.',
//         'geoserver_response' => $featureResponse->body(),
//         'status' => $featureResponse->status()
//     ], 500);
// }

// // Получаем информацию о featureType, чтобы получить bounding box
// $featureInfoUrl = "$UrlGEO/rest/workspaces/$workspace/datastores/$dataStoreName/featuretypes/$layerName.json";
// $featureInfoResponse = Http::withBasicAuth(env('GEOSERVER_USER'), env('GEOSERVER_PASS'))->get($featureInfoUrl);

// if (!$featureInfoResponse->successful()) {
//     \Log::error('Ошибка получения информации о featureType из GeoServer', [
//         'status' => $featureInfoResponse->status(),
//         'body' => $featureInfoResponse->body(),
//     ]);
//     return response()->json([
//         'error' => 'Не удалось получить информацию о слое из GeoServer.',
//         'geoserver_response' => $featureInfoResponse->body(),
//         'status' => $featureInfoResponse->status()
//     ], 500);
// }

// $featureInfo = $featureInfoResponse->json();
// $nativeBBox = $featureInfo['featureType']['nativeBoundingBox'] ?? null;
// $latLonBBox = $featureInfo['featureType']['latLonBoundingBox'] ?? null;