1160 lines
45 KiB
Vue
1160 lines
45 KiB
Vue
<template>
|
|
<main class="container mx-auto px-6 py-8">
|
|
<div class="max-w-5xl mx-auto">
|
|
<div class="flex flex-wrap items-center justify-between gap-3 mb-6">
|
|
<div>
|
|
<h1 class="text-2xl font-bold">
|
|
Nouvelle machine
|
|
</h1>
|
|
<p class="text-sm text-gray-500">
|
|
Renseignez les informations et la configuration avant de créer la machine.
|
|
</p>
|
|
</div>
|
|
<NuxtLink to="/machines" class="btn btn-ghost">
|
|
Annuler
|
|
</NuxtLink>
|
|
</div>
|
|
|
|
<form class="space-y-6" @submit.prevent="finalizeMachineCreation">
|
|
<div class="card bg-base-100 shadow-lg">
|
|
<div class="card-body space-y-6">
|
|
<div class="grid grid-cols-1 md:grid-cols-2 gap-4">
|
|
<div class="form-control">
|
|
<label class="label" for="machine-field-name">
|
|
<span class="label-text">Nom de la machine</span>
|
|
</label>
|
|
<input
|
|
id="machine-field-name"
|
|
v-model="newMachine.name"
|
|
type="text"
|
|
placeholder="Ex: Presse hydraulique #1"
|
|
class="input input-bordered"
|
|
required
|
|
>
|
|
</div>
|
|
|
|
<div class="form-control">
|
|
<label class="label" for="machine-field-site">
|
|
<span class="label-text">Site</span>
|
|
</label>
|
|
<select id="machine-field-site" v-model="newMachine.siteId" class="select select-bordered" required>
|
|
<option value="">
|
|
Sélectionner un site
|
|
</option>
|
|
<option v-for="site in sites" :key="site.id" :value="site.id">
|
|
{{ site.name }}
|
|
</option>
|
|
</select>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="grid grid-cols-1 md:grid-cols-2 gap-4">
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text">Type de machine</span>
|
|
</label>
|
|
<select v-model="newMachine.typeMachineId" class="select select-bordered" required>
|
|
<option value="">
|
|
Sélectionner un type
|
|
</option>
|
|
<option v-for="type in machineTypes" :key="type.id" :value="type.id">
|
|
{{ type.name }} ({{ type.category }})
|
|
</option>
|
|
</select>
|
|
</div>
|
|
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text">Référence</span>
|
|
</label>
|
|
<input
|
|
v-model="newMachine.reference"
|
|
type="text"
|
|
placeholder="Ex: PRESS-001"
|
|
class="input input-bordered"
|
|
>
|
|
</div>
|
|
</div>
|
|
|
|
<div v-if="selectedMachineType" class="p-4 bg-gray-50 rounded-lg space-y-2 text-sm">
|
|
<h4 class="font-semibold text-sm">
|
|
Structure du type sélectionné :
|
|
</h4>
|
|
<div class="flex flex-wrap gap-3">
|
|
<span class="inline-flex items-center gap-2">
|
|
<span class="font-medium">Familles de composants :</span>
|
|
<span class="badge badge-sm">{{ selectedMachineType.componentRequirements?.length || 0 }}</span>
|
|
</span>
|
|
<span class="inline-flex items-center gap-2">
|
|
<span class="font-medium">Groupes de pièces :</span>
|
|
<span class="badge badge-sm">{{ selectedMachineType.pieceRequirements?.length || 0 }}</span>
|
|
</span>
|
|
<span class="inline-flex items-center gap-2">
|
|
<span class="font-medium">Catégorie :</span>
|
|
<span class="badge badge-outline badge-sm">{{ selectedMachineType.category || 'N/A' }}</span>
|
|
</span>
|
|
</div>
|
|
<p
|
|
v-if="(selectedMachineType.componentRequirements?.length || 0) === 0 && (selectedMachineType.pieceRequirements?.length || 0) === 0"
|
|
class="text-xs text-gray-500"
|
|
>
|
|
Ce type n'a pas encore de familles configurées. La machine héritera de la structure legacy du type.
|
|
</p>
|
|
</div>
|
|
|
|
<div v-if="selectedMachineType?.componentRequirements?.length" class="space-y-4">
|
|
<h4 class="text-sm font-semibold">
|
|
Sélection des composants
|
|
</h4>
|
|
|
|
<div
|
|
v-for="requirement in selectedMachineType.componentRequirements"
|
|
:id="`component-group-${requirement.id}`"
|
|
:key="requirement.id"
|
|
class="border border-base-200 rounded-lg p-4 space-y-3"
|
|
>
|
|
<div class="flex flex-wrap items-start justify-between gap-3">
|
|
<div>
|
|
<h5 class="font-medium text-sm">
|
|
{{ requirement.label || requirement.typeComposant?.name || 'Famille de composants' }}
|
|
</h5>
|
|
<p class="text-xs text-gray-500">
|
|
Type : {{ requirement.typeComposant?.name || 'Non défini' }} · Min : {{ requirement.minCount ?? (requirement.required ? 1 : 0) }}
|
|
· Max : {{ requirement.maxCount ?? '∞' }}
|
|
</p>
|
|
</div>
|
|
|
|
<button
|
|
type="button"
|
|
class="btn btn-sm btn-outline"
|
|
:disabled="requirement.maxCount !== null && getComponentRequirementEntries(requirement.id).length >= requirement.maxCount"
|
|
@click="addComponentSelectionEntry(requirement)"
|
|
>
|
|
<IconLucidePlus class="w-4 h-4 mr-2" aria-hidden="true" />
|
|
Ajouter
|
|
</button>
|
|
</div>
|
|
|
|
<div v-if="getComponentRequirementEntries(requirement.id).length === 0" class="text-xs text-gray-500">
|
|
Aucun composant sélectionné pour ce groupe.
|
|
</div>
|
|
|
|
<div
|
|
v-for="(entry, entryIndex) in getComponentRequirementEntries(requirement.id)"
|
|
:key="`${requirement.id}-${entryIndex}`"
|
|
class="bg-base-200/60 rounded-md p-3 space-y-4"
|
|
>
|
|
<div class="flex flex-wrap items-center justify-between gap-2 text-xs text-gray-500">
|
|
<span>
|
|
Type appliqué :
|
|
{{ resolveComponentRequirementTypeLabel(requirement, entry) }}
|
|
</span>
|
|
<button
|
|
type="button"
|
|
class="btn btn-square btn-xs btn-error"
|
|
@click="removeComponentSelectionEntry(requirement.id, entryIndex)"
|
|
>
|
|
<IconLucideX class="w-4 h-4" aria-hidden="true" />
|
|
</button>
|
|
</div>
|
|
|
|
<div class="grid grid-cols-1 md:grid-cols-2 gap-3">
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Nom du composant</span>
|
|
</label>
|
|
<input
|
|
v-model="entry.definition.name"
|
|
type="text"
|
|
class="input input-bordered input-sm"
|
|
placeholder="Nom du composant"
|
|
>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Référence (optionnel)</span>
|
|
</label>
|
|
<input
|
|
v-model="entry.definition.reference"
|
|
type="text"
|
|
class="input input-bordered input-sm"
|
|
placeholder="Référence du composant"
|
|
>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Constructeur (optionnel)</span>
|
|
</label>
|
|
<ConstructeurSelect
|
|
class="w-full"
|
|
:model-value="entry.definition.constructeurId || null"
|
|
placeholder="Sélectionner un constructeur"
|
|
@update:modelValue="(value) => setComponentRequirementConstructeur(requirement.id, entryIndex, value)"
|
|
/>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Prix (optionnel)</span>
|
|
</label>
|
|
<input
|
|
v-model.number="entry.definition.prix"
|
|
type="number"
|
|
min="0"
|
|
step="0.01"
|
|
class="input input-bordered input-sm"
|
|
placeholder="0.00"
|
|
>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div v-if="selectedMachineType?.pieceRequirements?.length" class="space-y-4">
|
|
<h4 class="text-sm font-semibold">
|
|
Sélection des pièces principales
|
|
</h4>
|
|
|
|
<div
|
|
v-for="requirement in selectedMachineType.pieceRequirements"
|
|
:id="`piece-group-${requirement.id}`"
|
|
:key="requirement.id"
|
|
class="border border-base-200 rounded-lg p-4 space-y-3"
|
|
>
|
|
<div class="flex flex-wrap items-start justify-between gap-3">
|
|
<div>
|
|
<h5 class="font-medium text-sm">
|
|
{{ requirement.label || requirement.typePiece?.name || 'Groupe de pièces' }}
|
|
</h5>
|
|
<p class="text-xs text-gray-500">
|
|
Type : {{ requirement.typePiece?.name || 'Non défini' }} · Min : {{ requirement.minCount ?? (requirement.required ? 1 : 0) }}
|
|
· Max : {{ requirement.maxCount ?? '∞' }}
|
|
</p>
|
|
</div>
|
|
|
|
<button
|
|
type="button"
|
|
class="btn btn-sm btn-outline"
|
|
:disabled="requirement.maxCount !== null && getPieceRequirementEntries(requirement.id).length >= requirement.maxCount"
|
|
@click="addPieceSelectionEntry(requirement)"
|
|
>
|
|
<IconLucidePlus class="w-4 h-4 mr-2" aria-hidden="true" />
|
|
Ajouter
|
|
</button>
|
|
</div>
|
|
|
|
<div v-if="getPieceRequirementEntries(requirement.id).length === 0" class="text-xs text-gray-500">
|
|
Aucune pièce sélectionnée pour ce groupe.
|
|
</div>
|
|
|
|
<div
|
|
v-for="(entry, entryIndex) in getPieceRequirementEntries(requirement.id)"
|
|
:key="`${requirement.id}-piece-${entryIndex}`"
|
|
class="bg-base-200/60 rounded-md p-3 space-y-4"
|
|
>
|
|
<div class="flex flex-wrap items-center justify-between gap-2 text-xs text-gray-500">
|
|
<span>
|
|
Type appliqué :
|
|
{{ resolvePieceRequirementTypeLabel(requirement, entry) }}
|
|
</span>
|
|
<button
|
|
type="button"
|
|
class="btn btn-square btn-xs btn-error"
|
|
@click="removePieceSelectionEntry(requirement.id, entryIndex)"
|
|
>
|
|
<IconLucideX class="w-4 h-4" aria-hidden="true" />
|
|
</button>
|
|
</div>
|
|
|
|
<div class="grid grid-cols-1 md:grid-cols-2 gap-3">
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Nom de la pièce</span>
|
|
</label>
|
|
<input
|
|
v-model="entry.definition.name"
|
|
type="text"
|
|
class="input input-bordered input-sm"
|
|
placeholder="Nom de la pièce"
|
|
>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Référence (optionnel)</span>
|
|
</label>
|
|
<input
|
|
v-model="entry.definition.reference"
|
|
type="text"
|
|
class="input input-bordered input-sm"
|
|
placeholder="Référence de la pièce"
|
|
>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Constructeur (optionnel)</span>
|
|
</label>
|
|
<ConstructeurSelect
|
|
class="w-full"
|
|
:model-value="entry.definition.constructeurId || null"
|
|
placeholder="Sélectionner un constructeur"
|
|
@update:modelValue="(value) => setPieceRequirementConstructeur(requirement.id, entryIndex, value)"
|
|
/>
|
|
</div>
|
|
<div class="form-control">
|
|
<label class="label">
|
|
<span class="label-text text-xs">Prix (optionnel)</span>
|
|
</label>
|
|
<input
|
|
v-model.number="entry.definition.prix"
|
|
type="number"
|
|
min="0"
|
|
step="0.01"
|
|
class="input input-bordered input-sm"
|
|
placeholder="0.00"
|
|
>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
<div v-if="machinePreview" class="space-y-4">
|
|
<div class="border border-base-200 rounded-lg bg-base-100/80">
|
|
<div class="p-4 space-y-4">
|
|
<div class="flex items-center justify-between gap-3">
|
|
<div class="flex items-center gap-2 text-sm font-semibold text-gray-700">
|
|
<IconLucideEye class="w-4 h-4" aria-hidden="true" />
|
|
<span>Prévisualisation avant création</span>
|
|
</div>
|
|
<span class="badge" :class="getStatusBadgeClass(machinePreview.status)">
|
|
{{ machinePreview.status === 'ready' ? 'Prête à créer' : machinePreview.status === 'warning' ? 'À compléter' : 'Bloquante' }}
|
|
</span>
|
|
</div>
|
|
|
|
<div class="grid grid-cols-1 md:grid-cols-2 gap-3">
|
|
<div
|
|
v-for="field in machinePreview.base.fields"
|
|
:key="field.key"
|
|
class="flex flex-col gap-1"
|
|
>
|
|
<span class="text-[11px] uppercase tracking-wide text-gray-500">{{ field.label }}</span>
|
|
<span
|
|
class="text-sm font-medium"
|
|
:class="field.status === 'missing'
|
|
? 'text-error'
|
|
: field.status === 'optional'
|
|
? 'text-gray-500 italic'
|
|
: 'text-gray-900'"
|
|
>
|
|
{{ field.display }}
|
|
</span>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="flex flex-wrap gap-2 text-xs text-gray-500">
|
|
<span class="badge badge-ghost badge-sm">Type : {{ machinePreview.type.name }}</span>
|
|
<span v-if="machinePreview.type.category" class="badge badge-ghost badge-sm">Catégorie : {{ machinePreview.type.category }}</span>
|
|
<span class="badge badge-ghost badge-sm">Structure JSON : {{ machinePreview.type.hasStructuredDefinition ? 'Oui' : 'Legacy' }}</span>
|
|
</div>
|
|
|
|
<div v-if="machinePreview.base.issues.length" class="rounded-md bg-warning/10 border border-warning/30 p-3 text-xs text-warning">
|
|
<p class="font-medium mb-1">
|
|
Informations générales incomplètes :
|
|
</p>
|
|
<ul class="space-y-1">
|
|
<li v-for="issue in machinePreview.base.issues" :key="issue.message">
|
|
<button
|
|
type="button"
|
|
class="flex w-full items-start gap-2 text-left hover:underline"
|
|
@click="handleIssueClick(issue)"
|
|
>
|
|
<span class="mt-0.5 text-[8px] leading-none">•</span>
|
|
<span>{{ issue.message }}</span>
|
|
</button>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<div v-if="machinePreview.componentGroups.length" class="space-y-3">
|
|
<h5 class="text-xs font-semibold uppercase tracking-wide text-gray-500">
|
|
Composants hérités
|
|
</h5>
|
|
<div
|
|
v-for="group in machinePreview.componentGroups"
|
|
:key="group.id"
|
|
class="border border-base-200 rounded-md p-3 space-y-3"
|
|
>
|
|
<div class="flex flex-wrap items-start justify-between gap-2">
|
|
<div>
|
|
<p class="text-sm font-semibold">
|
|
{{ group.label }}
|
|
</p>
|
|
<p class="text-xs text-gray-500">
|
|
Type : {{ group.typeName }} · Min {{ group.min }} ·
|
|
{{ group.max !== null ? `Max ${group.max}` : 'Max ∞' }}
|
|
</p>
|
|
</div>
|
|
<span class="badge badge-sm" :class="getStatusBadgeClass(group.status)">
|
|
{{ group.completed }} / {{ group.total || 0 }} complétée(s)
|
|
</span>
|
|
</div>
|
|
|
|
<div v-if="group.issues.length" class="rounded bg-warning/10 border border-warning/30 p-2 text-[11px] text-warning">
|
|
<ul class="list-disc pl-4 space-y-1">
|
|
<li v-for="issue in group.issues" :key="issue.message">
|
|
{{ issue.message }}
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<ul class="space-y-2">
|
|
<li
|
|
v-for="entry in group.entries"
|
|
:key="entry.key"
|
|
class="flex items-start gap-3"
|
|
>
|
|
<component
|
|
:is="entry.status === 'complete' ? IconLucideCheckCircle2 : IconLucideCircle"
|
|
class="w-4 h-4 mt-0.5"
|
|
:class="entry.status === 'complete' ? 'text-success' : 'text-gray-400'"
|
|
aria-hidden="true"
|
|
/>
|
|
<div class="flex-1">
|
|
<p class="text-sm font-medium" :class="entry.status === 'complete' ? 'text-gray-900' : 'text-gray-500'">
|
|
{{ entry.title }}
|
|
</p>
|
|
<p v-if="entry.subtitle" class="text-xs text-gray-500">
|
|
{{ entry.subtitle }}
|
|
</p>
|
|
</div>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
|
|
<div v-else class="text-xs text-gray-500">
|
|
Aucun composant n'est requis pour ce type de machine.
|
|
</div>
|
|
|
|
<div v-if="machinePreview.pieceGroups.length" class="space-y-3">
|
|
<h5 class="text-xs font-semibold uppercase tracking-wide text-gray-500">
|
|
Pièces associées
|
|
</h5>
|
|
<div
|
|
v-for="group in machinePreview.pieceGroups"
|
|
:key="group.id"
|
|
class="border border-base-200 rounded-md p-3 space-y-3"
|
|
>
|
|
<div class="flex flex-wrap items-start justify-between gap-2">
|
|
<div>
|
|
<p class="text-sm font-semibold">
|
|
{{ group.label }}
|
|
</p>
|
|
<p class="text-xs text-gray-500">
|
|
Type : {{ group.typeName }} · Min {{ group.min }} ·
|
|
{{ group.max !== null ? `Max ${group.max}` : 'Max ∞' }}
|
|
</p>
|
|
</div>
|
|
<span class="badge badge-sm" :class="getStatusBadgeClass(group.status)">
|
|
{{ group.completed }} / {{ group.total || 0 }} complétée(s)
|
|
</span>
|
|
</div>
|
|
|
|
<div v-if="group.issues.length" class="rounded bg-warning/10 border border-warning/30 p-2 text-[11px] text-warning">
|
|
<ul class="list-disc pl-4 space-y-1">
|
|
<li v-for="issue in group.issues" :key="issue.message">
|
|
{{ issue.message }}
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
|
|
<ul class="space-y-2">
|
|
<li
|
|
v-for="entry in group.entries"
|
|
:key="entry.key"
|
|
class="flex items-start gap-3"
|
|
>
|
|
<component
|
|
:is="entry.status === 'complete' ? IconLucideCheckCircle2 : IconLucideCircle"
|
|
class="w-4 h-4 mt-0.5"
|
|
:class="entry.status === 'complete' ? 'text-success' : 'text-gray-400'"
|
|
aria-hidden="true"
|
|
/>
|
|
<div class="flex-1">
|
|
<p class="text-sm font-medium" :class="entry.status === 'complete' ? 'text-gray-900' : 'text-gray-500'">
|
|
{{ entry.title }}
|
|
</p>
|
|
<p v-if="entry.subtitle" class="text-xs text-gray-500">
|
|
{{ entry.subtitle }}
|
|
</p>
|
|
</div>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
|
|
<div v-else class="text-xs text-gray-500">
|
|
Aucun groupe de pièces à configurer pour ce type.
|
|
</div>
|
|
|
|
<div
|
|
v-if="machinePreview.issues.length && machinePreview.status !== 'ready'"
|
|
class="rounded-md border border-warning/30 bg-warning/10 p-3 text-xs text-warning"
|
|
>
|
|
<div class="flex items-start gap-2">
|
|
<IconLucideAlertTriangle class="w-4 h-4 mt-0.5" aria-hidden="true" />
|
|
<div class="space-y-1">
|
|
<p class="font-medium">
|
|
Points à vérifier avant la création :
|
|
</p>
|
|
<ul class="space-y-1">
|
|
<li v-for="issue in machinePreview.issues" :key="`${issue.scope}-${issue.message}`">
|
|
<button
|
|
type="button"
|
|
class="flex w-full items-start gap-2 text-left hover:underline"
|
|
@click="handleIssueClick(issue)"
|
|
>
|
|
<span class="mt-0.5 text-[8px] leading-none">•</span>
|
|
<span>
|
|
<span class="font-medium">{{ issue.scope }} :</span> {{ issue.message }}
|
|
</span>
|
|
</button>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div
|
|
v-if="blockingPreviewIssues.length"
|
|
class="text-xs text-error bg-error/10 border border-error/20 rounded-md px-3 py-2"
|
|
>
|
|
Compléter les informations bloquantes avant de créer la machine.
|
|
</div>
|
|
|
|
<div class="flex justify-end gap-3 pt-4 border-t border-base-200">
|
|
<NuxtLink to="/machines" class="btn btn-outline">
|
|
Annuler
|
|
</NuxtLink>
|
|
<button
|
|
type="submit"
|
|
class="btn btn-primary"
|
|
:disabled="!canCreateMachine || submitting"
|
|
:class="{ loading: submitting }"
|
|
>
|
|
Créer la machine
|
|
</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
</form>
|
|
</div>
|
|
</main>
|
|
</template>
|
|
|
|
<script setup>
|
|
import { ref, reactive, computed, watch, onMounted } from 'vue'
|
|
import ConstructeurSelect from '~/components/ConstructeurSelect.vue'
|
|
import { useMachines } from '~/composables/useMachines'
|
|
import { useSites } from '~/composables/useSites'
|
|
import { useMachineTypesApi } from '~/composables/useMachineTypesApi'
|
|
import { useToast } from '~/composables/useToast'
|
|
import { sanitizeDefinitionOverrides } from '~/shared/modelUtils'
|
|
import IconLucidePlus from '~icons/lucide/plus'
|
|
import IconLucideX from '~icons/lucide/x'
|
|
import IconLucideEye from '~icons/lucide/eye'
|
|
import IconLucideAlertTriangle from '~icons/lucide/alert-triangle'
|
|
import IconLucideCheckCircle2 from '~icons/lucide/check-circle-2'
|
|
import IconLucideCircle from '~icons/lucide/circle'
|
|
|
|
const { createMachine, createMachineFromType } = useMachines()
|
|
const { sites, loadSites } = useSites()
|
|
const { machineTypes, loadMachineTypes } = useMachineTypesApi()
|
|
const toast = useToast()
|
|
|
|
const submitting = ref(false)
|
|
|
|
const newMachine = reactive({
|
|
name: '',
|
|
siteId: '',
|
|
typeMachineId: '',
|
|
reference: ''
|
|
})
|
|
|
|
const componentRequirementSelections = reactive({})
|
|
const pieceRequirementSelections = reactive({})
|
|
|
|
const selectedMachineType = computed(() => {
|
|
if (!newMachine.typeMachineId) {
|
|
return null
|
|
}
|
|
return machineTypes.value.find(type => type.id === newMachine.typeMachineId) || null
|
|
})
|
|
|
|
const getStatusBadgeClass = (status) => {
|
|
if (status === 'ready') {
|
|
return 'badge-success'
|
|
}
|
|
if (status === 'warning') {
|
|
return 'badge-warning'
|
|
}
|
|
return 'badge-error'
|
|
}
|
|
|
|
const resolveComponentRequirementTypeLabel = (requirement, entry) => {
|
|
const typeId = entry?.typeComposantId || requirement?.typeComposantId || null
|
|
if (!typeId) {
|
|
return requirement?.typeComposant?.name || 'Type non défini'
|
|
}
|
|
return requirement?.typeComposant?.name || 'Type non défini'
|
|
}
|
|
|
|
const resolvePieceRequirementTypeLabel = (requirement, entry) => {
|
|
const typeId = entry?.typePieceId || requirement?.typePieceId || null
|
|
if (!typeId) {
|
|
return requirement?.typePiece?.name || 'Type non défini'
|
|
}
|
|
return requirement?.typePiece?.name || 'Type non défini'
|
|
}
|
|
|
|
const getComponentRequirementEntries = requirementId => componentRequirementSelections[requirementId] || []
|
|
const getPieceRequirementEntries = requirementId => pieceRequirementSelections[requirementId] || []
|
|
|
|
const createComponentSelectionEntry = (requirement, source = null) => ({
|
|
typeComposantId: source?.typeComposantId
|
|
|| source?.typeComposant?.id
|
|
|| requirement?.typeComposantId
|
|
|| null,
|
|
definition: {
|
|
name:
|
|
(typeof source?.name === 'string' ? source.name : null)
|
|
|| requirement?.typeComposant?.name
|
|
|| '',
|
|
reference: source?.reference || '',
|
|
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
|
|
prix: source?.prix ?? source?.price ?? null,
|
|
},
|
|
})
|
|
|
|
const createPieceSelectionEntry = (requirement, source = null) => ({
|
|
typePieceId: source?.typePieceId
|
|
|| source?.typePiece?.id
|
|
|| requirement?.typePieceId
|
|
|| null,
|
|
definition: {
|
|
name:
|
|
(typeof source?.name === 'string' ? source.name : null)
|
|
|| requirement?.typePiece?.name
|
|
|| '',
|
|
reference: source?.reference || '',
|
|
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
|
|
prix: source?.prix ?? source?.price ?? null,
|
|
},
|
|
})
|
|
|
|
const clearRequirementSelections = () => {
|
|
Object.keys(componentRequirementSelections).forEach((key) => {
|
|
delete componentRequirementSelections[key]
|
|
})
|
|
Object.keys(pieceRequirementSelections).forEach((key) => {
|
|
delete pieceRequirementSelections[key]
|
|
})
|
|
}
|
|
|
|
const addComponentSelectionEntry = (requirement) => {
|
|
const entries = getComponentRequirementEntries(requirement.id)
|
|
const max = requirement.maxCount ?? null
|
|
if (max !== null && entries.length >= max) {
|
|
toast.showError(`Vous ne pouvez pas ajouter plus de ${max} composant(s) pour ${requirement.label || requirement.typeComposant?.name || 'ce groupe'}`)
|
|
return
|
|
}
|
|
componentRequirementSelections[requirement.id] = [
|
|
...entries,
|
|
createComponentSelectionEntry(requirement),
|
|
]
|
|
}
|
|
|
|
const removeComponentSelectionEntry = (requirementId, index) => {
|
|
const entries = getComponentRequirementEntries(requirementId)
|
|
componentRequirementSelections[requirementId] = entries.filter((_, i) => i !== index)
|
|
}
|
|
|
|
const setComponentRequirementConstructeur = (requirementId, index, value) => {
|
|
const entries = getComponentRequirementEntries(requirementId)
|
|
const entry = entries[index]
|
|
if (!entry) return
|
|
entry.definition.constructeurId = value || null
|
|
}
|
|
|
|
const addPieceSelectionEntry = (requirement) => {
|
|
const entries = getPieceRequirementEntries(requirement.id)
|
|
const max = requirement.maxCount ?? null
|
|
if (max !== null && entries.length >= max) {
|
|
toast.showError(`Vous ne pouvez pas ajouter plus de ${max} pièce(s) pour ${requirement.label || requirement.typePiece?.name || 'ce groupe'}`)
|
|
return
|
|
}
|
|
pieceRequirementSelections[requirement.id] = [
|
|
...entries,
|
|
createPieceSelectionEntry(requirement),
|
|
]
|
|
}
|
|
|
|
const removePieceSelectionEntry = (requirementId, index) => {
|
|
const entries = getPieceRequirementEntries(requirementId)
|
|
pieceRequirementSelections[requirementId] = entries.filter((_, i) => i !== index)
|
|
}
|
|
|
|
const setPieceRequirementConstructeur = (requirementId, index, value) => {
|
|
const entries = getPieceRequirementEntries(requirementId)
|
|
const entry = entries[index]
|
|
if (!entry) return
|
|
entry.definition.constructeurId = value || null
|
|
}
|
|
|
|
const validateRequirementSelections = (type) => {
|
|
const errors = []
|
|
const componentSelectionsPayload = []
|
|
const pieceSelectionsPayload = []
|
|
|
|
for (const requirement of type.componentRequirements || []) {
|
|
const entries = getComponentRequirementEntries(requirement.id)
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const max = requirement.maxCount ?? null
|
|
|
|
if (entries.length < min) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typeComposant?.name || 'Composants'}" nécessite au moins ${min} élément(s).`)
|
|
}
|
|
|
|
if (max !== null && entries.length > max) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typeComposant?.name || 'Composants'}" ne peut dépasser ${max} élément(s).`)
|
|
}
|
|
|
|
entries.forEach((entry) => {
|
|
const resolvedTypeId = entry.typeComposantId || requirement.typeComposantId || null
|
|
if (!resolvedTypeId) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typeComposant?.name || 'Composants'}" nécessite un type de composant.`)
|
|
return
|
|
}
|
|
|
|
const payload = { requirementId: requirement.id }
|
|
if (entry.typeComposantId && entry.typeComposantId !== requirement.typeComposantId) {
|
|
payload.typeComposantId = entry.typeComposantId
|
|
}
|
|
|
|
const overrides = sanitizeDefinitionOverrides(entry.definition)
|
|
if (overrides) {
|
|
payload.definition = overrides
|
|
}
|
|
|
|
componentSelectionsPayload.push(payload)
|
|
})
|
|
}
|
|
|
|
for (const requirement of type.pieceRequirements || []) {
|
|
const entries = getPieceRequirementEntries(requirement.id)
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const max = requirement.maxCount ?? null
|
|
|
|
if (entries.length < min) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typePiece?.name || 'Pièces'}" nécessite au moins ${min} élément(s).`)
|
|
}
|
|
|
|
if (max !== null && entries.length > max) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typePiece?.name || 'Pièces'}" ne peut dépasser ${max} élément(s).`)
|
|
}
|
|
|
|
entries.forEach((entry) => {
|
|
const resolvedTypeId = entry.typePieceId || requirement.typePieceId || null
|
|
if (!resolvedTypeId) {
|
|
errors.push(`Le groupe "${requirement.label || requirement.typePiece?.name || 'Pièces'}" nécessite un type de pièce.`)
|
|
return
|
|
}
|
|
|
|
const payload = { requirementId: requirement.id }
|
|
if (entry.typePieceId && entry.typePieceId !== requirement.typePieceId) {
|
|
payload.typePieceId = entry.typePieceId
|
|
}
|
|
|
|
const overrides = sanitizeDefinitionOverrides(entry.definition)
|
|
if (overrides) {
|
|
payload.definition = overrides
|
|
}
|
|
|
|
pieceSelectionsPayload.push(payload)
|
|
})
|
|
}
|
|
|
|
if (errors.length > 0) {
|
|
return { valid: false, error: errors[0] }
|
|
}
|
|
|
|
return {
|
|
valid: true,
|
|
componentSelections: componentSelectionsPayload,
|
|
pieceSelections: pieceSelectionsPayload,
|
|
}
|
|
}
|
|
|
|
const machinePreview = computed(() => {
|
|
const type = selectedMachineType.value
|
|
if (!type) {
|
|
return null
|
|
}
|
|
|
|
const trimmedName = (newMachine.name || '').trim()
|
|
const currentSite = newMachine.siteId
|
|
? sites.value.find(site => site.id === newMachine.siteId) || null
|
|
: null
|
|
const trimmedReference = (newMachine.reference || '').trim()
|
|
|
|
const baseFields = [
|
|
{
|
|
key: 'name',
|
|
label: 'Nom',
|
|
display: trimmedName || 'À renseigner',
|
|
status: trimmedName ? 'complete' : 'missing'
|
|
},
|
|
{
|
|
key: 'site',
|
|
label: 'Site',
|
|
display: currentSite?.name || 'Sélectionner un site',
|
|
status: currentSite ? 'complete' : 'missing'
|
|
},
|
|
{
|
|
key: 'type',
|
|
label: 'Type sélectionné',
|
|
display: type.name,
|
|
status: 'complete'
|
|
},
|
|
{
|
|
key: 'reference',
|
|
label: 'Référence',
|
|
display: trimmedReference || 'Non renseignée',
|
|
status: trimmedReference ? 'complete' : 'optional'
|
|
}
|
|
]
|
|
|
|
const baseIssues = []
|
|
if (!trimmedName) {
|
|
baseIssues.push({ message: 'Renseigner un nom de machine.', kind: 'error', anchor: 'machine-field-name' })
|
|
}
|
|
if (!currentSite) {
|
|
baseIssues.push({ message: "Sélectionner un site d'affectation.", kind: 'error', anchor: 'machine-field-site' })
|
|
}
|
|
|
|
const baseStatus = baseIssues.some(issue => issue.kind === 'error') ? 'error' : 'ready'
|
|
|
|
const componentGroups = (type.componentRequirements || []).map((requirement) => {
|
|
const entries = getComponentRequirementEntries(requirement.id)
|
|
const normalizedEntries = entries.map((entry, index) => {
|
|
const overrides = sanitizeDefinitionOverrides(entry.definition)
|
|
const fallbackName = requirement.typeComposant?.name || 'Composant'
|
|
const rawName = typeof entry.definition?.name === 'string' ? entry.definition.name.trim() : ''
|
|
const displayName = overrides?.name || rawName || fallbackName
|
|
|
|
const subtitleParts = []
|
|
if (overrides?.reference) {
|
|
subtitleParts.push(`Réf. ${overrides.reference}`)
|
|
}
|
|
const status = entry.typeComposantId || requirement.typeComposantId ? 'complete' : 'pending'
|
|
|
|
return {
|
|
key: `${requirement.id}-${index}`,
|
|
status,
|
|
title: displayName,
|
|
subtitle: subtitleParts.join(' • ') || null,
|
|
}
|
|
})
|
|
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const max = requirement.maxCount ?? null
|
|
const completed = normalizedEntries.filter(entry => entry.status === 'complete').length
|
|
const issues = []
|
|
|
|
if (entries.length < min) {
|
|
issues.push({ message: `Minimum ${min} sélection(s) requise(s)`, kind: 'error', anchor: `component-group-${requirement.id}` })
|
|
}
|
|
|
|
if (max !== null && entries.length > max) {
|
|
issues.push({ message: `Maximum ${max} dépassé`, kind: 'error', anchor: `component-group-${requirement.id}` })
|
|
}
|
|
|
|
if (normalizedEntries.some(entry => entry.status !== 'complete')) {
|
|
issues.push({ message: 'Sélectionner un type pour chaque composant.', kind: 'error', anchor: `component-group-${requirement.id}` })
|
|
}
|
|
|
|
const status = issues.some(issue => issue.kind === 'error')
|
|
? 'error'
|
|
: completed < entries.length
|
|
? 'warning'
|
|
: 'ready'
|
|
|
|
return {
|
|
id: requirement.id,
|
|
label: requirement.label || requirement.typeComposant?.name || 'Famille de composants',
|
|
typeName: requirement.typeComposant?.name || 'Non défini',
|
|
min,
|
|
max,
|
|
entries: normalizedEntries,
|
|
issues,
|
|
completed,
|
|
total: entries.length,
|
|
status
|
|
}
|
|
})
|
|
|
|
const pieceGroups = (type.pieceRequirements || []).map((requirement) => {
|
|
const entries = getPieceRequirementEntries(requirement.id)
|
|
const normalizedEntries = entries.map((entry, index) => {
|
|
const overrides = sanitizeDefinitionOverrides(entry.definition)
|
|
const fallbackName = requirement.typePiece?.name || 'Pièce'
|
|
const rawName = typeof entry.definition?.name === 'string' ? entry.definition.name.trim() : ''
|
|
const displayName = overrides?.name || rawName || fallbackName
|
|
|
|
const subtitleParts = []
|
|
if (overrides?.reference) {
|
|
subtitleParts.push(`Réf. ${overrides.reference}`)
|
|
}
|
|
const status = entry.typePieceId || requirement.typePieceId ? 'complete' : 'pending'
|
|
|
|
return {
|
|
key: `${requirement.id}-${index}`,
|
|
status,
|
|
title: displayName,
|
|
subtitle: subtitleParts.join(' • ') || null,
|
|
}
|
|
})
|
|
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const max = requirement.maxCount ?? null
|
|
const completed = normalizedEntries.filter(entry => entry.status === 'complete').length
|
|
const issues = []
|
|
|
|
if (entries.length < min) {
|
|
issues.push({ message: `Minimum ${min} sélection(s) requise(s)`, kind: 'error', anchor: `piece-group-${requirement.id}` })
|
|
}
|
|
|
|
if (max !== null && entries.length > max) {
|
|
issues.push({ message: `Maximum ${max} dépassé`, kind: 'error', anchor: `piece-group-${requirement.id}` })
|
|
}
|
|
|
|
if (normalizedEntries.some(entry => entry.status !== 'complete')) {
|
|
issues.push({ message: 'Sélectionner un type pour chaque pièce.', kind: 'error', anchor: `piece-group-${requirement.id}` })
|
|
}
|
|
|
|
const status = issues.some(issue => issue.kind === 'error')
|
|
? 'error'
|
|
: completed < entries.length
|
|
? 'warning'
|
|
: 'ready'
|
|
|
|
return {
|
|
id: requirement.id,
|
|
label: requirement.label || requirement.typePiece?.name || 'Groupe de pièces',
|
|
typeName: requirement.typePiece?.name || 'Non défini',
|
|
min,
|
|
max,
|
|
entries: normalizedEntries,
|
|
issues,
|
|
completed,
|
|
total: entries.length,
|
|
status
|
|
}
|
|
})
|
|
|
|
const aggregatedIssues = [
|
|
...baseIssues.map(issue => ({ ...issue, scope: 'Informations générales' })),
|
|
...componentGroups.flatMap(group => group.issues.map(issue => ({ ...issue, scope: group.label }))),
|
|
...pieceGroups.flatMap(group => group.issues.map(issue => ({ ...issue, scope: group.label })))
|
|
]
|
|
|
|
const statuses = [
|
|
baseStatus,
|
|
...componentGroups.map(group => group.status),
|
|
...pieceGroups.map(group => group.status)
|
|
]
|
|
|
|
const overallStatus = statuses.includes('error')
|
|
? 'error'
|
|
: statuses.includes('warning')
|
|
? 'warning'
|
|
: 'ready'
|
|
|
|
return {
|
|
base: {
|
|
fields: baseFields,
|
|
issues: baseIssues,
|
|
status: baseStatus
|
|
},
|
|
componentGroups,
|
|
pieceGroups,
|
|
type: {
|
|
name: type.name,
|
|
category: type.category || null,
|
|
hasStructuredDefinition:
|
|
(type.componentRequirements?.length || 0) > 0 || (type.pieceRequirements?.length || 0) > 0
|
|
},
|
|
status: overallStatus,
|
|
ready: overallStatus === 'ready',
|
|
issues: aggregatedIssues
|
|
}
|
|
})
|
|
|
|
const blockingPreviewIssues = computed(() => {
|
|
if (!machinePreview.value) {
|
|
return []
|
|
}
|
|
return machinePreview.value.issues.filter(issue => issue.kind === 'error')
|
|
})
|
|
|
|
const canCreateMachine = computed(() => {
|
|
if (!machinePreview.value) {
|
|
return false
|
|
}
|
|
return blockingPreviewIssues.value.length === 0
|
|
})
|
|
|
|
const highlightClasses = ['ring', 'ring-primary', 'ring-offset-2']
|
|
|
|
const scrollToAnchor = (anchor) => {
|
|
if (!anchor || typeof window === 'undefined' || typeof document === 'undefined') {
|
|
return
|
|
}
|
|
const target = document.getElementById(anchor)
|
|
if (!target) {
|
|
return
|
|
}
|
|
target.scrollIntoView({ behavior: 'smooth', block: 'center' })
|
|
highlightClasses.forEach(cls => target.classList.add(cls))
|
|
window.setTimeout(() => {
|
|
highlightClasses.forEach(cls => target.classList.remove(cls))
|
|
}, 1500)
|
|
}
|
|
|
|
const handleIssueClick = (issue) => {
|
|
if (!issue?.anchor) {
|
|
return
|
|
}
|
|
scrollToAnchor(issue.anchor)
|
|
}
|
|
|
|
const initializeRequirementSelections = (type) => {
|
|
const componentRequirements = type.componentRequirements || []
|
|
const pieceRequirements = type.pieceRequirements || []
|
|
|
|
componentRequirements.forEach((requirement) => {
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const initialCount = Math.max(min, requirement.required ? 1 : 0)
|
|
if (initialCount > 0) {
|
|
componentRequirementSelections[requirement.id] = Array.from({ length: initialCount }, () => createComponentSelectionEntry(requirement))
|
|
} else {
|
|
componentRequirementSelections[requirement.id] = []
|
|
}
|
|
})
|
|
|
|
pieceRequirements.forEach((requirement) => {
|
|
const min = requirement.minCount ?? (requirement.required ? 1 : 0)
|
|
const initialCount = Math.max(min, requirement.required ? 1 : 0)
|
|
if (initialCount > 0) {
|
|
pieceRequirementSelections[requirement.id] = Array.from({ length: initialCount }, () => createPieceSelectionEntry(requirement))
|
|
} else {
|
|
pieceRequirementSelections[requirement.id] = []
|
|
}
|
|
})
|
|
}
|
|
|
|
const finalizeMachineCreation = async () => {
|
|
if (submitting.value) {
|
|
return
|
|
}
|
|
const type = selectedMachineType.value
|
|
if (!type) {
|
|
toast.showError('Merci de sélectionner un type de machine')
|
|
return
|
|
}
|
|
if (!canCreateMachine.value) {
|
|
toast.showError('Compléter les informations obligatoires avant de créer la machine')
|
|
return
|
|
}
|
|
|
|
submitting.value = true
|
|
try {
|
|
const baseMachineData = {
|
|
name: newMachine.name,
|
|
siteId: newMachine.siteId,
|
|
reference: newMachine.reference,
|
|
typeMachineId: type.id
|
|
}
|
|
|
|
const hasRequirements = (type.componentRequirements?.length || 0) > 0 || (type.pieceRequirements?.length || 0) > 0
|
|
|
|
let componentSelections = []
|
|
let pieceSelections = []
|
|
|
|
if (hasRequirements) {
|
|
const validationResult = validateRequirementSelections(type)
|
|
if (!validationResult.valid) {
|
|
toast.showError(validationResult.error)
|
|
return
|
|
}
|
|
componentSelections = validationResult.componentSelections
|
|
pieceSelections = validationResult.pieceSelections
|
|
}
|
|
|
|
const payload = {
|
|
...baseMachineData,
|
|
...(hasRequirements
|
|
? {
|
|
componentSelections,
|
|
pieceSelections
|
|
}
|
|
: {})
|
|
}
|
|
|
|
const result = hasRequirements
|
|
? await createMachine(payload)
|
|
: await createMachineFromType(baseMachineData, type)
|
|
|
|
if (result.success) {
|
|
newMachine.name = ''
|
|
newMachine.siteId = ''
|
|
newMachine.typeMachineId = ''
|
|
newMachine.reference = ''
|
|
clearRequirementSelections()
|
|
await navigateTo('/machines')
|
|
} else if (result.error) {
|
|
toast.showError(`Impossible de créer la machine: ${result.error}`)
|
|
}
|
|
} catch (error) {
|
|
toast.showError(`Erreur lors de la création: ${error.message}`)
|
|
} finally {
|
|
submitting.value = false
|
|
}
|
|
}
|
|
|
|
watch(
|
|
() => newMachine.typeMachineId,
|
|
(typeId) => {
|
|
clearRequirementSelections()
|
|
if (!typeId) {
|
|
return
|
|
}
|
|
|
|
const type = machineTypes.value.find(item => item.id === typeId)
|
|
if (!type) {
|
|
return
|
|
}
|
|
|
|
initializeRequirementSelections(type)
|
|
}
|
|
)
|
|
|
|
onMounted(async () => {
|
|
await Promise.all([
|
|
loadSites(),
|
|
loadMachineTypes()
|
|
])
|
|
})
|
|
</script>
|