Bagian 3: Database dan Validasi

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * Penyimpanan berkas berbasis baris: satu tugas satu baris dengan format
 * T;id;judul;pemilik;status;tenggat. Seluruh berkas dimuat saat konstruksi
 * dan ditulis ulang pada setiap perubahan — sederhana dan tepat untuk data
 * seukuran proyek ini; database mengambil alih saat data bertambah besar.
 */
public class RepositoryBerkas implements TugasRepository {

    private final Path berkas;
    private final Map<Integer, Tugas> data = new LinkedHashMap<>();
    private int urutan = 0;

    public RepositoryBerkas(Path berkas) {
        this.berkas = berkas;
        muat();
    }

    @Override
    public Tugas tambah(Tugas tugas) {
        tolakPemisah(tugas);
        urutan++;
        Tugas tersimpan = tugas.denganId(urutan);
        data.put(urutan, tersimpan);
        tulisUlang();
        return tersimpan;
    }

    @Override
    public Optional<Tugas> cari(int id) {
        return Optional.ofNullable(data.get(id));
    }

    @Override
    public List<Tugas> semua() {
        return new ArrayList<>(data.values());
    }

    @Override
    public Optional<Tugas> simpan(Tugas tugas) {
        if (!data.containsKey(tugas.id())) {
            return Optional.empty();
        }
        tolakPemisah(tugas);
        data.put(tugas.id(), tugas);
        tulisUlang();
        return Optional.of(tugas);
    }

    @Override
    public boolean hapus(int id) {
        boolean ada = data.remove(id) != null;
        if (ada) {
            tulisUlang();
        }
        return ada;
    }

    /** Memuat seluruh baris; baris cacat menghentikan proses karena integritas diragukan. */
    private void muat() {
        if (!Files.exists(berkas)) {
            return;   // berkas belum pernah dibuat: mulai dari kondisi kosong
        }
        List<String> baris;
        try {
            baris = Files.readAllLines(berkas, StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new UncheckedIOException("gagal membaca " + berkas, e);
        }
        for (int i = 0; i < baris.size(); i++) {
            String satu = baris.get(i);
            if (satu.isBlank()) {
                continue;
            }
            Tugas tugas = parseBaris(satu, i + 1);
            urutan = Math.max(urutan, tugas.id());
            data.put(tugas.id(), tugas);
        }
    }

    /** Menulis ulang seluruh berkas dalam charset UTF-8. */
    private void tulisUlang() {
        List<String> baris = new ArrayList<>();
        for (Tugas t : data.values()) {
            baris.add("T;" + t.id() + ";" + t.judul() + ";" + t.pemilik()
                    + ";" + t.status() + ";" + t.tenggat());
        }
        try {
            Files.write(berkas, baris, StandardCharsets.UTF_8);
        } catch (IOException e) {
            throw new UncheckedIOException("gagal menulis " + berkas, e);
        }
    }

    /**
     * Karakter ';' dipakai sebagai pemisah kolom, sehingga judul dan pemilik
     * yang memuatnya ditolak lebih awal agar berkas tetap bisa dibaca ulang.
     */
    private static void tolakPemisah(Tugas tugas) {
        if (tugas.judul().indexOf(';') >= 0 || tugas.pemilik().indexOf(';') >= 0) {
            throw new IllegalArgumentException("judul dan pemilik tidak boleh mengandung "
                    + "';' karena karakter itu dipakai sebagai pemisah kolom berkas");
        }
    }

    /** Mengubah satu baris berkas menjadi Tugas dengan laporan nomor baris. */
    private static Tugas parseBaris(String baris, int nomor) {
        if (!baris.startsWith("T;")) {
            throw new IllegalStateException("baris " + nomor + ": awalan tidak dikenal");
        }
        String[] kolom = baris.split(";", -1);
        if (kolom.length != 6) {
            throw new IllegalStateException("baris " + nomor + ": jumlah kolom "
                    + kolom.length + ", harap 6");
        }
        int id;
        try {
            id = Integer.parseInt(kolom[1]);
        } catch (NumberFormatException e) {
            throw new IllegalStateException("baris " + nomor + ": id '"
                    + kolom[1] + "' bukan angka");
        }
        LocalDate tenggat;
        try {
            tenggat = LocalDate.parse(kolom[5]);
        } catch (DateTimeParseException e) {
            throw new IllegalStateException("baris " + nomor + ": tenggat '"
                    + kolom[5] + "' tidak valid");
        }
        StatusTugas status;
        try {
            status = StatusTugas.dariTeks(kolom[4]);
        } catch (IllegalArgumentException e) {
            throw new IllegalStateException("baris " + nomor + ": " + e.getMessage());
        }
        return new Tugas(id, kolom[2], kolom[3], status, tenggat);
    }
}

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.util.Locale;

/**
 * Bagian 3: server dengan penyimpanan berkas. Babak 1 menulis data lewat
 * server pertama, lalu babak 2 membuat server baru atas berkas yang sama
 * untuk membuktikan data bertahan melewati "restart".
 */
public class ServerApi {

