]> git.immae.eu Git - github/Chocobozzz/PeerTube.git/blob - server/controllers/api/search.ts
e08e1d79fa15baea1ec64193c49e30e9e6d31cdc
[github/Chocobozzz/PeerTube.git] / server / controllers / api / search.ts
1 import * as express from 'express'
2 import { sanitizeUrl } from '@server/helpers/core-utils'
3 import { doRequest } from '@server/helpers/requests'
4 import { CONFIG } from '@server/initializers/config'
5 import { getOrCreateVideoAndAccountAndChannel } from '@server/lib/activitypub/videos'
6 import { AccountBlocklistModel } from '@server/models/account/account-blocklist'
7 import { getServerActor } from '@server/models/application/application'
8 import { ServerBlocklistModel } from '@server/models/server/server-blocklist'
9 import { ResultList, Video, VideoChannel } from '@shared/models'
10 import { SearchTargetQuery } from '@shared/models/search/search-target-query.model'
11 import { VideoChannelsSearchQuery, VideosSearchQuery } from '../../../shared/models/search'
12 import { buildNSFWFilter, isUserAbleToSearchRemoteURI } from '../../helpers/express-utils'
13 import { logger } from '../../helpers/logger'
14 import { getFormattedObjects } from '../../helpers/utils'
15 import { loadActorUrlOrGetFromWebfinger } from '../../helpers/webfinger'
16 import { getOrCreateActorAndServerAndModel } from '../../lib/activitypub/actor'
17 import {
18 asyncMiddleware,
19 commonVideosFiltersValidator,
20 optionalAuthenticate,
21 paginationValidator,
22 setDefaultPagination,
23 setDefaultSearchSort,
24 videoChannelsSearchSortValidator,
25 videoChannelsSearchValidator,
26 videosSearchSortValidator,
27 videosSearchValidator
28 } from '../../middlewares'
29 import { VideoModel } from '../../models/video/video'
30 import { VideoChannelModel } from '../../models/video/video-channel'
31 import { MChannelAccountDefault, MVideoAccountLightBlacklistAllFiles } from '../../typings/models'
32
33 const searchRouter = express.Router()
34
35 searchRouter.get('/videos',
36 paginationValidator,
37 setDefaultPagination,
38 videosSearchSortValidator,
39 setDefaultSearchSort,
40 optionalAuthenticate,
41 commonVideosFiltersValidator,
42 videosSearchValidator,
43 asyncMiddleware(searchVideos)
44 )
45
46 searchRouter.get('/video-channels',
47 paginationValidator,
48 setDefaultPagination,
49 videoChannelsSearchSortValidator,
50 setDefaultSearchSort,
51 optionalAuthenticate,
52 videoChannelsSearchValidator,
53 asyncMiddleware(searchVideoChannels)
54 )
55
56 // ---------------------------------------------------------------------------
57
58 export { searchRouter }
59
60 // ---------------------------------------------------------------------------
61
62 function searchVideoChannels (req: express.Request, res: express.Response) {
63 const query: VideoChannelsSearchQuery = req.query
64 const search = query.search
65
66 const isURISearch = search.startsWith('http://') || search.startsWith('https://')
67
68 const parts = search.split('@')
69
70 // Handle strings like @toto@example.com
71 if (parts.length === 3 && parts[0].length === 0) parts.shift()
72 const isWebfingerSearch = parts.length === 2 && parts.every(p => p && !p.includes(' '))
73
74 if (isURISearch || isWebfingerSearch) return searchVideoChannelURI(search, isWebfingerSearch, res)
75
76 // @username -> username to search in DB
77 if (query.search.startsWith('@')) query.search = query.search.replace(/^@/, '')
78
79 if (isSearchIndexEnabled(query)) {
80 return searchVideoChannelsIndex(query, res)
81 }
82
83 return searchVideoChannelsDB(query, res)
84 }
85
86 async function searchVideoChannelsIndex (query: VideoChannelsSearchQuery, res: express.Response) {
87 logger.debug('Doing channels search on search index.')
88
89 const result = await buildMutedForSearchIndex(res)
90
91 const body = Object.assign(query, result)
92
93 const url = sanitizeUrl(CONFIG.SEARCH.SEARCH_INDEX.URL) + '/api/v1/search/video-channels'
94
95 try {
96 const searchIndexResult = await doRequest<ResultList<VideoChannel>>({ uri: url, body, json: true })
97
98 return res.json(searchIndexResult.body)
99 } catch (err) {
100 logger.warn('Cannot use search index to make video channels search.', { err })
101
102 return res.sendStatus(500)
103 }
104 }
105
106 async function searchVideoChannelsDB (query: VideoChannelsSearchQuery, res: express.Response) {
107 const serverActor = await getServerActor()
108
109 const options = {
110 actorId: serverActor.id,
111 search: query.search,
112 start: query.start,
113 count: query.count,
114 sort: query.sort
115 }
116 const resultList = await VideoChannelModel.searchForApi(options)
117
118 return res.json(getFormattedObjects(resultList.data, resultList.total))
119 }
120
121 async function searchVideoChannelURI (search: string, isWebfingerSearch: boolean, res: express.Response) {
122 let videoChannel: MChannelAccountDefault
123 let uri = search
124
125 if (isWebfingerSearch) {
126 try {
127 uri = await loadActorUrlOrGetFromWebfinger(search)
128 } catch (err) {
129 logger.warn('Cannot load actor URL or get from webfinger.', { search, err })
130
131 return res.json({ total: 0, data: [] })
132 }
133 }
134
135 if (isUserAbleToSearchRemoteURI(res)) {
136 try {
137 const actor = await getOrCreateActorAndServerAndModel(uri, 'all', true, true)
138 videoChannel = actor.VideoChannel
139 } catch (err) {
140 logger.info('Cannot search remote video channel %s.', uri, { err })
141 }
142 } else {
143 videoChannel = await VideoChannelModel.loadByUrlAndPopulateAccount(uri)
144 }
145
146 return res.json({
147 total: videoChannel ? 1 : 0,
148 data: videoChannel ? [ videoChannel.toFormattedJSON() ] : []
149 })
150 }
151
152 function searchVideos (req: express.Request, res: express.Response) {
153 const query: VideosSearchQuery = req.query
154 const search = query.search
155
156 if (search && (search.startsWith('http://') || search.startsWith('https://'))) {
157 return searchVideoURI(search, res)
158 }
159
160 if (isSearchIndexEnabled(query)) {
161 return searchVideosIndex(query, res)
162 }
163
164 return searchVideosDB(query, res)
165 }
166
167 async function searchVideosIndex (query: VideosSearchQuery, res: express.Response) {
168 logger.debug('Doing videos search on search index.')
169
170 const result = await buildMutedForSearchIndex(res)
171
172 const body = Object.assign(query, result)
173
174 const url = sanitizeUrl(CONFIG.SEARCH.SEARCH_INDEX.URL) + '/api/v1/search/videos'
175
176 try {
177 const searchIndexResult = await doRequest<ResultList<Video>>({ uri: url, body, json: true })
178
179 return res.json(searchIndexResult.body)
180 } catch (err) {
181 logger.warn('Cannot use search index to make video search.', { err })
182
183 return res.sendStatus(500)
184 }
185 }
186
187 async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
188 const options = Object.assign(query, {
189 includeLocalVideos: true,
190 nsfw: buildNSFWFilter(res, query.nsfw),
191 filter: query.filter,
192 user: res.locals.oauth ? res.locals.oauth.token.User : undefined
193 })
194 const resultList = await VideoModel.searchAndPopulateAccountAndServer(options)
195
196 return res.json(getFormattedObjects(resultList.data, resultList.total))
197 }
198
199 async function searchVideoURI (url: string, res: express.Response) {
200 let video: MVideoAccountLightBlacklistAllFiles
201
202 // Check if we can fetch a remote video with the URL
203 if (isUserAbleToSearchRemoteURI(res)) {
204 try {
205 const syncParam = {
206 likes: false,
207 dislikes: false,
208 shares: false,
209 comments: false,
210 thumbnail: true,
211 refreshVideo: false
212 }
213
214 const result = await getOrCreateVideoAndAccountAndChannel({ videoObject: url, syncParam })
215 video = result ? result.video : undefined
216 } catch (err) {
217 logger.info('Cannot search remote video %s.', url, { err })
218 }
219 } else {
220 video = await VideoModel.loadByUrlAndPopulateAccount(url)
221 }
222
223 return res.json({
224 total: video ? 1 : 0,
225 data: video ? [ video.toFormattedJSON() ] : []
226 })
227 }
228
229 function isSearchIndexEnabled (query: SearchTargetQuery) {
230 if (query.searchTarget === 'search-index') return true
231
232 const searchIndexConfig = CONFIG.SEARCH.SEARCH_INDEX
233
234 if (searchIndexConfig.ENABLED !== true) return false
235
236 if (searchIndexConfig.DISABLE_LOCAL_SEARCH) return true
237 if (searchIndexConfig.IS_DEFAULT_SEARCH && !query.searchTarget) return true
238
239 return false
240 }
241
242 async function buildMutedForSearchIndex (res: express.Response) {
243 const serverActor = await getServerActor()
244 const accountIds = [ serverActor.Account.id ]
245
246 if (res.locals.oauth) {
247 accountIds.push(res.locals.oauth.token.User.Account.id)
248 }
249
250 const [ blockedHosts, blockedAccounts ] = await Promise.all([
251 ServerBlocklistModel.listHostsBlockedBy(accountIds),
252 AccountBlocklistModel.listHandlesBlockedBy(accountIds)
253 ])
254
255 return {
256 blockedHosts,
257 blockedAccounts
258 }
259 }