isVideoDurationValid,
isVideoLanguageValid,
isVideoLicenceValid,
- isVideoNameValid, isVideoOriginallyPublishedAtValid,
+ isVideoNameValid,
isVideoPrivacyValid,
isVideoStateValid,
isVideoSupportValid
import {
ACTIVITY_PUB,
API_VERSION,
- CONFIG,
- CONSTRAINTS_FIELDS, HLS_PLAYLIST_DIRECTORY, HLS_REDUNDANCY_DIRECTORY,
+ CONSTRAINTS_FIELDS,
+ HLS_REDUNDANCY_DIRECTORY,
+ HLS_STREAMING_PLAYLIST_DIRECTORY,
PREVIEWS_SIZE,
REMOTE_SCHEME,
STATIC_DOWNLOAD_PATHS,
VIDEO_LANGUAGES,
VIDEO_LICENCES,
VIDEO_PRIVACIES,
- VIDEO_STATES
+ VIDEO_STATES,
+ WEBSERVER
} from '../../initializers'
import { sendDeleteVideo } from '../../lib/activitypub/send'
import { AccountModel } from '../account/account'
import { ActorModel } from '../activitypub/actor'
import { AvatarModel } from '../avatar/avatar'
import { ServerModel } from '../server/server'
-import { buildBlockedAccountSQL, buildTrigramSearchIndex, createSimilarityAttribute, getVideoSort, throwIfNotValid } from '../utils'
+import {
+ buildBlockedAccountSQL,
+ buildTrigramSearchIndex,
+ buildWhereIdOrUUID,
+ createSimilarityAttribute,
+ getVideoSort,
+ isOutdated,
+ throwIfNotValid
+} from '../utils'
import { TagModel } from './tag'
import { VideoAbuseModel } from './video-abuse'
-import { VideoChannelModel } from './video-channel'
+import { ScopeNames as VideoChannelScopeNames, VideoChannelModel } from './video-channel'
import { VideoCommentModel } from './video-comment'
import { VideoFileModel } from './video-file'
import { VideoShareModel } from './video-share'
videoModelToFormattedDetailsJSON,
videoModelToFormattedJSON
} from './video-format-utils'
-import * as validator from 'validator'
import { UserVideoHistoryModel } from '../account/user-video-history'
import { UserModel } from '../account/user'
import { VideoImportModel } from './video-import'
import { VideoStreamingPlaylistModel } from './video-streaming-playlist'
+import { VideoPlaylistElementModel } from './video-playlist-element'
+import { CONFIG } from '../../initializers/config'
// FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
const indexes: Sequelize.DefineIndexesOptions[] = [
type ForAPIOptions = {
ids: number[]
+
+ videoPlaylistId?: number
+
withFiles?: boolean
}
serverAccountId: number
followerActorId: number
includeLocalVideos: boolean
+
filter?: VideoFilter
categoryOneOf?: number[]
nsfw?: boolean
languageOneOf?: string[]
tagsOneOf?: string[]
tagsAllOf?: string[]
+
withFiles?: boolean
+
accountId?: number
videoChannelId?: number
+
+ videoPlaylistId?: number
+
trendingDays?: number
user?: UserModel,
historyOfUser?: UserModel
@Scopes({
[ ScopeNames.FOR_API ]: (options: ForAPIOptions) => {
- const accountInclude = {
- attributes: [ 'id', 'name' ],
- model: AccountModel.unscoped(),
- required: true,
- include: [
- {
- attributes: [ 'id', 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
- model: ActorModel.unscoped(),
- required: true,
- include: [
- {
- attributes: [ 'host' ],
- model: ServerModel.unscoped(),
- required: false
- },
- {
- model: AvatarModel.unscoped(),
- required: false
- }
- ]
- }
- ]
- }
-
- const videoChannelInclude = {
- attributes: [ 'name', 'description', 'id' ],
- model: VideoChannelModel.unscoped(),
- required: true,
- include: [
- {
- attributes: [ 'uuid', 'preferredUsername', 'url', 'serverId', 'avatarId' ],
- model: ActorModel.unscoped(),
- required: true,
- include: [
- {
- attributes: [ 'host' ],
- model: ServerModel.unscoped(),
- required: false
- },
- {
- model: AvatarModel.unscoped(),
- required: false
- }
- ]
- },
- accountInclude
- ]
- }
-
const query: IFindOptions<VideoModel> = {
where: {
id: {
[ Sequelize.Op.any ]: options.ids
}
},
- include: [ videoChannelInclude ]
+ include: [
+ {
+ model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, true ] }),
+ required: true
+ }
+ ]
}
if (options.withFiles === true) {
})
}
+ if (options.videoPlaylistId) {
+ query.include.push({
+ model: VideoPlaylistElementModel.unscoped(),
+ required: true,
+ where: {
+ videoPlaylistId: options.videoPlaylistId
+ }
+ })
+ }
+
return query
},
[ ScopeNames.AVAILABLE_FOR_LIST_IDS ]: (options: AvailableForListIDsOptions) => {
Object.assign(query.where, privacyWhere)
}
+ if (options.videoPlaylistId) {
+ query.include.push({
+ attributes: [],
+ model: VideoPlaylistElementModel.unscoped(),
+ required: true,
+ where: {
+ videoPlaylistId: options.videoPlaylistId
+ }
+ })
+
+ query.subQuery = false
+ }
+
if (options.filter || options.accountId || options.videoChannelId) {
const videoChannelInclude: IIncludeOptions = {
attributes: [],
})
Tags: TagModel[]
+ @HasMany(() => VideoPlaylistElementModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ VideoPlaylistElements: VideoPlaylistElementModel[]
+
@HasMany(() => VideoAbuseModel, {
foreignKey: {
name: 'videoId',
accountId?: number,
videoChannelId?: number,
followerActorId?: number
+ videoPlaylistId?: number,
trendingDays?: number,
user?: UserModel,
historyOfUser?: UserModel
withFiles: options.withFiles,
accountId: options.accountId,
videoChannelId: options.videoChannelId,
+ videoPlaylistId: options.videoPlaylistId,
includeLocalVideos: options.includeLocalVideos,
user: options.user,
historyOfUser: options.historyOfUser,
}
static load (id: number | string, t?: Sequelize.Transaction) {
- const where = VideoModel.buildWhereIdOrUUID(id)
+ const where = buildWhereIdOrUUID(id)
const options = {
where,
transaction: t
}
static loadWithRights (id: number | string, t?: Sequelize.Transaction) {
- const where = VideoModel.buildWhereIdOrUUID(id)
+ const where = buildWhereIdOrUUID(id)
const options = {
where,
transaction: t
}
static loadOnlyId (id: number | string, t?: Sequelize.Transaction) {
- const where = VideoModel.buildWhereIdOrUUID(id)
+ const where = buildWhereIdOrUUID(id)
const options = {
attributes: [ 'id' ],
}
static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
- const where = VideoModel.buildWhereIdOrUUID(id)
+ const where = buildWhereIdOrUUID(id)
const options = {
order: [ [ 'Tags', 'name', 'ASC' ] ],
}
static loadForGetAPI (id: number | string, t?: Sequelize.Transaction, userId?: number) {
- const where = VideoModel.buildWhereIdOrUUID(id)
+ const where = buildWhereIdOrUUID(id)
const options = {
order: [ [ 'Tags', 'name', 'ASC' ] ],
if (ids.length === 0) return { data: [], total: count }
- // FIXME: typings
- const apiScope: any[] = [
- {
- method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
- }
- ]
-
- if (options.user) {
- apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.user.id ] })
- }
-
- const secondQuery = {
+ const secondQuery: IFindOptions<VideoModel> = {
offset: 0,
limit: query.limit,
attributes: query.attributes,
)
]
}
+
+ // FIXME: typing
+ const apiScope: any[] = []
+
+ if (options.user) {
+ apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.user.id ] })
+
+ // Even if the relation is n:m, we know that a user only have 0..1 video history
+ // So we won't have multiple rows for the same video
+ // A subquery adds some bugs in our query so disable it
+ secondQuery.subQuery = false
+ }
+
+ apiScope.push({
+ method: [
+ ScopeNames.FOR_API, {
+ ids,
+ withFiles: options.withFiles,
+ videoPlaylistId: options.videoPlaylistId
+ } as ForAPIOptions
+ ]
+ })
+
const rows = await VideoModel.scope(apiScope).findAll(secondQuery)
return {
return VIDEO_STATES[ id ] || 'Unknown'
}
- static buildWhereIdOrUUID (id: number | string) {
- return validator.isInt('' + id) ? { id } : { uuid: id }
- }
-
getOriginalFile () {
if (Array.isArray(this.VideoFiles) === false) return undefined
}
getThumbnailName () {
- // We always have a copy of the thumbnail
const extension = '.jpg'
return this.uuid + extension
}
name: `${this.name} ${videoFile.resolution}p${videoFile.extname}`,
createdBy: 'PeerTube',
announceList: [
- [ CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT + '/tracker/socket' ],
- [ CONFIG.WEBSERVER.URL + '/tracker/announce' ]
+ [ WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT + '/tracker/socket' ],
+ [ WEBSERVER.URL + '/tracker/announce' ]
],
- urlList: [ CONFIG.WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
+ urlList: [ WEBSERVER.URL + STATIC_PATHS.WEBSEED + this.getVideoFilename(videoFile) ]
}
const torrent = await createTorrentPromise(this.getVideoFilePath(videoFile), options)
}
removeStreamingPlaylist (isRedundancy = false) {
- const baseDir = isRedundancy ? HLS_REDUNDANCY_DIRECTORY : HLS_PLAYLIST_DIRECTORY
+ const baseDir = isRedundancy ? HLS_REDUNDANCY_DIRECTORY : HLS_STREAMING_PLAYLIST_DIRECTORY
const filePath = join(baseDir, this.uuid)
return remove(filePath)
isOutdated () {
if (this.isOwned()) return false
- const now = Date.now()
- const createdAtTime = this.createdAt.getTime()
- const updatedAtTime = this.updatedAt.getTime()
-
- return (now - createdAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL &&
- (now - updatedAtTime) > ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL
+ return isOutdated(this, ACTIVITY_PUB.VIDEO_REFRESH_INTERVAL)
}
setAsRefreshed () {
let baseUrlWs
if (this.isOwned()) {
- baseUrlHttp = CONFIG.WEBSERVER.URL
- baseUrlWs = CONFIG.WEBSERVER.WS + '://' + CONFIG.WEBSERVER.HOSTNAME + ':' + CONFIG.WEBSERVER.PORT
+ baseUrlHttp = WEBSERVER.URL
+ baseUrlWs = WEBSERVER.WS + '://' + WEBSERVER.HOSTNAME + ':' + WEBSERVER.PORT
} else {
baseUrlHttp = REMOTE_SCHEME.HTTP + '://' + this.VideoChannel.Account.Actor.Server.host
baseUrlWs = REMOTE_SCHEME.WS + '://' + this.VideoChannel.Account.Actor.Server.host
projects / github / Chocobozzz / PeerTube.git / blobdiff