@saooti/octopus-sdk 35.1.6 → 35.2.0

package/src/stores/AuthStore.ts

@@ -0,0 +1,43 @@
+import { Organisation } from '@/stores/class/general/organisation';
+import { Profile } from '@/stores/class/user/profile';
+import { defineStore } from 'pinia';
+
+interface AuthState{
+	authName: string;
+  authOrgaId?: string;
+  authOrgaName?: string;
+  authRole: Array<string>;
+  authParam: {
+    accessToken?: string;
+    refreshToken?: string;
+    expiration?: Date;
+  };
+  authProfile: Profile;
+  authOrganisation: Organisation;
+}
+export const useAuthStore = defineStore('AuthStore', {
+  state: (): AuthState => ({
+    authName: '',
+    authRole: [''],
+    authParam: {
+      accessToken: undefined,
+      refreshToken: undefined,
+      expiration: undefined,
+    },
+    authProfile: {
+      userId: '',
+    },
+    authOrganisation: {
+      id: '',
+      name: '',
+      imageUrl: '',
+      description: undefined,
+      monetisable: undefined,
+      location: undefined,
+      comments: undefined,
+      attributes: {
+        RSS_CONTACT: undefined,
+      },
+    },
+  }),
+})

package/src/stores/FilterStore.ts

@@ -0,0 +1,63 @@
+import { Category } from '@/stores/class/general/category';
+import { Rubriquage } from '@/stores/class/rubrique/rubriquage';
+import { RubriquageFilter } from '@/stores/class/rubrique/rubriquageFilter';
+import { Rubrique } from '@/stores/class/rubrique/rubrique';
+import { defineStore } from 'pinia';
+
+interface FilterState{
+	filterOrgaId?: string;
+  filterImgUrl?: string;
+  filterName?: string;
+  filterRubriquage: Array<Rubriquage>;
+  filterRubrique: Array<RubriquageFilter>;
+  filterRubriqueDisplay: Array<Rubrique>;
+  filterTypeMedia?: string;
+  filterSortOrder?: string;
+  filterSortField?: string;
+  filterLive?: boolean;
+  filterIab?: Category;
+}
+export const useFilterStore = defineStore('FilterStore', {
+  state: (): FilterState => ({
+    filterRubriquage: [],
+    filterRubrique: [],
+    filterRubriqueDisplay: [],
+    filterLive: false,
+  }),
+  actions : {
+    filterUpdateOrga(filter: {orgaId?:string,imgUrl?:string,name?:string,rubriquageArray?:Array<Rubriquage>, isLive?:boolean }) {
+      this.filterOrgaId = filter.orgaId;
+      if (filter.imgUrl || !filter.orgaId) {
+        this.filterImgUrl = filter.imgUrl;
+      }
+      if (filter.name || !filter.orgaId) {
+        this.filterName = filter.name;
+      }
+      if(filter.rubriquageArray){
+        this.filterRubriquage = filter.rubriquageArray;
+      }
+      this.filterLive = filter.isLive;
+      this.filterIab = undefined;
+    },
+    filterUpdateIab(iab?:Category) {
+      this.filterIab = iab;
+    },
+    filterUpdateRubrique(rubriqueFilter: Array<RubriquageFilter>) {
+      this.filterRubrique = rubriqueFilter;
+    },
+    filterUpdateRubriqueDisplay(rubriques: Array<Rubrique>) {
+      this.filterRubriqueDisplay = rubriques;
+    },
+    filterUpdateMedia(filter: {type?:string, order?:string, field?:string}) {
+      if (filter.type) {
+        this.filterTypeMedia = filter.type;
+      }
+      if (filter.order) {
+        this.filterSortOrder = filter.order;
+      }
+      if (filter.field) {
+        this.filterSortField = filter.field;
+      }
+    },
+  }
+})

package/src/stores/GeneralStore.ts

