Bagian 3: Database dan Security

/**
 * Exception unchecked pembawa status HTTP. Ditangkap di satu titik pada batas
 * router, lalu diterjemahkan menjadi respons JSON berstatus sesuai. Peran ini
 * dipegang @ExceptionHandler pada aplikasi Spring Boot sungguhan.
 */
public class ApiException extends RuntimeException {

    private final int status;

    public ApiException(int status, String pesan) {
        super(pesan);
        this.status = status;
    }

    public int status() {
        return status;
    }
}

import com.sun.net.httpserver.HttpServer;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.time.LocalDate;
import java.util.Base64;
import java.util.Locale;

/**
 * Titik masuk inti telanjang Bagian 3: repository berkas + gerbang keamanan.
 * Dua sesi server menunjukkan persistensi lintas restart: sesi pertama
 * membuat data pada berkas tugas-web.txt, sesi kedua memuatnya kembali.
 * Berkas dihapus lebih dulu bila ada agar demo selalu mulai bersih dan
 * keluaran identik di setiap eksekusi.
 */
public class AplikasiWeb {

    private static final Path BERKAS = Path.of("tugas-web.txt");

    public static void main(String[] args) throws Exception {
        Files.deleteIfExists(BERKAS);
        System.out.println("=== AplikasiWeb Bagian 3: persistensi + keamanan ===");
        System.out.println("[Bootstrap] tugas-web.txt disiapkan bersih");

        PenggunaWeb budi = new PenggunaWeb("budi", "sandi-budi", PenggunaWeb.Peran.ANGGOTA);
        PenggunaWeb siti = new PenggunaWeb("siti", "sandi-siti", PenggunaWeb.Peran.ADMIN);
        System.out.println("[Bootstrap] pengguna terdaftar: budi (ANGGOTA), siti (ADMIN)");

        HttpClient klien = HttpClient.newHttpClient();

        System.out.println();
        System.out.println("== Sesi 1: server pertama ==");
        HttpServer server = mulai();
        try {
            String dasar = dasar(server);
            kirim(klien, dasar, null, "GET", "/api/tugas", null);
            kirim(klien, dasar, "Bearer bukan-basic", "GET", "/api/tugas", null);
            kirim(klien, dasar, otorisasi("budi", "salah-total"), "GET", "/api/tugas", null);
            kirim(klien, dasar, otorisasi(budi), "POST", "/api/tugas",
                    "{\"judul\":\"Belajar arsitektur berlapis\",\"pemilik\":\"Budi\","
                            + "\"tenggat\":\"2026-02-01\"}");
            kirim(klien, dasar, otorisasi(budi), "POST", "/api/tugas",
                    "{\"judul\":\"Riset keamanan aplikasi web\",\"pemilik\":\"Dewi\","
                            + "\"tenggat\":\"2026-01-25\"}");
            kirim(klien, dasar, otorisasi(budi), "DELETE", "/api/tugas/1", null);
            kirim(klien, dasar, otorisasi(siti), "DELETE", "/api/tugas/1", null);
            kirim(klien, dasar, otorisasi(budi), "GET", "/api/tugas", null);
        } finally {
            server.stop(0);
        }

        System.out.println();
        System.out.println("== Sesi 2: server baru memuat berkas yang sama ==");
        HttpServer serverBaru = mulai();
        try {
            String dasar = dasar(serverBaru);
            kirim(klien, dasar, otorisasi(siti), "GET", "/api/tugas", null);
            kirim(klien, dasar, otorisasi(budi), "POST", "/api/tugas",
                    "{\"judul\":\"Menulis dokumentasi API\",\"pemilik\":\"Siti\","
                            + "\"tenggat\":\"2026-01-20\"}");
        } finally {
            serverBaru.stop(0);
        }

        System.out.println();
        System.out.println("[Bootstrap] kedua server berhenti; data bertahan di tugas-web.txt");
    }

