Merge pull request 'connect mqtt ws colo' (#38) from wisdom into main

Reviewed-on: #38

.gitignore

@@ -3,4 +3,5 @@ node_modules
 .vscode
 request.http
 *.rest
-package-lock.json
+package-lock.json
+*.log

config/index.js

@@ -292,12 +292,12 @@ const mqttOptions = {
   clientId: 'express_mqtt_client_' + Math.random().toString(16).substr(2, 8),
   clean: true,
   connectTimeout: 4000,
-  username: '', // jika ada
-  password: '', // jika ada
+  username: 'morekmorekmorek', // jika ada
+  password: 'morek888', // jika ada
 };
 
-const mqttUrl = 'ws://localhost:1884'; // Ganti dengan broker kamu
-const topic = 'morek';
+const mqttUrl = 'ws://117.102.231.130:7001'; // Ganti dengan broker kamu
+const topic = process.env.TOPIC_COD ?? 'morek';
 
 const mqttClient = mqtt.connect(mqttUrl, mqttOptions);
 

controllers/auth.controller.js

@@ -125,7 +125,8 @@ class AuthController {
 
     const response = await setResponse(
       {
-        accessToken: tokens.accessToken
+        accessToken: tokens.accessToken,
+        idData
       },
       'Verify successful'
     );

controllers/notification_error.controller.js

@@ -25,7 +25,6 @@ class NotificationErrorController {
     res.status(response.statusCode).json(response);
   }
 
-
   static async getById(req, res) {
     const { id } = req.params;
 
@@ -50,7 +49,10 @@ class NotificationErrorController {
     const results = await NotificationErrorService.createNotificationError(
       value
     );
-    const response = await setResponse(results, "Notification created successfully");
+    const response = await setResponse(
+      results,
+      "Notification created successfully"
+    );
 
     return res.status(response.statusCode).json(response);
   }
@@ -58,17 +60,27 @@ class NotificationErrorController {
   static async update(req, res) {
     const { id } = req.params;
 
-    const { error, value } = checkValidate(updateNotificationSchema, req)
+    const userId = req.user.user_id;
 
-    if (error) {
-      return res.status(400).json(setResponse(error, 'Validation failed', 400));
-    }
+    const results = await NotificationErrorService.updateNotificationError(
+      id,
+      userId
+    );
+    const response = await setResponse(
+      results,
+      "Notification Error updated successfully"
+    );
 
-    value.userId = req.user.user_id
-
-    const results = await NotificationErrorService.updateNotificationError(id, value);
-    const response = await setResponse(results, 'Notification Error User updated successfully')
+    res.status(response.statusCode).json(response);
+  }
 
+  static async resend(req, res) {
+    const { id } = req.params;
+    const results = await NotificationErrorService.resendNotification(id);
+    const response = await setResponse(
+      results,
+      "Notification Error resend successfully"
+    );
     res.status(response.statusCode).json(response);
   }
 }

controllers/notification_error_log.controller.js

@@ -55,9 +55,7 @@ class NotificationErrorLogController {
         return res.status(400).json(setResponse(error, 'Validation failed', 400));
       }
 
-      value.created_by = req.user.user_id;
-
-      const results = await NotificationErrorLogService.createNotificationErrorLog(value);
+      const results = await NotificationErrorLogService.createNotificationErrorLog(value, req.user.user_id);
       const response = await setResponse(results, 'Notification Error Log created successfully')
 
       return res.status(response.statusCode).json(response);

controllers/notification_error_user.controller.js

@@ -1,14 +1,28 @@
-const NotificationErrorUserService = require('../services/notification_error_user.service');
-const { setResponse, setResponsePaging, checkValidate } = require('../helpers/utils');
-const { insertNotificationErrorUserSchema, updateNotificationErrorUserSchema } = require('../validate/notification_error_user.schema');
+const NotificationErrorUserService = require("../services/notification_error_user.service");
+const {
+  setResponse,
+  setResponsePaging,
+  checkValidate,
+} = require("../helpers/utils");
+const {
+  insertNotificationErrorUserSchema,
+  updateNotificationErrorUserSchema,
+} = require("../validate/notification_error_user.schema");
 
 class NotificationErrorUserController {
   // Get all NotificationErrorUser
   static async getAll(req, res) {
     const queryParams = req.query;
 
-    const results = await NotificationErrorUserService.getAllNotificationErrorUser(queryParams);
-    const response = await setResponsePaging(queryParams, results, 'Notification Error User found')
+    const results =
+      await NotificationErrorUserService.getAllNotificationErrorUser(
+        queryParams
+      );
+    const response = await setResponsePaging(
+      queryParams,
+      results,
+      "Notification Error User found"
+    );
 
     res.status(response.statusCode).json(response);
   }
@@ -17,24 +31,35 @@ class NotificationErrorUserController {
   static async getById(req, res) {
     const { id } = req.params;
 
-    const results = await NotificationErrorUserService.getNotificationErrorUserById(id);
-    const response = await setResponse(results, 'Notification Error User found')
+    const results =
+      await NotificationErrorUserService.getNotificationErrorUserById(id);
+    const response = await setResponse(
+      results,
+      "Notification Error User found"
+    );
 
     res.status(response.statusCode).json(response);
   }
 
   // Create NotificationErrorUser
   static async create(req, res) {
-    const { error, value } = await checkValidate(insertNotificationErrorUserSchema, req)
+    const { error, value } = await checkValidate(
+      insertNotificationErrorUserSchema,
+      req
+    );
 
     if (error) {
-      return res.status(400).json(setResponse(error, 'Validation failed', 400));
+      return res.status(400).json(setResponse(error, "Validation failed", 400));
     }
 
-    value.userId = req.user.user_id
+    value.userId = req.user.user_id;
 
-    const results = await NotificationErrorUserService.createNotificationErrorUser(value);
-    const response = await setResponse(results, 'Notification Error User created successfully')
+    const results =
+      await NotificationErrorUserService.createNotificationErrorUser(value);
+    const response = await setResponse(
+      results,
+      "Notification Error User created successfully"
+    );
 
     return res.status(response.statusCode).json(response);
   }
@@ -43,16 +68,23 @@ class NotificationErrorUserController {
   static async update(req, res) {
     const { id } = req.params;
 
-    const { error, value } = checkValidate(updateNotificationErrorUserSchema, req)
+    const { error, value } = checkValidate(
+      updateNotificationErrorUserSchema,
+      req
+    );
 
     if (error) {
-      return res.status(400).json(setResponse(error, 'Validation failed', 400));
+      return res.status(400).json(setResponse(error, "Validation failed", 400));
     }
 
-    value.userId = req.user.user_id
+    value.userId = req.user.user_id;
 
-    const results = await NotificationErrorUserService.updateNotificationErrorUser(id, value);
-    const response = await setResponse(results, 'Notification Error User updated successfully')
+    const results =
+      await NotificationErrorUserService.updateNotificationErrorUser(id, value);
+    const response = await setResponse(
+      results,
+      "Notification Error User updated successfully"
+    );
 
     res.status(response.statusCode).json(response);
   }
@@ -61,11 +93,31 @@ class NotificationErrorUserController {
   static async delete(req, res) {
     const { id } = req.params;
 
-    const results = await NotificationErrorUserService.deleteNotificationErrorUser(id, req.user.user_id);
-    const response = await setResponse(results, 'Notification Error User deleted successfully')
+    const results =
+      await NotificationErrorUserService.deleteNotificationErrorUser(
+        id,
+        req.user.user_id
+      );
+    const response = await setResponse(
+      results,
+      "Notification Error User deleted successfully"
+    );
 
     res.status(response.statusCode).json(response);
   }
+
+  static async resendByUser(req, res) {
+    const { id, contact_phone } = req.params;
+    const results = await NotificationErrorUserService.resendNotificationByUser(
+      id,
+      contact_phone
+    );
+    const response = await setResponse(
+      results,
+      "Notification Error By User resend successfully"
+    );
+    res.status(response.statusCode).json(response);
+  }
 }
 
 module.exports = NotificationErrorUserController;

db/notification_error.db.js

@@ -14,14 +14,51 @@ const InsertNotificationErrorDb = async (store) => {
 const getNotificationByIdDb = async (id) => {
   const queryText = `
     SELECT
-      a.*
+      a.*,
+      b.plant_sub_section_id,
+      c.plant_sub_section_name,
+      d.device_code,
+      d.device_name,
+      d.device_location,
+      d.listen_channel,
+      e.brand_name
+
     FROM notification_error a
+
+    LEFT JOIN m_tags b
+        ON a.error_chanel = b.tag_number
+
+    LEFT JOIN m_plant_sub_section c
+        ON b.plant_sub_section_id = c.plant_sub_section_id
+
+    LEFT JOIN m_device d
+        ON a.error_chanel = d.listen_channel AND d.deleted_at IS NULL
+
+    LEFT JOIN m_brands e
+        ON d.brand_id = e.brand_id AND d.deleted_at IS NULL
+
     WHERE a.notification_error_id = $1 AND a.deleted_at IS NULL
   `;
   const result = await pool.query(queryText, [id]);
   return result.recordset[0];
 };
 
+const getDeviceNotificationByIdDb = async (chanel_id) => {
+  const queryText = `
+    SELECT 
+      device_code, 
+      device_name, 
+      device_location, 
+      listen_channel 
+
+    FROM m_device 
+    WHERE listen_channel = $1 
+    AND deleted_at IS NULL 
+  `;
+  const result = await pool.query(queryText, [chanel_id]);
+  return result.recordset[0];
+};
+
 
 const getAllNotificationDb = async (searchParams = {}) => {
   let queryParams = [];
@@ -82,8 +119,11 @@ const getAllNotificationDb = async (searchParams = {}) => {
       c.type_solution,
       c.path_solution,
 
+      d.device_code,
       d.device_name,
       d.device_location,
+      d.listen_channel,
+      e.brand_name,
 
       COALESCE(d.device_name, '') + ' - ' + COALESCE(b.error_code_name, '') AS device_name_error
 
@@ -96,7 +136,10 @@ const getAllNotificationDb = async (searchParams = {}) => {
         ON b.error_code_id = c.error_code_id AND c.deleted_at IS NULL
         
       LEFT JOIN m_device d
-        ON b.brand_id = d.brand_id AND d.deleted_at IS NULL
+        ON a.error_chanel = d.listen_channel AND d.deleted_at IS NULL
+
+      LEFT JOIN m_brands e
+        ON d.brand_id = e.brand_id AND d.deleted_at IS NULL
 
     WHERE a.deleted_at IS NULL
       ${whereConditions.length > 0 ? ` AND ${whereConditions.join(" AND ")}` : ""}
@@ -131,18 +174,22 @@ const updateNotificationErrorDb = async (id, data) => {
   return getNotificationByIdDb(id); 
 };
 
-const getReaderNotificationErrorDb = async (id) => {
+const getUsersNotificationErrorDb = async (id) => {
   const queryText = `
     SELECT 
+      b.notification_error_id,
       a.notification_error_user_id,
       a.contact_phone,
       a.contact_name,
       a.is_send,
-      b.message_error_issue
+      a.updated_at,
+      c.is_active
 
     FROM notification_error_user a
 
     LEFT JOIN notification_error b ON a.notification_error_id = b.notification_error_id
+
+    LEFT JOIN contact c ON a.contact_phone = c.contact_phone
     
     WHERE a.notification_error_id = $1 
       AND a.deleted_at IS NULL
@@ -154,9 +201,10 @@ const getReaderNotificationErrorDb = async (id) => {
 
 module.exports = {
   getNotificationByIdDb,
+  getDeviceNotificationByIdDb,
   getAllNotificationDb,
   InsertNotificationErrorDb,
   updateNotificationErrorDb,
-  getReaderNotificationErrorDb
+  getUsersNotificationErrorDb
   
 };

db/notification_error_log.db.js

@@ -7,7 +7,7 @@ const getAllNotificationErrorLogDb = async () => {
       b.contact_name,
       b.contact_type
     FROM notification_error_log a
-    LEFT JOIN contact b ON a.contact_id = b.contact_id
+    LEFT JOIN contact b ON a.contact_phone = b.contact_phone
     WHERE a.deleted_at IS NULL
     ORDER BY a.notification_error_log_id DESC
   `;
@@ -22,7 +22,7 @@ const getNotificationErrorLogByIdDb = async (id) => {
       b.contact_name,
       b.contact_type
     FROM notification_error_log a
-    LEFT JOIN contact b ON a.contact_id = b.contact_id
+    LEFT JOIN contact b ON a.contact_phone = b.contact_phone
     WHERE a.notification_error_log_id = $1 AND a.deleted_at IS NULL
   `;
   const result = await pool.query(queryText, [id]);
@@ -32,11 +32,15 @@ const getNotificationErrorLogByIdDb = async (id) => {
 const getNotificationErrorLogByNotificationErrorIdDb = async (notificationErrorId) => {
   const queryText = `
     SELECT
-      a.*,
-      b.contact_name,
-      b.contact_type
+      a.notification_error_log_description,
+      a.created_at,
+      b.contact_type,
+      c.user_fullname as created_by_name,
+      case when a.created_by is not null then c.user_fullname else b.contact_name end as contact_name,
+      case when a.created_by is not null then c.user_phone else a.contact_phone end as contact_phone
     FROM notification_error_log a
-    LEFT JOIN contact b ON a.contact_id = b.contact_id
+    LEFT JOIN contact b ON a.contact_phone = b.contact_phone
+    LEFT JOIN m_users c ON a.created_by = c.user_id
     WHERE a.notification_error_id = $1 AND a.deleted_at IS NULL
     ORDER BY a.created_at DESC
   `;
@@ -45,7 +49,27 @@ const getNotificationErrorLogByNotificationErrorIdDb = async (notificationErrorI
 };
 
 const createNotificationErrorLogDb = async (store) => {
-  const { query: queryText, values } = pool.buildDynamicInsert("notification_error_log", store);
+  const queryText = `
+    INSERT INTO notification_error_log (
+      notification_error_id, 
+      contact_phone, 
+      notification_error_log_description, 
+      created_by,
+      updated_by, 
+      created_at, 
+      updated_at
+    )
+    VALUES ($1, $2, $3, $4, $4, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP);
+    SELECT SCOPE_IDENTITY() as inserted_id;
+  `;
+
+  const values = [
+    store.notification_error_id,
+    store.contact_phone,
+    store.notification_error_log_description,
+    store.created_by
+  ];
+
   const result = await pool.query(queryText, values);
   const insertedId = result.recordset[0]?.inserted_id;
   return insertedId ? await getNotificationErrorLogByIdDb(insertedId) : null;

db/notification_error_user.db.js

@@ -10,10 +10,7 @@ const getAllNotificationErrorUserDb = async (searchParams = {}) => {
   }
 
   const { whereOrConditions, whereParamOr } = pool.buildStringOrIlike(
-    [
-      "a.notification_error_id",
-      "a.contact_id",
-    ],
+    ["a.notification_error_id", "a.contact_id"],
     searchParams.criteria,
     queryParams
   );
@@ -22,7 +19,11 @@ const getAllNotificationErrorUserDb = async (searchParams = {}) => {
 
   const { whereConditions, whereParamAnd } = pool.buildFilterQuery(
     [
-      { column: "a.notification_error_id", param: searchParams.name, type: "int" },
+      {
+        column: "a.notification_error_id",
+        param: searchParams.name,
+        type: "int",
+      },
       { column: "a.contact_id", param: searchParams.code, type: "int" },
     ],
     queryParams
@@ -36,10 +37,14 @@ const getAllNotificationErrorUserDb = async (searchParams = {}) => {
       a.*
     FROM notification_error_user a
     WHERE a.deleted_at IS NULL
-      ${whereConditions.length > 0 ? ` AND ${whereConditions.join(" AND ")}` : ""}
+      ${
+        whereConditions.length > 0
+          ? ` AND ${whereConditions.join(" AND ")}`
+          : ""
+      }
       ${whereOrConditions ? ` ${whereOrConditions}` : ""}
     ORDER BY a.notification_error_user_id ASC
-     ${searchParams.limit ? `OFFSET $2 * $1 ROWS FETCH NEXT $1 ROWS ONLY` : ''}
+     ${searchParams.limit ? `OFFSET $2 * $1 ROWS FETCH NEXT $1 ROWS ONLY` : ""}
   `;
 
   const result = await pool.query(queryText, queryParams);
@@ -55,16 +60,52 @@ const getAllNotificationErrorUserDb = async (searchParams = {}) => {
 const getNotificationErrorUserByIdDb = async (id) => {
   const queryText = `
     SELECT 
-      a.*
+      a.*,
+
+      b. is_active as contact_is_active,
+
+      d.error_code,
+      d.error_code_name,
+
+      e.device_name
+      
     FROM notification_error_user a
+    
+    LEFT JOIN contact b ON a.contact_phone = b.contact_phone
+
+    LEFT JOIN notification_error c ON a.notification_error_id = c.notification_error_id
+
+    LEFT JOIN brand_code d ON d.error_code_id = c.error_code_id
+
+    LEFT JOIN m_device e ON c.error_chanel = e.listen_channel
+
     WHERE a.notification_error_user_id = $1 AND a.deleted_at IS NULL
   `;
   const result = await pool.query(queryText, [id]);
   return result.recordset;
 };
 
+const getNotificationErrorByIdDb = async (notification_error_id) => {
+  const queryText = `
+    SELECT 
+      a.*,
+      b.is_active as contact_is_active,
+      c.is_read
+      
+    FROM notification_error_user a
+    LEFT JOIN contact b ON a.contact_phone = b.contact_phone
+    LEFT JOIN notification_error c ON a.notification_error_id = c.notification_error_id
+    WHERE a.notification_error_id = $1 AND a.deleted_at IS NULL
+  `;
+  const result = await pool.query(queryText, [notification_error_id]);
+  return result.recordset;
+};
+
 const createNotificationErrorUserDb = async (store) => {
-  const { query: queryText, values } = pool.buildDynamicInsert("notification_error_user", store);
+  const { query: queryText, values } = pool.buildDynamicInsert(
+    "notification_error_user",
+    store
+  );
   const result = await pool.query(queryText, values);
   const insertedId = result.recordset?.[0]?.inserted_id;
 
@@ -82,7 +123,7 @@ const updateNotificationErrorUserDb = async (id, data) => {
   );
 
   await pool.query(`${queryText} AND deleted_at IS NULL`, values);
-  return getNotificationErrorUserByIdDb(id); 
+  return getNotificationErrorUserByIdDb(id);
 };
 
 // Soft delete tag
@@ -99,6 +140,7 @@ const deleteNotificationErrorUserDb = async (id, deletedBy) => {
 module.exports = {
   getAllNotificationErrorUserDb,
   getNotificationErrorUserByIdDb,
+  getNotificationErrorByIdDb,
   createNotificationErrorUserDb,
   updateNotificationErrorUserDb,
   deleteNotificationErrorUserDb,

db/notification_wa.db.js

@@ -1,5 +1,11 @@
+// db/notification_wa.db.js
 const { default: axios } = require('axios');
 const CryptoJS = require('crypto-js');
+const https = require('https');
+
+const httpsAgent = new https.Agent({
+  rejectUnauthorized: false,
+});
 
 const generateTokenRedirect = async (userPhone, userName, id) => {
 
@@ -18,7 +24,7 @@ const shortUrltiny = async (encodedToken) => {
 
   const encodedUrl = encodeURIComponent(url); // ⬅️ Encode dulu!
 
-  const response = await axios.get(`https://tinyurl.com/api-create.php?url=${encodedUrl}`);
+  const response = await axios.get(`https://tinyurl.com/api-create.php?url=${encodedUrl}`,{httpsAgent}) ;
 
   let shortUrl = response.data;
   if (!shortUrl.startsWith('http')) {
@@ -38,11 +44,8 @@ const sendNotifikasi = async (phone, message) => {
 
   const endPointWhatsapp = process.env.ENDPOINT_WHATSAPP;
 
-  const response = await axios.post(endPointWhatsapp, payload);
-  // console.log('response', response);
-
   try {
-    const response = await axios.post(endPointWhatsapp, payload);
+    const response = await axios.post(endPointWhatsapp, payload,{httpsAgent} );
     // console.log(response.data);
     return response?.data
   } catch (error) {

ecosystem.config.js

@@ -1,7 +1,7 @@
 module.exports = {
   apps: [
     {
-      name: "bengkel-api",
+      name: "cod-api",
       script: "./index.js", // Path to your entry file
       env: {
         NODE_ENV: "development",
@@ -9,6 +9,14 @@ module.exports = {
       env_production: {
         NODE_ENV: "production",
       },
+      // Logging configuration
+      // error_file: "C:\IDETAMA\pm2-log\cod-api\cod-api-error.log",
+      // out_file: "C:\IDETAMA\pm2-log\cod-api\cod-api-out.log",
+      // log_file: "C:\IDETAMA\pm2-log\cod-api\cod-api-combined.log", // optional combined file
+      error_file: "cod-api-error.log",
+      out_file: "cod-api-out.log",
+      log_file: "cod-api-combined.log", // optional combined file
+      time: true, // adds timestamps to logs
     },
   ],
 };

middleware/verifyAccess.js

@@ -1,6 +1,10 @@
 const { ErrorHandler } = require("../helpers/error");
 const { getUserByIdDb } = require("../db/user.db");
 
+function isPhoneNumberID(phone) {
+  return /^(?:\+62|62|0)8[1-9][0-9]{6,10}$/.test(phone);
+}
+
 const verifyAccess = (minLevel = 1, allowUnapprovedReadOnly = false) => {
   return async (req, res, next) => {
     try {
@@ -11,21 +15,31 @@ const verifyAccess = (minLevel = 1, allowUnapprovedReadOnly = false) => {
       // Super Admin bypass semua
       if (user.is_sa) return next();
 
-      const fullUser = await getUserByIdDb(user.user_id);
-      if (!fullUser) throw new ErrorHandler(403, "Forbidden: User not found");
 
-      if (!fullUser.is_approve) {
-        if (req.method !== "GET") {
-          throw new ErrorHandler(403, "Account not approved — read-only access");
+      if (!isPhoneNumberID(user.user_id) && user.user_id) {
+        const fullUser = await getUserByIdDb(user.user_id);
+        if (!fullUser) throw new ErrorHandler(403, "Forbidden: User not found");
+
+        if (!fullUser.is_approve) {
+          if (req.method !== "GET") {
+            throw new ErrorHandler(403, "Account not approved — read-only access");
+          }
+
+          if (allowUnapprovedReadOnly) return next();
+
+          throw new ErrorHandler(403, "Account not approved");
         }
 
-        if (allowUnapprovedReadOnly) return next();
+        if (!fullUser.role_level || fullUser.role_level < minLevel) {
+          throw new ErrorHandler(403, "Forbidden: Insufficient role level");
+        }
+      } else {
+        if (req.method !== 'GET' && req.baseUrl !== '/api/notification-log') {
+          if (req.baseUrl !== '/api/notification') {
+            throw new ErrorHandler(403, "Forbidden: Insufficient Access");
+          }
+        }
 
-        throw new ErrorHandler(403, "Account not approved");
-      }
-
-      if (!fullUser.role_level || fullUser.role_level < minLevel) {
-        throw new ErrorHandler(403, "Forbidden: Insufficient role level");
       }
 
       next();

routes/notification_error.route.js

@@ -1,21 +1,40 @@
-const express = require('express');
-const NotificationErrorController = require('../controllers/notification_error.controller');
-const verifyToken = require('../middleware/verifyToken');
-const verifyAccess = require('../middleware/verifyAccess');
+const express = require("express");
+const NotificationErrorController = require("../controllers/notification_error.controller");
+const verifyToken = require("../middleware/verifyToken");
+const verifyAccess = require("../middleware/verifyAccess");
 
 const router = express.Router();
 
 router
-  .route('/')
-  .get(verifyToken.verifyAccessToken,verifyAccess(), NotificationErrorController.getAll)
-
-  router
-  .route('/')
-  .post(verifyToken.verifyAccessToken,verifyAccess(), NotificationErrorController.create)
+  .route("/")
+  .get(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorController.getAll
+  );
 
 router
-  .route('/:id')
-  .get(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorController.getById)
-  .put(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorController.update)
+  .route("/")
+  .post(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorController.create
+  );
+
+router
+  .route("/:id")
+  .get(verifyToken.verifyAccessToken, NotificationErrorController.getById)
+  .put(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorController.update
+  );
+
+router.post(
+  "/resend/:id",
+  verifyToken.verifyAccessToken,
+  verifyAccess(),
+  NotificationErrorController.resend
+);
 
 module.exports = router;

routes/notification_error_log.route.js

@@ -7,7 +7,10 @@ const router = express.Router();
 
 router.route("/")
     .get(verifyToken.verifyAccessToken, NotificationErrorLogController.getAll)
-    .post(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorLogController.create);
+    .post(
+        verifyToken.verifyAccessToken,
+        verifyAccess(),
+        NotificationErrorLogController.create);
 
 router.route("/:id")
     .get(verifyToken.verifyAccessToken, NotificationErrorLogController.getById);

routes/notification_error_user.route.js

@@ -1,17 +1,38 @@
-const express = require('express');
-const NotificationErrorUserController = require('../controllers/notification_error_user.controller');
-const verifyToken = require("../middleware/verifyToken")
-const verifyAccess = require("../middleware/verifyAccess")
+const express = require("express");
+const NotificationErrorUserController = require("../controllers/notification_error_user.controller");
+const verifyToken = require("../middleware/verifyToken");
+const verifyAccess = require("../middleware/verifyAccess");
 
 const router = express.Router();
 
-router.route("/")
-    .get(verifyToken.verifyAccessToken, NotificationErrorUserController.getAll)
-    .post(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorUserController.create);
+router
+  .route("/")
+  .get(verifyToken.verifyAccessToken, NotificationErrorUserController.getAll)
+  .post(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorUserController.create
+  );
 
-router.route("/:id")
-    .get(verifyToken.verifyAccessToken, NotificationErrorUserController.getById)
-    .put(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorUserController.update)
-    .delete(verifyToken.verifyAccessToken, verifyAccess(), NotificationErrorUserController.delete);
+router
+  .route("/:id")
+  .get(verifyToken.verifyAccessToken, NotificationErrorUserController.getById)
+  .put(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorUserController.update
+  )
+  .delete(
+    verifyToken.verifyAccessToken,
+    verifyAccess(),
+    NotificationErrorUserController.delete
+  );
 
-module.exports = router;
+router.post(
+  "/resend/:id/:contact_phone",
+  verifyToken.verifyAccessToken,
+  verifyAccess(),
+  NotificationErrorUserController.resendByUser
+);
+
+module.exports = router;

services/error_code.service.js

@@ -119,17 +119,6 @@ class ErrorCodeService {
     try {
       if (!data || typeof data !== "object") data = {};
 
-      if (
-        !data.solution ||
-        !Array.isArray(data.solution) ||
-        data.solution.length === 0
-      ) {
-        throw new ErrorHandler(
-          400,
-          "Error code must have at least 1 solution"
-        );
-      }
-
       const errorId = await createErrorCodeDb(brandId, {
         error_code: data.error_code,
         error_code_name: data.error_code_name,

services/notification_error.service.js

@@ -1,70 +1,86 @@
+// services/notification_error.service.js
 const {
   getAllNotificationDb,
   getNotificationByIdDb,
   InsertNotificationErrorDb,
-  getReaderNotificationErrorDb,
+  getUsersNotificationErrorDb,
   updateNotificationErrorDb,
-} = require('../db/notification_error.db');
+} = require("../db/notification_error.db");
 
-const {
-  getErrorCodeByIdDb,
-} = require('../db/brand_code.db');
-
-const {
-  getSolutionsByErrorCodeIdDb,
-} = require('../db/brand_code_solution.db');
+const { getErrorCodeByIdDb } = require("../db/brand_code.db");
 
+const { getSolutionsByErrorCodeIdDb } = require("../db/brand_code_solution.db");
 
 const {
   getAllNotificationErrorLogDb,
   getNotificationErrorLogByNotificationErrorIdDb,
-} = require('../db/notification_error_log.db');
+} = require("../db/notification_error_log.db");
+
+const { getSparepartsByErrorCodeIdDb } = require("../db/brand_sparepart.db");
 
 const {
-  getSparepartsByErrorCodeIdDb,
-} = require('../db/brand_sparepart.db');
+  getNotificationErrorByIdDb,
+} = require("../db/notification_error_user.db");
 
-const { getFileUploadByPathDb } = require('../db/file_uploads.db');
+const { getFileUploadByPathDb } = require("../db/file_uploads.db");
 
-const { ErrorHandler } = require('../helpers/error');
+const {
+  generateTokenRedirect,
+  shortUrltiny,
+  sendNotifikasi,
+} = require("../db/notification_wa.db");
+
+const { ErrorHandler } = require("../helpers/error");
 
 class NotificationService {
-  // Get all Notifications
   static async getAllNotification(param) {
     try {
       const results = await getAllNotificationDb(param);
 
-      results.data.map(element => {
-      });
-
+      if (results && Array.isArray(results.data)) {
+        results.data = await Promise.all(
+          results.data.map(async (notification) => {
+            const usersNotification =
+              (await getUsersNotificationErrorDb(
+                notification.notification_error_id
+              )) || [];
+            return {
+              ...notification,
+              users: usersNotification,
+            };
+          })
+        );
+      }
       return results;
     } catch (error) {
       throw new ErrorHandler(error.statusCode, error.message);
     }
   }
 
-   static async createNotificationError(data) {
+  static async createNotificationError(data) {
     try {
-      if (!data || typeof data !== 'object') data = {};
+      if (!data || typeof data !== "object") data = {};
 
       const result = await InsertNotificationErrorDb(data);
 
       return result;
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      return error;
     }
   }
 
-  // Get notification by ID
   static async getNotificationById(id) {
     try {
       const notification = await getNotificationByIdDb(id);
 
-      if (!notification || (Array.isArray(notification) && notification.length < 1)) {
-        throw new ErrorHandler(404, 'Notification not found');
+      if (
+        !notification ||
+        (Array.isArray(notification) && notification.length < 1)
+      ) {
+        throw new ErrorHandler(404, "Notification not found");
       }
 
-      const readerNotification = (await getReaderNotificationErrorDb(id))|| [];
+      const usersNotification = (await getUsersNotificationErrorDb(id)) || [];
 
       // Get error code details if error_code_id exists
       if (notification.error_code_id) {
@@ -72,16 +88,24 @@ class NotificationService {
 
         if (errorCode) {
           // Get solutions for this error code
-          const solutions = (await getSolutionsByErrorCodeIdDb(errorCode.error_code_id)) || [];
+          const solutions =
+            (await getSolutionsByErrorCodeIdDb(errorCode.error_code_id)) || [];
 
-          const spareparts = (await getSparepartsByErrorCodeIdDb(errorCode.error_code_id)) || [];
+          const spareparts =
+            (await getSparepartsByErrorCodeIdDb(errorCode.error_code_id)) || [];
 
           const solutionsWithDetails = await Promise.all(
             solutions.map(async (solution) => {
               let fileData = null;
-              if (solution.path_solution && solution.type_solution && solution.type_solution !== 'text') {
+              if (
+                solution.path_solution &&
+                solution.type_solution &&
+                solution.type_solution !== "text"
+              ) {
                 try {
-                  fileData = await getFileUploadByPathDb(solution.path_solution);
+                  fileData = await getFileUploadByPathDb(
+                    solution.path_solution
+                  );
                 } catch (e) {
                   fileData = null;
                 }
@@ -89,12 +113,11 @@ class NotificationService {
               return {
                 ...solution,
                 file_upload_name: fileData?.file_upload_name || null,
-                path_document: fileData?.path_document || null
+                path_document: fileData?.path_document || null,
               };
             })
           );
 
-
           notification.error_code = {
             ...errorCode,
             solution: solutionsWithDetails,
@@ -104,9 +127,10 @@ class NotificationService {
       }
 
       // Get activity logs for this notification
-      const notificationLogs = (await getNotificationErrorLogByNotificationErrorIdDb(id)) || [];
+      const notificationLogs =
+        (await getNotificationErrorLogByNotificationErrorIdDb(id)) || [];
 
-      notification.reader = readerNotification;
+      notification.users = usersNotification;
 
       notification.activity_logs = notificationLogs;
 
@@ -116,23 +140,128 @@ class NotificationService {
     }
   }
 
-  static async updateNotificationError(id, data) {
+  static async updateNotificationError(notification_error_id, data) {
     try {
-      if (!data || typeof data !== 'object') data = {};
+      const dataExist = await getNotificationErrorByIdDb(notification_error_id);
 
-      const dataExist = await getNotificationByIdDb(id);
-
-      if (dataExist.length < 1) {
-        throw new ErrorHandler(404, 'NotificationErrorUser not found');
+      if (!dataExist || (Array.isArray(dataExist) && dataExist.length < 1)) {
+        throw new ErrorHandler(404, "Notification Error User not found");
       }
 
-      const result = await updateNotificationErrorDb(id, data);
+      const notification = Array.isArray(dataExist) ? dataExist[0] : dataExist;
 
-      return result;
+      if (notification.is_read === true) {
+        return { success: true, message: "Notification has already been read" };
+      }
+
+      if (!notification.is_read) {
+        const updateStatus = await updateNotificationErrorDb(
+          notification_error_id,
+          { is_read: true }
+        );
+
+        if (!updateStatus) {
+          throw new ErrorHandler(500, "Failed to update notification");
+        }
+      }
+
+      return { success: true, message: "Notification marked as read" };
     } catch (error) {
-      throw new ErrorHandler(error.statusCode, error.message);
+      throw new ErrorHandler(error.statusCode || 500, error.message);
     }
   }
+
+  static async resendNotification(id) {
+    const deviceNotification = await getNotificationByIdDb(id);
+    if (!deviceNotification)
+      throw new ErrorHandler(404, "Notification Data not found");
+
+    const errorCode = await getErrorCodeByIdDb(
+      deviceNotification.error_code_id
+    );
+    const dataExist = await getUsersNotificationErrorDb(id);
+
+    const activeUsers =
+      dataExist?.filter((user) => user.is_active === true) || [];
+
+    if (activeUsers.length < 1)
+      throw new ErrorHandler(404, "No active contacts");
+
+    this._executeResendWa(
+      id,
+      activeUsers,
+      deviceNotification,
+      errorCode
+    ).catch((err) => console.error("Background Process Error:", err));
+
+    return {
+      count: activeUsers.length,
+    };
+  }
+
+  static async _executeResendWa(
+    id,
+    activeUsers,
+    deviceNotification,
+    errorCode
+  ) {
+    console.log(`user active: `, id, activeUsers);
+
+    const sendPromises = activeUsers.map(async (user) => {
+      try {
+       console.log(`user: ${user.contact_name} (${user.contact_phone})`);
+        const tokenRedirect = await generateTokenRedirect(
+          user.contact_phone,
+          user.contact_name,
+          id
+        );
+
+        const encodedToken = encodeURIComponent(tokenRedirect);
+        console.log("token: ", tokenRedirect);
+        const shortUrl = await shortUrltiny(encodedToken);
+        console.log("URL:", shortUrl);
+
+        const bodyWithUrl =
+          `Hai ${user.contact_name || "-"}\n` +
+          `Terjadi peringatan dengan kode ${errorCode?.error_code || "-"} - ${
+            errorCode?.error_code_name
+          } pada device ${deviceNotification.device_name || "-"}.\n` +
+          `Silahkan cek detail pada link berikut:\n ${shortUrl}`;
+
+        const resultSend = await sendNotifikasi(
+          user.contact_phone,
+          bodyWithUrl
+        );
+        
+        console.log("notifikasi wa:", resultSend)
+
+        const isSuccess = resultSend?.error ? false : true;
+
+        await updateNotificationErrorDb(user.notification_error_id, {
+          is_send: isSuccess,
+          is_delivered: isSuccess,
+        });
+
+        return { phone: user.contact_phone, status: "success" };
+      } catch (err) {
+        console.error(`Gagal mengirim ke ${user.contact_phone}:`, err.message);
+        return {
+          phone: user.contact_phone,
+          status: "failed",
+          error: err.message,
+        };
+      }
+    });
+
+    const results = await Promise.all(sendPromises);
+    console.log("result akhir: ", results)
+
+    console.log(
+      `Resend chat: ${
+        results.filter((r) => r.status === "success").length
+      }, Gagal: ${results.filter((r) => r.status === "failed").length}`
+    );
+  }
 }
 
 module.exports = NotificationService;

services/notification_error_log.service.js

@@ -7,6 +7,7 @@ const {
   deleteNotificationErrorLogDb
 } = require('../db/notification_error_log.db');
 
+const { getUserByIdDb } = require('../db/user.db');
 const { ErrorHandler } = require('../helpers/error');
 
 class NotificationErrorLogService {
@@ -40,15 +41,34 @@ class NotificationErrorLogService {
   }
 
   // Create Notification Error Log
-  static async createNotificationErrorLog(data) {
+  static async createNotificationErrorLog(data, userId) {
     try {
       if (!data || typeof data !== 'object') data = {};
 
+      let createdBy = null;
+      let contactPhone = data.contact_phone || null;
+
+      if (userId) {
+        try {
+          const user = await getUserByIdDb(userId);
+
+          if (user && user.user_id) {
+            createdBy = Number(user.user_id);
+          } else {
+            createdBy = null;
+            contactPhone = userId;
+          }
+        } catch (dbError) {
+          createdBy = null;
+          contactPhone = userId;
+        }
+      }
+
       const store = {
         notification_error_id: data.notification_error_id,
-        contact_id: data.contact_id,
+        contact_phone: contactPhone,
         notification_error_log_description: data.notification_error_log_description,
-        created_by: data.created_by
+        created_by: createdBy
       };
 
       const result = await createNotificationErrorLogDb(store);

services/notification_error_user.service.js

@@ -3,9 +3,16 @@ const {
   getNotificationErrorUserByIdDb,
   createNotificationErrorUserDb,
   updateNotificationErrorUserDb,
-  deleteNotificationErrorUserDb
-} = require('../db/notification_error_user.db');
-const { ErrorHandler } = require('../helpers/error');
+  deleteNotificationErrorUserDb,
+} = require("../db/notification_error_user.db");
+
+const {
+  generateTokenRedirect,
+  shortUrltiny,
+  sendNotifikasi,
+} = require("../db/notification_wa.db");
+
+const { ErrorHandler } = require("../helpers/error");
 
 class NotificationErrorUserService {
   // Get all Contact
@@ -13,10 +20,9 @@ class NotificationErrorUserService {
     try {
       const results = await getAllNotificationErrorUserDb(param);
 
-      results.data.map(element => {
-      });
+      results.data.map((element) => {});
 
-      return results
+      return results;
     } catch (error) {
       throw new ErrorHandler(error.statusCode, error.message);
     }
@@ -27,7 +33,8 @@ class NotificationErrorUserService {
     try {
       const result = await getNotificationErrorUserByIdDb(id);
 
-      if (result.length < 1) throw new ErrorHandler(404, 'NotificationErrorUser not found');
+      if (result.length < 1)
+        throw new ErrorHandler(404, "Notification Error User not found");
 
       return result;
     } catch (error) {
@@ -38,7 +45,7 @@ class NotificationErrorUserService {
   // Create NotificationErrorUser
   static async createNotificationErrorUser(data) {
     try {
-      if (!data || typeof data !== 'object') data = {};
+      if (!data || typeof data !== "object") data = {};
 
       const result = await createNotificationErrorUserDb(data);
 
@@ -51,12 +58,12 @@ class NotificationErrorUserService {
   // Update NotificationErrorUser
   static async updateNotificationErrorUser(id, data) {
     try {
-      if (!data || typeof data !== 'object') data = {};
+      if (!data || typeof data !== "object") data = {};
 
       const dataExist = await getNotificationErrorUserByIdDb(id);
 
       if (dataExist.length < 1) {
-        throw new ErrorHandler(404, 'NotificationErrorUser not found');
+        throw new ErrorHandler(404, "Notification Error User not found");
       }
 
       const result = await updateNotificationErrorUserDb(id, data);
@@ -73,7 +80,7 @@ class NotificationErrorUserService {
       const dataExist = await getNotificationErrorUserByIdDb(id);
 
       if (dataExist.length < 1) {
-        throw new ErrorHandler(404, 'NotificationErrorUser not found');
+        throw new ErrorHandler(404, "Notification Error User not found");
       }
 
       const result = await deleteNotificationErrorUserDb(id, userId);
@@ -83,6 +90,106 @@ class NotificationErrorUserService {
       throw new ErrorHandler(error.statusCode, error.message);
     }
   }
+
+  static async resendNotificationByUser(id, contact_phone) {
+    const results = [];
+
+    const idUser = Array.isArray(id) ? id : [id];
+
+    for (const id of idUser) {
+      try {
+        const dataExist = await getNotificationErrorUserByIdDb(id);
+
+        if (!dataExist || dataExist.length < 1) {
+          results.push({
+            id,
+            status: "failed",
+            message: "Data Notification Error User not found",
+          });
+          continue;
+        }
+
+        const data = dataExist[0];
+
+        if (data.contact_phone !== contact_phone) {
+          results.push({
+            id,
+            status: "failed",
+            message: `Phone ${contact_phone} not found.`,
+          });
+          continue;
+        }
+
+        if (data.contact_is_active === false) {
+          results.push({
+            id,
+            status: "failed",
+            message: `Contact ${data.contact_phone} not active.`,
+          });
+          continue;
+        }
+
+        const tokenRedirect = await generateTokenRedirect(
+          data.contact_phone,
+          data.contact_name,
+          data.notification_error_id
+        );
+
+        const encodedToken = encodeURIComponent(tokenRedirect);
+        const shortUrl = await shortUrltiny(encodedToken);
+
+        const bodyWithUrl =
+          `Hai ${data.contact_name || "-"}\n` +
+          `Terjadi peringatan dengan kode error ${data.error_code || "-"} - ${
+            data.error_code_name || "-"
+          } ` +
+          `pada device ${
+            data.device_name || "-"
+          }, silahkan cek detail pada link berikut:\n` +
+          `${shortUrl}`;
+
+        const resultSend = await sendNotifikasi(
+          data.contact_phone,
+          bodyWithUrl
+        );
+        const isSuccess = resultSend?.error ? false : true;
+
+        const updateData = {
+          is_send: isSuccess,
+          message_error_issue: bodyWithUrl,
+        };
+
+        await updateNotificationErrorUserDb(id, updateData);
+
+        if (!isSuccess) {
+          results.push({
+            id,
+            status: "failed",
+            message: `WhatsApp API Gagal: ${
+              resultSend?.message || "Unknown Error"
+            }`,
+          });
+        } else {
+          results.push({
+            status: 200,
+            notification_error_user_id: id,
+            notification_error_id: data.notification_error_id,
+            device_name: data.device_name,
+            error_code: data?.error_code,
+            error_code_name: data?.error_code_name,
+            users: {
+              contact_name: data.contact_name,
+              contact_phone: data.contact_phone,
+              is_send: isSuccess,
+            },
+          });
+        }
+      } catch (err) {
+        results.push({ id, status: "error", message: err.message });
+      }
+    }
+    return results;
+  }
 }
 
 module.exports = NotificationErrorUserService;

services/notifikasi-wa.service.js

@@ -1,19 +1,26 @@
-const { getAllContactDb } = require('../db/contact.db');
-const { InsertNotificationErrorDb } = require('../db/notification_error.db');
-const { createNotificationErrorUserDb, updateNotificationErrorUserDb } = require('../db/notification_error_user.db');
-const { generateTokenRedirect, shortUrltiny, sendNotifikasi } = require('../db/notification_wa.db');
+const { getAllContactDb } = require("../db/contact.db");
+const { InsertNotificationErrorDb } = require("../db/notification_error.db");
+const {
+  createNotificationErrorUserDb,
+  updateNotificationErrorUserDb,
+} = require("../db/notification_error_user.db");
+const {
+  generateTokenRedirect,
+  shortUrltiny,
+  sendNotifikasi,
+} = require("../db/notification_wa.db");
+const { getErrorCodeByIdDb } = require("../db/brand_code.db");
+const { getDeviceNotificationByIdDb } = require("../db/notification_error.db");
 
 class NotifikasiWaService {
-
   async onNotification(topic, message) {
-
     try {
       const paramDb = {
         limit: 100,
         page: 1,
-        criteria: '',
-        active: 1
-      }
+        criteria: "",
+        active: 1,
+      };
 
       // const chanel = {
       //   "time": "2025-12-11 11:10:58",
@@ -22,84 +29,97 @@ class NotifikasiWaService {
       //   "c_6501": 0
       // }
 
-      if (topic === 'morek') {
-
+      if (topic === process.env.TOPIC_COD ?? "morek") {
         const dataMqtt = JSON.parse(message);
 
         const resultChanel = [];
 
         Object.entries(dataMqtt).forEach(([key, value]) => {
-          if (key.startsWith('c_')) {
+          if (key.startsWith("c_")) {
             resultChanel.push({
               chanel_id: Number(key.slice(2)),
-              value
+              value,
             });
           }
         });
 
         const results = await getAllContactDb(paramDb);
 
-        const bodyMessage = `Hai Operator\n` +
-          `Terjadi peringatan pada device, silahkan cek detail pada link berikut :\n`;
-
         const dataUsers = results.data;
 
         for (const chanel of resultChanel) {
-          const data = {
-            "error_code_id": chanel.value,
-            "error_chanel": chanel.chanel_id,
-            "message_error_issue": bodyMessage,
-            "is_send": false,
-            "is_delivered": false,
-            "is_read": false,
-            "is_active": true
-          }
+          const errorCode = await getErrorCodeByIdDb(chanel.value);
+          const deviceNotification = await getDeviceNotificationByIdDb(
+            chanel.chanel_id
+          );
 
-          const resultNotificationError = await InsertNotificationErrorDb(data)
+          const data = {
+            error_code_id: chanel.value,
+            error_chanel: chanel.chanel_id,
+            is_send: false,
+            is_delivered: false,
+            is_read: false,
+            is_active: true,
+          };
+
+          const resultNotificationError = await InsertNotificationErrorDb(data);
 
           for (const dataUser of dataUsers) {
             if (dataUser.is_active) {
+              const tokenRedirect = await generateTokenRedirect(
+                dataUser.userPhone,
+                dataUser.userName,
+                resultNotificationError.notification_error_id
+              );
+
+              const encodedToken = encodeURIComponent(tokenRedirect);
+
+              const shortUrl = await shortUrltiny(encodedToken);
+
+              const bodyMessage =
+                `Hai ${dataUser.contact_name || "-"}\n` +
+                `Terjadi peringatan dengan kode error ${errorCode?.error_code || "-"
+                } - ${errorCode?.error_code_name || "-"} ` +
+                `pada device ${deviceNotification?.device_name || "-"
+                }, silahkan cek detail pada link berikut:\n` +
+                `${shortUrl}`;
 
               const param = {
                 idData: resultNotificationError.notification_error_id,
                 userPhone: dataUser.contact_phone,
                 userName: dataUser.contact_name,
                 bodyMessage: bodyMessage,
-              }
+              };
 
-              const tokenRedirect = await generateTokenRedirect(param.userPhone, param.userName, param.idData)
+              const resultNotificationErrorUser =
+                await createNotificationErrorUserDb({
+                  notification_error_id:
+                    resultNotificationError.notification_error_id,
+                  contact_phone: param.userPhone,
+                  contact_name: param.userName,
+                  is_send: false,
+                });
 
-              const encodedToken = encodeURIComponent(tokenRedirect);
+              const resultSend = await sendNotifikasi(
+                param.userPhone,
+                param.bodyMessage
+              );
 
-              const shortUrl = await shortUrltiny(encodedToken)
-
-              let bodyWithUrl = `${param.bodyMessage}\n🔗 ${shortUrl}`;
-
-              param.bodyMessage = bodyWithUrl
-
-              const resultNotificationErrorUser = await createNotificationErrorUserDb({
-                notification_error_id: resultNotificationError.notification_error_id,
-                contact_phone: param.userPhone,
-                contact_name: param.userName,
-                is_send: false,
-              });
-
-              const resultSend = await sendNotifikasi(param.userPhone, param.bodyMessage);
-
-              await updateNotificationErrorUserDb(resultNotificationErrorUser[0].notification_error_user_id, {
-                is_send: resultSend?.error ? false : true,
-              });
+              await updateNotificationErrorUserDb(
+                resultNotificationErrorUser[0].notification_error_user_id,
+                {
+                  is_send: resultSend?.error ? false : true,
+                }
+              );
             }
           }
         }
       }
-
     } catch (error) {
       // throw new ErrorHandler(error.statusCode, error.message);
-      return error
+      return error;
     }
   }
-
 }
 
 module.exports = new NotifikasiWaService();

validate/error_code.schema.js

@@ -31,11 +31,12 @@ const insertErrorCodeSchema = Joi.object({
   is_active: Joi.boolean().default(true),
   solution: Joi.array()
     .items(solutionSchema)
-    .min(1)
-    .required()
-    .messages({
-      "array.min": "Error code must have at least 1 solution",
-    }),
+    .optional(),
+  // .min(1)
+  // .required()
+  // .messages({
+  //   "array.min": "Error code must have at least 1 solution",
+  // }),
   spareparts: Joi.array()
     .items(Joi.number().integer())
     .optional(),

validate/notification.schema.js

@@ -40,21 +40,11 @@ const insertNotificationSchema = Joi.object({
 // Update Notification Schema
 // ========================
 const updateNotificationSchema = Joi.object({
-  is_send: Joi.boolean().optional().messages({
-    "boolean.base": "is_send must be a boolean",
-  }),
-
-  is_delivered: Joi.boolean().optional().messages({
-    "boolean.base": "is_delivered must be a boolean",
-  }),
 
   is_read: Joi.boolean().optional().messages({
     "boolean.base": "is_read must be a boolean",
   }),
-
-  is_active: Joi.boolean().optional().messages({
-    "boolean.base": "is_active must be a boolean",
-  }),
+  
 });
 
 module.exports = {

validate/notification_error_log.schema.js

@@ -2,7 +2,7 @@ const Joi = require("joi");
 
 const insertNotificationErrorLogSchema = Joi.object({
   notification_error_id: Joi.number().integer().required(),
-  contact_id: Joi.number().integer().required(),
+  contact_phone: Joi.string().optional(),
   notification_error_log_description: Joi.string().required()
 });