@@ -0,0 +1,57 @@
+import { Category } from '@/stores/class/general/category';
+import { CommentPodcast } from '@/stores/class/general/comment';
+import { defineStore } from 'pinia';
+
+interface GeneralState{
+  metaTitle: string;
+  platformEducation: boolean;
+  generalLogoUrl: string;
+  storedCategories: Array<Category>;
+  storedCategoriesOrga: Array<Category>;
+  isBeforeLive: boolean;
+  generalComments: {
+    knownIdentity: string | null;
+    actualPodcastId?: number;
+    loadedComments: Array<CommentPodcast>;
+    totalCount: number;
+  };
+}
+export const useGeneralStore = defineStore('GeneralStore', {
+  state: (): GeneralState => ({
+    metaTitle: 'Octopus by Saooti',
+    platformEducation:false,
+    generalLogoUrl: '/img/logo_octopus_final.svg',
+    storedCategories: [],
+    storedCategoriesOrga: [],
+    isBeforeLive: true,
+    generalComments: {
+      knownIdentity: null,
+      actualPodcastId: 0,
+      loadedComments: [],
+      totalCount: 0,
+    },
+  }),
+  actions:{
+    storedUpdateCategories(categories: Array<Category>) {
+      this.storedCategories = categories;
+    },
+    storedUpdateCategoriesOrga(categories: Array<Category>) {
+      this.storedCategoriesOrga = categories;
+    },
+    isBeforeLiveUpdate(isBeforeLive: boolean) {
+      this.isBeforeLive = isBeforeLive;
+    },
+    setCommentIdentity(identity:string|null) {
+      this.generalComments.knownIdentity = identity;
+    },
+    setCommentLoaded(data: {podcastId?: number, comments:Array<CommentPodcast>}) {
+      this.generalComments.actualPodcastId = data.podcastId;
+      this.generalComments.loadedComments = data.comments;
+    },
+    platformUpdateEducation(isEducation: boolean) {
+      this.platformEducation = isEducation;
+      this.generalLogoUrl = '/img/logo_education.webp';
+      this.metaTitle = 'RadioEducation.org';
+    },
+  }
+})

package/src/stores/PlayerStore.ts

