@saooti/octopus-sdk 41.7.2 → 41.8.0

package/.claude/settings.local.json

@@ -8,7 +8,8 @@
       "Bash(npm audit:*)",
       "Bash(python3:*)",
       "Bash(node --version:*)",
-      "Bash(npm:*)"
+      "Bash(npm:*)",
+      "Bash(npx vitest:*)"
     ]
   }
 }

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # CHANGELOG
 
+## 41.8.0 (18/03/2026)
+
+**Features**
+
+- **14083** - Ajout des fonctionnalités de saisons et types d'épisodes
+  - Ajout des propriétés relatives aux saisons sur les émissions et les épisodes
+  - `PodcastFilterList` permet de regrouper les épisodes en saisons
+  - `EmissionPage` affiche ses épisodes en saisons si définies
+  - `PodcastModuleBox` affiche le numéro de saison et d'épisode du podcast si
+    définis et que le `seasonMode` permet leur affichage
+- Ajout d'une classe `required` pour afficher une asterisque sur les champs
+  requis
+
+**Fix**
+
+- **14291** - Activation du bouton de génération de la transcription suite à
+  correction des droits
+
+## 41.7.3 (11/03/2026)
+
+**Features**
+
+- Intégration du composable de vérification des droits
+
+**Fix**
+
+- Correction affichage épisodes à valider pour `PODCAST_VALIDATION`.
+
 ## 41.7.2 (10/03/2026)
 
 **Fix**

package/index.ts

