yogiedigital/cod-api
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: brand device service

Browse Source
This commit is contained in:
mhmmdafif
2025-11-18 10:06:21 +07:00
parent 8176eb2bdd
commit de5051bfaf
2 changed files with 146 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

284
services/brand.service.js
View File

@@ -1,4 +1,4 @@
// Brand operations // BrandService.js
const { const {
getAllBrandsDb, getAllBrandsDb,
getBrandByIdDb, getBrandByIdDb,
@@ -9,7 +9,6 @@ const {
checkBrandNameExistsDb, checkBrandNameExistsDb,
} = require('../db/brand.db'); } = require('../db/brand.db');
// Error code operations
const { const {
getErrorCodesByBrandIdDb, getErrorCodesByBrandIdDb,
createErrorCodeDb, createErrorCodeDb,
@@ -17,7 +16,6 @@ const {
deleteErrorCodeDb, deleteErrorCodeDb,
} = require('../db/brand_code.db'); } = require('../db/brand_code.db');
// Sparepart operations
const { const {
getSparePartnsByErrorCodeIdDb, getSparePartnsByErrorCodeIdDb,
createSparePartDb, createSparePartDb,
@@ -25,7 +23,6 @@ const {
deleteSparePartDb, deleteSparePartDb,
} = require('../db/brand_sparepart.db'); } = require('../db/brand_sparepart.db');
// Solution operations
const { const {
getSolutionsByErrorCodeIdDb, getSolutionsByErrorCodeIdDb,
createSolutionDb, createSolutionDb,
@@ -37,13 +34,12 @@ const { getFileUploadByPathDb } = require('../db/file_uploads.db');
const { ErrorHandler } = require('../helpers/error'); const { ErrorHandler } = require('../helpers/error');
class BrandService { class BrandService {
static async getAllBrands(param) { static async getAllBrands(param) {
try { try {
const results = await getAllBrandsDb(param); const results = await getAllBrandsDb(param);
return results; return results;
} catch (error) { } catch (error) {
throw new ErrorHandler(error.statusCode, error.message); throw new ErrorHandler(error.statusCode || 500, error.message || 'Failed to get brands');
} }
} }
@@ -52,20 +48,21 @@ class BrandService {
const brand = await getBrandByIdDb(id); const brand = await getBrandByIdDb(id);
if (!brand) throw new ErrorHandler(404, 'Brand not found'); if (!brand) throw new ErrorHandler(404, 'Brand not found');
const errorCodes = await getErrorCodesByBrandIdDb(brand.brand_id); const errorCodes = await getErrorCodesByBrandIdDb(brand.brand_id) || [];
const errorCodesWithDetails = await Promise.all( const errorCodesWithDetails = await Promise.all(
errorCodes.map(async (errorCode) => { errorCodes.map(async (errorCode) => {
const solutions = await getSolutionsByErrorCodeIdDb(errorCode.error_code_id); const solutions = (await getSolutionsByErrorCodeIdDb(errorCode.error_code_id)) || [];
const solutionsWithFile = await Promise.all( const solutionsWithFile = await Promise.all(
solutions.map(async (s) => { solutions.map(async (s) => {
let fileData = null; let fileData = null;
if (s.path_solution && s.type_solution && s.type_solution !== 'text') {
if (s.path_solution && s.type_solution !== "text") { try {
fileData = await getFileUploadByPathDb(s.path_solution); fileData = await getFileUploadByPathDb(s.path_solution);
} catch (e) {
fileData = null;
}
} }
return { return {
...s, ...s,
file_upload_name: fileData?.file_upload_name || null, file_upload_name: fileData?.file_upload_name || null,
@@ -74,7 +71,7 @@ class BrandService {
}) })
); );
const spareparts = await getSparePartnsByErrorCodeIdDb(errorCode.error_code_id); const spareparts = (await getSparePartnsByErrorCodeIdDb(errorCode.error_code_id)) || [];
return { return {
...errorCode, ...errorCode,
@@ -88,155 +85,173 @@ class BrandService {
...brand, ...brand,
error_code: errorCodesWithDetails error_code: errorCodesWithDetails
}; };
} catch (error) { } catch (error) {
throw new ErrorHandler(error.statusCode, error.message); throw new ErrorHandler(error.statusCode || 500, error.message || 'Failed to get brand detail');
} }
} }
static async createBrandWithFullData(data) { static async createBrandWithFullData(data) {
try { try {
if (!data || typeof data !== "object") data = {}; if (!data || typeof data !== 'object') data = {};
if (data.brand_name) { if (!data.brand_name) throw new ErrorHandler(400, 'brand_name is required');
const exists = await checkBrandNameExistsDb(data.brand_name); const exists = await checkBrandNameExistsDb(data.brand_name);
if (exists) throw new ErrorHandler(400, "Brand name already exists"); if (exists) throw new ErrorHandler(400, 'Brand name already exists');
}
if (!data.error_code || !Array.isArray(data.error_code)) { if (!Array.isArray(data.error_code) || data.error_code.length === 0) {
throw new ErrorHandler(400, "Brand must have at least 1 error code"); throw new ErrorHandler(400, 'Brand must have at least 1 error code with solution');
} }
for (const ec of data.error_code) { for (const ec of data.error_code) {
if (!ec.solution || ec.solution.length === 0) { if (!Array.isArray(ec.solution) || ec.solution.length === 0) {
throw new ErrorHandler(400, `Error code ${ec.error_code} must have at least 1 solution`); throw new ErrorHandler(400, `Error code ${ec.error_code} must have at least 1 solution`);
} }
} }
const createdBrand = await createBrandDb({ const brandData = {
brand_name: data.brand_name, brand_name: data.brand_name,
brand_type: data.brand_type, brand_type: data.brand_type || null,
brand_manufacture: data.brand_manufacture, brand_manufacture: data.brand_manufacture || null,
brand_model: data.brand_model, brand_model: data.brand_model || null,
is_active: data.is_active, is_active: data.is_active,
created_by: data.created_by created_by: data.created_by || null
}); };
const createdBrand = await createBrandDb(brandData);
if (!createdBrand || !createdBrand.brand_id) {
throw new Error('Failed to create brand');
}
const brandId = createdBrand.brand_id; const brandId = createdBrand.brand_id;
for (const ec of data.error_code) {
const errorId = await createErrorCodeDb(brandId, {
error_code: ec.error_code,
error_code_name: ec.error_code_name,
error_code_description: ec.error_code_description,
error_code_color: ec.error_code_color,
path_icon: ec.path_icon,
is_active: ec.is_active,
created_by: data.created_by
});
for (const s of ec.solution) { for (const ec of data.error_code) {
await createSolutionDb(errorId, { const errorCodePayload = {
solution_name: s.solution_name, error_code: ec.error_code,
type_solution: s.type_solution, error_code_name: ec.error_code_name || null,
text_solution: s.text_solution || null, error_code_description: ec.error_code_description || null,
path_solution: s.path_solution || null, error_code_color: ec.error_code_color || null,
is_active: s.is_active, path_icon: ec.path_icon || null,
created_by: data.created_by is_active: ec.is_active,
}); created_by: data.created_by || null
};
const errorId = await createErrorCodeDb(brandId, errorCodePayload);
if (!errorId) {
throw new Error('Failed to create error code');
} }
if (Array.isArray(ec.sparepart)) { // solutions
for (const sp of ec.sparepart) { if (Array.isArray(ec.solution)) {
await createSparePartDb(errorId, { for (const s of ec.solution) {
sparepart_name: sp.sparepart_name, const solPayload = {
brand_sparepart_description: sp.brand_sparepart_description, solution_name: s.solution_name,
path_foto: sp.path_foto || null, type_solution: s.type_solution,
is_active: sp.is_active, text_solution: s.text_solution || null,
created_by: data.created_by path_solution: s.path_solution || null,
}); is_active: s.is_active,
created_by: data.created_by || null
};
await createSolutionDb(errorId, solPayload);
} }
} }
// spareparts
if (Array.isArray(ec.sparepart)) {
for (const sp of ec.sparepart) {
const spPayload = {
sparepart_name: sp.sparepart_name,
brand_sparepart_description: sp.brand_sparepart_description || null,
path_foto: sp.path_foto || null,
is_active: sp.is_active,
created_by: data.created_by || null
};
await createSparePartDb(errorId, spPayload);
}
}
} }
return await this.getBrandById(brandId); return await this.getBrandById(brandId);
} catch (error) { } catch (error) {
throw new ErrorHandler(500, `Bulk insert failed: ${error.message}`); if (error instanceof ErrorHandler) throw error;
throw new ErrorHandler(500, error.message || 'Create brand failed');
} }
} }
static async updateBrandWithFullData(id, data) { static async updateBrandWithFullData(id, data) {
try { try {
const existingBrand = await getBrandByIdDb(id); const existingBrand = await getBrandByIdDb(id);
if (!existingBrand) throw new ErrorHandler(404, "Brand not found"); if (!existingBrand) throw new ErrorHandler(404, 'Brand not found');
await updateBrandDb(existingBrand.brand_name, { if (data.brand_name && data.brand_name !== existingBrand.brand_name) {
brand_name: data.brand_name, const brandExists = await checkBrandNameExistsDb(data.brand_name, id);
brand_type: data.brand_type, if (brandExists) throw new ErrorHandler(400, 'Brand name already exists');
brand_manufacture: data.brand_manufacture, }
brand_model: data.brand_model,
is_active: data.is_active,
updated_by: data.updated_by
});
if (!data.error_code) return await this.getBrandById(id); const brandUpdatePayload = {
brand_name: data.brand_name ?? existingBrand.brand_name,
brand_type: data.brand_type ?? existingBrand.brand_type,
brand_manufacture: data.brand_manufacture ?? existingBrand.brand_manufacture,
brand_model: data.brand_model ?? existingBrand.brand_model,
is_active: typeof data.is_active === 'boolean' ? data.is_active : existingBrand.is_active,
updated_by: data.updated_by || null
};
await updateBrandDb(existingBrand.brand_name, brandUpdatePayload);
const existingErrorCodes = await getErrorCodesByBrandIdDb(id); if (!Array.isArray(data.error_code)) {
return await this.getBrandById(id);
}
const existingErrorCodes = await getErrorCodesByBrandIdDb(id) || [];
const incomingErrorCodes = data.error_code.map(ec => ec.error_code); const incomingErrorCodes = data.error_code.map(ec => ec.error_code);
for (const ec of data.error_code) { for (const ec of data.error_code) {
const existsEC = existingErrorCodes.find(e => e.error_code === ec.error_code); const existingEC = existingErrorCodes.find(e => e.error_code === ec.error_code);
let errorId = null; let errorId = null;
if (existsEC) { if (existingEC) {
await updateErrorCodeDb(existingBrand.brand_id, existsEC.error_code, { const updatePayload = {
error_code_name: ec.error_code_name, error_code_name: ec.error_code_name ?? existingEC.error_code_name,
error_code_description: ec.error_code_description, error_code_description: ec.error_code_description ?? existingEC.error_code_description,
error_code_color: ec.error_code_color, error_code_color: ec.error_code_color ?? existingEC.error_code_color,
path_icon: ec.path_icon, path_icon: ec.path_icon ?? existingEC.path_icon,
is_active: ec.is_active, is_active: existingEC.is_active,
updated_by: data.updated_by updated_by: data.updated_by || null
}); };
errorId = existsEC.error_code_id; await updateErrorCodeDb(existingEC.brand_id, existingEC.error_code, updatePayload);
errorId = existingEC.error_code_id;
} else { } else {
errorId = await createErrorCodeDb(id, { const createPayload = {
error_code: ec.error_code, error_code: ec.error_code,
error_code_name: ec.error_code_name, error_code_name: ec.error_code_name || null,
error_code_description: ec.error_code_description, error_code_description: ec.error_code_description || null,
error_code_color: ec.error_code_color, error_code_color: ec.error_code_color || null,
path_icon: ec.path_icon, path_icon: ec.path_icon || null,
is_active: ec.is_active, is_active: ec.is_active,
created_by: data.updated_by created_by: data.updated_by || null
}); };
errorId = await createErrorCodeDb(id, createPayload);
} }
const existingSolutions = await getSolutionsByErrorCodeIdDb(errorId); if (!errorId) throw new Error(`Failed to create/update error code ${ec.error_code}`);
const incomingSolutionNames = ec.solution?.map(s => s.solution_name) || [];
for (const s of ec.solution || []) { const existingSolutions = await getSolutionsByErrorCodeIdDb(errorId) || [];
const incomingSolutionNames = (ec.solution || []).map(s => s.solution_name);
for (const s of (ec.solution || [])) {
const existsSolution = existingSolutions.find(es => es.solution_name === s.solution_name); const existsSolution = existingSolutions.find(es => es.solution_name === s.solution_name);
const solPayload = {
solution_name: s.solution_name,
type_solution: s.type_solution,
text_solution: s.text_solution || null,
path_solution: s.path_solution || null,
is_active: s.is_active,
updated_by: data.updated_by || null,
created_by: data.updated_by || null
};
if (existsSolution) { if (existsSolution) {
await updateSolutionDb(existsSolution.brand_code_solution_id, { await updateSolutionDb(existsSolution.brand_code_solution_id, solPayload);
solution_name: s.solution_name,
type_solution: s.type_solution,
text_solution: s.text_solution || null,
path_solution: s.path_solution || null,
is_active: s.is_active,
updated_by: data.updated_by
});
} else { } else {
await createSolutionDb(errorId, { await createSolutionDb(errorId, solPayload);
solution_name: s.solution_name,
type_solution: s.type_solution,
text_solution: s.text_solution || null,
path_solution: s.path_solution || null,
is_active: s.is_active,
created_by: data.updated_by
});
} }
} }
@@ -246,28 +261,23 @@ class BrandService {
} }
} }
const existingSpareparts = await getSparePartnsByErrorCodeIdDb(errorId); const existingSpareparts = await getSparePartnsByErrorCodeIdDb(errorId) || [];
const incomingSparepartNames = ec.sparepart?.map(sp => sp.sparepart_name) || []; const incomingSparepartNames = (ec.sparepart || []).map(sp => sp.sparepart_name);
for (const sp of ec.sparepart || []) {
const existsSP = existingSpareparts.find(es => es.sparepart_name === sp.sparepart_name);
for (const sp of (ec.sparepart || [])) {
const existsSP = existingSpareparts.find(e => e.sparepart_name === sp.sparepart_name);
const spPayload = {
sparepart_name: sp.sparepart_name,
brand_sparepart_description: sp.brand_sparepart_description || null,
path_foto: sp.path_foto || null,
is_active: sp.is_active,
updated_by: data.updated_by || null,
created_by: data.updated_by || null
};
if (existsSP) { if (existsSP) {
await updateSparePartDb(existsSP.brand_sparepart_id, { await updateSparePartDb(existsSP.brand_sparepart_id, spPayload);
sparepart_name: sp.sparepart_name,
brand_sparepart_description: sp.brand_sparepart_description,
path_foto: sp.path_foto || null,
is_active: sp.is_active,
updated_by: data.updated_by
});
} else { } else {
await createSparePartDb(errorId, { await createSparePartDb(errorId, spPayload);
sparepart_name: sp.sparepart_name,
brand_sparepart_description: sp.brand_sparepart_description,
path_foto: sp.path_foto || null,
is_active: sp.is_active,
created_by: data.updated_by
});
} }
} }
@@ -276,7 +286,6 @@ class BrandService {
await deleteSparePartDb(es.brand_sparepart_id, data.updated_by); await deleteSparePartDb(es.brand_sparepart_id, data.updated_by);
} }
} }
} }
for (const ec of existingErrorCodes) { for (const ec of existingErrorCodes) {
@@ -286,21 +295,20 @@ class BrandService {
} }
return await this.getBrandById(id); return await this.getBrandById(id);
} catch (error) { } catch (error) {
throw new ErrorHandler(500, `Update failed: ${error.message}`); if (error instanceof ErrorHandler) throw error;
throw new ErrorHandler(500, `Update failed: ${error.message || 'unknown error'}`);
} }
} }
static async deleteBrand(id, userId) { static async deleteBrand(id, userId) {
try { try {
const exist = await getBrandByIdDb(id); const brandExist = await getBrandByIdDb(id);
if (!exist) throw new ErrorHandler(404, "Brand not found"); if (!brandExist) throw new ErrorHandler(404, 'Brand not found');
const result = await deleteBrandDb(id, userId);
return await deleteBrandDb(id, userId); return result;
} catch (error) { } catch (error) {
throw new ErrorHandler(error.statusCode, error.message); throw new ErrorHandler(error.statusCode || 500, error.message || 'Delete failed');
} }
} }
} }

0
uploads/pdf/pdf-dd41285d-2025-11-13_13-38-05.pdf → uploads/pdf/pdf-d0ded6ba-2025-10-26_17-11-14.pdf
View File