@@ -0,0 +1,134 @@
+import DurationHelper from '../helper/duration';
+import { Media } from '@/stores/class/general/media';
+import { MediaRadio, Radio } from '@/stores/class/general/player';
+import { Podcast } from '@/stores/class/general/podcast';
+import { defineStore } from 'pinia';
+interface Transcript{
+	actual: number, 
+	actualText:string,
+	value : Array<{endTime: number, startTime:number, text: string}>
+}
+interface PlayerState{
+	playerStatus: string; //STOPPED, LOADING, PLAYING, PAUSED
+	playerPodcast: Podcast|undefined;
+	playerVolume?: number; //From 0 to 1
+	playerElapsed: number; //From 0 to 1
+	playerTotal: number;
+	playerMedia: Media|undefined;
+	playerLive: Podcast|undefined;
+	playerRadio: Radio|undefined; 
+	playerStop?: boolean;
+	playerSeekTime?: number;
+	playerTranscript?:Transcript;
+}
+export const usePlayerStore = defineStore('PlayerStore', {
+  state: (): PlayerState => ({
+    playerStatus: 'STOPPED',
+    playerPodcast: undefined,
+    playerVolume: 1,
+    playerElapsed: 0,
+    playerTotal: 0,
+    playerMedia: undefined,
+    playerLive: undefined,
+    playerRadio: undefined,
+    playerSeekTime:0,
+  }),
+	getters: {
+		playedTime(): string{
+      if (this.playerElapsed && this.playerElapsed > 0 && this.playerTotal && this.playerTotal > 0) {
+        return DurationHelper.formatDuration(
+          Math.round(this.playerElapsed * this.playerTotal)
+        );
+      }
+      return '--:--';
+    },
+		totalTime(): string {
+      if (this.playerElapsed && this.playerElapsed > 0 && this.playerTotal && this.playerTotal > 0)
+        return DurationHelper.formatDuration(Math.round(this.playerTotal));
+      return '--:--';
+    },
+		isPlaying(): boolean {
+			return 'PLAYING' === this.playerStatus;
+		},
+		isPaused(): boolean {
+			return 'PAUSED' === this.playerStatus;
+		},
+		podcastImage(): string{
+      return this.playerPodcast?.imageUrl ?? "";
+		},
+		emissionName(): string {
+			return this.playerPodcast?.emission?.name ?? "";
+    },
+		transcriptText():string{
+      return this.playerTranscript?.actualText ?? "";
+    },
+    radioUrl(): string{
+      return this.playerRadio?.url ?? "";
+    }
+  },
+  actions: {
+    playerPlay(param?: any) {
+			if (!param) {
+				this.playerStatus = 'STOPPED';
+				this.playerPodcast = undefined;
+				this.playerMedia = undefined;
+				this.playerLive = undefined;
+				this.playerRadio = undefined;
+				this.playerElapsed = 0;
+				return;
+			}
+			if (
+				(this.playerPodcast && this.playerPodcast.podcastId === param.podcastId) ||
+				(this.playerMedia && this.playerMedia.mediaId === param.mediaId) ||
+				(this.playerLive && this.playerLive.conferenceId === param.conferenceId)
+			) {
+				//Do nothing
+				return;
+			}
+			this.playerStatus = 'LOADING';
+			this.playerPodcast = undefined;
+			this.playerMedia = undefined;
+			this.playerLive = undefined;
+			this.playerRadio = undefined;
+			this.playerElapsed = 0;
+			if (
+				param.conferenceId &&
+				(!param.podcastId || param.processingStatus !== 'READY')
+			) {
+				this.playerLive = param;
+			} else if (param.podcastId) {
+				this.playerPodcast = param;
+			} else if (param.mediaId) {
+				this.playerMedia = param;
+			}else if(param.canalId){
+				this.playerRadio = {...param,...{isInit: false}};
+			}
+		},
+
+		playerChangeStatus(isPause: boolean) {
+			if (isPause) {
+				this.playerStatus = 'PAUSED';
+			} else {
+				this.playerStatus = 'PLAYING';
+			}
+		},
+
+		playerUpdateSeekTime(seekTime: number){
+			this.playerSeekTime = seekTime;
+		},
+
+		playerMetadata(metadata: MediaRadio){
+			if(!this.playerRadio){return;}
+			this.playerRadio.metadata = metadata;
+		},
+
+		playerUpdateElapsed(elapsed: number, total:number){
+			this.playerElapsed = elapsed;
+			this.playerTotal = total;
+		},
+
+		playerUpdateTranscript(transcript?:Transcript) {
+			this.playerTranscript = transcript;
+		},
+  }
+})

package/src/{store → stores}/class/general/playlist.ts

@@ -1,4 +1,4 @@
-import { Organisation } from '../general/organisation';
+import { Organisation } from './organisation';
 import { Person } from '../user/person';
 import { FetchParam } from './fetchParam';
 

package/tsconfig.json

@@ -39,6 +39,5 @@
   ],
   "files": [
     "src/shims-vue.d.ts",
-    "src/vuex-shim.d.ts"
   ]
 }

package/src/store/ApiStore.ts

