app/components/Ui/Form.vue

<!--
Formulaire générique

Assure la validation des données, les actions de base (enregistrement, annulation, ...), et la confirmation avant
de quitter si des données ont été modifiées.

@see https://vuetifyjs.com/en/components/forms/#usage
-->

<template>
  <LayoutContainer>
    <v-form
      ref="form"
      v-model="isValid"
      :readonly="readonly"
      @submit.prevent=""
    >
      <!-- Top action bar -->
      <v-container
        v-if="actionPosition === 'both' || actionPosition === 'top'"
        :fluid="true"
        class="container btnActions"
      >
        <v-row>
          <v-col cols="12" sm="12">
            <slot name="form.button" />

            <UiButtonSubmit
              v-if="!readonly"
              :actions="actions"
              :validation-pending="validationPending || !isValid"
              @submit="submit"
            />
          </v-col>
        </v-row>
      </v-container>
      <div v-else class="mt-6" />

      <!-- Content -->
      <slot v-bind="{ modelValue }" />

      <!-- Bottom action bar -->
      <v-container
        v-if="actionPosition === 'both' || actionPosition === 'bottom'"
        :fluid="true"
        class="container btnActions"
      >
        <v-row>
          <v-col cols="12" sm="12">
            <slot name="form.button" />

            <UiButtonSubmit
              :validation-pending="validationPending || !isValid"
              :actions="actions"
              @submit="submit"
            />
          </v-col>
        </v-row>
      </v-container>
    </v-form>

    <!-- Confirmation dialog -->
    <LazyLayoutDialog
      :show="isConfirmationDialogShowing"
      :max-width="1000"
      theme="danger"
    >
      <template #dialogText>
        <v-card-title class="text-h5 theme-neutral">
          {{ $t('caution') }}
        </v-card-title>
        <v-card-text>
          <br />
          <p>{{ $t('quit_without_saving_warning') }}.</p>
        </v-card-text>
      </template>

      <template #dialogBtn>
        <div class="confirmation-dlg-actions">
          <v-btn class="theme-neutral" @click="closeConfirmationDialog">
            {{ $t('cancel') }}
          </v-btn>

          <v-btn class="theme-danger" @click="cancel">
            {{ $t('quit_with_no_saving') }}
          </v-btn>

          <v-btn class="theme-primary" @click="saveAndQuit">
            {{ $t('save_and_quit') }}
          </v-btn>
        </div>
      </template>
    </LazyLayoutDialog>
  </LayoutContainer>
</template>

<script setup lang="ts">
import { computed, ref, watch } from 'vue'
import type { ComputedRef, Ref, PropType } from 'vue'
import type { RouteLocationNormalized, RouteLocationRaw } from 'vue-router'
import * as _ from 'lodash-es'
import { FORM_FUNCTION, SUBMIT_TYPE, TYPE_ALERT } from '~/types/enum/enums'
import { useFormStore } from '~/stores/form'
import { useEntityManager } from '~/composables/data/useEntityManager'
import type ApiModel from '~/models/ApiModel'
import { usePageStore } from '~/stores/page'
import type { AnyJson } from '~/types/data'
import { useRefreshProfile } from '~/composables/data/useRefreshProfile'
import Organization from '~/models/Freemium/Organization'
import type Event from '~/models/Freemium/Event'
import Country from '~/models/Core/Country'

const props = defineProps({
  /**
   * Instance de l'ApiModel
   */
  modelValue: {
    type: Object as () => ApiModel,
    required: true,
  },
  /**
   * TODO: compléter
   */
  onChanged: {
    type: Function,
    required: false,
    default: null,
  },
  goBackRoute: {
    type: Object as PropType<RouteLocationRaw>,
    required: false,
    default: null,
  },
  /**
   * Types de soumission disponibles (enregistrer / enregistrer et quitter)
   */
  submitActions: {
    type: Object,
    required: false,
    default: () => {
      const actions: AnyJson = {}
      actions[SUBMIT_TYPE.SAVE] = {}
      return actions
    },
  },
  /**
   * La validation est en cours
   */
  validationPending: {
    type: Boolean,
    required: false,
    default: false,
  },
  /**
   * Faut-il rafraichir le profil à la soumission du formulaire ?
   */
  refreshProfileOnSubmit: {
    type: Boolean,
    required: false,
    default: false,
  },
  actionPosition: {
    type: String as PropType<'top' | 'bottom' | 'both'>,
    required: false,
    default: 'bottom',
  },
})

