@saooti/octopus-sdk 41.1.3 → 41.1.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # CHANGELOG
 
+## 41.1.5 (10/12/2025)
+
+**Misc**
+
+- Ajout API playlist, emission, et organisation
+
+## 41.1.4 (04/12/2025)
+
+**Misc**
+
+- Passage de `pinia` à version `>=2.3.0`
+  - *Podcastmaker* utilise la version `^2.3.0`
+  - *Frontoffice* utilise la version `^3.0.3`
+
 ## 41.1.3 (04/12/2025)
 
 **Misc**

package/index.ts

@@ -137,6 +137,10 @@ import {useAuthStore} from "./src/stores/AuthStore.ts";
 import {getApiUrl, ModuleApi} from "./src/api/apiConnection.ts";
 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";
+
 //Icons
 export const getAmazonMusicIcon = () => import("./src/components/icons/AmazonMusicIcon.vue");
 export const getApplePodcastIcon = () => import("./src/components/icons/ApplePodcastIcon.vue");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saooti/octopus-sdk",
-  "version": "41.1.3",
+  "version": "41.1.5",
   "private": false,
   "description": "Javascript SDK for using octopus",
   "author": "Saooti",
@@ -89,6 +89,6 @@
     "url": "git+https://github.com/saooti/octopus-sdk.git"
   },
   "peerDependencies": {
-    "pinia": "^2.3.0"
+    "pinia": ">=2.3.0"
   }
 }

package/src/api/apiUtils.ts

@@ -0,0 +1,25 @@
+/**
+ * Utility function to easily convert a list of IDs to a map of id => element
+ * @param ID The type of ID for the element
+ * @param T The type of element to retrieve
+ * @param ids The list of ids
+ * @param getter A function that given an ID, returns a promise of the matching element
+ * @param key The key for the ID
+ * @return A promise containing a map of ID => element
+ */
+export async function mapFromGetAll<ID extends string|number, T extends object >(ids: Array<ID>, getter: (id: ID) => Promise<T>, key: keyof T): Promise<Record<string, T>> {
+    const results: Record<string, T> = {};
+    const promises: Array<Promise<T>> = [];
+
+    // Retrieve data for each id
+    ids.forEach((id: ID) => {
+        const promise = getter(id).then(elt => results['' + elt[key]] = elt);
+        promises.push(promise);
+    });
+
+    // Wait for all promises to finish
+    await Promise.all(promises);
+
+    return results;
+}
+

package/src/api/emissionApi.ts

@@ -0,0 +1,31 @@
+import classicApi from "./classicApi";
+import { ModuleApi } from "./apiConnection";
+import { mapFromGetAll } from "./apiUtils";
+import { Emission } from "@/stores/class/general/emission";
+
+/**
+ * Retrieve an emission by ID
+ * @param emissionId The ID of the emission
+ * @return An emission
+ */
+async function get(emissionId: number): Promise<Emission> {
+    return classicApi.fetchData<Emission>({
+        api: ModuleApi.DEFAULT,
+        path: 'emission/' + emissionId
+    });
+}
+
+/**
+ * Retrieve all emissions specified by their IDs
+ * @param emissionIds A list of emission IDs. For better result, they
+                          should be unique.
+ * @return The matching emissions
+ */
+async function getAllById(emissionIds: Array<number>): Promise<Record<string, Emission>> {
+    return mapFromGetAll(emissionIds, get, 'emissionId');
+}
+
+export const emissionApi = {
+    get,
+    getAllById
+};

package/src/api/organisationApi.ts

@@ -0,0 +1,31 @@
+import classicApi from "./classicApi";
+import { ModuleApi } from "./apiConnection";
+import { Organisation } from "../stores/class/general/organisation";
+import { mapFromGetAll } from "./apiUtils";
+
+/**
+ * Retrieve an organisation by ID
+ * @param organisationId The ID of the organisation
+ * @return An organisation
+ */
+async function get(organisationId: string): Promise<Organisation> {
+    return classicApi.fetchData<Organisation>({
+        api: ModuleApi.DEFAULT,
+        path: 'organisation/' + organisationId
+    });
+}
+
+/**
+ * Retrieve all organisations specified by their IDs
+ * @param organisationIds A list of organisation IDs. For better result, they
+                          should be unique.
+ * @return The matching organisations
+ */
+async function getAllById(organisationIds: Array<string>): Promise<Record<string, Organisation>> {
+    return mapFromGetAll(organisationIds, get, 'id');
+}
+
+export const organisationApi = {
+    get,
+    getAllById
+};

package/src/api/playlistApi.ts

