feat(requests): add request quotas (#1277)

* feat(quotas): rebased

* feat: add getQuota() method to User entity

* feat(ui): add default quota setting options

* feat: user quota settings

* feat: quota display in request modals

* fix: only show user quotas on own profile or with manage users permission

* feat: add request progress circles to profile page

* feat: add migration

* fix: add missing restricted field to api schema

* fix: dont show auto approve message for movie request when restricted

* fix(lang): change enable checkbox langauge to "enable override"

Co-authored-by: Jakob Ankarhem <jakob.ankarhem@outlook.com>
Co-authored-by: TheCatLady <52870424+TheCatLady@users.noreply.github.com>

overseerr-api.yml

@@ -3033,6 +3033,63 @@ paths:
                     type: array
                     items:
                       $ref: '#/components/schemas/MediaRequest'
+  /user/{userId}/quota:
+    get:
+      summary: Get quotas for a specific user
+      description: |
+        Returns quota details for a user in a JSON object. Requires `MANAGE_USERS` permission if viewing other users.
+      tags:
+        - users
+      parameters:
+        - in: path
+          name: userId
+          required: true
+          schema:
+            type: number
+      responses:
+        '200':
+          description: User quota details in JSON
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  movie:
+                    type: object
+                    properties:
+                      days:
+                        type: number
+                        example: 7
+                      limit:
+                        type: number
+                        example: 10
+                      used:
+                        type: number
+                        example: 6
+                      remaining:
+                        type: number
+                        example: 4
+                      restricted:
+                        type: boolean
+                        example: false
+                  tv:
+                    type: object
+                    properties:
+                      days:
+                        type: number
+                        example: 7
+                      limit:
+                        type: number
+                        example: 10
+                      used:
+                        type: number
+                        example: 6
+                      remaining:
+                        type: number
+                        example: 4
+                      restricted:
+                        type: boolean
+                        example: false
   /user/{userId}/settings/main:
     get:
       summary: Get general settings for a user

server/entity/MediaRequest.ts

@@ -10,6 +10,7 @@ import {
   getRepository,
   OneToMany,
   AfterRemove,
+  RelationCount,
 } from 'typeorm';
 import { User } from './User';
 import Media from './Media';
@@ -60,6 +61,9 @@ export class MediaRequest {
   @Column({ type: 'varchar' })
   public type: MediaType;
 
+  @RelationCount((request: MediaRequest) => request.seasons)
+  public seasonCount: number;
+
   @OneToMany(() => SeasonRequest, (season) => season.request, {
     eager: true,
     cascade: true,

server/entity/User.ts

@@ -1,28 +1,34 @@
+import bcrypt from 'bcrypt';
+import path from 'path';
+import { default as generatePassword } from 'secure-random-password';
 import {
-  Entity,
-  PrimaryGeneratedColumn,
+  AfterLoad,
   Column,
   CreateDateColumn,
-  UpdateDateColumn,
+  Entity,
+  getRepository,
+  MoreThan,
+  Not,
   OneToMany,
-  RelationCount,
-  AfterLoad,
   OneToOne,
+  PrimaryGeneratedColumn,
+  RelationCount,
+  UpdateDateColumn,
 } from 'typeorm';
+import { v4 as uuid } from 'uuid';
+import { MediaRequestStatus, MediaType } from '../constants/media';
+import { UserType } from '../constants/user';
+import { QuotaResponse } from '../interfaces/api/userInterfaces';
+import PreparedEmail from '../lib/email';
 import {
-  Permission,
   hasPermission,
+  Permission,
   PermissionCheckOptions,
 } from '../lib/permissions';
-import { MediaRequest } from './MediaRequest';
-import bcrypt from 'bcrypt';
-import path from 'path';
-import PreparedEmail from '../lib/email';
-import logger from '../logger';
 import { getSettings } from '../lib/settings';
-import { default as generatePassword } from 'secure-random-password';
-import { UserType } from '../constants/user';
-import { v4 as uuid } from 'uuid';
+import logger from '../logger';
+import { MediaRequest } from './MediaRequest';
+import SeasonRequest from './SeasonRequest';
 import { UserSettings } from './UserSettings';
 
 @Entity()
@@ -80,6 +86,18 @@ export class User {
   @OneToMany(() => MediaRequest, (request) => request.requestedBy)
   public requests: MediaRequest[];
 
+  @Column({ nullable: true })
+  public movieQuotaLimit?: number;
+
+  @Column({ nullable: true })
+  public movieQuotaDays?: number;
+
+  @Column({ nullable: true })
+  public tvQuotaLimit?: number;
+
+  @Column({ nullable: true })
+  public tvQuotaDays?: number;
+
   @OneToOne(() => UserSettings, (settings) => settings.user, {
     cascade: true,
     eager: true,
@@ -199,4 +217,105 @@ export class User {
   public setDisplayName(): void {
     this.displayName = this.username || this.plexUsername;
   }
+
+  public async getQuota(): Promise<QuotaResponse> {
+    const {
+      main: { defaultQuotas },
+    } = getSettings();
+    const requestRepository = getRepository(MediaRequest);
+    const canBypass = this.hasPermission([Permission.MANAGE_USERS], {
+      type: 'or',
+    });
+
+    const movieQuotaLimit = !canBypass
+      ? this.movieQuotaLimit ?? defaultQuotas.movie.quotaLimit
+      : 0;
+    const movieQuotaDays = this.movieQuotaDays ?? defaultQuotas.movie.quotaDays;
+
+    // Count movie requests made during quota period
+    const movieDate = new Date();
+    if (movieQuotaDays) {
+      movieDate.setDate(movieDate.getDate() - movieQuotaDays);
+    } else {
+      movieDate.setDate(0);
+    }
+    // YYYY-MM-DD format
+    const movieQuotaStartDate = movieDate.toJSON().split('T')[0];
+    const movieQuotaUsed = movieQuotaLimit
+      ? await requestRepository.count({
+          where: {
+            requestedBy: this,
+            createdAt: MoreThan(movieQuotaStartDate),
+            type: MediaType.MOVIE,
+            status: Not(MediaRequestStatus.DECLINED),
+          },
+        })
+      : 0;
+
+    const tvQuotaLimit = !canBypass
+      ? this.tvQuotaLimit ?? defaultQuotas.tv.quotaLimit
+      : 0;
+    const tvQuotaDays = this.tvQuotaDays ?? defaultQuotas.tv.quotaDays;
+
+    // Count tv season requests made during quota period
+    const tvDate = new Date();
+    if (tvQuotaDays) {
+      tvDate.setDate(tvDate.getDate() - tvQuotaDays);
+    } else {
+      tvDate.setDate(0);
+    }
+    // YYYY-MM-DD format
+    const tvQuotaStartDate = tvDate.toJSON().split('T')[0];
+    const tvQuotaUsed = tvQuotaLimit
+      ? (
+          await requestRepository
+            .createQueryBuilder('request')
+            .leftJoin('request.seasons', 'seasons')
+            .leftJoin('request.requestedBy', 'requestedBy')
+            .where('request.type = :requestType', {
+              requestType: MediaType.TV,
+            })
+            .andWhere('requestedBy.id = :userId', {
+              userId: this.id,
+            })
+            .andWhere('request.createdAt > :date', {
+              date: tvQuotaStartDate,
+            })
+            .andWhere('request.status != :declinedStatus', {
+              declinedStatus: MediaRequestStatus.DECLINED,
+            })
+            .addSelect((subQuery) => {
+              return subQuery
+                .select('COUNT(season.id)', 'seasonCount')
+                .from(SeasonRequest, 'season')
+                .leftJoin('season.request', 'parentRequest')
+                .where('parentRequest.id = request.id');
+            }, 'seasonCount')
+            .getMany()
+        ).reduce((sum: number, req: MediaRequest) => sum + req.seasonCount, 0)
+      : 0;
+
+    return {
+      movie: {
+        days: movieQuotaDays,
+        limit: movieQuotaLimit,
+        used: movieQuotaUsed,
+        remaining: movieQuotaLimit
+          ? movieQuotaLimit - movieQuotaUsed
+          : undefined,
+        restricted:
+          movieQuotaLimit && movieQuotaLimit - movieQuotaUsed <= 0
+            ? true
+            : false,
+      },
+      tv: {
+        days: tvQuotaDays,
+        limit: tvQuotaLimit,
+        used: tvQuotaUsed,
+        remaining: tvQuotaLimit ? tvQuotaLimit - tvQuotaUsed : undefined,
+        restricted:
+          tvQuotaLimit && tvQuotaLimit - tvQuotaUsed <= 0 ? true : false,
+      },
+    };
+  }
 }

server/interfaces/api/userInterfaces.ts

@@ -1,5 +1,5 @@
-import type { User } from '../../entity/User';
 import { MediaRequest } from '../../entity/MediaRequest';
+import type { User } from '../../entity/User';
 import { PaginatedResponse } from './common';
 
 export interface UserResultsResponse extends PaginatedResponse {
@@ -9,3 +9,16 @@ export interface UserResultsResponse extends PaginatedResponse {
 export interface UserRequestsResponse extends PaginatedResponse {
   results: MediaRequest[];
 }
+
+export interface QuotaStatus {
+  days?: number;
+  limit?: number;
+  used: number;
+  remaining?: number;
+  restricted: boolean;
+}
+
+export interface QuotaResponse {
+  movie: QuotaStatus;
+  tv: QuotaStatus;
+}

server/interfaces/api/userSettingsInterfaces.ts

@@ -2,6 +2,14 @@ export interface UserSettingsGeneralResponse {
   username?: string;
   region?: string;
   originalLanguage?: string;
+  movieQuotaLimit?: number;
+  movieQuotaDays?: number;
+  tvQuotaLimit?: number;
+  tvQuotaDays?: number;
+  globalMovieQuotaDays?: number;
+  globalMovieQuotaLimit?: number;
+  globalTvQuotaLimit?: number;
+  globalTvQuotaDays?: number;
 }
 
 export interface UserSettingsNotificationsResponse {

server/lib/settings.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
-import path from 'path';
 import { merge } from 'lodash';
+import path from 'path';
 import { v4 as uuidv4 } from 'uuid';
 import { Permission } from './permissions';
 
@@ -61,13 +61,22 @@ export interface SonarrSettings extends DVRSettings {
   enableSeasonFolders: boolean;
 }
 
+interface Quota {
+  quotaLimit?: number;
+  quotaDays?: number;
+}
+
 export interface MainSettings {
   apiKey: string;
   applicationTitle: string;
   applicationUrl: string;
   csrfProtection: boolean;
   cacheImages: boolean;
   defaultPermissions: number;
+  defaultQuotas: {
+    movie: Quota;
+    tv: Quota;
+  };
   hideAvailable: boolean;
   localLogin: boolean;
   region: string;
@@ -199,6 +208,10 @@ class Settings {
         csrfProtection: false,
         cacheImages: false,
         defaultPermissions: Permission.REQUEST,
+        defaultQuotas: {
+          movie: {},
+          tv: {},
+        },
         hideAvailable: false,
         localLogin: true,
         region: '',

server/migration/1616576677254-AddUserQuotaFields.ts

@@ -0,0 +1,27 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddUserQuotaFields1616576677254 implements MigrationInterface {
+  name = 'AddUserQuotaFields1616576677254';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "temporary_user" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "email" varchar NOT NULL, "username" varchar, "plexId" integer, "plexToken" varchar, "permissions" integer NOT NULL DEFAULT (0), "avatar" varchar NOT NULL, "createdAt" datetime NOT NULL DEFAULT (datetime('now')), "updatedAt" datetime NOT NULL DEFAULT (datetime('now')), "password" varchar, "userType" integer NOT NULL DEFAULT (1), "plexUsername" varchar, "resetPasswordGuid" varchar, "recoveryLinkExpirationDate" date, "movieQuotaLimit" integer, "movieQuotaDays" integer, "tvQuotaLimit" integer, "tvQuotaDays" integer, CONSTRAINT "UQ_e12875dfb3b1d92d7d7c5377e22" UNIQUE ("email"))`
+    );
+    await queryRunner.query(
+      `INSERT INTO "temporary_user"("id", "email", "username", "plexId", "plexToken", "permissions", "avatar", "createdAt", "updatedAt", "password", "userType", "plexUsername", "resetPasswordGuid", "recoveryLinkExpirationDate") SELECT "id", "email", "username", "plexId", "plexToken", "permissions", "avatar", "createdAt", "updatedAt", "password", "userType", "plexUsername", "resetPasswordGuid", "recoveryLinkExpirationDate" FROM "user"`
+    );
+    await queryRunner.query(`DROP TABLE "user"`);
+    await queryRunner.query(`ALTER TABLE "temporary_user" RENAME TO "user"`);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "user" RENAME TO "temporary_user"`);
+    await queryRunner.query(
+      `CREATE TABLE "user" ("id" integer PRIMARY KEY AUTOINCREMENT NOT NULL, "email" varchar NOT NULL, "username" varchar, "plexId" integer, "plexToken" varchar, "permissions" integer NOT NULL DEFAULT (0), "avatar" varchar NOT NULL, "createdAt" datetime NOT NULL DEFAULT (datetime('now')), "updatedAt" datetime NOT NULL DEFAULT (datetime('now')), "password" varchar, "userType" integer NOT NULL DEFAULT (1), "plexUsername" varchar, "resetPasswordGuid" varchar, "recoveryLinkExpirationDate" date, CONSTRAINT "UQ_e12875dfb3b1d92d7d7c5377e22" UNIQUE ("email"))`
+    );
+    await queryRunner.query(
+      `INSERT INTO "user"("id", "email", "username", "plexId", "plexToken", "permissions", "avatar", "createdAt", "updatedAt", "password", "userType", "plexUsername", "resetPasswordGuid", "recoveryLinkExpirationDate") SELECT "id", "email", "username", "plexId", "plexToken", "permissions", "avatar", "createdAt", "updatedAt", "password", "userType", "plexUsername", "resetPasswordGuid", "recoveryLinkExpirationDate" FROM "temporary_user"`
+    );
+    await queryRunner.query(`DROP TABLE "temporary_user"`);
+  }
+}