@saooti/octopus-sdk 40.0.3 → 40.1.0

package/src/components/composable/podcasts/useCountdown.ts

@@ -0,0 +1,53 @@
+import {computed, onBeforeUnmount, onMounted, Ref, ref} from 'vue';
+export const useCountdown = (timeRemaining: number|undefined)=>{
+  const days = ref(0);
+  const hours = ref(0);
+  const minutes = ref(0);
+  const seconds = ref(0);
+  const remainingSeconds = ref(0);
+  const countdownTimer : Ref<ReturnType<typeof setTimeout> | undefined> = ref(undefined);
+
+  const countdownValues = computed(() => { 
+    return {
+      days: pad(days.value),
+      hours: pad(hours.value),
+      minutes: pad(minutes.value),
+      seconds: pad(remainingSeconds.value),
+    }
+  });
+
+  function timer(): void {
+    days.value = Math.floor(seconds.value / 24 / 60 / 60);
+    const hoursLeft = Math.floor(seconds.value - days.value * 86400);
+    hours.value = Math.floor(hoursLeft / 3600);
+    const minutesLeft = Math.floor(hoursLeft - hours.value * 3600);
+    minutes.value = Math.floor(minutesLeft / 60);
+    remainingSeconds.value = seconds.value % 60;
+    if (0 === seconds.value) {
+      clearInterval(countdownTimer.value as unknown as number);
+      countdownTimer.value = undefined;
+    } else {
+      seconds.value-=1;
+    }
+  }
+  function pad(n: number): string {
+    return/*  n < 10 ? "0" + n : */ n.toString();
+  }
+
+  onMounted(() => {
+    if (!timeRemaining || timeRemaining <= 0) return;
+    seconds.value = timeRemaining;
+    countdownTimer.value = setInterval(() => {
+      timer();
+    }, 1000);
+  })
+  
+  onBeforeUnmount(() => {
+    clearInterval(countdownTimer.value as unknown as number);
+  })
+
+	return {
+    countdownValues,
+    countdownTimer
+	}
+}

package/src/components/composable/podcasts/usePodcastView.ts

@@ -0,0 +1,85 @@
+import { Conference } from '@/stores/class/conference/conference';
+import { Podcast } from '@/stores/class/general/podcast';
+import dayjs from 'dayjs';
+import duration from "dayjs/plugin/duration";
+dayjs.extend(duration);
+// @ts-expect-error Bibliothèque non typée
+import humanizeDuration from "humanize-duration";
+import {computed, Ref} from 'vue';
+import { useI18n } from 'vue-i18n';
+import {useOrgaComputed} from "../useOrgaComputed"
+export const usePodcastView = (podcast: Ref<Podcast|undefined>,  podcastConference: Ref<Conference|undefined>)=>{
+
+  const i18n = useI18n();
+
+  const {isEditRights, isPodcastmaker} = useOrgaComputed();
+
+
+  const editRight = computed(() => { 
+    return isEditRights(podcast.value?.organisation.id);
+  });
+  const isLiveReadyToRecord = computed(() => { 
+    return (
+      undefined !== podcast.value &&
+      undefined !== podcast.value.conferenceId &&
+      0 !== podcast.value.conferenceId &&
+      "READY_TO_RECORD" === podcast.value.processingStatus
+    );
+  });
+  const isCounter = computed(() => { 
+    return (
+      isLiveReadyToRecord.value &&
+      undefined !==  podcastConference.value &&
+      ("PLANNED" ===  podcastConference.value.status ||
+        "PENDING" ===  podcastConference.value.status)
+    );
+  });
+
+  const timeRemaining = computed(() => { 
+    return !podcast.value ? 0: dayjs(podcast.value.pubDate).diff(dayjs(), "seconds");
+  });
+
+  const isPlannedInProcessor = computed(() => "PLANNED" === podcast.value?.processingStatus);
+  
+  const date = computed(() => { 
+    if (!podcast.value || 1970 === dayjs(podcast.value.pubDate).year()) {
+      return "";
+    }
+    if (isLiveReadyToRecord.value) {
+      return dayjs(podcast.value.pubDate).format("D MMMM YYYY - HH:mm");
+    }
+    return dayjs(podcast.value.pubDate).format("D MMMM YYYY");
+  });
+
+  const duration = computed(() => { 
+    if (!podcast.value || podcast.value.duration <= 1) return "";
+      if (podcast.value.duration > 600000) {
+        return humanizeDuration(podcast.value.duration, {
+          language: i18n.locale.value,
+          largest: 1,
+          round: true,
+        });
+      }
+      return humanizeDuration(podcast.value.duration, {
+        language: i18n.locale.value,
+        largest: 2,
+        round: true,
+      });
+  });
+
+  const durationIso = computed(() => { 
+    if (!podcast.value || podcast.value.duration <= 1) return "";
+      return dayjs.duration({ milliseconds: podcast.value.duration }).toISOString();
+  });
+	return {
+    isLiveReadyToRecord,
+    isCounter,
+    timeRemaining,
+    isPlannedInProcessor,
+    date,
+    duration,
+    durationIso,
+    editRight,
+    isPodcastmaker
+	}
+}

