Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,9 @@
+.venv
+__pycache__
+*.pyc
+.git
+.env
+.env.*
+bukang.db
+.pytest_cache
+.venv/

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,9 @@
 ---
 title: Bukang Backend
-emoji: 😻
-colorFrom: yellow
-colorTo: blue
+emoji: 🚀
+colorFrom: blue
+colorTo: green
 sdk: docker
 pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+app_port: 7860
+---

app/application/interfaces/jwt.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class JWTService(ABC):
+    @abstractmethod
+    def create_access_token(self, data: dict) -> str:
+        ...
+
+    @abstractmethod
+    def decode_token(self, token: str) -> dict:
+        ...

app/application/interfaces/password.py

@@ -0,0 +1,11 @@
+from abc import ABC, abstractmethod
+
+
+class PasswordService(ABC):
+    @abstractmethod
+    def hash(self, password: str) -> str:
+        ...
+
+    @abstractmethod
+    def verify(self, plain: str, hashed: str) -> bool:
+        ...

app/application/use_cases/auth_use_case.py

@@ -0,0 +1,81 @@
+from dataclasses import dataclass
+
+from app.domain.entities.user import User
+from app.domain.repositories.user_repository import UserRepository
+from app.application.interfaces.jwt import JWTService
+from app.application.interfaces.password import PasswordService
+
+
+@dataclass
+class RegisterRequest:
+    username: str
+    password: str
+
+
+@dataclass
+class LoginRequest:
+    username: str
+    password: str
+
+
+@dataclass
+class TokenResult:
+    access_token: str
+    token_type: str = "bearer"
+
+
+@dataclass
+class UserResult:
+    id: str
+    username: str
+
+
+class AuthUseCase:
+    def __init__(
+        self,
+        user_repository: UserRepository,
+        password_service: PasswordService,
+        jwt_service: JWTService,
+    ):
+        self._user_repo = user_repository
+        self._password = password_service
+        self._jwt = jwt_service
+
+    def register(self, request: RegisterRequest) -> UserResult:
+        existing = self._user_repo.find_by_username(request.username)
+        if existing is not None:
+            raise ValueError("Username already taken")
+
+        import uuid
+        user_id = str(uuid.uuid4())
+        hashed = self._password.hash(request.password)
+        user = User.create(
+            username=request.username,
+            hashed_password=hashed,
+            user_id=user_id,
+        )
+        self._user_repo.save(user)
+        return UserResult(id=user.id, username=user.username)
+
+    def login(self, request: LoginRequest) -> TokenResult:
+        user = self._user_repo.find_by_username(request.username)
+        if user is None:
+            raise ValueError("Invalid username or password")
+
+        if not self._password.verify(request.password, user.hashed_password):
+            raise ValueError("Invalid username or password")
+
+        token = self._jwt.create_access_token({"sub": user.id})
+        return TokenResult(access_token=token)
+
+    def verify_token(self, token: str) -> User:
+        payload = self._jwt.decode_token(token)
+        user_id: str | None = payload.get("sub")
+        if user_id is None:
+            raise ValueError("Invalid token")
+
+        user = self._user_repo.find_by_id(user_id)
+        if user is None:
+            raise ValueError("Invalid token")
+
+        return user

app/application/use_cases/student_use_case.py