@@ -0,0 +1,72 @@
+import classicApi from "./classicApi";
+import { ModuleApi } from "./apiConnection";
+import { Podcast, SimplifiedPodcast } from "../stores/class/general/podcast";
+import { Playlist } from "../stores/class/general/playlist";
+import { organisationApi } from "./organisationApi";
+import { emissionApi } from "./emissionApi";
+
+/**
+ * Retrieve playlist data
+ * @param playlistId The ID of the playlist
+ * @return The playlist
+ */
+async function get(playlistId: number): Promise<Playlist> {
+    return classicApi.fetchData<Playlist>({
+        api: ModuleApi.DEFAULT,
+        path: 'playlist/' + playlistId
+    });
+}
+
+/**
+ * Retrieve the podcasts defined in the playlist
+ * @param playlistId The ID of the playlist
+ * @return A list of simplified podcasts
+ */
+async function getContent(playlistId: number): Promise<Array<SimplifiedPodcast>> {
+    return classicApi.fetchData<Array<SimplifiedPodcast>>({
+        api: ModuleApi.DEFAULT,
+        path: 'v2/playlist/' + playlistId + '/content'
+    });
+}
+
+/**
+ * Retrieve the podcasts defined in the playlist, with all their data
+ * This query is longer, because it also needs to retrieve organisations &
+ * emissions.
+ * @param playlistId The ID of the playlist
+ * @return A list of podcasts
+ */
+async function getContentFull(playlistId: number): Promise<Array<Podcast>> {
+    const simplified = await this.getContent(playlistId);
+    const full: Array<Podcast> = [];
+
+    // TODO unique
+    const organisationIds = simplified.map((p: SimplifiedPodcast) => p.organisationId);
+    // TODO unique
+    const emissionIds = simplified.map((p: SimplifiedPodcast) => p.emissionId);
+
+    const organisations = await organisationApi.getAllById(organisationIds);
+    const emissions = await emissionApi.getAllById(emissionIds);
+
+    simplified.forEach((s: SimplifiedPodcast) => {
+        const organisation = organisations[s.organisationId];
+        const emission = emissions[s.emissionId];
+
+        full.push({
+            ...s,
+            organisation,
+            emission
+        });
+    })
+
+    return full;
+}
+
+/**
+ * API to manage playlists
+ */
+export const playlistApi = {
+    get,
+    getContent,
+    getContentFull
+}

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

@@ -80,6 +80,7 @@ import { Playlist } from "@/stores/class/general/playlist";
 import { computed, onBeforeMount, Ref, ref, watch } from "vue";
 import { AxiosError } from "axios";
 import { useI18n } from "vue-i18n";