package/src/components/composable/radio/usefetchRadioData.ts

@@ -0,0 +1,75 @@
+import classicApi from "../../../api/classicApi";
+import { MediaRadio, MetadataRadio, NextAdvertising } from '@/stores/class/general/player';
+import { Podcast } from '@/stores/class/general/podcast';
+import dayjs from 'dayjs';
+import radioHelper from "../../../helper/radio/radioHelper";
+import {onBeforeUnmount, Ref, ref} from 'vue';
+export const useFetchRadio = ()=>{
+
+  const radioInterval : Ref<ReturnType<typeof setTimeout> | undefined> = ref(undefined);
+  
+  async function fetchRadioMetadata(
+    canalId: number,
+    previousTitle: string,
+    callbackMetadata: (
+      metadata: MediaRadio,
+      podcast: Podcast | undefined,
+      history: Array<MediaRadio>
+    ) => void,
+    callbackAdvertising?: (
+      nextAdvertising: NextAdvertising
+    ) => void,
+  ): Promise<void> {
+    const metadata = await classicApi.fetchData<MetadataRadio>({
+      api: 14,
+      path:  "player/playing/" + canalId,
+    });
+    if(callbackAdvertising){
+      callbackAdvertising(metadata.nextAdvertising);
+    }
+    const arrayMetadata = metadata.previously;
+    arrayMetadata.unshift(metadata.currently);
+    for (let index = 0, len = arrayMetadata.length; index < len; index++) {
+      if (
+        dayjs().valueOf() - 18000 >
+        dayjs(arrayMetadata[index].startDate).valueOf()
+      ) {
+        await useCallbackIfNewMetadata(previousTitle, arrayMetadata, index, len,callbackMetadata);
+        return;
+      }
+    }
+  }
+  async function useCallbackIfNewMetadata(previousTitle: string, arrayMetadata: Array<MediaRadio>, index:number, len: number, callbackMetadata: (
+    metadata: MediaRadio,
+    podcast: Podcast | undefined,
+    history: Array<MediaRadio>
+  ) => void){
+    if (previousTitle !== arrayMetadata[index].title) {
+      const historyIndex = index + 1 < len ? index + 1 : index;
+      const history = arrayMetadata.slice(historyIndex, len);
+      if (arrayMetadata[index].podcastId) {
+        const data: Podcast = await classicApi.fetchData<Podcast>({
+          api: 0,
+          path: "podcast/" + arrayMetadata[index].podcastId,
+        });
+        callbackMetadata(arrayMetadata[index], data, history);
+      } else {
+        callbackMetadata(arrayMetadata[index], undefined, history);
+      }
+    }
+  }
+  function displayTitle(metadata: MediaRadio): string {
+    return radioHelper.displayTitle(metadata);
+  }
+
+
+  onBeforeUnmount(() => {
+    clearInterval(radioInterval.value as unknown as number);
+  })
+
+
+	return {
+    fetchRadioMetadata,
+    displayTitle
+	}
+}

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