    /** Server uji: filter keamanan membungkus router di atas repository berkas. */
    private static HttpServer mulai() throws IOException {
        RepositoryTugasWebBerkas repository = new RepositoryTugasWebBerkas(BERKAS);
        System.out.println("[Bootstrap] repository berkas siap: "
                + repository.jumlahTermuat() + " tugas termuat");
        LayananTugasWeb layanan = new LayananTugasWeb(repository, LocalDate.of(2026, 1, 15));
        HttpServer server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server.createContext("/", new FilterTokenWeb(new RouterWeb(layanan),
                new PenggunaWeb("budi", "sandi-budi", PenggunaWeb.Peran.ANGGOTA),
                new PenggunaWeb("siti", "sandi-siti", PenggunaWeb.Peran.ADMIN)));
        server.start();
        return server;
    }

    /** Alamat dasar server; nomor port tidak dicetak agar keluaran deterministik. */
    private static String dasar(HttpServer server) {
        return "http://127.0.0.1:" + server.getAddress().getPort();
    }

    /** Header Authorization Basic dari pasangan nama dan sandi. */
    private static String otorisasi(String nama, String sandi) {
        byte[] oktet = (nama + ":" + sandi).getBytes(StandardCharsets.UTF_8);
        return "Basic " + Base64.getEncoder().encodeToString(oktet);
    }

    private static String otorisasi(PenggunaWeb pengguna) {
        return otorisasi(pengguna.nama(), pengguna.sandi());
    }

    /** Mengirim satu permintaan lalu mencetak status dan body respons. */
    private static void kirim(HttpClient klien, String dasar, String otorisasi,
            String metode, String path, String body)
            throws IOException, InterruptedException {

        HttpRequest.Builder b = HttpRequest.newBuilder()
                .uri(URI.create(dasar + path))
                .timeout(Duration.ofSeconds(5));
        if (otorisasi != null) {
            b.header("Authorization", otorisasi);
        }
        if (body == null) {
            b.method(metode, HttpRequest.BodyPublishers.noBody());
        } else {
            b.header("Content-Type", "application/json")
                    .method(metode, HttpRequest.BodyPublishers.ofString(
                            body, StandardCharsets.UTF_8));
        }
        HttpResponse<String> r = klien.send(b.build(),
                HttpResponse.BodyHandlers.ofString());
        String www = r.headers().firstValue("WWW-Authenticate")
                .map(w -> " WWW-Authenticate=" + w).orElse("");
        String isi = r.body().isEmpty() ? "(tanpa body)" : r.body();
        System.out.printf(Locale.US, "%-7s %-15s -> %d%s %s%n",
                metode, path, r.statusCode(), www, isi);
    }
}

/**
 * Operasi menabrak aturan bisnis yang bergantung pada kondisi terkini:
 * transisi status yang sudah lampau atau batas tugas aktif per pemilik.
 * Diterjemahkan router menjadi respons 409 Conflict.
 */
public class AturanBisnisException extends ApiException {

    public AturanBisnisException(String pesan) {
        super(409, pesan);
    }
}

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Gerbang keamanan di depan router: dekorator HttpHandler yang memeriksa
 * header Authorization skema Basic sebelum permintaan diteruskan. Struktur
 * ini adalah miniatur filter chain Spring Security: satu pembungkus di luar
 * seluruh aplikasi, kode aplikasi tidak menyentuh satu baris pun.
 *
 * Autentikasi: kredensial "nama:sandi" dienkode base64 pada header; nama
 * dicari di daftar pengguna terdaftar dan sandi dibandingkan konstan-waktu.
 * Otorisasi: DELETE hanya untuk peran ADMIN, ditolak 403 bila peran kurang.
 * Seluruh penolakan autentikasi dijawab 401 plus header WWW-Authenticate
 * yang diwajibkan RFC 7235 (dan RFC 7617 untuk parameter charset).
 */
public class FilterTokenWeb implements HttpHandler {

