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 }