src/controllers/adminController.py

+# src/controllers/adminController.py
+
+import sys
+import os
+import sqlite3
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from controllers.controller import Controller
+from models.admin import Admin
+
+class AdminController(Controller):
+    def update_data_admin(self, admin):
+        try:
+            self.cursor.execute("UPDATE Admin SET nama=?, password=?, noTelp=? WHERE surel=?", 
+                                (admin['nama_admin'], admin['password'], admin['noTelp'], admin['surel']))
+            self.commit()
+            return "Nama admin berhasil diperbarui."
+        except sqlite3.DatabaseError as e:
+            return f"Nama admin tidak berhasil diperbarui: {e}"
+
+    def get_data_admin(self):
+        """Retrieve the admin data from the database and return it as an Admin object."""
+        try:
+            self.cursor.execute("SELECT surel, nama, password, noTelp FROM Admin")
+            admin_row = self.cursor.fetchone()
+            return Admin.from_row(admin_row) if admin_row else None
+        except sqlite3.DatabaseError as e:
+            return f"Error retrieving admin data: {e}"
+
+    def validate_data_admin(self, input_surel, input_password):
+        try:
+            admin = self.get_data_admin()
+            return admin.surel == input_surel and admin.password == input_password
+        except AttributeError:
+            return False
+        except sqlite3.DatabaseError as e:
+            return f"Error validating admin data: {e}"

src/controllers/barangController.py

+# src/controllers/barangController.py
+
+import sys
+import os
+import sqlite3
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from controllers.controller import Controller
+from models.barang import Barang
+
+class BarangController(Controller):
+    def add_barang(self, barang):
+        """Add new barang data to the warehouse."""
+        try:
+            self.cursor.execute(
+                "INSERT INTO barang (id_warehouse, id_barang, nama_barang, deskripsi_barang, stok, foto, status_pengiriman) VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (barang['id_warehouse'], barang['id_barang'], barang['nama_barang'], barang['deskripsi_barang'], barang['stok'], barang['foto'], barang['status_pengiriman'])
+            )
+            self.commit()
+            return "Barang berhasil ditambahkan."
+        except sqlite3.DatabaseError as e:
+            return f"Barang tidak berhasil ditambahkan: {e}"
+
+    def update_barang(self, barang):
+        """Update data barang for a certain data."""
+        try:
+            self.cursor.execute(
+                """UPDATE barang SET nama_barang=?, deskripsi_barang=?, stok=?, foto=?, status_pengiriman=?
+                WHERE id_warehouse=? AND id_barang=?""",
+                (barang['nama_barang'], barang['deskripsi_barang'], barang['stok'], barang['foto'], barang['status_pengiriman'], barang['id_warehouse'], barang['id_barang'])
+            )
+            self.commit()
+            return "Barang berhasil diperbarui."
+        except sqlite3.DatabaseError as e:
+            return f"Barang tidak berhasil diperbarui: {e}"
+
+    def search_barang(self, input_nama_barang):
+        """Find all barang in the warehouse that match the input given."""
+        try:
+            self.cursor.execute("SELECT * FROM barang WHERE nama_barang LIKE ?", (input_nama_barang + '%',))
+            searched_barang = self.cursor.fetchall()
+            return [Barang.from_row(row) for row in searched_barang] if searched_barang else []
+        except sqlite3.DatabaseError as e:
+            return f"Error searching barang: {e}"
+
+    def delete_barang(self, id_warehouse, id_barang):
+        """Delete a certain barang."""
+        try:
+            self.cursor.execute("DELETE FROM barang WHERE id_barang=? AND id_warehouse=?", (id_barang, id_warehouse))
+            self.commit()
+            return "Barang berhasil dihapus."
+        except sqlite3.DatabaseError as e:
+            return f"Barang tidak berhasil dihapus: {e}"
+
+    def get_all_barang(self, id_warehouse):
+        """Get all list barang in the warehouse."""
+        try:
+            self.cursor.execute("SELECT * FROM barang WHERE id_warehouse=?", (id_warehouse,))
+            all_barang = self.cursor.fetchall()
+            return [Barang.from_row(row) for row in all_barang] if all_barang else []
+        except sqlite3.DatabaseError as e:
+            return f"Error retrieving all barang: {e}"
+
+    def get_barang_info(self, id_warehouse, id_barang):
+        """Get detailed info for a barang."""
+        try:
+            self.cursor.execute("SELECT * FROM barang WHERE id_barang=? AND id_warehouse=?", (id_barang, id_warehouse))
+            barang_detail = self.cursor.fetchone()
+            return Barang.from_row(barang_detail) if barang_detail else None
+        except sqlite3.DatabaseError as e:
+            return f"Error retrieving barang details: {e}"
+
+    def move_barang(self, id_barang, id_warehouse, id_warehouse_tujuan):
+        """Move one barang to another warehouse."""
+        try:
+            # Determine current available capacity in desired warehouse
+            self.cursor.execute("SELECT kapasitas_terkini, kapasitas_maksimum FROM warehouse WHERE id_warehouse = ?", (id_warehouse_tujuan,))
+            warehouse_capacity_info = self.cursor.fetchone()
+            if warehouse_capacity_info:
+                current_capacity, max_capacity = warehouse_capacity_info
+                available_capacity = max_capacity - current_capacity
+
+                # Getting the quantity of barang
+                self.cursor.execute("SELECT stok FROM barang WHERE id_warehouse = ? AND id_barang = ?", (id_warehouse, id_barang))
+                stok = self.cursor.fetchone()
+
+                if stok:
+                    stok_barang = stok[0]
+                    if available_capacity >= stok_barang:
+                        # Move the barang and update status_pengiriman
+                        self.cursor.execute("UPDATE barang SET id_warehouse=?, status_pengiriman='Dalam Pengiriman' WHERE id_barang=? AND id_warehouse=?", (id_warehouse_tujuan, id_barang, id_warehouse))
+                        self.commit()
+                        return "Barang berhasil dipindahkan."
+                    else:
+                        return f"Barang tidak berhasil dipindahkan: Tidak cukup kapasitas di warehouse {id_warehouse_tujuan}"
+                else:
+                    return f"Barang tidak berhasil dipindahkan: Barang dengan id_barang={id_barang} tidak ditemukan di warehouse {id_warehouse}"
+            else:
+                return f"Barang tidak berhasil dipindahkan: Warehouse dengan id_warehouse={id_warehouse_tujuan} tidak ditemukan"
+        except sqlite3.DatabaseError as e:
+            return f"Barang tidak berhasil dipindahkan: {e}"
+
+    def move_all_barang(self, id_warehouse, id_warehouse_tujuan):
+        """Move all barang in a warehouse to another warehouse."""
+        try:
+            # Determine current available capacity in desired warehouse
+            self.cursor.execute("SELECT kapasitas_terkini, kapasitas_maksimum FROM warehouse WHERE id_warehouse = ?", (id_warehouse_tujuan,))
+            warehouse_capacity_info = self.cursor.fetchone()
+            if warehouse_capacity_info:
+                current_capacity, max_capacity = warehouse_capacity_info
+                available_capacity = max_capacity - current_capacity
+
+                # Getting the quantity of barang
+                self.cursor.execute("SELECT SUM(stok) FROM barang WHERE id_warehouse = %?", (id_warehouse))
+                stok = self.cursor.fetchone()
+
+                if stok:
+                    stok_all_barang = stok[0]
+                    if available_capacity >= stok_all_barang:
+                        # Move the barang and update status_pengiriman
+                        self.cursor.execute("UPDATE barang SET id_warehouse=?, status_pengiriman='Dalam Pengiriman' WHERE id_barang=? AND id_warehouse=?", (id_warehouse_tujuan, id_barang, id_warehouse))
+                        self.commit()
+                        return "Barang berhasil dipindahkan."
+                    else:
+                        return f"Barang tidak berhasil dipindahkan: Tidak cukup kapasitas di warehouse {id_warehouse_tujuan}"
+                else:
+                    return f"Barang tidak berhasil dipindahkan: Barang dengan id_barang={id_barang} tidak ditemukan di warehouse {id_warehouse}"
+            else:
+                return f"Barang tidak berhasil dipindahkan: Warehouse dengan id_warehouse={id_warehouse_tujuan} tidak ditemukan"
+        except sqlite3.DatabaseError as e:
+            return f"Barang tidak berhasil dipindahkan: {e}"