// ### Définitions
const i18n = useI18n()
const router = useRouter()
const { em } = useEntityManager()
const { refreshProfile } = useRefreshProfile()

// Le formulaire est-il valide
const isValid: Ref<boolean> = ref(true)

// Erreurs de validation
const errors: Ref<Array<string>> = ref([])

// Référence au component v-form
const form: Ref = ref(null)

const formStore = useFormStore()

// Le formulaire est-il en lecture seule
const readonly: ComputedRef<boolean> = computed(() => {
  return formStore.readonly
})

/**
 * Si l'utilisateur veut quitter le formulaire sans enregistrer ses modifications,
 * on affiche la fenêtre de confirmation. En attendant, on garde en mémoire la route qu'il
 * voulait suivre au cas où il confirmerait.
 */
const requestedLeavingRoute: Ref<RouteLocationNormalized | null> = ref(null)

// La fenêtre de confirmation est-elle affichée
const isConfirmationDialogShowing: ComputedRef<boolean> = computed(() => {
  return formStore.showConfirmToLeave
})

/**
 * Ferme la fenêtre de confirmation
 */
const closeConfirmationDialog = () => {
  requestedLeavingRoute.value = null
  formStore.setShowConfirmToLeave(false)
}

const emit = defineEmits(['update:model-value'])

// ### Actions du formulaire
/**
 * Soumet le formulaire
 *
 * @param next
 */
const submit = async (next: string | null = null) => {
  if (props.validationPending) {
    return
  }

  // Valide les données
  await validate()

  if (!isValid.value) {
    usePageStore().addAlert(TYPE_ALERT.ALERT, ['invalid_form'])
    return
  }

  try {
    usePageStore().loading = true

    const updatedEntity = await em.persist(props.modelValue)

    emit('update:model-value', updatedEntity)

    if (props.refreshProfileOnSubmit) {
      await refreshProfile()
    }

    usePageStore().addAlert(TYPE_ALERT.SUCCESS, ['saveSuccess'])

    // On retire l'état 'dirty'
    setIsDirty(false)

    const actionArgs = next ? props.submitActions[next] : null

    if (next === SUBMIT_TYPE.SAVE) {
      onSaveAction(actionArgs, updatedEntity.id)
    } else if (next === SUBMIT_TYPE.SAVE_AND_BACK) {
      onSaveAndQuitAction(actionArgs)
    }
  } catch (error: unknown) {
    const err = error as {
      response?: {
        status: number
        _data: { violations?: Array<{ message: string; propertyPath: string }> }
      }
    }
    if (
      err.response &&
      err.response.status === 422 &&
      err.response._data.violations
    ) {
      // TODO: à revoir
      const violations: Array<string> = []
      let fields: AnyJson = {}

      for (const violation of err.response._data.violations) {
        violations.push(i18n.t(violation.message) as string)
        fields = Object.assign(fields, {
          [violation.propertyPath]: violation.message,
        })
      }

      formStore.addViolation(fields)

      usePageStore().addAlert(TYPE_ALERT.ALERT, ['invalid_form'])
    } else {
      throw error
    }
  } finally {
    usePageStore().loading = false
  }
}

/**
 * Enregistre et quitte
 */
const saveAndQuit = async () => {
  await submit()
  cancel()
}

/**
 * Après l'action Sauvegarder
 *
 * Si on était en mode édition, on reste sur cette page (on ne fait rien).
 * Si on était en mode création, on bascule sur le mode édition
 *
 * @param route
 * @param id
 */
function onSaveAction(route: Route, id: number) {
  if (formStore.formFunction === FORM_FUNCTION.CREATE) {
    route.path += id
    navigateTo(route)
  }
}

/**
 * Après l'action Sauvegarder et Quitter
 *
 * On redirige vers la route donnée
 *
 * @param route
 */
function onSaveAndQuitAction(route: Route) {
  navigateTo(route)
}