@@ -0,0 +1,493 @@
+from fastapi import HTTPException, UploadFile, status
+from sqlalchemy.orm import Session
+
+from app.infrastructure.persistence.models.student import StudentModel as Student
+from app.infrastructure.storage.hf_storage import storage_service
+from app.presentation.schemas.student import SubmissionRequest
+
+
+def save_photo(file: UploadFile) -> str:
+    content = file.file.read()
+    return storage_service.upload_photo(content, file.filename or "photo.jpg")
+
+
+def create_submission(db: Session, user_id: str, data: SubmissionRequest) -> Student:
+    name = find_name_from_nrp(data.nrp)
+    if data.nrp[2] == "2" and data.nrp[3] == "5":
+        major = "Teknik Informatika"
+    elif data.nrp[2] == "5" and data.nrp[3] == "3":
+        major = "Rekayasa Perangkat Lunak"
+    elif data.nrp[2] == "5" and data.nrp[3] == "4":
+        major = "Rekayasa Kecerdasan Artifisial"
+    else:
+        major = "Unknown"
+
+    student = Student(
+        user_id=user_id,
+        nrp=data.nrp,
+        name=name,
+        major=major,
+        hometown=data.asal_daerah,
+        hobbies=",".join(data.hobi),
+        first_impression=data.first_impression,
+        longitude=data.longitude,
+        latitude=data.latitude,
+        captured_at=data.captured_at,
+        photo_url=data.photo_url,
+    )
+    db.add(student)
+    db.commit()
+    db.refresh(student)
+    return student
+
+
+def resolve_nrp_data(nrp: str, db: Session | None = None) -> dict:
+    if db is not None:
+        existing = db.query(Student).filter(Student.nrp == nrp).first()
+        if existing is not None:
+            return {"name": existing.name, "major": existing.major}
+
+    name = find_name_from_nrp(nrp)
+    if len(nrp) >= 4:
+        if nrp[2] == "2" and nrp[3] == "5":
+            major = "Teknik Informatika"
+        elif nrp[2] == "5" and nrp[3] == "3":
+            major = "Rekayasa Perangkat Lunak"
+        elif nrp[2] == "5" and nrp[3] == "4":
+            major = "Rekayasa Kecerdasan Artifisial"
+        else:
+            major = "Unknown"
+    else:
+        major = "Unknown"
+    return {"name": name, "major": major}
+
+
+def get_students(db: Session, user_id: str) -> list[Student]:
+    return (
+        db.query(Student)
+        .filter(Student.user_id == user_id)
+        .order_by(Student.created_at.desc())
+        .all()
+    )
+
+
+def get_student(db: Session, user_id: str, student_id: str) -> Student:
+    student = (
+        db.query(Student)
+        .filter(Student.id == student_id, Student.user_id == user_id)
+        .first()
+    )
+    if not student:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Student not found")
+    return student
+
+
+def search_students_by_nrp(db: Session, user_id: str, nrp: str) -> list[Student]:
+    return (
+        db.query(Student)
+        .filter(Student.user_id == user_id, Student.nrp.like(f"%{nrp}%"))
+        .order_by(Student.nrp)
+        .all()
+    )
+
+
+def get_roster(
+    db: Session,
+    user_id: str,
+    page: int = 1,
+    per_page: int = 20,
+    search: str = "",
+    major: str = "",
+    status: str = "",
+    all_: bool = False,
+) -> dict:
+    submissions = {
+        s.nrp: s
+        for s in db.query(Student).filter(Student.user_id == user_id).all()
+    }
+
+    entries = []
+    for nrp, name in _NRP_MAP.items():
+        if search and search.lower() not in nrp.lower() and search.lower() not in name.lower():
+            continue
+        sub = submissions.get(nrp)
+        entry_major = resolve_nrp_data(nrp)["major"]
+        if major and entry_major != major:
+            continue
+        submitted = sub is not None
+        if status == "submitted" and not submitted:
+            continue
+        if status == "pending" and submitted:
+            continue
+        entries.append({
+            "nrp": nrp,
+            "name": name,
+            "major": entry_major,
+            "submitted": submitted,
+            "photo_url": sub.photo_url if sub else None,
+            "hometown": sub.hometown if sub else None,
+            "hobbies": sub.hobbies if sub else None,
+            "first_impression": sub.first_impression if sub else None,
+            "submission_id": sub.id if sub else None,
+            "captured_at": sub.captured_at.isoformat() if sub and sub.captured_at else None,
+            "latitude": sub.latitude if sub else None,
+            "longitude": sub.longitude if sub else None,
+        })
+
+    entries.sort(key=lambda e: e["nrp"])
+    total = len(entries)
+    if all_:
+        return {
+            "entries": entries,
+            "total": total,
+            "submitted_count": sum(1 for e in entries if e["submitted"]),
+        }
+    total_pages = max(1, (total + per_page - 1) // per_page)
+    start = (page - 1) * per_page
+    paged = entries[start:start + per_page]
+
+    return {
+        "entries": paged,
+        "total": total,
+        "page": page,
+        "per_page": per_page,
+        "total_pages": total_pages,
+        "submitted_count": sum(1 for e in entries if e["submitted"]),
+    }
+
+
+_NRP_MAP = {
+    "5025251001": "Naura Rizky Ameira",
+    "5025251002": "Muhammad Faris Alfarrel",
+    "5025251004": "Ahmad Faruq Azzam",
+    "5025251005": "Ahmad Farras Favian Al Efasi",
+    "5025251006": "Farras Al Ghifari",
+    "5025251009": "Athar Rozy Rasyidan",
+    "5025251010": "Agile Octa Agrakha Handrian",
+    "5025251011": "Dzulfiqar Rafi'ussunnah",
+    "5025251012": "Khumaidy Syafiq El Maududy",
+    "5025251013": "Nisrina Zahralilla",
+    "5025251014": "Padhang Abiyu Fikri",
+    "5025251015": "Renato Kiran Arisandi",
+    "5025251016": "Keven John Gondowardojo",
+    "5025251017": "Wafi Fawwaz Sutisna",
+    "5025251018": "Farrel Marvellino Sugianto",
+    "5025251019": "Fakhrian Elanta",
+    "5025251020": "Firsto Al Kautsar Jagad Kurniaji",
+    "5025251021": "Yahdilil Haq Sarifuddin",
+    "5025251022": "Ahmad Radho Alfariz",
+    "5025251023": "Chairunnisa` Tsabitah",
+    "5025251024": "Rinaltra Nabasa Simanungkalit",
+    "5025251025": "Elba Galuh Hardiyanti",
+    "5025251027": "Hadryan Rizky Dimas Saputra",
+    "5025251028": "Julianda Caesar Prakoso",
+    "5025251031": "Najwan Sigit Cahya Buana",
+    "5025251032": "Nagita Aliya Sanopa",
+    "5025251033": "Jeremee Rafael Wynn",
+    "5025251034": "Ferdyan Dimas Satria",
+    "5025251035": "Aston Justin Holiwono",
+    "5025251036": "Darwisy Ahmad Alfayyadl",
+    "5025251037": "Hasan Mohammadi",
+    "5025251038": "Jovan Steve Antony",
+    "5025251039": "Benedictus Imanuel Wicaksono",
+    "5025251040": "Nurmaida Intan Permadani",
+    "5025251041": "Muhammad Adinata Parikesit",
+    "5025251042": "Yulius Restu Putranto",
+    "5025251043": "Tri Zuyyina Rohmah",
+    "5025251045": "Khalisya Zahra Putria Rahman",
+    "5025251046": "Muhammad Fairuz Ananta",
+    "5025251047": "Akhmad Fahmi",
+    "5025251048": "Rado Putra Yustisiawan",
+    "5025251049": "Husna 'Akifah",
+    "5025251050": "Muhammad Fajrul Hakam",
+    "5025251051": "Andra Safir Gemintang",
+    "5025251052": "Hilmy Fausta Pratama",
+    "5025251053": "M. Haziq Ridwan Parsa",
+    "5025251054": "Earlang Rangga Purwanto",
+    "5025251055": "Aga Nafta Filadelfiano",
+    "5025251056": "Sulthaan Daffaa'hadiansyach",
+    "5025251057": "Gabriella Putri Atmaja Adi",
+    "5025251058": "Shine Lee Romenzio Tarigan",
+    "5025251059": "Arsya Argananta",
+    "5025251060": "Sanchia Revana Koasasi",
+    "5025251061": "Bayu Setyo Nugroho",
+    "5025251062": "Aisyah Putri Diza",
+    "5025251063": "Lina Mushlihah",
+    "5025251064": "Mas Ayu Lana Afiah",
+    "5025251065": "Rida Izzati Azzahra",
+    "5025251066": "Nabil Khairie",
+    "5025251067": "Azka Fairus Syamsa",
+    "5025251068": "Satya Mahardika Sandyaditama",
+    "5025251069": "Evannio Michael Christeben Putra",
+    "5025251070": "Pandutama Putra Difira",
+    "5025251071": "Nasywa Zhafirah",
+    "5025251072": "Deborah Amalia Sheraviningrum",
+    "5025251073": "Ilham Husni Pratama",
+    "5025251075": "Muhammad Naufal Syahputra",
+    "5025251076": "Muhammad Faqih",
+    "5025251077": "Bastian Gerry Simangunsong",
+    "5025251078": "Muhammad Dida Pandawa",
+    "5025251079": "Isham Hawali Arijuddin",
+    "5025251080": "Kevin Jonathan Messakh",
+    "5025251081": "Luthfir Rizqy Fathullah Hanggi",
+    "5025251082": "M. Aqsha Syadindha Putra",
+    "5025251083": "Tubagus Muhamad Afif",
+    "5025251084": "Radhit Akriandra",
+    "5025251087": "Zakary Nareswara Tulus Sinudewangga Hatmadipura",
+    "5025251088": "I Komang Bagus Alvero Wisnawa",
+    "5025251089": "Nabila Zalfaa Putri Hamid",
+    "5025251090": "Nailla Chrysant Jelita",
+    "5025251091": "Mumtaz Hanumi Fayazida",
+    "5025251092": "Dhia Hiroyuki Prawira",
+    "5025251093": "Muhammad Hanif Musyafa",
+    "5025251094": "I Gusti Agung Wijnana Aryasa",
+    "5025251095": "Alessandro Almaz Filemon",
+    "5025251096": "Gabriel Mesly Managam Siahaan",
+    "5025251097": "Caroline Alverina",
+    "5025251098": "Wistara Banyu Kayana",
+    "5025251099": "Faris Rashid Azizi",
+    "5025251100": "Yudith Hafiz Rabbani",
+    "5025251101": "Ayudya Devina Azzahra",
+    "5025251102": "Muhammad Ludaka Firdaus",
+    "5025251103": "Rafifah Nabil Rahmadian",
+    "5025251104": "Amanda Putri Chaerunnisa",
+    "5025251105": "Gita Renada",
+    "5025251106": "Asher Yedijah Hoesono",
+    "5025251107": "Dimas Adiyaksa",
+    "5025251108": "Dimas Maulana Putra",
+    "5025251109": "Marveilleux Putra Mahasura",
+    "5025251110": "Muhammad Fauzta Putra Kavie",
+    "5025251111": "Ahmad Rafli Syarif Attallah",
+    "5025251112": "Faizaturrahmah Baity",
+    "5025251113": "Dewa Fitrah Fakhrusy Imron",
+    "5025251114": "Sheila Alvina Tsabita",
+    "5025251115": "Rayyan Aura Rahman",
+    "5025251116": "Moh. Zidan Ilmi Alwi",
+    "5025251117": "Faeyzar Ahnaf Musyarri",
+    "5025251118": "Anang Ardhiansyah",
+    "5025251120": "Alogo Hasiholan Napitupulu",
+    "5025251121": "Haidar Abiyyu At Taqy",
+    "5025251122": "Maida Aqillah Putri Nurandani",
+    "5025251124": "Muhammad Alhady Rizq",
+    "5025251125": "Muhammad Afzal Fulvian Handoni",
+    "5025251126": "Budiman Setiono",
+    "5025251129": "Muhammad Brahmana Priambudi",
+    "5025251130": "Aziz Alfarisi",
+    "5025251131": "Muhammad Azka Asyrafany",
+    "5025251132": "Kyla Rahma Maulida",
+    "5025251133": "Garda Putra Brahmantya",
+    "5025251134": "Althea Rahmania Fitri",
+    "5025251135": "Gadhiza Edgina Ikhwana Putri",
+    "5025251136": "Yudhistira Eka Pratama",
+    "5025251137": "Rayyan Aqsha Raditya",
+    "5025251138": "Farrel Satria Mukti",
+    "5025251139": "Gita Aulia",
+    "5025251140": "Tristan Athala Rizqullah Al Farisi",
+    "5025251141": "Muhammad Fahmi Ilmi",
+    "5025251142": "Rafi Atha Maulana",
+    "5025251143": "Ahmad Fakhrul Bawani",
+    "5025251144": "Muhammad Raihan Ar Royyan Daryanto",
+    "5025251145": "Raffa Atha Maulana",
+    "5025251146": "Febrian Ananda Tjahjono",
+    "5025251147": "Nicholaus Ardian Nugraha",
+    "5025251148": "Rahmavida Novita Setiani",
+    "5025251149": "Putu Pradipta Ananda",
+    "5025251150": "Made Joshua Ama Ede",
+    "5025251151": "Komang Mahatma Langendria",
+    "5025251152": "Dewa Ngakan Putu Sunyananda Triyanca",
+    "5025251153": "I Gede Made Adi Putra Adnyana",
+    "5025251154": "Boy Steven Benaya Aritonang",
+    "5025251155": "Wanhardo Jawak",
+    "5025251156": "Valian Athalla Syahputra",
+    "5025251158": "Aditya Lingga Mardika",
+    "5025251159": "Maulana Anugra Putra",
+    "5025251160": "Vania Aisha Rohmawati",
+    "5025251161": "Rizqi Arya Kuskhilbyano",
+    "5025251166": "Muhammad Kholid Zulfikar",
+    "5025251167": "Gabriela Asima Nainggolan",
+    "5025251168": "Lina Fatima Azzahra Badr",
+    "5025251169": "I Gusti Agung Candra Nugraha",
+    "5025251170": "Hussein Mohammad Mahsun",
+    "5025251171": "Daniel Pedrosaputra",
+    "5025251172": "Zainab Ammar Zahra",
+    "5025251174": "Marco Marcelino",
+    "5025251175": "Rafif Athalail Y",
+    "5025251176": "Kevinansyah Salviano Rachmadewa",
+    "5025251177": "Fathan Nurtamam Amry",
+    "5025251178": "Fazli Irham Ramadhan Abdillah",
+    "5025251179": "Muhammad Faiz Haq",
+    "5025251181": "Chaniel Daniello Junitona Tarigan",
+    "5025251182": "Yesenia Valencia Wibowo",
+    "5025251183": "Aditya Hariyadi Tjtujitno",
+    "5025251184": "Claresta Amelinda Hutauruk",
+    "5025251185": "Muhammad Irsyad Prihasto",
+    "5025251187": "Farrel Rizqi Pangestu",
+    "5025251188": "Novaldi Rayhan Asshiddiqi",
+    "5025251189": "Putu Dylan Pryana",
+    "5025251190": "Sayyid Faiz Al Izzuddin",
+    "5025251191": "Salsabila Hana Adniah",
+    "5025251193": "Raihan Naufal Ramadhan",
+    "5025251194": "I Nyoman Gede Anargya Sean Budhi Yasa",
+    "5025251195": "Dafa Dega Wijaya",
+    "5025251196": "I Dewa Gede Putra Susila",
+    "5025251198": "Bryan Darrick Pangedi",
+    "5025251199": "Muhammad Aqsan",
+    "5025251200": "Rafi Eka Pramudya",
+    "5025251201": "Fadlie Akbar Indrianto",
+    "5025251202": "Fawwas Razzan Sulfi Andreyawan",
+    "5025251203": "Muhammad Aqilah Arianto",
+    "5025251204": "Althof Rahmatullah",
+    "5025251205": "I Made Saskara Bawa",
+    "5025251206": "Rexa Matutu Harsaputra",
+    "5025251207": "Kezia Livina",
+    "5025251208": "Rafifah Rahmah Admayana",
+    "5025251209": "Marvel Timothy Noya",
+    "5025251210": "Fany Haikal Ahmad",
+    "5025251211": "Rizqi Ardiansyah Putra Pratama",
+    "5025251212": "Joel Angga Fransmartua Manalu",
+    "5025251213": "Ummi Kalsum Azzahra",
+    "5025251214": "Vijvika Nala Sanuratri",
+    "5025251215": "M Adhwa Athallah Tsani Anargya",
+    "5025251216": "Jessica Febiola",
+    "5025251217": "Syabil Zihni",
+    "5025251218": "Mushallina Dzikri Rozana",
+    "5025251219": "Farrel Fahrezi Rizvanala",
+    "5025251221": "Rachmat Ahzadel",
+    "5025251222": "I Dewa Nyoman Acarya Wibawantra",
+    "5025251223": "Sayyidah Fatimah Azzahrah Rakhmatullah",
+    "5025251225": "Fayyadh Ahmad Zuhri",
+    "5025251226": "Grandira Haidee Alexandro Letik",
+    "5025251227": "Khen Patra Yabes Sianipar",
+    "5025251229": "Muhammad Raffy Adika Putra Riyanto",
+    "5025251230": "Naila Hikaru",
+    "5025251231": "Nichola Matthew Hutabarat",
+    "5025251232": "Zidni Ammar Zadi",
+    "5025251233": "I Made Bagus Naratama Karangputra",
+    "5025251234": "Ahmad Fateh Eydil Faiq",
+    "5025251235": "Dhanishara Zaschya Putri Syamsudin",
+    "5025251236": "Gede Nararya Vatsa",
+    "5025251237": "Nur Handiena Deswinda Jefrimananda",
+    "5025251238": "Istaqim Makmun",
+    "5025251239": "Muhammad Faza Ismail",
+    "5025251240": "Medina Kusuma Prianda",
+    "5025251241": "Glenn Lucky Tangke Payung",
+    "5025251242": "Irsyad Ansyari Hakim",
+    "5025251243": "Irsyad Akbar",
+    "5025251245": "Hasna Nabila Hanim",
+    "5025251246": "Hamizan Rifqi Afandi",
+    "5025251247": "Gede Panji Dana Putra Ricedes",
+    "5025251248": "Maulana Bagas Rizqi Pratama",
+    "5025251249": "Enver Alif Wirawan",
+    "5025251251": "Mochammad Raja Defana",
+    "5025251252": "Matthew Adrian Putra",
+    "5025251253": "Darryl Ardan Wicaksono",
+    "5025251254": "Salsabila Shafadelarosa",
+    "5025251255": "Aghazy Setyo Nugroho",
+    "5025251257": "Rozan Hakim Abyandhono",
+    "5025251258": "Naila Sa'ada Cahyani",
+    "5025251259": "A. Deraya Meuthia Toja",
+    "5025251260": "Aqilah Ibrahim",
+    "5025251262": "Muhammad Rayza Buftiem",
+    "5025251263": "Raihan Ahmad Farraszaki",
+    "5025251264": "Ronald Ruben Sitopu",
+    "5025251265": "Affan Rafi Habibie",
+    "5025251268": "Safiya Nadira Az-Zahra",
+    "5025251269": "Daffa Arya Satyatma",
+    "5025251270": "Muhamad Alfareza Hariesa Pratama",
+    "5025251272": "Raka Rajendra Dipo Alam",
+    "5025251273": "Cokorda Bagus Laksmana Iswara",
+    "5025251274": "Hafuza Riffat",
+    "5053251001": "Rokhmatul Ilma Khanifa",
+    "5053251002": "Selly Aisyah",
+    "5053251003": "Aurelia Pradnyaswari Sanjaya Erawan",
+    "5053251004": "M. Khauzaky Amkanaky",
+    "5053251005": "Dheva Alvian Alfarizzy Excellent",
+    "5053251006": "Aurelia Nurdiansyah Putri",
+    "5053251007": "Abdul Ghofur Luqman Salim",
+    "5053251008": "Sulthan Zakinun Nasywa",
+    "5053251009": "Muchammad Naufal Aziz",
+    "5053251011": "Achmad Mirza Arzheta Rahman",
+    "5053251012": "Hilmi Taqiyuddin Haq",
+    "5053251013": "Hilmi Fauzi Adha Simamora",
+    "5053251014": "Muhammad Rafi Riansjah",
+    "5053251015": "Hafidz Nur Ikhsan Isnaeni",
+    "5053251017": "Daffa Randika",
+    "5053251018": "Mhd. Ravy Enstein Wahieda Elmunif",
+    "5053251019": "Muhammad Nafis Al Khalifi",
+    "5053251020": "Yuwand Arteta Hydri Wahyu Putra",
+    "5053251021": "Ahmad Zaidaan",
+    "5053251022": "Muhammad Hanif Nasrullah",
+    "5053251023": "Afrel Zharif Muflih",
+    "5053251024": "Nathan Alden",
+    "5053251025": "Muhammad Fakhry Ziyad Dhiyaulhaq",
+    "5053251026": "Safia Rashida Raya",
+    "5053251027": "Deara Briliana Putri",
+    "5053251028": "Yeremia Gunawan",
+    "5053251029": "Alvian Faza Wafda Reonaldi",
+    "5053251030": "La Ode Muhammad Ghofaruddin S",
+    "5053251031": "Muhammad Hisyam Nurdy",
+    "5053251032": "Daniel Dhaniswara",
+    "5053251033": "Vincent Anindito Priyamboddo",
+    "5053251034": "Nabila Ainiya Rahman",
+    "5053251035": "Azendra Kenar Arviant",
+    "5053251036": "Farrel Aryasatya Raharjo",
+    "5053251038": "Marsya Safina Maulidiyah",
+    "5053251039": "Devin Faza Raditya",
+    "5053251040": "Muhammad Zaydan Anugrah Pratama",
+    "5053251041": "Moch Siril Wafa Zidane Feliano",
+    "5053251042": "Ahmad Balya Malkan",
+    "5053251043": "Muhammad Farel Al Farisi",
+    "5053251044": "Fauzan Hasyim",
+    "5053251045": "Dzakwan Ghonim Fath'han Mubina",
+    "5053251046": "Reifan Al-Fattii Cahyadewa",
+    "5053251047": "Achmad Raffi Darmawan",
+    "5053251048": "Rilo Zidane Afrianta Tambunan",
+    "5053251049": "Matahari Gracio Sinaga",
+    "5053251050": "Reza",
+    "5054251001": "Benedictus Ryu Gunawan",
+    "5054251002": "Aziz Rahmad Arifin",
+    "5054251003": "Firdaus Mangkona",
+    "5054251004": "Muhammad Azka Ananta Khairon",
+    "5054251006": "Muhammad Fasya Atthaya Rosyada",
+    "5054251008": "Hilal Tsabitul Azmi Arba'i",
+    "5054251009": "Pranaja Adyatma Budiman",
+    "5054251010": "Rakha Makarim",
+    "5054251011": "Maria Putu Evelyne Corena Puryatma",
+    "5054251013": "Evina Fitriyani",
+    "5054251014": "Muhammad Rafie Safaraz Barus",
+    "5054251015": "Fahmi Alfayadh",
+    "5054251016": "Vincent Valentino",
+    "5054251017": "Rafa Rizki Aira Swala",
+    "5054251018": "Dinnetza Araafya Yudetti",
+    "5054251019": "Rasya Arya Ramadhan",
+    "5054251020": "Sandi Suryo Nugroho",
+    "5054251021": "Muhammad Fardan Hafidz",
+    "5054251022": "Daffa Aufa Afif",
+    "5054251023": "Zico Diego Rio Ramadhonny",
+    "5054251024": "Muhammad Irzam Hafis Fabiansyah",
+    "5054251025": "Rayyan Binar Ramadhan",
+    "5054251026": "Jonathan Joyo Wibowo",
+    "5054251027": "Faiz Farrosian Karim",
+    "5054251028": "Malfino Muhammad Willianz",
+    "5054251029": "Intifada Afkar Lazain Muhammad",
+    "5054251030": "Raihan Nurhakim",
+    "5054251032": "Rasya Gonawi",
+    "5054251033": "Levina Zahrathul Huda",
+    "5054251036": "Prima Surya Nusantara",
+    "5054251037": "Lioneil Diyoel Trystan Tikupadang",
+    "5054251039": "Muhammad Dzaky Haidar",
+    "5054251035": "Fauzan Tamma Harish Kunfaza",
+    "5054251041": "Maulana Rhys Pradana",
+    "5054251042": "Muhammad Farid Wijdan",
+    "5054251044": "Ahmad Zaki Fauzan Nabil",
+    "5054251045": "Mahardika Indra Pratama Ilyasa",
+    "5054251046": "Suhail Ainur Rofiq",
+    "5054251047": "A. Toriq Azhar",
+    "5054251048": "Sulaiman Faiz Tsaqib",
+    "5054251050": "Kadek Nathania Gavrila Astika",
+    "5054251051": "Rayyan Muhtar Ali",
+}
+
+
+def find_name_from_nrp(nrp: str) -> str:
+    return _NRP_MAP.get(nrp, "Unknown")

app/config.py

@@ -0,0 +1,17 @@
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    app_name: str = "Bukang API"
+    debug: bool = False
+    database_url: str = "sqlite:///./bukang.db"
+    secret_key: str = "change-me-in-production"
+    algorithm: str = "HS256"
+    access_token_expire_minutes: int = 60
+    cors_origins: str = "*"
+    hf_storage_repo: str = ""
+    hf_token: str = ""
+    model_config = {"env_file": "../.env"}
+
+
+settings = Settings()

app/core/logging.py

@@ -0,0 +1,8 @@
+import logging
+
+
+def setup_logging() -> None:
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    )