    public static void main(String[] args) throws Exception {
        Path berkas = Path.of("tugas-api.txt");

        System.out.println("=== Babak 1: server pertama menulis ke berkas ===");
        HttpServer server1 = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server1.createContext("/", new RouterTugas(new RepositoryBerkas(berkas)));
        server1.start();
        String dasar1 = "http://127.0.0.1:" + server1.getAddress().getPort();
        HttpClient klien1 = HttpClient.newHttpClient();
        try {
            cetak(klien1, "POST", dasar1 + "/api/tugas",
                    "{\"judul\":\"Belajar HttpServer\",\"pemilik\":\"Budi\",\"tenggat\":\"2026-01-20\"}",
                    null);
            cetak(klien1, "POST", dasar1 + "/api/tugas",
                    "{\"judul\":\"Tulis dokumentasi API\",\"pemilik\":\"Siti\",\"tenggat\":\"2026-02-01\"}",
                    null);
            cetak(klien1, "PUT", dasar1 + "/api/tugas/1",
                    "{\"judul\":\"Belajar HttpServer\",\"pemilik\":\"Budi\","
                            + "\"status\":\"SELESAI\",\"tenggat\":\"2026-01-20\"}",
                    null);
            cetak(klien1, "POST", dasar1 + "/api/tugas",
                    "{\"pemilik\":\"Dewi\",\"tenggat\":\"20-01-2026\"}",
                    "dua field bermasalah");
        } finally {
            server1.stop(0);
        }

        System.out.println();
        System.out.println("=== Isi tugas-api.txt setelah server berhenti ===");
        System.out.print(Files.readString(berkas, StandardCharsets.UTF_8));

        System.out.println();
        System.out.println("=== Babak 2: server baru memuat ulang berkas ===");
        HttpServer server2 = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
        server2.createContext("/", new RouterTugas(new RepositoryBerkas(berkas)));
        server2.start();
        String dasar2 = "http://127.0.0.1:" + server2.getAddress().getPort();
        HttpClient klien2 = HttpClient.newHttpClient();   // klien segar: koneksi lama tidak berlaku lagi
        try {
            cetak(klien2, "GET", dasar2 + "/api/tugas", null, null);
            cetak(klien2, "POST", dasar2 + "/api/tugas",
                    "{\"judul\":\"Rapat tim mingguan\",\"pemilik\":\"Dewi\",\"tenggat\":\"2026-02-10\"}",
                    null);
            cetak(klien2, "POST", dasar2 + "/api/tugas",
                    "{\"judul\":\"Rapat;belanja bulanan\",\"pemilik\":\"Dewi\",\"tenggat\":\"2026-02-15\"}",
                    "memuat pemisah ;");
        } finally {
            server2.stop(0);
        }
    }

