@saooti/octopus-sdk 41.1.6 → 41.1.8

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 41.1.8 (10/12/2025)
+
+**Fixes**
+
+- Correction recherche dans `PodcastList`
+
+## 41.1.7 (10/12/2025)
+
+**Misc**
+
+- Ajout API podcast
+- Utilisation search V2 pour les podcasts
+
 ## 41.1.6 (10/12/2025)
 
 **Fixes**
@@ -12,6 +25,7 @@
 **Misc**
 
 - Ajout API playlist, emission, et organisation
+- Utilisation content V2 pour la récupération du contenu des playlist
 
 ## 41.1.4 (04/12/2025)
 

package/index.ts

@@ -140,6 +140,7 @@ import classicApi from "./src/api/classicApi.ts";
 export { emissionApi } from "./src/api/emissionApi.ts";
 export { organisationApi } from "./src/api/organisationApi.ts";
 export { playlistApi } from "./src/api/playlistApi.ts";
+export { podcastApi, PodcastSort, type PodcastSearchOptions } from "./src/api/podcastApi.ts";
 
 //Icons
 export const getAmazonMusicIcon = () => import("./src/components/icons/AmazonMusicIcon.vue");

package/package.json

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

package/src/api/playlistApi.ts

@@ -4,6 +4,7 @@ import { Podcast, SimplifiedPodcast } from "../stores/class/general/podcast";
 import { Playlist } from "../stores/class/general/playlist";
 import { organisationApi } from "./organisationApi";
 import { emissionApi } from "./emissionApi";