+import { playlistApi } from "../../../api/playlistApi";
 
 //Props 
 const props = defineProps({
@@ -137,7 +138,7 @@ watch(searchPattern,() => {
   }
 });
 
-onBeforeMount(()=>fetchContent());
+onBeforeMount(fetchContent);
 
 
 //Methods
@@ -146,10 +147,7 @@ async function fetchContent(): Promise<void> {
     podcasts.value.length = 0;
     loading.value = true;
     try {
-      podcasts.value = await classicApi.fetchData<Array<Podcast>>({
-        api: 0,
-        path: "playlist/" + props.playlist.playlistId + "/content",
-      });
+      podcasts.value = await playlistApi.getContentFull(props.playlist.playlistId);
       if (!editRight.value) {
         podcasts.value = podcasts.value.filter((p: Podcast | null) => {
           return (

package/src/components/display/playlist/PodcastPlaylistInlineList.vue

@@ -40,6 +40,7 @@ import { Podcast } from "@/stores/class/general/podcast";
 import { Playlist } from "@/stores/class/general/playlist";
 import { onMounted, Ref, ref, watch } from "vue";
 import { useI18n } from "vue-i18n";
+import { playlistApi } from "../../../api/playlistApi";
 
 //Props 
 const props = defineProps<{
@@ -72,14 +73,17 @@ onMounted(()=>fetchContent())
 async function fetchContent(): Promise<void> {
   allPodcasts.value.length = 0;
   loading.value = true;
-  playlist.value = await classicApi.fetchData<Playlist>({
-    api: 0,
-    path: "playlist/" + props.playlistId,
-  });
-  allPodcasts.value = await classicApi.fetchData<Array<Podcast>>({
-    api: 0,
-    path: "playlist/" + props.playlistId + "/content",
-  });
+
+  // Retrieve both playlist & content at the same time
+  const [playlistData, content] = await Promise.all([
+    playlistApi.get(props.playlistId),
+    playlistApi.getContentFull(props.playlistId)
+  ]);
+
+  // Update data
+  playlist.value = playlistData;
+  allPodcasts.value = content;
+
   if (
     !(
       (undefined !== authStore.authOrgaId &&

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

@@ -42,15 +42,15 @@ import debounce from '../../../helper/debounceHelper';
 import PodcastItemInfo from "./PodcastItemInfo.vue";
 import PodcastImage from "./PodcastImage.vue";
 import dayjs from "dayjs";
-import { Podcast } from "@/stores/class/general/podcast";
+import { Podcast } from "../../../stores/class/general/podcast";
 import { computed, nextTick, onBeforeMount, ref, Ref, useTemplateRef } from "vue";
 import { Conference } from "@/stores/class/conference/conference";
 
 //Props 
-const props = defineProps({
-  podcast: { default: () => ({}), type: Object as () => Podcast },
-  fetchConference: { default: undefined, type: Object as () => Conference }
-});
+const props = defineProps<{
+  podcast: Podcast;
+  fetchConference?: Conference;
+}>();
 
 //Data 
 const isMobile = ref(false);

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

@@ -17,54 +17,95 @@ export enum ProcessingStatus {
   All = "ALL"
 }
 
+/** Describe the availability of the podcast */
+export interface PodcastAvailability {
+  date?: number | null;
+  visibility?: boolean;
+  immediate?: boolean;
+}
+
 /**
  * Data about a podcast/episode
  */
-export interface Podcast {
+export interface Podcast extends BasePodcast {
+  /** ID of the podcast */
+  podcastId: number;
+  /** Emission the podcast belongs to */
+  emission: Emission;
+  /** Organisation the podcast belongs to */
+  organisation: Organisation;
+  /** URL to the image */
   imageUrl?: string;
-  animators?: Array<Participant>;
-  annotations?: { [key: string]: string | number | boolean | undefined };
-  audioStorageUrl: string;
+  /** URL to the audio file (for downloading) */
   audioUrl: string;
+  /** URL to the audio file (file on bucket) */
+  audioStorageUrl: string;
+  /** Title of the podcast */
+  title: string;
+  /** The availability of the podcast */
+  availability: PodcastAvailability;
+  /** Description of the podcast */
+  description?: string;
+  /** Publishing date */
+  pubDate?: string;
+  /** The status of the processing of the audio file */
+  processingStatus?: ProcessingStatus;
+  /** An optional list of tags */
+  tags?: Array<string>;
+  /** An optional list of tags for OuestFrance */
+  ofTags?: Array<string>;
+
+  createdAt?: string;
+  createdByUserId?: string;
+  annotations?: { [key: string]: string | number | boolean | undefined };
   article?: string;
-  availability: {
-    date?: number | null;
-    visibility?: boolean;
-    immediate?: boolean;
-  };
   comments?: string;
   conferenceId?: number;
-  createdAt?: string;
-  createdByUserId?: string;
   valid?: boolean;
-  description?: string;
   downloadCount?: number;
+  weekDownloadCount?: number;
   duration: number;
   email?: string;
-  emission: Emission;
-  guests?: Array<Participant>;
   monetisable?: string;
-  organisation: Organisation;
-  podcastId: number;
-  /** The status of the processing of the audio file */
-  processingStatus?: ProcessingStatus;
+
+  animators?: Array<Participant>;
+  guests?: Array<Participant>;
   processorId?: string;
-  pubDate?: string;
   publisher?: Person;
   rubriqueIds?: Array<number>;
   rssEpisode?:string;
   score?: number;
   size?: number;
-  /** An optional list of tags */
-  tags?: Array<string>;
-  /** An optional list of tags for OuestFrance */
-  ofTags?: Array<string>;
-  title: string;
-  weekDownloadCount?: number;
   order?: number;
   video?: Video;
 }
 
+/**
+ * A podcast with incomplete data
+ */
+export interface SimplifiedPodcast extends
+  Omit<Podcast, 'emission'|'organisation'|'animators'|'guests'|'ofTags'|'comments'|'email'|'processorId'|'publisher'|'order'|'video'> {
+
+  /** The ID of the emission */
+  emissionId: number;
+  /** The ID of the organisation */
+  organisationId: string;
+}
+
+/**
+ * Convert a simplified podcast to a complete one
+ * @param simplified The incomplete podcast
+ * @param organisation The organisation the podcast belongs to
+ * @param emission The emission the podcast belongs to
+ */
+export function simplifiedToFull(simplified: SimplifiedPodcast, organisation: Organisation, emission: Emission): Podcast {
+  return {
+    ...simplified,
+    organisation,
+    emission
+  };
+}
+
 export function emptyPodcastData(): Podcast {
   return {
     podcastId: 0,