@redseat/api 0.3.5 → 0.3.6

package/dist/interfaces.d.ts

@@ -483,6 +483,42 @@ export declare enum RsSort {
     Name = "name",
     Size = "size"
 }
+export type MediaType = 'episode' | 'movie' | 'book' | 'song' | 'media';
+export interface IWatched {
+    type: MediaType;
+    id: string;
+    userRef?: string;
+    date: number;
+    modified: number;
+}
+export interface IWatchedForAdd {
+    type: MediaType;
+    id: string;
+    date: number;
+}
+export interface IViewProgress {
+    type: MediaType;
+    id: string;
+    userRef: string;
+    progress: number;
+    parent?: string;
+    modified: number;
+}
+export interface IViewProgressForAdd {
+    type: MediaType;
+    id: string;
+    parent?: string;
+    progress: number;
+}
+export interface HistoryQuery {
+    sort?: RsSort;
+    order?: SqlOrder;
+    before?: number;
+    after?: number;
+    types?: MediaType[];
+    id?: string;
+    pageKey?: number;
+}
 export type MovieSort = 'modified' | 'added' | 'created' | 'name' | 'digitalairdate';
 export interface DeletedQuery {
     after?: number;

package/dist/library.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload } from './interfaces.js';
+import { IFile, ITag, IPerson, ISerie, IMovie, MediaRequest, IEpisode, ExternalImage, IBackupFile, ILibrary, SerieInMedia, DeletedQuery, RsDeleted, MovieSort, RsSort, SqlOrder, RsRequest, DetectedFaceResult, UnassignFaceResponse, RsGroupDownload, IViewProgress, IWatched } from './interfaces.js';
 import { SSEMediasEvent, SSEUploadProgressEvent, SSEConvertProgressEvent, SSEEpisodesEvent, SSESeriesEvent, SSEMoviesEvent, SSEPeopleEvent, SSETagsEvent, SSELibraryStatusEvent, SSEMediaRatingEvent, SSEMediaProgressEvent } from './sse-types.js';
 import { EncryptFileOptions, EncryptedFile } from './encryption.js';
 export interface MediaForUpdate {
@@ -194,6 +194,9 @@ export declare class LibraryApi {
     updateMovie(movieId: string, updates: Partial<IMovie>): Promise<IMovie>;
     getMovieImages(movieId: string): Promise<ExternalImage[]>;
     setMovieWatched(movieId: string, date: number): Promise<void>;
+    getMovieWatched(movieId: string): Promise<IWatched>;
+    getMovieProgress(movieId: string): Promise<IViewProgress>;
+    setMovieProgress(movieId: string, progress: number): Promise<void>;
     searchMovies(name: string): Promise<IMovie[]>;
     movieRename(movieId: string, newName: string): Promise<IMovie>;
     updateMoviePoster(movieId: string, poster: FormData, type: string): Promise<void>;
@@ -214,6 +217,9 @@ export declare class LibraryApi {
     updatePersonPortrait(personId: string, portrait: FormData): Promise<void>;
     searchSeries(name: string): Promise<ISerie[]>;
     setEpisodeWatched(serieId: string, season: number, number: number, date: number): Promise<void>;
+    getEpisodeWatched(serieId: string, season: number, episode: number): Promise<IWatched>;
+    getEpisodeProgress(serieId: string, season: number, episode: number): Promise<IViewProgress>;
+    setEpisodeProgress(serieId: string, season: number, episode: number, progress: number): Promise<void>;
     /**
      * Searches for available media sources for a specific episode.
      * @param serieId - The series identifier

package/dist/library.js

@@ -368,6 +368,17 @@ export class LibraryApi {
     async setMovieWatched(movieId, date) {
         await this.client.post(this.getUrl(`/movies/${movieId}/watched`), { date });
     }
+    async getMovieWatched(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/watched`));
+        return res.data;
+    }
+    async getMovieProgress(movieId) {
+        const res = await this.client.get(this.getUrl(`/movies/${movieId}/progress`));
+        return res.data;
+    }
+    async setMovieProgress(movieId, progress) {
+        await this.client.post(this.getUrl(`/movies/${movieId}/progress`), { progress });
+    }
     async searchMovies(name) {
         const res = await this.client.get(this.getUrl(`/movies/search?name=${name}`));
         return res.data;
@@ -460,6 +471,17 @@ export class LibraryApi {
     async setEpisodeWatched(serieId, season, number, date) {
         await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${number}/watched`), { date });
     }
+    async getEpisodeWatched(serieId, season, episode) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/watched`));
+        return res.data;
+    }
+    async getEpisodeProgress(serieId, season, episode) {
+        const res = await this.client.get(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/progress`));
+        return res.data;
+    }
+    async setEpisodeProgress(serieId, season, episode, progress) {
+        await this.client.post(this.getUrl(`/series/${serieId}/seasons/${season}/episodes/${episode}/progress`), { progress });
+    }
     /**
      * Searches for available media sources for a specific episode.
      * @param serieId - The series identifier

package/dist/server.d.ts

@@ -1,5 +1,5 @@
 import { RedseatClient } from './client.js';
-import { ILibrary, IPlugin, ICredential } from './interfaces.js';
+import { ILibrary, IPlugin, ICredential, IWatched, IWatchedForAdd, IViewProgress, IViewProgressForAdd, HistoryQuery } from './interfaces.js';
 export declare class ServerApi {
     private client;
     constructor(client: RedseatClient);
@@ -19,4 +19,10 @@ export declare class ServerApi {
     deleteCredential(id: string): Promise<void>;
     saveOAuthCredentials(pluginId: string, params: Record<string, string>): Promise<void>;
     addLibraryCredential(credential: any): Promise<ILibrary>;
+    getHistory(query?: HistoryQuery): Promise<IWatched[]>;
+    addToHistory(watched: IWatchedForAdd): Promise<void>;
+    getProgressById(id: string): Promise<IViewProgress | null>;
+    addProgress(progress: IViewProgressForAdd): Promise<void>;
+    getAdminHistory(): Promise<IWatched[]>;
+    importHistory(watcheds: IWatchedForAdd[]): Promise<void>;
 }

package/dist/server.js

@@ -48,4 +48,44 @@ export class ServerApi {
         const res = await this.client.post('/libraries/credential', credential);
         return res.data;
     }
+    // History methods
+    async getHistory(query) {
+        const params = {};
+        if (query) {
+            if (query.sort !== undefined)
+                params.sort = query.sort;
+            if (query.order !== undefined)
+                params.order = query.order;
+            if (query.before !== undefined)
+                params.before = query.before;
+            if (query.after !== undefined)
+                params.after = query.after;
+            if (query.types !== undefined && query.types.length > 0)
+                params.types = query.types;
+            if (query.id !== undefined)
+                params.id = query.id;
+            if (query.pageKey !== undefined)
+                params.pageKey = query.pageKey;
+        }
+        const res = await this.client.get('/users/me/history', { params });
+        return res.data;
+    }
+    async addToHistory(watched) {
+        await this.client.post('/users/me/history', watched);
+    }
+    async getProgressById(id) {
+        const res = await this.client.get(`/users/me/history/progress/${id}`);
+        return res.data;
+    }
+    async addProgress(progress) {
+        await this.client.post('/users/me/history/progress', progress);
+    }
+    // Admin history methods
+    async getAdminHistory() {
+        const res = await this.client.get('/users/admin/history');
+        return res.data;
+    }
+    async importHistory(watcheds) {
+        await this.client.post('/users/admin/history/import', watcheds);
+    }
 }

package/libraries.md

@@ -912,6 +912,62 @@ Marks an episode as watched.
 await libraryApi.setEpisodeWatched('serie-id', 1, 1, Date.now());
 ```
 
+### `getEpisodeWatched(serieId: string, season: number, episode: number): Promise<IWatched>`
+
+Gets the watched status for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+
+**Returns:** Promise resolving to an `IWatched` object containing watched date and metadata
+
+**Example:**
+
+```typescript
+const watched = await libraryApi.getEpisodeWatched('serie-id', 1, 1);
+console.log(`Watched on: ${new Date(watched.date).toLocaleDateString()}`);
+```
+
+### `getEpisodeProgress(serieId: string, season: number, episode: number): Promise<IViewProgress>`
+
+Gets the view progress for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+
+**Returns:** Promise resolving to an `IViewProgress` object containing progress value
+
+**Example:**
+
+```typescript
+const progress = await libraryApi.getEpisodeProgress('serie-id', 1, 1);
+console.log(`Progress: ${progress.progress}ms`);
+```
+
+### `setEpisodeProgress(serieId: string, season: number, episode: number, progress: number): Promise<void>`
+
+Sets the view progress for an episode.
+
+**Parameters:**
+
+- `serieId`: The ID of the series
+- `season`: Season number
+- `episode`: Episode number
+- `progress`: Progress value (typically in milliseconds for video playback position)
+
+**Example:**
+
+```typescript
+// Save progress at 30 minutes
+await libraryApi.setEpisodeProgress('serie-id', 1, 1, 1800000);
+```
+
 ---
 
 ## Movies
@@ -1034,6 +1090,56 @@ Marks a movie as watched.
 await libraryApi.setMovieWatched('movie-id', Date.now());
 ```
 
+### `getMovieWatched(movieId: string): Promise<IWatched>`
+
+Gets the watched status for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+
+**Returns:** Promise resolving to an `IWatched` object containing watched date and metadata
+
+**Example:**
+
+```typescript
+const watched = await libraryApi.getMovieWatched('movie-id');
+console.log(`Watched on: ${new Date(watched.date).toLocaleDateString()}`);
+```
+
+### `getMovieProgress(movieId: string): Promise<IViewProgress>`
+
+Gets the view progress for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+
+**Returns:** Promise resolving to an `IViewProgress` object containing progress value
+
+**Example:**
+
+```typescript
+const progress = await libraryApi.getMovieProgress('movie-id');
+console.log(`Progress: ${progress.progress}ms`);
+```
+
+### `setMovieProgress(movieId: string, progress: number): Promise<void>`
+
+Sets the view progress for a movie.
+
+**Parameters:**
+
+- `movieId`: The ID of the movie
+- `progress`: Progress value (typically in milliseconds for video playback position)
+
+**Example:**
+
+```typescript
+// Save progress at 45 minutes
+await libraryApi.setMovieProgress('movie-id', 2700000);
+```
+
 ### `searchMovies(name: string): Promise<IMovie[]>`
 
 Searches for movies by name.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@redseat/api",
-    "version": "0.3.5",
+    "version": "0.3.6",
     "description": "TypeScript API client library for interacting with Redseat servers",
     "type": "module",
     "main": "./dist/index.js",

package/server.md

@@ -222,6 +222,127 @@ const library = await serverApi.addLibraryCredential({
 });
 ```
 
+## History Methods
+
+These methods manage the user's watch history and progress tracking across all libraries.
+
+### `getHistory(query?: HistoryQuery): Promise<IWatched[]>`
+
+Retrieves the current user's watch history.
+
+**Parameters:**
+- `query`: Optional query object with filtering parameters:
+  - `sort`: Sort key using `RsSort` enum
+  - `order`: Sort direction using `SqlOrder` enum (`ASC` or `DESC`)
+  - `before`: Filter entries before this timestamp
+  - `after`: Filter entries after this timestamp
+  - `types`: Array of `MediaType` to filter by (`'episode'`, `'movie'`, `'book'`, `'song'`, `'media'`)
+  - `id`: Filter by specific ID
+  - `pageKey`: Pagination key
+
+**Returns:** Promise resolving to an array of `IWatched` objects
+
+**Example:**
+```typescript
+// Get all history
+const history = await serverApi.getHistory();
+
+// Get recent movie watch history
+const movieHistory = await serverApi.getHistory({
+    types: ['movie'],
+    order: SqlOrder.DESC,
+    after: Date.now() - 86400000 * 30 // Last 30 days
+});
+```
+
+### `addToHistory(watched: IWatchedForAdd): Promise<void>`
+
+Adds an entry to the user's watch history.
+
+**Parameters:**
+- `watched`: Object containing:
+  - `type`: The `MediaType` (`'episode'`, `'movie'`, `'book'`, `'song'`, `'media'`)
+  - `id`: The ID of the watched item
+  - `date`: Timestamp when it was watched
+
+**Returns:** Promise resolving when the entry is added
+
+**Example:**
+```typescript
+await serverApi.addToHistory({
+    type: 'movie',
+    id: 'movie-123',
+    date: Date.now()
+});
+```
+
+### `getProgressById(id: string): Promise<IViewProgress | null>`
+
+Gets the view progress for a specific item by ID.
+
+**Parameters:**
+- `id`: The ID of the item to get progress for
+
+**Returns:** Promise resolving to `IViewProgress` object or `null` if not found
+
+**Example:**
+```typescript
+const progress = await serverApi.getProgressById('movie-123');
+if (progress) {
+    console.log(`Progress: ${progress.progress}ms`);
+}
+```
+
+### `addProgress(progress: IViewProgressForAdd): Promise<void>`
+
+Adds or updates view progress for an item.
+
+**Parameters:**
+- `progress`: Object containing:
+  - `type`: The `MediaType`
+  - `id`: The ID of the item
+  - `progress`: Progress value (typically in milliseconds for video)
+  - `parent`: Optional parent ID (e.g., series ID for episodes)
+
+**Returns:** Promise resolving when progress is saved
+
+**Example:**
+```typescript
+await serverApi.addProgress({
+    type: 'movie',
+    id: 'movie-123',
+    progress: 3600000 // 1 hour in milliseconds
+});
+```
+
+### `getAdminHistory(): Promise<IWatched[]>`
+
+**Admin only.** Retrieves watch history for all users.
+
+**Returns:** Promise resolving to an array of `IWatched` objects
+
+**Example:**
+```typescript
+const allHistory = await serverApi.getAdminHistory();
+```
+
+### `importHistory(watcheds: IWatchedForAdd[]): Promise<void>`
+
+**Admin only.** Imports watch history entries in bulk.
+
+**Parameters:**
+- `watcheds`: Array of `IWatchedForAdd` objects to import
+
+**Returns:** Promise resolving when import is complete
+
+**Example:**
+```typescript
+await serverApi.importHistory([
+    { type: 'movie', id: 'movie-1', date: Date.now() - 86400000 },
+    { type: 'episode', id: 'episode-1', date: Date.now() }
+]);
+```
+
 ## Usage Examples
 
 ### Complete Workflow: Create Library and Get Info