@@ -1,33 +0,0 @@
-import { ApiState, getDefaultApiState } from './classStore/typeApiStore';
-import { Module, MutationTree } from 'vuex';
-import { StoreState } from './classStore/typeAppStore';
-const mutations = <MutationTree<ApiState>>{
-  init(state, apiUrls: ApiState) {
-    state.apiUrl= apiUrls.apiUrl;
-    state.commentUrl= apiUrls.commentUrl;
-    state.frontendUrl= apiUrls.frontendUrl;
-    state.ftpUrl= apiUrls.ftpUrl;
-    state.hlsUrl= apiUrls.hlsUrl;
-    state.imageUrl= apiUrls.imageUrl;
-    state.keycloakUrl= apiUrls.keycloakUrl;
-    state.mediaUrl= apiUrls.mediaUrl;
-    state.miniplayerUrl= apiUrls.miniplayerUrl;
-    state.processorUrl= apiUrls.processorUrl;
-    state.recoUrl= apiUrls.recoUrl;
-    state.radioUrl= apiUrls.radioUrl;
-    state.rssUrl= apiUrls.rssUrl;
-    state.rtmpUrl= apiUrls.rtmpUrl;
-    state.speechToTextUrl= apiUrls.speechToTextUrl;
-    state.studioUrl= apiUrls.studioUrl;
-    state.videoMakerUrl= apiUrls.videoMakerUrl;
-    state.storageUrl= apiUrls.storageUrl;
-  },
-};
-
-const ApiModule: Module<ApiState, StoreState> = {
-  namespaced: true,
-  state: getDefaultApiState(),
-  mutations: mutations,
-};
-
-export default ApiModule;

package/src/store/AppStore.ts

@@ -1,76 +0,0 @@
-import { createStore, MutationTree } from 'vuex';
-import ApiStore from '@/store/ApiStore';
-import PlayerStore from '@/store/PlayerStore';
-import { AppStoreData, StoreState } from './classStore/typeAppStore';
-
-const mutations = <MutationTree<StoreState>>{
-  categoriesSet(state, categories) {
-    state.categories = categories;
-  },
-  categoriesOrgaSet(state, categories) {
-    state.categoriesOrga = categories;
-  },
-  filterOrga(state, filter) {
-    state.filter.organisationId = filter.orgaId;
-    if (filter.imgUrl || !filter.orgaId) {
-      state.filter.imgUrl = filter.imgUrl;
-    }
-    if (filter.name || !filter.orgaId) {
-      state.filter.name = filter.name;
-    }
-    if(filter.rubriquageArray){
-      state.filter.rubriquageArray = filter.rubriquageArray;
-    }
-    state.filter.live = filter.isLive;
-    state.filter.iab = undefined;
-  },
-  filterIab(state, iab) {
-    state.filter.iab = iab;
-  },
-  filterRubrique(state, rubriqueFilter) {
-    state.filter.rubriqueFilter = rubriqueFilter;
-  },
-  filterRubriqueDisplay(state, rubriques) {
-    state.filter.rubriqueDisplay = rubriques;
-  },
-  filterMedia(state, filter) {
-    if (filter.type) {
-      state.filter.typeMedia = filter.type;
-    }
-    if (filter.order) {
-      state.filter.sortOrder = filter.order;
-    }
-    if (filter.field) {
-      state.filter.sortField = filter.field;
-    }
-  },
-  initFilter(state, data) {
-    state.filter = {
-      ...state.filter,
-      ...data,
-    };
-  },
-  liveUpdate(state, isBeforeLive) {
-    state.liveUpdate.isBeforeLive = isBeforeLive;
-  },
-  setCommentIdentity(state, identity) {
-    state.comments.knownIdentity = identity;
-  },
-  setCommentLoaded(state, data) {
-    state.comments.actualPodcastId = data.podcastId;
-    state.comments.loadedComments = data.comments;
-  },
-  isEducation(state, isEducation) {
-    state.general.education = isEducation;
-    state.general.logoUrl = '/img/logo_education.webp';
-    state.general.metaTitle = 'RadioEducation.org';
-  },
-};
-export default createStore({
-  state: AppStoreData(),
-  modules: {
-    api : ApiStore,
-    player: PlayerStore
-  },
-  mutations: mutations,
-});

package/src/store/PlayerStore.ts