+import { unique } from '../helper/arrayHelper';
 
 /**
  * Retrieve playlist data
@@ -29,10 +30,6 @@ async function getContent(playlistId: number): Promise<Array<SimplifiedPodcast>>
     });
 }
 
-function unique<T>(value: T, index: number, array: Array<T>): boolean {
-    return array.indexOf(value) === index;
-}
-
 /**
  * Retrieve the podcasts defined in the playlist, with all their data
  * This query is longer, because it also needs to retrieve organisations &

package/src/api/podcastApi.ts

@@ -0,0 +1,174 @@
+import { Podcast, PodcastProcessingStatus, SimplifiedPodcast } from '../stores/class/general/podcast';
+import { ListClassicReturn } from '../stores/class/general/listReturn';
+import { useAuthStore } from '../stores/AuthStore';
+import classicApi from './classicApi';
+import { ModuleApi } from './apiConnection';
+import { unique } from '../helper/arrayHelper';
+import { organisationApi } from './organisationApi';
+import { emissionApi } from './emissionApi';
+
+export enum PodcastSort {
+    DATE = 'DATE',
+    DATE_ASC = 'DATE_ASC',
+    NAME = 'NAME',
+    LAST_PODCAST_DESC = 'LAST_PODCAST_DESC',
+    POPULARITY = 'POPULARITY',
+    SCORE = 'SCORE',
+    UPDATE_ASC = 'UPDATE_ASC',
+    UPDATE_DESC = 'UPDATE_DESC'
+}
+
+export enum PodcastMonetisation {
+    YES = "YES",
+    NO = "NO",
+    UNDEFINED = "UNDEFINED"
+}
+
+interface Paginable<S> {
+    /** The start of pagination */
+    first?: number;
+    /** The number of elements to retrieve */
+    pageSize?: number;
+    /** Sorting */
+    sort?: S;
+}
+
+/**
+ * The options available to search for podcasts.
+ * 
+ * ** /!\ This list is not exhaustive **
+ */
+export interface PodcastSearchOptions extends Paginable<PodcastSort> {
+    /** Filter by emission ID */
+    emissionId?: number|number[];
+    /** Filter by organisation ID */
+    organisationId?: string[];
+    /** Filter by title containing */
+    query?: string;
+    /** Filter by IAB category */
+    iabId?: number;
+    /** Filter by participant */
+    participantId?: number;
+    /** Fitler by monetisation */
+    monetisable?: PodcastMonetisation;
+    /** Filter by pub date before */
+    pubDateBefore?: string;
+    /** Filter by pub date after */
+    pubDateAfter?: string;
+    /** Filter by rubriquage exclusion ? */
+    noRubriquageId?: Array<number>;
+    /** Filter by rubrique */
+    rubriqueId?: Array<number>;
+    /** Filter by rubriquage */
+    rubriquageId?: Array<number>;
+    /** Also show hidden podcasts */
+    includeHidden?: boolean;
+    /** Filter by validity */
+    validity?: boolean;
+    /** Filter by status */
+    processingStatus?: Array<PodcastProcessingStatus>;
+    /** Filter by podcast having a video */
+    withVideo?: boolean;
+    /** Filter by tags */
+    tags: Array<string>;
+    /** Filter by beneficiaries/rights holder reference */
+    beneficiaries?: Array<string>;
+}
+
+async function downloadRegister(podcastId: number, parameters?: Record<string,unknown>): Promise<{ location: string; downloadId: number }> {
+    const authStore = useAuthStore();
+
+    return classicApi.fetchData<{
+        location: string;
+        downloadId: number;
+    }>({
+        api: ModuleApi.DEFAULT,
+        path:"podcast/download/register/" + podcastId + ".mp3",
+        parameters: {
+            access_token: authStore.authParam.accessToken,
+            ...parameters
+        },
+        headers: {'X-Extra-UA':'Saooti Player'},
+        isNotAuth:true
+    });
+}
+
+/**
+ * Get a podcast by its ID
+ */
+function get(podcastId: number): Promise<Podcast> {
+    return classicApi.fetchData<Podcast>({
+        api: ModuleApi.DEFAULT,
+        path: 'podcast/' + podcastId
+    });
+}
+
+/**
+ * Search for podcasts. Retrieved podcasts are 'incomplete', some of their
+ * properties are only IDs.
+ * Use `searchFull` to get full podcasts, but more queries will be made
+ * @param options The search criterias
+ * @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>> {
+    return classicApi.fetchData<ListClassicReturn<SimplifiedPodcast>>({
+        api: ModuleApi.DEFAULT,
+        path: 'v2/podcast/search',
+        parameters: {
+            ...options,
+            beneficiary: options.beneficiaries,
+            includeStatus: options.processingStatus,
+            includeTags: options.tags,
+            before: options.pubDateBefore,
+            after: options.pubDateAfter,
+            size: options.pageSize ?? 50
+        },
+        specialTreatement: adaptParameters
+    });
+}
+
+/**
+ * Retrieve the podcasts matching the search criterias, with all their data.
+ * This query is longer, because it also needs to retrieve organisations &
+ * emissions.
+ * @param options The search criterias
+ * @param adaptParameters If true, some adjustments will be made to the parameters
+ * @return A list of podcasts
+ */
+async function searchFull(options:PodcastSearchOptions, adaptParameters?: boolean): Promise<ListClassicReturn<Podcast>> {
+    const podcasts = await search(options, adaptParameters);
+    const full: ListClassicReturn<Podcast> = {
+        count: podcasts.count,
+        sort:podcasts.sort,
+        result: []
+    };
+    
+    const organisationIds = podcasts.result.map((p: SimplifiedPodcast) => p.organisationId)
+        .filter(unique);
+    const emissionIds = podcasts.result.map((p: SimplifiedPodcast) => p.emissionId)
+        .filter(unique);
+
+    const organisations = await organisationApi.getAllById(organisationIds);
+    const emissions = await emissionApi.getAllById(emissionIds);
+
+    podcasts.result.forEach((s: SimplifiedPodcast) => {
+        const organisation = organisations[s.organisationId];
+        const emission = emissions[s.emissionId];
+
+        full.result.push({
+            ...s,
+            organisation,
+            emission
+        });
+    });
+
+    return full;
+}
+
+export const podcastApi = {
+    downloadRegister,
+    get,
+    search,
+    searchFull
+}

package/src/components/display/podcasts/PodcastList.vue

@@ -60,43 +60,54 @@ import classicApi from "../../../api/classicApi";
 import PodcastItem from "./PodcastItem.vue";
 import ClassicLazy from "../../misc/ClassicLazy.vue";
 import { useFilterStore } from "../../../stores/FilterStore";