app/db/base.py

@@ -0,0 +1,5 @@
+from sqlalchemy.orm import DeclarativeBase
+
+
+class Base(DeclarativeBase):
+    pass

app/db/session.py

@@ -0,0 +1,19 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+
+from app.config import settings
+
+engine = create_engine(
+    settings.database_url,
+    pool_pre_ping=True,
+    pool_recycle=300,
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/domain/entities/user.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+
+@dataclass
+class User:
+    id: str
+    username: str
+    hashed_password: str
+    created_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
+
+    @staticmethod
+    def create(username: str, hashed_password: str, user_id: str) -> "User":
+        return User(
+            id=user_id,
+            username=username,
+            hashed_password=hashed_password,
+        )

app/domain/repositories/user_repository.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from app.domain.entities.user import User
+
+
+class UserRepository(ABC):
+    @abstractmethod
+    def find_by_id(self, user_id: str) -> User | None:
+        ...
+
+    @abstractmethod
+    def find_by_username(self, username: str) -> User | None:
+        ...
+
+    @abstractmethod
+    def save(self, user: User) -> User:
+        ...

app/infrastructure/persistence/models/student.py

@@ -0,0 +1,25 @@
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import Column, String, DateTime, Text, Float, ForeignKey
+
+from app.db.base import Base
+
+
+class StudentModel(Base):
+    __tablename__ = "students"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id = Column(String, ForeignKey("users.id"), nullable=False, index=True)
+    nrp = Column(String, nullable=False, index=True)
+    name = Column(String, nullable=False)
+    hometown = Column(String, nullable=True)
+    major = Column(String, nullable=False)
+    photo_url = Column(Text, nullable=True)
+    hobbies = Column(Text, nullable=True)
+    first_impression = Column(Text, nullable=True)
+    longitude = Column(Float, nullable=True)
+    latitude = Column(Float, nullable=True)
+    captured_at = Column(DateTime, nullable=True)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+    updated_at = Column(DateTime, default=lambda: datetime.now(timezone.utc), onupdate=lambda: datetime.now(timezone.utc))

app/infrastructure/persistence/models/user.py

@@ -0,0 +1,15 @@
+import uuid
+from datetime import datetime, timezone
+
+from sqlalchemy import Column, String, DateTime
+
+from app.db.base import Base
+
+
+class UserModel(Base):
+    __tablename__ = "users"
+
+    id = Column(String, primary_key=True, default=lambda: str(uuid.uuid4()))
+    username = Column(String, unique=True, nullable=False, index=True)
+    hashed_password = Column(String, nullable=False)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))