@@ -1,87 +0,0 @@
-import { getDefaultPlayerState } from './classStore/typePlayerStore';
-import { Module, MutationTree } from 'vuex';
-import { StoreState } from './classStore/typeAppStore';
-import { Player } from './class/general/player';
-
-const mutations = <MutationTree<Player>>{
-  playPodcast(state, podcast) {
-    if (!podcast) {
-      state.status = 'STOPPED';
-      state.podcast = undefined;
-      state.media = undefined;
-      state.live = undefined;
-      state.radio = undefined;
-      state.elapsed = 0;
-      return;
-    }
-    if (
-      (state.podcast &&
-        state.podcast.podcastId === podcast.podcastId) ||
-      (state.media && state.media.mediaId === podcast.mediaId) ||
-      (state.live &&
-        state.live.conferenceId === podcast.conferenceId)
-    ) {
-      //Do nothing
-      return;
-    }
-    state.status = 'LOADING';
-    state.podcast = undefined;
-    state.media = undefined;
-    state.live = undefined;
-    state.radio = undefined;
-    state.elapsed = 0;
-    if (
-      podcast.conferenceId &&
-      (!podcast.podcastId || podcast.processingStatus !== 'READY')
-    ) {
-      state.live = podcast;
-    } else if (podcast.podcastId) {
-      state.podcast = podcast;
-    } else if (podcast.mediaId) {
-      state.media = podcast;
-    }else if(podcast.canalId){
-      state.radio = {...podcast,...{isInit: false}};
-    }
-  },
-
-  radioMetadata(state, metadata){
-    if(!state.radio){return;}
-    state.radio.metadata = metadata;
-  },
-
-  pause(state, pause) {
-    if (pause) {
-      state.status = 'PAUSED';
-    } else {
-      state.status = 'PLAYING';
-    }
-  },
-
-  elapsed(state, elapsed) {
-    state.elapsed = elapsed;
-  },
-
-  totalTime(state, total) {
-    state.total = total;
-  },
-
-  volume(state, volume) {
-    state.volume = volume;
-  },
-
-  seekTime(state, seekTime) {
-    state.seekTime = seekTime;
-  },
-
-  transcript(state, transcript) {
-    state.transcript = transcript;
-  },
-};
-
-const PlayerModule: Module<Player, StoreState> = {
-  namespaced: true,
-  state: getDefaultPlayerState(),
-  mutations: mutations,
-};
-
-export default PlayerModule;

package/src/store/classStore/typeApiStore.ts

@@ -1,43 +0,0 @@
-
-export interface ApiState {
-    apiUrl: undefined,
-    commentUrl: undefined,
-    frontendUrl: undefined,
-    ftpUrl: undefined,
-    hlsUrl: undefined,
-    imageUrl: undefined,
-    keycloakUrl: undefined,
-    mediaUrl: undefined,
-    miniplayerUrl:undefined,
-    processorUrl: undefined,
-    radioUrl: undefined,
-    recoUrl:undefined,
-    rssUrl: undefined,
-    rtmpUrl: undefined,
-    speechToTextUrl: undefined,
-    studioUrl: undefined,
-    videoMakerUrl: undefined,
-    storageUrl: undefined,
-}
-export function getDefaultApiState(): ApiState {
-  return {
-    apiUrl: undefined,
-    commentUrl:undefined,
-    frontendUrl: undefined,
-    ftpUrl: undefined,
-    hlsUrl: undefined,
-    imageUrl: undefined,
-    keycloakUrl: undefined,
-    mediaUrl: undefined,
-    miniplayerUrl:undefined,
-    processorUrl: undefined,
-    radioUrl: undefined,
-    recoUrl:undefined,
-    rssUrl: undefined,
-    rtmpUrl: undefined,
-    speechToTextUrl: undefined,
-    studioUrl: undefined,
-    videoMakerUrl: undefined,
-    storageUrl: undefined,
-  };
-}

package/src/store/classStore/typeAppStore.ts