/**
 * Avant de quitter le formulaire, si le formulaire a été modifié, on demande confirmation
 */
onBeforeRouteLeave(
  (to: RouteLocationNormalized, from: RouteLocationNormalized) => {
    if (formStore.dirty === true) {
      requestedLeavingRoute.value = to
      formStore.setShowConfirmToLeave(true)
      return false
    }
    return true
  },
)

onMounted(() => {
  window.addEventListener('beforeunload', quitWithoutSaving)
})

onBeforeUnmount(() => {
  window.removeEventListener('beforeunload', quitWithoutSaving)
})

function quitWithoutSaving(event) {
  if (formStore.dirty === true) {
    event.returnValue = i18n.t('quit_without_saving_warning')
  }
}

/**
 * Quitte le formulaire sans enregistrer
 */
const cancel = () => {
  setIsDirty(false)

  formStore.setShowConfirmToLeave(false)

  em.reset(props.modelValue)

  if (requestedLeavingRoute.value !== null) {
    navigateTo(requestedLeavingRoute.value)
  } else if (formStore.goAfterLeave !== null) {
    router.push(formStore.goAfterLeave) // TODO: voir si on peut pas passer ça comme prop du component
  }
}

const actions = computed(() => {
  return _.keys(props.submitActions)
})

// #### Validation et store
/**
 *  Update store when form is changed (if valid)
 */
const onFormChange = async () => {
  if (isValid.value) {
    em.save(props.modelValue)
    setIsDirty(true)

    if (props.onChanged) {
      // Execute the custom onChange method, if defined
      // TODO: voir quelles variables passer à cette méthode custom ; d'ailleurs, vérifier aussi si cette méthode est utilisée
      props.onChanged()
    }
  }
}

/**
 * Utilise la méthode validate() de v-form pour valider le formulaire et mettre à jour les variables isValid et errors
 *
 * @see https://vuetifyjs.com/en/api/v-form/#functions-validate
 */
const validate = async function () {
  const validation = await form.value.validate()
  isValid.value = validation.valid
  errors.value = validation.errors
}

// #### Gestion de l'état dirty
const unwatch = watch(
  // /!\ Important de passer par un getter de l'objet (le `() => ({ ...props.modelValue })`),
  //     car on perd la réactivité de celui-ci quand on soumet le formulaire
  //     (et donc le watcher cesse de fonctionner)
  () => ({ ...props.modelValue }),
  (newEntity, oldEntity) => {
    if (JSON.stringify(newEntity) !== JSON.stringify(oldEntity)) {
      setIsDirty(true)
    }
  },
)

/**
 * Handle events if the form is dirty to prevent submission
 * @param e
 */
// TODO: voir si encore nécessaire avec le @submit.prevent
const preventSubmit = (e: Event) => {
  // Cancel the event
  e.preventDefault()
  // Chrome requires returnValue to be set
  const event = e as { returnValue: string }
  event.returnValue = ''
}

/**
 * Applique ou retire l'état dirty (modifié) du formulaire
 */
const setIsDirty = (dirty: boolean) => {
  formStore.setDirty(dirty)
}

// Nettoyer les données lors du démontage du composant
onBeforeUnmount(() => {
  unwatch()
})

defineExpose({ validate })
</script>

<style scoped>
.btnActions {
  text-align: right;

  @media (max-width: 600px) {
    :deep(.v-col-12) {
      display: flex;
      flex-direction: column;
      justify-content: center;
      align-items: center;
      width: 100%;

      .v-btn {
        margin: 12px 0 !important;
        max-width: 250px;
      }
    }
  }
}

.confirmation-dlg-actions {
  display: flex;
  flex-direction: row;
}

.confirmation-dlg-actions .v-btn {
  min-width: 255px;
  max-width: 255px;
  margin: 0 8px;
  font-size: 13px;
  font-weight: 600;
}

@media (max-width: 960px) {
  .confirmation-dlg-actions {
    width: 100%;
    flex-direction: column;
    align-items: center;
  }

  .confirmation-dlg-actions .v-btn {
    min-width: 80%;
    max-width: 80%;
    margin: 6px 0 !important;
  }
}
</style>