app/infrastructure/persistence/repositories/user_repository.py

@@ -0,0 +1,43 @@
+import uuid
+from sqlalchemy.orm import Session
+
+from app.domain.entities.user import User
+from app.domain.repositories.user_repository import UserRepository
+from app.infrastructure.persistence.models.user import UserModel
+
+
+class SQLAlchemyUserRepository(UserRepository):
+    def __init__(self, db: Session):
+        self._db = db
+
+    def find_by_id(self, user_id: str) -> User | None:
+        model = self._db.query(UserModel).filter(UserModel.id == user_id).first()
+        if model is None:
+            return None
+        return self._to_entity(model)
+
+    def find_by_username(self, username: str) -> User | None:
+        model = self._db.query(UserModel).filter(UserModel.username == username).first()
+        if model is None:
+            return None
+        return self._to_entity(model)
+
+    def save(self, user: User) -> User:
+        model = UserModel(
+            id=user.id or str(uuid.uuid4()),
+            username=user.username,
+            hashed_password=user.hashed_password,
+        )
+        self._db.add(model)
+        self._db.commit()
+        self._db.refresh(model)
+        return self._to_entity(model)
+
+    @staticmethod
+    def _to_entity(model: UserModel) -> User:
+        return User(
+            id=model.id,
+            username=model.username,
+            hashed_password=model.hashed_password,
+            created_at=model.created_at,
+        )