    private final HttpHandler target;
    private final Map<String, PenggunaWeb> pengguna = new LinkedHashMap<>();

    public FilterTokenWeb(HttpHandler target, PenggunaWeb... penggunaTerdaftar) {
        this.target = target;
        for (PenggunaWeb p : penggunaTerdaftar) {
            pengguna.put(p.nama(), p);
        }
    }

    @Override
    public void handle(HttpExchange exchange) throws IOException {
        try {
            PenggunaWeb terverifikasi = autentikasi(exchange);
            otorisasi(exchange, terverifikasi);
        } catch (ApiException e) {
            tolak(exchange, e.status(), e.getMessage());
            return;   // permintaan ditolak: router tidak pernah dipanggil
        }
        target.handle(exchange);   // router punya penanganan galat dan penutupan exchange sendiri
    }

    /**
     * Memeriksa kredensial Basic pada header Authorization.
     * Melempar ApiException 401 bila kredensial tidak sah.
     */
    private PenggunaWeb autentikasi(HttpExchange ex) {
        String header = ex.getRequestHeaders().getFirst("Authorization");
        if (header == null || !header.startsWith("Basic ")) {
            throw new ApiException(401,
                    "header Authorization wajib berformat 'Basic <kredensial>'");
        }
        byte[] oktet;
        try {
            oktet = Base64.getDecoder().decode(header.substring("Basic ".length()).strip());
        } catch (IllegalArgumentException e) {
            throw new ApiException(401, "kredensial Basic bukan base64 yang sah");
        }
        String teks = new String(oktet, StandardCharsets.UTF_8);
        // Pemisah pertama: sandi boleh memuat karakter ':' sedangkan nama tidak.
        int posisi = teks.indexOf(':');
        if (posisi < 1) {
            throw new ApiException(401, "kredensial harus berformat 'nama:sandi'");
        }
        String nama = teks.substring(0, posisi);
        String sandi = teks.substring(posisi + 1);

        PenggunaWeb terdaftar = pengguna.get(nama);
        if (terdaftar == null || !terdaftar.cocokSandi(sandi)) {
            // Pesan seragam untuk nama tak dikenal dan sandi salah,
            // supaya tidak membocorkan nama mana yang terdaftar.
            throw new ApiException(401, "nama atau sandi salah");
        }
        return terdaftar;
    }

    /**
     * Memeriksa izin per permintaan: menghapus tugas hanya untuk ADMIN.
     * Melempar ApiException 403 bila peran tidak mencukupi.
     */
    private void otorisasi(HttpExchange ex, PenggunaWeb terverifikasi) {
        if ("DELETE".equals(ex.getRequestMethod())
                && terverifikasi.peran() != PenggunaWeb.Peran.ADMIN) {
            throw new ApiException(403, "menghapus tugas memerlukan peran ADMIN"
                    + " (terautentikasi sebagai " + terverifikasi.nama() + ")");
        }
    }

    /** Menulis respons penolakan: body JSON, header WWW-Authenticate untuk 401. */
    private static void tolak(HttpExchange ex, int status, String pesan) throws IOException {
        ex.getRequestBody().readAllBytes();   // buang body belum terbaca agar koneksi sehat
        byte[] isi = JsonWeb.galat(status, pesan).getBytes(StandardCharsets.UTF_8);
        ex.getResponseHeaders().set("Content-Type", "application/json; charset=utf-8");
        if (status == 401) {
            ex.getResponseHeaders().set("WWW-Authenticate",
                    "Basic realm=\"tugas-web\", charset=\"UTF-8\"");
        }
        ex.sendResponseHeaders(status, isi.length);
        try (OutputStream os = ex.getResponseBody()) {
            os.write(isi);
        } finally {
            ex.close();
        }
    }
}

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * Serializer dan parser JSON mini untuk inti telanjang aplikasi web:
 * objek datar dengan nilai teks, angka, boolean, atau null. Objek dan array
 * bersarang sengaja tidak didukung agar kelas ini tetap ringkas; pustaka
 * seperti Jackson menangani seluruh kasus pada aplikasi Spring Boot asli.
 */