src/controllers/controller.py

+import sqlite3
+
+class Controller:
+    def __init__(self, db_name):
+        """Controller class constructor, connects instance to specified db_name"""
+        self.conn = sqlite3.connect(db_name)
+        self.cursor = self.conn.cursor()
+        self.cursor.execute("PRAGMA foreign_keys = 1")
+
+    def commit(self):
+        """Commit the current transaction."""
+        self.conn.commit()
+
+    def __del__(self):
+        """Ensure the database connection is closed when the object is destroyed."""
+        if self.conn:
+            self.conn.close()

src/controllers/warehouseController.py

+import sys
+import os
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from controllers.controller import *
+from models.warehouse import *
+class WarehouseController(Controller):
+    def add_warehouse(self, warehouse):
+        """Add new warehouse."""
+        try:
+            self.cursor.execute("INSERT INTO warehouse (nama_warehouse, kapasitas_maksimum, alamat, kapasitas_terkini) VALUES (?, ?, ?, ?)",
+                                (warehouse['nama_warehouse'], warehouse['kapasitas_maksimum'], warehouse['alamat'], 0))
+            self.commit()
+            return "Warehouse berhasil ditambahkan."
+        except sqlite3.DatabaseError as e:
+            return f"Warehouse tidak berhasil ditambahkan: {e}"
+
+    def delete_warehouse(self, id_warehouse):
+        """Delete a certain warehouse."""
+        try:
+            self.cursor.execute("DELETE FROM warehouse WHERE id_warehouse=?", (id_warehouse,))
+            self.commit()
+            return "Warehouse berhasil dihapus."
+        except sqlite3.DatabaseError as e:
+            return f"Warehouse tidak berhasil dihapus: {e}"
+
+    def update_warehouse(self, warehouse):
+        """Update a certain warehouse data."""
+        try:
+            self.cursor.execute("UPDATE warehouse SET nama_warehouse=?, kapasitas_maksimum=?, alamat=? WHERE id_warehouse=?",
+                                (warehouse['nama_warehouse'], warehouse['kapasitas_maksimum'], warehouse['alamat'], warehouse['id_warehouse']))
+            self.commit()
+            return "Warehouse berhasil diperbarui."
+        except sqlite3.DatabaseError as e:
+            return f"Warehouse tidak berhasil diperbarui: {e}"
+
+    def search_warehouse(self, input_nama_warehouse):
+        """Finding all warehouses that match the input given."""
+        try:
+            self.cursor.execute("SELECT * FROM warehouse WHERE nama_warehouse LIKE ?", (input_nama_warehouse + '%',))
+            searched_warehouse = self.cursor.fetchall()
+            return [Warehouse.from_row(row) for row in searched_warehouse] if searched_warehouse else []
+        except sqlite3.DatabaseError as e:
+            return f"Error searching warehouse: {e}"
+
+    def get_all_warehouses(self):
+        """Get all list warehouse in the database."""
+        try:
+            self.cursor.execute("SELECT * FROM warehouse")
+            all_warehouse = self.cursor.fetchall()
+            return [Warehouse.from_row(row) for row in all_warehouse] if all_warehouse else []
+        except sqlite3.DatabaseError as e:
+            return f"Error retrieving all warehouses: {e}"
+
+    def get_warehouse_info(self, id_warehouse):
+        """Get detail info for a warehouse."""
+        try:
+            self.cursor.execute("SELECT * FROM warehouse WHERE id_warehouse=?", (id_warehouse,))
+            warehouse_detail = self.cursor.fetchone()
+            return Warehouse.from_row(warehouse_detail) if warehouse_detail else None
+        except sqlite3.DatabaseError as e:
+            return f"Error retrieving warehouse details: {e}"