@@ -0,0 +1,165 @@
+import { RubriquageFilter } from "@/stores/class/rubrique/rubriquageFilter";
+import { useOrgaComputed } from "../useOrgaComputed";
+import { useFilterStore } from "../../../stores/FilterStore";
+import { useAuthStore } from "../../../stores/AuthStore";
+import { useSimplePageParam } from './useSimplePageParam';
+import { useRubriquesFilterParam } from './useRubriquesFilterParam';
+import { computed, nextTick, onMounted, Ref, ref, watch } from "vue";
+import dayjs from "dayjs";
+
+export const useAdvancedParamInit = (props: any, isEmission: boolean)=>{
+
+  const { searchPattern,organisationId, searchMinSize, paginateFirst, initSearchPattern, initOrga} = useSimplePageParam(props);
+  const { isEditRights, isPodcastmaker } = useOrgaComputed();
+  const { stringifyRubriquesFilter } = useRubriquesFilterParam();
+
+  const filterStore  = useFilterStore();
+  const authStore  = useAuthStore();
+
+
+  const isInit = ref(false);
+  const monetisable = ref("UNDEFINED");// UNDEFINED, YES, NO
+  const fromDate: Ref<string|undefined> = ref(undefined);
+  const toDate: Ref<string|undefined> = ref(undefined);
+  const includeHidden = ref(false);
+  const sort = ref("DATE"); // SCORE, DATE, POPULARITY, NAME, LAST_PODCAST_DESC
+  const validity = ref("true"); 
+  const iabId: Ref<number|undefined> = ref(undefined);
+  const rubriqueFilter: Ref<Array<RubriquageFilter>> = ref([]);
+
+
+  const organisationRight = computed(() => isEditRights(organisationId.value));
+  const organisation = computed(() => organisationId.value ?? filterStore.filterOrgaId);
+  const rubriquesFilterArrayIds = computed(() => {
+    const allRubriquageId: Array<number> = [];
+    const noRubriquageId: Array<number> = [];
+    const rubriqueId: Array<number> = [];
+    for(const filter of rubriqueFilter.value){
+      if (-1 === filter.rubriqueId) {
+        noRubriquageId.push(filter.rubriquageId);
+      } else if (0 === filter.rubriqueId) {
+        allRubriquageId.push(filter.rubriquageId);
+      } else {
+        rubriqueId.push(filter.rubriqueId);
+      }
+    }
+    return {
+      rubriquageId: allRubriquageId,
+      rubriqueId: rubriqueId,
+      noRubriquageId: noRubriquageId
+    }
+  });
+
+  watch(() => props.routeQuery, () => initSearchPattern());
+  watch(() => props.routeMonetisable, () => initMonetisable());
+  watch(() => props.routeSort, () => initSort());
+  watch(() => props.routeIncludeHidden, () => initIncludeHidden());
+  watch(() => props.routeValidity, () => initValidity());
+  watch(() => props.routeFrom, () => initFromDate());
+  watch(() => props.routeTo, () => initToDate());
+  watch(() => props.routeIab, () => {iabId.value = props.routeIab;});
+  watch(() => props.routeOrga, () => initOrga());
+  watch(() => props.routeRubriques, () => initRubriquageFilter());
+  watch(organisationId, () => {
+    if (!isInit.value) {
+      return;
+    }
+    // TODO si oldValue !=null
+    rubriqueFilter.value = [];
+  });
+
+  onMounted(() => {
+    initAdvancedParams();
+  })
+
+  function initAdvancedParams(){
+    iabId.value = filterStore.filterIab?.id ?? props.routeIab;
+    initRubriquageFilter();
+    initIncludeHidden();
+    initValidity();
+    initMonetisable();
+    initSort();
+    initFromDate();
+    initToDate();
+    nextTick(() => {
+      isInit.value = true;
+    });
+  }
+
+  function initFromDate(){
+    if(dayjs(props.routeFrom).isValid()){
+      fromDate.value = props.routeFrom;
+    }
+  }
+
+  function initToDate(){
+    if(dayjs(props.routeTo).isValid()){
+      toDate.value = props.routeTo;
+    }
+  }
+
+  function initMonetisable(){
+    if(["YES", "NO"].includes(props.routeMonetisable)){
+      monetisable.value = props.routeMonetisable;
+    }else{
+      monetisable.value = "UNDEFINED";
+    }
+  }
+
+  function initSort(){
+    if(["SCORE", "POPULARITY", "NAME", "DATE_ASC"].includes(props.routeSort)){
+      sort.value = props.routeSort;
+    }else{
+      sort.value = isEmission ? "LAST_PODCAST_DESC" : "DATE";
+    }
+  }
+
+  function initIncludeHidden(){
+    includeHidden.value = undefined !== organisation.value && organisationRight.value && "false"!==props.routeIncludeHidden;
+  }
+
+  function initValidity(){
+    const cantDisplay = isPodcastmaker.value || isEmission || !includeHidden.value || !authStore.isRoleContribution || !organisationRight.value;
+    if(cantDisplay){
+      validity.value = "true";
+    }else{
+      validity.value = props.routeValidity;
+    }
+  }
+
+  function initRubriquageFilter(){
+    if(props.routeRubriques === stringifyRubriquesFilter(rubriqueFilter.value)){
+      return
+    }
+    const rubriqueFilterToUpdate = [];
+    if(props.routeRubriques.trim().length){
+      const arrayFilter = props.routeRubriques.split(",");
+      for(const filter of arrayFilter){
+        const rubriqueFilter = filter.split(":");
+        rubriqueFilterToUpdate.push({
+          rubriquageId:  parseInt(rubriqueFilter[0]),
+          rubriqueId:  parseInt(rubriqueFilter[1]),
+          nameRubriquage: "",
+          nameRubrique: "",
+        })
+      }
+    }
+    rubriqueFilter.value = rubriqueFilterToUpdate;
+  }
+
+	return {
+    organisationId,
+    searchPattern,
+    monetisable,
+    iabId,
+    sort,
+    includeHidden,
+    fromDate,
+    toDate,
+    rubriqueFilter,
+    searchMinSize,
+    paginateFirst,
+    validity,
+    rubriquesFilterArrayIds
+	}
+}

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