@@ -1,81 +0,0 @@
-import { Category } from '../class/general/category';
-import { CommentPodcast } from '../class/general/comment';
-import { Rubriquage } from '../class/rubrique/rubriquage';
-import { RubriquageFilter } from '../class/rubrique/rubriquageFilter';
-import { Rubrique } from '../class/rubrique/rubrique';
-import { ApiState } from './typeApiStore';
-import { AuthState } from './typeAuthStore';
-import { getDefaultPlayerState } from './typePlayerStore';
-import { Player } from '../class/general/player';
-
-export interface Filter{
-  organisationId: string | undefined;
-  imgUrl: string | undefined;
-  name: string | undefined;
-  rubriquageArray: Array<Rubriquage>;
-  rubriqueFilter: Array<RubriquageFilter>;
-  rubriqueDisplay: Array<Rubrique>;
-  typeMedia: string | undefined;
-  sortOrder: string | undefined;
-  sortField: string | undefined;
-  live: boolean|undefined;
-  iab: Category |undefined;
-}
-
-export interface StoreState {
-  general: {
-    metaTitle: string;
-    education: boolean;
-    logoUrl: string;
-  };
-  categories: Array<Category>;
-  categoriesOrga: Array<Category>;
-  filter: Filter;
-  liveUpdate: {
-    isBeforeLive: boolean;
-  };
-  comments: {
-    knownIdentity: string | null;
-    actualPodcastId: number;
-    loadedComments: Array<CommentPodcast>;
-    totalCount: number;
-  };
-  player: Player;
-  auth?: AuthState;
-  api?: ApiState;
-}
-
-export function AppStoreData(): StoreState {
-  return {
-    general: {
-      metaTitle: 'Octopus by Saooti',
-      education: false,
-      logoUrl: '/img/logo_octopus_final.svg',
-    },
-    categories: [],
-    categoriesOrga: [],
-    filter: {
-      organisationId: undefined,
-      imgUrl: undefined,
-      name:undefined,
-      rubriquageArray: [],
-      rubriqueFilter: [],
-      rubriqueDisplay: [],
-      typeMedia: undefined,
-      sortOrder: undefined,
-      sortField: undefined,
-      live: false,
-      iab: undefined,
-    },
-    liveUpdate: {
-      isBeforeLive: true,
-    },
-    comments: {
-      knownIdentity: null,
-      actualPodcastId: 0,
-      loadedComments: [],
-      totalCount: 0,
-    },
-    player: getDefaultPlayerState(),
-  };
-}

package/src/store/classStore/typeAuthStore.ts

@@ -1,44 +0,0 @@
-import { Organisation } from "../class/general/organisation";
-import { Profile } from "../class/user/profile";
-
-export interface AuthState {
-  name: string;
-  organisationId: string | undefined;
-  organisationName: string | undefined;
-  role: Array<string>;
-  oAuthParam: {
-    accessToken: string | undefined;
-    refreshToken: string | undefined;
-    expiration: Date | undefined;
-  };
-  profile: Profile;
-  organisation: Organisation;
-}
-export function getDefaultAuthState(): AuthState {
-  return {
-    name: '',
-    organisationId: undefined,
-    organisationName: undefined,
-    role: [''],
-    oAuthParam: {
-      accessToken: undefined,
-      refreshToken: undefined,
-      expiration: undefined,
-    },
-    profile: {
-      userId: '',
-    },
-    organisation: {
-      id: '',
-      name: '',
-      imageUrl: '',
-      description: undefined,
-      monetisable: undefined,
-      location: undefined,
-      comments: undefined,
-      attributes: {
-        RSS_CONTACT: undefined,
-      },
-    },
-  };
-}

package/src/store/classStore/typePlayerStore.ts

@@ -1,15 +0,0 @@
-import { Player } from '../class/general/player';
-
-export function getDefaultPlayerState(): Player {
-  return {
-    status: 'STOPPED', //STOPPED, LOADING, PLAYING, PAUSED
-    podcast: undefined,
-    volume: 1, //From 0 to 1
-    elapsed: 0, //From 0 to 1
-    total: 0,
-    media: undefined,
-    live: undefined,
-    radio: undefined,
-    seekTime:0,
-  };
-}