    /**
     * Mengirim satu permintaan lalu mencetak status dan body responsnya.
     * Nomor port sengaja tidak dicetak agar keluaran tetap deterministik.
     */
    private static void cetak(HttpClient klien, String metode, String url,
            String body, String keterangan) throws IOException, InterruptedException {
        HttpRequest.Builder b = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .timeout(Duration.ofSeconds(5));
        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> respons =
                klien.send(b.build(), HttpResponse.BodyHandlers.ofString());

        String path = URI.create(url).getPath();
        String target = keterangan == null ? path : path + " (" + keterangan + ")";
        System.out.printf(Locale.US, "%-6s %-30s -> %d %s%n",
                metode, target, respons.statusCode(), respons.body());
    }
}

=== Babak 1: server pertama menulis ke berkas ===
POST   /api/tugas                     -> 201 {"id":1,"judul":"Belajar HttpServer","pemilik":"Budi","status":"TODO","tenggat":"2026-01-20"}
POST   /api/tugas                     -> 201 {"id":2,"judul":"Tulis dokumentasi API","pemilik":"Siti","status":"TODO","tenggat":"2026-02-01"}
PUT    /api/tugas/1                   -> 200 {"id":1,"judul":"Belajar HttpServer","pemilik":"Budi","status":"SELESAI","tenggat":"2026-01-20"}
POST   /api/tugas (dua field bermasalah) -> 400 {"error":"judul wajib diisi; tenggat '20-01-2026' harus ISO-8601, contoh 2026-01-20"}

=== Isi tugas-api.txt setelah server berhenti ===
T;1;Belajar HttpServer;Budi;SELESAI;2026-01-20
T;2;Tulis dokumentasi API;Siti;TODO;2026-02-01

=== Babak 2: server baru memuat ulang berkas ===
GET    /api/tugas                     -> 200 [{"id":1,"judul":"Belajar HttpServer","pemilik":"Budi","status":"SELESAI","tenggat":"2026-01-20"},{"id":2,"judul":"Tulis dokumentasi API","pemilik":"Siti","status":"TODO","tenggat":"2026-02-01"}]
POST   /api/tugas                     -> 201 {"id":3,"judul":"Rapat tim mingguan","pemilik":"Dewi","status":"TODO","tenggat":"2026-02-10"}
POST   /api/tugas (memuat pemisah ;)  -> 400 {"error":"judul dan pemilik tidak boleh mengandung ';' karena karakter itu dipakai sebagai pemisah kolom berkas"}

import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Validasi payload tugas yang mengumpulkan seluruh pelanggaran sekaligus,
 * bukan berhenti pada pelanggaran pertama. Hasilnya: satu respons 400
 * yang menyebut semua masalah sehingga klien cukup memperbaiki sekali.
 */
public final class ValidasiTugas {

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

    /** Validasi POST: judul, pemilik, dan tenggat wajib; status tidak dibaca. */
    public static List<String> galatBuat(Map<String, Object> payload) {
        List<String> galat = new ArrayList<>();
        cekJudul(payload, galat);
        cekPemilik(payload, galat);
        cekTenggat(payload, galat);
        return galat;
    }

    /** Validasi PUT: seluruh field wajib, termasuk status. */
    public static List<String> galatUbah(Map<String, Object> payload) {
        List<String> galat = new ArrayList<>(galatBuat(payload));
        String status = teks(payload, "status");
        if (status == null) {
            galat.add("status wajib diisi (TODO/SELESAI)");
        } else {
            try {
                StatusTugas.dariTeks(status);
            } catch (IllegalArgumentException e) {
                galat.add(e.getMessage());
            }
        }
        return galat;
    }

    private static void cekJudul(Map<String, Object> payload, List<String> galat) {
        String judul = teks(payload, "judul");
        if (judul == null) {
            galat.add("judul wajib diisi");
        } else if (judul.isEmpty()) {
            galat.add("judul tidak boleh kosong");
        } else if (judul.length() > Tugas.PANJANG_JUDUL_MAKS) {
            galat.add("judul " + judul.length() + " karakter, maksimal "
                    + Tugas.PANJANG_JUDUL_MAKS);
        }
    }

    private static void cekPemilik(Map<String, Object> payload, List<String> galat) {
        String pemilik = teks(payload, "pemilik");
        if (pemilik == null) {
            galat.add("pemilik wajib diisi");
        } else if (pemilik.isEmpty()) {
            galat.add("pemilik tidak boleh kosong");
        }
    }

