[routerLink]="['/videos/watch', video.uuid]" [attr.title]="video.name"
class="video-thumbnail"
>
-<img alt="" [attr.aria-labelledby]="video.name" [attr.src]="getImageUrl()" [ngClass]="{ 'blur-filter': nsfw }" />
+
<img alt="" [attr.aria-labelledby]="video.name" [attr.src]="getImageUrl()" [ngClass]="{ 'blur-filter': nsfw }" />
-<div class="video-thumbnail-overlay">
- {{ video.durationLabel }}
-</div>
+ <div class="video-thumbnail-overlay">{{ video.durationLabel }}</div>
+
+ <div class="progress-bar" *ngIf="video.userHistory?.currentTime">
+ <div [ngStyle]="{ 'width.%': getProgressPercent() }"></div>
+ </div>
</a>
}
}
+ .progress-bar {
+ height: 3px;
+ width: 100%;
+ position: relative;
+ top: -3px;
+ background-color: rgba(0, 0, 0, 0.20);
+
+ div {
+ height: 100%;
+ background-color: var(--mainColor);
+ }
+ }
+
.video-thumbnail-overlay {
position: absolute;
right: 5px;
return this.video.thumbnailUrl
}
+
+ getProgressPercent () {
+ if (!this.video.userHistory) return 0
+
+ const currentTime = this.video.userHistory.currentTime
+
+ return (currentTime / this.video.duration) * 100
+ }
}
avatar: Avatar
}
+ userHistory?: {
+ currentTime: number
+ }
+
static buildClientUrl (videoUUID: string) {
return '/videos/watch/' + videoUUID
}
this.blacklisted = hash.blacklisted
this.blacklistedReason = hash.blacklistedReason
+
+ this.userHistory = hash.userHistory
}
isVideoNSFWForUser (user: User, serverConfig: ServerConfig) {
return VideoService.BASE_VIDEO_URL + uuid + '/views'
}
+ getUserWatchingVideoUrl (uuid: string) {
+ return VideoService.BASE_VIDEO_URL + uuid + '/watching'
+ }
+
getVideo (uuid: string): Observable<VideoDetails> {
return this.serverService.localeObservable
.pipe(
)
}
- private async onVideoFetched (video: VideoDetails, videoCaptions: VideoCaption[], startTime = 0) {
+ private async onVideoFetched (video: VideoDetails, videoCaptions: VideoCaption[], startTimeFromUrl: number) {
this.video = video
// Re init attributes
this.completeDescriptionShown = false
this.remoteServerDown = false
+ let startTime = startTimeFromUrl || (this.video.userHistory ? this.video.userHistory.currentTime : 0)
+ // Don't start the video if we are at the end
+ if (this.video.duration - startTime <= 1) startTime = 0
+
if (this.video.isVideoNSFWForUser(this.user, this.serverService.getConfig())) {
const res = await this.confirmService.confirm(
this.i18n('This video contains mature or explicit content. Are you sure you want to watch it?'),
poster: this.video.previewUrl,
startTime,
theaterMode: true,
- language: this.localeId
+ language: this.localeId,
+
+ userWatching: this.user ? {
+ url: this.videoService.getUserWatchingVideoUrl(this.video.uuid),
+ authorizationHeader: this.authService.getRequestHeaderValue()
+ } : undefined
})
if (this.videojsLocaleLoaded === false) {
import './peertube-videojs-plugin'
import './peertube-load-progress-bar'
import './theater-button'
-import { VideoJSCaption, videojsUntyped } from './peertube-videojs-typings'
+import { UserWatching, VideoJSCaption, videojsUntyped } from './peertube-videojs-typings'
import { buildVideoEmbed, buildVideoLink, copyToClipboard } from './utils'
import { getCompleteLocale, getShortLocale, is18nLocale, isDefaultLocale } from '../../../../shared/models/i18n/i18n'
startTime: number | string
theaterMode: boolean,
videoCaptions: VideoJSCaption[],
+
language?: string,
controls?: boolean,
muted?: boolean,
loop?: boolean
+
+ userWatching?: UserWatching
}) {
const videojsOptions = {
// We don't use text track settings for now
playerElement: options.playerElement,
videoViewUrl: options.videoViewUrl,
videoDuration: options.videoDuration,
- startTime: options.startTime
+ startTime: options.startTime,
+ userWatching: options.userWatching
}
},
controlBar: {
import { VideoFile } from '../../../../shared/models/videos/video.model'
import { renderVideo } from './video-renderer'
import './settings-menu-button'
-import { PeertubePluginOptions, VideoJSCaption, VideoJSComponentInterface, videojsUntyped } from './peertube-videojs-typings'
+import { PeertubePluginOptions, UserWatching, VideoJSCaption, VideoJSComponentInterface, videojsUntyped } from './peertube-videojs-typings'
import { isMobile, timeToInt, videoFileMaxByResolution, videoFileMinByResolution } from './utils'
import * as CacheChunkStore from 'cache-chunk-store'
import { PeertubeChunkStore } from './peertube-chunk-store'
AUTO_QUALITY_THRESHOLD_PERCENT: 30, // Bandwidth should be 30% more important than a resolution bitrate to change to it
AUTO_QUALITY_OBSERVATION_TIME: 10000, // Wait 10 seconds after having change the resolution before another check
AUTO_QUALITY_HIGHER_RESOLUTION_DELAY: 5000, // Buffering higher resolution during 5 seconds
- BANDWIDTH_AVERAGE_NUMBER_OF_VALUES: 5 // Last 5 seconds to build average bandwidth
+ BANDWIDTH_AVERAGE_NUMBER_OF_VALUES: 5, // Last 5 seconds to build average bandwidth
+ USER_WATCHING_VIDEO_INTERVAL: 5000 // Every 5 seconds, notify the user is watching the video
}
private readonly webtorrent = new WebTorrent({
private videoViewInterval
private torrentInfoInterval
private autoQualityInterval
+ private userWatchingVideoInterval
private addTorrentDelay
private qualityObservationTimer
private runAutoQualitySchedulerTimer
this.runTorrentInfoScheduler()
this.runViewAdd()
+ if (options.userWatching) this.runUserWatchVideo(options.userWatching)
+
this.player.one('play', () => {
// Don't run immediately scheduler, wait some seconds the TCP connections are made
this.runAutoQualitySchedulerTimer = setTimeout(() => this.runAutoQualityScheduler(), this.CONSTANTS.AUTO_QUALITY_SCHEDULER)
clearInterval(this.torrentInfoInterval)
clearInterval(this.autoQualityInterval)
+ if (this.userWatchingVideoInterval) clearInterval(this.userWatchingVideoInterval)
+
// Don't need to destroy renderer, video player will be destroyed
this.flushVideoFile(this.currentVideoFile, false)
}, 1000)
}
+ private runUserWatchVideo (options: UserWatching) {
+ let lastCurrentTime = 0
+
+ this.userWatchingVideoInterval = setInterval(() => {
+ const currentTime = Math.floor(this.player.currentTime())
+
+ if (currentTime - lastCurrentTime >= 1) {
+ lastCurrentTime = currentTime
+
+ this.notifyUserIsWatching(currentTime, options.url, options.authorizationHeader)
+ .catch(err => console.error('Cannot notify user is watching.', err))
+ }
+ }, this.CONSTANTS.USER_WATCHING_VIDEO_INTERVAL)
+ }
+
private clearVideoViewInterval () {
if (this.videoViewInterval !== undefined) {
clearInterval(this.videoViewInterval)
return fetch(this.videoViewUrl, { method: 'POST' })
}
+ private notifyUserIsWatching (currentTime: number, url: string, authorizationHeader: string) {
+ const body = new URLSearchParams()
+ body.append('currentTime', currentTime.toString())
+
+ const headers = new Headers({ 'Authorization': authorizationHeader })
+
+ return fetch(url, { method: 'PUT', body, headers })
+ }
+
private fallbackToHttp (done?: Function, play = true) {
this.disableAutoResolution(true)
src: string
}
+type UserWatching = {
+ url: string,
+ authorizationHeader: string
+}
+
type PeertubePluginOptions = {
videoFiles: VideoFile[]
playerElement: HTMLVideoElement
startTime: number | string
autoplay: boolean,
videoCaptions: VideoJSCaption[]
+
+ userWatching?: UserWatching
}
// videojs typings don't have some method we need
VideoJSComponentInterface,
PeertubePluginOptions,
videojsUntyped,
- VideoJSCaption
+ VideoJSCaption,
+ UserWatching
}
localVideoChannelValidator,
videosCustomGetValidator
} from '../../middlewares'
-import { videosGetValidator, videosShareValidator } from '../../middlewares/validators'
-import { videoCommentGetValidator } from '../../middlewares/validators/video-comments'
+import { videoCommentGetValidator, videosGetValidator, videosShareValidator } from '../../middlewares/validators'
import { AccountModel } from '../../models/account/account'
import { ActorModel } from '../../models/activitypub/actor'
import { ActorFollowModel } from '../../models/activitypub/actor-follow'
async function searchVideosDB (query: VideosSearchQuery, res: express.Response) {
const options = Object.assign(query, {
includeLocalVideos: true,
- nsfw: buildNSFWFilter(res, query.nsfw)
+ nsfw: buildNSFWFilter(res, query.nsfw),
+ userId: res.locals.oauth ? res.locals.oauth.token.User.id : undefined
})
const resultList = await VideoModel.searchAndPopulateAccountAndServer(options)
import * as express from 'express'
import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate } from '../../../middlewares'
-import {
- addVideoCaptionValidator,
- deleteVideoCaptionValidator,
- listVideoCaptionsValidator
-} from '../../../middlewares/validators/video-captions'
+import { addVideoCaptionValidator, deleteVideoCaptionValidator, listVideoCaptionsValidator } from '../../../middlewares/validators'
import { createReqFiles } from '../../../helpers/express-utils'
import { CONFIG, sequelizeTypescript, VIDEO_CAPTIONS_MIMETYPE_EXT } from '../../../initializers'
import { getFormattedObjects } from '../../../helpers/utils'
setDefaultPagination,
setDefaultSort
} from '../../../middlewares'
-import { videoCommentThreadsSortValidator } from '../../../middlewares/validators'
import {
addVideoCommentReplyValidator,
addVideoCommentThreadValidator,
listVideoCommentThreadsValidator,
listVideoThreadCommentsValidator,
- removeVideoCommentValidator
-} from '../../../middlewares/validators/video-comments'
+ removeVideoCommentValidator,
+ videoCommentThreadsSortValidator
+} from '../../../middlewares/validators'
import { VideoModel } from '../../../models/video/video'
import { VideoCommentModel } from '../../../models/video/video-comment'
import { auditLoggerFactory, CommentAuditView, getAuditIdFromRes } from '../../../helpers/audit-logger'
import { videoImportsRouter } from './import'
import { resetSequelizeInstance } from '../../../helpers/database-utils'
import { rename } from 'fs-extra'
+import { watchingRouter } from './watching'
const auditLogger = auditLoggerFactory('videos')
const videosRouter = express.Router()
videosRouter.use('/', videoCaptionsRouter)
videosRouter.use('/', videoImportsRouter)
videosRouter.use('/', ownershipVideoRouter)
+videosRouter.use('/', watchingRouter)
videosRouter.get('/categories', listVideoCategories)
videosRouter.get('/licences', listVideoLicences)
asyncMiddleware(getVideoDescription)
)
videosRouter.get('/:id',
+ optionalAuthenticate,
asyncMiddleware(videosGetValidator),
getVideo
)
tagsAllOf: req.query.tagsAllOf,
nsfw: buildNSFWFilter(res, req.query.nsfw),
filter: req.query.filter as VideoFilter,
- withFiles: false
+ withFiles: false,
+ userId: res.locals.oauth ? res.locals.oauth.token.User.id : undefined
})
return res.json(getFormattedObjects(resultList.data, resultList.total))
--- /dev/null
+import * as express from 'express'
+import { UserWatchingVideo } from '../../../../shared'
+import { asyncMiddleware, asyncRetryTransactionMiddleware, authenticate, videoWatchingValidator } from '../../../middlewares'
+import { UserVideoHistoryModel } from '../../../models/account/user-video-history'
+import { UserModel } from '../../../models/account/user'
+
+const watchingRouter = express.Router()
+
+watchingRouter.put('/:videoId/watching',
+ authenticate,
+ asyncMiddleware(videoWatchingValidator),
+ asyncRetryTransactionMiddleware(userWatchVideo)
+)
+
+// ---------------------------------------------------------------------------
+
+export {
+ watchingRouter
+}
+
+// ---------------------------------------------------------------------------
+
+async function userWatchVideo (req: express.Request, res: express.Response) {
+ const user = res.locals.oauth.token.User as UserModel
+
+ const body: UserWatchingVideo = req.body
+ const { id: videoId } = res.locals.video as { id: number }
+
+ await UserVideoHistoryModel.upsert({
+ videoId,
+ userId: user.id,
+ currentTime: body.currentTime
+ })
+
+ return res.type('json').status(204).end()
+}
}
async function isVideoExist (id: string, res: Response, fetchType: VideoFetchType = 'all') {
- const video = await fetchVideo(id, fetchType)
+ const userId = res.locals.oauth ? res.locals.oauth.token.User.id : undefined
+
+ const video = await fetchVideo(id, fetchType, userId)
if (video === null) {
res.status(404)
type VideoFetchType = 'all' | 'only-video' | 'id' | 'none'
-function fetchVideo (id: number | string, fetchType: VideoFetchType) {
- if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id)
+function fetchVideo (id: number | string, fetchType: VideoFetchType, userId?: number) {
+ if (fetchType === 'all') return VideoModel.loadAndPopulateAccountAndServerAndTags(id, undefined, userId)
if (fetchType === 'only-video') return VideoModel.load(id)
import { VideoViewModel } from '../models/video/video-views'
import { VideoChangeOwnershipModel } from '../models/video/video-change-ownership'
import { VideoRedundancyModel } from '../models/redundancy/video-redundancy'
+import { UserVideoHistoryModel } from '../models/account/user-video-history'
require('pg').defaults.parseInt8 = true // Avoid BIGINT to be converted to string
ScheduleVideoUpdateModel,
VideoImportModel,
VideoViewModel,
- VideoRedundancyModel
+ VideoRedundancyModel,
+ UserVideoHistoryModel
])
// Check extensions exist in the database
)
}
+ /************* Forgot password *************/
+
async setResetPasswordVerificationString (userId: number) {
const generatedString = await generateRandomString(32)
return this.getValue(this.generateResetPasswordKey(userId))
}
+ /************* Email verification *************/
+
async setVerifyEmailVerificationString (userId: number) {
const generatedString = await generateRandomString(32)
return this.getValue(this.generateVerifyEmailKey(userId))
}
+ /************* Views per IP *************/
+
setIPVideoView (ip: string, videoUUID: string) {
- return this.setValue(this.buildViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
+ return this.setValue(this.generateViewKey(ip, videoUUID), '1', VIDEO_VIEW_LIFETIME)
}
async isVideoIPViewExists (ip: string, videoUUID: string) {
- return this.exists(this.buildViewKey(ip, videoUUID))
+ return this.exists(this.generateViewKey(ip, videoUUID))
}
+ /************* API cache *************/
+
async getCachedRoute (req: express.Request) {
- const cached = await this.getObject(this.buildCachedRouteKey(req))
+ const cached = await this.getObject(this.generateCachedRouteKey(req))
return cached as CachedRoute
}
(statusCode) ? { statusCode: statusCode.toString() } : null
)
- return this.setObject(this.buildCachedRouteKey(req), cached, lifetime)
+ return this.setObject(this.generateCachedRouteKey(req), cached, lifetime)
}
+ /************* Video views *************/
+
addVideoView (videoId: number) {
const keyIncr = this.generateVideoViewKey(videoId)
const keySet = this.generateVideosViewKey()
])
}
- generateVideosViewKey (hour?: number) {
+ /************* Keys generation *************/
+
+ generateCachedRouteKey (req: express.Request) {
+ return req.method + '-' + req.originalUrl
+ }
+
+ private generateVideosViewKey (hour?: number) {
if (!hour) hour = new Date().getHours()
return `videos-view-h${hour}`
}
- generateVideoViewKey (videoId: number, hour?: number) {
+ private generateVideoViewKey (videoId: number, hour?: number) {
if (!hour) hour = new Date().getHours()
return `video-view-${videoId}-h${hour}`
}
- generateResetPasswordKey (userId: number) {
+ private generateResetPasswordKey (userId: number) {
return 'reset-password-' + userId
}
- generateVerifyEmailKey (userId: number) {
+ private generateVerifyEmailKey (userId: number) {
return 'verify-email-' + userId
}
- buildViewKey (ip: string, videoUUID: string) {
+ private generateViewKey (ip: string, videoUUID: string) {
return videoUUID + '-' + ip
}
- buildCachedRouteKey (req: express.Request) {
- return req.method + '-' + req.originalUrl
- }
+ /************* Redis helpers *************/
private getValue (key: string) {
return new Promise<string>((res, rej) => {
})
}
+ private deleteFieldInHash (key: string, field: string) {
+ return new Promise<void>((res, rej) => {
+ this.client.hdel(this.prefix + key, field, err => err ? rej(err) : res())
+ })
+ }
+
private setValue (key: string, value: string, expirationMilliseconds: number) {
return new Promise<void>((res, rej) => {
this.client.set(this.prefix + key, value, 'PX', expirationMilliseconds, (err, ok) => {
})
}
+ private setValueInHash (key: string, field: string, value: string) {
+ return new Promise<void>((res, rej) => {
+ this.client.hset(this.prefix + key, field, value, (err) => {
+ if (err) return rej(err)
+
+ return res()
+ })
+ })
+ }
+
private increment (key: string) {
return new Promise<number>((res, rej) => {
this.client.incr(this.prefix + key, (err, value) => {
function cacheRoute (lifetimeArg: string | number) {
return async function (req: express.Request, res: express.Response, next: express.NextFunction) {
- const redisKey = Redis.Instance.buildCachedRouteKey(req)
+ const redisKey = Redis.Instance.generateCachedRouteKey(req)
try {
await lock.acquire(redisKey, async (done) => {
export * from './users'
export * from './user-subscriptions'
export * from './videos'
-export * from './video-abuses'
-export * from './video-blacklist'
-export * from './video-channels'
export * from './webfinger'
export * from './search'
-export * from './video-imports'
--- /dev/null
+export * from './video-abuses'
+export * from './video-blacklist'
+export * from './video-captions'
+export * from './video-channels'
+export * from './video-comments'
+export * from './video-imports'
+export * from './video-watch'
+export * from './videos'
import * as express from 'express'
import 'express-validator'
import { body, param } from 'express-validator/check'
-import { isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
import {
isVideoAbuseExist,
isVideoAbuseModerationCommentValid,
isVideoAbuseReasonValid,
isVideoAbuseStateValid
-} from '../../helpers/custom-validators/video-abuses'
+} from '../../../helpers/custom-validators/video-abuses'
const videoAbuseReportValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import * as express from 'express'
import { body, param } from 'express-validator/check'
-import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
-import { isVideoBlacklistExist, isVideoBlacklistReasonValid } from '../../helpers/custom-validators/video-blacklist'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
+import { isVideoBlacklistExist, isVideoBlacklistReasonValid } from '../../../helpers/custom-validators/video-blacklist'
const videosBlacklistRemoveValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import * as express from 'express'
-import { areValidationErrors } from './utils'
-import { checkUserCanManageVideo, isVideoExist } from '../../helpers/custom-validators/videos'
-import { isIdOrUUIDValid } from '../../helpers/custom-validators/misc'
+import { areValidationErrors } from '../utils'
+import { checkUserCanManageVideo, isVideoExist } from '../../../helpers/custom-validators/videos'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
import { body, param } from 'express-validator/check'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
-import { UserRight } from '../../../shared'
-import { logger } from '../../helpers/logger'
-import { isVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../helpers/custom-validators/video-captions'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { UserRight } from '../../../../shared'
+import { logger } from '../../../helpers/logger'
+import { isVideoCaptionExist, isVideoCaptionFile, isVideoCaptionLanguageValid } from '../../../helpers/custom-validators/video-captions'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
const addVideoCaptionValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid video id'),
import * as express from 'express'
import { body, param } from 'express-validator/check'
-import { UserRight } from '../../../shared'
-import { isAccountNameWithHostExist } from '../../helpers/custom-validators/accounts'
+import { UserRight } from '../../../../shared'
+import { isAccountNameWithHostExist } from '../../../helpers/custom-validators/accounts'
import {
isLocalVideoChannelNameExist,
isVideoChannelDescriptionValid,
isVideoChannelNameValid,
isVideoChannelNameWithHostExist,
isVideoChannelSupportValid
-} from '../../helpers/custom-validators/video-channels'
-import { logger } from '../../helpers/logger'
-import { UserModel } from '../../models/account/user'
-import { VideoChannelModel } from '../../models/video/video-channel'
-import { areValidationErrors } from './utils'
-import { isActorPreferredUsernameValid } from '../../helpers/custom-validators/activitypub/actor'
-import { ActorModel } from '../../models/activitypub/actor'
+} from '../../../helpers/custom-validators/video-channels'
+import { logger } from '../../../helpers/logger'
+import { UserModel } from '../../../models/account/user'
+import { VideoChannelModel } from '../../../models/video/video-channel'
+import { areValidationErrors } from '../utils'
+import { isActorPreferredUsernameValid } from '../../../helpers/custom-validators/activitypub/actor'
+import { ActorModel } from '../../../models/activitypub/actor'
const listVideoAccountChannelsValidator = [
param('accountName').exists().withMessage('Should have a valid account name'),
import * as express from 'express'
import { body, param } from 'express-validator/check'
-import { UserRight } from '../../../shared'
-import { isIdOrUUIDValid, isIdValid } from '../../helpers/custom-validators/misc'
-import { isValidVideoCommentText } from '../../helpers/custom-validators/video-comments'
-import { isVideoExist } from '../../helpers/custom-validators/videos'
-import { logger } from '../../helpers/logger'
-import { UserModel } from '../../models/account/user'
-import { VideoModel } from '../../models/video/video'
-import { VideoCommentModel } from '../../models/video/video-comment'
-import { areValidationErrors } from './utils'
+import { UserRight } from '../../../../shared'
+import { isIdOrUUIDValid, isIdValid } from '../../../helpers/custom-validators/misc'
+import { isValidVideoCommentText } from '../../../helpers/custom-validators/video-comments'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { logger } from '../../../helpers/logger'
+import { UserModel } from '../../../models/account/user'
+import { VideoModel } from '../../../models/video/video'
+import { VideoCommentModel } from '../../../models/video/video-comment'
+import { areValidationErrors } from '../utils'
const listVideoCommentThreadsValidator = [
param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid videoId'),
import * as express from 'express'
import { body } from 'express-validator/check'
-import { isIdValid } from '../../helpers/custom-validators/misc'
-import { logger } from '../../helpers/logger'
-import { areValidationErrors } from './utils'
+import { isIdValid } from '../../../helpers/custom-validators/misc'
+import { logger } from '../../../helpers/logger'
+import { areValidationErrors } from '../utils'
import { getCommonVideoAttributes } from './videos'
-import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../helpers/custom-validators/video-imports'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
-import { isVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../helpers/custom-validators/videos'
-import { CONFIG } from '../../initializers/constants'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
+import { isVideoImportTargetUrlValid, isVideoImportTorrentFile } from '../../../helpers/custom-validators/video-imports'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { isVideoChannelOfAccountExist, isVideoMagnetUriValid, isVideoNameValid } from '../../../helpers/custom-validators/videos'
+import { CONFIG } from '../../../initializers/constants'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
const videoImportAddValidator = getCommonVideoAttributes().concat([
body('channelId')
--- /dev/null
+import { body, param } from 'express-validator/check'
+import * as express from 'express'
+import { isIdOrUUIDValid } from '../../../helpers/custom-validators/misc'
+import { isVideoExist } from '../../../helpers/custom-validators/videos'
+import { areValidationErrors } from '../utils'
+import { logger } from '../../../helpers/logger'
+
+const videoWatchingValidator = [
+ param('videoId').custom(isIdOrUUIDValid).not().isEmpty().withMessage('Should have a valid id'),
+ body('currentTime')
+ .toInt()
+ .isInt().withMessage('Should have correct current time'),
+
+ async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+ logger.debug('Checking videoWatching parameters', { parameters: req.body })
+
+ if (areValidationErrors(req, res)) return
+ if (!await isVideoExist(req.params.videoId, res, 'id')) return
+
+ return next()
+ }
+]
+
+// ---------------------------------------------------------------------------
+
+export {
+ videoWatchingValidator
+}
import * as express from 'express'
import 'express-validator'
import { body, param, ValidationChain } from 'express-validator/check'
-import { UserRight, VideoChangeOwnershipStatus, VideoPrivacy } from '../../../shared'
+import { UserRight, VideoChangeOwnershipStatus, VideoPrivacy } from '../../../../shared'
import {
isBooleanValid,
isDateValid,
isUUIDValid,
toIntOrNull,
toValueOrNull
-} from '../../helpers/custom-validators/misc'
+} from '../../../helpers/custom-validators/misc'
import {
checkUserCanManageVideo,
isScheduleVideoUpdatePrivacyValid,
isVideoRatingTypeValid,
isVideoSupportValid,
isVideoTagsValid
-} from '../../helpers/custom-validators/videos'
-import { getDurationFromVideoFile } from '../../helpers/ffmpeg-utils'
-import { logger } from '../../helpers/logger'
-import { CONSTRAINTS_FIELDS } from '../../initializers'
-import { VideoShareModel } from '../../models/video/video-share'
-import { authenticate } from '../oauth'
-import { areValidationErrors } from './utils'
-import { cleanUpReqFiles } from '../../helpers/express-utils'
-import { VideoModel } from '../../models/video/video'
-import { UserModel } from '../../models/account/user'
-import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../helpers/custom-validators/video-ownership'
-import { VideoChangeOwnershipAccept } from '../../../shared/models/videos/video-change-ownership-accept.model'
-import { VideoChangeOwnershipModel } from '../../models/video/video-change-ownership'
-import { AccountModel } from '../../models/account/account'
-import { VideoFetchType } from '../../helpers/video'
+} from '../../../helpers/custom-validators/videos'
+import { getDurationFromVideoFile } from '../../../helpers/ffmpeg-utils'
+import { logger } from '../../../helpers/logger'
+import { CONSTRAINTS_FIELDS } from '../../../initializers'
+import { VideoShareModel } from '../../../models/video/video-share'
+import { authenticate } from '../../oauth'
+import { areValidationErrors } from '../utils'
+import { cleanUpReqFiles } from '../../../helpers/express-utils'
+import { VideoModel } from '../../../models/video/video'
+import { UserModel } from '../../../models/account/user'
+import { checkUserCanTerminateOwnershipChange, doesChangeVideoOwnershipExist } from '../../../helpers/custom-validators/video-ownership'
+import { VideoChangeOwnershipAccept } from '../../../../shared/models/videos/video-change-ownership-accept.model'
+import { VideoChangeOwnershipModel } from '../../../models/video/video-change-ownership'
+import { AccountModel } from '../../../models/account/account'
+import { VideoFetchType } from '../../../helpers/video'
const videosAddValidator = getCommonVideoAttributes().concat([
body('videofile')
--- /dev/null
+import { AllowNull, BelongsTo, Column, CreatedAt, ForeignKey, IsInt, Min, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { VideoModel } from '../video/video'
+import { UserModel } from './user'
+
+@Table({
+ tableName: 'userVideoHistory',
+ indexes: [
+ {
+ fields: [ 'userId', 'videoId' ],
+ unique: true
+ },
+ {
+ fields: [ 'userId' ]
+ },
+ {
+ fields: [ 'videoId' ]
+ }
+ ]
+})
+export class UserVideoHistoryModel extends Model<UserVideoHistoryModel> {
+ @CreatedAt
+ createdAt: Date
+
+ @UpdatedAt
+ updatedAt: Date
+
+ @AllowNull(false)
+ @IsInt
+ @Column
+ currentTime: number
+
+ @ForeignKey(() => VideoModel)
+ @Column
+ videoId: number
+
+ @BelongsTo(() => VideoModel, {
+ foreignKey: {
+ allowNull: false
+ },
+ onDelete: 'CASCADE'
+ })
+ Video: VideoModel
+
+ @ForeignKey(() => UserModel)
+ @Column
+ userId: number
+
+ @BelongsTo(() => UserModel, {
+ foreignKey: {
+ allowNull: false
+ },
+ onDelete: 'CASCADE'
+ })
+ User: UserModel
+}
getVideoLikesActivityPubUrl,
getVideoSharesActivityPubUrl
} from '../../lib/activitypub'
+import { isArray } from 'util'
export type VideoFormattingJSONOptions = {
completeDescription?: boolean
const formattedAccount = video.VideoChannel.Account.toFormattedJSON()
const formattedVideoChannel = video.VideoChannel.toFormattedJSON()
+ const userHistory = isArray(video.UserVideoHistories) ? video.UserVideoHistories[0] : undefined
+
const videoObject: Video = {
id: video.id,
uuid: video.uuid,
url: formattedVideoChannel.url,
host: formattedVideoChannel.host,
avatar: formattedVideoChannel.avatar
- }
+ },
+
+ userHistory: userHistory ? {
+ currentTime: userHistory.currentTime
+ } : undefined
}
if (options) {
videoModelToFormattedJSON
} from './video-format-utils'
import * as validator from 'validator'
+import { UserVideoHistoryModel } from '../account/user-video-history'
+
// FIXME: Define indexes here because there is an issue with TS and Sequelize.literal when called directly in the annotation
const indexes: Sequelize.DefineIndexesOptions[] = [
WITH_TAGS = 'WITH_TAGS',
WITH_FILES = 'WITH_FILES',
WITH_SCHEDULED_UPDATE = 'WITH_SCHEDULED_UPDATE',
- WITH_BLACKLISTED = 'WITH_BLACKLISTED'
+ WITH_BLACKLISTED = 'WITH_BLACKLISTED',
+ WITH_USER_HISTORY = 'WITH_USER_HISTORY'
}
type ForAPIOptions = {
include: [
{
model: () => VideoFileModel.unscoped(),
+ // FIXME: typings
+ [ 'separate' as any ]: true, // We may have multiple files, having multiple redundancies so let's separate this join
required: false,
include: [
{
required: false
}
]
+ },
+ [ ScopeNames.WITH_USER_HISTORY ]: (userId: number) => {
+ return {
+ include: [
+ {
+ attributes: [ 'currentTime' ],
+ model: UserVideoHistoryModel.unscoped(),
+ required: false,
+ where: {
+ userId
+ }
+ }
+ ]
+ }
}
})
@Table({
name: 'videoId',
allowNull: false
},
- onDelete: 'cascade',
- hooks: true
+ onDelete: 'cascade'
})
VideoViews: VideoViewModel[]
+ @HasMany(() => UserVideoHistoryModel, {
+ foreignKey: {
+ name: 'videoId',
+ allowNull: false
+ },
+ onDelete: 'cascade'
+ })
+ UserVideoHistories: UserVideoHistoryModel[]
+
@HasOne(() => ScheduleVideoUpdateModel, {
foreignKey: {
name: 'videoId',
accountId?: number,
videoChannelId?: number,
actorId?: number
- trendingDays?: number
+ trendingDays?: number,
+ userId?: number
}, countVideos = true) {
const query: IFindOptions<VideoModel> = {
offset: options.start,
accountId: options.accountId,
videoChannelId: options.videoChannelId,
includeLocalVideos: options.includeLocalVideos,
+ userId: options.userId,
trendingDays
}
tagsAllOf?: string[]
durationMin?: number // seconds
durationMax?: number // seconds
+ userId?: number
}) {
const whereAnd = []
licenceOneOf: options.licenceOneOf,
languageOneOf: options.languageOneOf,
tagsOneOf: options.tagsOneOf,
- tagsAllOf: options.tagsAllOf
+ tagsAllOf: options.tagsAllOf,
+ userId: options.userId
}
return VideoModel.getAvailableForApi(query, queryOptions)
return VideoModel.scope([ ScopeNames.WITH_ACCOUNT_DETAILS, ScopeNames.WITH_FILES ]).findOne(query)
}
- static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction) {
+ static loadAndPopulateAccountAndServerAndTags (id: number | string, t?: Sequelize.Transaction, userId?: number) {
const where = VideoModel.buildWhereIdOrUUID(id)
const options = {
transaction: t
}
+ const scopes = [
+ ScopeNames.WITH_TAGS,
+ ScopeNames.WITH_BLACKLISTED,
+ ScopeNames.WITH_FILES,
+ ScopeNames.WITH_ACCOUNT_DETAILS,
+ ScopeNames.WITH_SCHEDULED_UPDATE
+ ]
+
+ if (userId) {
+ scopes.push({ method: [ ScopeNames.WITH_USER_HISTORY, userId ] } as any) // FIXME: typings
+ }
+
return VideoModel
- .scope([
- ScopeNames.WITH_TAGS,
- ScopeNames.WITH_BLACKLISTED,
- ScopeNames.WITH_FILES,
- ScopeNames.WITH_ACCOUNT_DETAILS,
- ScopeNames.WITH_SCHEDULED_UPDATE
- ])
+ .scope(scopes)
.findOne(options)
}
return {}
}
- private static async getAvailableForApi (query: IFindOptions<VideoModel>, options: AvailableForListIDsOptions, countVideos = true) {
+ private static async getAvailableForApi (
+ query: IFindOptions<VideoModel>,
+ options: AvailableForListIDsOptions & { userId?: number},
+ countVideos = true
+ ) {
const idsScope = {
method: [
ScopeNames.AVAILABLE_FOR_LIST_IDS, options
if (ids.length === 0) return { data: [], total: count }
- const apiScope = {
- method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
+ // FIXME: typings
+ const apiScope: any[] = [
+ {
+ method: [ ScopeNames.FOR_API, { ids, withFiles: options.withFiles } as ForAPIOptions ]
+ }
+ ]
+
+ if (options.userId) {
+ apiScope.push({ method: [ ScopeNames.WITH_USER_HISTORY, options.userId ] })
}
const secondQuery = {
import './video-comments'
import './video-imports'
import './videos'
+import './videos-history'
--- /dev/null
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+ flushTests,
+ killallServers,
+ makePostBodyRequest,
+ makePutBodyRequest,
+ runServer,
+ ServerInfo,
+ setAccessTokensToServers,
+ uploadVideo
+} from '../../utils'
+
+const expect = chai.expect
+
+describe('Test videos history API validator', function () {
+ let path: string
+ let server: ServerInfo
+
+ // ---------------------------------------------------------------
+
+ before(async function () {
+ this.timeout(30000)
+
+ await flushTests()
+
+ server = await runServer(1)
+
+ await setAccessTokensToServers([ server ])
+
+ const res = await uploadVideo(server.url, server.accessToken, {})
+ const videoUUID = res.body.video.uuid
+
+ path = '/api/v1/videos/' + videoUUID + '/watching'
+ })
+
+ describe('When notifying a user is watching a video', function () {
+
+ it('Should fail with an unauthenticated user', async function () {
+ const fields = { currentTime: 5 }
+ await makePutBodyRequest({ url: server.url, path, fields, statusCodeExpected: 401 })
+ })
+
+ it('Should fail with an incorrect video id', async function () {
+ const fields = { currentTime: 5 }
+ const path = '/api/v1/videos/blabla/watching'
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+ })
+
+ it('Should fail with an unknown video', async function () {
+ const fields = { currentTime: 5 }
+ const path = '/api/v1/videos/d91fff41-c24d-4508-8e13-3bd5902c3b02/watching'
+
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 404 })
+ })
+
+ it('Should fail with a bad current time', async function () {
+ const fields = { currentTime: 'hello' }
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 400 })
+ })
+
+ it('Should succeed with the correct parameters', async function () {
+ const fields = { currentTime: 5 }
+
+ await makePutBodyRequest({ url: server.url, path, fields, token: server.accessToken, statusCodeExpected: 204 })
+ })
+ })
+
+ after(async function () {
+ killallServers([ server ])
+
+ // Keep the logs if the test failed
+ if (this['ok']) {
+ await flushTests()
+ }
+ })
+})
import './video-privacy'
import './video-schedule-update'
import './video-transcoder'
+import './videos-history'
import './videos-overview'
--- /dev/null
+/* tslint:disable:no-unused-expression */
+
+import * as chai from 'chai'
+import 'mocha'
+import {
+ flushTests,
+ getVideosListWithToken,
+ getVideoWithToken,
+ killallServers, makePutBodyRequest,
+ runServer, searchVideoWithToken,
+ ServerInfo,
+ setAccessTokensToServers,
+ uploadVideo
+} from '../../utils'
+import { Video, VideoDetails } from '../../../../shared/models/videos'
+import { userWatchVideo } from '../../utils/videos/video-history'
+
+const expect = chai.expect
+
+describe('Test videos history', function () {
+ let server: ServerInfo = null
+ let video1UUID: string
+ let video2UUID: string
+ let video3UUID: string
+
+ before(async function () {
+ this.timeout(30000)
+
+ await flushTests()
+
+ server = await runServer(1)
+
+ await setAccessTokensToServers([ server ])
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 1' })
+ video1UUID = res.body.video.uuid
+ }
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 2' })
+ video2UUID = res.body.video.uuid
+ }
+
+ {
+ const res = await uploadVideo(server.url, server.accessToken, { name: 'video 3' })
+ video3UUID = res.body.video.uuid
+ }
+ })
+
+ it('Should get videos, without watching history', async function () {
+ const res = await getVideosListWithToken(server.url, server.accessToken)
+ const videos: Video[] = res.body.data
+
+ for (const video of videos) {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video.id)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(video.userHistory).to.be.undefined
+ expect(videoDetails.userHistory).to.be.undefined
+ }
+ })
+
+ it('Should watch the first and second video', async function () {
+ await userWatchVideo(server.url, server.accessToken, video1UUID, 3)
+ await userWatchVideo(server.url, server.accessToken, video2UUID, 8)
+ })
+
+ it('Should return the correct history when listing, searching and getting videos', async function () {
+ const videosOfVideos: Video[][] = []
+
+ {
+ const res = await getVideosListWithToken(server.url, server.accessToken)
+ videosOfVideos.push(res.body.data)
+ }
+
+ {
+ const res = await searchVideoWithToken(server.url, 'video', server.accessToken)
+ videosOfVideos.push(res.body.data)
+ }
+
+ for (const videos of videosOfVideos) {
+ const video1 = videos.find(v => v.uuid === video1UUID)
+ const video2 = videos.find(v => v.uuid === video2UUID)
+ const video3 = videos.find(v => v.uuid === video3UUID)
+
+ expect(video1.userHistory).to.not.be.undefined
+ expect(video1.userHistory.currentTime).to.equal(3)
+
+ expect(video2.userHistory).to.not.be.undefined
+ expect(video2.userHistory.currentTime).to.equal(8)
+
+ expect(video3.userHistory).to.be.undefined
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video1UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.not.be.undefined
+ expect(videoDetails.userHistory.currentTime).to.equal(3)
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video2UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.not.be.undefined
+ expect(videoDetails.userHistory.currentTime).to.equal(8)
+ }
+
+ {
+ const resDetail = await getVideoWithToken(server.url, server.accessToken, video3UUID)
+ const videoDetails: VideoDetails = resDetail.body
+
+ expect(videoDetails.userHistory).to.be.undefined
+ }
+ })
+
+ after(async function () {
+ killallServers([ server ])
+
+ // Keep the logs if the test failed
+ if (this['ok']) {
+ await flushTests()
+ }
+ })
+})
--- /dev/null
+import { makePutBodyRequest } from '../requests/requests'
+
+function userWatchVideo (url: string, token: string, videoId: number | string, currentTime: number) {
+ const path = '/api/v1/videos/' + videoId + '/watching'
+ const fields = { currentTime }
+
+ return makePutBodyRequest({ url, path, token, fields, statusCodeExpected: 204 })
+}
+
+// ---------------------------------------------------------------------------
+
+export {
+ userWatchVideo
+}
export * from './user-right.enum'
export * from './user-role'
export * from './user-video-quota.model'
+export * from './user-watching-video.model'
--- /dev/null
+export interface UserWatchingVideo {
+ currentTime: number
+}
account: AccountAttribute
channel: VideoChannelAttribute
+
+ userHistory?: {
+ currentTime: number
+ }
}
export interface VideoDetails extends Video {
projects / github / Chocobozzz / PeerTube.git / commitdiff
