361 lines
12 KiB
JavaScript
361 lines
12 KiB
JavaScript
// Brand operations
|
|
const {
|
|
getAllBrandsDb,
|
|
getBrandByIdDb,
|
|
getBrandByNameDb,
|
|
createBrandDb,
|
|
updateBrandDb,
|
|
deleteBrandDb,
|
|
checkBrandNameExistsDb,
|
|
} = require("../db/brand.db");
|
|
|
|
// Error code operations
|
|
const {
|
|
getErrorCodesByBrandIdDb,
|
|
createErrorCodeDb,
|
|
updateErrorCodeDb,
|
|
deleteErrorCodeDb,
|
|
} = require("../db/brand_code.db");
|
|
|
|
// Solution operations
|
|
const {
|
|
getSolutionsByErrorCodeIdDb,
|
|
createSolutionDb,
|
|
updateSolutionDb,
|
|
deleteSolutionDb,
|
|
} = require("../db/brand_code_solution.db");
|
|
const { getFileUploadByPathDb } = require("../db/file_uploads.db");
|
|
const { ErrorHandler } = require("../helpers/error");
|
|
|
|
class BrandService {
|
|
// Get all brands
|
|
static async getAllBrands(param) {
|
|
try {
|
|
const results = await getAllBrandsDb(param);
|
|
|
|
results.data.map((element) => {});
|
|
|
|
return results;
|
|
} catch (error) {
|
|
throw new ErrorHandler(error.statusCode, error.message);
|
|
}
|
|
}
|
|
|
|
// Get brand by ID with complete data
|
|
static async getBrandById(id) {
|
|
try {
|
|
const brand = await getBrandByIdDb(id);
|
|
if (!brand) throw new ErrorHandler(404, "Brand not found");
|
|
|
|
const errorCodes = await getErrorCodesByBrandIdDb(brand.brand_id);
|
|
|
|
const errorCodesWithSolutions = await Promise.all(
|
|
errorCodes.map(async (errorCode) => {
|
|
const solutions = await getSolutionsByErrorCodeIdDb(
|
|
errorCode.error_code_id
|
|
);
|
|
|
|
const solutionsWithFiles = await Promise.all(
|
|
solutions.map(async (solution) => {
|
|
let fileData = null;
|
|
// console.log('Processing solution:', {
|
|
// solution_id: solution.brand_code_solution_id,
|
|
// path_solution: solution.path_solution,
|
|
// type_solution: solution.type_solution
|
|
// });
|
|
|
|
if (solution.path_solution && solution.type_solution !== "text") {
|
|
fileData = await getFileUploadByPathDb(solution.path_solution);
|
|
console.log("File data found:", fileData);
|
|
}
|
|
|
|
const enhancedSolution = {
|
|
...solution,
|
|
file_upload_name: fileData?.file_upload_name || null,
|
|
path_document: fileData?.path_document || null,
|
|
};
|
|
|
|
// console.log('Enhanced solution:', {
|
|
// solution_id: enhancedSolution.brand_code_solution_id,
|
|
// original_path_solution: enhancedSolution.path_solution,
|
|
// path_document: enhancedSolution.path_document,
|
|
// file_upload_name: enhancedSolution.file_upload_name
|
|
// });
|
|
|
|
return enhancedSolution;
|
|
})
|
|
);
|
|
|
|
return {
|
|
...errorCode,
|
|
solution: solutionsWithFiles,
|
|
};
|
|
})
|
|
);
|
|
|
|
return {
|
|
...brand,
|
|
error_code: errorCodesWithSolutions,
|
|
};
|
|
} catch (error) {
|
|
throw new ErrorHandler(error.statusCode, error.message);
|
|
}
|
|
}
|
|
|
|
// Create brand
|
|
static async createBrandWithFullData(data) {
|
|
try {
|
|
if (!data || typeof data !== "object") data = {};
|
|
|
|
if (data.brand_name) {
|
|
const brandExists = await checkBrandNameExistsDb(data.brand_name);
|
|
if (brandExists) {
|
|
throw new ErrorHandler(400, "Brand name already exists");
|
|
}
|
|
}
|
|
|
|
if (
|
|
!data.error_code ||
|
|
!Array.isArray(data.error_code) ||
|
|
data.error_code.length === 0
|
|
) {
|
|
throw new ErrorHandler(
|
|
400,
|
|
"Brand must have at least 1 error code with solution"
|
|
);
|
|
}
|
|
|
|
for (const errorCode of data.error_code) {
|
|
if (
|
|
!errorCode.solution ||
|
|
!Array.isArray(errorCode.solution) ||
|
|
errorCode.solution.length === 0
|
|
) {
|
|
throw new ErrorHandler(
|
|
400,
|
|
`Error code ${errorCode.error_code} must have at least 1 solution`
|
|
);
|
|
}
|
|
}
|
|
|
|
const brandData = {
|
|
brand_name: data.brand_name,
|
|
brand_type: data.brand_type,
|
|
brand_manufacture: data.brand_manufacture,
|
|
brand_model: data.brand_model,
|
|
is_active: data.is_active,
|
|
created_by: data.created_by,
|
|
};
|
|
|
|
const createdBrand = await createBrandDb(brandData);
|
|
if (!createdBrand) {
|
|
throw new Error("Failed to create brand");
|
|
}
|
|
|
|
const brandId = createdBrand.brand_id;
|
|
|
|
for (const errorCodeData of data.error_code) {
|
|
const errorId = await createErrorCodeDb(brandId, {
|
|
error_code: errorCodeData.error_code,
|
|
error_code_name: errorCodeData.error_code_name,
|
|
error_code_description: errorCodeData.error_code_description,
|
|
error_code_color: errorCodeData.error_code_color,
|
|
path_icon: errorCodeData.path_icon,
|
|
is_active: errorCodeData.is_active,
|
|
created_by: data.created_by,
|
|
});
|
|
|
|
if (!errorId) {
|
|
throw new Error("Failed to create error code");
|
|
}
|
|
|
|
// Create solutions for this error code
|
|
if (errorCodeData.solution && Array.isArray(errorCodeData.solution)) {
|
|
for (const solutionData of errorCodeData.solution) {
|
|
await createSolutionDb(errorId, {
|
|
solution_name: solutionData.solution_name,
|
|
type_solution: solutionData.type_solution,
|
|
text_solution: solutionData.text_solution || null,
|
|
path_solution: solutionData.path_solution || null,
|
|
is_active: solutionData.is_active,
|
|
created_by: data.created_by,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return await this.getBrandById(brandId);
|
|
} catch (error) {
|
|
throw new ErrorHandler(500, `Bulk insert failed: ${error.message}`);
|
|
}
|
|
}
|
|
|
|
// Soft delete brand by ID
|
|
static async deleteBrand(id, userId) {
|
|
try {
|
|
const brandExist = await getBrandByIdDb(id);
|
|
|
|
if (!brandExist) {
|
|
throw new ErrorHandler(404, "Brand not found");
|
|
}
|
|
|
|
const result = await deleteBrandDb(id, userId);
|
|
|
|
return result;
|
|
} catch (error) {
|
|
throw new ErrorHandler(error.statusCode, error.message);
|
|
}
|
|
}
|
|
|
|
// Update brand
|
|
static async updateBrandWithFullData(id, data) {
|
|
try {
|
|
const existingBrand = await getBrandByIdDb(id);
|
|
if (!existingBrand) throw new ErrorHandler(404, "Brand not found");
|
|
|
|
if (data.brand_name && data.brand_name !== existingBrand.brand_name) {
|
|
const brandExists = await checkBrandNameExistsDb(data.brand_name, id);
|
|
if (brandExists) {
|
|
throw new ErrorHandler(400, "Brand name already exists");
|
|
}
|
|
}
|
|
|
|
const brandData = {
|
|
brand_name: data.brand_name,
|
|
brand_type: data.brand_type,
|
|
brand_manufacture: data.brand_manufacture,
|
|
brand_model: data.brand_model,
|
|
is_active: data.is_active,
|
|
updated_by: data.updated_by,
|
|
};
|
|
|
|
await updateBrandDb(existingBrand.brand_name, brandData);
|
|
|
|
if (data.error_code && Array.isArray(data.error_code)) {
|
|
const existingErrorCodes = await getErrorCodesByBrandIdDb(id);
|
|
const incomingErrorCodes = data.error_code.map((ec) => ec.error_code);
|
|
|
|
// Create/update/delete error codes
|
|
for (const errorCodeData of data.error_code) {
|
|
// Check if error code already exists
|
|
const existingEC = existingErrorCodes.find(
|
|
(ec) => ec.error_code === errorCodeData.error_code
|
|
);
|
|
|
|
if (existingEC) {
|
|
// Update existing error code using separate db function
|
|
await updateErrorCodeDb(
|
|
existingEC.brand_id,
|
|
existingEC.error_code,
|
|
{
|
|
error_code_name: errorCodeData.error_code_name,
|
|
error_code_description: errorCodeData.error_code_description,
|
|
error_code_color: errorCodeData.error_code_color,
|
|
path_icon: errorCodeData.path_icon,
|
|
is_active: errorCodeData.is_active,
|
|
updated_by: data.updated_by,
|
|
}
|
|
);
|
|
|
|
if (
|
|
errorCodeData.solution &&
|
|
Array.isArray(errorCodeData.solution)
|
|
) {
|
|
const existingSolutions = await getSolutionsByErrorCodeIdDb(
|
|
existingEC.error_code_id
|
|
);
|
|
const incomingSolutionNames = errorCodeData.solution.map(
|
|
(s) => s.solution_name
|
|
);
|
|
|
|
// Update or create solutions
|
|
for (const solutionData of errorCodeData.solution) {
|
|
const existingSolution = existingSolutions.find(
|
|
(s) => s.solution_name === solutionData.solution_name
|
|
);
|
|
|
|
if (existingSolution) {
|
|
// Update existing solution
|
|
await updateSolutionDb(
|
|
existingSolution.brand_code_solution_id,
|
|
{
|
|
solution_name: solutionData.solution_name,
|
|
type_solution: solutionData.type_solution,
|
|
text_solution: solutionData.text_solution || null,
|
|
path_solution: solutionData.path_solution || null,
|
|
is_active: solutionData.is_active,
|
|
updated_by: data.updated_by,
|
|
}
|
|
);
|
|
} else {
|
|
// Create new solution
|
|
await createSolutionDb(existingEC.error_code_id, {
|
|
solution_name: solutionData.solution_name,
|
|
type_solution: solutionData.type_solution,
|
|
text_solution: solutionData.text_solution || null,
|
|
path_solution: solutionData.path_solution || null,
|
|
is_active: solutionData.is_active,
|
|
created_by: data.updated_by,
|
|
});
|
|
}
|
|
}
|
|
|
|
// Delete solutions that are not in the incoming request
|
|
for (const existingSolution of existingSolutions) {
|
|
if (
|
|
!incomingSolutionNames.includes(
|
|
existingSolution.solution_name
|
|
)
|
|
) {
|
|
await deleteSolutionDb(
|
|
existingSolution.brand_code_solution_id,
|
|
data.updated_by
|
|
);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
const errorId = await createErrorCodeDb(id, {
|
|
error_code: errorCodeData.error_code,
|
|
error_code_name: errorCodeData.error_code_name,
|
|
error_code_description: errorCodeData.error_code_description,
|
|
error_code_color: errorCodeData.error_code_color,
|
|
path_icon: errorCodeData.path_icon,
|
|
is_active: errorCodeData.is_active,
|
|
created_by: data.updated_by,
|
|
});
|
|
|
|
if (
|
|
errorCodeData.solution &&
|
|
Array.isArray(errorCodeData.solution)
|
|
) {
|
|
for (const solutionData of errorCodeData.solution) {
|
|
await createSolutionDb(errorId, {
|
|
solution_name: solutionData.solution_name,
|
|
type_solution: solutionData.type_solution,
|
|
text_solution: solutionData.text_solution || null,
|
|
path_solution: solutionData.path_solution || null,
|
|
is_active: solutionData.is_active,
|
|
created_by: data.updated_by,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (const existingEC of existingErrorCodes) {
|
|
if (!incomingErrorCodes.includes(existingEC.error_code)) {
|
|
await deleteErrorCodeDb(id, existingEC.error_code, data.updated_by);
|
|
}
|
|
}
|
|
}
|
|
|
|
return await this.getBrandById(id);
|
|
} catch (error) {
|
|
throw new ErrorHandler(500, `Update failed: ${error.message}`);
|
|
}
|
|
}
|
|
}
|
|
|
|
module.exports = BrandService;
|