app/infrastructure/security/jwt.py

@@ -0,0 +1,26 @@
+from datetime import datetime, timedelta, timezone
+
+from jose import JWTError, jwt
+
+from app.config import settings
+from app.application.interfaces.jwt import JWTService
+
+
+class JoseJWTService(JWTService):
+    def create_access_token(self, data: dict) -> str:
+        to_encode = data.copy()
+        expire = datetime.now(timezone.utc) + timedelta(
+            minutes=settings.access_token_expire_minutes
+        )
+        to_encode.update({"exp": expire})
+        return jwt.encode(
+            to_encode, settings.secret_key, algorithm=settings.algorithm
+        )
+
+    def decode_token(self, token: str) -> dict:
+        try:
+            return jwt.decode(
+                token, settings.secret_key, algorithms=[settings.algorithm]
+            )
+        except JWTError:
+            raise ValueError("Invalid token")

app/infrastructure/security/password.py

@@ -0,0 +1,11 @@
+import bcrypt
+
+from app.application.interfaces.password import PasswordService
+
+
+class BcryptPasswordService(PasswordService):
+    def hash(self, password: str) -> str:
+        return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
+
+    def verify(self, plain: str, hashed: str) -> bool:
+        return bcrypt.checkpw(plain.encode(), hashed.encode())