public final class JsonWeb {

    private JsonWeb() {
        // Kelas utilitas: seluruh anggota static.
    }

    /** Meloloskan karakter yang wajib di-escape di dalam string JSON. */
    public static String escape(String teks) {
        StringBuilder hasil = new StringBuilder();
        for (int i = 0; i < teks.length(); i++) {
            char c = teks.charAt(i);
            switch (c) {
                case '"' -> hasil.append("\\\"");
                case '\\' -> hasil.append("\\\\");
                case '\n' -> hasil.append("\\n");
                case '\t' -> hasil.append("\\t");
                case '\r' -> hasil.append("\\r");
                default -> {
                    if (c < 0x20) {
                        hasil.append(String.format("\\u%04x", (int) c));
                    } else {
                        hasil.append(c);
                    }
                }
            }
        }
        return hasil.toString();
    }

    /** Membungkus teks menjadi string JSON sah (kutip plus escape). */
    public static String teks(String nilai) {
        return "\"" + escape(nilai) + "\"";
    }

    /** Satu tugas menjadi objek JSON dengan urutan field tetap. */
    public static String tugas(TugasWeb t) {
        return "{\"id\":" + t.id()
                + ",\"judul\":" + teks(t.judul())
                + ",\"pemilik\":" + teks(t.pemilik())
                + ",\"status\":\"" + t.status() + "\""
                + ",\"tenggat\":\"" + t.tenggat() + "\"}";
    }

    /** Daftar tugas menjadi array JSON. */
    public static String daftar(List<TugasWeb> semua) {
        StringBuilder hasil = new StringBuilder("[");
        for (TugasWeb t : semua) {
            if (hasil.length() > 1) {
                hasil.append(",");
            }
            hasil.append(tugas(t));
        }
        return hasil.append("]").toString();
    }

    /** Amplop galat tunggal. */
    public static String galat(int status, String pesan) {
        return "{\"status\":" + status + ",\"pesan\":" + teks(pesan) + "}";
    }

    /** Amplop galat validasi dengan rincian per field. */
    public static String galat(int status, String pesan, List<String> rincian) {
        if (rincian == null || rincian.isEmpty()) {
            return galat(status, pesan);
        }
        StringBuilder hasil = new StringBuilder("{\"status\":").append(status)
                .append(",\"pesan\":").append(teks(pesan)).append(",\"galat\":[");
        boolean pertama = true;
        for (String g : rincian) {
            if (!pertama) {
                hasil.append(",");
            }
            pertama = false;
            hasil.append(teks(g));
        }
        return hasil.append("]}").toString();
    }

    /**
     * Mem-parsing objek JSON datar menjadi Map dengan urutan field terjaga.
     * Nilai berupa String, Long, Double, Boolean, atau null; nilai bersarang
     * ditolak. Melempar IllegalArgumentException bila teks tidak sah.
     */
    public static Map<String, Object> parseObjek(String json) {
        Pembaca baca = new Pembaca(json);
        Map<String, Object> hasil = baca.objek();
        baca.spasi();
        if (!baca.habis()) {
            throw baca.galat("konten tambahan setelah objek");
        }
        return hasil;
    }

    /** Pembaca JSON karakter demi karakter dengan posisi terlacak. */
    private static final class Pembaca {

        private final String teks;
        private int pos = 0;

        Pembaca(String teks) {
            this.teks = teks;
        }

        /** Membaca '{' sampai '}' menjadi LinkedHashMap. */
        Map<String, Object> objek() {
            spasi();
            harap('{');
            Map<String, Object> hasil = new LinkedHashMap<>();
            spasi();
            if (lihat() == '}') {
                pos++;
                return hasil;
            }
            while (true) {
                spasi();
                String kunci = string();
                spasi();
                harap(':');
                spasi();
                hasil.put(kunci, nilai());
                spasi();
                if (lihat() == ',') {
                    pos++;
                    continue;
                }
                harap('}');
                return hasil;
            }
        }

