PeerTube/server/models/video/video-live.ts

185 lines
4.0 KiB
TypeScript
Raw Normal View History

import { Transaction } from 'sequelize'
import {
AllowNull,
BeforeDestroy,
BelongsTo,
Column,
CreatedAt,
DataType,
DefaultScope,
ForeignKey,
Model,
Table,
UpdatedAt
} from 'sequelize-typescript'
2022-03-04 13:40:02 +01:00
import { CONFIG } from '@server/initializers/config'
import { WEBSERVER } from '@server/initializers/constants'
import { MVideoLive, MVideoLiveVideoWithSetting } from '@server/types/models'
2022-04-22 10:54:05 +02:00
import { LiveVideo, LiveVideoLatencyMode, VideoState } from '@shared/models'
import { AttributesOnly } from '@shared/typescript-utils'
import { VideoModel } from './video'
import { VideoBlacklistModel } from './video-blacklist'
import { VideoLiveReplaySettingModel } from './video-live-replay-setting'
@DefaultScope(() => ({
include: [
{
model: VideoModel,
required: true,
include: [
{
model: VideoBlacklistModel,
required: false
}
]
},
{
model: VideoLiveReplaySettingModel,
required: false
}
]
}))
@Table({
tableName: 'videoLive',
indexes: [
{
fields: [ 'videoId' ],
unique: true
},
{
fields: [ 'replaySettingId' ],
unique: true
}
]
})
2021-05-12 14:09:04 +02:00
export class VideoLiveModel extends Model<Partial<AttributesOnly<VideoLiveModel>>> {
2020-09-25 16:19:35 +02:00
@AllowNull(true)
@Column(DataType.STRING)
streamKey: string
2020-09-25 16:19:35 +02:00
@AllowNull(false)
@Column
saveReplay: boolean
2020-12-03 14:10:54 +01:00
@AllowNull(false)
@Column
permanentLive: boolean
2022-03-04 13:40:02 +01:00
@AllowNull(false)
@Column
latencyMode: LiveVideoLatencyMode
@CreatedAt
createdAt: Date
@UpdatedAt
updatedAt: Date
@ForeignKey(() => VideoModel)
@Column
videoId: number
@BelongsTo(() => VideoModel, {
foreignKey: {
allowNull: false
},
onDelete: 'cascade'
})
Video: VideoModel
@ForeignKey(() => VideoLiveReplaySettingModel)
@Column
replaySettingId: number
@BelongsTo(() => VideoLiveReplaySettingModel, {
foreignKey: {
allowNull: true
},
onDelete: 'set null'
})
ReplaySetting: VideoLiveReplaySettingModel
@BeforeDestroy
static deleteReplaySetting (instance: VideoLiveModel, options: { transaction: Transaction }) {
return VideoLiveReplaySettingModel.destroy({
where: {
id: instance.replaySettingId
},
transaction: options.transaction
})
}
static loadByStreamKey (streamKey: string) {
const query = {
where: {
streamKey
},
include: [
{
model: VideoModel.unscoped(),
required: true,
where: {
state: VideoState.WAITING_FOR_LIVE
},
include: [
{
model: VideoBlacklistModel.unscoped(),
required: false
}
]
},
{
model: VideoLiveReplaySettingModel.unscoped(),
required: false
}
]
}
return VideoLiveModel.findOne<MVideoLiveVideoWithSetting>(query)
}
static loadByVideoId (videoId: number) {
const query = {
where: {
videoId
}
}
return VideoLiveModel.findOne<MVideoLive>(query)
}
2022-04-22 09:50:20 +02:00
toFormattedJSON (canSeePrivateInformation: boolean): LiveVideo {
let privateInformation: Pick<LiveVideo, 'rtmpUrl' | 'rtmpsUrl' | 'streamKey'> | {} = {}
2021-11-05 11:36:03 +01:00
// If we don't have a stream key, it means this is a remote live so we don't specify the rtmp URL
2022-04-22 09:50:20 +02:00
// We also display these private information only to the live owne/moderators
if (this.streamKey && canSeePrivateInformation === true) {
privateInformation = {
streamKey: this.streamKey,
rtmpUrl: CONFIG.LIVE.RTMP.ENABLED
2023-05-16 09:12:50 +02:00
? WEBSERVER.RTMP_BASE_LIVE_URL
2022-04-22 09:50:20 +02:00
: null,
rtmpsUrl: CONFIG.LIVE.RTMPS.ENABLED
2023-05-16 09:12:50 +02:00
? WEBSERVER.RTMPS_BASE_LIVE_URL
2022-04-22 09:50:20 +02:00
: null
}
2021-11-05 11:36:03 +01:00
}
const replaySettings = this.replaySettingId
? this.ReplaySetting.toFormattedJSON()
: undefined
return {
2022-04-22 09:50:20 +02:00
...privateInformation,
2020-11-02 15:43:44 +01:00
2020-12-03 14:10:54 +01:00
permanentLive: this.permanentLive,
2022-03-04 13:40:02 +01:00
saveReplay: this.saveReplay,
replaySettings,
2022-03-04 13:40:02 +01:00
latencyMode: this.latencyMode
}
}
}