src/database/seed.py

+from faker import Faker
+import sqlite3
+import random
+import logging
+import os
+import sys
+# from controller.controller import *
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+if __name__ == "__main__":
+    if not os.path.exists("src/database/warehosea.db"):
+
+        # Connect to SQLite database
+        connection = sqlite3.connect('warehosea.db')
+
+        # Create cursor
+        cursor = connection.cursor()
+        fake = Faker('id_ID')
+
+        cursor.execute("""
+        CREATE TABLE Admin (
+            surel VARCHAR(255) PRIMARY KEY,
+            nama VARCHAR(255) NOT NULL,
+            password VARCHAR(255) NOT NULL,
+            noTelp VARCHAR(20) NOT NULL
+        );
+        """)
+
+        cursor.execute("""
+        INSERT INTO Admin (surel, nama, password, noTelp) 
+        VALUES ('hoseaganteng@gmail.com', 'Hosea', 'gantengtapiboong', '6285712345678');
+        """)
+
+        create_warehouse_table_query = """
+        CREATE TABLE IF NOT EXISTS warehouse (
+            id_warehouse INTEGER PRIMARY KEY AUTOINCREMENT, 
+            nama_warehouse TEXT NOT NULL,
+            kapasitas_maksimum INTEGER,
+            kapasitas_terkini INTEGER NOT NULL,
+            alamat TEXT NOT NULL
+        );
+        """
+        cursor.execute(create_warehouse_table_query)
+
+        seed_data_warehouse_query = """
+        INSERT INTO warehouse (nama_warehouse, kapasitas_maksimum, kapasitas_terkini, alamat) 
+        VALUES 
+        ('Warehouse Dianti', 2000, 0, 'Jl. Gatot Subroto No. 34, RT 08 RW 04, Kel. Mulyoharjo, Kec. Semarang Tengah, Kota Semarang, Jawa Tengah 50184'),
+        ('Warehouse Licia', 1500, 0, 'Jl. Panglima Sudirman No. 90, RT 04 RW 07, Kel. Kebayoran Baru, Kec. Kebayoran Baru, Kota Jakarta Selatan, DKI Jakarta 12110'),
+        ('Warehouse Adrea', 1800, 0, 'Jl. Surya Sumantri No. 123, RT 05 RW 08, Kel. Sukajadi, Kec. Cibeunying Kaler, Kota Bandung, Jawa Barat 40161'),
+        ('Warehouse Radina', 1200, 0, 'Jl. Dr. Sutomo No. 56, RT 09 RW 02, Kel. Simpang Raya, Kec. Pekanbaru Kota, Kota Pekanbaru, Riau 28131'),
+        ('Warehouse Jawas', 2000, 0, 'Jl. Gunung Merapi No. 45, RT 07 RW 03, Kel. Tanah Abang, Kec. Menteng, Kota Jakarta Pusat, DKI Jakarta 10220'),
+        ('Warehouse Azkira', 1000, 0, 'Jl. Diponegoro No. 78, RT 12 RW 05, Kel. Gajah Mada, Kec. Pontianak Kota, Kota Pontianak, Kalimantan Barat 78121');
+        """
+        cursor.executescript(seed_data_warehouse_query)
+
+        create_barang_table_query = """
+        CREATE TABLE IF NOT EXISTS barang (
+            id_warehouse INTEGER,
+            id_barang INTEGER,
+            nama_barang TEXT NOT NULL,
+            deskripsi_barang TEXT,
+            stok INTEGER NOT NULL,
+            foto BLOB,
+            status_pengiriman TEXT CHECK(status_pengiriman IN ('Dalam Pengiriman', 'Berada di Warehouse')),
+            PRIMARY KEY (id_warehouse, id_barang),
+            FOREIGN KEY (id_warehouse) REFERENCES warehouse(id_warehouse)
+        );
+        """
+        cursor.execute(create_barang_table_query)
+
+
+        # Creating triggers
+        cursor.execute("""
+        CREATE TRIGGER update_capacity_after_insert
+        AFTER INSERT ON barang
+        FOR EACH ROW
+        BEGIN
+            UPDATE warehouse
+            SET kapasitas_terkini = kapasitas_terkini + NEW.stok
+            WHERE id_warehouse = NEW.id_warehouse;
+        END;
+        """)
+
+        cursor.execute("""
+        CREATE TRIGGER update_capacity_after_delete
+        AFTER DELETE ON barang
+        FOR EACH ROW
+        BEGIN
+            UPDATE warehouse
+            SET kapasitas_terkini = kapasitas_terkini - OLD.stok
+            WHERE id_warehouse = OLD.id_warehouse;
+        END;
+        """)
+
+        cursor.execute("""
+        CREATE TRIGGER update_capacity_on_status_change
+        AFTER UPDATE ON barang
+        FOR EACH ROW
+        BEGIN
+            UPDATE warehouse
+            SET kapasitas_terkini = CASE
+                WHEN NEW.status_pengiriman = 'Dalam Pengiriman' AND OLD.status_pengiriman = 'Berada di Warehouse' THEN kapasitas_terkini - OLD.stok
+                WHEN NEW.status_pengiriman = 'Berada di Warehouse' AND OLD.status_pengiriman = 'Dalam Pengiriman' THEN kapasitas_terkini + NEW.stok
+                ELSE kapasitas_terkini
+            END
+            WHERE id_warehouse = CASE
+                WHEN NEW.status_pengiriman = 'Dalam Pengiriman' AND OLD.status_pengiriman = 'Berada di Warehouse' THEN OLD.id_warehouse
+                WHEN NEW.status_pengiriman = 'Berada di Warehouse' AND OLD.status_pengiriman = 'Dalam Pengiriman' THEN NEW.id_warehouse
+                ELSE id_warehouse
+            END;
+        END;
+        """)
+
+        barang = {
+            "Sabun Mandi": "Sabun mandi dengan aroma segar untuk membersihkan tubuh Anda setiap hari.",
+            "Sampo Clear": "Sampo anti-ketombe yang efektif membersihkan dan menyegarkan kulit kepala Anda.",
+            "Odol Pepsodent": "Pasta gigi yang membantu melindungi gigi dan gusi dari kerusakan.",
+            "Beras Cap Raja": "Beras berkualitas tinggi yang cocok untuk membuat nasi lezat dan gurih.",
+            "Minyak Goreng Filma": "Minyak goreng yang sehat dan berkualitas untuk memasak makanan kesukaan Anda.",
+            "Kecap ABC": "Kecap manis yang memberikan cita rasa gurih pada masakan Indonesia.",
+            "Gula Pasir": "Gula pasir halus yang digunakan untuk membuat makanan dan minuman menjadi lebih manis.",
+            "Teh Sariwangi": "Teh hitam berkualitas tinggi dengan cita rasa yang khas dan harum.",
+            "Kopi Kapal Api": "Kopi bubuk yang memiliki aroma dan rasa yang khas, cocok untuk dinikmati setiap pagi.",
+            "Mie Indomie": "Mie instan dengan berbagai varian rasa yang praktis dan lezat.",
+            "Susu Bendera": "Susu segar yang kaya akan nutrisi untuk menjaga kesehatan tubuh Anda.",
+            "Minuman Teh Botol Sosro": "Minuman teh botol yang menyegarkan dengan rasa teh yang alami.",
+            "Kacang Garuda": "Kacang renyah yang diolah dengan kualitas terbaik untuk camilan sehari-hari.",
+            "Biskuit Roma": "Biskuit renyah yang cocok dinikmati sebagai camilan santai bersama keluarga.",
+            "Saus Tomat ABC": "Saus tomat yang lezat dan kaya akan rasa untuk menyempurnakan hidangan Anda.",
+            "Sirup Marjan": "Sirup dengan berbagai varian rasa yang cocok untuk membuat minuman segar.",
+            "Roti Sari Roti": "Roti tawar yang lembut dan enak, cocok untuk membuat sarapan yang bergizi.",
+            "Makanan Kucing Whiskas": "Makanan kucing yang diformulasikan khusus untuk menjaga kesehatan kucing kesayangan Anda.",
+            "Mie Goreng Merk ABC": "Mie instan yang mudah dan praktis untuk disajikan sebagai makanan ringan.",
+            "Minyak Kayu Putih Cap Lang": "Minyak kayu putih yang berkualitas untuk membantu meredakan pilek dan nyeri otot.",
+            "Madu Cap Kupu-kupu": "Madu murni yang kaya akan manfaat untuk menjaga kesehatan tubuh dan meningkatkan daya tahan tubuh.",
+            "Permen Mentos": "Permen segar dengan rasa yang bervariasi, cocok untuk menyegarkan napas Anda setiap saat.",
+            "Kopi Torabika": "Kopi instan yang memiliki rasa khas dan aromanya yang menggugah selera.",
+            "Gula Aren": "Gula alami yang dihasilkan dari pohon aren untuk menambahkan rasa manis pada makanan dan minuman Anda.",
+            "Sari Roti Coklat": "Roti coklat lembut yang cocok untuk dinikmati sebagai camilan atau sarapan.",
+            "Mie Sedaap": "Mie instan dengan rasa yang lezat dan bumbu yang khas, membuatnya menjadi pilihan favorit.",
+            "Minyak Zaitun": "Minyak zaitun yang kaya akan antioksidan dan baik untuk kesehatan jantung.",
+            "Susu Kental Manis Frisian Flag": "Susu kental manis yang nikmat untuk dicampurkan ke minuman atau makanan favorit Anda.",
+            "Roti Tawar Gardenia": "Roti tawar yang lembut dan segar, cocok untuk membuat sandwich atau dimakan dengan selai.",
+            "Teh Celup Sariwangi": "Teh celup berkualitas tinggi yang praktis disajikan, cocok untuk menemani waktu santai Anda.",
+            "Minuman Energi Kratingdaeng": "Minuman energi yang menyegarkan dengan kandungan bahan aktif yang dapat meningkatkan energi Anda.",
+            "Mie Telur Merk Miura": "Mie instan dengan tambahan telur yang memberikan rasa lezat dan gizi yang seimbang.",
+            "Permen Gula-gula": "Permen berbagai rasa yang cocok untuk dinikmati sebagai camilan di waktu luang.",
+            "Sirup ABC": "Sirup yang dapat dicampurkan dengan air untuk membuat minuman segar yang menyehatkan.",
+            "Makanan Anjing Pedigree": "Makanan anjing dengan kandungan nutrisi yang lengkap untuk menjaga kesehatan dan kebahagiaan anjing Anda.",
+            "Kacang Garuda": "Kacang panggang yang gurih dan renyah, cocok untuk dinikmati sebagai camilan sehari-hari.",
+            "Permen Coklat Beng-beng": "Permen coklat dengan lapisan wafer yang lezat, cocok untuk memuaskan keinginan ngemil Anda.",
+            "Kecap Manis Bango": "Kecap manis dengan rasa yang khas dan aroma yang menggugah selera.",
+            "Biskuit Better": "Biskuit yang mengandung gandum utuh dan serat untuk makanan ringan yang sehat dan lezat.",
+            "Teh Botol Sosro": "Minuman teh siap saji yang menyegarkan dengan rasa teh yang alami.",
+            "Permen Jelly Belly": "Permen jelly berbagai rasa yang cocok untuk dinikmati sebagai camilan di waktu luang.",
+            "Mie Instant Sarimi": "Mie instan dengan bumbu khas Indonesia yang lezat dan praktis disajikan.",
+            "Minyak Goreng Sania": "Minyak goreng yang sehat dan berkualitas tinggi untuk memasak masakan lezat dan sehat.",
+            "Teh Celup Tong Tji": "Teh celup dengan kualitas terbaik yang memberikan sensasi rasa dan aroma yang menyegarkan.",
+            "Susu Bubuk Bear Brand": "Susu bubuk dengan kandungan nutrisi yang lengkap"
+        }
+
+        # Fungsi untuk menghasilkan 5 digit number character random unique
+        def generate_unique_key(existing_keys):
+            while True:
+                key = fake.unique.random_number(digits=5)
+                if key not in existing_keys:
+                    return str(key)
+
+        # Iterasi terhadap seluruh elemen pada map barang
+        map_id_barang = {}
+        existing_keys = set()
+        for nama_barang, deskripsi_barang in barang.items():
+            key = generate_unique_key(existing_keys)
+            map_id_barang[key] = nama_barang
+            existing_keys.add(key)
+
+
+        # Use correct placeholders and manage database operations safely
+        try:
+                # Fetch existing warehouse IDs from the database
+            # cursor.execute("SELECT id_warehouse FROM warehouse")
+            # warehouse_ids = [row[0] for row in cursor.fetchall()]
+
+            # Use these warehouse IDs when inserting items
+            for _ in range(200):
+                try:
+                    id_barang = random.choice(list(map_id_barang.keys()))
+                    nama_barang = map_id_barang[id_barang]
+                    deskripsi_barang = barang[nama_barang]
+                    stok = random.randint(1, 80)
+                    status_pengiriman = fake.random_element(elements=('Dalam Pengiriman', 'Berada di Warehouse'))
+
+                    sql = "INSERT INTO barang (id_warehouse, id_barang, nama_barang, deskripsi_barang, stok, status_pengiriman) VALUES (?, ?, ?, ?, ?, ?)"
+                    val = (random.randint(1,6), id_barang, nama_barang, deskripsi_barang, stok, status_pengiriman)
+                    cursor.execute(sql, val)
+                    connection.commit()
+                except sqlite3.IntegrityError as e:
+                    logging.error(f"Failed to insert item {id_barang}: {e}")
+                except Exception as e:
+                    logging.error(f"An error occurred while inserting item {id_barang}: {e}")
+        except Exception as e:
+            logging.error(f"An error occurred during setup: {e}")
+        finally:
+            cursor.close()
+            connection.close()
+            logging.info("Database connection closed.")
+    else:
+        print("gamsauk")
\ No newline at end of file

