MALIO-DEV/Inventory
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Normalize machine link responses

Browse Source
This commit is contained in:
MatthieuTD
2025-10-09 09:21:40 +02:00
parent f89364d04e
commit 95c2a82689
3 changed files with 1028 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

709
app/pages/machine/[id].vue
View File

@@ -858,18 +858,17 @@ const {
updateMachine: updateMachineApi,
reconfigureSkeleton: reconfigureMachineSkeleton,
} = useMachines()
const {
getComposantsByMachine,
updateComposant: updateComposantApi
const {
updateComposant: updateComposantApi
} = useComposants()
const {
getPiecesByMachine,
updatePiece: updatePieceApi
} = usePieces()
const { componentTypes, loadComponentTypes } = useComponentTypes()
const { pieceTypes, loadPieceTypes } = usePieceTypes()
const { upsertCustomFieldValue, updateCustomFieldValue: updateCustomFieldValueApi } = useCustomFields()
const { get } = useApi()
const {
uploadDocuments,
deleteDocument,
@@ -884,6 +883,8 @@ const loading = ref(true)
const machine = ref(null)
const components = ref([])
const pieces = ref([])
const machineComponentLinks = ref([])
const machinePieceLinks = ref([])
const printAreaRef = ref(null)
const { constructeurs, loadConstructeurs } = useConstructeurs()
@@ -970,6 +971,67 @@ const pieceTypeLabelMap = computed(() => {
return map
})
const isPlainObject = (value) => Object.prototype.toString.call(value) === '[object Object]'
const resolveIdentifier = (...candidates) => {
for (const candidate of candidates) {
if (candidate !== undefined && candidate !== null && candidate !== '') {
return candidate
}
}
return null
}
const extractParentLinkIdentifiers = (source) => {
if (!source || typeof source !== 'object') {
return {}
}
const identifiers = {}
const idKeys = [
'parentRequirementId',
'parentComponentRequirementId',
'parentPieceRequirementId',
'parentMachineComponentRequirementId',
'parentMachinePieceRequirementId',
'parentLinkId',
'parentComponentLinkId',
'parentPieceLinkId',
'parentComponentId',
'parentPieceId',
]
idKeys.forEach((key) => {
if (Object.prototype.hasOwnProperty.call(source, key)) {
const value = source[key]
if (value !== undefined && value !== null && value !== '') {
identifiers[key] = value
}
}
})
const objectKeys = [
'parentRequirement',
'parentComponentRequirement',
'parentPieceRequirement',
'parentMachineComponentRequirement',
'parentMachinePieceRequirement',
]
objectKeys.forEach((key) => {
const value = source[key]
if (isPlainObject(value) && value.id !== undefined && value.id !== null && value.id !== '') {
const idKey = `${key}Id`
if (!Object.prototype.hasOwnProperty.call(identifiers, idKey)) {
identifiers[idKey] = value.id
}
}
})
return identifiers
}
const resolveComponentRequirementTypeLabel = (requirement, entry) => {
const typeId = entry?.typeComposantId || requirement?.typeComposantId || null
if (!typeId) {
@@ -994,47 +1056,126 @@ const getPieceRequirementEntries = (requirementId) => {
return pieceRequirementSelections[requirementId] || []
}
const createComponentSelectionEntry = (requirement, source = null) => ({
typeComposantId: source?.typeMachineComponentRequirement?.typeComposantId
|| source?.typeComposantId
|| source?.typeComposant?.id
|| requirement?.typeComposantId
|| null,
definition: {
name:
source?.name
|| source?.nom
|| requirement?.typeComposant?.name
|| '',
reference: source?.reference || '',
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
prix:
source?.prix
?? source?.price
?? null,
},
})
const createComponentSelectionEntry = (requirement, source = null) => {
const link = source?.machineComponentLink || null
const createPieceSelectionEntry = (requirement, source = null) => ({
typePieceId: source?.typeMachinePieceRequirement?.typePieceId
|| source?.typePieceId
|| source?.typePiece?.id
|| requirement?.typePieceId
|| null,
definition: {
name:
source?.name
|| source?.nom
|| requirement?.typePiece?.name
|| '',
reference: source?.reference || '',
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
prix:
source?.prix
?? source?.price
?? null,
},
})
const entry = {
linkId: resolveIdentifier(link?.id, source?.machineComponentLinkId, source?.linkId),
composantId: resolveIdentifier(source?.composantId, source?.componentId, source?.id),
parentLinkId: resolveIdentifier(
link?.parentLinkId,
link?.parentComponentLinkId,
source?.parentComponentLinkId,
source?.parentLinkId,
),
parentRequirementId: resolveIdentifier(
link?.parentRequirementId,
source?.parentRequirementId,
requirement?.parentRequirementId,
),
parentMachineComponentRequirementId: resolveIdentifier(
link?.parentMachineComponentRequirementId,
source?.parentMachineComponentRequirementId,
requirement?.parentMachineComponentRequirementId,
),
parentMachinePieceRequirementId: resolveIdentifier(
link?.parentMachinePieceRequirementId,
source?.parentMachinePieceRequirementId,
requirement?.parentMachinePieceRequirementId,
),
parentComponentId: resolveIdentifier(link?.parentComponentId, source?.parentComponentId),
parentPieceId: resolveIdentifier(link?.parentPieceId, source?.parentPieceId),
typeComposantId:
source?.typeMachineComponentRequirement?.typeComposantId
|| source?.typeComposantId
|| source?.typeComposant?.id
|| requirement?.typeComposantId
|| null,
definition: {
name:
source?.name
|| source?.nom
|| requirement?.typeComposant?.name
|| '',
reference: source?.reference || '',
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
prix:
source?.prix
?? source?.price
?? null,
},
}
if (link?.overrides && isPlainObject(link.overrides)) {
entry.definition = {
...entry.definition,
...link.overrides,
}
}
return entry
}
const createPieceSelectionEntry = (requirement, source = null) => {
const link = source?.machinePieceLink || null
const entry = {
linkId: resolveIdentifier(link?.id, source?.machinePieceLinkId, source?.linkId),
pieceId: resolveIdentifier(source?.pieceId, source?.id),
parentLinkId: resolveIdentifier(link?.parentLinkId, source?.parentLinkId),
parentComponentLinkId: resolveIdentifier(
link?.parentComponentLinkId,
source?.parentComponentLinkId,
source?.machineComponentLinkId,
),
parentRequirementId: resolveIdentifier(
link?.parentRequirementId,
source?.parentRequirementId,
requirement?.parentRequirementId,
),
parentMachineComponentRequirementId: resolveIdentifier(
link?.parentMachineComponentRequirementId,
source?.parentMachineComponentRequirementId,
requirement?.parentMachineComponentRequirementId,
),
parentMachinePieceRequirementId: resolveIdentifier(
link?.parentMachinePieceRequirementId,
source?.parentMachinePieceRequirementId,
requirement?.parentMachinePieceRequirementId,
),
parentComponentId: resolveIdentifier(link?.parentComponentId, source?.parentComponentId, source?.composantId),
parentPieceId: resolveIdentifier(link?.parentPieceId, source?.parentPieceId),
composantId: resolveIdentifier(source?.composantId, link?.composantId, link?.componentId),
typePieceId:
source?.typeMachinePieceRequirement?.typePieceId
|| source?.typePieceId
|| source?.typePiece?.id
|| requirement?.typePieceId
|| null,
definition: {
name:
source?.name
|| source?.nom
|| requirement?.typePiece?.name
|| '',
reference: source?.reference || '',
constructeurId: source?.constructeurId || source?.constructeur?.id || null,
prix:
source?.prix
?? source?.price
?? null,
},
}
if (link?.overrides && isPlainObject(link.overrides)) {
entry.definition = {
...entry.definition,
...link.overrides,
}
}
return entry
}
const resetSkeletonRequirementSelections = () => {
Object.keys(componentRequirementSelections).forEach((key) => {
@@ -1225,8 +1366,8 @@ const changeMachineView = async (view) => {
const validateSkeletonSelections = (type) => {
const errors = []
const componentSelectionsPayload = []
const pieceSelectionsPayload = []
const componentLinksPayload = []
const pieceLinksPayload = []
for (const requirement of type.componentRequirements || []) {
const entries = getComponentRequirementEntries(requirement.id)
@@ -1254,17 +1395,32 @@ const validateSkeletonSelections = (type) => {
return
}
const payload = { requirementId: requirement.id }
if (entry.typeComposantId && entry.typeComposantId !== requirement.typeComposantId) {
payload.typeComposantId = entry.typeComposantId
const payload = {
requirementId: requirement.id,
typeComposantId: resolvedTypeId,
}
if (entry.linkId) {
payload.id = entry.linkId
payload.linkId = entry.linkId
}
if (entry.composantId) {
payload.composantId = entry.composantId
}
const overrides = sanitizeDefinitionOverrides(entry.definition)
if (overrides) {
payload.definition = overrides
payload.overrides = overrides
}
componentSelectionsPayload.push(payload)
Object.assign(
payload,
extractParentLinkIdentifiers(requirement),
extractParentLinkIdentifiers(entry),
)
componentLinksPayload.push(payload)
})
}
@@ -1294,17 +1450,36 @@ const validateSkeletonSelections = (type) => {
return
}
const payload = { requirementId: requirement.id }
if (entry.typePieceId && entry.typePieceId !== requirement.typePieceId) {
payload.typePieceId = entry.typePieceId
const payload = {
requirementId: requirement.id,
typePieceId: resolvedTypeId,
}
if (entry.linkId) {
payload.id = entry.linkId
payload.linkId = entry.linkId
}
if (entry.pieceId) {
payload.pieceId = entry.pieceId
}
if (entry.composantId) {
payload.composantId = entry.composantId
}
const overrides = sanitizeDefinitionOverrides(entry.definition)
if (overrides) {
payload.definition = overrides
payload.overrides = overrides
}
pieceSelectionsPayload.push(payload)
Object.assign(
payload,
extractParentLinkIdentifiers(requirement),
extractParentLinkIdentifiers(entry),
)
pieceLinksPayload.push(payload)
})
}
@@ -1314,8 +1489,8 @@ const validateSkeletonSelections = (type) => {
return {
valid: true,
componentSelections: componentSelectionsPayload,
pieceSelections: pieceSelectionsPayload,
componentLinks: componentLinksPayload,
pieceLinks: pieceLinksPayload,
}
}
@@ -1333,6 +1508,16 @@ const applySkeletonReconfigurationResult = async (data) => {
machineDocumentsLoaded.value = !!(machine.value.documents?.length)
}
const linksApplied = applyMachineLinks(data) || applyMachineLinks(updatedMachine)
if (linksApplied) {
if (machine.value) {
machine.value.componentLinks = machineComponentLinks.value
machine.value.pieceLinks = machinePieceLinks.value
}
collapseAllComponents()
return
}
const newComponents = data.components ?? updatedMachine?.components ?? null
if (Array.isArray(newComponents)) {
components.value = transformComponentCustomFields(newComponents)
@@ -1352,7 +1537,7 @@ const saveSkeletonConfiguration = async () => {
}
const type = machineType.value
let payload = { componentSelections: [], pieceSelections: [] }
let payload = { componentLinks: [], pieceLinks: [] }
if (type && machineHasSkeletonRequirements.value) {
const validation = validateSkeletonSelections(type)
@@ -1361,8 +1546,8 @@ const saveSkeletonConfiguration = async () => {
return
}
payload = {
componentSelections: validation.componentSelections,
pieceSelections: validation.pieceSelections,
componentLinks: validation.componentLinks,
pieceLinks: validation.pieceLinks,
}
}
@@ -1436,8 +1621,17 @@ const getMachineFieldId = (fieldName) => {
// Computed
const machinePieces = computed(() => {
const filteredPieces = pieces.value.filter(piece => !piece.composantId)
console.log('machinePieces computed:', filteredPieces)
const filteredPieces = pieces.value.filter((piece) => {
const parentLinkId = resolveIdentifier(
piece.parentComponentLinkId,
piece.machinePieceLink?.parentComponentLinkId,
piece.parentLinkId,
)
if (parentLinkId) {
return false
}
return !piece.composantId
})
return filteredPieces
})
@@ -2081,96 +2275,319 @@ function mergeComponentTrees(existing = [], updates = []) {
return merged
}
const buildMachineHierarchyFromLinks = (componentLinks = [], pieceLinks = []) => {
const componentMap = new Map()
const componentRoots = []
componentLinks.forEach((link, index) => {
if (!isPlainObject(link)) {
return
}
const baseComponent = isPlainObject(link.composant)
? link.composant
: isPlainObject(link.component)
? link.component
: isPlainObject(link.targetComponent)
? link.targetComponent
: {}
const linkId = resolveIdentifier(link.id, link.linkId, link.machineComponentLinkId)
const node = {
...baseComponent,
machineComponentLink: link,
machineComponentLinkId: linkId,
linkId,
componentLinkId: linkId,
composantId: resolveIdentifier(
baseComponent.composantId,
baseComponent.componentId,
link.composantId,
link.componentId,
baseComponent.id,
),
parentComponentLinkId: resolveIdentifier(
link.parentComponentLinkId,
link.parentLinkId,
link.parentMachineComponentLinkId,
baseComponent.parentComponentLinkId,
baseComponent.parentLinkId,
),
parentComposantId: resolveIdentifier(
baseComponent.parentComposantId,
link.parentComponentId,
),
parentRequirementId: resolveIdentifier(
baseComponent.parentRequirementId,
link.parentRequirementId,
),
parentMachineComponentRequirementId: resolveIdentifier(
baseComponent.parentMachineComponentRequirementId,
link.parentMachineComponentRequirementId,
),
parentMachinePieceRequirementId: resolveIdentifier(
baseComponent.parentMachinePieceRequirementId,
link.parentMachinePieceRequirementId,
),
typeMachineComponentRequirement:
link.requirement
|| link.typeMachineComponentRequirement
|| baseComponent.typeMachineComponentRequirement
|| null,
typeMachineComponentRequirementId: resolveIdentifier(
link.requirementId,
link.typeMachineComponentRequirementId,
(link.requirement || link.typeMachineComponentRequirement)?.id,
baseComponent.typeMachineComponentRequirementId,
),
definition: baseComponent.definition || {},
pieces: [],
subComponents: [],
sousComposants: [],
}
if (!node.id) {
node.id = resolveIdentifier(
baseComponent.id,
node.composantId,
link.composantId,
link.componentId,
`component-${index}`,
)
}
node.requirementId = node.typeMachineComponentRequirementId
node.machineComponentLinkOverrides = link.overrides || null
node.overrides = link.overrides || null
node.definitionOverrides = link.overrides || null
node.subcomponents = node.subComponents
componentMap.set(node.machineComponentLinkId || node.id, node)
})
componentMap.forEach((node) => {
const parentLinkId = resolveIdentifier(node.parentComponentLinkId)
if (parentLinkId && componentMap.has(parentLinkId)) {
const parent = componentMap.get(parentLinkId)
parent.subComponents.push(node)
parent.sousComposants = parent.subComponents
parent.subcomponents = parent.subComponents
node.parentComposantId = resolveIdentifier(
node.parentComposantId,
parent.composantId,
parent.id,
)
} else {
componentRoots.push(node)
}
})
const machinePieces = []
pieceLinks.forEach((link, index) => {
if (!isPlainObject(link)) {
return
}
const basePiece = isPlainObject(link.piece)
? link.piece
: isPlainObject(link.targetPiece)
? link.targetPiece
: isPlainObject(link.pieceModel)
? link.pieceModel
: {}
const linkId = resolveIdentifier(link.id, link.linkId, link.machinePieceLinkId)
const parentComponentLinkId = resolveIdentifier(
link.parentComponentLinkId,
link.parentLinkId,
link.parentMachineComponentLinkId,
basePiece.parentComponentLinkId,
)
const pieceEntry = {
...basePiece,
id: resolveIdentifier(basePiece.id, link.pieceId, linkId, `piece-${index}`),
pieceId: resolveIdentifier(basePiece.id, link.pieceId),
machinePieceLink: link,
machinePieceLinkId: linkId,
linkId,
parentComponentLinkId,
parentLinkId: resolveIdentifier(
link.parentLinkId,
link.parentMachinePieceLinkId,
basePiece.parentLinkId,
),
parentPieceLinkId: resolveIdentifier(
link.parentPieceLinkId,
basePiece.parentPieceLinkId,
),
parentPieceId: resolveIdentifier(
basePiece.parentPieceId,
link.parentPieceId,
),
parentComponentId: resolveIdentifier(
basePiece.parentComponentId,
link.parentComponentId,
),
composantId: resolveIdentifier(
basePiece.composantId,
basePiece.componentId,
link.composantId,
link.componentId,
),
typeMachinePieceRequirement:
link.requirement
|| link.typeMachinePieceRequirement
|| basePiece.typeMachinePieceRequirement
|| null,
}
pieceEntry.typeMachinePieceRequirementId = resolveIdentifier(
link.requirementId,
link.typeMachinePieceRequirementId,
pieceEntry.typeMachinePieceRequirement?.id,
basePiece.typeMachinePieceRequirementId,
)
pieceEntry.parentMachineComponentRequirementId = resolveIdentifier(
basePiece.parentMachineComponentRequirementId,
link.parentMachineComponentRequirementId,
)
pieceEntry.parentMachinePieceRequirementId = resolveIdentifier(
basePiece.parentMachinePieceRequirementId,
link.parentMachinePieceRequirementId,
)
pieceEntry.definition = basePiece.definition || {}
pieceEntry.overrides = link.overrides || null
if (!pieceEntry.name && link.overrides?.name) {
pieceEntry.name = link.overrides.name
}
if (parentComponentLinkId && componentMap.has(parentComponentLinkId)) {
const parent = componentMap.get(parentComponentLinkId)
parent.pieces.push(pieceEntry)
pieceEntry.parentComponentName = parent.name || parent.nom || null
} else {
machinePieces.push(pieceEntry)
}
})
componentMap.forEach((node) => {
node.sousComposants = node.subComponents
node.subcomponents = node.subComponents
})
return {
components: componentRoots,
machinePieces,
}
}
const resolveLinkArray = (source, keys) => {
if (!source || typeof source !== 'object') {
return null
}
for (const key of keys) {
const value = source[key]
if (Array.isArray(value)) {
return value
}
}
return null
}
const applyMachineLinks = (source) => {
const container = source?.machine ?? null
const componentLinks =
resolveLinkArray(source, ['componentLinks', 'machineComponentLinks']) ??
resolveLinkArray(container, ['componentLinks', 'machineComponentLinks'])
const pieceLinks =
resolveLinkArray(source, ['pieceLinks', 'machinePieceLinks']) ??
resolveLinkArray(container, ['pieceLinks', 'machinePieceLinks'])
if (componentLinks === null && pieceLinks === null) {
return false
}
const normalizedComponentLinks = componentLinks ?? []
const normalizedPieceLinks = pieceLinks ?? []
machineComponentLinks.value = normalizedComponentLinks
machinePieceLinks.value = normalizedPieceLinks
const { components: hierarchy, machinePieces: machineLevelPieces } =
buildMachineHierarchyFromLinks(normalizedComponentLinks, normalizedPieceLinks)
components.value = transformComponentCustomFields(hierarchy)
pieces.value = transformCustomFields(machineLevelPieces)
return true
}
// Methods
const loadMachineData = async () => {
loading.value = true
try {
console.log('Début du chargement des données pour machineId:', machineId)
// Load specific machine directly from API
const { apiCall } = useApi()
console.log('Appel API pour machine:', machineId)
const machineResult = await apiCall(`/machines/${machineId}`, { method: 'GET' })
console.log('Résultat machine complet:', machineResult)
console.log('machineResult.success:', machineResult.success)
console.log('machineResult.data:', machineResult.data)
console.log('machineResult.error:', machineResult.error)
console.log('Machine customFieldValues:', machineResult.data?.customFieldValues)
console.log('Nombre de champs personnalisés:', machineResult.data?.customFieldValues?.length)
if (machineResult.success) {
machine.value = machineResult.data
machine.value.documents = machine.value.documents || []
machine.value.customFieldValues = machine.value.customFieldValues || []
machineDocumentsLoaded.value = !!(machine.value.documents?.length)
console.log('Machine trouvée et assignée:', machine.value)
const machineResult = await get(`/machines/${machineId}`)
syncMachineCustomFields()
} else {
console.error('Machine non trouvée:', machineId)
console.error('Erreur API:', machineResult.error)
loading.value = false
if (!machineResult.success) {
console.error('Machine non trouvée:', machineId, machineResult.error)
machine.value = null
components.value = []
pieces.value = []
return
}
// Initialize machine fields
const machinePayload = machineResult.data?.machine && typeof machineResult.data.machine === 'object'
? machineResult.data.machine
: machineResult.data
if (!machinePayload || typeof machinePayload !== 'object') {
console.error('Réponse machine invalide pour', machineId)
machine.value = null
components.value = []
pieces.value = []
return
}
machine.value = {
...machinePayload,
documents: machinePayload.documents || [],
customFieldValues: machinePayload.customFieldValues || [],
}
machineDocumentsLoaded.value = machine.value.documents.length > 0
syncMachineCustomFields()
initMachineFields()
console.log('Champs machine initialisés')
console.log('Machine après initialisation:', machine.value)
console.log('Machine name:', machineName.value)
console.log('Machine reference:', machineReference.value)
// Load components with hierarchy
console.log('Chargement des composants avec hiérarchie...')
const componentsResult = await apiCall(`/composants/hierarchy/${machineId}`, { method: 'GET' })
console.log('Résultat composants:', componentsResult)
console.log('Structure des données reçues:', JSON.stringify(componentsResult.data, null, 2))
if (componentsResult.success) {
console.log('Transformation des composants...')
components.value = transformComponentCustomFields(componentsResult.data)
console.log('Composants chargés:', components.value.length)
console.log('Composants transformés:', components.value)
collapseAllComponents()
// Debug: afficher la hiérarchie
console.log('=== HIÉRARCHIE DES COMPOSANTS ===')
components.value.forEach(comp => {
console.log(`Composant: ${comp.name} (ID: ${comp.id}, Parent: ${comp.parentComposantId})`)
if (comp.subComponents && comp.subComponents.length > 0) {
console.log(` Sous-composants: ${comp.subComponents.map(sc => sc.name).join(', ')}`)
}
})
console.log('=== FIN HIÉRARCHIE ===')
} else {
console.error('Erreur lors du chargement des composants:', componentsResult.error)
const linksApplied = applyMachineLinks(machineResult.data)
if (machine.value) {
machine.value.componentLinks = machineComponentLinks.value
machine.value.pieceLinks = machinePieceLinks.value
}
// Load pieces from machine response instead of separate API call
if (machine.value && machine.value.pieces) {
// Transformer les champs personnalisés
pieces.value = transformCustomFields(machine.value.pieces)
console.log('Pièces transformées:', pieces.value)
console.log('Pièces chargées:', pieces.value.length)
} else {
console.log('Aucune pièce trouvée dans la réponse de la machine')
if (!linksApplied) {
components.value = transformComponentCustomFields(machinePayload.components || [])
pieces.value = transformCustomFields(machinePayload.pieces || [])
}
collapseAllComponents()
if (!machineDocumentsLoaded.value) {
await refreshMachineDocuments()
}
console.log('Chargement terminé avec succès')
} catch (error) {
console.error('Erreur lors du chargement des données:', error)
} finally {
loading.value = false
console.log('Loading terminé, loading.value =', loading.value)
}
}
const updateMachineInfo = async () => {
if (!machine.value) return
try {
const result = await updateMachineApi(machine.value.id, {
name: machineName.value,
@@ -2178,8 +2595,25 @@ const updateMachineInfo = async () => {
constructeurId: machineConstructeurId.value || null
})
if (result.success) {
machine.value = result.data
machineConstructeurId.value = result.data.constructeurId || result.data.constructeur?.id || null
const machinePayload = result.data?.machine && typeof result.data.machine === 'object'
? result.data.machine
: result.data
if (machinePayload && typeof machinePayload === 'object') {
machine.value = {
...machine.value,
...machinePayload,
documents: machinePayload.documents || machine.value.documents || [],
customFieldValues: machinePayload.customFieldValues || machine.value.customFieldValues || [],
}
machineConstructeurId.value = machine.value.constructeurId || machine.value.constructeur?.id || null
const linksApplied = applyMachineLinks(result.data)
if (linksApplied && machine.value) {
machine.value.componentLinks = machineComponentLinks.value
machine.value.pieceLinks = machinePieceLinks.value
}
}
}
} catch (error) {
console.error('Erreur lors de la mise à jour de la machine:', error)
@@ -2348,14 +2782,12 @@ const updatePieceCustomField = async (fieldUpdate) => {
}
}
const editComponent = (component) => {
// TODO: Implement edit modal
console.log('Edit component:', component)
const editComponent = () => {
toast.showInfo('La modification des composants sera bientôt disponible')
}
const editPiece = (piece) => {
// TODO: Implement edit modal
console.log('Edit piece:', piece)
const editPiece = () => {
toast.showInfo('La modification des pièces sera bientôt disponible')
}
const toggleEditMode = () => {
@@ -2415,7 +2847,6 @@ onMounted(() => {
const route = useRoute()
if (route.query.edit === 'true') {
isEditMode.value = true
console.log('Mode édition activé depuis l\'URL')
}
})
</script>