}
for (const id of ids) {
- const videoFull = await VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+ const videoFull = await VideoModel.loadFull(id)
const files = videoFull.VideoFiles || []
const hls = videoFull.getHLSPlaylist()
return
}
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(uuid)
+ const video = await VideoModel.loadFull(uuid)
if (!video) throw new Error('Video not found.')
const dataInput: VideoTranscodingPayload[] = []
// Everything worked, we can save the playlist now
await playlist.save()
- const allVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.id)
+ const allVideo = await VideoModel.loadFull(video.id)
await federateVideoIfNeeded(allVideo, false)
console.log(`Successfully moved HLS files of ${video.name}.`)
const ids = await VideoModel.listLocalIds()
for (const id of ids) {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+ const video = await VideoModel.loadFull(id)
console.log('Updating video ' + video.uuid)
const channel = res.locals.videoChannel
// We need more attributes for federation
- const targetVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoChangeOwnership.Video.id, t)
+ const targetVideo = await VideoModel.loadFull(videoChangeOwnership.Video.id, t)
const oldVideoChannel = await VideoChannelModel.loadAndPopulateAccount(targetVideo.channelId, t)
try {
const { videoInstanceUpdated, isNewVideo } = await sequelizeTypescript.transaction(async t => {
// Refresh video since thumbnails to prevent concurrent updates
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoFromReq.id, t)
+ const video = await VideoModel.loadFull(videoFromReq.id, t)
const sequelizeOptions = { transaction: t }
const oldVideoChannel = video.VideoChannel
}
// Refresh video since files have changed
- return VideoModel.loadAndPopulateAccountAndServerAndTags(video.id)
+ return VideoModel.loadFull(video.id)
}
const job = await JobQueue.Instance.createJobWithPromise({ type: 'manage-video-torrent', payload })
await job.finished()
- const refreshedVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.id)
+ const refreshedVideo = await VideoModel.loadFull(video.id)
if (!refreshedVideo) return
// Only federate and notify after the torrent creation
if (!onlyVideo.isOwned()) return
return sequelizeTypescript.transaction(async t => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(onlyVideo.id, t)
+ const video = await VideoModel.loadFull(onlyVideo.id, t)
const existingRate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byAccount.id, video.id, activity.id, t)
if (existingRate && existingRate.type === 'dislike') return
if (!onlyVideo.isOwned()) return
return sequelizeTypescript.transaction(async t => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(onlyVideo.id, t)
+ const video = await VideoModel.loadFull(onlyVideo.id, t)
const existingRate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byAccount.id, video.id, activity.id, t)
if (existingRate && existingRate.type === 'like') return
return sequelizeTypescript.transaction(async t => {
if (!byActor.Account) throw new Error('Unknown account ' + byActor.url)
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(onlyVideo.id, t)
+ const video = await VideoModel.loadFull(onlyVideo.id, t)
const rate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byActor.Account.id, video.id, likeActivity.id, t)
if (!rate || rate.type !== 'like') throw new Error(`Unknown like by account ${byActor.Account.id} for video ${video.id}.`)
return sequelizeTypescript.transaction(async t => {
if (!byActor.Account) throw new Error('Unknown account ' + byActor.url)
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(onlyVideo.id, t)
+ const video = await VideoModel.loadFull(onlyVideo.id, t)
const rate = await AccountVideoRateModel.loadByAccountAndVideoOrUrl(byActor.Account.id, video.id, dislike.id, t)
if (!rate || rate.type !== 'dislike') throw new Error(`Unknown dislike by account ${byActor.Account.id} for video ${video.id}.`)
return
}
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(associatedVideo.id)
+ const video = await VideoModel.loadFull(associatedVideo.id)
const createActivity = buildCreateActivity(redundancyModel.url, byActor, redundancyModel.toActivityPubObject())
return sendUndoVideoRelatedActivity({
return
}
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(associatedVideo.id)
+ const video = await VideoModel.loadFull(associatedVideo.id)
const activityBuilder = (audience: ActivityAudience) => {
const redundancyObject = redundancyModel.toActivityPubObject()
if (videoCaption.isOwned()) throw new Error('Cannot load remote caption of owned video.')
// Used to fetch the path
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoCaption.videoId)
+ const video = await VideoModel.loadFull(videoCaption.videoId)
if (!video) return undefined
const remoteUrl = videoCaption.getFileUrl(video)
// Key is the video UUID
protected async loadRemoteFile (key: string) {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(key)
+ const video = await VideoModel.loadFull(key)
if (!video) return undefined
if (video.isOwned()) throw new Error('Cannot load remote preview of owned video.')
if (file.getVideo().isOwned()) throw new Error('Cannot load remote file of owned video.')
// Used to fetch the path
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(file.getVideo().id)
+ const video = await VideoModel.loadFull(file.getVideo().id)
if (!video) return undefined
const remoteUrl = file.getRemoteTorrentUrl(video)
const payload = job.data as ActivitypubHttpFetcherPayload
let video: MVideoFullLight
- if (payload.videoId) video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoId)
+ if (payload.videoId) video = await VideoModel.loadFull(payload.videoId)
const fetcherType: { [ id in FetchType ]: (items: any[]) => Promise<any> } = {
'activity': items => processActivities(items, { outboxUrl: payload.uri, fromFetch: true }),
const payload = job.data as VideoFileImportPayload
logger.info('Processing video file import in job %d.', job.id)
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
+ const video = await VideoModel.loadFull(payload.videoUUID)
// No video, maybe deleted?
if (!video) {
logger.info('Do not process job %d, video does not exist.', job.id)
if (previewModel) await video.addAndSaveThumbnail(previewModel, t)
// Now we can federate the video (reload from database, we need more attributes)
- const videoForFederation = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
+ const videoForFederation = await VideoModel.loadFull(video.uuid, t)
await federateVideoIfNeeded(videoForFederation, true, t)
// Update video import object
await liveSession.save()
// Remove old HLS playlist video files
- const videoWithFiles = await VideoModel.loadAndPopulateAccountAndServerAndTags(liveVideo.id)
+ const videoWithFiles = await VideoModel.loadFull(liveVideo.id)
const hlsPlaylist = videoWithFiles.getHLSPlaylist()
await VideoFileModel.removeHLSFilesOfVideoId(hlsPlaylist.id)
}
try {
- const fullVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.id)
+ const fullVideo = await VideoModel.loadFull(video.id)
return federateVideoIfNeeded(fullVideo, false, undefined)
} catch (err) {
logger.warn('Cannot federate live after cleanup', { videoId: video.id, err })
logger.info('Process video studio edition of %s in job %d.', payload.videoUUID, job.id, lTags)
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
+ const video = await VideoModel.loadFull(payload.videoUUID)
// No video, maybe deleted?
if (!video) {
const payload = job.data as VideoTranscodingPayload
logger.info('Processing transcoding job %d.', job.id, lTags(payload.videoUUID))
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
+ const video = await VideoModel.loadFull(payload.videoUUID)
// No video, maybe deleted?
if (!video) {
logger.info('Do not process job %d, video does not exist.', job.id, lTags(payload.videoUUID))
const { resolution, isPortraitMode, audioStream } = await videoArg.probeMaxQualityFile()
// Maybe the video changed in database, refresh it
- const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoArg.uuid)
+ const videoDatabase = await VideoModel.loadFull(videoArg.uuid)
// Video does not exist anymore
if (!videoDatabase) return undefined
const videoId = live.videoId
try {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+ const video = await VideoModel.loadFull(videoId)
logger.info('Will publish and federate live %s.', video.url, localLTags)
const { videoId, liveSession: liveSessionArg, cleanupNow = false } = options
try {
- const fullVideo = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+ const fullVideo = await VideoModel.loadFull(videoId)
if (!fullVideo) return
const live = await VideoLiveModel.loadByVideoId(fullVideo.id)
)
}
- if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
+ if (fetchType === 'all') return VideoModel.loadFull(id, undefined, userId)
if (fetchType === 'only-immutable-attributes') return VideoModel.loadImmutableAttributes(id)
removeVideo: (id: number) => {
return sequelizeTypescript.transaction(async t => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(id, t)
+ const video = await VideoModel.loadFull(id, t)
await video.destroy({ transaction: t })
})
},
getFiles: async (id: number | string) => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+ const video = await VideoModel.loadFull(id)
if (!video) return undefined
const webtorrentVideoFiles = (video.VideoFiles || []).map(f => ({
},
blacklistVideo: async (options: { videoIdOrUUID: number | string, createOptions: VideoBlacklistCreate }) => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(options.videoIdOrUUID)
+ const video = await VideoModel.loadFull(options.videoIdOrUUID)
if (!video) return
await blacklistVideo(video, options.createOptions)
},
unblacklistVideo: async (options: { videoIdOrUUID: number | string }) => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(options.videoIdOrUUID)
+ const video = await VideoModel.loadFull(options.videoIdOrUUID)
if (!video) return
const videoBlacklist = await VideoBlacklistModel.loadByVideoId(video.id)
for (const schedule of schedules) {
await sequelizeTypescript.transaction(async t => {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(schedule.videoId, t)
+ const video = await VideoModel.loadFull(schedule.videoId, t)
logger.info('Executing scheduled video update on %s.', video.uuid)
const views = await Redis.Instance.getLocalVideoViews(videoId)
await Redis.Instance.deleteLocalVideoViews(videoId)
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+ const video = await VideoModel.loadFull(videoId)
if (!video) {
logger.debug('Video %d does not exist anymore, skipping videos view addition.', videoId, lTags())
continue
const videoIds = await VideoModel.getAllIdsFromChannel(videoChannel)
for (const videoId of videoIds) {
- const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(videoId)
+ const video = await VideoModel.loadFull(videoId)
await federateVideoIfNeeded(video, false)
}
return sequelizeTypescript.transaction(async t => {
// Maybe the video changed in database, refresh it
- const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
+ const videoDatabase = await VideoModel.loadFull(video.uuid, t)
// Video does not exist anymore
if (!videoDatabase) return undefined
const videoWithRights = (video as MVideoWithRights).VideoChannel?.Account?.userId
? video as MVideoWithRights
- : await VideoModel.loadAndPopulateAccountAndServerAndTags(video.id)
+ : await VideoModel.loadFull(video.id)
const privacy = videoWithRights.privacy
export type GetType =
'api' |
- 'full-light' |
+ 'full' |
'account-blacklist-files' |
'all-files' |
'thumbnails' |
private readonly videoModelBuilder: VideoModelBuilder
- private static readonly videoFilesInclude = new Set<GetType>([ 'api', 'full-light', 'account-blacklist-files', 'all-files' ])
+ private static readonly videoFilesInclude = new Set<GetType>([ 'api', 'full', 'account-blacklist-files', 'all-files' ])
constructor (protected readonly sequelize: Sequelize) {
this.videoQueryBuilder = new VideosModelGetQuerySubBuilder(sequelize)
protected streamingPlaylistFilesQuery: string
private static readonly trackersInclude = new Set<GetType>([ 'api' ])
- private static readonly liveInclude = new Set<GetType>([ 'api', 'full-light' ])
- private static readonly scheduleUpdateInclude = new Set<GetType>([ 'api', 'full-light' ])
- private static readonly tagsInclude = new Set<GetType>([ 'api', 'full-light' ])
- private static readonly userHistoryInclude = new Set<GetType>([ 'api', 'full-light' ])
- private static readonly accountInclude = new Set<GetType>([ 'api', 'full-light', 'account-blacklist-files' ])
+ private static readonly liveInclude = new Set<GetType>([ 'api', 'full' ])
+ private static readonly scheduleUpdateInclude = new Set<GetType>([ 'api', 'full' ])
+ private static readonly tagsInclude = new Set<GetType>([ 'api', 'full' ])
+ private static readonly userHistoryInclude = new Set<GetType>([ 'api', 'full' ])
+ private static readonly accountInclude = new Set<GetType>([ 'api', 'full', 'account-blacklist-files' ])
private static readonly ownerUserInclude = new Set<GetType>([ 'blacklist-rights' ])
private static readonly blacklistedInclude = new Set<GetType>([
'api',
- 'full-light',
+ 'full',
'account-blacklist-files',
'thumbnails-blacklist',
'blacklist-rights'
private static readonly thumbnailsInclude = new Set<GetType>([
'api',
- 'full-light',
+ 'full',
'account-blacklist-files',
'all-files',
'thumbnails',
return queryBuilder.queryVideo({ url, transaction, type: 'account-blacklist-files' })
}
- static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Transaction, userId?: number): Promise<MVideoFullLight> {
+ static loadFull (id: number | string, t?: Transaction, userId?: number): Promise<MVideoFullLight> {
const queryBuilder = new VideoModelGetQueryBuilder(VideoModel.sequelize)
- return queryBuilder.queryVideo({ id, transaction: t, type: 'full-light', userId })
+ return queryBuilder.queryVideo({ id, transaction: t, type: 'full', userId })
}
static loadForGetAPI (parameters: {