src/models/admin.py

+from models.model import *
+class Admin(Model):
+    def __init__(self, surel, nama_admin, password, noTelp):
+        self.surel = surel
+        self.nama_admin = nama_admin
+        self.password = password
+        self.noTelp = noTelp
\ No newline at end of file

src/models/barang.py

+from models.model import *
+class Barang(Model):
+    def __init__(self, id_warehouse, id_barang, nama_barang, deskripsi_barang, stok, pathFoto, status_pengiriman):
+        self.id_warehouse = id_warehouse
+        self.id_barang = id_barang
+        self.nama_barang = nama_barang
+        self.deskripsi_barang = deskripsi_barang
+        self.stok = stok
+        self.status_pengiriman = status_pengiriman
+        self.foto = pathFoto
\ No newline at end of file

src/models/model.py

+class Model:
+    @classmethod
+    def from_row(cls, row):
+        return cls(*row)
\ No newline at end of file

src/models/warehouse.py

+from models.model import *
+class Warehouse(Model):
+    def __init__(self, id_warehouse, nama_warehouse, kapasitas_maksimum, kapasitas_terkini, alamat):
+        self.id_warehouse = id_warehouse
+        self.nama_warehouse = nama_warehouse
+        self.kapasitas_maksimum = kapasitas_maksimum
+        self.kapasitas_terkini = kapasitas_terkini
+        self.alamat = alamat
\ No newline at end of file

