add feature admin give province to sales & schedule notification

config/config.ts

@@ -5,11 +5,4 @@ dotenv.config();
 export const config = {
   port: process.env.PORT ? parseInt(process.env.PORT) : 3000,
   BASE_URL: process.env.BASE_URL || 'http://localhost:3200',
-};
-
-// require('dotenv').config();
-
-// module.exports = {
-//   port: process.env.PORT || 3000,
-//   BASE_URL: process.env.BASE_URL || 'http://localhost:3200'
-// };
+};

config/keycloak.ts

@@ -7,15 +7,4 @@ export const CLIENT_ID = process.env.CLIENT_ID as string;
 export const CLIENT_SECRET = process.env.CLIENT_SECRET as string;
 export const JWT_SECRET = process.env.JWT_SECRET as string;
 export const KEYCLOAK_ADMIN_URL = process.env.KEYCLOAK_ADMIN_URL as string;
-export const KEYCLOAK_REALM = process.env.KEYCLOAK_REALM as string;
-
-// require('dotenv').config();
-
-// module.exports = {
-//     KEYCLOAK_TOKEN_URL: process.env.KEYCLOAK_TOKEN_URL,
-//     CLIENT_ID: process.env.CLIENT_ID,
-//     CLIENT_SECRET: process.env.CLIENT_SECRET,
-//     JWT_SECRET: process.env.JWT_SECRET,
-//     KEYCLOAK_ADMIN_URL: process.env.KEYCLOAK_ADMIN_URL,
-//     KEYCLOAK_REALM: process.env.KEYCLOAK_REALM,
-// };
+export const KEYCLOAK_REALM = process.env.KEYCLOAK_REALM as string;

index.ts

@@ -17,8 +17,10 @@ import CategoryRoutes from './src/routes/admin/CategoryRoute';
 import ScheduleVisitationRoutes from './src/routes/admin/ScheduleVisitationRoute';
 import ScheduleVisitationForSalesRoutes from './src/routes/sales/ScheduleVisitationRoute';
 import salesRoutes from './src/routes/admin/SalesRoute';
+import userAreaRoutes from './src/routes/admin/UserAreaRoute';
 
 import './src/utils/Scheduler';
+import "./src/utils/ScheduleNotification";
 
 const app: Application = express();
 
@@ -47,6 +49,7 @@ app.use('/storage/', express.static(path.join(__dirname, 'storage/')));
 const apiV1 = express.Router();
 apiV1.use('/province', provinceRoutes);
 apiV1.use('/sales', salesRoutes);
+apiV1.use('/user-area', userAreaRoutes);
 apiV1.use('/city', cityRoutes);
 apiV1.use('/hospital', hospitalRoutes);
 apiV1.use('/hospital-area', salesHospitalRoutes);

prisma/migrations/20250902131957_add_field_in_userkeycloak/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "keycloak_users" ADD COLUMN     "phone" TEXT;

prisma/migrations/20250903020800_add_role_in_userkeycloak/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "keycloak_users" ADD COLUMN     "role" TEXT;

prisma/schema.prisma

@@ -61,6 +61,8 @@ model User {
 model UserKeycloak {
   id                 String               @id @default(uuid())
   fullname           String
+  phone              String?
+  role               String?
   Hospital           Hospital[]
   UserArea           UserArea[]
   Vendor             Vendor[]

src/controllers/admin/CityController.ts

@@ -57,66 +57,4 @@ export const deleteCity = async (req: Request, res: Response): Promise<Response>
     } catch (err) {
         return errorResponse(res, err);
     }
-};
-
-// const { CityCollection } = require('../../resources/admin/city/CityCollection.js');
-// const { CityResource } = require('../../resources/admin/city/CityResource.js');
-// const cityService = require('../../services/admin/CityService.js');
-// const { PaginationParam } = require('../../utils/PaginationParams.js');
-// const { errorResponse, messageSuccessResponse } = require('../../utils/Response.js');
-// const { validateStoreCityRequest, validateUpdateCityRequest } = require('../../validators/admin/city/CityValidators.js');
-
-// exports.getAllCity = async (req, res) => {
-//     try {
-//         const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
-
-//         const { cities, total } = await cityService.getAllCityService({
-//             page, limit, search, sortBy, orderBy
-//         });
-
-//         return CityCollection(req, res, cities, total, page, limit, 'City data successfully retrieved');
-//     } catch (err) {
-//         return errorResponse(res, err);
-//     }
-// };
-
-// exports.showCity = async (req, res) => {
-//     try {
-//         const id = req.params.id;
-//         const data = await cityService.showCityService(id);
-//         return CityResource(res, data, 'Success show city');
-//     } catch (err) {
-//         return errorResponse(res, err);
-//     }
-// };
-
-// exports.storeCity = async (req, res) => {
-//     try {
-//         const validatedData = validateStoreCityRequest(req.body);
-//         await cityService.storeCityService(validatedData, req);
-//         return messageSuccessResponse(res, 'Success added city', 201);
-//     } catch (err) {
-//         return errorResponse(res, err);
-//     }
-// }
-
-// exports.updateCity = async (req, res) => {
-//     try {
-//         const id = req.params.id;
-//         const validatedData = validateUpdateCityRequest(req.body);
-//         await cityService.updateCityService(validatedData, id, req);
-//         return messageSuccessResponse(res, 'Success update city');
-//     } catch (err) {
-//         return errorResponse(res, err);
-//     }
-// }
-
-// exports.deleteCity = async (req, res) => {
-//     try {
-//         const id = req.params.id;
-//         await cityService.deleteCityService(id, req);
-//         return messageSuccessResponse(res, 'Success delete city');
-//     } catch (err) {
-//         return errorResponse(res, err);
-//     }
-// };
+};

