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 { getOrCreateAPVideo } 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 { getOrCreateAPActor } from '../../lib/activitypub/actors'
  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.fail({
 106       status: HttpStatusCode.INTERNAL_SERVER_ERROR_500,
 107       message: 'Cannot use search index to make video channels search'
 108     })
 109   }
 110 }
 111
 112 async function searchVideoChannelsDB (query: VideoChannelsSearchQuery, res: express.Response) {
 113   const serverActor = await getServerActor()
 114
 115   const apiOptions = await Hooks.wrapObject({
 116     actorId: serverActor.id,
 117     search: query.search,
 118     start: query.start,
 119     count: query.count,
 120     sort: query.sort
 121   }, 'filter:api.search.video-channels.local.list.params')
 122
 123   const resultList = await Hooks.wrapPromiseFun(
 124     VideoChannelModel.searchForApi,
 125     apiOptions,
 126     'filter:api.search.video-channels.local.list.result'
 127   )
 128
 129   return res.json(getFormattedObjects(resultList.data, resultList.total))
 130 }
 131
 132 async function searchVideoChannelURI (search: string, isWebfingerSearch: boolean, res: express.Response) {
 133   let videoChannel: MChannelAccountDefault
 134   let uri = search
 135
 136   if (isWebfingerSearch) {
 137     try {
 138       uri = await loadActorUrlOrGetFromWebfinger(search)
 139     } catch (err) {
 140       logger.warn('Cannot load actor URL or get from webfinger.', { search, err })
 141
 142       return res.json({ total: 0, data: [] })
 143     }
 144   }
 145
 146   if (isUserAbleToSearchRemoteURI(res)) {
 147     try {
 148       const actor = await getOrCreateAPActor(uri, 'all', true, true)
 149       videoChannel = actor.VideoChannel
 150     } catch (err) {
 151       logger.info('Cannot search remote video channel %s.', uri, { err })
 152     }
 153   } else {
 154     videoChannel = await VideoChannelModel.loadByUrlAndPopulateAccount(uri)
 155   }
 156
 157   return res.json({
 158     total: videoChannel ? 1 : 0,
 159     data: videoChannel ? [ videoChannel.toFormattedJSON() ] : []
 160   })
 161 }
 162
 163 function searchVideos (req: express.Request, res: express.Response) {
 164   const query: VideosSearchQuery = req.query
 165   const search = query.search
 166
 167   if (search && (search.startsWith('http://') || search.startsWith('https://'))) {
 168     return searchVideoURI(search, res)
 169   }
 170
 171   if (isSearchIndexSearch(query)) {
 172     return searchVideosIndex(query, res)
 173   }
 174
 175   return searchVideosDB(query, res)
 176 }
 177
 178 async function searchVideosIndex (query: VideosSearchQuery, res: express.Response) {
 179   const result = await buildMutedForSearchIndex(res)
 180
 181   let body: VideosSearchQuery = Object.assign(query, result)
 182
 183   // Use the default instance NSFW policy if not specified
 184   if (!body.nsfw) {
 185     const nsfwPolicy = res.locals.oauth
 186       ? res.locals.oauth.token.User.nsfwPolicy
 187       : CONFIG.INSTANCE.DEFAULT_NSFW_POLICY
 188
 189     body.nsfw = nsfwPolicy === 'do_not_list'
 190       ? 'false'
 191       : 'both'
 192   }
 193
 194   body = await Hooks.wrapObject(body, 'filter:api.search.videos.index.list.params')
 195
 196   const url = sanitizeUrl(CONFIG.SEARCH.SEARCH_INDEX.URL) + '/api/v1/search/videos'
 197
 198   try {
 199     logger.debug('Doing videos search index request on %s.', url, { body })
 200
 201     const { body: searchIndexResult } = await doJSONRequest<ResultList<Video>>(url, { method: 'POST', json: body })
 202     const jsonResult = await Hooks.wrapObject(searchIndexResult, 'filter:api.search.videos.index.list.result')
 203
 204     return res.json(jsonResult)
 205   } catch (err) {
 206     logger.warn('Cannot use search index to make video search.', { err })
 207
 208     return res.fail({
 209       status: HttpStatusCode.INTERNAL_SERVER_ERROR_500,
 210       message: 'Cannot use search index to make video search'
 211     })
 212   }
 213 }
 214
 215 async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
 216   const apiOptions = await Hooks.wrapObject(Object.assign(query, {
 217     includeLocalVideos: true,
 218     nsfw: buildNSFWFilter(res, query.nsfw),
 219     filter: query.filter,
 220     user: res.locals.oauth ? res.locals.oauth.token.User : undefined
 221   }), 'filter:api.search.videos.local.list.params')
 222
 223   const resultList = await Hooks.wrapPromiseFun(
 224     VideoModel.searchAndPopulateAccountAndServer,
 225     apiOptions,
 226     'filter:api.search.videos.local.list.result'
 227   )
 228
 229   return res.json(getFormattedObjects(resultList.data, resultList.total))
 230 }
 231
 232 async function searchVideoURI (url: string, res: express.Response) {
 233   let video: MVideoAccountLightBlacklistAllFiles
 234
 235   // Check if we can fetch a remote video with the URL
 236   if (isUserAbleToSearchRemoteURI(res)) {
 237     try {
 238       const syncParam = {
 239         likes: false,
 240         dislikes: false,
 241         shares: false,
 242         comments: false,
 243         thumbnail: true,
 244         refreshVideo: false
 245       }
 246
 247       const result = await getOrCreateAPVideo({ videoObject: url, syncParam })
 248       video = result ? result.video : undefined
 249     } catch (err) {
 250       logger.info('Cannot search remote video %s.', url, { err })
 251     }
 252   } else {
 253     video = await VideoModel.loadByUrlAndPopulateAccount(url)
 254   }
 255
 256   return res.json({
 257     total: video ? 1 : 0,
 258     data: video ? [ video.toFormattedJSON() ] : []
 259   })
 260 }
 261
 262 function isSearchIndexSearch (query: SearchTargetQuery) {
 263   if (query.searchTarget === 'search-index') return true
 264
 265   const searchIndexConfig = CONFIG.SEARCH.SEARCH_INDEX
 266
 267   if (searchIndexConfig.ENABLED !== true) return false
 268
 269   if (searchIndexConfig.DISABLE_LOCAL_SEARCH) return true
 270   if (searchIndexConfig.IS_DEFAULT_SEARCH && !query.searchTarget) return true
 271
 272   return false
 273 }
 274
 275 async function buildMutedForSearchIndex (res: express.Response) {
 276   const serverActor = await getServerActor()
 277   const accountIds = [ serverActor.Account.id ]
 278
 279   if (res.locals.oauth) {
 280     accountIds.push(res.locals.oauth.token.User.Account.id)
 281   }
 282
 283   const [ blockedHosts, blockedAccounts ] = await Promise.all([
 284     ServerBlocklistModel.listHostsBlockedBy(accountIds),
 285     AccountBlocklistModel.listHandlesBlockedBy(accountIds)
 286   ])
 287
 288   return {
 289     blockedHosts,
 290     blockedAccounts
 291   }
 292 }