2022-08-10 04:51:13 -05:00
|
|
|
import { IncludeOptions, Op, WhereOptions } from 'sequelize'
|
2018-08-02 08:34:09 -05:00
|
|
|
import {
|
2018-08-02 10:48:50 -05:00
|
|
|
AfterUpdate,
|
2018-08-02 08:34:09 -05:00
|
|
|
AllowNull,
|
|
|
|
BelongsTo,
|
|
|
|
Column,
|
|
|
|
CreatedAt,
|
|
|
|
DataType,
|
|
|
|
Default,
|
|
|
|
DefaultScope,
|
|
|
|
ForeignKey,
|
|
|
|
Is,
|
|
|
|
Model,
|
|
|
|
Table,
|
|
|
|
UpdatedAt
|
|
|
|
} from 'sequelize-typescript'
|
2021-05-11 04:15:29 -05:00
|
|
|
import { afterCommitIfTransaction } from '@server/helpers/database-utils'
|
2020-12-08 07:30:29 -06:00
|
|
|
import { MVideoImportDefault, MVideoImportFormattable } from '@server/types/models/video/video-import'
|
2021-12-24 03:14:47 -06:00
|
|
|
import { VideoImport, VideoImportState } from '@shared/models'
|
2021-12-16 11:04:16 -06:00
|
|
|
import { AttributesOnly } from '@shared/typescript-utils'
|
2020-12-08 07:30:29 -06:00
|
|
|
import { isVideoImportStateValid, isVideoImportTargetUrlValid } from '../../helpers/custom-validators/video-imports'
|
2018-08-06 10:13:39 -05:00
|
|
|
import { isVideoMagnetUriValid } from '../../helpers/custom-validators/videos'
|
2020-12-08 07:30:29 -06:00
|
|
|
import { CONSTRAINTS_FIELDS, VIDEO_IMPORT_STATES } from '../../initializers/constants'
|
2021-05-11 04:15:29 -05:00
|
|
|
import { UserModel } from '../user/user'
|
2022-08-10 04:51:13 -05:00
|
|
|
import { getSort, searchAttribute, throwIfNotValid } from '../utils'
|
2020-12-08 07:30:29 -06:00
|
|
|
import { ScopeNames as VideoModelScopeNames, VideoModel } from './video'
|
2022-08-10 04:51:13 -05:00
|
|
|
import { VideoChannelSyncModel } from './video-channel-sync'
|
|
|
|
|
|
|
|
const defaultVideoScope = () => {
|
|
|
|
return VideoModel.scope([
|
|
|
|
VideoModelScopeNames.WITH_ACCOUNT_DETAILS,
|
|
|
|
VideoModelScopeNames.WITH_TAGS,
|
|
|
|
VideoModelScopeNames.WITH_THUMBNAILS
|
|
|
|
])
|
|
|
|
}
|
2018-08-02 08:34:09 -05:00
|
|
|
|
2019-04-23 02:50:57 -05:00
|
|
|
@DefaultScope(() => ({
|
2018-08-02 08:34:09 -05:00
|
|
|
include: [
|
|
|
|
{
|
2019-04-23 02:50:57 -05:00
|
|
|
model: UserModel.unscoped(),
|
2018-08-07 03:07:53 -05:00
|
|
|
required: true
|
|
|
|
},
|
|
|
|
{
|
2022-08-10 04:51:13 -05:00
|
|
|
model: defaultVideoScope(),
|
|
|
|
required: false
|
|
|
|
},
|
|
|
|
{
|
|
|
|
model: VideoChannelSyncModel.unscoped(),
|
2018-08-07 03:07:53 -05:00
|
|
|
required: false
|
2018-08-02 08:34:09 -05:00
|
|
|
}
|
|
|
|
]
|
2019-04-23 02:50:57 -05:00
|
|
|
}))
|
2018-08-02 08:34:09 -05:00
|
|
|
|
|
|
|
@Table({
|
|
|
|
tableName: 'videoImport',
|
|
|
|
indexes: [
|
|
|
|
{
|
|
|
|
fields: [ 'videoId' ],
|
|
|
|
unique: true
|
2018-08-07 03:07:53 -05:00
|
|
|
},
|
|
|
|
{
|
|
|
|
fields: [ 'userId' ]
|
2018-08-02 08:34:09 -05:00
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
2021-05-12 07:09:04 -05:00
|
|
|
export class VideoImportModel extends Model<Partial<AttributesOnly<VideoImportModel>>> {
|
2018-08-02 08:34:09 -05:00
|
|
|
@CreatedAt
|
|
|
|
createdAt: Date
|
|
|
|
|
|
|
|
@UpdatedAt
|
|
|
|
updatedAt: Date
|
|
|
|
|
2018-08-06 10:13:39 -05:00
|
|
|
@AllowNull(true)
|
|
|
|
@Default(null)
|
2019-04-18 04:28:17 -05:00
|
|
|
@Is('VideoImportTargetUrl', value => throwIfNotValid(value, isVideoImportTargetUrlValid, 'targetUrl', true))
|
2018-08-02 08:34:09 -05:00
|
|
|
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.URL.max))
|
|
|
|
targetUrl: string
|
|
|
|
|
2018-08-06 10:13:39 -05:00
|
|
|
@AllowNull(true)
|
|
|
|
@Default(null)
|
2019-04-18 04:28:17 -05:00
|
|
|
@Is('VideoImportMagnetUri', value => throwIfNotValid(value, isVideoMagnetUriValid, 'magnetUri', true))
|
2018-08-06 10:13:39 -05:00
|
|
|
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.URL.max)) // Use the same constraints than URLs
|
|
|
|
magnetUri: string
|
|
|
|
|
|
|
|
@AllowNull(true)
|
|
|
|
@Default(null)
|
|
|
|
@Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_IMPORTS.TORRENT_NAME.max))
|
|
|
|
torrentName: string
|
|
|
|
|
2018-08-02 08:34:09 -05:00
|
|
|
@AllowNull(false)
|
|
|
|
@Default(null)
|
|
|
|
@Is('VideoImportState', value => throwIfNotValid(value, isVideoImportStateValid, 'state'))
|
|
|
|
@Column
|
|
|
|
state: VideoImportState
|
|
|
|
|
|
|
|
@AllowNull(true)
|
|
|
|
@Default(null)
|
|
|
|
@Column(DataType.TEXT)
|
|
|
|
error: string
|
|
|
|
|
2018-08-07 03:07:53 -05:00
|
|
|
@ForeignKey(() => UserModel)
|
|
|
|
@Column
|
|
|
|
userId: number
|
|
|
|
|
|
|
|
@BelongsTo(() => UserModel, {
|
|
|
|
foreignKey: {
|
|
|
|
allowNull: false
|
|
|
|
},
|
|
|
|
onDelete: 'cascade'
|
|
|
|
})
|
|
|
|
User: UserModel
|
|
|
|
|
2018-08-02 08:34:09 -05:00
|
|
|
@ForeignKey(() => VideoModel)
|
|
|
|
@Column
|
|
|
|
videoId: number
|
|
|
|
|
|
|
|
@BelongsTo(() => VideoModel, {
|
|
|
|
foreignKey: {
|
2018-08-02 10:48:50 -05:00
|
|
|
allowNull: true
|
2018-08-02 08:34:09 -05:00
|
|
|
},
|
2018-08-02 10:48:50 -05:00
|
|
|
onDelete: 'set null'
|
2018-08-02 08:34:09 -05:00
|
|
|
})
|
|
|
|
Video: VideoModel
|
|
|
|
|
2022-08-10 04:51:13 -05:00
|
|
|
@ForeignKey(() => VideoChannelSyncModel)
|
|
|
|
@Column
|
|
|
|
videoChannelSyncId: number
|
|
|
|
|
|
|
|
@BelongsTo(() => VideoChannelSyncModel, {
|
|
|
|
foreignKey: {
|
|
|
|
allowNull: true
|
|
|
|
},
|
|
|
|
onDelete: 'set null'
|
|
|
|
})
|
|
|
|
VideoChannelSync: VideoChannelSyncModel
|
|
|
|
|
2018-08-02 10:48:50 -05:00
|
|
|
@AfterUpdate
|
|
|
|
static deleteVideoIfFailed (instance: VideoImportModel, options) {
|
|
|
|
if (instance.state === VideoImportState.FAILED) {
|
2021-02-09 04:22:42 -06:00
|
|
|
return afterCommitIfTransaction(options.transaction, () => instance.Video.destroy())
|
2018-08-02 10:48:50 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
return undefined
|
|
|
|
}
|
|
|
|
|
2020-12-08 07:30:29 -06:00
|
|
|
static loadAndPopulateVideo (id: number): Promise<MVideoImportDefault> {
|
2019-02-21 07:28:06 -06:00
|
|
|
return VideoImportModel.findByPk(id)
|
2018-08-02 08:34:09 -05:00
|
|
|
}
|
|
|
|
|
2022-01-19 07:58:16 -06:00
|
|
|
static listUserVideoImportsForApi (options: {
|
|
|
|
userId: number
|
|
|
|
start: number
|
|
|
|
count: number
|
|
|
|
sort: string
|
|
|
|
|
2022-08-10 04:51:13 -05:00
|
|
|
search?: string
|
2022-01-19 07:58:16 -06:00
|
|
|
targetUrl?: string
|
2022-08-10 04:51:13 -05:00
|
|
|
videoChannelSyncId?: number
|
2022-01-19 07:58:16 -06:00
|
|
|
}) {
|
2022-08-10 04:51:13 -05:00
|
|
|
const { userId, start, count, sort, targetUrl, videoChannelSyncId, search } = options
|
2022-01-19 07:58:16 -06:00
|
|
|
|
|
|
|
const where: WhereOptions = { userId }
|
2022-08-10 04:51:13 -05:00
|
|
|
const include: IncludeOptions[] = [
|
|
|
|
{
|
|
|
|
attributes: [ 'id' ],
|
|
|
|
model: UserModel.unscoped(), // FIXME: Without this, sequelize try to COUNT(DISTINCT(*)) which is an invalid SQL query
|
|
|
|
required: true
|
|
|
|
},
|
|
|
|
{
|
|
|
|
model: VideoChannelSyncModel.unscoped(),
|
|
|
|
required: false
|
|
|
|
}
|
|
|
|
]
|
2022-01-19 07:58:16 -06:00
|
|
|
|
|
|
|
if (targetUrl) where['targetUrl'] = targetUrl
|
2022-08-10 04:51:13 -05:00
|
|
|
if (videoChannelSyncId) where['videoChannelSyncId'] = videoChannelSyncId
|
|
|
|
|
|
|
|
if (search) {
|
|
|
|
include.push({
|
|
|
|
model: defaultVideoScope(),
|
|
|
|
required: true,
|
|
|
|
where: searchAttribute(search, 'name')
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
include.push({
|
|
|
|
model: defaultVideoScope(),
|
|
|
|
required: false
|
|
|
|
})
|
|
|
|
}
|
2022-01-19 07:58:16 -06:00
|
|
|
|
2018-08-02 10:48:50 -05:00
|
|
|
const query = {
|
2018-08-03 09:23:45 -05:00
|
|
|
distinct: true,
|
2022-08-10 04:51:13 -05:00
|
|
|
include,
|
2018-08-07 03:07:53 -05:00
|
|
|
offset: start,
|
|
|
|
limit: count,
|
|
|
|
order: getSort(sort),
|
2022-01-19 07:58:16 -06:00
|
|
|
where
|
2018-08-02 10:48:50 -05:00
|
|
|
}
|
|
|
|
|
2022-02-28 01:34:43 -06:00
|
|
|
return Promise.all([
|
|
|
|
VideoImportModel.unscoped().count(query),
|
|
|
|
VideoImportModel.findAll<MVideoImportDefault>(query)
|
|
|
|
]).then(([ total, data ]) => ({ total, data }))
|
2018-08-02 10:48:50 -05:00
|
|
|
}
|
|
|
|
|
2022-08-10 02:53:39 -05:00
|
|
|
static async urlAlreadyImported (channelId: number, targetUrl: string): Promise<boolean> {
|
|
|
|
const element = await VideoImportModel.unscoped().findOne({
|
|
|
|
where: {
|
|
|
|
targetUrl,
|
|
|
|
state: {
|
|
|
|
[Op.in]: [ VideoImportState.PENDING, VideoImportState.PROCESSING, VideoImportState.SUCCESS ]
|
|
|
|
}
|
|
|
|
},
|
|
|
|
include: [
|
|
|
|
{
|
|
|
|
model: VideoModel,
|
|
|
|
required: true,
|
|
|
|
where: {
|
|
|
|
channelId
|
|
|
|
}
|
|
|
|
}
|
|
|
|
]
|
|
|
|
})
|
|
|
|
|
|
|
|
return !!element
|
|
|
|
}
|
|
|
|
|
2019-01-02 09:37:43 -06:00
|
|
|
getTargetIdentifier () {
|
|
|
|
return this.targetUrl || this.magnetUri || this.torrentName
|
|
|
|
}
|
|
|
|
|
2019-08-20 12:05:31 -05:00
|
|
|
toFormattedJSON (this: MVideoImportFormattable): VideoImport {
|
2018-08-02 08:34:09 -05:00
|
|
|
const videoFormatOptions = {
|
2018-09-28 03:18:37 -05:00
|
|
|
completeDescription: true,
|
2018-08-02 08:34:09 -05:00
|
|
|
additionalAttributes: { state: true, waitTranscoding: true, scheduledUpdate: true }
|
|
|
|
}
|
2018-08-02 10:48:50 -05:00
|
|
|
const video = this.Video
|
2018-09-28 03:18:37 -05:00
|
|
|
? Object.assign(this.Video.toFormattedJSON(videoFormatOptions), { tags: this.Video.Tags.map(t => t.name) })
|
2018-08-02 10:48:50 -05:00
|
|
|
: undefined
|
2018-08-02 08:34:09 -05:00
|
|
|
|
2022-08-10 04:51:13 -05:00
|
|
|
const videoChannelSync = this.VideoChannelSync
|
|
|
|
? { id: this.VideoChannelSync.id, externalChannelUrl: this.VideoChannelSync.externalChannelUrl }
|
|
|
|
: undefined
|
|
|
|
|
2018-08-02 08:34:09 -05:00
|
|
|
return {
|
2018-08-03 02:27:30 -05:00
|
|
|
id: this.id,
|
2018-08-07 02:54:36 -05:00
|
|
|
|
2018-08-02 08:34:09 -05:00
|
|
|
targetUrl: this.targetUrl,
|
2018-08-07 02:54:36 -05:00
|
|
|
magnetUri: this.magnetUri,
|
|
|
|
torrentName: this.torrentName,
|
|
|
|
|
2018-08-02 10:48:50 -05:00
|
|
|
state: {
|
|
|
|
id: this.state,
|
|
|
|
label: VideoImportModel.getStateLabel(this.state)
|
|
|
|
},
|
2018-08-03 02:27:30 -05:00
|
|
|
error: this.error,
|
2018-08-02 10:48:50 -05:00
|
|
|
updatedAt: this.updatedAt.toISOString(),
|
|
|
|
createdAt: this.createdAt.toISOString(),
|
2022-08-10 04:51:13 -05:00
|
|
|
video,
|
|
|
|
videoChannelSync
|
2018-08-02 08:34:09 -05:00
|
|
|
}
|
|
|
|
}
|
2018-08-10 09:54:01 -05:00
|
|
|
|
2018-08-02 10:48:50 -05:00
|
|
|
private static getStateLabel (id: number) {
|
|
|
|
return VIDEO_IMPORT_STATES[id] || 'Unknown'
|
|
|
|
}
|
2018-08-02 08:34:09 -05:00
|
|
|
}
|