first commit

.dockerignore

@@ -0,0 +1,4 @@
+node_modules
+npm-debug.log
+
+/generated/prisma

.env.example

@@ -0,0 +1,22 @@
+# Environment variables declared in this file are automatically made available to Prisma.
+# See the documentation for more detail: https://pris.ly/d/prisma-schema#accessing-environment-variables-from-the-schema
+
+# Prisma supports the native connection string format for PostgreSQL, MySQL, SQLite, SQL Server, MongoDB and CockroachDB.
+# See the documentation for all the connection string options: https://pris.ly/d/connection-strings
+
+# The following `prisma+postgres` URL is similar to the URL produced by running a local Prisma Postgres 
+# server with the `prisma dev` CLI command, when not choosing any non-default ports or settings. The API key, unlike the 
+# one found in a remote Prisma Postgres URL, does not contain any sensitive information.
+
+# Database
+DATABASE_URL="postgresql://postgres:postgres@localhost:5432/<namadb>"
+
+PORT=3200
+
+# Keycloak
+KEYCLOAK_TOKEN_URL=<url>/realms/<name_realm>/protocol/openid-connect/token
+CLIENT_ID=my-app
+CLIENT_SECRET=vUT3dbn2EfYslBYMm0cjvvA6D5bLT2mH
+JWT_SECRET=FF9q223buywGKYfLbu4ojSOYJ9s63G0iJFiCwSiVXB4FOm4WJQMoOF7DubqYT46v
+KEYCLOAK_ADMIN_URL=<url>
+KEYCLOAK_REALM=<name_realm>

.gitignore

@@ -0,0 +1,5 @@
+node_modules
+# Keep environment variables out of version control
+.env
+
+/generated/prisma

Dockerfile

@@ -0,0 +1,17 @@
+FROM node:18
+
+WORKDIR /app
+
+# Install dependensi
+COPY package*.json ./
+RUN npm install
+
+# Salin semua kode
+COPY . .
+
+# Tambah entrypoint
+COPY entrypoint.sh /entrypoint.sh
+RUN chmod +x /entrypoint.sh
+
+# Jalankan entrypoint saat container start
+CMD ["/entrypoint.sh"]

config/config.js

@@ -0,0 +1,6 @@
+require('dotenv').config();
+
+module.exports = {
+  port: process.env.PORT || 3000,
+  BASE_URL: process.env.BASE_URL || 'http://localhost:3200'
+};

config/keycloak.js

@@ -0,0 +1,10 @@
+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,
+};

docker-compose.yml

@@ -0,0 +1,32 @@
+version: "3.8"
+
+services:
+  db:
+    image: postgres:15
+    restart: always
+    ports:
+      - "6000:5432"
+    environment:
+      POSTGRES_USER: postgres123
+      POSTGRES_PASSWORD: postgres123
+      POSTGRES_DB: db_radar
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres123"]
+      interval: 5s
+      timeout: 3s
+      retries: 5
+
+  api:
+    build: .
+    ports:
+      - "3200:3200"
+    env_file:
+      - .env
+    depends_on:
+      db:
+        condition: service_healthy
+
+volumes:
+  postgres-data:

duplicate_keycloak.json

@@ -0,0 +1,14 @@
+{
+    "realm": "pearlgw",
+    "auth-server-url": "http://localhost:8020/",
+    "ssl-required": "external",
+    "resource": "my-app",
+    "verify-token-audience": true,
+    "credentials": {
+        "secret": "vUT3dbn2EfYslBYMm0cjvvA6D5bLT2mH"
+    },
+    "confidential-port": 0,
+    "policy-enforcer": {
+        "credentials": {}
+    }
+}

entrypoint.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+
+echo "📦 Menjalankan Prisma generate..."
+npx prisma generate
+
+echo "🔃 Menjalankan migrasi dev..."
+npx prisma migrate dev --name init
+
+echo "♻️ Reset database dan menjalankan seeder..."
+npx prisma migrate reset --force
+
+echo "🚀 Menjalankan aplikasi..."
+exec node index.js

index.js

@@ -0,0 +1,38 @@
+const express = require('express')
+const cors = require('cors')
+const errorHandler = require('./src/middleware/ErrorHandler.js')
+const app = express()
+const path = require('path');
+// const hospitalRoutes = require('./src/routes/HospitalRoute.js')
+const provinceRoutes = require('./src/routes/admin/ProvinceRoute.js')
+const authRoutes = require('./src/routes/auth/AuthRoute.js')
+// const userRoutes = require('./src/routes/UserRoute.js')
+const cityRoutes = require('./src/routes/admin/CityRoute.js')
+const salesRoutes = require('./src/routes/admin/SalesRoute.js')
+const adminRoutes = require('./src/routes/superadmin/AdminRoute.js')
+const hospitalRoutes = require('./src/routes/admin/HospitalRoute.js')
+const salesHospitalRoutes = require('./src/routes/sales/HospitalRoute.js')
+const { port } = require('./config/config.js')
+
+app.use(cors())
+app.use(express.json())
+app.use('/storage/', express.static(path.join(__dirname, 'storage/')));
+
+const apiV1 = express.Router();
+
+// apiV1.use('/hospitals', hospitalRoutes);
+apiV1.use('/province', provinceRoutes);
+apiV1.use('/auth', authRoutes);
+// apiV1.use('/user', userRoutes);
+apiV1.use('/city', cityRoutes);
+apiV1.use('/sales', salesRoutes);
+apiV1.use('/admin', adminRoutes);
+apiV1.use('/hospital', hospitalRoutes);
+apiV1.use('/hospital-area', salesHospitalRoutes);
+
+app.use('/v1/api', apiV1);
+app.use(errorHandler);
+
+app.listen(port, () => {
+    console.log(`Server started on port ${port}`);
+})

keycloak.json

@@ -0,0 +1,14 @@
+{
+    "realm": "radar",
+    "auth-server-url": "https://keycloak.natagw.my.id/",
+    "ssl-required": "external",
+    "resource": "fg-radar",
+    "verify-token-audience": true,
+    "credentials": {
+        "secret": "7kVIBw6FYdHhjLRfnruLj4l8X0qlP2Yz"
+    },
+    "confidential-port": 0,
+    "policy-enforcer": {
+        "credentials": {}
+    }
+}

package.json

@@ -0,0 +1,33 @@
+{
+  "name": "proyek_radar_farmagitechs",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "prisma": {
+    "seed": "node prisma/seeders/DatabaseSeeder.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@faker-js/faker": "^9.8.0",
+    "@prisma/client": "^6.10.1",
+    "axios": "^1.10.0",
+    "bcrypt": "^6.0.0",
+    "cors": "^2.8.5",
+    "dayjs": "^1.11.13",
+    "dayjs-plugin-utc": "^0.1.2",
+    "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "jsonwebtoken": "^9.0.2",
+    "multer": "^2.0.1",
+    "pg": "^8.16.2",
+    "qs": "^6.14.0"
+  },
+  "devDependencies": {
+    "prisma": "^6.10.1"
+  }
+}

prisma/migrations/20250623021621_migrate_init/migration.sql

