app/store/profile/access.ts

import { defineStore } from 'pinia'
import {$roleUtils} from "~/services/rights/roleUtils";
import {
  AbilitiesType,
  baseAccessState,
  baseOrganizationState,
  OrignalAccessState
} from "~/types/interfaces";
import {useOrganizationProfileStore} from "~/store/profile/organization";

import {MyProfile} from "~/models/Access/MyProfile";
import {useRepo} from "pinia-orm";
import {computed, ref, Ref} from "@vue/reactivity";
import {useEach} from "#imports";
import {useAbility} from "@casl/vue";

export const useAccessProfileStore = defineStore('accessProfile', () => {

  // State
  const bearer = ref(null)
  const id = ref(null)
  const switchId = ref(null)
  const name = ref(null)
  const givenName = ref(null)
  const gender = ref(null)
  const avatarId = ref(null)
  const activityYear = ref(null)
  const historical = ref([])
  const roles: Ref<Array<string>> = ref([])
  const abilities = ref([])
  const isAdminAccess = ref(false)
  const isSuperAdminAccess = ref(false)
  const isAdmin = ref(false)
  const isAdministratifManager = ref(false)
  const isPedagogicManager = ref(false)
  const isFinancialManager = ref(false)
  const isCaMember = ref(false)
  const isStudent = ref(false)
  const isTeacher = ref(false)
  const isMember = ref(false)
  const isOther = ref(false)
  const isGuardian = ref(false)
  const isPayer = ref(false)
  const multiAccesses: Ref<Array<baseOrganizationState>> = ref([])
  const familyAccesses: Ref<Array<baseAccessState>> = ref([])
  const originalAccess = ref(null)

  // Getters
  /**
   * Est-ce que l'utilisateur possède un compte administrateur
   * @return {boolean}
   */
  const isAdminAccount = computed((): boolean => {
    return isAdminAccess.value ?? false
  })

  /**
   * Retourne l'id de la session en cours
   * @return {boolean}
   */
  const currentAccessId = computed((): number => {
    return switchId.value ?? (id.value ?? 0)
  })


  // Actions
  const setMultiAccesses = (organizations: any) => {
    useEach(organizations, (organization: baseOrganizationState) => {
      multiAccesses.value.push({
        id: organization.id,
        name: organization.name
      })
    })
  }

  const setFamilyAccesses = (accesses: any) => {
    useEach(accesses, (access: baseAccessState) => {
      const a: baseAccessState = {
        id: access.id,
        name: access.name,
        givenName: access.givenName,
        gender: access.gender,
        avatarId: access.avatarId
      }
      familyAccesses.value.push(a)
    })
  }

  const setProfile = (profile: any) => {
    const profileRoles: Array<string> = Object.values(profile.roles)

    name.value = profile.name
    givenName.value = profile.givenName
    gender.value = profile.gender
    avatarId.value = profile.avatarId
    activityYear.value = profile.activityYear
    historical.value = profile.historical
    isAdminAccess.value = profile.isAdminAccess

    isAdmin.value = $roleUtils.isA('ADMIN', profileRoles)
    isAdministratifManager.value = $roleUtils.isA('ADMINISTRATIF_MANAGER', profileRoles)
    isPedagogicManager.value = $roleUtils.isA('PEDAGOGICS_MANAGER', profileRoles)
    isFinancialManager.value = $roleUtils.isA('FINANCIAL_MANAGER', profileRoles)
    isCaMember.value = $roleUtils.isA('CA', profileRoles)
    isStudent.value = $roleUtils.isA('STUDENT', profileRoles)
    isTeacher.value = $roleUtils.isA('TEACHER', profileRoles)
    isMember.value = $roleUtils.isA('MEMBER', profileRoles)
    isOther.value = $roleUtils.isA('OTHER', profileRoles)
    isGuardian.value = profile.isGuardian
    isPayer.value = profile.isPayor
    roles.value = $roleUtils.filterFunctionRoles(profileRoles)

    // Time to add the original Access (switch User case)
    originalAccess.value = profile.originalAccess

    // Time to set Multi Accesses
    setMultiAccesses(profile.multiAccesses)

    // Time to set Family Accesses
    setFamilyAccesses(profile.familyAccesses)

    // Time to set Organization Profile
    const organizationProfileStore = useOrganizationProfileStore()
    organizationProfileStore.setProfile(profile.organization)

    useRepo(MyProfile).save(profile)
  }

  const refreshProfile = (profile: any) => {
    name.value = profile.name
    givenName.value = profile.givenName
    gender.value = profile.gender
    avatarId.value = profile.avatarId
    activityYear.value = profile.activityYear

    const organizationProfileStore = useOrganizationProfileStore()
    organizationProfileStore.refreshProfile(profile.organization)
  }

  const setOriginalAccess = (access: any) => {
    if (access) {
      const organization: baseOrganizationState = {
        id: access.organization.id,
        name: access.organization.name
      }

      const originalAccess: OrignalAccessState = {
        id: access.id,
        name: access.name,
        givenName: access.givenName,
        gender: access.gender,
        isSuperAdminAccess: access.isSuperAdminAccess,
        avatarId: access.avatarId,
        organization: organization
      }
      setOriginalAccess(originalAccess)
    }
  }

  /**
   * Teste le profil d'un utilisateur
   *
   * @param {string} profile : profile à tester
   * @return {boolean}
   */
  const testProfile = (profile:string): boolean => {
    const factory: {[key: string]: boolean|null} = {
      'admin': isAdmin.value,
      'administratifManager': isAdministratifManager.value,
      'pedagogicManager': isPedagogicManager.value,
      'financialManager': isFinancialManager.value,
      'caMember': isCaMember.value,
      'student': isStudent.value,
      'teacher': isTeacher.value,
      'member': isMember.value,
      'other': isOther.value,
      'guardian': isGuardian.value,
      'payor': isPayer.value,
    }

    if (!(profile in factory)) {
      return false
    }
    return factory[profile] ?? false
  }

  /**
   * Retourne vrai si l'utilisateur connecté possède l'un des profils passés en paramètre
   *
   * @param {Array<string>} profiles Profils à tester
   * @return {boolean}
   */
  const hasProfile = (profiles: Array<string>|null): boolean => {
    if (null === profiles)
      return true;

    let hasProfile = false;
    profiles.map(async (profile) => {
      if (testProfile(profile))
        hasProfile = true;
    });
    return hasProfile;
  }

  const { can } = useAbility()

  /**
   * Est-ce que l'utilisateur possède l'habilité
   *
   * @param {Array<AbilitiesType>} abilities Habilités à tester
   * @return {boolean}
   */
  const hasAbility = (abilities: Array<AbilitiesType>|null): boolean => {
    if(abilities === null)
      return true;

    let hasAbility= false;
    abilities.map((ability) => {
      if (can(ability.action, ability.subject))
        hasAbility = true;
    });
    return hasAbility;
  }

  /**
   * Est-ce que l'utilisateur possède le ou les rôles donnés ?
   *
   * @param {Array<string>} roles Rôles à tester
   * @return {boolean}
   */
  const hasRole = computed((rolesToTest: Array<string>|null): boolean => {
    if (rolesToTest === null) {
      return true
    }

    rolesToTest.map((r) => {
      if (roles.value.includes(r)) {
        return true
      }
    })
    return false
  })

  return {
    bearer,
    id,
    switchId,
    name,
    givenName,
    gender,
    avatarId,
    activityYear,
    historical,
    roles,
    abilities,
    isAdminAccess,
    isSuperAdminAccess,
    isAdmin,
    isAdministratifManager,
    isPedagogicManager,
    isFinancialManager,
    isCaMember,
    isStudent,
    isTeacher,
    isMember,
    isOther,
    isGuardian,
    isPayer,
    multiAccesses,
    familyAccesses,
    originalAccess,
    isAdminAccount,
    currentAccessId,
    setMultiAccesses,
    setFamilyAccesses,
    setProfile,
    refreshProfile,
    setOriginalAccess,
    hasProfile,
    hasAbility,
    hasRole,
  }
})