abuseNewMessage: $localize`An abuse report received a new message`,
abuseStateChange: $localize`One of your abuse reports has been accepted or rejected by moderators`,
newPeerTubeVersion: $localize`A new PeerTube version is available`,
- newPluginVersion: $localize`One of your plugin/theme has a new available version`
+ newPluginVersion: $localize`One of your plugin/theme has a new available version`,
+ myVideoEditionFinished: $localize`Video edition finished`
}
this.notificationSettingGroups = [
{
'newCommentOnMyVideo',
'blacklistOnMyVideo',
'myVideoPublished',
- 'myVideoImportFinished'
+ 'myVideoImportFinished',
+ 'myVideoEditionFinished'
]
},
this.pluginUrl = `/admin/plugins/list-installed`
this.pluginQueryParams.pluginType = this.plugin.type + ''
break
+
+ case UserNotificationType.MY_VIDEO_EDITION_FINISHED:
+ this.videoUrl = this.buildVideoUrl(this.video)
+ break
}
} catch (err) {
this.type = null
<my-global-icon iconName="cog" aria-hidden="true"></my-global-icon>
<div class="message" i18n>
- <a (click)="markAsRead(notification)" [href]="notification.peertubeVersionLink" target="_blank" rel="noopener noreferrer">A new version of PeerTube</a> is available: {{ notification.peertube.latestVersion }}
+ <a (click)="markAsRead(notification)" [href]="notification.peertubeVersionLink" target="_blank" rel="noopener noreferrer">A new version of PeerTube</a> is available: {{ notification.peertube.latestVersion }}
+ </div>
+ </ng-container>
+
+ <ng-container *ngSwitchCase="19"> <!-- UserNotificationType.MY_VIDEO_EDITION_FINISHED -->
+ <my-global-icon iconName="film" aria-hidden="true"></my-global-icon>
+
+ <div class="message" i18n>
+ Your video <a (click)="markAsRead(notification)" [routerLink]="notification.videoUrl">{{ notification.video.name }}</a> edition has finished
</div>
</ng-container>
if (files.some(f => f.storage === VideoStorage.FILE_SYSTEM) || hls?.storage === VideoStorage.FILE_SYSTEM) {
console.log('Processing video %s.', videoFull.name)
- const success = await moveToExternalStorageState(videoFull, false, undefined)
+ const success = await moveToExternalStorageState({ video: videoFull, isNewVideo: false, transaction: undefined })
if (!success) {
console.error(
abuseNewMessage: body.abuseNewMessage,
abuseStateChange: body.abuseStateChange,
newPeerTubeVersion: body.newPeerTubeVersion,
- newPluginVersion: body.newPluginVersion
+ newPluginVersion: body.newPluginVersion,
+ myVideoEditionFinished: body.myVideoEditionFinished
}
await UserNotificationSettingModel.update(values, query)
if (!refreshedVideo) return
if (refreshedVideo.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
- return addMoveToObjectStorageJob(refreshedVideo)
+ return addMoveToObjectStorageJob({ video: refreshedVideo, previousVideoState: undefined })
}
if (refreshedVideo.state === VideoState.TO_TRANSCODE) {
- return addOptimizeOrMergeAudioJob(refreshedVideo, videoFile, user)
+ return addOptimizeOrMergeAudioJob({ video: refreshedVideo, videoFile, user })
}
}).catch(err => logger.error('Cannot add optimize/merge audio job for %s.', videoCreated.uuid, { err, ...lTags(videoCreated.uuid) }))
// ---------------------------------------------------------------------------
-const LAST_MIGRATION_VERSION = 695
+const LAST_MIGRATION_VERSION = 700
// ---------------------------------------------------------------------------
--- /dev/null
+import * as Sequelize from 'sequelize'
+
+async function up (utils: {
+ transaction: Sequelize.Transaction
+ queryInterface: Sequelize.QueryInterface
+ sequelize: Sequelize.Sequelize
+ db: any
+}): Promise<void> {
+ const { transaction } = utils
+
+ {
+ const data = {
+ type: Sequelize.INTEGER,
+ defaultValue: null,
+ allowNull: true
+ }
+ await utils.queryInterface.addColumn('userNotificationSetting', 'myVideoEditionFinished', data, { transaction })
+ }
+
+ {
+ const query = 'UPDATE "userNotificationSetting" SET "myVideoEditionFinished" = 1'
+ await utils.sequelize.query(query, { transaction })
+ }
+
+ {
+ const data = {
+ type: Sequelize.INTEGER,
+ defaultValue: null,
+ allowNull: false
+ }
+ await utils.queryInterface.changeColumn('userNotificationSetting', 'myVideoEditionFinished', data, { transaction })
+ }
+}
+
+function down () {
+ throw new Error('Not implemented.')
+}
+
+export {
+ up,
+ down
+}
import { VideoModel } from '@server/models/video/video'
import { VideoJobInfoModel } from '@server/models/video/video-job-info'
import { MStreamingPlaylistVideo, MVideo, MVideoFile, MVideoWithAllFiles } from '@server/types/models'
-import { MoveObjectStoragePayload, VideoStorage } from '@shared/models'
+import { MoveObjectStoragePayload, VideoState, VideoStorage } from '@shared/models'
const lTagsBase = loggerTagsFactory('move-object-storage')
if (pendingMove === 0) {
logger.info('Running cleanup after moving files to object storage (video %s in job %d)', video.uuid, job.id, lTags)
- await doAfterLastJob(video, payload.isNewVideo)
+ await doAfterLastJob({ video, previousVideoState: payload.previousVideoState, isNewVideo: payload.isNewVideo })
}
} catch (err) {
logger.error('Cannot move video %s to object storage.', video.url, { err, ...lTags })
}
}
-async function doAfterLastJob (video: MVideoWithAllFiles, isNewVideo: boolean) {
+async function doAfterLastJob (options: {
+ video: MVideoWithAllFiles
+ previousVideoState: VideoState
+ isNewVideo: boolean
+}) {
+ const { video, previousVideoState, isNewVideo } = options
+
for (const playlist of video.VideoStreamingPlaylists) {
if (playlist.storage === VideoStorage.OBJECT_STORAGE) continue
await remove(getHLSDirectory(video))
}
- await moveToNextState(video, isNewVideo)
+ await moveToNextState({ video, previousVideoState, isNewVideo })
}
async function onFileMoved (options: {
import { generateWebTorrentVideoFilename } from '@server/lib/paths'
import { VideoTranscodingProfilesManager } from '@server/lib/transcoding/default-transcoding-profiles'
import { isAbleToUploadVideo } from '@server/lib/user'
-import { addMoveToObjectStorageJob, addOptimizeOrMergeAudioJob } from '@server/lib/video'
+import { addOptimizeOrMergeAudioJob } from '@server/lib/video'
import { approximateIntroOutroAdditionalSize } from '@server/lib/video-editor'
import { VideoPathManager } from '@server/lib/video-path-manager'
-import { buildNextVideoState } from '@server/lib/video-state'
import { UserModel } from '@server/models/user/user'
import { VideoModel } from '@server/models/video/video'
import { VideoFileModel } from '@server/models/video/video-file'
VideoEditorTaskCutPayload,
VideoEditorTaskIntroPayload,
VideoEditorTaskOutroPayload,
- VideoEditorTaskWatermarkPayload,
- VideoState
+ VideoEditorTaskWatermarkPayload
} from '@shared/models'
import { logger, loggerTagsFactory } from '../../../helpers/logger'
async function processVideoEdition (job: Job) {
const payload = job.data as VideoEditionPayload
+ const lTags = lTagsBase(payload.videoUUID)
- logger.info('Process video edition of %s in job %d.', payload.videoUUID, job.id)
+ logger.info('Process video edition of %s in job %d.', payload.videoUUID, job.id, lTags)
const video = await VideoModel.loadAndPopulateAccountAndServerAndTags(payload.videoUUID)
// No video, maybe deleted?
if (!video) {
- logger.info('Can\'t process job %d, video does not exist.', job.id, lTagsBase(payload.videoUUID))
+ logger.info('Can\'t process job %d, video does not exist.', job.id, lTags)
return undefined
}
inputPath: tmpInputFilePath ?? originalFilePath,
video,
outputPath,
- task
+ task,
+ lTags
})
if (tmpInputFilePath) await remove(tmpInputFilePath)
return outputPath
})
- logger.info('Video edition ended for video %s.', video.uuid)
+ logger.info('Video edition ended for video %s.', video.uuid, lTags)
const newFile = await buildNewFile(video, editionResultPath)
await newFile.save()
- video.state = buildNextVideoState()
video.duration = await getVideoStreamDuration(outputPath)
await video.save()
await federateVideoIfNeeded(video, false, undefined)
- if (video.state === VideoState.TO_TRANSCODE) {
- const user = await UserModel.loadByVideoId(video.id)
-
- await addOptimizeOrMergeAudioJob(video, newFile, user, false)
- } else if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
- await addMoveToObjectStorageJob(video, false)
- }
+ const user = await UserModel.loadByVideoId(video.id)
+ await addOptimizeOrMergeAudioJob({ video, videoFile: newFile, user, isNewVideo: false })
}
// ---------------------------------------------------------------------------
outputPath: string
video: MVideo
task: T
+ lTags: { tags: string[] }
}
const taskProcessors: { [id in VideoEditorTask['name']]: (options: TaskProcessorOptions) => Promise<any> } = {
async function processTask (options: TaskProcessorOptions) {
const { video, task } = options
- logger.info('Processing %s task for video %s.', task.name, video.uuid, { task })
+ logger.info('Processing %s task for video %s.', task.name, video.uuid, { task, ...options.lTags })
const processor = taskProcessors[options.task.name]
if (!process) throw new Error('Unknown task ' + task.name)
await updateVideoFile(video, payload.filePath)
if (CONFIG.OBJECT_STORAGE.ENABLED) {
- await addMoveToObjectStorageJob(video)
+ await addMoveToObjectStorageJob({ video, previousVideoState: video.state })
} else {
await federateVideoIfNeeded(video, false)
}
}
if (video.state === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
- return addMoveToObjectStorageJob(videoImportUpdated.Video)
+ return addMoveToObjectStorageJob({ video: videoImportUpdated.Video, previousVideoState: VideoState.TO_IMPORT })
}
// Create transcoding jobs?
if (video.state === VideoState.TO_TRANSCODE) {
- await addOptimizeOrMergeAudioJob(videoImportUpdated.Video, videoFile, videoImport.User)
+ await addOptimizeOrMergeAudioJob({ video: videoImportUpdated.Video, videoFile, user: videoImport.User })
}
} catch (err) {
})
}
- await moveToNextState(videoWithFiles, false)
+ await moveToNextState({ video: videoWithFiles, isNewVideo: false })
}
async function cleanupTMPLiveFiles (hlsDirectory: string) {
}
await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
- await retryTransactionWrapper(moveToNextState, video, payload.isNewVideo)
+ await retryTransactionWrapper(moveToNextState, { video, isNewVideo: payload.isNewVideo })
}
async function onVideoFirstWebTorrentTranscoding (
// Move to next state if there are no other resolutions to generate
if (!hasHls && !hasNewResolutions) {
- await retryTransactionWrapper(moveToNextState, videoDatabase, payload.isNewVideo)
+ await retryTransactionWrapper(moveToNextState, { video: videoDatabase, isNewVideo: payload.isNewVideo })
}
}
await VideoJobInfoModel.decrease(video.uuid, 'pendingTranscode')
- await retryTransactionWrapper(moveToNextState, video, payload.isNewVideo)
+ await retryTransactionWrapper(moveToNextState, { video, isNewVideo: payload.isNewVideo })
}
// ---------------------------------------------------------------------------
AbuseStateChangeForReporter,
AutoFollowForInstance,
CommentMention,
+ EditionFinishedForOwner,
FollowForInstance,
FollowForUser,
ImportFinishedForOwner,
abuseStateChange: [ AbuseStateChangeForReporter ],
newAbuseMessage: [ NewAbuseMessageForReporter, NewAbuseMessageForModerators ],
newPeertubeVersion: [ NewPeerTubeVersionForAdmins ],
- newPluginVersion: [ NewPluginVersionForAdmins ]
+ newPluginVersion: [ NewPluginVersionForAdmins ],
+ videoEditionFinished: [ EditionFinishedForOwner ]
}
private static instance: Notifier
.catch(err => logger.error('Cannot notify on new plugin version %s.', plugin.name, { err }))
}
+ notifyOfFinishedVideoEdition (video: MVideoFullLight) {
+ const models = this.notificationModels.videoEditionFinished
+
+ this.sendNotifications(models, video)
+ .catch(err => logger.error('Cannot notify on finished edition %s.', video.url, { err }))
+ }
+
private async notify <T> (object: AbstractNotification<T>) {
await object.prepare()
subject: `Your video ${this.payload.name} has been published`,
text: `Your video "${this.payload.name}" has been published.`,
locals: {
- title: 'You video is live',
+ title: 'Your video is live',
action: {
text: 'View video',
url: videoUrl
--- /dev/null
+import { logger } from '@server/helpers/logger'
+import { WEBSERVER } from '@server/initializers/constants'
+import { UserModel } from '@server/models/user/user'
+import { UserNotificationModel } from '@server/models/user/user-notification'
+import { MUserDefault, MUserWithNotificationSetting, MVideoFullLight, UserNotificationModelForApi } from '@server/types/models'
+import { UserNotificationType } from '@shared/models'
+import { AbstractNotification } from '../common/abstract-notification'
+
+export class EditionFinishedForOwner extends AbstractNotification <MVideoFullLight> {
+ private user: MUserDefault
+
+ async prepare () {
+ this.user = await UserModel.loadByVideoId(this.payload.id)
+ }
+
+ log () {
+ logger.info('Notifying user %s its video edition %s is finished.', this.user.username, this.payload.url)
+ }
+
+ getSetting (user: MUserWithNotificationSetting) {
+ return user.NotificationSetting.myVideoEditionFinished
+ }
+
+ getTargetUsers () {
+ if (!this.user) return []
+
+ return [ this.user ]
+ }
+
+ async createNotification (user: MUserWithNotificationSetting) {
+ const notification = await UserNotificationModel.create<UserNotificationModelForApi>({
+ type: UserNotificationType.MY_VIDEO_EDITION_FINISHED,
+ userId: user.id,
+ videoId: this.payload.id
+ })
+ notification.Video = this.payload
+
+ return notification
+ }
+
+ createEmail (to: string) {
+ const videoUrl = WEBSERVER.URL + this.payload.getWatchStaticPath()
+
+ return {
+ to,
+ subject: `Edition of your video ${this.payload.name} has finished`,
+ text: `Edition of your video ${this.payload.name} has finished.`,
+ locals: {
+ title: 'Video edition has finished',
+ action: {
+ text: 'View video',
+ url: videoUrl
+ }
+ }
+ }
+ }
+}
export * from './new-video-for-subscribers'
+export * from './edition-finished-for-owner'
export * from './import-finished-for-owner'
export * from './owned-publication-after-auto-unblacklist'
export * from './owned-publication-after-schedule-update'
abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
autoInstanceFollowing: UserNotificationSettingValue.WEB,
newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
- newPluginVersion: UserNotificationSettingValue.WEB
+ newPluginVersion: UserNotificationSettingValue.WEB,
+ myVideoEditionFinished: UserNotificationSettingValue.WEB
}
return UserNotificationSettingModel.create(values, { transaction: t })
}
if (
+ currentState !== VideoState.TO_EDIT &&
currentState !== VideoState.TO_TRANSCODE &&
currentState !== VideoState.TO_MOVE_TO_EXTERNAL_STORAGE &&
CONFIG.TRANSCODING.ENABLED
return VideoState.PUBLISHED
}
-function moveToNextState (video: MVideoUUID, isNewVideo = true) {
+function moveToNextState (options: {
+ video: MVideoUUID
+ previousVideoState?: VideoState
+ isNewVideo?: boolean // Default true
+}) {
+ const { video, previousVideoState, isNewVideo = true } = options
+
return sequelizeTypescript.transaction(async t => {
// Maybe the video changed in database, refresh it
const videoDatabase = await VideoModel.loadAndPopulateAccountAndServerAndTags(video.uuid, t)
const newState = buildNextVideoState(videoDatabase.state)
if (newState === VideoState.PUBLISHED) {
- return moveToPublishedState(videoDatabase, isNewVideo, t)
+ return moveToPublishedState({ video: videoDatabase, previousVideoState, isNewVideo, transaction: t })
}
if (newState === VideoState.TO_MOVE_TO_EXTERNAL_STORAGE) {
- return moveToExternalStorageState(videoDatabase, isNewVideo, t)
+ return moveToExternalStorageState({ video: videoDatabase, isNewVideo, transaction: t })
}
})
}
-async function moveToExternalStorageState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
+async function moveToExternalStorageState (options: {
+ video: MVideoFullLight
+ isNewVideo: boolean
+ transaction: Transaction
+}) {
+ const { video, isNewVideo, transaction } = options
+
const videoJobInfo = await VideoJobInfoModel.load(video.id, transaction)
const pendingTranscode = videoJobInfo?.pendingTranscode || 0
// We want to wait all transcoding jobs before moving the video on an external storage
if (pendingTranscode !== 0) return false
+ const previousVideoState = video.state
await video.setNewState(VideoState.TO_MOVE_TO_EXTERNAL_STORAGE, isNewVideo, transaction)
logger.info('Creating external storage move job for video %s.', video.uuid, { tags: [ video.uuid ] })
try {
- await addMoveToObjectStorageJob(video, isNewVideo)
+ await addMoveToObjectStorageJob({ video, previousVideoState, isNewVideo })
return true
} catch (err) {
// ---------------------------------------------------------------------------
-async function moveToPublishedState (video: MVideoFullLight, isNewVideo: boolean, transaction: Transaction) {
- logger.info('Publishing video %s.', video.uuid, { tags: [ video.uuid ] })
+async function moveToPublishedState (options: {
+ video: MVideoFullLight
+ isNewVideo: boolean
+ transaction: Transaction
+ previousVideoState?: VideoState
+}) {
+ const { video, isNewVideo, transaction, previousVideoState } = options
+ const previousState = previousVideoState ?? video.state
+
+ logger.info('Publishing video %s.', video.uuid, { previousState, tags: [ video.uuid ] })
- const previousState = video.state
await video.setNewState(VideoState.PUBLISHED, isNewVideo, transaction)
// If the video was not published, we consider it is a new one for other instances
// Live videos are always federated, so it's not a new video
await federateVideoIfNeeded(video, isNewVideo, transaction)
- if (!isNewVideo) return
+ if (previousState === VideoState.TO_EDIT) {
+ Notifier.Instance.notifyOfFinishedVideoEdition(video)
+ return
+ }
- Notifier.Instance.notifyOnNewVideoIfNeeded(video)
+ if (isNewVideo) {
+ Notifier.Instance.notifyOnNewVideoIfNeeded(video)
- if (previousState === VideoState.TO_TRANSCODE) {
- Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(video)
+ if (previousState === VideoState.TO_TRANSCODE) {
+ Notifier.Instance.notifyOnVideoPublishedAfterTranscoding(video)
+ }
}
}
import { VideoJobInfoModel } from '@server/models/video/video-job-info'
import { FilteredModelAttributes } from '@server/types'
import { MThumbnail, MUserId, MVideoFile, MVideoTag, MVideoThumbnail, MVideoUUID } from '@server/types/models'
-import { ThumbnailType, VideoCreate, VideoPrivacy, VideoTranscodingPayload } from '@shared/models'
+import { ThumbnailType, VideoCreate, VideoPrivacy, VideoState, VideoTranscodingPayload } from '@shared/models'
import { CreateJobOptions, JobQueue } from './job-queue/job-queue'
import { updateVideoMiniatureFromExisting } from './thumbnail'
import { CONFIG } from '@server/initializers/config'
return Promise.all(promises)
}
+// ---------------------------------------------------------------------------
+
async function setVideoTags (options: {
video: MVideoTag
tags: string[]
video.Tags = tagInstances
}
-async function addOptimizeOrMergeAudioJob (video: MVideoUUID, videoFile: MVideoFile, user: MUserId, isNewVideo = true) {
+// ---------------------------------------------------------------------------
+
+async function addOptimizeOrMergeAudioJob (options: {
+ video: MVideoUUID
+ videoFile: MVideoFile
+ user: MUserId
+ isNewVideo?: boolean // Default true
+}) {
+ const { video, videoFile, user, isNewVideo } = options
+
let dataInput: VideoTranscodingPayload
if (videoFile.isAudio()) {
return JobQueue.Instance.createJobWithPromise({ type: 'video-transcoding', payload: payload }, options)
}
-async function addMoveToObjectStorageJob (video: MVideoUUID, isNewVideo = true) {
- await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
-
- const dataInput = { videoUUID: video.uuid, isNewVideo }
- return JobQueue.Instance.createJobWithPromise({ type: 'move-to-object-storage', payload: dataInput })
-}
-
async function getTranscodingJobPriority (user: MUserId) {
const now = new Date()
const lastWeek = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7)
// ---------------------------------------------------------------------------
+async function addMoveToObjectStorageJob (options: {
+ video: MVideoUUID
+ previousVideoState: VideoState
+ isNewVideo?: boolean // Default true
+}) {
+ const { video, previousVideoState, isNewVideo = true } = options
+
+ await VideoJobInfoModel.increaseOrCreate(video.uuid, 'pendingMove')
+
+ const dataInput = { videoUUID: video.uuid, isNewVideo, previousVideoState }
+ return JobQueue.Instance.createJobWithPromise({ type: 'move-to-object-storage', payload: dataInput })
+}
+
+// ---------------------------------------------------------------------------
+
export {
buildLocalVideoFromReq,
buildVideoThumbnailsFromReq,
@Column
newPluginVersion: UserNotificationSettingValue
+ @AllowNull(false)
+ @Default(null)
+ @Is(
+ 'UserNotificationSettingMyVideoEditionFinished',
+ value => throwIfNotValid(value, isUserNotificationSettingValid, 'myVideoEditionFinished')
+ )
+ @Column
+ myVideoEditionFinished: UserNotificationSettingValue
+
@ForeignKey(() => UserModel)
@Column
userId: number
abuseNewMessage: this.abuseNewMessage,
abuseStateChange: this.abuseStateChange,
newPeerTubeVersion: this.newPeerTubeVersion,
+ myVideoEditionFinished: this.myVideoEditionFinished,
newPluginVersion: this.newPluginVersion
}
}
abuseNewMessage: UserNotificationSettingValue.WEB,
abuseStateChange: UserNotificationSettingValue.WEB,
newPeerTubeVersion: UserNotificationSettingValue.WEB,
+ myVideoEditionFinished: UserNotificationSettingValue.WEB,
newPluginVersion: UserNotificationSettingValue.WEB
}
checkMyVideoImportIsFinished,
checkNewActorFollow,
checkNewVideoFromSubscription,
+ checkVideoEditionIsFinished,
checkVideoIsPublished,
FIXTURE_URLS,
MockSmtpServer,
} from '@server/tests/shared'
import { wait } from '@shared/core-utils'
import { buildUUID } from '@shared/extra-utils'
-import { UserNotification, UserNotificationType, VideoPrivacy } from '@shared/models'
+import { UserNotification, UserNotificationType, VideoEditorTask, VideoPrivacy } from '@shared/models'
import { cleanupTests, PeerTubeServer, waitJobs } from '@shared/server-commands'
const expect = chai.expect
describe('Test user notifications', function () {
let servers: PeerTubeServer[] = []
let userAccessToken: string
+
let userNotifications: UserNotification[] = []
let adminNotifications: UserNotification[] = []
let adminNotificationsServer2: UserNotification[] = []
let emails: object[] = []
+
let channelId: number
before(async function () {
})
})
+ describe('Video editor', function () {
+ let baseParams: CheckerBaseParams
+
+ before(() => {
+ baseParams = {
+ server: servers[1],
+ emails,
+ socketNotifications: adminNotificationsServer2,
+ token: servers[1].accessToken
+ }
+ })
+
+ it('Should send a notification after editor edition', async function () {
+ this.timeout(240000)
+
+ const { name, shortUUID, id } = await uploadRandomVideoOnServers(servers, 2, { waitTranscoding: true })
+
+ await waitJobs(servers)
+ await checkVideoIsPublished({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
+
+ const tasks: VideoEditorTask[] = [
+ {
+ name: 'cut',
+ options: {
+ start: 0,
+ end: 1
+ }
+ }
+ ]
+ await servers[1].videoEditor.createEditionTasks({ videoId: id, tasks })
+ await waitJobs(servers)
+
+ await checkVideoEditionIsFinished({ ...baseParams, videoName: name, shortUUID, checkType: 'presence' })
+ })
+ })
+
describe('My video is imported', function () {
let baseParams: CheckerBaseParams
await servers[0].config.enableMinimumTranscoding()
- await servers[0].config.updateExistingSubConfig({
- newConfig: {
- videoEditor: {
- enabled: true
- }
- }
- })
+ await servers[0].config.enableEditor()
})
describe('Cutting', function () {
abuseStateChange: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
autoInstanceFollowing: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
newPeerTubeVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
+ myVideoEditionFinished: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL,
newPluginVersion: UserNotificationSettingValue.WEB | UserNotificationSettingValue.EMAIL
}
}
await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
}
+async function checkVideoEditionIsFinished (options: CheckerBaseParams & {
+ videoName: string
+ shortUUID: string
+ checkType: CheckerType
+}) {
+ const { videoName, shortUUID } = options
+ const notificationType = UserNotificationType.MY_VIDEO_EDITION_FINISHED
+
+ function notificationChecker (notification: UserNotification, checkType: CheckerType) {
+ if (checkType === 'presence') {
+ expect(notification).to.not.be.undefined
+ expect(notification.type).to.equal(notificationType)
+
+ checkVideo(notification.video, videoName, shortUUID)
+ checkActor(notification.video.channel)
+ } else {
+ expect(notification.video).to.satisfy(v => v === undefined || v.name !== videoName)
+ }
+ }
+
+ function emailNotificationFinder (email: object) {
+ const text: string = email['text']
+ return text.includes(shortUUID) && text.includes('Edition of your video')
+ }
+
+ await checkNotification({ ...options, notificationChecker, emailNotificationFinder })
+}
+
async function checkMyVideoImportIsFinished (options: CheckerBaseParams & {
videoName: string
shortUUID: string
await setDefaultChannelAvatar(servers)
await setDefaultAccountAvatar(servers)
+ await servers[1].config.enableEditor()
+
if (serversCount > 1) {
await doubleFollow(servers[0], servers[1])
}
checkNewCommentAbuseForModerators,
checkNewAccountAbuseForModerators,
checkNewPeerTubeVersion,
- checkNewPluginVersion
+ checkNewPluginVersion,
+ checkVideoEditionIsFinished
}
// ---------------------------------------------------------------------------
import { ContextType } from '../activitypub/context'
+import { VideoState } from '../videos'
import { VideoEditorTaskCut } from '../videos/editor'
import { VideoResolution } from '../videos/file/video-resolution.enum'
import { SendEmailOptions } from './emailer.model'
interface BaseTranscodingPayload {
videoUUID: string
isNewVideo?: boolean
+
+ // Custom notification when the task is finished
+ notification?: 'default' | 'video-edition'
}
export interface HLSTranscodingPayload extends BaseTranscodingPayload {
export interface MoveObjectStoragePayload {
videoUUID: string
isNewVideo: boolean
+ previousVideoState: VideoState
}
export type VideoEditorTaskCutPayload = VideoEditorTaskCut
newPeerTubeVersion: UserNotificationSettingValue
newPluginVersion: UserNotificationSettingValue
+
+ myVideoEditionFinished: UserNotificationSettingValue
}
ABUSE_NEW_MESSAGE = 16,
NEW_PLUGIN_VERSION = 17,
- NEW_PEERTUBE_VERSION = 18
+ NEW_PEERTUBE_VERSION = 18,
+
+ MY_VIDEO_EDITION_FINISHED = 19
}
export interface VideoInfo {
})
}
+ enableEditor () {
+ return this.updateExistingSubConfig({
+ newConfig: {
+ videoEditor: {
+ enabled: true
+ }
+ }
+ })
+ }
+
getConfig (options: OverrideCommandOptions = {}) {
const path = '/api/v1/config'
projects / github / Chocobozzz / PeerTube.git / commitdiff
