通过兰空图床为博客实现首页随机图

1
<?php
2

3
namespace App\Http\Controllers\Api\V1;
4

5
use App\Http\Controllers\Controller;
6
use App\Models\Image;
7
use App\Models\Strategy;
8
use App\Models\User;
9
use Illuminate\Http\Request;
10
use Illuminate\Http\Response;
11
use Illuminate\Support\Facades\Auth;
12

13
class  RandomImageController  extends  Controller
14
{
15
    /**
16
     * 随机获取用户的一张图片（不限制存储策略）
17
     * 支持参数：
18
     * - type: 文件类型，如 png, jpg, mp4
19
     * - format: 返回格式 json/url/raw
20
     * 支持三种返回方式：
21
     * - 默认：返回图片信息JSON
22
     * - ?format=url：返回图片URL链接
23
     * - ?format=raw：直接返回图片内容
24
     */
25
    public function random(Request $request): Response
26
    {
27
        $format = $request->query('format', 'json'); // json, url, raw
28
        $type = $request->query('type'); // 文件扩展名，如：jpg, png, mp4
29

30
        /** @var User $user */
31
        $user = Auth::user();
32

33
        $query = $user->images();
34

35
        // 如果指定了文件类型，添加筛选条件
36
        if ($type) {
37
            $query->where('extension', strtolower($type));
38
        }
39

40
        // 随机获取用户的一张图片
41
        $image = $query->inRandomOrder()->first();
42

43
        if (!$image) {
44
            if ($type) {
45
                return $this->fail("没有找到 {$type} 类型的文件");
46
            }
47
            return $this->fail('没有找到图片');
48
        }
49

50
        return $this->formatImageResponse($image, $format);
51
    }
52

53
    /**
54
     * 根据存储策略ID随机获取一张图片
55
     * 支持三种返回方式：
56
     * - 默认：返回图片信息JSON
57
     * - ?format=url：返回图片URL链接
58
     * - ?format=raw：直接返回图片内容
59
     */
60
    public function byStrategy(Request $request): Response
61
    {
62
        $strategyId = $request->route('strategy_id');
63
        $format = $request->query('format', 'json'); // json, url, raw
64

65
        // 验证存储策略是否存在
66
        $strategy = Strategy::find($strategyId);
67
        if (!$strategy) {
68
            return $this->fail('存储策略不存在');
69
        }
70

71
        /** @var User $user */
72
        $user = Auth::user();
73

74
        // 从该存储策略中随机获取用户的一张图片
75
        $image = $user->images()
76
            ->where('strategy_id', $strategyId)
77
            ->inRandomOrder()
78
            ->first();
79

80
        if (!$image) {
81
            return $this->fail('该存储策略下没有找到图片');
82
        }
83

84
        return $this->formatImageResponse($image, $format);
85
    }
86

87
    /**
88
     * 根据相册ID随机获取一张图片
89
     * 支持三种返回方式：
90
     * - 默认：返回图片信息JSON
91
     * - ?format=url：返回图片URL链接
92
     * - ?format=raw：直接返回图片内容
93
     */
94
    public function byAlbum(Request $request): Response
95
    {
96
        $albumId = $request->route('album_id');
97
        $format = $request->query('format', 'json'); // json, url, raw
98

99
        /** @var User $user */
100
        $user = Auth::user();
101

102
        // 验证相册是否存在且属于当前用户
103
        $album = $user->albums()->find($albumId);
104
        if (!$album) {
105
            return $this->fail('相册不存在或无权访问');
106
        }
107

108
        // 从该相册中随机获取一张图片
109
        $image = $user->images()
110
            ->where('album_id', $albumId)
111
            ->inRandomOrder()
112
            ->first();
113

114
        if (!$image) {
115
            return $this->fail('该相册下没有找到图片');
116
        }
117

118
        return $this->formatImageResponse($image, $format);
119
    }
120

121
    /**
122
     * 批量随机获取图片
123
     * 支持参数：
124
     * - count: 获取数量，默认5，最大20
125
     * - strategy_id: 限制存储策略
126
     * - album_id: 限制相册
127
     * - type: 限制文件类型
128
     */
129
    public function batch(Request $request): Response
130
    {
131
        $count = min((int)$request->query('count', 5), 20); // 最多20张
132
        $strategyId = $request->query('strategy_id');
133
        $albumId = $request->query('album_id');
134
        $type = $request->query('type');
135

136
        /** @var User $user */
137
        $user = Auth::user();
138

139
        $query = $user->images();
140

141
        // 添加筛选条件
142
        if ($strategyId) {
143
            $strategy = Strategy::find($strategyId);
144
            if (!$strategy) {
145
                return $this->fail('存储策略不存在');
146
            }
147
            $query->where('strategy_id', $strategyId);
148
        }
149

150
        if ($albumId) {
151
            $album = $user->albums()->find($albumId);
152
            if (!$album) {
153
                return $this->fail('相册不存在或无权访问');
154
            }
155
            $query->where('album_id', $albumId);
156
        }
157

158
        if ($type) {
159
            $query->where('extension', strtolower($type));
160
        }
161

162
        // 随机获取指定数量的图片
163
        $images = $query->inRandomOrder()->limit($count)->get();
164

165
        if ($images->isEmpty()) {
166
            return $this->fail('没有找到符合条件的图片');
167
        }
168

169
        // 格式化返回数据
170
        $images->each(function (Image $image) {
171
            $image->human_date = $image->created_at->diffForHumans();
172
            $image->date = $image->created_at->format('Y-m-d H:i:s');
173
            $image->append(['pathname', 'links'])->setVisible([
174
                'album', 'key', 'name', 'pathname', 'origin_name', 'size', 'mimetype', 'extension', 'md5', 'sha1',
175
                'width', 'height', 'links', 'human_date', 'date',
176
            ]);
177
        });
178

179
        return $this->success('获取成功', [
180
            'count' => $images->count(),
181
            'images' => $images
182
        ]);
183
    }
184

185
    /**
186
     * 格式化图片响应
187
     */
188
    private function formatImageResponse(Image $image, string $format): Response
189
    {
190
        switch ($format) {
191
            case 'url':
192
                // 返回图片URL
193
                return response($image->url, 200, [
194
                    'Content-Type' => 'text/plain',
195
                ]);
196

197
            case 'raw':
198
                // 直接返回图片内容
199
                try {
200
                    $contents = $image->filesystem()->read($image->pathname);
201
                    return response($contents, 200, [
202
                        'Content-Type' => $image->mimetype,
203
                        'Content-Length' => strlen($contents),
204
                        'Cache-Control' => 'public, max-age=3600',
205
                        'Content-Disposition' => 'inline; filename="' . $image->origin_name . '"',
206
                    ]);
207
                } catch (\Exception $e) {
208
                    return $this->fail('读取文件失败');
209
                }
210

211
            default:
212
                // 返回JSON格式的图片信息
213
                $image->human_date = $image->created_at->diffForHumans();
214
                $image->date = $image->created_at->format('Y-m-d H:i:s');
215
                $image->append(['pathname', 'links'])->setVisible([
216
                    'album', 'key', 'name', 'pathname', 'origin_name', 'size', 'mimetype', 'extension', 'md5', 'sha1',
217
                    'width', 'height', 'links', 'human_date', 'date',
218
                ]);
219

220
                return $this->success('获取成功', $image);
221
        }
222
    }
223
}