@@ -0,0 +1,104 @@
+-- CreateTable
+CREATE TABLE "revoked_tokens" (
+    "id" TEXT NOT NULL,
+    "token" TEXT NOT NULL,
+    "revoked_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "revoked_tokens_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "users" (
+    "id" TEXT NOT NULL,
+    "username" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "password_hash" TEXT NOT NULL,
+    "role" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "users_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "provinces" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "provinces_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "cities" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "province_id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "cities_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "hospitals" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "hospital_code" TEXT,
+    "type" TEXT,
+    "ownership" TEXT,
+    "province_id" TEXT NOT NULL,
+    "city_id" TEXT NOT NULL,
+    "address" TEXT,
+    "simrs_type" TEXT,
+    "contact" TEXT,
+    "image" TEXT,
+    "progress_status" TEXT,
+    "note" TEXT,
+    "created_by" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "hospitals_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "user_areas" (
+    "id" TEXT NOT NULL,
+    "user_id" TEXT NOT NULL,
+    "province_id" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "user_areas_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "provinces_name_key" ON "provinces"("name");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "cities_name_province_id_key" ON "cities"("name", "province_id");
+
+-- AddForeignKey
+ALTER TABLE "cities" ADD CONSTRAINT "cities_province_id_fkey" FOREIGN KEY ("province_id") REFERENCES "provinces"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "hospitals" ADD CONSTRAINT "hospitals_province_id_fkey" FOREIGN KEY ("province_id") REFERENCES "provinces"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "hospitals" ADD CONSTRAINT "hospitals_city_id_fkey" FOREIGN KEY ("city_id") REFERENCES "cities"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "hospitals" ADD CONSTRAINT "hospitals_created_by_fkey" FOREIGN KEY ("created_by") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "user_areas" ADD CONSTRAINT "user_areas_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "user_areas" ADD CONSTRAINT "user_areas_province_id_fkey" FOREIGN KEY ("province_id") REFERENCES "provinces"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/migrations/20250623071313_update_field_user/migration.sql

@@ -0,0 +1,18 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `name` on the `users` table. All the data in the column will be lost.
+  - You are about to drop the column `password_hash` on the `users` table. All the data in the column will be lost.
+  - Added the required column `email` to the `users` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `firstname` to the `users` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `lastname` to the `users` table without a default value. This is not possible if the table is not empty.
+  - Added the required column `password` to the `users` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- AlterTable
+ALTER TABLE "users" DROP COLUMN "name",
+DROP COLUMN "password_hash",
+ADD COLUMN     "email" TEXT NOT NULL,
+ADD COLUMN     "firstname" TEXT NOT NULL,
+ADD COLUMN     "lastname" TEXT NOT NULL,
+ADD COLUMN     "password" TEXT NOT NULL;

prisma/migrations/20250623091018_add_field_activity_logs/migration.sql

@@ -0,0 +1,18 @@
+-- AlterTable
+ALTER TABLE "hospitals" ADD COLUMN     "logActivityId" TEXT;
+
+-- AlterTable
+ALTER TABLE "user_areas" ADD COLUMN     "logActivityId" TEXT;
+
+-- CreateTable
+CREATE TABLE "activity_logs" (
+    "id" TEXT NOT NULL,
+    "user_id" TEXT NOT NULL,
+    "username" TEXT NOT NULL,
+    "action" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+    "deletedAt" TIMESTAMP(3),
+
+    CONSTRAINT "activity_logs_pkey" PRIMARY KEY ("id")
+);

prisma/migrations/20250624013629_update_table_hospital_and_user_area/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `logActivityId` on the `hospitals` table. All the data in the column will be lost.
+
+*/
+-- AlterTable
+ALTER TABLE "hospitals" DROP COLUMN "logActivityId";

prisma/migrations/20250624013831_update_table/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - You are about to drop the column `logActivityId` on the `user_areas` table. All the data in the column will be lost.
+
+*/
+-- AlterTable
+ALTER TABLE "user_areas" DROP COLUMN "logActivityId";

prisma/migrations/20250624041254_update_field_enum_in_hospital/migration.sql

@@ -0,0 +1,12 @@
+/*
+  Warnings:
+
+  - Added the required column `progress_status` to the `hospitals` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- CreateEnum
+CREATE TYPE "ProgressStatus" AS ENUM ('cari_data', 'dihubungi', 'negosiasi', 'follow_up', 'mou', 'onboarded', 'tidak_berminat');
+
+-- AlterTable
+ALTER TABLE "hospitals" DROP COLUMN "progress_status",
+ADD COLUMN     "progress_status" "ProgressStatus" NOT NULL;

prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (e.g., Git)
+provider = "postgresql"

prisma/schema.prisma

@@ -0,0 +1,126 @@
+// This is your Prisma schema file,
+// learn more about it in the docs: https://pris.ly/d/prisma-schema
+
+// Looking for ways to speed up your queries, or scale easily with your serverless or edge functions?
+// Try Prisma Accelerate: https://pris.ly/cli/accelerate-init
+
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "postgresql"
+  url      = env("DATABASE_URL")
+}
+
+enum ProgressStatus {
+  cari_data
+  dihubungi
+  negosiasi
+  follow_up
+  mou
+  onboarded
+  tidak_berminat
+}
+
+model RevokedToken {
+  id         String   @id @default(uuid())
+  token      String
+  revoked_at DateTime @default(now())
+
+  @@map("revoked_tokens")
+}
+
+model ActivityLog {
+  id        String    @id @default(uuid())
+  user_id   String
+  username  String
+  action    String
+  createdAt DateTime  @default(now())
+  updatedAt DateTime  @updatedAt
+  deletedAt DateTime?
+
+  @@map("activity_logs")
+}
+
+model User {
+  id         String     @id @default(uuid())
+  username   String
+  email      String
+  password   String
+  firstname  String
+  lastname   String
+  role       String
+  createdAt  DateTime   @default(now())
+  updatedAt  DateTime   @updatedAt
+  deletedAt  DateTime?
+  hospitals  Hospital[]
+  user_areas UserArea[]
+
+  @@map("users")
+}
+
+model Province {
+  id         String     @id @default(uuid())
+  name       String     @unique
+  cities     City[]
+  hospitals  Hospital[]
+  user_areas UserArea[]
+  createdAt  DateTime   @default(now())
+  updatedAt  DateTime   @updatedAt
+  deletedAt  DateTime?
+
+  @@map("provinces")
+}
+
+model City {
+  id          String     @id @default(uuid())
+  name        String
+  province_id String
+  province    Province   @relation(fields: [province_id], references: [id])
+  hospitals   Hospital[]
+  createdAt   DateTime   @default(now())
+  updatedAt   DateTime   @updatedAt
+  deletedAt   DateTime?
+
+  @@unique([name, province_id], name: "name_province_id")
+  @@map("cities")
+}
+
+model Hospital {
+  id              String       @id @default(uuid())
+  name            String
+  hospital_code   String?
+  type            String?
+  ownership       String?
+  province_id     String
+  city_id         String
+  address         String?
+  simrs_type      String?
+  contact         String?
+  image           String?
+  progress_status ProgressStatus
+  note            String?
+  created_by      String
+  createdAt       DateTime     @default(now())
+  updatedAt       DateTime     @updatedAt
+  deletedAt       DateTime?
+  province        Province     @relation(fields: [province_id], references: [id])
+  city            City         @relation(fields: [city_id], references: [id])
+  user            User         @relation(fields: [created_by], references: [id])
+
+  @@map("hospitals")
+}
+
+model UserArea {
+  id            String       @id @default(uuid())
+  user_id       String
+  province_id   String
+  user          User         @relation(fields: [user_id], references: [id])
+  province      Province     @relation(fields: [province_id], references: [id])
+  createdAt     DateTime     @default(now())
+  updatedAt     DateTime     @updatedAt
+  deletedAt     DateTime?
+
+  @@map("user_areas")
+}

prisma/seeders/DatabaseSeeder.js

@@ -0,0 +1,93 @@
+const prisma = require('../../src/prisma/PrismaClient.js');
+
+const { seedProvinces } = require('./ProvinceSeeder');
+const { seedAcehCities } = require('./city/AcehCitySeeder');
+const { seedBaliCities } = require('./city/BaliCitySeeder');
+const { seedBantenCities } = require('./city/BantenCitySeeder');
+const { seedBengkuluCities } = require('./city/BengkuluCitySeeder');
+const { seedDIYogyakartaCities } = require('./city/DIYogyakartaCitySeeder');
+const { seedDKIJakartaCities } = require('./city/DKIJakartaCitySeeder');
+const { seedGorontaloCities } = require('./city/GorontaloCitySeeder');
+const { seedJambiCities } = require('./city/JambiCitySeeder');
+const { seedJawaBaratCities } = require('./city/JawaBaratCitySeeder');
+const { seedJawaTengahCities } = require('./city/JawaTengahCitySeeder');
+const { seedJawaTimurCities } = require('./city/JawaTimurCitySeeder');
+const { seedKalimantanBaratCities } = require('./city/KalimantanBaratCitySeeder');
+const { seedKalimantanSelatanCities } = require('./city/KalimantanSelatanCitySeeder');
+const { seedKalimantanTengahCities } = require('./city/KalimantanTengahCitySeeder');
+const { seedKalimantanTimurCities } = require('./city/KalimantanTimurCitySeeder');
+const { seedKalimantanUtaraCities } = require('./city/KalimantanUtaraCitySeeder');
+const { seedKepulauanBangkaBelitungCities } = require('./city/KepulauanBangkaBelitungCitySeeder');
+const { seedKepulauanRiauCities } = require('./city/KepulauanRiauCitySeeder');
+const { seedLampungCities } = require('./city/LampungCitySeeder');
+const { seedMalukuCities } = require('./city/MalukuCitySeeder');
+const { seedMalukuUtaraCities } = require('./city/MalukuUtaraCitySeeder');
+const { seedNusaTenggaraBaratCities } = require('./city/NusaTenggaraBaratCitySeeder');
+const { seedNusaTenggaraTimurCities } = require('./city/NusaTenggaraTimurCitySeeder');
+const { seedPapuaCities } = require('./city/PapuaCitySeeder');
+const { seedPapuaBaratCities } = require('./city/PapuaBaratCitySeeder');
+const { seedPapuaBaratDayaCities } = require('./city/PapuaBaratDayaCitySeeder');
+const { seedPapuaPegununganCities } = require('./city/PapuaPegununganCitySeeder');
+const { seedPapuaTengahCities } = require('./city/PapuaTengahCitySeeder');
+const { seedRiauCities } = require('./city/RiauCitySeeder');
+const { seedSulawesiBaratCities } = require('./city/SulawesiBaratCitySeeder');
+const { seedSulawesiSelatanCities } = require('./city/SulawesiSelatanCitySeeder');
+const { seedSulawesiTengahCities } = require('./city/SulawesiTengahCitySeeder');
+const { seedSulawesiTenggaraCities } = require('./city/SulawesiTenggaraCitySeeder');
+const { seedSulawesiUtaraCities } = require('./city/SulawesiUtaraCitySeeder');
+const { seedSumateraBaratCities } = require('./city/SumateraBaratCitySeeder');
+const { seedSumateraSelatanCities } = require('./city/SumateraSelatanCitySeeder');
+const { seedSumateraUtaraCities } = require('./city/SumateraUtaraCitySeeder');
+const { seedHospital } = require('./HospitalSeeder.js');
+const { seedSales } = require('./UserSeeder.js');
+
+async function main() {
+    await seedProvinces();
+    await seedAcehCities();
+    await seedBaliCities();
+    await seedBantenCities();
+    await seedBengkuluCities();
+    await seedDIYogyakartaCities();
+    await seedDKIJakartaCities();
+    await seedGorontaloCities();
+    await seedJambiCities();
+    await seedJawaBaratCities();
+    await seedJawaTengahCities();
+    await seedJawaTimurCities();
+    await seedKalimantanBaratCities();
+    await seedKalimantanSelatanCities();
+    await seedKalimantanTengahCities();
+    await seedKalimantanTimurCities();
+    await seedKalimantanUtaraCities();
+    await seedKepulauanBangkaBelitungCities();
+    await seedKepulauanRiauCities();
+    await seedLampungCities();
+    await seedMalukuCities();
+    await seedMalukuUtaraCities();
+    await seedNusaTenggaraBaratCities();
+    await seedNusaTenggaraTimurCities();
+    await seedPapuaCities();
+    await seedPapuaBaratCities();
+    await seedPapuaBaratDayaCities();
+    await seedPapuaPegununganCities();
+    await seedPapuaTengahCities();
+    await seedRiauCities();
+    await seedSulawesiBaratCities();
+    await seedSulawesiSelatanCities();
+    await seedSulawesiTengahCities();
+    await seedSulawesiTenggaraCities();
+    await seedSulawesiUtaraCities();
+    await seedSumateraBaratCities();
+    await seedSumateraSelatanCities();
+    await seedSumateraUtaraCities();
+    // await seedSales();
+    // await seedHospital();
+}
+
+main().then(() => {
+    console.log('✅ Seeding completed');
+    return prisma.$disconnect();
+}).catch((e) => {
+    console.error('❌ Seeding error:', e);
+    return prisma.$disconnect().then(() => process.exit(1));
+});

prisma/seeders/HospitalSeeder.js

@@ -0,0 +1,49 @@
+const prisma = require('../../src/prisma/PrismaClient.js');
+const { faker } = require('@faker-js/faker');
+const timeLocal = require('../../src/utils/TimeLocal.js');
+
+exports.seedHospital = async () => {
+    // 1. Ambil semua provinsi
+    const allProvinces = await prisma.province.findMany();
+    const shuffled = allProvinces.sort(() => 0.5 - Math.random());
+    const selectedProvinces = shuffled.slice(0, 5); // ambil 5 random
+
+    for (const province of selectedProvinces) {
+        const cities = await prisma.city.findMany({
+            where: { province_id: province.id }
+        });
+
+        if (cities.length === 0) continue; // skip kalau tidak ada kota
+
+        const randomCity = cities[Math.floor(Math.random() * cities.length)];
+
+        await prisma.hospital.create({
+            data: {
+                name: `RS ${faker.company.name()}`,
+                hospital_code: faker.string.alphanumeric(6).toUpperCase(),
+                type: faker.helpers.arrayElement(['Tipe A', 'Tipe B', 'Tipe C']),
+                ownership: faker.helpers.arrayElement(['Pemerintah', 'Swasta']),
+                address: faker.location.streetAddress(),
+                simrs_type: faker.helpers.arrayElement(['SIMRS A', 'SIMRS B', 'SIMRS C']),
+                contact: faker.phone.number('08##########'),
+                image: '/storage/img/dummy.jpg',
+                note: faker.lorem.sentence(),
+                progress_status: 'cari_data',
+                createdAt: timeLocal.now().toDate(),
+                province: { connect: { id: province.id } },
+                city: { connect: { id: randomCity.id } },
+                // user: { connect: { id: await getRandomUserId() } }, // opsional: assign user
+                user: null
+            }
+        });
+    }
+
+    console.log('✅ Hospital seeder done!');
+};
+
+// Fungsi ambil 1 user id random dari tabel user
+async function getRandomUserId() {
+    const users = await prisma.user.findMany({ where: { deletedAt: null } });
+    if (users.length === 0) throw new Error('No users found for seeding hospital.');
+    return users[Math.floor(Math.random() * users.length)].id;
+}

prisma/seeders/ProvinceSeeder.js

@@ -0,0 +1,30 @@
+const prisma = require('../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../src/utils/TimeLocal.js')
+
+const provinces = [
+    "Aceh", "Bali", "Banten", "Bengkulu", "DI Yogyakarta", "DKI Jakarta", "Gorontalo",
+    "Jambi", "Jawa Barat", "Jawa Tengah", "Jawa Timur", "Kalimantan Barat",
+    "Kalimantan Selatan", "Kalimantan Tengah", "Kalimantan Timur", "Kalimantan Utara",
+    "Kepulauan Bangka Belitung", "Kepulauan Riau", "Lampung", "Maluku",
+    "Maluku Utara", "Nusa Tenggara Barat", "Nusa Tenggara Timur", "Papua",
+    "Papua Barat", "Papua Barat Daya", "Papua Pegunungan", "Papua Selatan",
+    "Papua Tengah", "Riau", "Sulawesi Barat", "Sulawesi Selatan", "Sulawesi Tengah",
+    "Sulawesi Tenggara", "Sulawesi Utara", "Sumatera Barat", "Sumatera Selatan", "Sumatera Utara"
+];
+
+exports.seedProvinces = async () => {
+    for (const name of provinces.sort()) {
+        await prisma.province.upsert({
+            where: { name },
+            create: {
+                name,
+                createdAt: timeLocal.now().toDate(),
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            }
+        });
+    }
+
+    console.log('✅ Provinces seeded!');
+};

prisma/seeders/UserSeeder.js

@@ -0,0 +1,51 @@
+const { KeycloakRepository, UserRepository, UserAreaRepository } = require('../../src/repository/admin/SalesRepository.js');
+const prisma = require('../../src/prisma/PrismaClient');
+const { faker } = require('@faker-js/faker');
+
+exports.seedSales = async () => {
+    try {
+        const provinces = await prisma.province.findMany();
+        if (provinces.length === 0) throw new Error('No provinces found');
+
+        const users = [
+            {
+                username: 'sales1',
+                email: 'sales1@example.com',
+                firstname: 'Sales',
+                lastname: 'One',
+                password: 'Sales@123',
+            },
+            {
+                username: 'sales2',
+                email: 'sales2@example.com',
+                firstname: 'Sales',
+                lastname: 'Two',
+                password: 'Sales@123',
+            },
+            {
+                username: 'sales3',
+                email: 'sales3@example.com',
+                firstname: 'Sales',
+                lastname: 'Three',
+                password: 'Sales@123',
+            },
+        ];
+
+        for (const user of users) {
+            const shuffled = provinces.sort(() => 0.5 - Math.random());
+            const selectedProvinces = shuffled.slice(0, Math.floor(Math.random() * 3) + 1);
+            const province_ids = selectedProvinces.map(p => p.id);
+
+            user.province_ids = province_ids;
+
+            const userId = await KeycloakRepository.createUser(user);
+            await KeycloakRepository.assignSalesRole(userId);
+            await UserRepository.createUser(userId, user);
+            await UserAreaRepository.createMany(userId, province_ids);
+
+            console.log(`✅ Seeded user ${user.username}`);
+        }
+    } catch (err) {
+        console.error('❌ Failed to seed sales:', err.message);
+    }
+};

prisma/seeders/city/AcehCitySeeder.js

@@ -0,0 +1,62 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Aceh Barat',
+    'Kabupaten Aceh Barat Daya',
+    'Kabupaten Aceh Besar',
+    'Kabupaten Aceh Jaya',
+    'Kabupaten Aceh Selatan',
+    'Kabupaten Aceh Singkil',
+    'Kabupaten Aceh Tamiang',
+    'Kabupaten Aceh Tengah',
+    'Kabupaten Aceh Tenggara',
+    'Kabupaten Aceh Timur',
+    'Kabupaten Aceh Utara',
+    'Kabupaten Bener Meriah',
+    'Kabupaten Bireuen',
+    'Kabupaten Gayo Lues',
+    'Kabupaten Nagan Raya',
+    'Kabupaten Pidie',
+    'Kabupaten Pidie Jaya',
+    'Kabupaten Simeulue',
+    'Kota Banda Aceh',
+    'Kota Langsa',
+    'Kota Lhokseumawe',
+    'Kota Sabang',
+    'Kota Subulussalam'
+
+    // 23
+];
+
+exports.seedAcehCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Aceh' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Aceh not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            create: {
+                name,
+                province_id: province.id,
+                updatedAt: timeLocal.now().toDate()
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            }
+        });
+    }
+
+    console.log('✅ Aceh City seeded!.');
+};

prisma/seeders/city/BaliCitySeeder.js

@@ -0,0 +1,48 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Badung',
+    'Kabupaten Bangli',
+    'Kabupaten Buleleng',
+    'Kabupaten Gianyar',
+    'Kabupaten Jembrana',
+    'Kabupaten Karangasem',
+    'Kabupaten Klungkung',
+    'Kabupaten Tabanan',
+    'Kota Denpasar'
+
+    // 9
+];
+
+exports.seedBaliCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Bali' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Bali not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Bali City seeded!.');
+};

prisma/seeders/city/BantenCitySeeder.js

@@ -0,0 +1,47 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Lebak',
+    'Kabupaten Pandeglang',
+    'Kabupaten Serang',
+    'Kabupaten Tangerang',
+    'Kota Cilegon',
+    'Kota Serang',
+    'Kota Tangerang',
+    'Kota Tangerang Selatan'
+
+    // 8
+];
+
+exports.seedBantenCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Banten' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Banten not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Banten City seeded!.');
+};

prisma/seeders/city/BengkuluCitySeeder.js

@@ -0,0 +1,47 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bengkulu Selatan',
+    'Kabupaten Bengkulu Tengah',
+    'Kabupaten Bengkulu Utara',
+    'Kabupaten Kaur',
+    'Kabupaten Kepahiang',
+    'Kabupaten Lebong',
+    'Kabupaten Muko Muko',
+    'Kabupaten Rejang Lebong',
+    'Kabupaten Seluma',
+    'Kota Bengkulu'
+
+    // 10
+];
+
+exports.seedBengkuluCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Bengkulu' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Bengkulu not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Bengkulu City seeded!.');
+};

prisma/seeders/city/DIYogyakartaCitySeeder.js

@@ -0,0 +1,42 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bantul',
+    'Kabupaten Gunungkidul',
+    'Kabupaten Kulon Progo',
+    'Kabupaten Sleman',
+    'Kota Yogyakarta'
+
+    // 5
+];
+
+exports.seedDIYogyakartaCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'DI Yogyakarta' },
+    });
+
+    if (!province) {
+        console.error('❌ Province DI Yogyakarta not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ DI Yogyakarta City seeded!.');
+};

prisma/seeders/city/DKIJakartaCitySeeder.js

@@ -0,0 +1,45 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Kepulauan Seribu',
+    'Kota Jakarta Barat',
+    'Kota Jakarta Pusat',
+    'Kota Jakarta Selatan',
+    'Kota Jakarta Timur',
+    'Kota Jakarta Utara'
+
+    // 6
+];
+
+exports.seedDKIJakartaCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'DKI Jakarta' },
+    });
+
+    if (!province) {
+        console.error('❌ Province DKI Jakarta not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ DKI Jakarta City seeded!.');
+};

prisma/seeders/city/GorontaloCitySeeder.js

@@ -0,0 +1,45 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Boalemo',
+    'Kabupaten Bone Bolango',
+    'Kabupaten Gorontalo',
+    'Kabupaten Gorontalo Utara',
+    'Kabupaten Pohuwato',
+    'Kota Gorontalo'
+
+    // 6
+];
+
+exports.seedGorontaloCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Gorontalo' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Gorontalo not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Gorontalo City seeded!.');
+};

prisma/seeders/city/JambiCitySeeder.js

@@ -0,0 +1,50 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Batang Hari',
+    'Kabupaten Bungo',
+    'Kabupaten Kerinci',
+    'Kabupaten Merangin',
+    'Kabupaten Muaro Jambi',
+    'Kabupaten Sarolangun',
+    'Kabupaten Tanjung Jabung Barat',
+    'Kabupaten Tanjung Jabung Timur',
+    'Kabupaten Tebo',
+    'Kota Jambi',
+    'Kota Sungai Penuh'
+
+    // 11
+];
+
+exports.seedJambiCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Jambi' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Jambi not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Jambi City seeded!.');
+};

prisma/seeders/city/JawaBaratCitySeeder.js

@@ -0,0 +1,66 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bandung',
+    'Kabupaten Bandung Barat',
+    'Kabupaten Bekasi',
+    'Kabupaten Bogor',
+    'Kabupaten Ciamis',
+    'Kabupaten Cianjur',
+    'Kabupaten Cirebon',
+    'Kabupaten Garut',
+    'Kabupaten Indramayu',
+    'Kabupaten Karawang',
+    'Kabupaten Kuningan',
+    'Kabupaten Majalengka',
+    'Kabupaten Pangandaran',
+    'Kabupaten Purwakarta',
+    'Kabupaten Subang',
+    'Kabupaten Sukabumi',
+    'Kabupaten Sumedang',
+    'Kabupaten Tasikmalaya',
+    'Kota Bandung',
+    'Kota Banjar',
+    'Kota Bekasi',
+    'Kota Bogor',
+    'Kota Cimahi',
+    'Kota Cirebon',
+    'Kota Depok',
+    'Kota Sukabumi',
+    'Kota Tasikmalaya'
+
+    // 27
+];
+
+exports.seedJawaBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Jawa Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Jawa Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Jawa Barat City seeded!.');
+};

prisma/seeders/city/JawaTengahCitySeeder.js

@@ -0,0 +1,74 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Banjarnegara',
+    'Kabupaten Banyumas',
+    'Kabupaten Batang',
+    'Kabupaten Blora',
+    'Kabupaten Boyolali',
+    'Kabupaten Brebes',
+    'Kabupaten Cilacap',
+    'Kabupaten Demak',
+    'Kabupaten Grobogan',
+    'Kabupaten Jepara',
+    'Kabupaten Karanganyar',
+    'Kabupaten Kebumen',
+    'Kabupaten Kendal',
+    'Kabupaten Klaten',
+    'Kabupaten Kudus',
+    'Kabupaten Magelang',
+    'Kabupaten Pati',
+    'Kabupaten Pekalongan',
+    'Kabupaten Pemalang',
+    'Kabupaten Purbalingga',
+    'Kabupaten Purworejo',
+    'Kabupaten Rembang',
+    'Kabupaten Semarang',
+    'Kabupaten Sragen',
+    'Kabupaten Sukoharjo',
+    'Kabupaten Tegal',
+    'Kabupaten Temanggung',
+    'Kabupaten Wonogiri',
+    'Kabupaten Wonosobo',
+    'Kota Magelang',
+    'Kota Pekalongan',
+    'Kota Salatiga',
+    'Kota Semarang',
+    'Kota Surakarta',
+    'Kota Tegal'
+
+    // 35
+];
+
+exports.seedJawaTengahCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Jawa Tengah' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Jawa Tengah not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Jawa Tengah City seeded!.');
+};

prisma/seeders/city/JawaTimurCitySeeder.js

@@ -0,0 +1,77 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bangkalan',
+    'Kabupaten Banyuwangi',
+    'Kabupaten Blitar',
+    'Kabupaten Bojonegoro',
+    'Kabupaten Bondowoso',
+    'Kabupaten Gresik',
+    'Kabupaten Jember',
+    'Kabupaten Jombang',
+    'Kabupaten Kediri',
+    'Kabupaten Lamongan',
+    'Kabupaten Lumajang',
+    'Kabupaten Madiun',
+    'Kabupaten Magetan',
+    'Kabupaten Malang',
+    'Kabupaten Mojokerto',
+    'Kabupaten Nganjuk',
+    'Kabupaten Ngawi',
+    'Kabupaten Pacitan',
+    'Kabupaten Pamekasan',
+    'Kabupaten Pasuruan',
+    'Kabupaten Ponorogo',
+    'Kabupaten Probolinggo',
+    'Kabupaten Sampang',
+    'Kabupaten Sidoarjo',
+    'Kabupaten Situbondo',
+    'Kabupaten Sumenep',
+    'Kabupaten Trenggalek',
+    'Kabupaten Tuban',
+    'Kabupaten Tulungagung',
+    'Kota Batu',
+    'Kota Blitar',
+    'Kota Kediri',
+    'Kota Madiun',
+    'Kota Malang',
+    'Kota Mojokerto',
+    'Kota Pasuruan',
+    'Kota Probolinggo',
+    'Kota Surabaya'
+
+    // 38
+];
+
+exports.seedJawaTimurCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Jawa Timur' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Jawa Timur not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Jawa Timur City seeded!.');
+};

prisma/seeders/city/KalimantanBaratCitySeeder.js

@@ -0,0 +1,53 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bengkayang',
+    'Kabupaten Kapuas Hulu',
+    'Kabupaten Kayong Utara',
+    'Kabupaten Ketapang',
+    'Kabupaten Kubu Raya',
+    'Kabupaten Landak',
+    'Kabupaten Melawi',
+    'Kabupaten Mempawah',
+    'Kabupaten Sambas',
+    'Kabupaten Sanggau',
+    'Kabupaten Sekadau',
+    'Kabupaten Sintang',
+    'Kota Pontianak',
+    'Kota Singkawang'
+
+    // 14
+];
+
+exports.seedKalimantanBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kalimantan Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kalimantan Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kalimantan Barat City seeded!.');
+};

prisma/seeders/city/KalimantanSelatanCitySeeder.js

@@ -0,0 +1,52 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Balangan',
+    'Kabupaten Banjar',
+    'Kabupaten Barito Kuala',
+    'Kabupaten Hulu Sungai Selatan',
+    'Kabupaten Hulu Sungai Tengah',
+    'Kabupaten Hulu Sungai Utara',
+    'Kabupaten Kotabaru',
+    'Kabupaten Tabalong',
+    'Kabupaten Tanah Bumbu',
+    'Kabupaten Tanah Laut',
+    'Kabupaten Tapin',
+    'Kota Banjarbaru',
+    'Kota Banjarmasin'
+
+    // 13
+];
+
+exports.seedKalimantanSelatanCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kalimantan Selatan' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kalimantan Selatan not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kalimantan Selatan City seeded!.');
+};

prisma/seeders/city/KalimantanTengahCitySeeder.js

@@ -0,0 +1,53 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Barito Selatan',
+    'Kabupaten Barito Timur',
+    'Kabupaten Barito Utara',
+    'Kabupaten Gunung Mas',
+    'Kabupaten Kapuas',
+    'Kabupaten Katingan',
+    'Kabupaten Kotawaringin Barat',
+    'Kabupaten Kotawaringin Timur',
+    'Kabupaten Lamandau',
+    'Kabupaten Murung Raya',
+    'Kabupaten Pulang Pisau',
+    'Kabupaten Sukamara',
+    'Kabupaten Seruyan',
+    'Kota Palangka Raya'
+
+    // 14
+];
+
+exports.seedKalimantanTengahCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kalimantan Tengah' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kalimantan Tengah not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kalimantan Tengah City seeded!.');
+};

prisma/seeders/city/KalimantanTimurCitySeeder.js

@@ -0,0 +1,49 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Berau',
+    'Kabupaten Kutai Barat',
+    'Kabupaten Kutai Kartanegara',
+    'Kabupaten Kutai Timur',
+    'Kabupaten Mahakam Ulu',
+    'Kabupaten Paser',
+    'Kabupaten Penajam Paser Utara',
+    'Kota Balikpapan',
+    'Kota Bontang',
+    'Kota Samarinda'
+
+    // 10
+];
+
+exports.seedKalimantanTimurCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kalimantan Timur' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kalimantan Timur not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kalimantan Timur City seeded!.');
+};

prisma/seeders/city/KalimantanUtaraCitySeeder.js

@@ -0,0 +1,44 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bulungan',
+    'Kabupaten Malinau',
+    'Kabupaten Nunukan',
+    'Kabupaten Tana Tidung',
+    'Kota Tarakan'
+
+    // 5
+];
+
+exports.seedKalimantanUtaraCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kalimantan Utara' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kalimantan Utara not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kalimantan Utara City seeded!.');
+};

prisma/seeders/city/KepulauanBangkaBelitungCitySeeder.js

@@ -0,0 +1,46 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bangka',
+    'Kabupaten Bangka Barat',
+    'Kabupaten Bangka Selatan',
+    'Kabupaten Bangka Tengah',
+    'Kabupaten Belitung',
+    'Kabupaten Belitung Timur',
+    'Kota Pangkal Pinang'
+
+    // 7
+];
+
+exports.seedKepulauanBangkaBelitungCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kepulauan Bangka Belitung' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kepulauan Bangka Belitung not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kepulauan Bangka Belitung City seeded!.');
+};

prisma/seeders/city/KepulauanRiauCitySeeder.js

@@ -0,0 +1,46 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bintan',
+    'Kabupaten Karimun',
+    'Kabupaten Kepulauan Anambas',
+    'Kabupaten Lingga',
+    'Kabupaten Natuna',
+    'Kota Batam',
+    'Kota Tanjung Pinang'
+
+    // 7
+];
+
+exports.seedKepulauanRiauCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Kepulauan Riau' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Kepulauan Riau not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Kepulauan Riau City seeded!.');
+};

prisma/seeders/city/LampungCitySeeder.js

@@ -0,0 +1,54 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Lampung Barat',
+    'Kabupaten Lampung Selatan',
+    'Kabupaten Lampung Tengah',
+    'Kabupaten Lampung Timur',
+    'Kabupaten Lampung Utara',
+    'Kabupaten Mesuji',
+    'Kabupaten Pesawaran',
+    'Kabupaten Pesisir Barat',
+    'Kabupaten Pringsewu',
+    'Kabupaten Tanggamus',
+    'Kabupaten Tulang Bawang',
+    'Kabupaten Tulang Bawang Barat',
+    'Kabupaten Way Kanan',
+    'Kota Bandar Lampung',
+    'Kota Metro'
+
+    // 15
+];
+
+exports.seedLampungCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Lampung' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Lampung not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Lampung City seeded!.');
+};

prisma/seeders/city/MalukuCitySeeder.js

@@ -0,0 +1,50 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Buru',
+    'Kabupaten Buru Selatan',
+    'Kabupaten Kepulauan Aru',
+    'Kabupaten Maluku Barat Daya',
+    'Kabupaten Maluku Tengah',
+    'Kabupaten Maluku Tenggara',
+    'Kabupaten Seram Bagian Barat',
+    'Kabupaten Seram Bagian Timur',
+    'Kota Ambon',
+    'Kota Tual',
+    'Kabupaten Maluku Tenggara Barat'
+
+    // 11
+];
+
+exports.seedMalukuCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Maluku' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Maluku not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Maluku City seeded!.');
+};

prisma/seeders/city/MalukuUtaraCitySeeder.js

@@ -0,0 +1,49 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Halmahera Barat',
+    'Kabupaten Halmahera Tengah',
+    'Kabupaten Halmahera Timur',
+    'Kabupaten Halmahera Selatan',
+    'Kabupaten Halmahera Utara',
+    'Kabupaten Kepulauan Sula',
+    'Kabupaten Pulau Morotai',
+    'Kabupaten Pulau Taliabu',
+    'Kota Ternate',
+    'Kota Tidore Kepulauan'
+
+    // 10
+];
+
+exports.seedMalukuUtaraCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Maluku Utara' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Maluku Utara not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Maluku Utara City seeded!.');
+};

prisma/seeders/city/NusaTenggaraBaratCitySeeder.js

@@ -0,0 +1,49 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bima',
+    'Kabupaten Dompu',
+    'Kabupaten Lombok Barat',
+    'Kabupaten Lombok Tengah',
+    'Kabupaten Lombok Timur',
+    'Kabupaten Lombok Utara',
+    'Kabupaten Sumbawa',
+    'Kabupaten Sumbawa Barat',
+    'Kota Bima',
+    'Kota Mataram'
+
+    // 10
+];
+
+exports.seedNusaTenggaraBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Nusa Tenggara Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Nusa Tenggara Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Nusa Tenggara Barat City seeded!.');
+};

prisma/seeders/city/NusaTenggaraTimurCitySeeder.js

@@ -0,0 +1,61 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Alor',
+    'Kabupaten Belu',
+    'Kabupaten Ende',
+    'Kabupaten Flores Timur',
+    'Kabupaten Kupang',
+    'Kabupaten Lembata',
+    'Kabupaten Malaka',
+    'Kabupaten Manggarai',
+    'Kabupaten Manggarai Barat',
+    'Kabupaten Manggarai Timur',
+    'Kabupaten Nagekeo',
+    'Kabupaten Ngada',
+    'Kabupaten Rote Ndao',
+    'Kabupaten Sabu Raijua',
+    'Kabupaten Sikka',
+    'Kabupaten Sumba Barat',
+    'Kabupaten Sumba Barat Daya',
+    'Kabupaten Sumba Tengah',
+    'Kabupaten Sumba Timur',
+    'Kabupaten Timor Tengah Selatan',
+    'Kabupaten Timor Tengah Utara',
+    'Kota Kupang'
+
+    // 22
+];
+
+exports.seedNusaTenggaraTimurCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Nusa Tenggara Timur' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Nusa Tenggara Timur not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Nusa Tenggara Timur City seeded!.');
+};

prisma/seeders/city/PapuaBaratCitySeeder.js

@@ -0,0 +1,46 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Fakfak',
+    'Kabupaten Kaimana',
+    'Kabupaten Manokwari',
+    'Kabupaten Manokwari Selatan',
+    'Kabupaten Pegunungan Arfak',
+    'Kabupaten Teluk Bintuni',
+    'Kabupaten Teluk Wondama',
+
+    // 7
+];
+
+exports.seedPapuaBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua Barat City seeded!.');
+};

prisma/seeders/city/PapuaBaratDayaCitySeeder.js

@@ -0,0 +1,45 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Maybrat',
+    'Kabupaten Sorong',
+    'Kabupaten Sorong Selatan',
+    'Kabupaten Tambrauw',
+    'Kabupaten Raja Ampat',
+    'Kota Sorong'
+
+    // 6
+];
+
+exports.seedPapuaBaratDayaCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua Barat Daya' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua Barat Daya not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: {
+                updatedAt: timeLocal.now().toDate()
+            },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua Barat Daya City seeded!.');
+};

prisma/seeders/city/PapuaCitySeeder.js

@@ -0,0 +1,46 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Biak Numfor',
+    'Kabupaten Jayapura',
+    'Kabupaten Keerom',
+    'Kabupaten Kepulauan Yapen',
+    'Kabupaten Mamberamo Raya',
+    'Kabupaten Sarmi',
+    'Kabupaten Supiori',
+    'Kabupaten Waropen',
+    'Kota Jayapura'
+
+    // 9
+];
+
+exports.seedPapuaCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua City seeded!.');
+};

prisma/seeders/city/PapuaPegununganCitySeeder.js

@@ -0,0 +1,45 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Jayawijaya',
+    'Kabupaten Lanny Jaya',
+    'Kabupaten Mamberamo Tengah',
+    'Kabupaten Nduga',
+    'Kabupaten Pegunungan Bintang',
+    'Kabupaten Tolikara',
+    'Kabupaten Yahukimo',
+    'Kabupaten Yalimo'
+
+    // 8
+];
+
+exports.seedPapuaPegununganCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua Pegunungan' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua Pegunungan not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua Pegunungan City seeded!.');
+};

prisma/seeders/city/PapuaSelatanCitySeeder.js

@@ -0,0 +1,41 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Asmat',
+    'Kabupaten Boven Digoel',
+    'Kabupaten Mappi',
+    'Kabupaten Merauke'
+
+    // 4
+];
+
+exports.seedPapuaSelatanCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua Selatan' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua Selatan not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua Selatan City seeded!.');
+};

prisma/seeders/city/PapuaTengahCitySeeder.js

@@ -0,0 +1,45 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Deiyai',
+    'Kabupaten Dogiyai',
+    'Kabupaten Intan Jaya',
+    'Kabupaten Mimika',
+    'Kabupaten Nabire',
+    'Kabupaten Paniai',
+    'Kabupaten Puncak',
+    'Kabupaten Puncak Jaya'
+
+    // 8
+];
+
+exports.seedPapuaTengahCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Papua Tengah' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Papua Tengah not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Papua Tengah City seeded!.');
+};

prisma/seeders/city/RiauCitySeeder.js

@@ -0,0 +1,49 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bengkalis',
+    'Kabupaten Indragiri Hilir',
+    'Kabupaten Indragiri Hulu',
+    'Kabupaten Kampar',
+    'Kabupaten Kepulauan Meranti',
+    'Kabupaten Kuantan Singingi',
+    'Kabupaten Pelalawan',
+    'Kabupaten Rokan Hilir',
+    'Kabupaten Rokan Hulu',
+    'Kabupaten Siak',
+    'Kota Dumai',
+    'Kota Pekanbaru'
+
+    // 12
+];
+
+exports.seedRiauCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Riau' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Riau not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Riau City seeded!.');
+};

prisma/seeders/city/SulawesiBaratCitySeeder.js

@@ -0,0 +1,43 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Majene',
+    'Kabupaten Mamasa',
+    'Kabupaten Mamuju',
+    'Kabupaten Mamuju Tengah',
+    'Kabupaten Pasangkayu',
+    'Kabupaten Polewali Mandar'
+
+    // 6
+];
+
+exports.seedSulawesiBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sulawesi Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sulawesi Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sulawesi Barat City seeded!.');
+};

prisma/seeders/city/SulawesiSelatanCitySeeder.js

@@ -0,0 +1,61 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bantaeng',
+    'Kabupaten Barru',
+    'Kabupaten Bone',
+    'Kabupaten Bulukumba',
+    'Kabupaten Enrekang',
+    'Kabupaten Gowa',
+    'Kabupaten Jeneponto',
+    'Kabupaten Kepulauan Selayar',
+    'Kabupaten Luwu',
+    'Kabupaten Luwu Timur',
+    'Kabupaten Luwu Utara',
+    'Kabupaten Maros',
+    'Kabupaten Pangkajene dan Kepulauan',
+    'Kabupaten Pinrang',
+    'Kabupaten Sidenreng Rappang',
+    'Kabupaten Sinjai',
+    'Kabupaten Soppeng',
+    'Kabupaten Takalar',
+    'Kabupaten Tana Toraja',
+    'Kabupaten Toraja Utara',
+    'Kabupaten Wajo',
+    'Kota Makassar',
+    'Kota Palopo',
+    'Kota Parepare'
+
+    // 24
+];
+
+exports.seedSulawesiSelatanCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sulawesi Selatan' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sulawesi Selatan not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sulawesi Selatan City seeded!.');
+};

prisma/seeders/city/SulawesiTengahCitySeeder.js

@@ -0,0 +1,50 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Banggai',
+    'Kabupaten Banggai Kepulauan',
+    'Kabupaten Banggai Laut',
+    'Kabupaten Buol',
+    'Kabupaten Donggala',
+    'Kabupaten Morowali',
+    'Kabupaten Morowali Utara',
+    'Kabupaten Parigi Moutong',
+    'Kabupaten Poso',
+    'Kabupaten Sigi',
+    'Kabupaten Tojo Una-Una',
+    'Kabupaten Tolitoli',
+    'Kota Palu'
+
+    // 13
+];
+
+exports.seedSulawesiTengahCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sulawesi Tengah' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sulawesi Tengah not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sulawesi Tengah City seeded!.');
+};

prisma/seeders/city/SulawesiTenggaraCitySeeder.js

@@ -0,0 +1,54 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bombana',
+    'Kabupaten Buton',
+    'Kabupaten Buton Selatan',
+    'Kabupaten Buton Tengah',
+    'Kabupaten Buton Utara',
+    'Kabupaten Kolaka',
+    'Kabupaten Kolaka Timur',
+    'Kabupaten Kolaka Utara',
+    'Kabupaten Konawe',
+    'Kabupaten Konawe Kepulauan',
+    'Kabupaten Konawe Selatan',
+    'Kabupaten Konawe Utara',
+    'Kabupaten Muna',
+    'Kabupaten Muna Barat',
+    'Kabupaten Wakatobi',
+    'Kota Baubau',
+    'Kota Kendari'
+
+    // 17
+];
+
+exports.seedSulawesiTenggaraCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sulawesi Tenggara' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sulawesi Tenggara not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sulawesi Tenggara City seeded!.');
+};

prisma/seeders/city/SulawesiUtaraCitySeeder.js

@@ -0,0 +1,52 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Bolaang Mongondow',
+    'Kabupaten Bolaang Mongondow Selatan',
+    'Kabupaten Bolaang Mongondow Timur',
+    'Kabupaten Bolaang Mongondow Utara',
+    'Kabupaten Kepulauan Sangihe',
+    'Kabupaten Kepulauan Siau Tagulandang Biaro (Sitaro)',
+    'Kabupaten Kepulauan Talaud',
+    'Kabupaten Minahasa',
+    'Kabupaten Minahasa Selatan',
+    'Kabupaten Minahasa Tenggara',
+    'Kabupaten Minahasa Utara',
+    'Kota Bitung',
+    'Kota Kotamobagu',
+    'Kota Manado',
+    'Kota Tomohon'
+
+    // 15
+];
+
+exports.seedSulawesiUtaraCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sulawesi Utara' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sulawesi Utara not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sulawesi Utara City seeded!.');
+};

prisma/seeders/city/SumateraBaratCitySeeder.js

@@ -0,0 +1,56 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Agam',
+    'Kabupaten Dharmasraya',
+    'Kabupaten Kepulauan Mentawai',
+    'Kabupaten Lima Puluh Kota',
+    'Kabupaten Padang Pariaman',
+    'Kabupaten Pasaman',
+    'Kabupaten Pasaman Barat',
+    'Kabupaten Pesisir Selatan',
+    'Kabupaten Sijunjung',
+    'Kabupaten Solok',
+    'Kabupaten Solok Selatan',
+    'Kabupaten Tanah Datar',
+    'Kota Bukittinggi',
+    'Kota Padang',
+    'Kota Padang Panjang',
+    'Kota Pariaman',
+    'Kota Payakumbuh',
+    'Kota Sawahlunto',
+    'Kota Solok'
+
+    // 19
+];
+
+exports.seedSumateraBaratCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sumatera Barat' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sumatera Barat not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sumatera Barat City seeded!.');
+};

prisma/seeders/city/SumateraSelatanCitySeeder.js

@@ -0,0 +1,54 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Banyuasin',
+    'Kabupaten Empat Lawang',
+    'Kabupaten Lahat',
+    'Kabupaten Muara Enim',
+    'Kabupaten Musi Banyuasin',
+    'Kabupaten Musi Rawas',
+    'Kabupaten Musi Rawas Utara',
+    'Kabupaten Ogan Ilir',
+    'Kabupaten Ogan Komering Ilir',
+    'Kabupaten Ogan Komering Ulu',
+    'Kabupaten Ogan Komering Ulu Selatan',
+    'Kabupaten Ogan Komering Ulu Timur',
+    'Kabupaten Penukal Abab Lematang Ilir',
+    'Kota Lubuklinggau',
+    'Kota Pagar Alam',
+    'Kota Palembang',
+    'Kota Prabumulih'
+
+    // 17
+];
+
+exports.seedSumateraSelatanCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sumatera Selatan' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sumatera Selatan not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sumatera Selatan City seeded!.');
+};

prisma/seeders/city/SumateraUtaraCitySeeder.js

@@ -0,0 +1,70 @@
+const prisma = require('../../../src/prisma/PrismaClient.js');
+const timeLocal = require('../../../src/utils/TimeLocal.js')
+
+const cityNames = [
+    'Kabupaten Asahan',
+    'Kabupaten Batu Bara',
+    'Kabupaten Dairi',
+    'Kabupaten Deli Serdang',
+    'Kabupaten Humbang Hasundutan',
+    'Kabupaten Karo',
+    'Kabupaten Labuhanbatu',
+    'Kabupaten Labuhanbatu Selatan',
+    'Kabupaten Labuhanbatu Utara',
+    'Kabupaten Langkat',
+    'Kabupaten Mandailing Natal',
+    'Kabupaten Nias',
+    'Kabupaten Nias Barat',
+    'Kabupaten Nias Selatan',
+    'Kabupaten Nias Utara',
+    'Kabupaten Padang Lawas',
+    'Kabupaten Padang Lawas Utara',
+    'Kabupaten Pakpak Bharat',
+    'Kabupaten Samosir',
+    'Kabupaten Serdang Bedagai',
+    'Kabupaten Simalungun',
+    'Kabupaten Tapanuli Selatan',
+    'Kabupaten Tapanuli Tengah',
+    'Kabupaten Tapanuli Utara',
+    'Kabupaten Toba',
+    'Kota Binjai',
+    'Kota Gunungsitoli',
+    'Kota Medan',
+    'Kota Padangsidimpuan',
+    'Kota Pematangsiantar',
+    'Kota Sibolga',
+    'Kota Tanjungbalai',
+    'Kota Tebing Tinggi'
+
+    // 33
+];
+
+exports.seedSumateraUtaraCities = async () => {
+    const province = await prisma.province.findFirst({
+        where: { name: 'Sumatera Utara' },
+    });
+
+    if (!province) {
+        console.error('❌ Province Sumatera Utara not found. Seed it first.');
+        return;
+    }
+
+    for (const name of cityNames) {
+        await prisma.city.upsert({
+            where: {
+                name_province_id: {
+                    name,
+                    province_id: province.id,
+                },
+            },
+            update: { updatedAt: timeLocal.now().toDate() },
+            create: {
+                name,
+                province_id: province.id,
+                createdAt: timeLocal.now().toDate()
+            },
+        });
+    }
+
+    console.log('✅ Sumatera Utara City seeded!.');
+};

src/controllers/admin/CityController.js

@@ -0,0 +1,60 @@
+const cityService = require('../../services/admin/CityService.js');
+const { ListResponse } = require('../../utils/ListResponse.js');
+const { PaginationParam } = require('../../utils/PaginationParams.js');
+const { errorResponse, successResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateStoreCityRequest } = 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 ListResponse({ req, res, data: cities, page, limit, total, message: '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 successResponse(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 = validateStoreCityRequest(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/HospitalController.js

@@ -0,0 +1,60 @@
+const hospitalService = require('../../services/admin/HospitalService.js');
+const { ListResponse } = require('../../utils/ListResponse.js');
+const { PaginationParam } = require('../../utils/PaginationParams.js');
+const { errorResponse, successResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateStoreHospitalRequest, validateUpdateHospitalRequest } = require('../../validators/admin/hospital/HospitalValidators.js');
+
+exports.getAllHospital = async (req, res) => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { hospitals, total } = await hospitalService.getAllHospitalService({
+            page, limit, search, sortBy, orderBy
+        });
+
+        return ListResponse({ req, res, data: hospitals, page, limit, total, message: 'Hospital data successfully retrieved' });
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.showHospital = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const data = await hospitalService.showHospitalService(id);
+        return successResponse(res, data, 'Success show hospital');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.storeHospital = async (req, res) => {
+    try {
+        const validatedData = validateStoreHospitalRequest(req.body);
+        await hospitalService.storeHospitalService(validatedData, req);
+        return messageSuccessResponse(res, 'Success added hospital', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.updateHospital = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateUpdateHospitalRequest(req.body);
+        await hospitalService.updateHospitalService(validatedData, id, req);
+        return messageSuccessResponse(res, 'Success update hospital');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.deleteHospital = async (req, res) => {
+    try {
+        const id = req.params.id;
+        await hospitalService.deleteHospitalService(id, req);
+        return messageSuccessResponse(res, 'Success delete hospital');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/controllers/admin/ProvinceController.js

@@ -0,0 +1,60 @@
+const provinceService = require('../../services/admin/ProvinceService.js');
+const { ListResponse } = require('../../utils/ListResponse.js');
+const { PaginationParam } = require('../../utils/PaginationParams.js');
+const { errorResponse, successResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateStoreProvinceRequest } = require('../../validators/admin/province/ProvinceValidators.js');
+
+exports.getAllProvince = async (req, res) => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { provinces, total } = await provinceService.getAllProvinceService({
+            page, limit, search, sortBy, orderBy
+        });
+
+        return ListResponse({ req, res, data: provinces, page, limit, total, message: 'Province data successfully retrieved' });
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.showProvince = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const data = await provinceService.showProvinceService(id);
+        return successResponse(res, data, 'Success show province');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.storeProvince = async (req, res) => {
+    try {
+        const validatedData = validateStoreProvinceRequest(req.body);
+        await provinceService.storeProvinceService(validatedData, req);
+        return messageSuccessResponse(res, 'Success added province', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.updateProvince = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateStoreProvinceRequest(req.body);
+        await provinceService.updateProvinceService(validatedData, id, req);
+        return messageSuccessResponse(res, 'Success update province');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.deleteProvince = async (req, res) => {
+    try {
+        const id = req.params.id;
+        await provinceService.deleteProvinceService(id, req);
+        return messageSuccessResponse(res, 'Success delete province');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/controllers/admin/SalesController.js

@@ -0,0 +1,60 @@
+const salesService = require('../../services/admin/SalesService.js');
+const { ListResponse } = require('../../utils/ListResponse.js');
+const { PaginationParam } = require('../../utils/PaginationParams.js');
+const { errorResponse, successResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateCreateSalesRequest, validateUpdateSalesRequest } = require('../../validators/admin/sales/SalesValidators.js');
+
+exports.getAllSales = async (req, res) => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { sales, total } = await salesService.getAllSalesService({
+            page, limit, search, sortBy, orderBy
+        });
+
+        return ListResponse({ req, res, data: sales, page, limit, total, message: 'Sales data successfully retrieved' });
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.showSales = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const data = await salesService.showSalesService(id);
+        return successResponse(res, data, 'Success show sales');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.storeSales = async (req, res) => {
+    try {
+        const validated = validateCreateSalesRequest(req.body);
+        await salesService.storeSalesService(validated, req);
+        return messageSuccessResponse(res, 'Sales user created successfully', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.updateSales = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateUpdateSalesRequest(req.body);
+        await salesService.updateSalesService(validatedData, id, req);
+        return messageSuccessResponse(res, 'Success update sales');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.deleteSales = async (req, res) => {
+    try {
+        const id = req.params.id;
+        await salesService.deleteSalesService(id, req);
+        return messageSuccessResponse(res, 'Success delete sales');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/controllers/auth/AuthControllers.js

@@ -0,0 +1,31 @@
+const { loginService, getUserService, logoutService } = require('../../services/auth/AuthService.js');
+const { successResponse, errorResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateLoginRequest } = require('../../validators/auth/LoginValidators.js');
+
+exports.login = async (req, res) => {
+    try {
+        const validated = validateLoginRequest(req.body);
+        const { user, token } = await loginService(validated, req);
+        return successResponse(res, { ...user, token }, 'Login success');
+    } catch (error) {
+        return errorResponse(res, error);
+    }
+};
+
+exports.getUser = async (req, res) => {
+    try {
+        const data = await getUserService(req);
+        return successResponse(res, data, 'Success get user');
+    } catch (error) {
+        return errorResponse(res, error);
+    }
+};
+
+exports.logout = async (req, res) => {
+    try {
+        await logoutService(req);
+        return messageSuccessResponse(res, 'Logout success', 200);
+    } catch (error) {
+        return errorResponse(res, error);
+    }
+}

src/controllers/sales/HospitalController.js

@@ -0,0 +1,48 @@
+const { getAllHospitalByAreaService, storeHospitalService, updateHospitalService, showHospitalService } = require("../../services/sales/HospitalService");
+const { ListResponse } = require("../../utils/ListResponse");
+const { PaginationParam } = require("../../utils/PaginationParams");
+const { errorResponse, messageSuccessResponse, successResponse } = require("../../utils/Response");
+const { validateStoreHospitalRequest, validateUpdateHospitalRequest } = require('../../validators/admin/hospital/HospitalValidators.js');
+
+exports.getAllHospitalByArea = async (req, res) => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { hospitals, total } = await getAllHospitalByAreaService({ page, limit, search, sortBy, orderBy, }, req);
+
+        return ListResponse({ req, res, data: hospitals, page, limit, total, message: 'Hospital data successfully retrieved' });
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.storeHospital = async (req, res) => {
+    try {
+        const validatedData = validateStoreHospitalRequest(req.body);
+        await storeHospitalService(validatedData, req);
+        return messageSuccessResponse(res, 'Success added hospital', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.updateHospital = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateUpdateHospitalRequest(req.body);
+        await updateHospitalService(validatedData, id, req);
+        return messageSuccessResponse(res, 'Success update hospital');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.showHospital = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const data = await showHospitalService(id);
+        return successResponse(res, data, 'Success show hospital');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/controllers/superadmin/AdminController.js

@@ -0,0 +1,60 @@
+const adminService = require('../../services/superadmin/AdminService.js');
+const { ListResponse } = require('../../utils/ListResponse.js');
+const { PaginationParam } = require('../../utils/PaginationParams.js');
+const { errorResponse, successResponse, messageSuccessResponse } = require('../../utils/Response.js');
+const { validateCreateAdminRequest, validateUpdateAdminRequest } = require('../../validators/superadmin/admin/AdminValidators.js');
+
+exports.getAllAdmin = async (req, res) => {
+    try {
+        const { page, limit, search, sortBy, orderBy } = PaginationParam(req);
+
+        const { admin, total } = await adminService.getAllAdminService({
+            page, limit, search, sortBy, orderBy
+        });
+
+        return ListResponse({ req, res, data: admin, page, limit, total, message: 'Admin data successfully retrieved' });
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.showAdmin = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const data = await adminService.showAdminService(id);
+        return successResponse(res, data, 'Success show admin');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};
+
+exports.storeAdmin = async (req, res) => {
+    try {
+        const validated = validateCreateAdminRequest(req.body);
+        await adminService.storeAdminService(validated, req);
+        return messageSuccessResponse(res, 'Admin user created successfully', 201);
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.updateAdmin = async (req, res) => {
+    try {
+        const id = req.params.id;
+        const validatedData = validateUpdateAdminRequest(req.body);
+        await adminService.updateAdminService(validatedData, id, req);
+        return messageSuccessResponse(res, 'Success update admin');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+}
+
+exports.deleteAdmin = async (req, res) => {
+    try {
+        const id = req.params.id;
+        await adminService.deleteAdminService(id, req);
+        return messageSuccessResponse(res, 'Success delete admin');
+    } catch (err) {
+        return errorResponse(res, err);
+    }
+};

src/middleware/CheckRole.js

@@ -0,0 +1,18 @@
+// src/middleware/checkRole.js
+const HttpException = require("../utils/HttpException");
+
+const checkRole = (requiredRoles = []) => {
+    return (req, res, next) => {
+        const userRoles = req.user?.roles || [];
+
+        const hasRole = requiredRoles.some(role => userRoles.includes(role));
+
+        if (!hasRole) {
+            throw new HttpException("You don't have permission to access this resource.", 403);
+        }
+
+        next();
+    };
+};
+
+module.exports = checkRole;

src/middleware/ErrorHandler.js

@@ -0,0 +1,19 @@
+// module.exports = (err, req, res, next) => {
+//     const status = err.statusCode || 500;
+//     // const message = err.message || 'Internal Server Error';
+//     const message = Array.isArray(err.message) ? err.message : [err.message] || 'Internal Server Error';
+
+//     res.status(status).json({
+//         success: false,
+//         message,
+//     });
+// };
+
+module.exports = (err, req, res, next) => {
+    const status = err.statusCode || 500;
+
+    res.status(status).json({
+        success: false,
+        message: err.message || 'Internal Server Error',
+    });
+};

src/middleware/UploadImage.js

@@ -0,0 +1,24 @@
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+// Pastikan folder storage/img ada
+const storagePath = path.join(__dirname, '../../storage/img');
+if (!fs.existsSync(storagePath)) {
+    fs.mkdirSync(storagePath, { recursive: true });
+}
+
+const storage = multer.diskStorage({
+    destination: (req, file, cb) => {
+        cb(null, storagePath);
+    },
+    filename: (req, file, cb) => {
+        const ext = path.extname(file.originalname);
+        const filename = `${Date.now()}-${Math.round(Math.random() * 1E9)}${ext}`;
+        cb(null, filename);
+    }
+});
+
+const upload = multer({ storage });
+
+module.exports = upload;

src/middleware/VerifyJWT.js

@@ -0,0 +1,44 @@
+const jwt = require('jsonwebtoken');
+const { JWT_SECRET } = require('../../config/keycloak.js');
+const prisma = require('../prisma/PrismaClient.js');
+
+const errorMessage = async (res, message, status_code) => {
+    return res.status(status_code).json({ status: false, message })
+}
+
+const verifyJWT = async (req, res, next) => {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        return errorMessage(res, 'Token not provided.', 401);
+    }
+
+    const token = authHeader.split(' ')[1];
+
+    try {
+        const decoded = jwt.verify(token, JWT_SECRET);
+
+        const revoked = await prisma.revokedToken.findFirst({
+            where: { token: token },
+        });
+
+        if (revoked) {
+            return errorMessage(res, 'Token has been revoked.', 401);
+        }
+
+        req.user = decoded;
+        next();
+    } catch (err) {
+        if (err.name === 'TokenExpiredError') {
+            return errorMessage(res, 'Token has expired.', 401);
+        } else if (err.name === 'JsonWebTokenError') {
+            return errorMessage(res, 'Invalid token.', 403);
+        } else if (err.name === 'NotBeforeError') {
+            return errorMessage(res, 'Token not active yet.', 401);
+        } else {
+            return errorMessage(res, 'Internal server error while verifying token.', 500);
+        }
+    }
+};
+
+module.exports = verifyJWT;

src/prisma/PrismaClient.js

@@ -0,0 +1,5 @@
+const { PrismaClient } = require('@prisma/client');
+
+const prisma = new PrismaClient();
+
+module.exports = prisma;

src/repository/admin/CityRepository.js

@@ -0,0 +1,63 @@
+const prisma = require('../../prisma/PrismaClient.js');
+
+const CityRepository = {
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return prisma.city.findMany({
+            where,
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                name: true,
+                // province_id: true,
+                createdAt: true,
+                updatedAt: true,
+                province: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                }
+            },
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.city.count({ where });
+    },
+
+    findById: async (id) => {
+        return prisma.city.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                name: true,
+                createdAt: true,
+                updatedAt: true,
+                province: {
+                    select: {
+                        id: true,
+                        name: true
+                    }
+                }
+            }
+        });
+    },
+
+    create: async (data) => {
+        return prisma.city.create({ data });
+    },
+
+    update: async (id, data) => {
+        return prisma.city.update({
+            where: { id },
+            data
+        });
+    },
+};
+
+module.exports = CityRepository;

src/repository/admin/HospitalRepository.js

@@ -0,0 +1,87 @@
+const prisma = require('../../prisma/PrismaClient.js');
+
+const HospitalRepository = {
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return await prisma.hospital.findMany({
+            where,
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                name: true,
+                hospital_code: true,
+                type: true,
+                ownership: true,
+                province: { select: { id: true, name: true } },
+                city: { select: { id: true, name: true } },
+                address: true,
+                simrs_type: true,
+                contact: true,
+                image: true,
+                progress_status: true,
+                note: true,
+                user: { select: { id: true, username: true } },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.hospital.count({ where });
+    },
+
+    findById: async (id) => {
+        return prisma.hospital.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                name: true,
+                hospital_code: true,
+                type: true,
+                ownership: true,
+                province: { select: { id: true, name: true } },
+                city: { select: { id: true, name: true } },
+                address: true,
+                simrs_type: true,
+                contact: true,
+                image: true,
+                progress_status: true,
+                note: true,
+                user: { select: { id: true, username: true } },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    create: async (data) => {
+        return prisma.hospital.create({ data });
+    },
+
+    update: async (id, data) => {
+        return prisma.hospital.update({
+            where: { id },
+            data: {
+                name: data.name,
+                hospital_code: data.hospital_code,
+                type: data.type,
+                ownership: data.ownership,
+                province: { connect: { id: data.province_id } },
+                city: { connect: { id: data.city_id } },
+                address: data.address,
+                simrs_type: data.simrs_type,
+                contact: data.contact,
+                note: data.note,
+                image: data.image,
+                progress_status: data.progress_status,
+            }
+        });
+    },
+};
+
+module.exports = HospitalRepository;

src/repository/admin/ProvinceRepository.js

@@ -0,0 +1,50 @@
+const prisma = require('../../prisma/PrismaClient.js');
+
+const ProvinceRepository = {
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return prisma.province.findMany({
+            where,
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                name: true,
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.province.count({ where });
+    },
+
+    findById: async (id) => {
+        return prisma.province.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                name: true,
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    create: async (data) => {
+        return prisma.province.create({ data });
+    },
+
+    update: async (id, data) => {
+        return prisma.province.update({
+            where: { id },
+            data
+        });
+    },
+};
+
+module.exports = ProvinceRepository;

src/repository/admin/SalesRepository.js

@@ -0,0 +1,261 @@
+const axios = require('axios');
+const qs = require('qs');
+const {
+    KEYCLOAK_REALM,
+    KEYCLOAK_ADMIN_URL,
+    CLIENT_ID,
+    CLIENT_SECRET
+} = require('../../../config/keycloak.js');
+const HttpException = require('../../utils/HttpException.js');
+const bcrypt = require('bcrypt');
+const prisma = require('../../prisma/PrismaClient.js');
+
+const getAdminToken = async () => {
+    const tokenParams = qs.stringify({
+        grant_type: 'client_credentials',
+        client_id: CLIENT_ID,
+        client_secret: CLIENT_SECRET
+    });
+
+    const { data } = await axios.post(
+        `${KEYCLOAK_ADMIN_URL}/realms/${KEYCLOAK_REALM}/protocol/openid-connect/token`,
+        tokenParams,
+        {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        }
+    );
+
+    return data.access_token;
+};
+
+const KeycloakRepository = {
+    createUser: async (userData) => {
+        const token = await getAdminToken();
+
+        // Cek apakah username sudah terpakai
+        const { data: usersByUsername } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users?username=${encodeURIComponent(userData.username)}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        if (usersByUsername.length > 0) {
+            throw new HttpException('Username already exists in Keycloak', 409);
+        }
+
+        // Cek apakah email sudah terpakai
+        const { data: usersByEmail } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users?email=${encodeURIComponent(userData.email)}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        if (usersByEmail.length > 0) {
+            throw new HttpException('Email already exists in Keycloak', 409);
+        }
+
+        const response = await axios.post(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users`,
+            {
+                username: userData.username,
+                email: userData.email,
+                firstName: userData.firstname,
+                lastName: userData.lastname,
+                enabled: true,
+                credentials: [{
+                    type: "password",
+                    value: userData.password,
+                    temporary: false
+                }]
+            },
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        return response.headers.location.split('/').pop();
+    },
+
+    assignSalesRole: async (userId) => {
+        const token = await getAdminToken();
+
+        // Get role sales
+        const { data: roles } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/roles`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        const salesRole = roles.find(role => role.name === 'sales');
+        if (!salesRole) throw new HttpException('Sales role not found in Keycloak', 500);
+
+        // Assign role to user
+        await axios.post(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}/role-mappings/realm`,
+            [salesRole],
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    },
+
+    updateUser: async (userId, updatedData) => {
+        const token = await getAdminToken();
+
+        await axios.put(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}`,
+            {
+                firstName: updatedData.firstname,
+                lastName: updatedData.lastname,
+                email: updatedData.email,
+                credentials: updatedData.password ? [{
+                    type: 'password',
+                    value: updatedData.password,
+                    temporary: false
+                }] : undefined
+            },
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    },
+
+    deleteUser: async (userId) => {
+        const token = await getAdminToken();
+
+        await axios.delete(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    }
+};
+
+const UserRepository = {
+    createUser: async (userId, userData) => {
+        const hashedPassword = await bcrypt.hash(userData.password, 10);
+
+        return prisma.user.create({
+            data: {
+                id: userId,
+                username: userData.username,
+                email: userData.email,
+                firstname: userData.firstname,
+                lastname: userData.lastname,
+                password: hashedPassword,
+                role: 'sales'
+            }
+        });
+    },
+
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return prisma.user.findMany({
+            where: {
+                ...where,
+                role: 'sales'
+            },
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                firstname: true,
+                lastname: true,
+                role: true,
+                user_areas: {
+                    select: {
+                        id: true,
+                        province: {
+                            select: {
+                                id: true,
+                                name: true
+                            }
+                        }
+                    }
+                },
+                createdAt: true,
+                updatedAt: true,
+            },
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.user.count({
+            where: {
+                ...where,
+                role: 'admin'
+            },
+        });
+    },
+
+    findById: async (id) => {
+        return prisma.user.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                firstname: true,
+                lastname: true,
+                user_areas: {
+                    select: {
+                        id: true,
+                        province: {
+                            select: {
+                                id: true,
+                                name: true
+                            }
+                        }
+                    }
+                },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    updateUser: async (id, updatedData) => {
+        const updatePayload = {
+            email: updatedData.email,
+            firstname: updatedData.firstname,
+            lastname: updatedData.lastname
+        };
+
+        if (updatedData.password) {
+            updatePayload.password = await bcrypt.hash(updatedData.password, 10);
+        }
+
+        return prisma.user.update({
+            where: { id },
+            data: updatePayload
+        });
+    },
+
+    deleteUser: async (id) => {
+        return prisma.user.update({
+            where: { id },
+            data: {
+                deletedAt: new Date()
+            }
+        });
+    }
+};
+
+const UserAreaRepository = {
+    createMany: async (userId, provinceIds) => {
+        const data = provinceIds.map(provinceId => ({
+            user_id: userId,
+            province_id: provinceId
+        }));
+
+        return prisma.userArea.createMany({
+            data,
+            skipDuplicates: true
+        });
+    },
+
+    deleteByUserId: async (userId) => {
+        return prisma.userArea.deleteMany({
+            where: { user_id: userId }
+        });
+    }
+};
+
+module.exports = { KeycloakRepository, UserRepository, UserAreaRepository };

src/repository/sales/HospitalRepository.js

@@ -0,0 +1,87 @@
+const prisma = require('../../prisma/PrismaClient.js');
+
+const HospitalRepository = {
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return await prisma.hospital.findMany({
+            where,
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                name: true,
+                hospital_code: true,
+                type: true,
+                ownership: true,
+                province: { select: { id: true, name: true } },
+                city: { select: { id: true, name: true } },
+                address: true,
+                simrs_type: true,
+                contact: true,
+                image: true,
+                progress_status: true,
+                note: true,
+                user: { select: { id: true, username: true } },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.hospital.count({ where });
+    },
+
+    create: async (data) => {
+        return prisma.hospital.create({ data });
+    },
+
+    findById: async (id) => {
+        return prisma.hospital.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                name: true,
+                hospital_code: true,
+                type: true,
+                ownership: true,
+                province: { select: { id: true, name: true } },
+                city: { select: { id: true, name: true } },
+                address: true,
+                simrs_type: true,
+                contact: true,
+                image: true,
+                progress_status: true,
+                note: true,
+                user: { select: { id: true, username: true } },
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    update: async (id, data) => {
+        return prisma.hospital.update({
+            where: { id },
+            data: {
+                name: data.name,
+                hospital_code: data.hospital_code,
+                type: data.type,
+                ownership: data.ownership,
+                province: { connect: { id: data.province_id } },
+                city: { connect: { id: data.city_id } },
+                address: data.address,
+                simrs_type: data.simrs_type,
+                contact: data.contact,
+                note: data.note,
+                image: data.image,
+                progress_status: data.progress_status,
+            }
+        });
+    },
+};
+
+module.exports = HospitalRepository;

src/repository/superadmin/AdminRepository.js

@@ -0,0 +1,219 @@
+const axios = require('axios');
+const qs = require('qs');
+const {
+    KEYCLOAK_REALM,
+    KEYCLOAK_ADMIN_URL,
+    CLIENT_ID,
+    CLIENT_SECRET
+} = require('../../../config/keycloak.js');
+const HttpException = require('../../utils/HttpException.js');
+const bcrypt = require('bcrypt');
+const prisma = require('../../prisma/PrismaClient.js');
+
+const getAdminToken = async () => {
+    const tokenParams = qs.stringify({
+        grant_type: 'client_credentials',
+        client_id: CLIENT_ID,
+        client_secret: CLIENT_SECRET
+    });
+
+    const { data } = await axios.post(
+        `${KEYCLOAK_ADMIN_URL}/realms/${KEYCLOAK_REALM}/protocol/openid-connect/token`,
+        tokenParams,
+        {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded'
+            }
+        }
+    );
+
+    return data.access_token;
+};
+
+const KeycloakRepository = {
+    createUser: async (userData) => {
+        const token = await getAdminToken();
+
+        // Cek apakah username sudah terpakai
+        const { data: usersByUsername } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users?username=${encodeURIComponent(userData.username)}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        if (usersByUsername.length > 0) {
+            throw new HttpException('Username already exists in Keycloak', 409);
+        }
+
+        // Cek apakah email sudah terpakai
+        const { data: usersByEmail } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users?email=${encodeURIComponent(userData.email)}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        if (usersByEmail.length > 0) {
+            throw new HttpException('Email already exists in Keycloak', 409);
+        }
+
+        const response = await axios.post(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users`,
+            {
+                username: userData.username,
+                email: userData.email,
+                firstName: userData.firstname,
+                lastName: userData.lastname,
+                enabled: true,
+                credentials: [{
+                    type: "password",
+                    value: userData.password,
+                    temporary: false
+                }]
+            },
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        return response.headers.location.split('/').pop();
+    },
+
+    assignAdminRole: async (userId) => {
+        const token = await getAdminToken();
+
+        // Get role sales
+        const { data: roles } = await axios.get(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/roles`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+
+        const adminRole = roles.find(role => role.name === 'admin');
+        if (!adminRole) throw new HttpException('Admin role not found in Keycloak', 500);
+
+        // Assign role to user
+        await axios.post(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}/role-mappings/realm`,
+            [adminRole],
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    },
+
+    updateUser: async (userId, updatedData) => {
+        const token = await getAdminToken();
+
+        await axios.put(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}`,
+            {
+                firstName: updatedData.firstname,
+                lastName: updatedData.lastname,
+                email: updatedData.email,
+                credentials: updatedData.password ? [{
+                    type: 'password',
+                    value: updatedData.password,
+                    temporary: false
+                }] : undefined
+            },
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    },
+
+    deleteUser: async (userId) => {
+        const token = await getAdminToken();
+
+        await axios.delete(
+            `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users/${userId}`,
+            { headers: { Authorization: `Bearer ${token}` } }
+        );
+    }
+};
+
+const AdminRepository = {
+    createUser: async (userId, userData) => {
+        const hashedPassword = await bcrypt.hash(userData.password, 10);
+
+        return prisma.user.create({
+            data: {
+                id: userId,
+                username: userData.username,
+                email: userData.email,
+                firstname: userData.firstname,
+                lastname: userData.lastname,
+                password: hashedPassword,
+                role: 'admin'
+            }
+        });
+    },
+
+    findAll: async ({ skip, take, where, orderBy }) => {
+        return prisma.user.findMany({
+            where: {
+                ...where,
+                role: 'admin'
+            },
+            skip,
+            take,
+            orderBy,
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                firstname: true,
+                lastname: true,
+                role: true,
+                createdAt: true,
+                updatedAt: true,
+            },
+        });
+    },
+
+    countAll: async (where) => {
+        return prisma.user.count({
+            where: {
+                ...where,
+                role: 'admin'
+            }
+        });
+    },
+
+    findById: async (id) => {
+        return prisma.user.findFirst({
+            where: {
+                id,
+                deletedAt: null
+            },
+            select: {
+                id: true,
+                username: true,
+                email: true,
+                firstname: true,
+                lastname: true,
+                createdAt: true,
+                updatedAt: true,
+            }
+        });
+    },
+
+    updateUser: async (id, updatedData) => {
+        const updatePayload = {
+            email: updatedData.email,
+            firstname: updatedData.firstname,
+            lastname: updatedData.lastname
+        };
+
+        if (updatedData.password) {
+            updatePayload.password = await bcrypt.hash(updatedData.password, 10);
+        }
+
+        return prisma.user.update({
+            where: { id },
+            data: updatePayload
+        });
+    },
+
+    deleteUser: async (id) => {
+        return prisma.user.update({
+            where: { id },
+            data: {
+                deletedAt: new Date()
+            }
+        });
+    }
+};
+
+module.exports = { KeycloakRepository, AdminRepository };

src/routes/admin/CityRoute.js

@@ -0,0 +1,13 @@
+const express = require('express')
+const router = express.Router()
+const cityController = require('../../controllers/admin/CityController.js')
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+
+router.get('/', verifyJWT, checkRole(['admin']), cityController.getAllCity);
+router.post('/', verifyJWT, checkRole(['admin']), cityController.storeCity);
+router.get('/:id', verifyJWT, checkRole(['admin']), cityController.showCity);
+router.patch('/:id', verifyJWT, checkRole(['admin']), cityController.updateCity);
+router.delete('/:id', verifyJWT, checkRole(['admin']), cityController.deleteCity);
+
+module.exports = router;

src/routes/admin/HospitalRoute.js

@@ -0,0 +1,14 @@
+const express = require('express')
+const router = express.Router()
+const hospitalController = require('../../controllers/admin/HospitalController.js')
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+const upload = require('../../middleware/UploadImage.js');
+
+router.get('/', verifyJWT, checkRole(['admin']), hospitalController.getAllHospital);
+router.post('/', verifyJWT, upload.single('image'), checkRole(['admin']), hospitalController.storeHospital);
+router.get('/:id', verifyJWT, checkRole(['admin']), hospitalController.showHospital);
+router.patch('/:id', verifyJWT, upload.single('image'), checkRole(['admin']), hospitalController.updateHospital);
+router.delete('/:id', verifyJWT, checkRole(['admin']), hospitalController.deleteHospital);
+
+module.exports = router;

src/routes/admin/ProvinceRoute.js

@@ -0,0 +1,19 @@
+const express = require('express')
+const router = express.Router()
+const provinceController = require('../../controllers/admin/ProvinceController.js')
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+
+// router.get('/', verifyJWT, checkRole(['admin', 'sales']), provinceController.getAllProvince);
+// router.post('/', verifyJWT, checkRole(['admin']), provinceController.storeProvince);
+// router.get('/:id', verifyJWT, checkRole(['admin']), provinceController.showProvince);
+// router.patch('/:id', verifyJWT, checkRole(['admin']), provinceController.updateProvince);
+// router.delete('/:id', verifyJWT, checkRole(['admin']), provinceController.deleteProvince);
+
+router.get('/', verifyJWT, checkRole(['admin']), provinceController.getAllProvince);
+router.post('/', verifyJWT, checkRole(['admin']), provinceController.storeProvince);
+router.get('/:id', verifyJWT, checkRole(['admin']), provinceController.showProvince);
+router.patch('/:id', verifyJWT, checkRole(['admin']), provinceController.updateProvince);
+router.delete('/:id', verifyJWT, checkRole(['admin']), provinceController.deleteProvince);
+
+module.exports = router;

src/routes/admin/SalesRoute.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const salesControllers = require('../../controllers/admin/SalesController.js');
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+
+const router = express.Router();
+
+router.post('/', verifyJWT, checkRole(['admin']), salesControllers.storeSales);
+router.get('/', verifyJWT, checkRole(['admin']), salesControllers.getAllSales);
+router.get('/:id', verifyJWT, checkRole(['admin']), salesControllers.showSales);
+router.patch('/:id', verifyJWT, checkRole(['admin']), salesControllers.updateSales);
+router.delete('/:id', verifyJWT, checkRole(['admin']), salesControllers.deleteSales);
+
+module.exports = router;

src/routes/auth/AuthRoute.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const authControllers = require('../../controllers/auth/AuthControllers.js');
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+
+const router = express.Router();
+
+router.post('/login', authControllers.login);
+router.get('/me', verifyJWT, authControllers.getUser);
+router.post('/logout', verifyJWT, authControllers.logout);
+
+module.exports = router;

src/routes/sales/HospitalRoute.js

@@ -0,0 +1,13 @@
+const express = require('express')
+const router = express.Router()
+const hospitalController = require('../../controllers/sales/HospitalController.js')
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+const upload = require('../../middleware/UploadImage.js');
+
+router.get('/', verifyJWT, checkRole(['sales']), hospitalController.getAllHospitalByArea);
+router.post('/', verifyJWT, upload.single('image'), checkRole(['sales']), hospitalController.storeHospital);
+router.patch('/:id', verifyJWT, upload.single('image'), checkRole(['sales']), hospitalController.updateHospital);
+router.get('/:id', verifyJWT, checkRole(['sales']), hospitalController.showHospital);
+
+module.exports = router;

src/routes/superadmin/AdminRoute.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const adminControllers = require('../../controllers/superadmin/AdminController.js');
+const verifyJWT = require('../../middleware/VerifyJWT.js');
+const checkRole = require('../../middleware/CheckRole.js');
+
+const router = express.Router();
+
+router.post('/', verifyJWT, checkRole(['superadmin']), adminControllers.storeAdmin);
+router.get('/', verifyJWT, checkRole(['superadmin']), adminControllers.getAllAdmin);
+router.get('/:id', verifyJWT, checkRole(['superadmin']), adminControllers.showAdmin);
+router.patch('/:id', verifyJWT, checkRole(['superadmin']), adminControllers.updateAdmin);
+router.delete('/:id', verifyJWT, checkRole(['superadmin']), adminControllers.deleteAdmin);
+
+module.exports = router;

src/services/admin/CityService.js

@@ -0,0 +1,70 @@
+const CityRepository = require('../../repository/admin/CityRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const prisma = require('../../prisma/PrismaClient.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const timeLocal = require('../../utils/TimeLocal.js');
+const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
+const ProvinceRepository = require('../../repository/admin/ProvinceRepository.js');
+
+exports.getAllCityService = async ({ page, limit, search, sortBy, orderBy }) => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        ...SearchFilter(search, ['name']),
+        deletedAt: null
+    };
+
+    const [cities, total] = await Promise.all([
+        CityRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        CityRepository.countAll(where)
+    ]);
+
+    return { cities, total };
+};
+
+exports.showCityService = async (id) => {
+    const city = await CityRepository.findById(id);
+    if (!city) {
+        throw new HttpException("Data city not found", 404);
+    }
+    return city;
+};
+
+exports.storeCityService = async (validateData, req) => {
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const data = await CityRepository.create(validateData);
+    await createLog(req, data);
+};
+
+exports.updateCityService = async (validateData, id, req) => {
+    const city = await CityRepository.findById(id);
+    if (!city) {
+        throw new HttpException("Data city not found", 404);
+    }
+
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const data = await CityRepository.update(id, validateData);
+    await updateLog(req, data);
+};
+
+exports.deleteCityService = async (id, req) => {
+    const city = await CityRepository.findById(id);
+
+    if (!city) {
+        throw new HttpException('City not found', 404);
+    }
+
+    const data = await CityRepository.update(id, {
+        deletedAt: timeLocal.now().toDate()
+    });
+
+    await deleteLog(req, data);
+};

src/services/admin/HospitalService.js

@@ -0,0 +1,148 @@
+const HospitalRepository = require('../../repository/admin/HospitalRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const timeLocal = require('../../utils/TimeLocal.js');
+const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
+const ProvinceRepository = require('../../repository/admin/ProvinceRepository.js');
+const CityRepository = require('../../repository/admin/CityRepository.js');
+const { BASE_URL } = require('../../../config/config.js');
+
+exports.getAllHospitalService = async ({ page, limit, search, sortBy, orderBy }) => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        ...SearchFilter(search, ['name',]),
+        deletedAt: null
+    };
+
+    const [hospitals, total] = await Promise.all([
+        HospitalRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        HospitalRepository.countAll(where)
+    ]);
+
+    return { hospitals, total };
+};
+
+exports.showHospitalService = async (id) => {
+    const hospital = await HospitalRepository.findById(id);
+    if (!hospital) {
+        throw new HttpException("Data hospital not found", 404);
+    }
+    return hospital;
+};
+
+exports.storeHospitalService = async (validateData, req) => {
+    const creatorId = req.user.id;
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const city = await CityRepository.findById(validateData.city_id);
+    if (!city) {
+        throw new HttpException('City not found', 404);
+    }
+
+    if (!req.file) {
+        throw new HttpException({ image: ['image file is required'] }, 422);
+    }
+
+    const existingHospital = await prisma.hospital.findFirst({
+        where: {
+            name: validateData.name,
+            city_id: validateData.city_id,
+            deletedAt: null
+        }
+    });
+
+    if (existingHospital) {
+        throw new HttpException('Hospital with same name in this city already exists', 400);
+    }
+
+    const imagePath = req.file ? `/storage/img/${req.file.filename}` : null;
+
+    const payload = {
+        ...validateData,
+        image: imagePath,
+        progress_status: "cari_data",
+        created_by: creatorId
+    };
+
+    const data = await HospitalRepository.create(payload);
+    await createLog(req, data);
+};
+
+const validProgressStatuses = ['cari_data', 'dihubungi', 'negosiasi', 'follow_up', 'mou', 'onboarded', 'tidak_berminat'];
+
+exports.updateHospitalService = async (validateData, id, req) => {
+    // const hospital = await HospitalRepository.findById(id);
+    // if (!hospital) {
+    //     throw new HttpException("Data hospital not found", 404);
+    // }
+
+    // const data = await HospitalRepository.update(id, validateData);
+    // await updateLog(req, data);
+
+    const hospital = await HospitalRepository.findById(id);
+    if (!hospital) {
+        throw new HttpException("Hospital data not found", 404);
+    }
+
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const city = await CityRepository.findById(validateData.city_id);
+    if (!city) {
+        throw new HttpException('City not found', 404);
+    }
+
+    if (validateData.progress_status && !validProgressStatuses.includes(validateData.progress_status)) {
+        throw new HttpException(
+            `Invalid progress_status. Allowed values are: ${validProgressStatuses.join(', ')}`,
+            422
+        );
+    }
+
+    const existingHospital = await prisma.hospital.findFirst({
+        where: {
+            name: validateData.name,
+            city_id: validateData.city_id,
+            deletedAt: null
+        }
+    });
+
+    if (existingHospital) {
+        throw new HttpException('Hospital with same name in this city already exists', 400);
+    }
+
+    // Jika ada file baru, replace image
+    let imagePath = hospital.image; // pakai yang lama
+    if (req.file) {
+        imagePath = `/storage/img/${req.file.filename}`; // path relatif
+    }
+
+    const payload = {
+        ...validateData,
+        image: imagePath,
+        updated_by: req.user.id,
+    };
+
+    const data = await HospitalRepository.update(id, payload);
+    await updateLog(req, data);
+};
+
+exports.deleteHospitalService = async (id, req) => {
+    const hospital = await HospitalRepository.findById(id);
+
+    if (!hospital) {
+        throw new HttpException('Hospital not found', 404);
+    }
+
+    const data = await HospitalRepository.update(id, {
+        deletedAt: timeLocal.now().toDate()
+    });
+
+    await deleteLog(req, data);
+};

src/services/admin/ProvinceService.js

@@ -0,0 +1,56 @@
+const ProvinceRepository = require('../../repository/admin/ProvinceRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const timeLocal = require('../../utils/TimeLocal.js')
+
+exports.getAllProvinceService = async ({ page, limit, search, sortBy, orderBy }) => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        ...SearchFilter(search, ['name']),
+        deletedAt: null
+    };
+
+    const [provinces, total] = await Promise.all([
+        ProvinceRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        ProvinceRepository.countAll(where)
+    ]);
+
+    return { provinces, total };
+};
+
+exports.showProvinceService = async (id) => {
+    const province = await ProvinceRepository.findById(id);
+    if (!province) {
+        throw new HttpException("Data province not found", 404);
+    }
+    return province;
+};
+
+exports.storeProvinceService = async (validateData, req) => {
+    const province = await ProvinceRepository.create(validateData);
+    await createLog(req, province);
+};
+
+exports.updateProvinceService = async (validateData, id, req) => {
+    const province = await ProvinceRepository.findById(id);
+    if (!province) {
+        throw new HttpException("Data province not found", 404);
+    }
+
+    const data = await ProvinceRepository.update(id, validateData);
+    await updateLog(req, data);
+};
+
+exports.deleteProvinceService = async (id, req) => {
+    const province = await ProvinceRepository.findById(id);
+    if (!province) {
+        throw new HttpException("Data province not found", 404);
+    }
+
+    const data = await ProvinceRepository.update(id, {
+        deletedAt: timeLocal.now().toDate()
+    });
+    await deleteLog(req, data);
+};

src/services/admin/SalesService.js

@@ -0,0 +1,68 @@
+const SalesRepository = require('../../repository/admin/SalesRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const timeLocal = require('../../utils/TimeLocal.js');
+const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
+
+exports.getAllSalesService = async ({ page, limit, search, sortBy, orderBy }) => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        ...SearchFilter(search, ['username', 'email', 'firstname', 'lastname']),
+        deletedAt: null
+    };
+
+    const [sales, total] = await Promise.all([
+        SalesRepository.UserRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        SalesRepository.UserRepository.countAll(where)
+    ]);
+
+    return { sales, total };
+};
+
+exports.showSalesService = async (id) => {
+    const sales = await SalesRepository.UserRepository.findById(id);
+    if (!sales) {
+        throw new HttpException("Data sales not found", 404);
+    }
+    return sales;
+};
+
+exports.storeSalesService = async (userData, req) => {
+    const userId = await SalesRepository.KeycloakRepository.createUser(userData);
+    await SalesRepository.KeycloakRepository.assignSalesRole(userId);
+    const data = await SalesRepository.UserRepository.createUser(userId, userData);
+
+    if (userData.province_ids && userData.province_ids.length > 0) {
+        await SalesRepository.UserAreaRepository.createMany(userId, userData.province_ids);
+    }
+
+    await createLog(req, data);
+};
+
+exports.updateSalesService = async (userData, id, req) => {
+    const sales = await SalesRepository.UserRepository.findById(id);
+    if (!sales) throw new HttpException('Sales not found', 404);
+
+    await SalesRepository.KeycloakRepository.updateUser(id, userData);
+    const data = await SalesRepository.UserRepository.updateUser(id, userData);
+
+    if (userData.province_ids && userData.province_ids.length > 0) {
+        await SalesRepository.UserAreaRepository.deleteByUserId(id);
+        await SalesRepository.UserAreaRepository.createMany(id, userData.province_ids);
+    }
+
+    await updateLog(req, data);
+};
+
+exports.deleteSalesService = async (id, req) => {
+    const sales = await SalesRepository.UserRepository.findById(id);
+    if (!sales) {
+        throw new HttpException('Sales not found', 404);
+    }
+
+    await SalesRepository.KeycloakRepository.deleteUser(id);
+    const data = await SalesRepository.UserRepository.deleteUser(id, { deletedAt: timeLocal.now().toDate() });
+
+    await deleteLog(req, data);
+};

src/services/auth/AuthService.js

@@ -0,0 +1,152 @@
+const axios = require('axios');
+const jwt = require('jsonwebtoken');
+const {
+    KEYCLOAK_TOKEN_URL,
+    CLIENT_ID,
+    CLIENT_SECRET,
+    JWT_SECRET,
+} = require('../../../config/keycloak.js');
+const HttpException = require('../../utils/HttpException.js');
+const prisma = require('../../prisma/PrismaClient.js');
+const { loginLog, logoutLog } = require('../../utils/LogActivity.js');
+
+exports.loginService = async ({ username, password }, req) => {
+    const params = new URLSearchParams();
+    params.append('grant_type', 'password');
+    params.append('client_id', CLIENT_ID);
+    params.append('client_secret', CLIENT_SECRET);
+    params.append('username', username);
+    params.append('password', password);
+
+    try {
+        const { data } = await axios.post(KEYCLOAK_TOKEN_URL, params, {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+        });
+
+        const decoded = jwt.decode(data.access_token);
+
+        const user = {
+            id: decoded.sub,
+            username: decoded.preferred_username,
+            email: decoded.email,
+            firstname: decoded.given_name,
+            lastname: decoded.family_name,
+            roles: decoded.realm_access?.roles || []
+        };
+
+        await loginLog(req, user);
+
+        const token = jwt.sign(user, JWT_SECRET, { expiresIn: '1d' });
+
+        return { user, token };
+    } catch (error) {
+        throw new HttpException('Invalid username or password', 401);
+    }
+};
+
+exports.getUserService = async (req) => {
+    const user = req.user;
+
+    if (!user) {
+        throw new HttpException('Invalid or missing token', 401);
+    }
+
+    const { id, username, email, firstname, lastname, roles } = user;
+
+    return { id, username, email, firstname, lastname, roles };
+};
+
+// exports.registerService = async (req) => {
+//     const { username, email, firstname, lastname, password, phonenumber, alamathehe } = validateRegisterRequest(req.body);
+
+//     // Ambil admin token via client_credentials
+//     const tokenParams = qs.stringify({
+//         grant_type: 'client_credentials',
+//         client_id: CLIENT_ID,
+//         client_secret: CLIENT_SECRET
+//     });
+
+//     let adminToken;
+//     try {
+//         const tokenResponse = await axios.post(
+//             KEYCLOAK_TOKEN_URL,
+//             tokenParams,
+//             { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }
+//         );
+
+//         adminToken = tokenResponse.data.access_token;
+//     } catch (err) {
+//         console.error('Token Error:', err.response?.data || err.message);
+//         throw new HttpException('Failed to get admin token', 400);
+//     }
+
+//     // Panggil endpoint pendaftaran user
+//     try {
+//         const response = await axios.post(
+//             `${KEYCLOAK_ADMIN_URL}/admin/realms/${KEYCLOAK_REALM}/users`,
+//             {
+//                 username,
+//                 email,
+//                 enabled: true,
+//                 firstName: firstname,
+//                 lastName: lastname,
+//                 credentials: [
+//                     {
+//                         type: 'password',
+//                         value: password,
+//                         temporary: false
+//                     }
+//                 ],
+//                 attributes: [
+//                     {
+//                         phoneNumber: phonenumber,
+//                     },
+//                     {
+//                         alamatHehe: alamathehe
+//                     }
+//                 ]
+//             },
+//             {
+//                 headers: {
+//                     Authorization: `Bearer ${adminToken}`,
+//                     'Content-Type': 'application/json'
+//                 }
+//             }
+//         );
+
+//         if (response.status !== 201) {
+//             throw new HttpException('Failed to register user in Keycloak', 400);
+//         }
+
+//     } catch (err) {
+//         // console.error('Register Error:', err.response?.data || err.message);
+//         // throw new HttpException('Keycloak registration error: ' + (err.response?.data?.errorMessage || err.message), 400);
+//         throw new HttpException((err.response?.data?.errorMessage || err.message), 400);
+//     }
+// };
+
+exports.logoutService = async (req) => {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        throw new HttpException('No JWT token provided', 401);
+    }
+
+    const token = authHeader.split(' ')[1];
+
+    let decoded;
+    try {
+        decoded = jwt.verify(token, JWT_SECRET);
+    } catch (error) {
+        throw new HttpException('Invalid JWT token', 400);
+    }
+
+    // Simpan ke tabel revoked_tokens
+    await prisma.revokedToken.create({
+        data: {
+            token,
+        },
+    });
+
+    await logoutLog(req, decoded)
+};

src/services/sales/HospitalService.js

@@ -0,0 +1,173 @@
+const salesHospitalRepository = require('../../repository/sales/HospitalRepository.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const prisma = require('../../prisma/PrismaClient.js');
+const { createLog, updateLog } = require('../../utils/LogActivity.js');
+const ProvinceRepository = require('../../repository/admin/ProvinceRepository.js');
+const CityRepository = require('../../repository/admin/CityRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const HospitalRepository = require('../../repository/admin/HospitalRepository.js');
+
+exports.getAllHospitalByAreaService = async ({ page, limit, search, sortBy, orderBy }, req) => {
+    const skip = (page - 1) * limit;
+
+    const userAreas = await prisma.userArea.findMany({
+        where: { user_id: req.user.id },
+        select: { province_id: true },
+    });
+
+    const provinceIds = userAreas.map(ua => ua.province_id);
+
+    // const where = {
+    //     ...SearchFilter(search, ['username', 'email', 'firstname', 'lastname']),
+    //     deletedAt: null
+    // };
+
+    const where = {
+        ...SearchFilter(search, [
+            'name',
+            'hospital_code',
+            'type',
+            'ownership',
+            'address',
+            'simrs_type',
+            'contact',
+            'image',
+            'progress_status',
+            'note',
+            'province.name',
+            'city.name',
+            'user.username'
+        ]),
+        province_id: { in: provinceIds },
+        deletedAt: null
+    };
+
+    const [hospitals, total] = await Promise.all([
+        salesHospitalRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        salesHospitalRepository.countAll(where)
+    ]);
+
+    return { hospitals, total };
+};
+
+exports.storeHospitalService = async (validateData, req) => {
+    const creatorId = req.user.id;
+
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const userArea = await prisma.userArea.findFirst({
+        where: {
+            user_id: req.user.id,
+            province_id: validateData.province_id
+        }
+    });
+
+    if (!userArea) {
+        throw new HttpException('You are not allowed to add hospital to this province', 403);
+    }
+
+    const city = await CityRepository.findById(validateData.city_id);
+    if (!city) {
+        throw new HttpException('City not found', 404);
+    }
+
+    const existingHospital = await prisma.hospital.findFirst({
+        where: {
+            name: validateData.name,
+            city_id: validateData.city_id,
+            deletedAt: null
+        }
+    });
+
+    if (existingHospital) {
+        throw new HttpException('Hospital with same name in this city already exists', 400);
+    }
+
+    if (!req.file) {
+        throw new HttpException({ image: ['image file is required'] }, 422);
+    }
+
+    const imagePath = req.file ? `/storage/img/${req.file.filename}` : null;
+
+    const payload = {
+        ...validateData,
+        image: imagePath,
+        progress_status: "cari_data",
+        created_by: creatorId
+    };
+
+    const data = await salesHospitalRepository.create(payload);
+    await createLog(req, data);
+};
+
+const validProgressStatuses = ['cari_data', 'dihubungi', 'negosiasi', 'follow_up', 'mou', 'onboarded', 'tidak_berminat'];
+
+exports.updateHospitalService = async (validateData, id, req) => {
+    // const hospital = await HospitalRepository.findById(id);
+    // if (!hospital) {
+    //     throw new HttpException("Data hospital not found", 404);
+    // }
+
+    // const data = await HospitalRepository.update(id, validateData);
+    // await updateLog(req, data);
+
+    const hospital = await HospitalRepository.findById(id);
+    if (!hospital) {
+        throw new HttpException("Hospital data not found", 404);
+    }
+
+    const province = await ProvinceRepository.findById(validateData.province_id);
+    if (!province) {
+        throw new HttpException('Province not found', 404);
+    }
+
+    const city = await CityRepository.findById(validateData.city_id);
+    if (!city) {
+        throw new HttpException('City not found', 404);
+    }
+
+    if (validateData.progress_status && !validProgressStatuses.includes(validateData.progress_status)) {
+        throw new HttpException(
+            `Invalid progress_status. Allowed values are: ${validProgressStatuses.join(', ')}`,
+            422
+        );
+    }
+
+    const existingHospital = await prisma.hospital.findFirst({
+        where: {
+            name: validateData.name,
+            city_id: validateData.city_id,
+            deletedAt: null
+        }
+    });
+
+    if (existingHospital) {
+        throw new HttpException('Hospital with same name in this city already exists', 400);
+    }
+
+    // Jika ada file baru, replace image
+    let imagePath = hospital.image; // pakai yang lama
+    if (req.file) {
+        imagePath = `/storage/img/${req.file.filename}`; // path relatif
+    }
+
+    const payload = {
+        ...validateData,
+        image: imagePath,
+        updated_by: req.user.id,
+    };
+
+    const data = await salesHospitalRepository.update(id, payload);
+    await updateLog(req, data);
+};
+
+exports.showHospitalService = async (id) => {
+    const hospital = await salesHospitalRepository.findById(id);
+    if (!hospital) {
+        throw new HttpException("Data hospital not found", 404);
+    }
+    return hospital;
+};

src/services/superadmin/AdminService.js

@@ -0,0 +1,59 @@
+const AdminRepository = require('../../repository/superadmin/AdminRepository.js');
+const HttpException = require('../../utils/HttpException.js');
+const { SearchFilter } = require('../../utils/SearchFilter.js');
+const timeLocal = require('../../utils/TimeLocal.js');
+const { createLog, updateLog, deleteLog } = require('../../utils/LogActivity.js');
+
+exports.getAllAdminService = async ({ page, limit, search, sortBy, orderBy }) => {
+    const skip = (page - 1) * limit;
+
+    const where = {
+        ...SearchFilter(search, ['username', 'email', 'firstname', 'lastname']),
+        deletedAt: null
+    };
+
+    const [admin, total] = await Promise.all([
+        AdminRepository.AdminRepository.findAll({ skip, take: limit, where, orderBy: { [sortBy]: orderBy } }),
+        AdminRepository.AdminRepository.countAll(where)
+    ]);
+
+    return { admin, total };
+};
+
+exports.showAdminService = async (id) => {
+    const admin = await AdminRepository.AdminRepository.findById(id);
+    if (!admin) {
+        throw new HttpException("Data Admin not found", 404);
+    }
+    return admin;
+};
+
+exports.storeAdminService = async (userData, req) => {
+    const userId = await AdminRepository.KeycloakRepository.createUser(userData);
+    await AdminRepository.KeycloakRepository.assignAdminRole(userId);
+    const data = await AdminRepository.AdminRepository.createUser(userId, userData);
+
+    await createLog(req, data);
+};
+
+exports.updateAdminService = async (userData, id, req) => {
+    const admin = await AdminRepository.AdminRepository.findById(id);
+    if (!admin) throw new HttpException('Admin not found', 404);
+
+    await AdminRepository.KeycloakRepository.updateUser(id, userData);
+    const data = await AdminRepository.AdminRepository.updateUser(id, userData);
+
+    await updateLog(req, data);
+};
+
+exports.deleteAdminService = async (id, req) => {
+    const admin = await AdminRepository.AdminRepository.findById(id);
+    if (!admin) {
+        throw new HttpException('Admin not found', 404);
+    }
+
+    await AdminRepository.KeycloakRepository.deleteUser(id);
+    const data = await AdminRepository.AdminRepository.deleteUser(id, { deletedAt: timeLocal.now().toDate() });
+
+    await deleteLog(req, data);
+};

src/utils/HttpException.js

@@ -0,0 +1,18 @@
+// class HttpException extends Error {
+//     constructor(message, statusCode = 500) {
+//         super(message);
+//         this.statusCode = statusCode;
+//     }
+// }
+
+// module.exports = HttpException;
+
+class HttpException extends Error {
+    constructor(message = 'Internal Server Error', statusCode = 500) {
+        super(typeof message === 'string' ? message : 'Validation failed');
+        this.statusCode = statusCode;
+        this.message = message; // bisa object atau string
+    }
+}
+
+module.exports = HttpException;