app/infrastructure/storage/hf_storage.py

@@ -0,0 +1,46 @@
+import uuid
+from pathlib import Path
+
+from huggingface_hub import batch_bucket_files
+
+from app.config import settings
+
+
+class StorageService:
+    def __init__(self):
+        self.bucket_name = settings.hf_storage_repo
+        self.token = settings.hf_token
+        self._hf_enabled = bool(self.bucket_name and self.token)
+        self._upload_dir = "uploads"
+
+    def upload_photo(self, file_content: bytes, filename: str) -> str:
+        if self._hf_enabled:
+            return self._upload_to_hf(file_content, filename)
+        return self._upload_local(file_content, filename)
+
+    def _upload_to_hf(self, file_content: bytes, filename: str) -> str:
+        ext = Path(filename).suffix or ".jpg"
+        unique_name = f"{uuid.uuid4().hex}{ext}"
+        path_in_bucket = f"uploads/{unique_name}"
+
+        batch_bucket_files(
+            self.bucket_name,
+            add=[(file_content, path_in_bucket)],
+            token=self.token,
+        )
+
+        return f"https://huggingface.co/buckets/{self.bucket_name}/{path_in_bucket}"
+
+    def _upload_local(self, file_content: bytes, filename: str) -> str:
+        import os
+
+        os.makedirs(self._upload_dir, exist_ok=True)
+        ext = Path(filename).suffix or ".jpg"
+        unique_name = f"{uuid.uuid4().hex}{ext}"
+        path = os.path.join(self._upload_dir, unique_name)
+        with open(path, "wb") as f:
+            f.write(file_content)
+        return f"/uploads/{unique_name}"
+
+
+storage_service = StorageService()

app/main.py

@@ -0,0 +1,101 @@
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from app.config import settings
+from app.core.logging import setup_logging
+from app.db.base import Base
+from app.db.session import engine
+from app.presentation.routers import auth, students
+from app.presentation.schemas.response import error, success
+
+tags_metadata = [
+    {
+        "name": "health",
+        "description": "Health check endpoint",
+    },
+    {
+        "name": "auth",
+        "description": "User registration and authentication",
+    },
+    {
+        "name": "students",
+        "description": "Student CRUD operations",
+    },
+]
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    setup_logging()
+    Base.metadata.create_all(bind=engine)
+    yield
+
+
+app = FastAPI(
+    title=settings.app_name,
+    description="Student Profile Collection API — Kumpulkan Profil Mahasiswa dalam satu tempat",
+    version="1.0.0",
+    lifespan=lifespan,
+    openapi_tags=tags_metadata,
+    swagger_ui_parameters={"persistAuthorization": True},
+)
+
+origins = (
+    settings.cors_origins.split(",")
+    if settings.cors_origins != "*"
+    else ["*"]
+)
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.exception_handler(HTTPException)
+def http_exception_handler(_: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content=error(exc.detail, exc.status_code),
+    )
+
+
+@app.exception_handler(Exception)
+def generic_exception_handler(_: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content=error("Internal server error", 500),
+    )
+
+
+os.makedirs("uploads", exist_ok=True)
+app.mount("/uploads", StaticFiles(directory="uploads"), name="uploads")
+
+app.include_router(auth.router)
+app.include_router(students.router)
+
+
+@app.get("/")
+def root():
+    return JSONResponse(
+        content={"message": "Bukang API is running", "docs": "/docs"}
+    )
+
+
+@app.get(
+    "/api/health",
+    tags=["health"],
+    summary="Check API health",
+    responses={
+        200: {"description": "API is healthy"},
+    },
+)
+def health():
+    return success({"status": "ok"})

app/presentation/dependencies.py