@@ -118,6 +118,7 @@ export const getClassicTagInput = () => import("./src/components/form/ClassicTag
 export const getClassicWysiwyg = () => import("./src/components/form/ClassicWysiwyg.vue");
 
 //Composable
+import { useRights, EditRight } from "./src/components/composable/useRights.ts";
 import {useResizePhone} from "./src/components/composable/useResizePhone";
 import {useTagOf} from "./src/components/composable/useTagOf.ts";
 import {useSelenium} from "./src/components/composable/useSelenium.ts";
@@ -133,6 +134,7 @@ export { useSharePlatforms, SharePlatformName, type SharePlatform } from "./src/
 export { useSharePath } from "./src/components/composable/share/useSharePath.ts";
 export { useOrgaComputed } from "./src/components/composable/useOrgaComputed.ts";
 export { useSeoTitleUrl } from "./src/components/composable/route/useSeoTitleUrl.ts";
+export { useSeasonsManagement } from "./src/components/composable/useSeasonsManagement.ts";
 
 //helper
 import domHelper from "./src/helper/domHelper.ts";
@@ -165,8 +167,8 @@ export { playlistApi } from "./src/api/playlistApi.ts";
 export { podcastApi, PodcastSort, type PodcastSearchOptions } from "./src/api/podcastApi.ts";
 
 // Types
-export { type Emission, emptyEmissionData } from "./src/stores/class/general/emission.ts";
-export { type Podcast, type PodcastAvailability } from "./src/stores/class/general/podcast.ts";
+export { type Emission, SeasonMode, emptyEmissionData } from "./src/stores/class/general/emission.ts";
+export { type Podcast, type PodcastAvailability, PodcastType } from "./src/stores/class/general/podcast.ts";
 export { type Playlist, type PlaylistRule } from "./src/stores/class/general/playlist.ts";
 export { type Annotations } from "./src/stores/class/general";
 
@@ -202,6 +204,8 @@ import { ROUTE_PARAMS } from "./src/components/composable/route/types";
 import { defineAsyncComponent } from "vue";
 
 export {
+    useRights,
+    EditRight,
     useResizePhone,
     useTagOf,
     useSelenium,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saooti/octopus-sdk",
-  "version": "41.7.2",
+  "version": "41.8.0",
   "private": false,
   "description": "Javascript SDK for using octopus",
   "author": "Saooti",

package/src/api/emissionApi.ts

@@ -2,6 +2,7 @@ import classicApi from "./classicApi";
 import { ModuleApi } from "./apiConnection";
 import { mapFromGetAll } from "./apiUtils";
 import { Emission } from "@/stores/class/general/emission";
+import { ListClassicReturn } from "@/stores/class/general/listReturn";
 
 /**
  * Retrieve an emission by ID
@@ -25,7 +26,49 @@ async function getAllById(emissionIds: Array<number>): Promise<Record<string, Em
     return mapFromGetAll(emissionIds, get, 'emissionId');
 }
 
+
+/**
+ * Search for emissions
+ * @param query A filter on the name of the emission
+ * @param options Optional options to filter the results
+ */
+async function search(query?: string, options?: {
+    /** The index of the first element to retrieve */
+    first?: number;
+    /** The number of elements to retrieve */
+    size?: number;
+    specialTreatment?: boolean;
+    distributedBy?: string;
+    /** Filter by organisation */
+    organisationId?: string|string[];
+}): Promise<ListClassicReturn<Emission>> {
+    return classicApi.fetchData<ListClassicReturn<Emission>>({
+        api: ModuleApi.DEFAULT,
+        path: "emission/search",
+        parameters: {
+            query,
+            first: options?.first ?? 0,
+            size: options?.size ?? 10,
+            distributedBy: options?.distributedBy,
+            organisationId: options?.organisationId
+        },
+        specialTreatement: options?.specialTreatment ?? true
+    });
+}
+
+/**
+ * Remove seasons data from emission
+ * @param emissionId The ID of the emission for which to remove the data
+ */
+async function resetSeasons(emissionId: number): Promise<void> {
+    return classicApi.putData({
+        api: ModuleApi.DEFAULT,
+        path: 'emission/seasons/reset/' + emissionId
+    });
+}
 export const emissionApi = {
     get,
-    getAllById
+    getAllById,
+    search,
+    resetSeasons
 };

package/src/api/podcastApi.ts

@@ -1,4 +1,4 @@
-import { Podcast, PodcastProcessingStatus, SimplifiedPodcast } from '../stores/class/general/podcast';
+import { Podcast, PodcastProcessingStatus, PodcastType, SimplifiedPodcast } from '../stores/class/general/podcast';
 import { ListClassicReturn } from '../stores/class/general/listReturn';
 import { useAuthStore } from '../stores/AuthStore';
 import classicApi from './classicApi';
@@ -17,7 +17,9 @@ export enum PodcastSort {
     POPULARITY = 'POPULARITY',
     SCORE = 'SCORE',
     UPDATE_ASC = 'UPDATE_ASC',
-    UPDATE_DESC = 'UPDATE_DESC'
+    UPDATE_DESC = 'UPDATE_DESC',
+    /** Smart sort using seasons settings */
+    SEASONAL = 'SEASONAL'
 }
 
 export enum PodcastMonetisation {
@@ -68,11 +70,15 @@ export interface PodcastSearchOptions extends Paginable<PodcastSort> {
     tags?: Array<string>;
     /** Filter by beneficiaries/rights holder reference */
     beneficiaries?: Array<string>;
+    /** Filter by seasons */
+    season?: Array<number>;
+    /** Filter by season episode number */
+    seasonEpisode?: Array<number>;
+    /** Filter by episode type */
+    episodeType?: PodcastType;
 }
 
 async function downloadRegister(podcastId: number, parameters?: Record<string,unknown>): Promise<{ location: string; downloadId: number }> {
-    const authStore = useAuthStore();
-
     return classicApi.fetchData<{
         location: string;
         downloadId: number;
@@ -137,7 +143,7 @@ function processSearchParameters(search: PodcastSearchOptions): FetchParam {
  * @param adaptParameters If true, some adjustments will be made to the parameters
  * @return A list of simplified podcasts
  */
-function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promise<ListClassicReturn<SimplifiedPodcast>> {
+async function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promise<ListClassicReturn<SimplifiedPodcast>> {
     return classicApi.fetchData<ListClassicReturn<SimplifiedPodcast>>({
         api: ModuleApi.DEFAULT,
         path: 'v2/podcast/search',
@@ -146,6 +152,21 @@ function search(options: PodcastSearchOptions, adaptParameters?: boolean): Promi
     });
 }
 
+/**
+ * Count podcasts matching the filters
+ * @param options The search criterias
+ * @param adaptParameters If true, some adjustments will be made to the parameters
+ * @return A list of simplified podcasts
+ */
+async function count(options: PodcastSearchOptions, adaptParameters?: boolean): Promise<number> {
+    const result = await search({
+        ...options,
+        size: 0
+    }, adaptParameters);
+
+    return result.count;
+}
+
 /**
  * Retrieve the podcasts matching the search criterias, with all their data.
  * This query is longer, because it also needs to retrieve organisations &
@@ -185,6 +206,7 @@ async function searchFull(options:PodcastSearchOptions, adaptParameters?: boolea
 }
 
 export const podcastApi = {
+    count,
     downloadRegister,
     get,
     search,

package/src/components/composable/route/useAdvancedParamInit.ts

@@ -9,6 +9,7 @@ import dayjs from "dayjs";
 
 import { RouteProps } from "./types";
 import { EmissionGroup, groupsApi } from "../../../api/groupsApi";
+import { useRights } from "../useRights";
 
 export const useAdvancedParamInit = (props: RouteProps, isEmission: boolean) => {
 
@@ -18,7 +19,7 @@ export const useAdvancedParamInit = (props: RouteProps, isEmission: boolean) =>
 
   const filterStore  = useFilterStore();
   const authStore  = useAuthStore();
-
+  const { canValidatePodcast } = useRights();
 
   const isInit = ref(false);
   const monetisable = ref("UNDEFINED");// UNDEFINED, YES, NO
@@ -125,8 +126,8 @@ export const useAdvancedParamInit = (props: RouteProps, isEmission: boolean) =>
     includeHidden.value = undefined !== organisation.value && organisationRight.value && "false"!==props.routeIncludeHidden;
   }
 
-  function initValidity(){
-    const cantDisplay = isPodcastmaker.value || isEmission || !includeHidden.value || !authStore.isRoleContribution || !organisationRight.value;
+  function initValidity() {
+    const cantDisplay = isPodcastmaker.value || isEmission || !includeHidden.value || !canValidatePodcast();
     if(cantDisplay){
       validity.value = "true";
     }else{

package/src/components/composable/useRights.ts

@@ -0,0 +1,196 @@
+import { useAuthStore } from "../../stores/AuthStore";
+import type { Emission } from "../../stores/class/general/emission";
+import type { Podcast } from "../../stores/class/general/podcast";
+
+type Role =
+    'ADMIN'|'ORGANISATION'|
+    'PRODUCTION'|'RESTRICTED_PRODUCTION'|'PODCAST_CRUD'|'PODCAST_VALIDATION'|
+    'PLAYLISTS'|'RESTRICTED_ANIMATION';
+
+export enum EditRight {
+    None,          // User cannot edit
+    Restricted,    // User cannot edit because element is used elsewhere
+    Full           // User can edit
+}
+/**
+ * Composable to manage rights.
+ * Based on AuthStore, but converts roles to easily usable tests for various
+ * actions.
+ */
+export const useRights = () => {
+    const authStore = useAuthStore();
+
+    function roleContainsAny(...roles: Role[]): boolean {
+	    return (authStore.authRole as Role[]).findIndex((r: Role) => roles.includes(r)) > -1;
+    }
+
+    // Creation is limited by roles
+    function canCreateEmission(): boolean {
+	    return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION');
+    }
+
+    function canEditEmission(emission: Emission): boolean {
+        if (
+            // Can edit new emissions
+            (!emission.emissionId && canCreateEmission()) ||
+            // Can edit when with sufficient rights
+		    roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION')
+        ) {
+            return true;
+        }
+
+	    // Can only edit if has created the emission
+	    return (roleContainsAny('RESTRICTED_PRODUCTION') && emission.createdByUserId === authStore.authProfile?.userId);
+    }
+
+    function canDeleteEmission(): boolean {
+	    // In case of restricted production, it will only delete podcasts
+	    // created by user, and delete the emission only if empty afterwards
+	    return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION');
+    }
+
+    function canEditCommentsConfigEmission(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION');
+    }
+
+    function canCreatePodcast(): boolean {
+        // All roles that can create podcasts
+        return roleContainsAny(
+            'ADMIN',
+            'ORGANISATION',
+            'PRODUCTION',
+            'PODCAST_CRUD',
+            'RESTRICTED_PRODUCTION',
+            'RESTRICTED_ANIMATION'
+        );
+    }
+
+    function canDuplicatePodcast(): boolean {
+        // Same as creationm but notably without PODCAST_CRUD and
+        // RESTRICTED_ANIMATION
+        return roleContainsAny(
+            'ADMIN',
+            'ORGANISATION',
+            'PRODUCTION',
+            'RESTRICTED_PRODUCTION',
+        );
+    }
+
+    function canEditPodcast(podcast: Podcast): boolean {
+        // Full rights users can edit any podcast
+        if (roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION')) {
+            return true;
+        }
+
+        // RESTRICTED users can only edit their own podcasts
+        if (roleContainsAny('RESTRICTED_PRODUCTION', 'RESTRICTED_ANIMATION')) {
+            return podcast.createdByUserId === authStore.authProfile?.userId;
+        }
+
+        // PODCAST_CRUD can only edit their own non-valid podcasts
+        if (roleContainsAny('PODCAST_CRUD')) {
+            return podcast.valid === false &&
+                   podcast.publisher?.userId === authStore.authProfile?.userId;
+        }
+
+        return false;
+    }
+
+    function canDeletePodcast(podcast: Podcast): boolean {
+        // Same permissions as editing
+        return canEditPodcast(podcast);
+    }
+
+    function canValidatePodcast(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'PODCAST_VALIDATION');
+    }
+
+    function canEditCommentsConfigPodcast(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION');
+    }
+
+    function canCreatePlaylist(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PLAYLISTS');
+    }
+
+    function canEditPlaylist(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PLAYLISTS');
+    }
+
+    function canDeletePlaylist(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PLAYLISTS');
+    }
+
+    function canCreateParticipant(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION');
+    }
+
+    async function getParticipantEditRight(participantId: number|undefined): Promise<EditRight> {
+        // New participants can be edited, and also with sufficient rights
+	    if(!participantId || roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION')) {
+	        return EditRight.Full;
+	    } else {
+	        return EditRight.None;
+	    }
+    }
+
+    async function canEditParticipant(participantId: number|undefined): Promise<boolean> {
+        const editRight = await getParticipantEditRight(participantId);
+        return editRight === EditRight.Full;
+    }
+
+
+    async function canDeleteParticipant(participantId: number|undefined): Promise<boolean> {
+        const editRight = await getParticipantEditRight(participantId);
+        return editRight === EditRight.Full;
+    }
+
+    function canEditCodeInsertPlayer(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION');
+    }
+
+    function canEditTranscript(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION');
+    }
+
+    function canSeeHistory(): boolean {
+        return roleContainsAny('ADMIN', 'ORGANISATION');
+    }
+
+    function isRestrictedProduction(): boolean {
+        return roleContainsAny('RESTRICTED_PRODUCTION') && !roleContainsAny('ADMIN', 'ORGANISATION', 'PRODUCTION');
+    }
+
+    return {
+        // Emissions
+        canCreateEmission,
+        canEditEmission,
+        canDeleteEmission,
+        canEditCommentsConfigEmission,
+
+        // Podcasts
+        canCreatePodcast,
+        canDuplicatePodcast,
+        canEditPodcast,
+        canDeletePodcast,
+        canValidatePodcast,
+        canEditCommentsConfigPodcast,
+
+        // Playlists
+        canCreatePlaylist,
+        canEditPlaylist,
+        canDeletePlaylist,
+
+        // Participants
+        canCreateParticipant,
+        getParticipantEditRight,
+        canEditParticipant,
+        canDeleteParticipant,
+
+        // Other
+        canEditCodeInsertPlayer,
+        canEditTranscript,
+        canSeeHistory,
+        isRestrictedProduction
+    }
+}

package/src/components/composable/useSeasonsManagement.ts

@@ -0,0 +1,43 @@
+import { Podcast } from "@/stores/class/general/podcast";
+import { Emission, SeasonMode } from "../../stores/class/general/emission";
+
+/**
+ * Composable to facilitate seasons operations
+ */
+export const useSeasonsManagement = () => {
+    /**
+     * Indicates that seasons are enabled on the given emission
+     * @param emission The emission to check for seasons
+     * @returns True if seasons are enabled, false otherwise
+     */
+    function areSeasonsEnabled(emission: Emission): boolean {
+        return [
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING
+        ].includes(emission.seasonMode);
+    }
+
+    /**
+     * Simple formatter to display season/episode of the given podcast
+     * @param podcast The podcast to check
+     * @returns A string describing the season/episode of the podcast or null
+     *          if no seasons are defined
+     */
+    function formatSeason(podcast: Podcast): string|null {
+        switch (podcast.emission.seasonMode) {
+            case SeasonMode.NO_SEASON:
+                return null;
+
+            case SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING:
+                return `S${podcast.seasonNumber}`;
+
+            case SeasonMode.SEASON_WITH_PODCAST_NUMBERING:
+                return `S${podcast.seasonNumber}·E${podcast.seasonEpisodeNumber}`;
+        }
+    }
+
+    return {
+        areSeasonsEnabled,
+        formatSeason
+    }
+}

package/src/components/display/live/RadioPlanning.vue

@@ -254,9 +254,7 @@ function createArrayDays() {
     });
   }
 }
-async function fetchOccurrencesAndLives(): Promise<
-  Array<PlanningOccurrence | PlanningLive>
-> {
+async function fetchOccurrencesAndLives(): Promise<Array<PlanningOccurrence|PlanningLive>> {
   const params = {
     canalId: props.radio?.id,
     from:startOfDay.value,
@@ -275,6 +273,7 @@ async function fetchOccurrencesAndLives(): Promise<
     path: "live/list",
     parameters: params,
   });
+
   if (lives.length) {
     occurrences = occurrences.concat(lives);
     occurrences.sort((a, b) => {
@@ -286,6 +285,7 @@ async function fetchOccurrencesAndLives(): Promise<
   }
   return occurrences;
 }
+
 async function fetchOccurrences(): Promise<void> {
   if (planning.value[daySelected.value]) {
     return;
@@ -310,6 +310,7 @@ async function fetchOccurrences(): Promise<void> {
       ) {
         periodDayIndex += 1;
       }
+
       switch (periodOfDay.value[periodDayIndex].id) {
         case "morning":
           planning.value[daySelected.value].morning.push(occ);
@@ -325,8 +326,9 @@ async function fetchOccurrences(): Promise<void> {
       }
       planningLength.value[daySelected.value] += 1;
     }
-  } catch {
+  } catch(e) {
     error.value = true;
+    console.error(e);
   }
   loading.value = false;
 }