-import { Podcast, emptyPodcastData } from "@/stores/class/general/podcast";
+import { Podcast, PodcastProcessingStatus, emptyPodcastData } from "../../../stores/class/general/podcast";
 import { computed, onBeforeMount, Ref, ref, watch } from "vue";
 import { FetchParam } from "@/stores/class/general/fetchParam";
 import { AxiosError } from "axios";
-import { ListClassicReturn } from "@/stores/class/general/listReturn";
+import { ListClassicReturn } from "../../../stores/class/general/listReturn";
 import { useI18n } from "vue-i18n";
-
+import { podcastApi, PodcastMonetisation, PodcastSearchOptions, PodcastSort } from "../../../api/podcastApi";
 
 //Props 
-const props = defineProps({
-  first: { default: 0, type: Number },
-  size: { default: 30, type: Number },
-  organisationId: { default: () => [], type: Array as () => Array<string> },
-  emissionId: { default: undefined, type: Number },
-  iabId: { default: undefined, type: Number },
-  participantId: { default: undefined, type: Number },
-  query: { default: undefined, type: String },
-  monetisable: { default: undefined, type: String },
-  popularSort: { default: false, type: Boolean },
-  reload: { default: false, type: Boolean },
-  before: { default: undefined, type: String },
-  after: { default: undefined, type: String },
-  includeHidden: { default: false, type: Boolean },
-  showCount: { default: false, type: Boolean },
-  displaySortText: { default: true, type: Boolean },
-  sortCriteria: { default: undefined, type: String },
-  validity: { default: 'true', type: String },
-  rubriqueId: { default: () => [], type: Array as () => Array<number> },
-  rubriquageId: { default: () => [], type: Array as () => Array<number> },
-  noRubriquageId: { default: () => [], type: Array as () => Array<number> },
-  justSizeChosen: { default: false, type: Boolean },
-  withVideo: { default: undefined, type: Boolean },
-  includeTag:{ default: () => [], type: Array as () => Array<string> },
-  forceUpdateParameters: { default: false, type: Boolean },
+const props = withDefaults(defineProps<{
+  first?: number;
+  size?: number;
+  organisationId?: Array<string>;
+  emissionId?: number;
+  iabId?: number;
+  participantId?: number;
+  query?: string;
+  monetisable?: PodcastMonetisation;
+  popularSort?: boolean;
+  reload?: boolean;
+  before?: string;
+  after?: string;
+  includeHidden?: boolean;
+  showCount?: boolean;
+  displaySortText?: boolean;
+  sortCriteria?: PodcastSort;
+  validity?: 'true'|'false'|boolean;
+  rubriqueId?: Array<number>;
+  rubriquageId?: Array<number>;
+  noRubriquageId?: Array<number>;
+  justSizeChosen?: boolean;
+  withVideo?: boolean;
+  includeTag?: Array<string>;
+  forceUpdateParameters?: boolean;
   /** The beneficiaries to filter on */
-  beneficiaries: { default: null, type: Array as () => Array<string> }
-})
+  beneficiaries?: Array<string>;
+}>(), {
+  first: 0,
+  size: 30,
+  popularSort: false,
+  reload: false,
+  includeHidden: false,
+  showCount: false,
+  displaySortText: true,
+  validity: true,
+  justSizeChosen: false,
+  forceUpdateParameters: false
+});
 
 //Emits
 const emit = defineEmits(["fetch", "emptyList"]);
@@ -137,7 +148,7 @@ const organisation = computed(() => {
   }
   return filterStore.filterOrgaId ? [filterStore.filterOrgaId] : [];
 });
