codevdesign 1.0.53 → 1.0.55

package/composants/csqcDate.vue

@@ -1,6 +1,6 @@
 <template>
   <v-date-input
-    v-model="dateInterne"
+    :model-value="dateInterne"
     v-bind="$attrs"
     input-format="yyyy-MM-dd"
     variant="outlined"
@@ -12,7 +12,7 @@
 </template>
 
 <script setup lang="ts">
-  import { computed } from 'vue'
+  import { computed, ref } from 'vue'
   import { VDateInput } from 'vuetify/labs/VDateInput'
 
   type Model = string | Date | null
@@ -20,7 +20,7 @@
   const props = defineProps<{ modelValue: Model }>()
 
   const emit = defineEmits<{
-    (e: 'update:model-value', v: string | null): void
+    (e: 'update:modelValue', v: string | null): void
     (e: 'change', v: string | null): void
   }>()
 
@@ -28,6 +28,7 @@
   const normalizeToYmd = (v: Date | string | null | undefined): string | null => {
     if (v == null || v === '') return null
 
+    // Date -> YYYY-MM-DD (local)
     if (v instanceof Date) {
       if (isNaN(v.getTime())) return null
       const yyyy = v.getFullYear()
@@ -36,44 +37,43 @@
       return `${yyyy}-${mm}-${dd}`
     }
 
+    // String -> accepte seulement YYYY-MM-DD
     const s = String(v).trim()
+    const m = s.match(/^(\d{4})-(\d{2})-(\d{2})$/)
+    if (!m) return null
 
-    // si ça commence par YYYY-MM-DD, on prend les 10 premiers chars
-    const m = s.match(/^(\d{4}-\d{2}-\d{2})/)
-    if (m) return m[1]
+    // Optionnel: validation simple (évite 2026-99-99)
+    const y = Number(m[1]),
+      mo = Number(m[2]),
+      d = Number(m[3])
+    if (mo < 1 || mo > 12 || d < 1 || d > 31) return null
 
-    // Sinon, on tente un fallback
-    const d = new Date(s)
-    if (isNaN(d.getTime())) return null
-    const yyyy = d.getFullYear()
-    const mm = String(d.getMonth() + 1).padStart(2, '0')
-    const dd = String(d.getDate()).padStart(2, '0')
-    return `${yyyy}-${mm}-${dd}`
+    return `${m[1]}-${m[2]}-${m[3]}`
   }
 
   // UI: VDateInput stable avec Date|null
