MALIO-DEV/Inventory_backend
Archived
3
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

build: Fichiers de build générés - Ajout des fichiers TypeScript compilés et des déclarations de types

Browse Source
This commit is contained in:
Matthieu
2025-07-29 21:04:35 +02:00
parent e145b2c1ff
commit 1dbbf2b8ec
103 changed files with 10936 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1010
dist/machines/machines.controller.d.ts vendored Normal file
View File

File diff suppressed because it is too large Load Diff

90
dist/machines/machines.controller.js vendored Normal file
View File

@@ -0,0 +1,90 @@
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MachinesController = void 0;
const common_1 = require("@nestjs/common");
const machines_service_1 = require("./machines.service");
const machine_dto_1 = require("../shared/dto/machine.dto");
let MachinesController = class MachinesController {
machinesService;
constructor(machinesService) {
this.machinesService = machinesService;
}
create(createMachineDto) {
return this.machinesService.create(createMachineDto);
}
findAll() {
return this.machinesService.findAll();
}
findOne(id) {
return this.machinesService.findOne(id);
}
update(id, updateMachineDto) {
return this.machinesService.update(id, updateMachineDto);
}
remove(id) {
return this.machinesService.remove(id);
}
addMissingCustomFields(id) {
return this.machinesService.addMissingCustomFields(id);
}
};
exports.MachinesController = MachinesController;
__decorate([
(0, common_1.Post)(),
__param(0, (0, common_1.Body)()),
__metadata("design:type", Function),
__metadata("design:paramtypes", [machine_dto_1.CreateMachineDto]),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "create", null);
__decorate([
(0, common_1.Get)(),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "findAll", null);
__decorate([
(0, common_1.Get)(':id'),
__param(0, (0, common_1.Param)('id')),
__metadata("design:type", Function),
__metadata("design:paramtypes", [String]),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "findOne", null);
__decorate([
(0, common_1.Patch)(':id'),
__param(0, (0, common_1.Param)('id')),
__param(1, (0, common_1.Body)()),
__metadata("design:type", Function),
__metadata("design:paramtypes", [String, machine_dto_1.UpdateMachineDto]),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "update", null);
__decorate([
(0, common_1.Delete)(':id'),
__param(0, (0, common_1.Param)('id')),
__metadata("design:type", Function),
__metadata("design:paramtypes", [String]),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "remove", null);
__decorate([
(0, common_1.Post)(':id/add-custom-fields'),
__param(0, (0, common_1.Param)('id')),
__metadata("design:type", Function),
__metadata("design:paramtypes", [String]),
__metadata("design:returntype", void 0)
], MachinesController.prototype, "addMissingCustomFields", null);
exports.MachinesController = MachinesController = __decorate([
(0, common_1.Controller)('machines'),
__metadata("design:paramtypes", [machines_service_1.MachinesService])
], MachinesController);
//# sourceMappingURL=machines.controller.js.map

1
dist/machines/machines.controller.js.map vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"machines.controller.js","sourceRoot":"","sources":["../../src/machines/machines.controller.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,2CAAmF;AACnF,yDAAqD;AACrD,2DAA+E;AAGxE,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IACA;IAA7B,YAA6B,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;IAAG,CAAC;IAGjE,MAAM,CAAS,gBAAkC;QAC/C,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACvD,CAAC;IAGD,OAAO;QACL,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;IACxC,CAAC;IAGD,OAAO,CAAc,EAAU;QAC7B,OAAO,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC1C,CAAC;IAGD,MAAM,CAAc,EAAU,EAAU,gBAAkC;QACxE,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;IAC3D,CAAC;IAGD,MAAM,CAAc,EAAU;QAC5B,OAAO,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACzC,CAAC;IAGD,sBAAsB,CAAc,EAAU;QAC5C,OAAO,IAAI,CAAC,eAAe,CAAC,sBAAsB,CAAC,EAAE,CAAC,CAAC;IACzD,CAAC;CACF,CAAA;AAhCY,gDAAkB;AAI7B;IADC,IAAA,aAAI,GAAE;IACC,WAAA,IAAA,aAAI,GAAE,CAAA;;qCAAmB,8BAAgB;;gDAEhD;AAGD;IADC,IAAA,YAAG,GAAE;;;;iDAGL;AAGD;IADC,IAAA,YAAG,EAAC,KAAK,CAAC;IACF,WAAA,IAAA,cAAK,EAAC,IAAI,CAAC,CAAA;;;;iDAEnB;AAGD;IADC,IAAA,cAAK,EAAC,KAAK,CAAC;IACL,WAAA,IAAA,cAAK,EAAC,IAAI,CAAC,CAAA;IAAc,WAAA,IAAA,aAAI,GAAE,CAAA;;6CAAmB,8BAAgB;;gDAEzE;AAGD;IADC,IAAA,eAAM,EAAC,KAAK,CAAC;IACN,WAAA,IAAA,cAAK,EAAC,IAAI,CAAC,CAAA;;;;gDAElB;AAGD;IADC,IAAA,aAAI,EAAC,uBAAuB,CAAC;IACN,WAAA,IAAA,cAAK,EAAC,IAAI,CAAC,CAAA;;;;gEAElC;6BA/BU,kBAAkB;IAD9B,IAAA,mBAAU,EAAC,UAAU,CAAC;qCAEyB,kCAAe;GADlD,kBAAkB,CAgC9B"}

2
dist/machines/machines.module.d.ts vendored Normal file
View File

@@ -0,0 +1,2 @@
export declare class MachinesModule {
}

22
dist/machines/machines.module.js vendored Normal file
View File

@@ -0,0 +1,22 @@
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MachinesModule = void 0;
const common_1 = require("@nestjs/common");
const machines_controller_1 = require("./machines.controller");
const machines_service_1 = require("./machines.service");
let MachinesModule = class MachinesModule {
};
exports.MachinesModule = MachinesModule;
exports.MachinesModule = MachinesModule = __decorate([
(0, common_1.Module)({
controllers: [machines_controller_1.MachinesController],
providers: [machines_service_1.MachinesService]
})
], MachinesModule);
//# sourceMappingURL=machines.module.js.map

1
dist/machines/machines.module.js.map vendored Normal file
View File

@@ -0,0 +1 @@
{"version":3,"file":"machines.module.js","sourceRoot":"","sources":["../../src/machines/machines.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,+DAA2D;AAC3D,yDAAqD;AAM9C,IAAM,cAAc,GAApB,MAAM,cAAc;CAAG,CAAA;AAAjB,wCAAc;yBAAd,cAAc;IAJ1B,IAAA,eAAM,EAAC;QACN,WAAW,EAAE,CAAC,wCAAkB,CAAC;QACjC,SAAS,EAAE,CAAC,kCAAe,CAAC;KAC7B,CAAC;GACW,cAAc,CAAG"}

1013
dist/machines/machines.service.d.ts vendored Normal file
View File

File diff suppressed because it is too large Load Diff

675
dist/machines/machines.service.js vendored Normal file
View File

@@ -0,0 +1,675 @@
"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MachinesService = void 0;
const common_1 = require("@nestjs/common");
const prisma_service_1 = require("../prisma/prisma.service");
let MachinesService = class MachinesService {
prisma;
constructor(prisma) {
this.prisma = prisma;
}
async create(createMachineDto) {
const typeMachine = await this.prisma.typeMachine.findUnique({
where: { id: createMachineDto.typeMachineId },
include: {
customFields: true,
},
});
if (!typeMachine) {
throw new Error('Type de machine non trouvé');
}
return await this.prisma.$transaction(async (prisma) => {
const machine = await prisma.machine.create({
data: createMachineDto,
include: {
site: true,
typeMachine: true,
},
});
const components = typeMachine.components;
if (components) {
await this.createComponentsFromType(prisma, machine.id, components);
}
const machinePieces = typeMachine.machinePieces;
if (machinePieces) {
await this.createMachinePiecesFromType(prisma, machine.id, machinePieces);
}
if (typeMachine.customFields && typeMachine.customFields.length > 0) {
await this.createMachineCustomFieldsFromType(prisma, machine.id, typeMachine.customFields);
}
return await prisma.machine.findUnique({
where: { id: machine.id },
include: {
site: true,
typeMachine: {
include: {
customFields: true,
},
},
composants: {
include: {
typeComposant: true,
sousComposants: true,
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
},
},
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
customFieldValues: {
include: {
customField: true,
},
},
documents: true,
},
});
});
}
async createComponentsFromType(prisma, machineId, components, parentComposantId) {
for (const component of components) {
if (!component.name)
continue;
let typeComposant = null;
if (component.customFields && component.customFields.length > 0) {
typeComposant = await prisma.typeComposant.findFirst({
where: { name: component.name }
});
if (!typeComposant) {
typeComposant = await prisma.typeComposant.create({
data: {
name: component.name,
description: component.description || '',
},
});
for (const customField of component.customFields) {
await prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typeComposantId: typeComposant.id,
},
});
}
}
}
const createdComposant = await prisma.composant.create({
data: {
name: component.name,
reference: component.reference || '',
prestataire: component.prestataire || '',
emplacement: component.emplacement || '',
prix: component.prix || null,
machineId,
parentComposantId,
typeComposantId: typeComposant?.id || null,
},
});
if (typeComposant && typeComposant.id) {
const customFields = await prisma.customField.findMany({
where: { typeComposantId: typeComposant.id },
});
for (const customField of customFields) {
const defaultValue = component.customFields?.find(cf => cf.name === customField.name)?.defaultValue || '';
await prisma.customFieldValue.create({
data: {
value: defaultValue,
customFieldId: customField.id,
composantId: createdComposant.id,
},
});
}
}
if (component.pieces) {
for (const piece of component.pieces) {
if (!piece || !piece.name)
continue;
let typePiece = null;
if (piece.customFields && piece.customFields.length > 0) {
typePiece = await prisma.typePiece.findFirst({
where: { name: piece.name }
});
if (!typePiece) {
typePiece = await prisma.typePiece.create({
data: {
name: piece.name,
description: piece.description || '',
},
});
for (const customField of piece.customFields) {
await prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typePieceId: typePiece.id,
},
});
}
}
}
const createdPiece = await prisma.piece.create({
data: {
name: piece.name,
reference: piece.reference || '',
prestataire: piece.prestataire || '',
emplacement: piece.emplacement || '',
prix: piece.prix || null,
composantId: createdComposant.id,
typePieceId: typePiece?.id || null,
},
});
if (typePiece && typePiece.id) {
const customFields = await prisma.customField.findMany({
where: { typePieceId: typePiece.id },
});
for (const customField of customFields) {
const defaultValue = piece.customFields?.find(cf => cf.name === customField.name)?.defaultValue || '';
await prisma.customFieldValue.create({
data: {
value: defaultValue,
customFieldId: customField.id,
pieceId: createdPiece.id,
},
});
}
}
}
}
if (component.subComponents) {
await this.createComponentsFromType(prisma, machineId, component.subComponents, createdComposant.id);
}
}
}
async createMachinePiecesFromType(prisma, machineId, machinePieces) {
for (const piece of machinePieces) {
if (!piece || !piece.name)
continue;
const createdPiece = await prisma.piece.create({
data: {
name: piece.name,
machineId,
},
});
if (piece.customFields && piece.customFields.length > 0) {
for (const customField of piece.customFields) {
const createdCustomField = await prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typePieceId: null,
},
});
await prisma.customFieldValue.create({
data: {
value: customField.defaultValue || '',
customFieldId: createdCustomField.id,
pieceId: createdPiece.id,
},
});
}
}
}
}
async createMachineCustomFieldsFromType(prisma, machineId, machineCustomFields) {
for (const customField of machineCustomFields) {
if (!customField || !customField.name)
continue;
const createdCustomField = await prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typeMachineId: null,
},
});
await prisma.customFieldValue.create({
data: {
value: customField.defaultValue || '',
customFieldId: createdCustomField.id,
machineId: machineId,
},
});
}
}
async findAll() {
return this.prisma.machine.findMany({
include: {
site: true,
typeMachine: {
include: {
customFields: true,
},
},
composants: {
include: {
typeComposant: true,
sousComposants: true,
customFieldValues: {
include: {
customField: true,
},
},
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
},
},
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
customFieldValues: {
include: {
customField: true,
},
},
documents: true,
},
});
}
async findOne(id) {
return this.prisma.machine.findUnique({
where: { id },
include: {
site: true,
typeMachine: {
include: {
customFields: true,
},
},
composants: {
include: {
typeComposant: true,
sousComposants: true,
customFieldValues: {
include: {
customField: true,
},
},
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
},
},
pieces: {
include: {
customFieldValues: {
include: {
customField: true,
},
},
},
},
customFieldValues: {
include: {
customField: true,
},
},
documents: true,
},
});
}
async update(id, updateMachineDto) {
return this.prisma.machine.update({
where: { id },
data: updateMachineDto,
include: {
site: true,
typeMachine: {
include: {
customFields: true,
},
},
composants: {
include: {
typeComposant: true,
sousComposants: true,
pieces: true,
},
},
pieces: true,
customFieldValues: {
include: {
customField: true,
},
},
documents: true,
},
});
}
async remove(id) {
const machine = await this.prisma.machine.findUnique({
where: { id },
include: {
composants: true,
pieces: true,
documents: true,
customFieldValues: true,
},
});
if (!machine) {
throw new Error('Machine non trouvée');
}
return await this.prisma.$transaction(async (prisma) => {
if (machine.customFieldValues.length > 0) {
await prisma.customFieldValue.deleteMany({
where: { machineId: id },
});
}
if (machine.documents.length > 0) {
await prisma.document.deleteMany({
where: { machineId: id },
});
}
if (machine.pieces.length > 0) {
await prisma.piece.deleteMany({
where: { machineId: id },
});
}
if (machine.composants.length > 0) {
await prisma.composant.deleteMany({
where: { machineId: id },
});
}
return await prisma.machine.delete({
where: { id },
});
});
}
async addMissingCustomFields(machineId) {
const machine = await this.prisma.machine.findUnique({
where: { id: machineId },
include: {
typeMachine: true,
composants: {
include: {
pieces: true,
},
},
pieces: true,
},
});
if (!machine || !machine.typeMachine) {
throw new Error('Machine ou type de machine non trouvé');
}
const typeMachine = machine.typeMachine;
const components = typeMachine.components || [];
const machinePieces = typeMachine.machinePieces || [];
const machineCustomFields = typeMachine.customFields || [];
if (machineCustomFields && machineCustomFields.length > 0) {
for (const customField of machineCustomFields) {
const existingValue = await this.prisma.customFieldValue.findFirst({
where: {
machineId: machineId,
customField: {
name: customField.name,
},
},
include: {
customField: true,
},
});
if (!existingValue) {
const createdCustomField = await this.prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typeMachineId: null,
},
});
await this.prisma.customFieldValue.create({
data: {
value: customField.defaultValue || '',
customFieldId: createdCustomField.id,
machineId: machineId,
},
});
}
}
}
for (const component of machine.composants) {
const typeComponent = components.find((c) => c.name === component.name);
if (typeComponent && typeComponent.customFields && typeComponent.customFields.length > 0) {
let typeComposant = await this.prisma.typeComposant.findFirst({
where: { name: component.name },
});
if (!typeComposant) {
typeComposant = await this.prisma.typeComposant.create({
data: {
name: component.name,
description: typeComponent.description || '',
},
});
}
for (const customField of typeComponent.customFields) {
const existingField = await this.prisma.customField.findFirst({
where: {
name: customField.name,
typeComposantId: typeComposant.id,
},
});
if (!existingField) {
await this.prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typeComposantId: typeComposant.id,
},
});
}
}
await this.prisma.composant.update({
where: { id: component.id },
data: { typeComposantId: typeComposant.id },
});
const customFields = await this.prisma.customField.findMany({
where: { typeComposantId: typeComposant.id },
});
for (const customField of customFields) {
const existingValue = await this.prisma.customFieldValue.findFirst({
where: {
customFieldId: customField.id,
composantId: component.id,
},
});
if (!existingValue) {
const defaultValue = typeComponent.customFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
await this.prisma.customFieldValue.create({
data: {
value: defaultValue,
customFieldId: customField.id,
composantId: component.id,
},
});
}
}
for (const piece of component.pieces) {
const typePiece = typeComponent.pieces?.find((p) => p.name === piece.name);
if (typePiece && typePiece.customFields && typePiece.customFields.length > 0) {
let typePieceEntity = await this.prisma.typePiece.findFirst({
where: { name: piece.name },
});
if (!typePieceEntity) {
typePieceEntity = await this.prisma.typePiece.create({
data: {
name: piece.name,
description: typePiece.description || '',
},
});
}
for (const customField of typePiece.customFields) {
const existingField = await this.prisma.customField.findFirst({
where: {
name: customField.name,
typePieceId: typePieceEntity.id,
},
});
if (!existingField) {
await this.prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typePieceId: typePieceEntity.id,
},
});
}
}
await this.prisma.piece.update({
where: { id: piece.id },
data: { typePieceId: typePieceEntity.id },
});
const customFields = await this.prisma.customField.findMany({
where: { typePieceId: typePieceEntity.id },
});
for (const customField of customFields) {
const existingValue = await this.prisma.customFieldValue.findFirst({
where: {
customFieldId: customField.id,
pieceId: piece.id,
},
});
if (!existingValue) {
const defaultValue = typePiece.customFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
await this.prisma.customFieldValue.create({
data: {
value: defaultValue,
customFieldId: customField.id,
pieceId: piece.id,
},
});
}
}
}
}
}
}
for (const piece of machine.pieces) {
const typePiece = machinePieces.find((p) => p.name === piece.name);
if (typePiece && typePiece.customFields && typePiece.customFields.length > 0) {
let typePieceEntity = await this.prisma.typePiece.findFirst({
where: { name: piece.name },
});
if (!typePieceEntity) {
typePieceEntity = await this.prisma.typePiece.create({
data: {
name: piece.name,
description: typePiece.description || '',
},
});
}
for (const customField of typePiece.customFields) {
const existingField = await this.prisma.customField.findFirst({
where: {
name: customField.name,
typePieceId: typePieceEntity.id,
},
});
if (!existingField) {
await this.prisma.customField.create({
data: {
name: customField.name,
type: customField.type,
required: customField.required || false,
defaultValue: customField.defaultValue,
options: customField.options || [],
typePieceId: typePieceEntity.id,
},
});
}
}
await this.prisma.piece.update({
where: { id: piece.id },
data: { typePieceId: typePieceEntity.id },
});
const customFields = await this.prisma.customField.findMany({
where: { typePieceId: typePieceEntity.id },
});
for (const customField of customFields) {
const existingValue = await this.prisma.customFieldValue.findFirst({
where: {
customFieldId: customField.id,
pieceId: piece.id,
},
});
if (!existingValue) {
const defaultValue = typePiece.customFields.find((cf) => cf.name === customField.name)?.defaultValue || '';
await this.prisma.customFieldValue.create({
data: {
value: defaultValue,
customFieldId: customField.id,
pieceId: piece.id,
},
});
}
}
}
}
return this.findOne(machineId);
}
};
exports.MachinesService = MachinesService;
exports.MachinesService = MachinesService = __decorate([
(0, common_1.Injectable)(),
__metadata("design:paramtypes", [prisma_service_1.PrismaService])
], MachinesService);
//# sourceMappingURL=machines.service.js.map

1
dist/machines/machines.service.js.map vendored Normal file
View File

File diff suppressed because one or more lines are too long