@@ -0,0 +1,48 @@
+import { useRoute, useRouter } from 'vue-router';
+export const useRouteUpdateParams = ()=>{
+
+  const router  = useRouter();
+  const route  = useRoute();
+
+  function checkPage(): boolean{
+    return ['podcasts', 'emissions', 'participants', 'playlists', 'productors', 'rubrique'].includes(route.name?.toString()??"");
+  }
+
+  function checkPageAdvanced(): boolean{
+    return ['podcasts', 'emissions'].includes(route.name?.toString()??"");
+  }
+
+  function updatePaginateSize(ps:number){
+    if(checkPage()){
+      router.push({query: {...route.query, ...{ps:ps, pr:1}}});
+    }
+  }
+
+  function updateRouteParam(update: {[key:string]: string|undefined}){
+    if(checkPage()){
+      router.push({query: {...route.query, ...update}});
+    }
+  }
+
+  function updateRouteParamAdvanced(update: {[key:string]: string|undefined}){
+    if(checkPageAdvanced()){
+      router.push({query: {...route.query, ...update}});
+    }
+  }
+
+  function updateFiltersParam(update: {[key:string]: string|undefined}, advancedUpdate: {[key:string]: string|undefined}){
+    if(checkPageAdvanced()){
+      router.push({query: {...route.query, ...update, ...advancedUpdate}});
+    }else{
+      router.push({query: {...route.query, ...update}});
+    }
+  }
+
+
+	return {
+    updatePaginateSize,
+    updateRouteParam,
+    updateRouteParamAdvanced,
+    updateFiltersParam
+	}
+}

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

