nshop/packages/Longyi/ImageUpload/src/Http/Controllers/Admin/ImageUploadController.php

<?php

namespace Longyi\ImageUpload\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use Illuminate\Http\Request;
use Longyi\ImageUpload\Models\ImageFolder;
use Longyi\ImageUpload\Models\ImageUpload as ImageUploadModel;
use Longyi\ImageUpload\Services\ImageUploadService;
use Exception;

class ImageUploadController extends Controller
{
    /**
     * @var ImageUploadService
     */
    protected $imageUploadService;

    /**
     * Create a new controller instance.
     *
     * @param ImageUploadService $imageUploadService
     */
    public function __construct(ImageUploadService $imageUploadService)
    {
        $this->imageUploadService = $imageUploadService;
    }

    /**
     * Upload a single image.
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function upload(Request $request)
    {
        try {
            $request->validate([
                'image' => 'required|file',
                'directory' => 'nullable|string',
            ]);

            $file = $request->file('image');
            $directory = $request->input('directory');

            $result = $this->imageUploadService->upload($file, $directory);

            return response()->json([
                'success' => true,
                'message' => __('Image uploaded successfully'),
                'data' => $result,
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Upload multiple images.
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function uploadMultiple(Request $request)
    {
        try {
            $request->validate([
                'images' => 'required|array',
                'images.*' => 'file',
                'directory' => 'nullable|string',
            ]);

            $files = $request->file('images');
            $directory = 'uploads/'.$request->input('directory');

            $results = $this->imageUploadService->uploadMultiple($files, $directory);

            // 解析 folder_id：如果传了 directory，按目录名查找文件夹
            $folderId = 0;
            if (! empty($directory)) {
                $folder = ImageFolder::where('path', $directory)->first();
                $folderId = $folder ? $folder->id : 0;
            }

            // 将上传成功的图片记录写入 image_uploads 表
            foreach ($results as $result) {
                if (! empty($result['success'])) {
                    ImageUploadModel::create([
                        'folder_id'      => $folderId,
                        'original_name'  => $result['original_name'] ?? '',
                        'file_name'      => basename($result['path'] ?? ''),
                        'file_path'      => $result['path'] ?? '',
                        'file_url'       => $result['url'] ?? '',
                        'mime_type'      => $result['mime_type'] ?? '',
                        'file_size'      => $result['size'] ?? 0,
                        'disk'           => $result['disk'] ?? 's3',
                    ]);
                }
            }

            $successCount = count(array_filter($results, fn($r) => $r['success'] ?? false));
            $failedCount = count($results) - $successCount;

            return response()->json([
                'success' => true,
                'message' => __(':success images uploaded successfully, :failed failed', [
                    'success' => $successCount,
                    'failed' => $failedCount,
                ]),
                'data' => $results,
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Delete an image (S3 + database record).
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function delete(Request $request)
    {
        try {
            $request->validate([
                'path' => 'required|string',
                'disk' => 'nullable|string',
            ]);

            $path = $request->input('path');
            $disk = $request->input('disk');

            // 删除 S3 文件
            $deleted = $this->imageUploadService->delete($path, $disk);

            // 同时删除数据库记录
            ImageUploadModel::where('file_path', $path)->delete();

            return response()->json([
                'success' => true,
                'message' => __('Image deleted successfully'),
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Get image URL.
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function getUrl(Request $request)
    {
        try {
            $request->validate([
                'path' => 'required|string',
                'disk' => 'nullable|string',
            ]);

            $path = $request->input('path');
            $disk = $request->input('disk');

            $url = $this->imageUploadService->getUrl($path, $disk);

            return response()->json([
                'success' => true,
                'url' => $url,
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Get folders list (from database).
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function getFolders(Request $request)
    {
        try {
            $folders = ImageFolder::orderBy('created_at', 'desc')->get()->map(function ($folder) {
                return [
                    'id'   => $folder->id,
                    'name' => $folder->name,
                    'path' => $folder->path,
                ];
            });

            return response()->json([
                'success' => true,
                'data'    => [
                    'folders' => $folders,
                ],
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Create a folder (database only, no S3).
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function createFolder(Request $request)
    {
        try {
            $request->validate([
                'folder_name'   => 'required|string|max:255',
                'parent_folder' => 'nullable|string',
            ]);

            $folderName   = trim($request->input('folder_name'));
            $parentFolder = trim($request->input('parent_folder', ''));

            // 检查同名文件夹
            $exists = ImageFolder::where('name', $folderName)
                ->where('parent_id', 0)
                ->exists();

            if ($exists) {
                return response()->json([
                    'success' => false,
                    'message' => __('Folder already exists'),
                ], 422);
            }

            $basePath = config('image_upload.upload_directory', 'uploads');
            $folder = ImageFolder::create([
                'name'      => $folderName,
                'parent_id' => 0,
                'path'      => $basePath . '/' . $folderName,
            ]);

            return response()->json([
                'success' => true,
                'message' => __('Folder created successfully'),
                'data'    => [
                    'id'   => $folder->id,
                    'name' => $folder->name,
                    'path' => $folder->path,
                ],
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Delete a folder (database + related images on S3).
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function deleteFolder(Request $request)
    {
        try {
            $request->validate([
                'folder_id' => 'required|integer',
            ]);

            $folderId = $request->input('folder_id');
            $folder = ImageFolder::findOrFail($folderId);

            // 删除该文件夹下所有图片的 S3 文件和数据库记录
            $images = ImageUploadModel::where('folder_id', $folderId)->get();
            foreach ($images as $image) {
                // 从 S3 删除图片文件
                try {
                    $this->imageUploadService->delete($image->file_path, $image->disk);
                } catch (\Exception $e) {
                    // S3 删除失败不影响数据库删除
                }
                $image->delete();
            }

            // 删除文件夹记录
            $folder->delete();

            return response()->json([
                'success' => true,
                'message' => __('Folder deleted successfully'),
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }

    /**
     * Get images in a folder (from database).
     *
     * @param Request $request
     * @return \Illuminate\Http\JsonResponse
     */
    public function getImages(Request $request)
    {
        try {
            $folderId = $request->input('folder_id', 0);

            $query = ImageUploadModel::orderBy('created_at', 'desc');

            if ($folderId > 0) {
                $query->where('folder_id', $folderId);
            } else {
                $query->where('folder_id', 0);
            }

            $images = $query->get()->map(function ($image) {
                return [
                    'id'            => $image->id,
                    'path'          => $image->file_path,
                    'name'          => $image->original_name,
                    'url'           => $image->file_url,
                    'size'          => $image->file_size,
                    'mime_type'     => $image->mime_type,
                    'last_modified' => $image->updated_at->timestamp,
                ];
            });

            return response()->json([
                'success' => true,
                'data'    => $images,
            ]);
        } catch (Exception $e) {
            return response()->json([
                'success' => false,
                'message' => $e->getMessage(),
            ], 422);
        }
    }
}