src/controllers/admin/SalesController.ts

@@ -13,4 +13,36 @@ export const getAllSales = async (req: Request, res: Response): Promise<Response
     } catch (err) {
         return errorResponse(res, err);
     }
-};
+};
+
+// export const storeCity = async (req: Request, res: Response): Promise<Response> => {
+//     try {
+//         const validatedData = validateStoreCityRequest(req.body);
+//         await CityService.storeCityService(validatedData, req as CustomRequest);
+//         return messageSuccessResponse(res, 'Success added city', 201);
+//     } catch (err) {
+//         return errorResponse(res, err);
+//     }
+// };
+
+
+// export const showCity = async (req: Request, res: Response): Promise<Response> => {
+//     try {
+//         const id = req.params.id;
+//         const data = await CityService.showCityService(id);
+//         return CityResource(res, data, 'Success show city');
+//     } catch (err) {
+//         return errorResponse(res, err);
+//     }
+// };
+
+// export const updateCity = async (req: Request, res: Response): Promise<Response> => {
+//     try {
+//         const id = req.params.id;
+//         const validatedData = validateUpdateCityRequest(req.body);
+//         await CityService.updateCityService(validatedData, id, req as CustomRequest);
+//         return messageSuccessResponse(res, 'Success update city');
+//     } catch (err) {
+//         return errorResponse(res, err);
+//     }
+// };

src/controllers/admin/UserAreaController.ts