@@ -0,0 +1,24 @@
+import { RubriquageFilter } from '@/stores/class/rubrique/rubriquageFilter';
+import { useFilterStore } from '../../../stores/FilterStore';
+import { computed } from 'vue';
+
+export const useRubriquesFilterComputed = ()=>{
+
+  const filterStore  = useFilterStore();
+
+  const rubriqueQueryParam = computed(() => { 
+    if (filterStore.filterRubrique?.length) {
+      return filterStore.filterRubrique
+        .map(
+          (value: RubriquageFilter) =>
+            value.rubriquageId + ":" + value.rubriqueId,
+        )
+        .join();
+    }
+    return undefined;
+  });
+
+	return {
+    rubriqueQueryParam
+	}
+}

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

@@ -0,0 +1,32 @@
+import { RubriquageFilter } from '@/stores/class/rubrique/rubriquageFilter';
+import { useFilterStore } from '../../../stores/FilterStore';
+import { useRouteUpdateParams } from './useRouteUpdateParams';
+
+export const useRubriquesFilterParam = ()=>{
+
+  const { updateFiltersParam, updateRouteParamAdvanced } = useRouteUpdateParams();
+
+  const filterStore  = useFilterStore();
+
+  function stringifyRubriquesFilter(filter :Array<RubriquageFilter>|undefined): string{
+    if(!filter){
+      return "";
+    }
+    return filter
+      .map((value) => value.rubriquageId + ":" + value.rubriqueId)
+      .join();
+  }
+
+  function modifyRubriquesFilter(modifyFunction: (a: Array<RubriquageFilter>)=> Array<RubriquageFilter>){
+    const newFilter = modifyFunction( Array.from(filterStore.filterRubrique));
+    const queryString = stringifyRubriquesFilter(newFilter);
+    const valToUpdate = "" !== queryString ? queryString : undefined;
+    updateFiltersParam({ rubriquesId: valToUpdate }, {r: valToUpdate});
+  }
+
+	return {
+    stringifyRubriquesFilter,
+    modifyRubriquesFilter,
+    updateRouteParamAdvanced
+	}
+}

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