1
<?php
2

3
use App\Http\Controllers\Api\V1\RandomImageController;//20250801 by Tim
4
use Illuminate\Support\Facades\Route;
5
use App\Http\Controllers\Api\V1\ImageController;
6
use App\Http\Controllers\Api\V1\AlbumController;
7
use App\Http\Controllers\Api\V1\TokenController;
8
use App\Http\Controllers\Api\V1\UserController;
9
use App\Http\Controllers\Api\V1\StrategyController;
10
use App\Http\Middleware\CheckIsEnableApi;
11

12
Route::group([
13
    'prefix' => 'v1',
14
    'middleware' => CheckIsEnableApi::class,
15
], function () {
16
    Route::get('strategies', [StrategyController::class, 'index']);
17
    Route::post('upload', [ImageController::class, 'upload']);
18
    Route::post('tokens', [TokenController::class, 'store'])->middleware('throttle:3,1');
19

20
    Route::group([
21
        'middleware' => 'auth:sanctum',
22
    ], function () {
23
        Route::get('images', [ImageController::class, 'images']);
24
        Route::delete('images/{key}', [ImageController::class, 'destroy']);
25
        Route::get('albums', [AlbumController::class, 'index']);
26
        Route::delete('albums/{id}', [AlbumController::class, 'destroy']);
27
        Route::delete('tokens', [TokenController::class, 'clear']);
28
        Route::get('profile', [UserController::class, 'index']);
29

30
        //20250801 by Tim 新增：随机图片相关路由
31
        Route::get('random-image', [RandomImageController::class, 'random']);
32
        Route::get('strategies/{strategy_id}/random-image', [RandomImageController::class, 'byStrategy']);
33
        Route::get('albums/{album_id}/random-image', [RandomImageController::class, 'byAlbum']);
34
        Route::get('random-images/batch', [RandomImageController::class, 'batch']);
35
    });
36
});

1
export async function onRequest(context) {
2
  const { request, env } = context;
3

4
  // Only allow GET requests
5
  if (request.method !== "GET") {
6
    return new Response("Method Not Allowed", { status: 405 });
7
  }
8

9
  const API_TOKEN = env.LSKY_TOKEN;
10

11
  const LSKY_API_URL =
12
    "此处填入随机接口";
13
  const FALLBACK_IMAGE =
14
    "此处填入默认图URL";
15

16
  const noCacheHeaders = {
17
    "Cache-Control": "no-store, no-cache, must-revalidate",
18
    Pragma: "no-cache",
19
    Expires: "0",
20
  };
21

22
  if (!API_TOKEN) {
23
    console.error("Missing LSKY_TOKEN environment variable");
24
    return Response.redirect(FALLBACK_IMAGE, 302, {
25
      headers: noCacheHeaders,
26
    });
27
  }
28

29
  try {
30
    const res = await fetch(`${LSKY_API_URL}?format=url`, {
31
      headers: {
32
        Authorization: `Bearer ${API_TOKEN}`,
33
        Accept: "application/json",
34
      },
35
    });
36

37
    if (!res.ok) {
38
      throw new Error(`API Error: ${res.status}`);
39
    }
40

41
    const targetUrl = (await res.text()).trim();
42

43
    if (!targetUrl.startsWith("http")) {
44
      throw new Error("Invalid URL received");
45
    }
46

47
    // Temporary redirect for random image (GET only)
48
    return Response.redirect(targetUrl, 302, {
49
      headers: noCacheHeaders,
50
    });
51
  } catch (error) {
52
    console.error("Fetch Random Image Failed:", error);
53
    return Response.redirect(FALLBACK_IMAGE, 302, {
54
      headers: noCacheHeaders,
55
    });
56
  }
57
}