app/types/interfaces.d.ts

import { Ability } from '@casl/ability'
import { Store } from 'pinia'
import DataPersister from '~/services/data/dataPersister'
import DataProvider from '~/services/data/dataProvider'
import DataDeleter from '~/services/data/dataDeleter'
import {
  ABILITIES,
  FORM_FUNCTION,
  GENDER,
  TYPE_ALERT,
} from '~/types/enum/enums'
import ApiResource from "~/models/ApiResource";
import {AnyJson} from "~/types/enum/data";
import {Record} from "immutable";

/**
 * Upgrade du @nuxt/types pour TypeScript
 */
declare module '@nuxt/types' {
  interface Context {
    $ability: Ability
    $dataPersister: DataPersister
    $dataProvider: DataProvider
    $dataDeleter: DataDeleter
  }
}

declare module '@vuex-orm/core' {
  interface Query {
    getAllRelations: () => Array<string>
  }
}

interface AbilitiesType {
  action: ABILITIES

  subject: string
  /** an array of fields to which user has (or not) access */
  fields?: string[]
  /** an object of conditions which restricts the rule scope */
  conditions?: any
  /** indicates whether rule allows or forbids something */
  inverted?: boolean
  /** message which explains why rule is forbidden */
  reason?: string
}

interface formState {
  violations: AnyJson
  readonly: boolean
  formFunction: FORM_FUNCTION
  dirty: boolean
  showConfirmToLeave: boolean
  goAfterLeave: string | null
}

interface Alert {
  type: TYPE_ALERT
  messages: Array<string>
}

interface pageState {
  alerts: Array<Alert>,
  menusOpened: Record<string, boolean>
}

interface ormState {
  initialValues: Map<string, Map<number, ApiResource>>
}

interface Historical {
  future?: boolean
  past?: boolean
  present?: boolean
  dateStart?: string
  dateEnd?: string
}

interface baseAccessState {
  id: number | null
  name: string | null
  givenName: string | null
  gender: GENDER | null
  avatarId: number | null
}

interface baseOrganizationState {
  id: number | null
  name: string | null
  website?: string | null
}

interface OrignalAccessState extends baseAccessState {
  isSuperAdminAccess: boolean
  organization: baseOrganizationState
}

interface accessState extends baseAccessState {
  bearer: string | null
  switchId: number | null
  activityYear: number | null
  historical: Historical | Array<string>
  roles: Array<string>
  abilities: Array<AbilitiesType>
  isAdminAccess: boolean | null
  isSuperAdminAccess: boolean | null
  isAdmin: boolean | null
  isAdministratifManager: boolean | null
  isPedagogicManager: boolean | null
  isFinancialManager: boolean | null
  isCaMember: boolean | null
  isStudent: boolean | null
  isTeacher: boolean | null
  isMember: boolean | null
  isOther: boolean | null
  isGuardian: boolean | null
  isPayer: boolean | null
  multiAccesses: Array<baseOrganizationState>
  familyAccesses: Array<baseAccessState>
  originalAccess: OrignalAccessState | null
}

interface organizationState extends baseOrganizationState {
  id: number | null
  parametersId: number | null
  name: string | null
  product?: string | null
  currentActivityYear?: number | null
  modules?: Array<string>
  hasChildren?: boolean | null
  showAdherentList?: boolean | null
  legalStatus?: string | null
  networks: Array<string>
  parents: Array<baseOrganizationState>
}

type AnyStore = Store<any>

interface EnumChoice {
  value: string
  label: string
}

interface Filter {
  readonly key: string
  readonly value: string | boolean | number
}

type EnumChoices = Array<EnumChoice>

interface HookProvider {
  invoke(args: DataProviderArgs): Promise<any>
}
interface HookPersister {
  invoke(args: DataPersisterArgs): Promise<any>
}
interface HookDeleter {
  invoke(args: DataDeleterArgs): Promise<any>
}

interface Processor {
  process(data: AnyJson): Promise<any>
}

interface Normalizer {
  normalize(args: DataPersisterArgs): any
}
interface Denormalizer {
  denormalize(data: any): any
}

interface DolibarrContractLine {
  id: number
  contractId: number
  dateStart: Date
  dateEnd: Date
  serviceRef: string
  serviceLabel: string
}

interface DolibarrContract {
  ref: string
  socId: number
  lines: Array<DolibarrContractLine>
}

interface DolibarrBill {
  id: number
  ref: string
  socId: number
  date: Date
  taxExcludedAmount: number
  taxIncludedAmount: number
  paid: boolean
}

interface DolibarrAccount {
  organizationId: number
  socId: number
  clientNumber: string
  product:
    | 'PRODUCT_ARTIST'
    | 'PRODUCT_ARTIST_PREMIUM'
    | 'PRODUCT_SCHOOL'
    | 'PRODUCT_SCHOOL_PREMIUM'
    | 'PRODUCT_MANAGER'
  contract: DolibarrContract
  bills: Array<DolibarrBill>
}

interface MobytUserStatus {
  organizationId: number
  active: boolean
  amount: number
  money: number
}

interface MercureEntityUpdate {
  iri: string
  operation: 'create' | 'delete' | 'update'
  data: any
}

interface sseState {
  connected: boolean
  events: Array<MercureEntityUpdate>
}