@@ -0,0 +1,30 @@
+import { useGeneralStore } from "../../../stores/GeneralStore";
+import { useRoute, useRouter } from "vue-router";
+export const useSeoTitleUrl = ()=>{
+
+  const router = useRouter();
+  const route = useRoute();
+  const generalStore = useGeneralStore();
+
+  function updatePathParams(text: string) {
+    const seoText = stringUrlEncode(text);
+    if(seoText !== route.params.title){
+      router.replace({ params: { ...route.params, ...{title:seoText}}, query: route.query});
+    }
+    document.title = text + " - "+ generalStore.metaTitle;
+  }
+
+  function stringUrlEncode(text: string): string {
+    if(!text.length){
+      return "";
+    }
+    const withoutSpecialChar = text.replaceAll(
+      /[!"`'#%&,:;<>=\-_@{}~$.()*+/\\?[\]^|]+/gm, ' ');
+    const trimText = withoutSpecialChar.trim();
+    return "-"+trimText.replaceAll(/\s+/gm, '-');
+  }
+
+	return {
+    updatePathParams
+	}
+}

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

@@ -0,0 +1,50 @@
+import { useFilterStore } from '../../../stores/FilterStore';
+import { useRouteUpdateParams } from './useRouteUpdateParams';
+import { computed, onMounted, Ref, ref, watch } from "vue";
+
+export const useSimplePageParam = (props: any)=>{
+
+  const { updateRouteParam } = useRouteUpdateParams();
+
+  const filterStore  = useFilterStore();
+
+
+  const searchPattern = ref("");
+  const organisationId: Ref<string|undefined> = ref(undefined);
+
+  const searchMinSize = computed(() => searchPattern.value.length>3 ? searchPattern.value : "");
+  const paginateFirst = computed(() => {
+    if(!props.pr){
+      return 0;
+    }
+    return  Math.max((props.pr - 1 ) * props.ps, 0);
+  });
+
+  watch(searchPattern, () => {
+    updateRouteParam({
+      q: searchMinSize.value.length ? searchMinSize.value : undefined,
+    });
+  });
+
+  onMounted(() => {
+    initOrga();
+    initSearchPattern();
+  })
+
+  function initSearchPattern(){
+    searchPattern.value = props.routeQuery ?? "";
+  }
+  function initOrga(){
+    organisationId.value = filterStore.filterOrgaId ?? props.routeOrga;
+  }
+
+
+	return {
+    searchPattern,
+    organisationId,
+    searchMinSize,
+    paginateFirst,
+    initSearchPattern,
+    initOrga
+	}
+}

package/src/components/composable/useErrorHandler.ts

@@ -0,0 +1,25 @@
+import { AxiosError } from "axios";
+import { useAuthStore } from "../../stores/AuthStore";
+import { useRouter } from "vue-router";
+
+export const useErrorHandler = ()=>{
+
+  const authStore = useAuthStore();
+  const router = useRouter();
+
+  function handle403(error: AxiosError): void {
+    if (403 === error.response?.status) {
+      if (undefined === authStore.authOrgaId) {
+        window.location.href = window.location.origin + "/sso/login";
+      } else {
+        router.push({
+          path: "/main/pub/error",
+        });
+      }
+    }
+  }
+
+	return {
+    handle403
+	}
+}

package/src/components/composable/useImageProxy.ts

@@ -0,0 +1,28 @@
+import { useApiStore } from "../../stores/ApiStore";
+export const useImageProxy = ()=>{
+
+  const apiStore = useApiStore();
+
+  function useProxyImageUrl(url: string|undefined, width: string, height?: string): string {
+    if (!url) {
+      return "";
+    }
+    if (apiStore.imageUrl && url.includes("http")) {
+      const size = height ? "height=" + height : "width=" + width;
+      const encode = btoa(url).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+      return (
+        apiStore.imageUrl +
+        "image/" +
+        encode +
+        "?" +
+        size +
+        "&useWebp=true"
+      );
+    }
+    return url;
+  }
+
+	return {
+    useProxyImageUrl
+	}
+}

package/src/components/composable/useInit.ts

@@ -0,0 +1,38 @@
+
+import classicApi from "../../api/classicApi";
+import { useAuthStore } from "../../stores/AuthStore";
+import { useGeneralStore } from "../../stores/GeneralStore";
+import { Category } from "@/stores/class/general/category";
+import { useI18n } from "vue-i18n";
+
+export const useInit= ()=>{
+
+  const authStore = useAuthStore();
+  const generalStore = useGeneralStore();
+
+  const i18n = useI18n()
+
+  async function initSdk() {
+    classicApi.fetchData<Array<Category>>({
+      api: 0,
+      path:`iab/list${authStore.authOrgaId ? "/" + authStore.authOrgaId : ""}`,
+      parameters:{ lang: i18n.locale.value },
+    })
+    .then((data: Array<Category>) => {
+      if(data.length){
+        generalStore.storedUpdateCategories(data);
+      }
+    });
+    const captcha = document.getElementsByClassName(
+      "grecaptcha-badge",
+    )[0] as HTMLElement;
+    if (captcha) {
+      captcha.style.display = "none";
+    }
+  }
+
+
+	return {
+    initSdk
+	}
+}

package/src/components/composable/useMetaTitle.ts

@@ -0,0 +1,19 @@
+import { useGeneralStore } from "../../stores/GeneralStore";
+import { useRoute } from "vue-router";
+import { useI18n } from "vue-i18n";
+export const useMetaTitle = ()=>{
+
+  const route = useRoute();
+  const generalStore = useGeneralStore();
+  const {t} = useI18n();
+
+  function updateMetaTitle(){
+    if(""!==route.meta.title){
+      document.title = route.meta.title ? t(route.meta.title) +' - '+ generalStore.metaTitle: generalStore.metaTitle;
+    }
+  }
+
+	return {
+    updateMetaTitle
+	}
+}