        /** Satu nilai: string, true, false, null, atau angka datar. */
        Object nilai() {
            char c = lihat();
            if (c == '"') {
                return string();
            }
            if (c == '{' || c == '[') {
                throw galat("objek/array bersarang tidak didukung parser mini");
            }
            if (c == 't') {
                harapKata("true");
                return Boolean.TRUE;
            }
            if (c == 'f') {
                harapKata("false");
                return Boolean.FALSE;
            }
            if (c == 'n') {
                harapKata("null");
                return null;
            }
            return angka();
        }

        /** Membaca string berikut kutip pembuka dan penutupnya. */
        String string() {
            harap('"');
            StringBuilder hasil = new StringBuilder();
            while (pos < teks.length()) {
                char c = teks.charAt(pos++);
                if (c == '"') {
                    return hasil.toString();
                }
                if (c == '\\') {
                    hasil.append(escapeBerikutnya());
                } else {
                    hasil.append(c);
                }
            }
            throw galat("string tidak ditutup kutip");
        }

        /** Membaca satu karakter hasil escape, misalnya \n atau \". */
        char escapeBerikutnya() {
            if (pos >= teks.length()) {
                throw galat("escape berada di ujung string");
            }
            char c = teks.charAt(pos++);
            return switch (c) {
                case '"' -> '"';
                case '\\' -> '\\';
                case '/' -> '/';
                case 'n' -> '\n';
                case 't' -> '\t';
                case 'r' -> '\r';
                case 'b' -> '\b';
                case 'f' -> '\f';
                default -> throw galat("escape tidak dikenal: \\" + c);
            };
        }

        /** Membaca angka bulat atau pecahan tanpa notasi ilmiah. */
        Object angka() {
            int awal = pos;
            if (lihat() == '-') {
                pos++;
            }
            while (pos < teks.length() && "0123456789.".indexOf(teks.charAt(pos)) >= 0) {
                pos++;
            }
            String teksAngka = teks.substring(awal, pos);
            if (teksAngka.isEmpty() || teksAngka.equals("-")) {
                throw galat("nilai tidak dikenal mulai di posisi " + awal);
            }
            try {
                if (teksAngka.indexOf('.') >= 0) {
                    return Double.valueOf(teksAngka);
                }
                return Long.valueOf(teksAngka);
            } catch (NumberFormatException e) {
                throw galat("angka tidak sah: " + teksAngka);
            }
        }

        /** Memastikan kata kunci (true/false/null) ada di posisi sekarang. */
        void harapKata(String kata) {
            if (!teks.startsWith(kata, pos)) {
                throw galat("kata kunci '" + kata + "' tidak ditemukan");
            }
            pos += kata.length();
        }

        /** Melewati spasi dan whitespace lain. */
        void spasi() {
            while (pos < teks.length() && Character.isWhitespace(teks.charAt(pos))) {
                pos++;
            }
        }

        /** Melihat karakter pada posisi sekarang tanpa memajukannya. */
        char lihat() {
            if (pos >= teks.length()) {
                throw galat("teks berakhir sebelum waktunya");
            }
            return teks.charAt(pos);
        }

        /** Memastikan karakter yang diharapkan ada, lalu memajukan posisi. */
        void harap(char diharapkan) {
            char c = lihat();
            if (c != diharapkan) {
                throw galat("diharapkan '" + diharapkan + "', ditemukan '" + c + "'");
            }
            pos++;
        }

        boolean habis() {
            return pos >= teks.length();
        }

        IllegalArgumentException galat(String pesan) {
            return new IllegalArgumentException(pesan + " (posisi " + pos + ")");
        }
    }
}