@@ -0,0 +1,65 @@
+import { Request, Response } from 'express';
+import * as UserAreaService from '../../services/admin/UserAreaService';
+import { PaginationParam } from '../../utils/PaginationParams';
+import { errorResponse, messageSuccessResponse } from '../../utils/Response';
+import { UserAreaCollection } from '../../resources/admin/user_area/UserAreaCollection';
+import { CustomRequest } from '../../types/token/CustomRequest';
+import { validateStoreUserAreaRequest, validateUpdateUserAreaRequest } from '../../validators/admin/user_area/UserAreaValidators';
+import { UserAreaResource } from '../../resources/admin/user_area/UserAreaResource';
+
+export const getAllUserArea = async (req: Request, res: Response): Promise<Response | void> => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { areas, total } = await UserAreaService.getAllUserAreaService(
+            { page, limit, search, sortBy, orderBy },
+        );
+
+        return UserAreaCollection(req, res, areas, total, page, limit, 'User area data successfully retrieved',);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+
+export const CreateUserArea = async (req: Request, res: Response): Promise<Response> => {
+    try {
+        const validatedData = validateStoreUserAreaRequest(req.body);
+        await UserAreaService.storeUserAreaService(validatedData, req as CustomRequest);
+        return messageSuccessResponse(res, 'Success added user area', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+export const showUserArea = async (req: Request, res: Response): Promise<Response> => {
+    try {
+        const id = req.params.id;
+        const data = await UserAreaService.showUserAreaService(id);
+        return UserAreaResource(res, data, 'Success show user area');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+export const updateUserArea = async (req: Request, res: Response): Promise<Response> => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateUpdateUserAreaRequest(req.body);
+        await UserAreaService.updateUserAreaService(validatedData, id, req as CustomRequest);
+        return messageSuccessResponse(res, 'Success update user area');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+
+export const DeleteUserArea = async (req: Request, res: Response): Promise<Response> => {
+    try {
+        const id = req.params.id;
+        await UserAreaService.deleteUserAreaService(id, req as CustomRequest);
+        return messageSuccessResponse(res, 'Success delete user area');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/repository/admin/SalesRepository.ts

@@ -1,37 +1,34 @@
+import { create } from 'domain';
 import prisma from '../../prisma/PrismaClient';
 import { Prisma } from '@prisma/client';
 
 interface FindAllParams {
     skip?: number;
     take?: number;
-    where?: Prisma.UserWhereInput;
-    orderBy?: Prisma.UserOrderByWithRelationInput;
+    where?: Prisma.UserKeycloakWhereInput;
+    orderBy?: Prisma.UserKeycloakOrderByWithRelationInput;
 }
 
 const SalesRepository = {
-    findAll: async ({ skip, take, where = {}, orderBy }: FindAllParams) => {
-        return prisma.user.findMany({
+    findAll: async ({ skip, take, where = {} }: FindAllParams) => {
+        return prisma.userKeycloak.findMany({
             where: {
                 ...where,
                 role: 'sales',
             },
             skip,
             take,
-            orderBy,
             select: {
                 id: true,
-                email: true,
-                firstname: true,
-                lastname: true,
+                fullname: true,
+                phone: true,
                 role: true,
-                createdAt: true,
-                updatedAt: true,
             },
         });
     },
 
-    countAll: async (where: Prisma.UserWhereInput = {}): Promise<number> => {
-        return prisma.user.count({
+    countAll: async (where: Prisma.UserKeycloakWhereInput = {}): Promise<number> => {
+        return prisma.userKeycloak.count({
             where: {
                 ...where,
                 role: 'sales',

src/repository/admin/ScheduleVisitationRepository.ts

@@ -1,6 +1,5 @@
 import prisma from '../../prisma/PrismaClient';
 import { Prisma } from '@prisma/client';
-import { ScheduleVisitationDTO } from '../../types/admin/schedule_visitation/ScheduleVisitationDTO';
 
 interface FindAllParams {
     skip: number;

src/repository/admin/UserAreaRepository.ts

@@ -0,0 +1,94 @@
+// AreaRepository.ts
+import prisma from '../../prisma/PrismaClient';
+import { Prisma } from '@prisma/client';
+
+interface FindAllParams {
+    skip?: number;
+    take?: number;
+    where?: Prisma.UserAreaWhereInput;
+    orderBy?: Prisma.UserAreaOrderByWithRelationInput;
+}
+
+const UserAreaRepository = {
+    findAll: async ({ skip, take, where, orderBy }: FindAllParams) => {
+        return await prisma.userArea.findMany({
+            where,
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                user: {
+                    select: {
+                        id: true,
+                        fullname: true,
+                        phone: true,
+                        role: true,
+                    },
+                },
+                province: {
+                    select: {
+                        id: true,
+                        name: true,
+                    },
+                },
+                createdAt: true,
+                updatedAt: true
+            },
+        });
+    },
+
+    countAll: async (where?: Prisma.UserAreaWhereInput) => {
+        return prisma.userArea.count({ where });
+    },
+
+    findById: async (id: string) => {
+        return prisma.userArea.findFirst({
+            where: {
+                id,
+                deletedAt: null,
+            },
+            select: {
+                id: true,
+                user: {
+                    select: {
+                        id: true,
+                        fullname: true,
+                        phone: true,
+                        role: true
+                    }
+                },
+                province: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    create: async (data: Prisma.UserAreaCreateInput) => {
+        return prisma.userArea.create({
+            data,
+        });
+    },
+
+    update: async (id: string, data: Prisma.UserAreaUpdateInput) => {
+        return prisma.userArea.update({
+            where: { id },
+            data,
+        });
+    },
+
+    deleteByUserId: async (userId: string) => {
+        return prisma.userArea.deleteMany({
+            where: { user_id: userId },
+        });
+    },
+
+};
+
+export default UserAreaRepository;

src/resources/admin/sales/SalesCollection.ts

@@ -1,12 +1,9 @@
 import { Request, Response } from 'express';
 import { ListResponse } from '../../../utils/ListResponse';
-import { formatISOWithoutTimezone } from '../../../utils/FormatDate';
 import { SalesDTO } from '../../../types/admin/sales/SalesDTO';
 
 const formatItem = (item: SalesDTO) => ({
     ...item,
-    createdAt: formatISOWithoutTimezone(item.createdAt),
-    updatedAt: formatISOWithoutTimezone(item.updatedAt),
 });
 
 export const SalesCollection = (req: Request, res: Response, data: SalesDTO[] = [], total: number | null = null, page: number = 1, limit: number = 10, message: string = 'Success'): Response => {
@@ -29,28 +26,4 @@ export const SalesCollection = (req: Request, res: Response, data: SalesDTO[] =
         limit,
         message,
     });
-};
-
-
-// const { ListResponse } = require("../../../utils/ListResponse");
-// const { formatISOWithoutTimezone } = require("../../../utils/FormatDate.js");
-
-// const formatItem = (item) => ({
-//     ...item,
-//     createdAt: formatISOWithoutTimezone(item.createdAt),
-//     updatedAt: formatISOWithoutTimezone(item.updatedAt)
-// });
-
-// exports.CityCollection = (req, res, data = [], total = null, page = 1, limit = 10, message = 'Success') => {
-//     const formattedData = data.map(formatItem);
-
-//     if (typeof total !== 'number') {
-//         return res.status(200).json({
-//             success: true,
-//             message,
-//             data: Array.isArray(formattedData)
-//         });
-//     }
-
-//     return ListResponse({ req, res, data: formattedData, total, page, limit, message });
-// };
+};

src/resources/admin/user_area/UserAreaCollection.ts

@@ -0,0 +1,32 @@
+import { Request, Response } from 'express';
+import { ListResponse } from '../../../utils/ListResponse';
+import { formatISOWithoutTimezone } from '../../../utils/FormatDate';
+import { UserAreaDTO } from '../../../types/admin/user_area/UserAreaDTO';
+
+const formatItem = (item: UserAreaDTO) => ({
+    ...item,
+    createdAt: formatISOWithoutTimezone(item.createdAt),
+    updatedAt: formatISOWithoutTimezone(item.updatedAt),
+});
+
+export const UserAreaCollection = (req: Request, res: Response, data: UserAreaDTO[] = [], total: number | null = null, page: number = 1, limit: number = 10, message: string = 'Success'): Response => {
+    const formattedData = data.map(formatItem);
+
+    if (typeof total !== 'number') {
+        return res.status(200).json({
+            success: true,
+            message,
+            data: Array.isArray(formattedData),
+        });
+    }
+
+    return ListResponse({
+        req,
+        res,
+        data: formattedData,
+        total,
+        page,
+        limit,
+        message,
+    });
+};

src/resources/admin/user_area/UserAreaResource.ts

@@ -0,0 +1,19 @@
+import { Response } from 'express';
+import { formatISOWithoutTimezone } from '../../../utils/FormatDate';
+import { UserAreaDTO } from '../../../types/admin/user_area/UserAreaDTO';
+
+const formatItem = (item: UserAreaDTO) => ({
+    ...item,
+    createdAt: formatISOWithoutTimezone(item.createdAt),
+    updatedAt: formatISOWithoutTimezone(item.updatedAt),
+});
+
+export const UserAreaResource = (res: Response, data: UserAreaDTO, message: string = 'Success'): Response => {
+    const formattedData = formatItem(data);
+
+    return res.status(200).json({
+        success: true,
+        message,
+        data: formattedData,
+    });
+};

src/routes/admin/UserAreaRoute.ts

@@ -0,0 +1,15 @@
+import express, { Router } from 'express';
+import * as UserAreaController from '../../controllers/admin/UserAreaController';
+import keycloak from '../../middleware/Keycloak';
+import { extractToken } from '../../middleware/ExtractToken';
+import checkRoles from '../../middleware/CheckRoles';
+
+const router: Router = express.Router();
+
+router.get('/', [keycloak.protect(), extractToken, checkRoles(["admin"])], UserAreaController.getAllUserArea);
+router.post('/', [keycloak.protect(), extractToken, checkRoles(["admin"])], UserAreaController.CreateUserArea);
+router.get('/:id', [keycloak.protect(), extractToken, checkRoles(["admin"])], UserAreaController.showUserArea);
+router.patch('/:id', [keycloak.protect(), extractToken, checkRoles(["admin"])], UserAreaController.updateUserArea);
+router.delete('/:id', [keycloak.protect(), extractToken, checkRoles(["admin"])], UserAreaController.DeleteUserArea);
+
+export default router;

src/services/admin/SalesService.ts

@@ -13,9 +13,8 @@ interface GetAllSalesParams {
 export const getAllSalesService = async ({ page, limit, search = '', sortBy, orderBy }: GetAllSalesParams) => {
     const skip = (page - 1) * limit;
 
-    const where: Prisma.UserWhereInput = {
+    const where: Prisma.UserKeycloakWhereInput = {
         ...SearchFilter(search, ['id', 'firstname', 'lastname']),
-        deletedAt: null,
     };
 
     const [sales, total] = await Promise.all([

src/services/admin/ScheduleVisitationService.ts

@@ -89,7 +89,7 @@ export const getAllScheduleVisitationService = async ({ page, limit, search, sor
 export const storeScheduleVisitationService = async (validateData: ScheduleVisitationRequestDTO, req: CustomRequest) => {
     const creatorId = req.tokenData.sub;
 
-    const sales = await prisma.user.findFirst({
+    const sales = await prisma.userKeycloak.findFirst({
         where: {
             id: validateData.sales_id,
         }
@@ -150,7 +150,7 @@ export const updateScheduleVisitationService = async (validateData: Partial<Sche
     }
 
     if (validateData.sales_id) {
-        const sales = await prisma.user.findFirst({ where: { id: validateData.sales_id } });
+        const sales = await prisma.userKeycloak.findFirst({ where: { id: validateData.sales_id } });
         if (!sales) throw new HttpException("Sales user not found", 404);
 
         payload.sales_visit = { connect: { id: validateData.sales_id } };

src/services/admin/UserAreaService.ts

@@ -0,0 +1,133 @@
+import { Prisma } from '@prisma/client';
+import prisma from '../../prisma/PrismaClient';
+import ProvinceRepository from '../../repository/admin/ProvinceRepository';
+import UserAreaRepository from '../../repository/admin/UserAreaRepository';
+import { RequestUpdateUserAreaDTO, RequestUserAreaDTO } from '../../types/admin/user_area/UserAreaDTO';
+import { CustomRequest } from '../../types/token/CustomRequest';
+import { HttpException } from '../../utils/HttpException';
+import { createLog, deleteLog, updateLog } from '../../utils/LogActivity';
+import { SearchFilter } from '../../utils/SearchFilter';
+import { now } from '../../utils/TimeLocal';
+
+interface GetAllAreaParams {
+    page: number;
+    limit: number;
+    search?: string;
+    sortBy: string;
+    orderBy: 'asc' | 'desc';
+}
+
+export const getAllUserAreaService = async ({ page, limit, search, sortBy, orderBy }: GetAllAreaParams): Promise<{ areas: any[]; total: number; }> => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        deletedAt: null,
+        ...SearchFilter(search, ['user.fullname', 'province.name']),
+    };
+
+    const [areas, total] = await Promise.all([
+        UserAreaRepository.findAll({
+            skip,
+            take: limit,
+            where,
+            orderBy: { [sortBy]: orderBy },
+        }),
+        UserAreaRepository.countAll(where),
+    ]);
+
+    return { areas, total };
+};
+
+export const storeUserAreaService = async (validateData: RequestUserAreaDTO, req: CustomRequest) => {
+    const { user_id, province_id } = validateData;
+
+    const userKeycloak = await prisma.userKeycloak.findFirst({ where: { id: user_id } });
+    if (!userKeycloak) {
+        throw new HttpException('User not found', 404);
+    }
+
+    // cek semua province id valid
+    for (const pid of province_id) {
+        const province = await ProvinceRepository.findById(pid);
+        if (!province) {
+            throw new HttpException(`Province with id ${pid} not found`, 404);
+        }
+    }
+
+    // simpan banyak province untuk user
+    const results = await Promise.all(
+        province_id.map(pid =>
+            UserAreaRepository.create({
+                user: { connect: { id: user_id } },
+                province: { connect: { id: pid } },
+            })
+        )
+    );
+
+    // bentuk object gabungan untuk response + log
+    const data = {
+        user_id,
+        provinces: province_id,
+        createdAt: results[0]?.createdAt,
+        updatedAt: results[0]?.updatedAt,
+    };
+
+    await createLog(req, data);
+};
+
+export const showUserAreaService = async (id: string) => {
+    const user_area = await UserAreaRepository.findById(id);
+    if (!user_area) {
+        throw new HttpException('Data user area not found', 404);
+    }
+    return user_area;
+};
+
+export const updateUserAreaService = async (validateData: Partial<RequestUpdateUserAreaDTO>, id: string, req: CustomRequest) => {
+    const user_area = await UserAreaRepository.findById(id);
+    if (!user_area) {
+        throw new HttpException('Data user area not found', 404);
+    }
+
+    const updatePayload = validateData;
+
+    if (updatePayload.user_id) {
+        const userKeycloak = await prisma.userKeycloak.findFirst({ where: { id: updatePayload.user_id } });
+        if (!userKeycloak) {
+            throw new HttpException('User not found', 404);
+        }
+    }
+
+    if (updatePayload.province_id) {
+        const province = await prisma.province.findFirst({ where: { id: updatePayload.province_id } });
+        if (!province) {
+            throw new HttpException('Province not found', 404);
+        }
+    }
+
+    const prismaPayload: Prisma.UserAreaUpdateInput = {};
+    if (validateData.user_id) {
+        prismaPayload.user = { connect: { id: validateData.user_id } };
+    }
+    if (validateData.province_id) {
+        prismaPayload.province = { connect: { id: validateData.province_id } };
+    }
+
+    const data = await UserAreaRepository.update(id, prismaPayload);
+
+    await updateLog(req, data);
+};
+
+export const deleteUserAreaService = async (id: string, req: CustomRequest) => {
+    const user_area = await UserAreaRepository.findById(id);
+    if (!user_area) {
+        throw new HttpException('User area not found', 404);
+    }
+
+    const data = await UserAreaRepository.update(id, {
+        deletedAt: now().toDate(),
+    });
+
+    await deleteLog(req, data);
+    return data;
+};

src/services/sales/ScheduleVisitationService.ts

@@ -93,16 +93,7 @@ export const getAllScheduleVisitationService = async (req: CustomRequest,
 
 export const storeScheduleVisitationService = async (validateData: ScheduleVisitationRequestDTO, req: CustomRequest) => {
     const userLogin = req.tokenData.sub;
-
-    // const sales = await prisma.user.findFirst({
-    //     where: {
-    //         id: validateData.sales_id,
-    //     }
-    // });
-    // if (!sales) {
-    //     throw new HttpException('Sales user not found', 404);
-    // }
-
+    
     const hospital = await HospitalRepository.findById(validateData.hospital_id);
     if (!hospital) {
         throw new HttpException('Hospital not found', 404);

src/types/admin/sales/SalesDTO.ts

@@ -1,9 +1,6 @@
 export interface SalesDTO {
     id: string;
-    email: string;
-    firstname: string;
-    lastname: string;
-    role: string;
-    createdAt: Date;
-    updatedAt: Date;
+    fullname: string;
+    phone: string | null;
+    role: string | null;
 }

src/types/admin/user_area/UserAreaDTO.ts

@@ -0,0 +1,25 @@
+export interface UserAreaDTO {
+    id: string;
+    user: {
+        id: string;
+        fullname: string;
+        phone: string | null;
+        role: string | null;
+    }
+    province: {
+        id: string;
+        name: string;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}
+
+export interface RequestUserAreaDTO {
+    user_id: string;
+    province_id: string[];
+}
+
+export interface RequestUpdateUserAreaDTO {
+    user_id?: string;
+    province_id?: string;
+}

src/utils/LogActivity.ts

@@ -55,51 +55,4 @@ export const createLog = (req: CustomRequest, data: LogData) => baseLog({ req, a
 export const updateLog = (req: CustomRequest, data: LogData) => baseLog({ req, action: 'update', data });
 export const deleteLog = (req: CustomRequest, data: LogData) => baseLog({ req, action: 'delete', data });
 export const loginLog = (req: CustomRequest, data: LogData) => baseLog({ req, action: 'login', data });
-export const logoutLog = (req: CustomRequest, data: LogData) => baseLog({ req, action: 'logout', data });
-
-
-// const jwt = require('jsonwebtoken');
-// const prisma = require('../prisma/PrismaClient.js');
-// const timeLocal = require('../utils/TimeLocal.js');
-// const { getUserNameById } = require('./CheckUserKeycloak.js');
-
-// const baseLog = async ({ req, action, data }) => {
-//     try {
-//         let userId, username;
-
-//         // Ambil userId dari token Keycloak
-//         if (req?.tokenData?.sub) {
-//             userId = req.tokenData.sub;
-//             username = await getUserNameById(userId);
-//         }
-
-//         // Fallback kalau tokenData tidak ada
-//         if (!userId || !username) {
-//             userId = data?.id;
-//             username = data?.username;
-//         }
-
-//         if (!userId || !username) return;
-
-//         await prisma.activityLog.create({
-//             data: {
-//                 user_id: userId,
-//                 username,
-//                 action: JSON.stringify({ [action]: data }),
-//                 createdAt: timeLocal.now().toDate(),
-//                 updatedAt: timeLocal.now().toDate(),
-//                 deletedAt: null,
-//             }
-//         });
-//     } catch (err) {
-//         console.error('Failed to log activity:', err.message);
-//     }
-// };
-
-// const createLog = (req, data) => baseLog({ req, action: 'create', data });
-// const updateLog = (req, data) => baseLog({ req, action: 'update', data });
-// const deleteLog = (req, data) => baseLog({ req, action: 'delete', data });
-// const loginLog = (req, data) => baseLog({ req, action: 'login', data });
-// const logoutLog = (req, data) => baseLog({ req, action: 'logout', data });
-
-// module.exports = { createLog, updateLog, deleteLog, loginLog, logoutLog };
+export const logoutLog = (req: CustomRequest, data: LogData) => baseLog({ req, action: 'logout', data });

src/utils/ScheduleNotification.ts

@@ -0,0 +1,154 @@
+import 'dotenv/config'
+import cron from "node-cron";
+import dayjs from "dayjs";
+import axios from "axios";
+import prisma from "../prisma/PrismaClient";
+import { formatISOWithoutTimezone } from './FormatDate';
+
+const queue: (() => Promise<void>)[] = [];
+let processing = false;
+
+const API_URL_NOTIFICATION = process.env.API_TOKEN_NOTIFICATION;
+const API_TOKEN_NOTIFICATTION = process.env.API_TOKEN_NOTIFICATTION;
+
+const delay = (ms: number) => new Promise((res) => setTimeout(res, ms));
+
+const randomDelay = () => {
+    const min = 60 * 1000;  // 60 detik
+    const max = 180 * 1000; // 180 detik
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+};
+
+// Worker untuk memproses queue
+const processQueue = async () => {
+    if (processing || queue.length === 0) return;
+    processing = true;
+
+    while (queue.length > 0) {
+        console.log(`▶️ Mulai memproses antrean, sisa job: ${queue.length}`);
+        const job = queue.shift();
+        if (job) {
+            try {
+                await job();
+                if (queue.length > 0) {
+                    const delayMs = randomDelay();
+                    console.log(`⏳ Tunggu ${Math.round(delayMs / 1000)} detik sebelum job berikutnya...`);
+                    await delay(delayMs);
+                }
+            } catch (err: any) {
+                console.error("❌ Job gagal:", err.message);
+            }
+        }
+    }
+
+    console.log("✅ Semua job selesai diproses.");
+    processing = false;
+};
+
+// Tambah job ke antrean
+const addToQueue = (fn: () => Promise<void>) => {
+    queue.push(fn);
+    console.log(`➕ Job ditambahkan ke antrean. Total sekarang: ${queue.length}`);
+    console.log("📦 Isi antrean saat ini:", queue.map((_, i) => `Job#${i + 1}`));
+    processQueue();
+};
+
+// Cron: jalan tiap hari
+cron.schedule("00 08 * * *", async () => {
+    console.log("⏰ [CRON] Checking schedules for today...");
+
+    try {
+        const today = dayjs().startOf("day").toDate();
+        const tomorrow = dayjs().add(1, "day").startOf("day").toDate();
+
+        // Ambil semua schedule untuk hari ini
+        const schedules = await prisma.scheduleVisitation.findMany({
+            where: {
+                deletedAt: null,
+                date_visit: {
+                    gte: today,
+                    lt: tomorrow,
+                },
+            },
+            include: {
+                sales_visit: true,
+                hospital: {
+                    include: {
+                        province: true,
+                        city: true,
+                    }
+                }
+            },
+        });
+
+        if (schedules.length === 0) {
+            console.log("ℹ️ No schedules for today.");
+            return;
+        }
+
+        console.log(`📌 Ditemukan ${schedules.length} schedule untuk hari ini:`);
+        schedules.forEach((s, idx) => {
+            console.log(`   #${idx + 1} SalesID=${s.sales_id}, Phone=${s.sales_visit?.phone ?? "❌ kosong"}`);
+        });
+
+        schedules.forEach((schedule, idx) => {
+            const phone = schedule.sales_visit?.phone as string | undefined;
+            if (!phone) {
+                console.warn(`⚠️ Sales ${schedule.sales_id} tidak punya nomor telepon.`);
+                return;
+            }
+
+            const fullname = schedule.sales_visit?.fullname || '-';
+            const hospitalName = schedule.hospital?.name || '-';
+            const hospitalAddress = schedule.hospital?.address || '-';
+            const hospitalContact = schedule.hospital?.contact || '-';
+            const hospitalEmail = schedule.hospital?.email || '-';
+            const hospitalLat = schedule.hospital?.latitude || '-';
+            const hospitalLong = schedule.hospital?.longitude || '-';
+            const hospitalGmaps = schedule.hospital?.gmaps_url || '-';
+            const hospitalProv = schedule.hospital?.province.name || '-';
+            const hospitalCity = schedule.hospital?.city.name || '-';
+            const scheduleCreate = schedule.createdAt || '-';
+
+            const message = `
+Halo ${fullname},
+
+[[[ maaf, ini sedang testing - gayuh ]]]
+Ini adalah pengingat jadwal kunjungan yang dibuat pada tanggal ${formatISOWithoutTimezone(scheduleCreate)}.
+
+Anda dijadwalkan untuk mengunjungi:
+Rumah Sakit: ${hospitalName}
+Alamat: ${hospitalAddress}
+Kota: ${hospitalCity}, Provinsi: ${hospitalProv}
+Kontak: ${hospitalContact}, Email: ${hospitalEmail}
+Lokasi Google Maps: ${hospitalGmaps}
+Koordinat: Latitude ${hospitalLat}, Longitude ${hospitalLong}
+
+Nomor telepon sales terkait: ${phone}
+
+Pastikan semua persiapan kunjungan sudah lengkap! Semangat bertugas!
+`.trim();
+
+            addToQueue(async () => {
+                console.log(
+                    `[${dayjs().format("HH:mm:ss")}] 📩 (Job#${idx + 1}) Sending message to ${phone}...`
+                );
+                await axios.post(
+                    API_URL_NOTIFICATION!,
+                    { to: phone, message },
+                    {
+                        headers: {
+                            "x-api-token": API_TOKEN_NOTIFICATTION!,
+                            "Content-Type": "application/json",
+                        },
+                    }
+                );
+                console.log(
+                    `[${dayjs().format("HH:mm:ss")}] ✔️ (Job#${idx + 1}) Sent message to ${phone}`
+                );
+            });
+        });
+    } catch (err: any) {
+        console.error("❌ Cron job error:", err.message);
+    }
+});

src/utils/Scheduler.ts

@@ -1,73 +1,3 @@
-// const cron = require('node-cron');
-// const axios = require('axios');
-// const dayjs = require('dayjs');
-// const prisma = require('../prisma/PrismaClient.js');
-
-// const getAdminToken = async () => {
-//     const response = await axios.post(`${process.env.KEYCLOAK_URL}/realms/master/protocol/openid-connect/token`, new URLSearchParams({
-//         client_id: 'admin-cli',
-//         username: process.env.KEYCLOAK_ADMIN_USERNAME,
-//         password: process.env.KEYCLOAK_ADMIN_PASSWORD,
-//         grant_type: 'password'
-//     }), {
-//         headers: {
-//             'Content-Type': 'application/x-www-form-urlencoded'
-//         }
-//     });
-
-//     return response.data.access_token;
-// };
-
-// async function getAllUsers(token) {
-//     const res = await axios.get(`${process.env.KEYCLOAK_URL}/admin/realms/${process.env.KEYCLOAK_REALM}/users`, {
-//         headers: {
-//             Authorization: `Bearer ${token}`
-//         }
-//     });
-
-//     return res.data;
-// }
-
-// async function syncUserToDB(user) {
-//     const fullname = `${user.firstName || ''} ${user.lastName || ''}`.trim();
-//     const existing = await prisma.userKeycloak.findUnique({ where: { id: user.id } });
-//     if (!existing) {
-//         await prisma.userKeycloak.create({
-//             data: {
-//                 id: user.id,
-//                 fullname
-//             }
-//         });
-//         console.log('✔️ Synced user:', fullname);
-//     }
-// }
-
-// // Cron job setiap 1 menit
-// cron.schedule('* * * * *', async () => {
-//     console.log('[SYNC] Checking for new users...');
-
-//     try {
-//         const token = await getAdminToken();
-//         const users = await getAllUsers(token);
-
-//         const now = dayjs();
-//         const oneMinuteAgo = now.subtract(1, 'minute');
-
-//         // Filter user yang dibuat dalam 1 menit terakhir
-//         const newUsers = users.filter(u => u.createdTimestamp && dayjs(u.createdTimestamp).isAfter(oneMinuteAgo));
-
-//         for (const user of newUsers) {
-//             await syncUserToDB(user);
-//         }
-
-//         if (newUsers.length === 0) {
-//             console.log('ℹ️ No new users.');
-//         }
-//     } catch (err) {
-//         console.error('❌ Sync error:', err.message);
-//     }
-// });
-
 import cron from 'node-cron';
 import axios from 'axios';
 import dayjs from 'dayjs';
@@ -79,6 +9,17 @@ interface KeycloakUser {
     firstName?: string;
     lastName?: string;
     createdTimestamp?: number;
+    attributes?: {
+        phone?: string[];
+    };
+}
+interface KeycloakRole {
+    id: string;
+    name: string;
+    description?: string;
+    composite?: boolean;
+    clientRole?: boolean;
+    containerId?: string;
 }
 
 const getAdminToken = async (): Promise<string> => {
@@ -113,8 +54,25 @@ const getAllUsers = async (token: string): Promise<KeycloakUser[]> => {
     return res.data;
 };
 
-const syncUserToDB = async (user: KeycloakUser): Promise<void> => {
+const getUserRoles = async (token: string, userId: string): Promise<KeycloakRole[]> => {
+    const res = await axios.get(
+        `${process.env.KEYCLOAK_URL}/admin/realms/${process.env.KEYCLOAK_REALM}/users/${userId}/role-mappings/realm`,
+        {
+            headers: {
+                Authorization: `Bearer ${token}`,
+            },
+        }
+    );
+
+    return res.data;
+};
+
+const syncUserToDB = async (user: KeycloakUser, token: string): Promise<void> => {
     const fullname = `${user.firstName || ''} ${user.lastName || ''}`.trim();
+    const phone = user.attributes?.phone?.[0] || null;
+
+    const roles = await getUserRoles(token, user.id);
+    const role = roles[0]?.name || null;
 
     const existing = await prisma.userKeycloak.findUnique({
         where: { id: user.id },
@@ -125,6 +83,8 @@ const syncUserToDB = async (user: KeycloakUser): Promise<void> => {
             data: {
                 id: user.id,
                 fullname,
+                phone,
+                role
             },
         });
         console.log('✔️ Synced user:', fullname);
@@ -149,7 +109,7 @@ cron.schedule('* * * * *', async () => {
         );
 
         for (const user of newUsers) {
-            await syncUserToDB(user);
+            await syncUserToDB(user, token);
         }
 
         if (newUsers.length === 0) {

src/validators/admin/user_area/UserAreaValidators.ts

@@ -0,0 +1,32 @@
+import Joi from 'joi';
+import { validateWithSchema } from '../../ValidateSchema';
+import { RequestUpdateUserAreaDTO, RequestUserAreaDTO } from '../../../types/admin/user_area/UserAreaDTO';
+
+const storeUserAreaSchema = Joi.object<RequestUserAreaDTO>({
+    user_id: Joi.string().trim().required().messages({
+        'string.empty': 'User ID is required',
+    }),
+    province_id: Joi.array().items(
+        Joi.string().trim().required()
+    ).min(1).required().messages({
+        'array.base': 'Province ID must be an array',
+        'array.min': 'At least one Province ID is required',
+    }),
+});
+
+const updateUserAreaSchema = Joi.object<Partial<RequestUpdateUserAreaDTO>>({
+    user_id: Joi.string().trim().optional().messages({
+        'string.empty': 'User ID is required',
+    }),
+    province_id: Joi.string().trim().optional().messages({
+        'string.empty': 'Province ID is required',
+    }),
+});
+
+export const validateStoreUserAreaRequest = (body: unknown): RequestUserAreaDTO => {
+    return validateWithSchema<RequestUserAreaDTO>(storeUserAreaSchema, body);
+};
+
+export const validateUpdateUserAreaRequest = (body: unknown): Partial<RequestUpdateUserAreaDTO> => {
+    return validateWithSchema<Partial<RequestUpdateUserAreaDTO>>(updateUserAreaSchema, body);
+};