server/controllers/api/search.ts

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