-import * as Bluebird from 'bluebird'
import { values } from 'lodash'
import { col, FindOptions, fn, literal, Op, QueryTypes, where, WhereOptions } from 'sequelize'
import {
HasOne,
Is,
IsEmail,
+ IsUUID,
Model,
Scopes,
Table,
MUser,
MUserDefault,
MUserFormattable,
- MUserId,
MUserNotifSettingChannelDefault,
MUserWithNotificationSetting,
- MVideoFullLight
+ MVideoWithRights
} from '@server/types/models'
import { hasUserRight, USER_ROLE_LABELS } from '../../../shared/core-utils/users'
import { AbuseState, MyUser, UserRight, VideoPlaylistType, VideoPrivacy } from '../../../shared/models'
import { VideoModel } from '../video/video'
import { VideoChannelModel } from '../video/video-channel'
import { VideoImportModel } from '../video/video-import'
+import { VideoLiveModel } from '../video/video-live'
import { VideoPlaylistModel } from '../video/video-playlist'
import { AccountModel } from './account'
import { UserNotificationSettingModel } from './user-notification-setting'
-import { VideoLiveModel } from '../video/video-live'
enum ScopeNames {
FOR_ME_API = 'FOR_ME_API',
}
]
})
-export class UserModel extends Model<UserModel> {
+export class UserModel extends Model {
@AllowNull(true)
@Is('UserPassword', value => throwIfNotValid(value, isUserPasswordValid, 'user password', true))
@Column
pluginAuth: string
+ @AllowNull(false)
+ @Default(DataType.UUIDV4)
+ @IsUUID(4)
+ @Column(DataType.UUID)
+ feedToken: string
+
@AllowNull(true)
@Default(null)
@Column
})
}
- static listWithRight (right: UserRight): Bluebird<MUserDefault[]> {
+ static listWithRight (right: UserRight): Promise<MUserDefault[]> {
const roles = Object.keys(USER_ROLE_LABELS)
.map(k => parseInt(k, 10) as UserRole)
.filter(role => hasUserRight(role, right))
return UserModel.findAll(query)
}
- static listUserSubscribersOf (actorId: number): Bluebird<MUserWithNotificationSetting[]> {
+ static listUserSubscribersOf (actorId: number): Promise<MUserWithNotificationSetting[]> {
const query = {
include: [
{
return UserModel.unscoped().findAll(query)
}
- static listByUsernames (usernames: string[]): Bluebird<MUserDefault[]> {
+ static listByUsernames (usernames: string[]): Promise<MUserDefault[]> {
const query = {
where: {
username: usernames
return UserModel.findAll(query)
}
- static loadById (id: number): Bluebird<MUser> {
+ static loadById (id: number): Promise<MUser> {
return UserModel.unscoped().findByPk(id)
}
- static loadByIdWithChannels (id: number, withStats = false): Bluebird<MUserDefault> {
+ static loadByIdWithChannels (id: number, withStats = false): Promise<MUserDefault> {
const scopes = [
ScopeNames.WITH_VIDEOCHANNELS
]
return UserModel.scope(scopes).findByPk(id)
}
- static loadByUsername (username: string): Bluebird<MUserDefault> {
+ static loadByUsername (username: string): Promise<MUserDefault> {
const query = {
where: {
- username: { [Op.iLike]: username }
+ username
}
}
return UserModel.findOne(query)
}
- static loadForMeAPI (username: string): Bluebird<MUserNotifSettingChannelDefault> {
+ static loadForMeAPI (id: number): Promise<MUserNotifSettingChannelDefault> {
const query = {
where: {
- username: { [Op.iLike]: username }
+ id
}
}
return UserModel.scope(ScopeNames.FOR_ME_API).findOne(query)
}
- static loadByEmail (email: string): Bluebird<MUserDefault> {
+ static loadByEmail (email: string): Promise<MUserDefault> {
const query = {
where: {
email
return UserModel.findOne(query)
}
- static loadByUsernameOrEmail (username: string, email?: string): Bluebird<MUserDefault> {
+ static loadByUsernameOrEmail (username: string, email?: string): Promise<MUserDefault> {
if (!email) email = username
const query = {
return UserModel.findOne(query)
}
- static loadByVideoId (videoId: number): Bluebird<MUserDefault> {
+ static loadByVideoId (videoId: number): Promise<MUserDefault> {
const query = {
include: [
{
return UserModel.findOne(query)
}
- static loadByVideoImportId (videoImportId: number): Bluebird<MUserDefault> {
+ static loadByVideoImportId (videoImportId: number): Promise<MUserDefault> {
const query = {
include: [
{
return UserModel.findOne(query)
}
- static loadByChannelActorId (videoChannelActorId: number): Bluebird<MUserDefault> {
+ static loadByChannelActorId (videoChannelActorId: number): Promise<MUserDefault> {
const query = {
include: [
{
return UserModel.findOne(query)
}
- static loadByAccountActorId (accountActorId: number): Bluebird<MUserDefault> {
+ static loadByAccountActorId (accountActorId: number): Promise<MUserDefault> {
const query = {
include: [
{
return UserModel.findOne(query)
}
- static loadByLiveId (liveId: number): Bluebird<MUser> {
+ static loadByLiveId (liveId: number): Promise<MUser> {
const query = {
include: [
{
required: true,
include: [
{
- attributes: [ 'id', 'videoId' ],
+ attributes: [],
model: VideoLiveModel.unscoped(),
required: true,
where: {
]
}
- return UserModel.findOne(query)
+ return UserModel.unscoped().findOne(query)
}
static generateUserQuotaBaseSQL (options: {
const totalDailyActiveUsers = await getActiveUsers(1)
const totalWeeklyActiveUsers = await getActiveUsers(7)
const totalMonthlyActiveUsers = await getActiveUsers(30)
+ const totalHalfYearActiveUsers = await getActiveUsers(180)
return {
totalUsers,
totalDailyActiveUsers,
totalWeeklyActiveUsers,
- totalMonthlyActiveUsers
+ totalMonthlyActiveUsers,
+ totalHalfYearActiveUsers
}
}
.then(u => u.map(u => u.username))
}
- canGetVideo (video: MVideoFullLight) {
+ canGetVideo (video: MVideoWithRights) {
const videoUserId = video.VideoChannel.Account.userId
if (video.isBlacklisted()) {