test/test_admin_controller.py

+# tests/test_admin_controller.py
+
+import sys
+import os
+import pytest
+
+# Change path directory to src
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(root_dir + '/src')
+
+from controllers.adminController import AdminController
+from models.admin import Admin
+
+@pytest.fixture(scope="module")
+def controller():
+    # Create a new controller instance for the tests
+    return AdminController("src/database/warehosea.db")
+
+def test_update_data_admin(controller):
+    admin = Admin(
+        surel="hoseaganteng@gmail.com",
+        nama_admin="Updated Admin",
+        password="securepassword",
+        noTelp="1234567890"
+    )
+    result = controller.update_data_admin(admin.__dict__)
+    assert result == "Nama admin berhasil diperbarui."
+    updated_admin = controller.get_data_admin()
+    assert updated_admin.nama_admin == "Updated Admin"
+    assert updated_admin.password == "securepassword"
+    assert updated_admin.noTelp == "1234567890"
+
+def test_get_data_admin(controller):
+    admin = controller.get_data_admin()
+    assert admin is not None
+    assert admin.surel == "hoseaganteng@gmail.com"
+    assert admin.nama_admin == "Updated Admin"
+    assert admin.password == "securepassword"
+    assert admin.noTelp == "1234567890"
+
+def test_validate_data_admin(controller):
+    input_surel = "hoseaganteng@gmail.com"
+    input_password = "securepassword"
+    is_valid = controller.validate_data_admin(input_surel, input_password)
+    assert is_valid is True
+
+    input_surel = "hoseaganteng@gmail.com"
+    input_password = "wrongpassword"
+    is_valid = controller.validate_data_admin(input_surel, input_password)
+    assert is_valid is False
+
+# Run the test
+if __name__ == "__main__":
+    pytest.main()