@@ -0,0 +1,57 @@
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from sqlalchemy.orm import Session
+
+from app.db.session import get_db
+from app.domain.repositories.user_repository import UserRepository
+from app.infrastructure.persistence.repositories.user_repository import (
+    SQLAlchemyUserRepository,
+)
+from app.infrastructure.security.jwt import JoseJWTService
+from app.application.use_cases.auth_use_case import AuthUseCase
+
+oauth2_scheme = HTTPBearer(auto_error=False)
+
+
+def get_user_repository(db: Session = Depends(get_db)) -> UserRepository:
+    return SQLAlchemyUserRepository(db)
+
+
+def get_auth_use_case(
+    user_repo: UserRepository = Depends(get_user_repository),
+) -> AuthUseCase:
+    from app.infrastructure.security.password import BcryptPasswordService
+
+    return AuthUseCase(
+        user_repository=user_repo,
+        password_service=BcryptPasswordService(),
+        jwt_service=JoseJWTService(),
+    )
+
+
+def get_current_user(
+    cred: HTTPAuthorizationCredentials | None = Depends(oauth2_scheme),
+    db: Session = Depends(get_db),
+) -> str:
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Not authenticated",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    if cred is None:
+        raise credentials_exception
+
+    try:
+        jwt_service = JoseJWTService()
+        payload = jwt_service.decode_token(cred.credentials)
+        user_id: str | None = payload.get("sub")
+        if user_id is None:
+            raise credentials_exception
+    except ValueError:
+        raise credentials_exception
+
+    repo = SQLAlchemyUserRepository(db)
+    user = repo.find_by_id(user_id)
+    if user is None:
+        raise credentials_exception
+    return user_id

app/presentation/routers/auth.py

@@ -0,0 +1,69 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+
+from app.application.use_cases.auth_use_case import AuthUseCase, RegisterRequest, LoginRequest
+from app.presentation.dependencies import get_auth_use_case
+from app.presentation.schemas.auth import RegisterRequest as RegisterSchema, LoginRequest as LoginSchema
+from app.presentation.schemas.response import (
+    TokenResponseSchema,
+    UserResponseSchema,
+    common_error,
+    success,
+)
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+
+@router.post(
+    "/register",
+    summary="Register a new user",
+    responses={
+        201: {
+            "model": UserResponseSchema,
+            "description": "User registered successfully",
+        },
+        400: {"description": "Username already taken"},
+        **common_error,
+    },
+)
+def register(
+    req: RegisterSchema,
+    auth_use_case: AuthUseCase = Depends(get_auth_use_case),
+):
+    try:
+        result = auth_use_case.register(
+            RegisterRequest(username=req.username, password=req.password)
+        )
+        return success({"id": result.id, "username": result.username})
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST, detail=str(e)
+        )
+
+
+@router.post(
+    "/login",
+    summary="Login and get access token",
+    responses={
+        **common_error,
+        200: {
+            "model": TokenResponseSchema,
+            "description": "Login successful",
+        },
+        401: {"description": "Invalid username or password"},
+    },
+)
+def login(
+    req: LoginSchema,
+    auth_use_case: AuthUseCase = Depends(get_auth_use_case),
+):
+    try:
+        result = auth_use_case.login(
+            LoginRequest(username=req.username, password=req.password)
+        )
+        return success(
+            {"access_token": result.access_token, "token_type": "bearer"}
+        )
+    except ValueError as e:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail=str(e)
+        )

app/presentation/routers/students.py

@@ -0,0 +1,107 @@
+from fastapi import APIRouter, Depends, HTTPException, Query, UploadFile, status, Path
+from sqlalchemy.orm import Session
+
+from app.db.session import get_db
+from app.presentation.dependencies import get_current_user
+from app.presentation.schemas.response import (
+    StudentResponseSchema,
+    common_error,
+    success,
+)
+from app.presentation.schemas.student import (
+    SubmissionRequest,
+)
+from app.application.use_cases import student_use_case
+
+router = APIRouter(prefix="/api/students", tags=["students"])
+
+# --- Public endpoints (no auth) ---
+
+
+@router.get(
+    "/nrp/{nrp}",
+    summary="Resolve NRP to name & major (public)",
+    responses={
+        200: {"description": "NRP data resolved"},
+        404: {"description": "NRP not found"},
+    },
+)
+def resolve_nrp(nrp: str, db: Session = Depends(get_db)):
+    data = student_use_case.resolve_nrp_data(nrp, db)
+    if data["name"] == "Unknown":
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="NRP not found")
+    return success(data)
+
+
+@router.post(
+    "/upload-photo",
+    summary="Upload photo (public)",
+    responses={
+        200: {"description": "Photo uploaded"},
+    },
+)
+def upload_photo(file: UploadFile):
+    url = student_use_case.save_photo(file)
+    return success({"photo_url": url})
+
+
+# --- Protected endpoints (auth required) ---
+
+
+@router.post(
+    "/submissions",
+    status_code=201,
+    summary="Submit complete student profile",
+    responses={
+        201: {"model": StudentResponseSchema, "description": "Submission created"},
+        400: {"description": "Invalid data"},
+    },
+)
+def submit_profile(
+    data: SubmissionRequest,
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_current_user),
+):
+    student = student_use_case.create_submission(db, user_id, data)
+    return success(student)
+
+
+@router.get(
+    "",
+    summary="List own submissions or search by NRP",
+    responses={
+        **common_error,
+        200: {
+            "model": StudentResponseSchema,
+            "description": "List of submissions",
+        },
+    },
+)
+def list_students(
+    nrp: str | None = Query(
+        None, description="Search own submissions by NRP (partial match)"
+    ),
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_current_user),
+):
+    if nrp:
+        return success(student_use_case.search_students_by_nrp(db, user_id, nrp))
+    return success(student_use_case.get_students(db, user_id))
+
+
+@router.get(
+    "/roster",
+    summary="Get full roster (NRP map + submission status) with pagination",
+)
+def get_roster(
+    page: int = Query(1, ge=1, description="Page number"),
+    per_page: int = Query(20, ge=1, le=100, description="Items per page"),
+    search: str = Query("", description="Search by NRP or name"),
+    major: str = Query("", description="Filter by major (exact match)"),
+    status: str = Query("", description='Filter by submission status: "submitted", "pending", or empty for all'),
+    all: bool = Query(False, description="Return all matching entries without pagination"),
+    db: Session = Depends(get_db),
+    user_id: str = Depends(get_current_user),
+):
+    data = student_use_case.get_roster(db, user_id, page, per_page, search, major, status, all_=all)
+    return success(data)

app/presentation/schemas/auth.py

@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class RegisterRequest(BaseModel):
+    username: str
+    password: str
+
+
+class UserResponse(BaseModel):
+    id: str
+    username: str

app/presentation/schemas/response.py

