-import * as Sequelize from 'sequelize'
-
-import { addMethodsToModel, getSort } from '../utils'
-import {
- BlacklistedVideoInstance,
- BlacklistedVideoAttributes,
-
- BlacklistedVideoMethods
-} from './video-blacklist-interface'
-
-let BlacklistedVideo: Sequelize.Model<BlacklistedVideoInstance, BlacklistedVideoAttributes>
-let toFormatedJSON: BlacklistedVideoMethods.ToFormatedJSON
-let countTotal: BlacklistedVideoMethods.CountTotal
-let list: BlacklistedVideoMethods.List
-let listForApi: BlacklistedVideoMethods.ListForApi
-let loadById: BlacklistedVideoMethods.LoadById
-let loadByVideoId: BlacklistedVideoMethods.LoadByVideoId
-
-export default function (sequelize: Sequelize.Sequelize, DataTypes: Sequelize.DataTypes) {
- BlacklistedVideo = sequelize.define<BlacklistedVideoInstance, BlacklistedVideoAttributes>('BlacklistedVideo',
- {},
+import { FindOptions } from 'sequelize'
+import { AllowNull, BelongsTo, Column, CreatedAt, DataType, Default, ForeignKey, Is, Model, Table, UpdatedAt } from 'sequelize-typescript'
+import { MVideoBlacklist, MVideoBlacklistFormattable } from '@server/types/models'
+import { VideoBlacklist, VideoBlacklistType } from '../../../shared/models/videos'
+import { isVideoBlacklistReasonValid, isVideoBlacklistTypeValid } from '../../helpers/custom-validators/video-blacklist'
+import { CONSTRAINTS_FIELDS } from '../../initializers/constants'
+import { getBlacklistSort, searchAttribute, SortType, throwIfNotValid } from '../utils'
+import { ThumbnailModel } from './thumbnail'
+import { VideoModel } from './video'
+import { ScopeNames as VideoChannelScopeNames, SummaryOptions, VideoChannelModel } from './video-channel'
+
+@Table({
+ tableName: 'videoBlacklist',
+ indexes: [
{
- indexes: [
- {
- fields: [ 'videoId' ],
- unique: true
- }
- ]
+ fields: [ 'videoId' ],
+ unique: true
}
- )
-
- const classMethods = [
- associate,
-
- countTotal,
- list,
- listForApi,
- loadById,
- loadByVideoId
- ]
- const instanceMethods = [
- toFormatedJSON
]
- addMethodsToModel(BlacklistedVideo, classMethods, instanceMethods)
-
- return BlacklistedVideo
-}
-
-// ------------------------------ METHODS ------------------------------
-
-toFormatedJSON = function (this: BlacklistedVideoInstance) {
- return {
- id: this.id,
- videoId: this.videoId,
- createdAt: this.createdAt
- }
-}
-
-// ------------------------------ STATICS ------------------------------
-
-function associate (models) {
- BlacklistedVideo.belongsTo(models.Video, {
- foreignKey: 'videoId',
+})
+export class VideoBlacklistModel extends Model {
+
+ @AllowNull(true)
+ @Is('VideoBlacklistReason', value => throwIfNotValid(value, isVideoBlacklistReasonValid, 'reason', true))
+ @Column(DataType.STRING(CONSTRAINTS_FIELDS.VIDEO_BLACKLIST.REASON.max))
+ reason: string
+
+ @AllowNull(false)
+ @Column
+ unfederated: boolean
+
+ @AllowNull(false)
+ @Default(null)
+ @Is('VideoBlacklistType', value => throwIfNotValid(value, isVideoBlacklistTypeValid, 'type'))
+ @Column
+ type: VideoBlacklistType
+
+ @CreatedAt
+ createdAt: Date
+
+ @UpdatedAt
+ updatedAt: Date
+
+ @ForeignKey(() => VideoModel)
+ @Column
+ videoId: number
+
+ @BelongsTo(() => VideoModel, {
+ foreignKey: {
+ allowNull: false
+ },
onDelete: 'cascade'
})
-}
-
-countTotal = function () {
- return BlacklistedVideo.count()
-}
+ Video: VideoModel
+
+ static listForApi (parameters: {
+ start: number
+ count: number
+ sort: SortType
+ search?: string
+ type?: VideoBlacklistType
+ }) {
+ const { start, count, sort, search, type } = parameters
+
+ function buildBaseQuery (): FindOptions {
+ return {
+ offset: start,
+ limit: count,
+ order: getBlacklistSort(sort.sortModel, sort.sortValue)
+ }
+ }
-list = function () {
- return BlacklistedVideo.findAll()
-}
+ const countQuery = buildBaseQuery()
+
+ const findQuery = buildBaseQuery()
+ findQuery.include = [
+ {
+ model: VideoModel,
+ required: true,
+ where: searchAttribute(search, 'name'),
+ include: [
+ {
+ model: VideoChannelModel.scope({ method: [ VideoChannelScopeNames.SUMMARY, { withAccount: true } as SummaryOptions ] }),
+ required: true
+ },
+ {
+ model: ThumbnailModel,
+ attributes: [ 'type', 'filename' ],
+ required: false
+ }
+ ]
+ }
+ ]
+
+ if (type) {
+ countQuery.where = { type }
+ findQuery.where = { type }
+ }
-listForApi = function (start: number, count: number, sort: string) {
- const query = {
- offset: start,
- limit: count,
- order: [ getSort(sort) ]
+ return Promise.all([
+ VideoBlacklistModel.count(countQuery),
+ VideoBlacklistModel.findAll(findQuery)
+ ]).then(([ count, rows ]) => {
+ return {
+ data: rows,
+ total: count
+ }
+ })
}
- return BlacklistedVideo.findAndCountAll(query).then(({ rows, count }) => {
- return {
- data: rows,
- total: count
+ static loadByVideoId (id: number): Promise<MVideoBlacklist> {
+ const query = {
+ where: {
+ videoId: id
+ }
}
- })
-}
-loadById = function (id: number) {
- return BlacklistedVideo.findById(id)
-}
+ return VideoBlacklistModel.findOne(query)
+ }
-loadByVideoId = function (id: string) {
- const query = {
- where: {
- videoId: id
+ toFormattedJSON (this: MVideoBlacklistFormattable): VideoBlacklist {
+ return {
+ id: this.id,
+ createdAt: this.createdAt,
+ updatedAt: this.updatedAt,
+ reason: this.reason,
+ unfederated: this.unfederated,
+ type: this.type,
+
+ video: this.Video.toFormattedJSON()
}
}
-
- return BlacklistedVideo.findOne(query)
}