    private static void cekTenggat(Map<String, Object> payload, List<String> galat) {
        String tenggat = teks(payload, "tenggat");
        if (tenggat == null) {
            galat.add("tenggat wajib diisi");
        } else {
            try {
                LocalDate.parse(tenggat);
            } catch (DateTimeParseException e) {
                galat.add("tenggat '" + tenggat + "' harus ISO-8601, contoh 2026-01-20");
            }
        }
    }

    /** Nilai field sebagai String yang sudah dipangkas; null bila hilang atau bukan teks. */
    private static String teks(Map<String, Object> payload, String kunci) {
        if (payload.get(kunci) instanceof String s) {
            return s.strip();
        }
        return null;
    }
}

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;

/**
 * Implementasi TugasRepository di atas SQLite lewat JDBC.
 * Sebelum dipakai: letakkan driver sqlite-jdbc di classpath, misalnya
 * java -cp sqlite-jdbc.jar:. ServerApi.java
 */
public class RepositorySqlite implements TugasRepository {

    private final Connection koneksi;

    public RepositorySqlite(String url) throws SQLException {
        // URL contoh: "jdbc:sqlite:tugas.db"
        this.koneksi = DriverManager.getConnection(url);
        try (PreparedStatement ps = koneksi.prepareStatement(
                "CREATE TABLE IF NOT EXISTS tugas ("
                        + "id INTEGER PRIMARY KEY AUTOINCREMENT,"
                        + "judul TEXT NOT NULL,"
                        + "pemilik TEXT NOT NULL,"
                        + "status TEXT NOT NULL,"
                        + "tenggat TEXT NOT NULL)")) {
            ps.executeUpdate();
        }
    }

    @Override
    public Tugas tambah(Tugas tugas) {
        try (PreparedStatement ps = koneksi.prepareStatement(
                "INSERT INTO tugas (judul, pemilik, status, tenggat) VALUES (?, ?, ?, ?)",
                Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, tugas.judul());
            ps.setString(2, tugas.pemilik());
            ps.setString(3, tugas.status().name());
            ps.setString(4, tugas.tenggat().toString());
            ps.executeUpdate();
            try (ResultSet kunci = ps.getGeneratedKeys()) {
                kunci.next();
                return tugas.denganId(kunci.getInt(1));
            }
        } catch (SQLException e) {
            throw new IllegalStateException("gagal menyimpan tugas", e);
        }
    }

    @Override
    public Optional<Tugas> cari(int id) {
        // SELECT ... WHERE id = ? dengan parameter terikat, lalu petakan ResultSet ke Tugas.
        throw new UnsupportedOperationException("latihan untuk pembaca");
    }

    @Override
    public List<Tugas> semua() {
        // SELECT id, judul, pemilik, status, tenggat FROM tugas ORDER BY id
        throw new UnsupportedOperationException("latihan untuk pembaca");
    }

    @Override
    public Optional<Tugas> simpan(Tugas tugas) {
        // UPDATE tugas SET judul = ?, pemilik = ?, status = ?, tenggat = ? WHERE id = ?
        throw new UnsupportedOperationException("latihan untuk pembaca");
    }

    @Override
    public boolean hapus(int id) {
        // DELETE FROM tugas WHERE id = ?
        throw new UnsupportedOperationException("latihan untuk pembaca");
    }

    /** Transaksi: memindahkan seluruh tugas satu pemilik dalam satu kesatuan. */
    public void pindahkanPemilik(String lama, String baru) throws SQLException {
        koneksi.setAutoCommit(false);
        try (PreparedStatement ps = koneksi.prepareStatement(
                "UPDATE tugas SET pemilik = ? WHERE pemilik = ?")) {
            ps.setString(1, baru);
            ps.setString(2, lama);
            ps.executeUpdate();
            koneksi.commit();
        } catch (SQLException e) {
            koneksi.rollback();
            throw e;
        } finally {
            koneksi.setAutoCommit(true);
        }
    }
}