test/test_admin_model.py

+# tests/test_admin_model.py
+
+import sys
+import os
+import pytest
+
+# Change path directory to src
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(root_dir + '/src')
+
+from models.admin import Admin
+
+def test_admin_model():
+    surel = "admin@example.com"
+    nama_admin = "Admin Name"
+    password = "securepassword"
+    noTelp = "1234567890"
+
+    admin = Admin(surel, nama_admin, password, noTelp)
+
+    assert admin.surel == surel
+    assert admin.nama_admin == nama_admin
+    assert admin.password == password
+    assert admin.noTelp == noTelp
+
+# Run the test
+if __name__ == "__main__":
+    pytest.main()

test/test_barang_controller.py

+# tests/test_barang_controller.py
+
+import sys
+import os
+import pytest
+
+# Change path directory to src
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(root_dir + '/src')
+
+from controllers.barangController import BarangController
+from models.barang import Barang
+
+@pytest.fixture(scope="module")
+def controller():
+    # Create a new controller instance for the tests
+    return BarangController("src/database/warehosea.db")
+
+def test_add_barang(controller):
+    barang = Barang(
+        id_warehouse=1,
+        id_barang=101,
+        nama_barang="Barang Test",
+        deskripsi_barang="Deskripsi Barang Test",
+        stok=50,
+        pathFoto=None,
+        status_pengiriman="Berada di Warehouse"
+    ).__dict__
+    result = controller.add_barang(barang)
+    assert result == "Barang berhasil ditambahkan."
+    added_barang = controller.get_barang_info(barang['id_warehouse'], barang['id_barang'])
+    assert added_barang.nama_barang == "Barang Test"
+    assert added_barang.deskripsi_barang == "Deskripsi Barang Test"
+    assert added_barang.stok == 50
+    assert added_barang.foto is None
+    assert added_barang.status_pengiriman == "Berada di Warehouse"
+
+def test_update_barang(controller):
+    barang = Barang(
+        id_warehouse=1,
+        id_barang=101,
+        nama_barang="Updated Barang Test",
+        deskripsi_barang="Updated Deskripsi Barang Test",
+        stok=100,
+        pathFoto=None,
+        status_pengiriman="Dalam Pengiriman"
+    ).__dict__
+    result = controller.update_barang(barang)
+    assert result == "Barang berhasil diperbarui."
+    updated_barang = controller.get_barang_info(barang['id_warehouse'], barang['id_barang'])
+    assert updated_barang.nama_barang == "Updated Barang Test"
+    assert updated_barang.deskripsi_barang == "Updated Deskripsi Barang Test"
+    assert updated_barang.stok == 100
+    assert updated_barang.foto is None
+    assert updated_barang.status_pengiriman == "Dalam Pengiriman"
+
+def test_search_barang(controller):
+    input_nama_barang = "Barang "
+    search_results = controller.search_barang(input_nama_barang)
+    assert isinstance(search_results, list)
+    assert len(search_results) > 0
+    for result in search_results:
+        assert input_nama_barang in result.nama_barang
+
+def test_delete_barang(controller):
+    id_warehouse = 1
+    id_barang = 101
+    result = controller.delete_barang(id_warehouse, id_barang)
+    assert result == "Barang berhasil dihapus."
+    deleted_barang = controller.get_barang_info(id_warehouse, id_barang)
+    assert deleted_barang is None
+
+def test_get_all_barang(controller):
+    id_warehouse = 1
+    all_barang = controller.get_all_barang(id_warehouse)
+    assert isinstance(all_barang, list)
+
+def test_get_barang_info(controller):
+    barang = Barang(
+        id_warehouse=1,
+        id_barang=102,
+        nama_barang="Barang Info Test",
+        deskripsi_barang="Deskripsi Barang Info Test",
+        stok=30,
+        pathFoto=None,
+        status_pengiriman="Berada di Warehouse"
+    ).__dict__
+    controller.add_barang(barang)
+    fetched_barang = controller.get_barang_info(barang['id_warehouse'], barang['id_barang'])
+    assert fetched_barang is not None
+    assert fetched_barang.nama_barang == "Barang Info Test"
+    assert fetched_barang.deskripsi_barang == "Deskripsi Barang Info Test"
+    assert fetched_barang
+
+# Run the test
+if __name__ == "__main__":
+    pytest.main()