-const sort = computed(() => props.popularSort ? "POPULARITY" : (props.sortCriteria ?? "DATE"));
+const sort = computed(() => props.popularSort ? PodcastSort.POPULARITY : (props.sortCriteria ?? PodcastSort.DATE));
 const sortText = computed(() => {
   if (!props.displaySortText) {
     return "";
@@ -176,9 +187,15 @@ onBeforeMount(()=>fetchContent(false))
 //Methods
 async function fetchContent(reset: boolean): Promise<void> {
   loading.value = true;
-  const param: FetchParam = {
+
+  let validity: undefined|boolean = undefined;
+  if (props.validity !== undefined) {
+    validity = props.validity === 'true' || props.validity === true;
+  }
+  
+  const param: PodcastSearchOptions = {
     first: reset ? 0 : dfirst.value,
-    size: dsize.value,
+    pageSize: dsize.value,
     organisationId: organisation.value,
     emissionId: props.emissionId,
     iabId: props.iabId,
@@ -186,31 +203,26 @@ async function fetchContent(reset: boolean): Promise<void> {
     query: props.query,
     monetisable: props.monetisable,
     sort: sort.value,
-    before: props.before,
-    after: props.after,
-    noRubriquageId: props.noRubriquageId.length
+    pubDateBefore: props.before,
+    pubDateAfter: props.after,
+    noRubriquageId: props.noRubriquageId?.length
       ? props.noRubriquageId
       : undefined,
-    rubriqueId: props.rubriqueId.length ? props.rubriqueId : undefined,
-    rubriquageId: props.rubriquageId.length ? props.rubriquageId : undefined,
+    rubriqueId: props.rubriqueId?.length ? props.rubriqueId : undefined,
+    rubriquageId: props.rubriquageId?.length ? props.rubriquageId : undefined,
     includeHidden: props.includeHidden,
-    validity: props.validity,
+    validity,
     /* publisherId:
       !this.onlyValid && !authStore.isRoleProduction
         ? authStore.authProfile?.userId
         : undefined, */
-    includeStatus: ["READY", "PROCESSING"],
+    processingStatus: [PodcastProcessingStatus.Ready, PodcastProcessingStatus.Processing],
     withVideo: props.withVideo,
-    includeTag: props.includeTag.length ? props.includeTag : undefined,
-    beneficiary: props.beneficiaries ?? undefined
+    tags: props.includeTag?.length ? props.includeTag : undefined,
+    beneficiaries: props.beneficiaries ?? undefined
   };
   try {
-    const data = await classicApi.fetchData<ListClassicReturn<Podcast>>({
-      api: 0,
-      path: "podcast/search",
-      parameters: param,
-      specialTreatement: true,
-    });
+    const data = await podcastApi.searchFull(param, true);
     afterFetching(reset, data);
   } catch (error) {
     handle403(error as AxiosError);

package/src/components/display/podcasts/PodcastPlayButton.vue

@@ -91,7 +91,7 @@ import CancelIcon from "vue-material-design-icons/Cancel.vue";
 import AlertIcon from "vue-material-design-icons/Alert.vue";
 import DurationHelper from "../../../helper/durationHelper";
 import { state } from "../../../stores/ParamSdkStore";
-import { Podcast, ProcessingStatus } from "../../../stores/class/general/podcast";
+import { Podcast, PodcastProcessingStatus as ProcessingStatus } from "../../../stores/class/general/podcast";
 import { Conference } from "@/stores/class/conference/conference";
 import { usePlayerStore } from "../../../stores/PlayerStore";
 import { computed, defineAsyncComponent, ref } from "vue";

package/src/helper/arrayHelper.ts

@@ -0,0 +1,3 @@
+export function unique<T>(value: T, index: number, array: Array<T>): boolean {
+    return array.indexOf(value) === index;
+}

package/src/stores/class/general/podcast.ts

@@ -7,7 +7,7 @@ import { Video } from "./video";
 /**
  * State of processing of the audio file
  */
-export enum ProcessingStatus {
+export enum PodcastProcessingStatus {
   Planned = "PLANNED",
   Processing = "PROCESSING",
   Ready = "READY",
@@ -27,7 +27,7 @@ export interface PodcastAvailability {
 /**
  * Data about a podcast/episode
  */
-export interface Podcast extends BasePodcast {
+export interface Podcast {
   /** ID of the podcast */
   podcastId: number;
   /** Emission the podcast belongs to */
@@ -49,7 +49,7 @@ export interface Podcast extends BasePodcast {
   /** Publishing date */
   pubDate?: string;
   /** The status of the processing of the audio file */
-  processingStatus?: ProcessingStatus;
+  processingStatus?: PodcastProcessingStatus;
   /** An optional list of tags */
   tags?: Array<string>;
   /** An optional list of tags for OuestFrance */