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 (isSearchIndexSearch(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 (isSearchIndexSearch(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: VideosSearchQuery = Object.assign(query, result)
 173
 174   // Use the default instance NSFW policy if not specified
 175   if (!body.nsfw) {
 176     const nsfwPolicy = res.locals.oauth
 177       ? res.locals.oauth.token.User.nsfwPolicy
 178       : CONFIG.INSTANCE.DEFAULT_NSFW_POLICY
 179
 180     body.nsfw = nsfwPolicy === 'do_not_list'
 181       ? 'false'
 182       : 'both'
 183   }
 184
 185   const url = sanitizeUrl(CONFIG.SEARCH.SEARCH_INDEX.URL) + '/api/v1/search/videos'
 186
 187   try {
 188     const searchIndexResult = await doRequest<ResultList<Video>>({ uri: url, body, json: true })
 189
 190     return res.json(searchIndexResult.body)
 191   } catch (err) {
 192     logger.warn('Cannot use search index to make video search.', { err })
 193
 194     return res.sendStatus(500)
 195   }
 196 }
 197
 198 async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
 199   const options = Object.assign(query, {
 200     includeLocalVideos: true,
 201     nsfw: buildNSFWFilter(res, query.nsfw),
 202     filter: query.filter,
 203     user: res.locals.oauth ? res.locals.oauth.token.User : undefined
 204   })
 205   const resultList = await VideoModel.searchAndPopulateAccountAndServer(options)
 206
 207   return res.json(getFormattedObjects(resultList.data, resultList.total))
 208 }
 209
 210 async function searchVideoURI (url: string, res: express.Response) {
 211   let video: MVideoAccountLightBlacklistAllFiles
 212
 213   // Check if we can fetch a remote video with the URL
 214   if (isUserAbleToSearchRemoteURI(res)) {
 215     try {
 216       const syncParam = {
 217         likes: false,
 218         dislikes: false,
 219         shares: false,
 220         comments: false,
 221         thumbnail: true,
 222         refreshVideo: false
 223       }
 224
 225       const result = await getOrCreateVideoAndAccountAndChannel({ videoObject: url, syncParam })
 226       video = result ? result.video : undefined
 227     } catch (err) {
 228       logger.info('Cannot search remote video %s.', url, { err })
 229     }
 230   } else {
 231     video = await VideoModel.loadByUrlAndPopulateAccount(url)
 232   }
 233
 234   return res.json({
 235     total: video ? 1 : 0,
 236     data: video ? [ video.toFormattedJSON() ] : []
 237   })
 238 }
 239
 240 function isSearchIndexSearch (query: SearchTargetQuery) {
 241   if (query.searchTarget === 'search-index') return true
 242
 243   const searchIndexConfig = CONFIG.SEARCH.SEARCH_INDEX
 244
 245   if (searchIndexConfig.ENABLED !== true) return false
 246
 247   if (searchIndexConfig.DISABLE_LOCAL_SEARCH) return true
 248   if (searchIndexConfig.IS_DEFAULT_SEARCH && !query.searchTarget) return true
 249
 250   return false
 251 }
 252
 253 async function buildMutedForSearchIndex (res: express.Response) {
 254   const serverActor = await getServerActor()
 255   const accountIds = [ serverActor.Account.id ]
 256
 257   if (res.locals.oauth) {
 258     accountIds.push(res.locals.oauth.token.User.Account.id)
 259   }
 260
 261   const [ blockedHosts, blockedAccounts ] = await Promise.all([
 262     ServerBlocklistModel.listHostsBlockedBy(accountIds),
 263     AccountBlocklistModel.listHandlesBlockedBy(accountIds)
 264   ])
 265
 266   return {
 267     blockedHosts,
 268     blockedAccounts
 269   }
 270 }