test/test_barang_model.py

+# tests/test_barang_model.py
+
+import sys
+import os
+import pytest
+
+# Change path directory to src
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(root_dir + '/src')
+
+from models.barang import Barang
+
+def test_barang_model():
+    id_warehouse = 1
+    id_barang = 101
+    nama_barang = "Barang Test"
+    deskripsi_barang = "Deskripsi Barang Test"
+    stok = 50
+    pathFoto = None
+    status_pengiriman = "Berada di Warehouse"
+
+    barang = Barang(id_warehouse, id_barang, nama_barang, deskripsi_barang, stok, pathFoto, status_pengiriman)
+
+    assert barang.id_warehouse == id_warehouse
+    assert barang.id_barang == id_barang
+    assert barang.nama_barang == nama_barang
+    assert barang.deskripsi_barang == deskripsi_barang
+    assert barang.stok == stok
+    assert barang.foto == pathFoto
+    assert barang.status_pengiriman == status_pengiriman
+
+# Run the test
+if __name__ == "__main__":
+    pytest.main()

test/test_warehouse_controller.py

+# tests/test_warehouse_controller.py
+
+import sys
+import os
+import pytest
+
+# Change path directory to root
+root_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(root_dir + '/src')
+
+from controllers.warehouseController import WarehouseController
+from models.warehouse import Warehouse
+
+@pytest.fixture(scope="module")
+def controller():
+    # Create a new controller instance for the tests
+    return WarehouseController("src/database/warehosea.db")
+
+def test_add_warehouse(controller):
+    warehouse = {
+        "id_warehouse": 10,
+        "nama_warehouse": "Main Warehouse",
+        "kapasitas_maksimum": 1000,
+        "kapasitas_terkini": 0,
+        "alamat": "123 Warehouse St."
+    }
+    add_result = controller.add_warehouse(warehouse)
+    assert add_result == "Warehouse berhasil ditambahkan."
+
+def test_get_all_warehouses(controller):
+    warehouses = controller.get_all_warehouses()
+    assert isinstance(warehouses, list), "Expected a list of warehouses"
+    if warehouses:
+        last_warehouse = warehouses[-1]
+        assert isinstance(last_warehouse, Warehouse), "Expected an instance of Warehouse"
+
+def test_get_warehouse_info(controller):
+    warehouse = {
+        "id_warehouse": 11,
+        "nama_warehouse": "Test Warehouse",
+        "kapasitas_maksimum": 500,
+        "kapasitas_terkini": 0,
+        "alamat": "456 Test St."
+    }
+    controller.add_warehouse(warehouse)
+    
+    warehouses = controller.get_all_warehouses()
+    last_warehouse = warehouses[-1]
+    last_warehouse_by_id = controller.get_warehouse_info(last_warehouse.id_warehouse)
+    assert last_warehouse_by_id.id_warehouse == last_warehouse.id_warehouse
+
+def test_delete_warehouse(controller):
+    warehouses = controller.get_all_warehouses()
+    if warehouses:
+        last_warehouse = warehouses[-1]
+        delete_result = controller.delete_warehouse(last_warehouse.id_warehouse)
+        assert delete_result == "Warehouse berhasil dihapus."
+        warehouses_after_deletion = controller.get_all_warehouses()
+        if warehouses_after_deletion:
+            assert last_warehouse.id_warehouse not in [w.id_warehouse for w in warehouses_after_deletion]
+
+def test_update_warehouse(controller):
+    warehouse = {
+        "id_warehouse": 12,
+        "nama_warehouse": "Warehouse to Update",
+        "kapasitas_maksimum": 800,
+        "kapasitas_terkini": 0,
+        "alamat": "789 Update St."
+    }
+    controller.add_warehouse(warehouse)
+    warehouses = controller.get_all_warehouses()
+    last_warehouse = warehouses[-1]
+    updated_warehouse = {
+        "id_warehouse": last_warehouse.id_warehouse,
+        "nama_warehouse": "Updated Warehouse",
+        "kapasitas_maksimum": 1500,
+        "alamat": "456 Updated St."
+    }
+    update_result = controller.update_warehouse(updated_warehouse)
+    assert update_result == "Warehouse berhasil diperbarui."
+    updated_warehouse_info = controller.get_warehouse_info(last_warehouse.id_warehouse)
+    assert updated_warehouse_info.nama_warehouse == updated_warehouse["nama_warehouse"]
+    assert updated_warehouse_info.kapasitas_maksimum == updated_warehouse["kapasitas_maksimum"]
+    assert updated_warehouse_info.alamat == updated_warehouse["alamat"]
+
+def test_search_warehouse(controller):
+    input_nama_warehouse = "Main"
+    search_results = controller.search_warehouse(input_nama_warehouse)
+    assert isinstance(search_results, list), "Expected a list of search results"
+    for result in search_results:
+        assert input_nama_warehouse in result.nama_warehouse
+
+# Run the test
+if __name__ == "__main__":
+    pytest.main()

test/test_warehouse_model.py

+# tests/test_warehouse.py
+
+# Change path directory to root
+import sys
+import os
+root_dir = os.path.abspath(os.path.join(os.getcwd()))
+sys.path.append(root_dir + '/src')
+
+from models.warehouse import *
+
+def test_warehouse_model():
+    id_warehouse = 1
+    nama_warehouse = "Main Warehouse"
+    kapasitas_maksimum = 1000
+    kapasitas_terkini = 500
+    alamat = "123 Warehouse St."
+
+    w = Warehouse(id_warehouse, nama_warehouse, kapasitas_maksimum, kapasitas_terkini, alamat)
+
+    assert w.id_warehouse == id_warehouse
+    assert w.nama_warehouse == nama_warehouse
+    assert w.kapasitas_maksimum == kapasitas_maksimum
+    assert w.kapasitas_terkini == kapasitas_terkini
+    assert w.alamat == alamat