-  const dateInterne = computed<Date | null>({
-    get() {
-      const ymd = normalizeToYmd(props.modelValue as any)
-      if (!ymd) return null
-
-      // Construire une Date locale sans décalage timezone (évite UTC shift)
-      const [y, m, d] = ymd.split('-').map(Number)
-      return new Date(y, m - 1, d)
-    },
-    set() {
-      // rien: on émet seulement dans choixUtilisateur
-    },
+  const dateInterne = computed<Date | null>(() => {
+    const ymd = normalizeToYmd(props.modelValue as any)
+    if (!ymd) return null
+    const [y, m, d] = ymd.split('-').map(Number)
+    return new Date(y, m - 1, d) // local, stable
   })
 
+  const prevBeforeEmit = ref<string | null>(null)
+
   const choixUtilisateur = (v: Date | string | null) => {
     const next = normalizeToYmd(v)
     const current = normalizeToYmd(props.modelValue as any)
 
-    // Bloque la 2e émission au blur (même si type diffère Date/string)
+    // rollback: on reçoit l'ancienne valeur (celle qu'on avait avant)
+    if (prevBeforeEmit.value && next === prevBeforeEmit.value && current !== prevBeforeEmit.value) {
+      return
+    }
+
     if (next === current) return
 
-    emit('update:model-value', next)
+    prevBeforeEmit.value = current
+    emit('update:modelValue', next)
     emit('change', next)
   }
 </script>

package/index.ts

@@ -35,6 +35,7 @@ import response from './modeles/response'
 
 // outils
 import csqcRafraichisseurToken from './outils/rafraichisseurToken'
+import csqcRafraichisseurTokenParent from './outils/csqcRafraichisseurTokenParent'
 import csqcOutils from './outils/csqcOutils'
 
 // i18n
@@ -68,6 +69,7 @@ export {
   csqcImportCSV,
   csqcRechercheUtilisateur,
   csqcRafraichisseurToken,
+  csqcRafraichisseurTokenParent,
   csqcOutils,
   modeleSnackbar,
   modeleDatatableColonne as colonne,

package/outils/csqcRafraichisseurTokenParent.ts

@@ -0,0 +1,132 @@
+import i18n from '@/plugins/i18n'
+
+class RafraichisseurTokenParent {
+  private intervalleEnSecondes = 5
+  private secondesAvantExpirationTokenParentPourRafraichir = 10
+  private popupAffiche = false
+  private timerId: number | null = null
+
+  public async demarrer(nomCookie: string, urlPortailSeConnecterParent: string, urlPortailRafraichissementParent: string) {
+    await this.verifierJeton(nomCookie, urlPortailSeConnecterParent, urlPortailRafraichissementParent)
+    if (this.timerId != null) return
+    window.setInterval(() => {
+      this.verifierJeton(nomCookie, urlPortailSeConnecterParent, urlPortailRafraichissementParent)
+    }, this.intervalleEnSecondes * 1000)
+  }
+
+  // Permet d’arrêter le timer (ex: au logout / destroy)
+  public arreter(): void {
+    if (this.timerId != null) {
+      clearInterval(this.timerId)
+      this.timerId = null
+    }
+  }
+
+  private async verifierJeton(nomCookie: string, urlPortailSeConnecterParent: string, urlPortailRafraichissementParent: string) {
+    if (this.popupAffiche) return //Ne rien faire si le popup de déconnexion est déjà affiché
+
+    const tokenEncode = this.lireCookie(nomCookie)
+
+    if (tokenEncode == null || (tokenEncode != null && !this.estJetonValide(tokenEncode))) {
+      await this.rafraichir(nomCookie, urlPortailSeConnecterParent, urlPortailRafraichissementParent)
+    }
+  }
+
+  private estJetonValide(tokenEncode: string) {
+    if (tokenEncode === null || tokenEncode === '') {
+      return false
+    }
+
+    const token = this.parseJwt(tokenEncode)
+
+    let tempActuel = new Date().getTime() / 1000 // Temps en secondes
+
+    tempActuel += this.secondesAvantExpirationTokenParentPourRafraichir
+    if (tempActuel > token.exp) {
+      return false
+    }
+    return true
+  }
+
+  private async rafraichir(nomCookie: string, urlPortailSeConnecterParent: string, urlPortailRafraichissementParent: string) {
+    if (!nomCookie) return
+
+    const controller = new AbortController()
+    const timeout = setTimeout(() => controller.abort(), 10_000)
+
+    try {
+      // Rafraichir par IFrame est le seul moyen qui fonctionne pour ne pas avoir un HTTP 405 ou
+      // un NS_BINDING_ABORTED dans le frontend en appelant le Rafraichir du portail parent
+      await this.rafraichirParIframe(nomCookie, urlPortailSeConnecterParent, urlPortailRafraichissementParent)
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } catch (err: any) {
+      if (err?.name === 'AbortError') console.warn('RafraichisseurTokenParent timeout')
+      else console.error('Erreur rafraichisseur de token parent', err)
+      // on réessaiera au prochain tick
+    } finally {
+      clearTimeout(timeout)
+    }
+  }
+
+  private async rafraichirParIframe(nomCookie: string, urlPortailSeConnecterParent: string, urlPortailRafraichissementParent: string) {
+    // Pour éviter les cross référence, on créé un iframe qui appel portail parent et force la MAJ du jeton ou l'invalidation du jeton, si jamais l'utilisateur n'est plus connecté
+    // ajax vers le refresh
+    const iframe = document.createElement('iframe')
+    const url = urlPortailRafraichissementParent
+    iframe.src = `${url}`
+    iframe.id = 'idRafrToken'
+    iframe.style.display = 'none'
+    document.body.appendChild(iframe)
+    iframe.onload = () => {
+      const jetonCSQC = this.lireCookie(nomCookie)
+      if (jetonCSQC == null || jetonCSQC === '') {
+        this.estDeconnecte(urlPortailSeConnecterParent)
+      }
+
+      iframe.remove()
+    }
+
+    // Attendre 1500 ms
+    await new Promise(resolve => setTimeout(resolve, 1500))
+  }
+
+  private estDeconnecte(urlPortailSeConnecterParent: string) {
+    this.popupAffiche = true
+    if (confirm('rafr' + i18n.global.t('csqcRafraichisseurTokenParent.estDeconnecte'))) {
+      window.open(`${urlPortailSeConnecterParent}?urlRetour=${encodeURI(window.localStorage.href)}`, '_self')
+      this.popupAffiche = false
+    }
+  }
+
+  private lireCookie(nom: string) {
+    const nameEQ = `${nom}=`
+    const ca = document.cookie.split(';')
+    for (let i = 0; i < ca.length; i += 1) {
+      let c = ca[i]
+      while (c.charAt(0) === ' ') {
+        c = c.substring(1, c.length)
+      }
+      if (c.indexOf(nameEQ) === 0) {
+        return c.substring(nameEQ.length, c.length)
+      }
+    }
+    return null
+  }
+
+  private parseJwt(token: string) {
+    const base64Url = token.split('.')[1]
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/')
+    const jsonPayload = decodeURIComponent(
+      atob(base64)
+        .split('')
+        .map(c => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+        .join(''),
+    )
+    return JSON.parse(jsonPayload)
+  }
+}
+
+// Instance
+const rafraichisseurTokenParent = new RafraichisseurTokenParent()
+export default rafraichisseurTokenParent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codevdesign",
-  "version": "1.0.53",
+  "version": "1.0.55",
   "description": "Composants Vuetify 3 pour les projets Codev",
   "files": [
     "./**/*.vue",