@@ -0,0 +1,100 @@
+import uuid
+from datetime import datetime, timezone
+
+from pydantic import BaseModel
+
+from app.presentation.schemas.auth import TokenResponse, UserResponse
+from app.presentation.schemas.student import StudentResponse
+
+
+def _request_id() -> str:
+    return "req_" + uuid.uuid4().hex[:8]
+
+
+def _timestamp() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def success(data):
+    return {
+        "success": True,
+        "data": data,
+        "meta": {"request_id": _request_id(), "timestamp": _timestamp()},
+    }
+
+
+def error(detail: str, status_code: int = 400):
+    return {
+        "success": False,
+        "data": {"detail": detail, "status_code": status_code},
+        "meta": {"request_id": _request_id(), "timestamp": _timestamp()},
+    }
+
+
+# --- OpenAPI documentation models ---
+
+
+class Meta(BaseModel):
+    request_id: str
+    timestamp: str
+
+
+class StudentResponseSchema(BaseModel):
+    success: bool = True
+    data: StudentResponse
+    meta: Meta
+
+
+class StudentListResponseSchema(BaseModel):
+    success: bool = True
+    data: list[StudentResponse]
+    meta: Meta
+
+
+class MessageData(BaseModel):
+    message: str
+
+
+class MessageResponseSchema(BaseModel):
+    success: bool = True
+    data: MessageData
+    meta: Meta
+
+
+class TokenData(TokenResponse):
+    pass
+
+
+class TokenResponseSchema(BaseModel):
+    success: bool = True
+    data: TokenData
+    meta: Meta
+
+
+class UserData(BaseModel):
+    id: str
+    username: str
+
+
+class UserResponseSchema(BaseModel):
+    success: bool = True
+    data: UserData
+    meta: Meta
+
+
+class ErrorDetail(BaseModel):
+    detail: str
+    status_code: int
+
+
+class ErrorResponseSchema(BaseModel):
+    success: bool = False
+    data: ErrorDetail
+    meta: Meta
+
+
+common_error = {
+    401: {"model": ErrorResponseSchema, "description": "Unauthorized"},
+    422: {"model": ErrorResponseSchema, "description": "Validation Error"},
+    500: {"model": ErrorResponseSchema, "description": "Internal Server Error"},
+}

app/presentation/schemas/student.py

@@ -0,0 +1,46 @@
+from datetime import datetime
+
+from pydantic import BaseModel
+
+
+class StudentCreate(BaseModel):
+    nrp: str
+
+
+class StudentUpdate(BaseModel):
+    hometown: str | None = None
+    hobbies: str | None = None
+    first_impression: str | None = None
+    photo_url: str | None = None
+    longitude: float | None = None
+    latitude: float | None = None
+    captured_at: datetime | None = None
+
+
+class SubmissionRequest(BaseModel):
+    nrp: str
+    asal_daerah: str
+    hobi: list[str]
+    first_impression: str
+    longitude: float
+    latitude: float
+    captured_at: datetime
+    photo_url: str
+
+
+class StudentResponse(BaseModel):
+    id: str
+    nrp: str
+    name: str | None = None
+    major: str | None = None
+    hometown: str | None = None
+    hobbies: str | None = None
+    first_impression: str | None = None
+    photo_url: str | None = None
+    longitude: float | None = None
+    latitude: float | None = None
+    captured_at: datetime | None = None
+    created_at: datetime
+    updated_at: datetime
+
+    model_config = {"from_attributes": True}

migrate.py

@@ -0,0 +1,52 @@
+"""Add missing columns to students table and drop nrp unique constraint."""
+from sqlalchemy import inspect, text
+from app.db.session import engine
+
+
+def run():
+    inspector = inspect(engine)
+    existing_cols = {c["name"] for c in inspector.get_columns("students")}
+    indexes = inspector.get_indexes("students")
+    dialect = engine.dialect.name
+    added = []
+
+    with engine.connect() as conn:
+        if "longitude" not in existing_cols:
+            t = "FLOAT" if dialect == "sqlite" else "DOUBLE PRECISION"
+            conn.execute(text(f"ALTER TABLE students ADD COLUMN longitude {t}"))
+            added.append("longitude")
+
+        if "latitude" not in existing_cols:
+            t = "FLOAT" if dialect == "sqlite" else "DOUBLE PRECISION"
+            conn.execute(text(f"ALTER TABLE students ADD COLUMN latitude {t}"))
+            added.append("latitude")
+
+        if "captured_at" not in existing_cols:
+            t = "DATETIME" if dialect == "sqlite" else "TIMESTAMP"
+            conn.execute(text(f"ALTER TABLE students ADD COLUMN captured_at {t}"))
+            added.append("captured_at")
+
+        if "user_id" not in existing_cols:
+            if dialect == "sqlite":
+                conn.execute(text("ALTER TABLE students ADD COLUMN user_id VARCHAR"))
+            else:
+                conn.execute(text("ALTER TABLE students ADD COLUMN user_id VARCHAR REFERENCES users(id)"))
+            added.append("user_id")
+
+        # Drop unique index on nrp (now scoped by user_id)
+        for idx in indexes:
+            if idx["name"] == "ix_students_nrp" and idx.get("unique"):
+                conn.execute(text("DROP INDEX ix_students_nrp"))
+                print("  Dropped unique index on nrp")
+                break
+
+        conn.commit()
+
+    if added:
+        print(f"✓ Added columns to {dialect}: {', '.join(added)}")
+    else:
+        print(f"✓ All columns already exist ({dialect}). Nothing to do.")
+
+
+if __name__ == "__main__":
+    run()

pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "bukang-api"
+version = "0.1.0"
+description = "Backend API for Bukang - Student Profile Collection"
+requires-python = ">=3.11"
+dependencies = [
+    "fastapi>=0.115.0",
+    "uvicorn[standard]>=0.34.0",
+    "sqlalchemy>=2.0.0",
+    "pydantic-settings>=2.7.0",
+    "python-jose[cryptography]>=3.3.0",
+    "passlib[bcrypt]>=1.7.4",
+    "python-multipart>=0.0.18",
+    "psycopg2-binary>=2.9.0",
+    "huggingface_hub>=0.27.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "httpx>=0.28.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

requirements.txt

@@ -0,0 +1,11 @@
+fastapi>=0.115.0
+uvicorn[standard]>=0.34.0
+sqlalchemy>=2.0.0
+pydantic-settings>=2.7.0
+python-jose[cryptography]>=3.3.0
+passlib[bcrypt]>=1.7.4
+python-multipart>=0.0.18
+psycopg2-binary>=2.9.0
+huggingface_hub>=0.27.0
+pytest>=8.0.0
+httpx>=0.28.0