5803024019/UAS_Kelompok5
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
UAS_Kelompok5/lost-and-found - Revisi 1/lost-and-found.txt
bambang-code1 e2f89b43f4 sudah bisa login
2025-11-23 22:49:46 +07:00

15315 lines
450 KiB
Plaintext
Raw Blame History

// cmd/server/main.go
// cmd/server/main.go
package main
import (
"log"
"lost-and-found/internal/config"
"lost-and-found/internal/middleware"
"lost-and-found/internal/routes"
"lost-and-found/internal/workers"
"os"
"os/signal"
"syscall"
"github.com/gin-gonic/gin"
"github.com/joho/godotenv"
)
func main() {
// Load .env file
if err := godotenv.Load(); err != nil {
log.Println("⚠️ No .env file found, using environment variables")
}
// Initialize JWT config
config.InitJWT()
// Initialize database
log.Println("📊 Initializing database...")
if err := config.InitDB(); err != nil {
log.Fatalf("❌ Failed to initialize database: %v", err)
}
defer config.CloseDB()
// Run migrations
log.Println("🔄 Running migrations...")
db := config.GetDB()
if err := config.RunMigrations(db); err != nil {
log.Fatalf("❌ Failed to run migrations: %v", err)
}
// Initialize Gin
if config.IsProduction() {
gin.SetMode(gin.ReleaseMode)
}
router := gin.Default()
// Apply middleware
router.Use(middleware.CORSMiddleware())
router.Use(middleware.LoggerMiddleware())
router.Use(middleware.RateLimiterMiddleware())
// Serve static files (uploads)
router.Static("/uploads", "./uploads")
router.Static("/css", "./web/css")
router.Static("/js", "./web/js")
// Frontend routes
router.GET("/", func(c *gin.Context) {
c.File("./web/index.html")
})
router.GET("/login", func(c *gin.Context) {
c.File("./web/login.html")
})
router.GET("/register", func(c *gin.Context) {
c.File("./web/register.html")
})
router.GET("/admin", func(c *gin.Context) {
c.File("./web/admin.html")
})
router.GET("/manager", func(c *gin.Context) {
c.File("./web/manager.html")
})
router.GET("/user", func(c *gin.Context) {
c.File("./web/user.html")
})
// Setup API routes
routes.SetupRoutes(router, db)
// Start background workers with error handling
log.Println("🔄 Starting background workers...")
expireWorker := workers.NewExpireWorker(db)
auditWorker := workers.NewAuditWorker(db)
matchingWorker := workers.NewMatchingWorker(db)
notificationWorker := workers.NewNotificationWorker(db)
go expireWorker.Start()
go auditWorker.Start()
go matchingWorker.Start()
go notificationWorker.Start()
log.Println("✅ Background workers started")
// Setup graceful shutdown
quit := make(chan os.Signal, 1)
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
// Get server config
serverConfig := config.GetServerConfig()
port := serverConfig.Port
// Start server
go func() {
log.Printf("🚀 Server starting on http://localhost:%s\n", port)
log.Printf("📍 API available at http://localhost:%s/api\n", port)
log.Printf("🌐 Frontend available at http://localhost:%s\n", port)
log.Println("✅ Ready to receive requests")
if err := router.Run(":" + port); err != nil {
log.Fatalf("❌ Failed to start server: %v", err)
}
}()
// Wait for interrupt signal
<-quit
log.Println("\n🛑 Shutting down server gracefully...")
// Stop workers
log.Println("🔄 Stopping background workers...")
expireWorker.Stop()
auditWorker.Stop()
matchingWorker.Stop()
notificationWorker.Stop()
log.Println("✅ Background workers stopped")
log.Println("✅ Server exited gracefully")
}
-- database/enhancement.sql
-- ============================================
-- ENHANCEMENT FOR LOST & FOUND DATABASE
-- Stored Procedures, Functions, Triggers, Views
-- ============================================
DELIMITER $$
-- ============================================
-- FUNCTIONS
-- ============================================
-- Function: Hitung similarity score antara 2 string
CREATE FUNCTION fn_calculate_similarity(str1 TEXT, str2 TEXT)
RETURNS DECIMAL(5,2)
DETERMINISTIC
BEGIN
DECLARE similarity DECIMAL(5,2);
DECLARE len1 INT;
DECLARE len2 INT;
DECLARE common_words INT DEFAULT 0;
SET len1 = LENGTH(str1);
SET len2 = LENGTH(str2);
-- Simple similarity calculation (bisa diganti dengan algorithm lebih kompleks)
IF str1 = str2 THEN
SET similarity = 100.00;
ELSEIF LOCATE(LOWER(str1), LOWER(str2)) > 0 THEN
SET similarity = 75.00;
ELSE
SET similarity = 50.00;
END IF;
RETURN similarity;
END$$
-- Function: Check apakah item sudah expired
CREATE FUNCTION fn_is_item_expired(item_id INT)
RETURNS BOOLEAN
READS SQL DATA
BEGIN
DECLARE is_expired BOOLEAN DEFAULT FALSE;
DECLARE expire_date TIMESTAMP;
SELECT expires_at INTO expire_date
FROM items
WHERE id = item_id AND deleted_at IS NULL;
IF expire_date IS NOT NULL AND expire_date < NOW() THEN
SET is_expired = TRUE;
END IF;
RETURN is_expired;
END$$
-- Function: Hitung total items per kategori
CREATE FUNCTION fn_count_items_by_category(cat_id INT)
RETURNS INT
READS SQL DATA
BEGIN
DECLARE total INT DEFAULT 0;
SELECT COUNT(*) INTO total
FROM items
WHERE category_id = cat_id
AND deleted_at IS NULL
AND status = 'unclaimed';
RETURN total;
END$$
-- ============================================
-- STORED PROCEDURES
-- ============================================
-- Procedure: Create claim dengan transaction dan locking
CREATE PROCEDURE sp_create_claim(
IN p_item_id INT,
IN p_user_id INT,
IN p_description TEXT,
IN p_proof_url VARCHAR(255),
IN p_contact VARCHAR(50),
OUT p_claim_id INT,
OUT p_status VARCHAR(50),
OUT p_message TEXT
)
BEGIN
DECLARE v_item_status VARCHAR(50);
DECLARE v_item_desc TEXT;
DECLARE v_similarity DECIMAL(5,2);
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
ROLLBACK;
SET p_status = 'error';
SET p_message = 'Transaction failed. Claim not created.';
SET p_claim_id = NULL;
END;
START TRANSACTION;
-- Lock item untuk prevent concurrent claims
SELECT status, description INTO v_item_status, v_item_desc
FROM items
WHERE id = p_item_id AND deleted_at IS NULL
FOR UPDATE;
-- Validasi: item harus unclaimed
IF v_item_status != 'unclaimed' THEN
SET p_status = 'error';
SET p_message = 'Item sudah diklaim atau tidak tersedia';
ROLLBACK;
ELSE
-- Insert claim
INSERT INTO claims (
item_id, user_id, description,
proof_url, contact, status
) VALUES (
p_item_id, p_user_id, p_description,
p_proof_url, p_contact, 'pending'
);
SET p_claim_id = LAST_INSERT_ID();
-- Calculate similarity score
SET v_similarity = fn_calculate_similarity(p_description, v_item_desc);
-- Insert verification record
INSERT INTO claim_verifications (
claim_id, similarity_score, is_auto_matched
) VALUES (
p_claim_id, v_similarity, FALSE
);
-- Create notification for managers
INSERT INTO notifications (
user_id, type, title, message, entity_type, entity_id
)
SELECT
u.id,
'new_claim',
'Klaim Baru',
CONCAT('Ada klaim baru untuk barang: ', i.name),
'claim',
p_claim_id
FROM users u
CROSS JOIN items i
WHERE u.role_id = 2
AND u.deleted_at IS NULL
AND i.id = p_item_id;
SET p_status = 'success';
SET p_message = 'Claim created successfully';
COMMIT;
END IF;
END$$
-- Procedure: Verify claim (approve/reject)
CREATE PROCEDURE sp_verify_claim(
IN p_claim_id INT,
IN p_verifier_id INT,
IN p_action VARCHAR(20), -- 'approve' or 'reject'
IN p_notes TEXT,
OUT p_status VARCHAR(50),
OUT p_message TEXT
)
BEGIN
DECLARE v_item_id INT;
DECLARE v_user_id INT;
DECLARE v_claim_status VARCHAR(50);
DECLARE EXIT HANDLER FOR SQLEXCEPTION
BEGIN
ROLLBACK;
SET p_status = 'error';
SET p_message = 'Verification failed';
END;
START TRANSACTION;
-- Get claim details with lock
SELECT item_id, user_id, status
INTO v_item_id, v_user_id, v_claim_status
FROM claims
WHERE id = p_claim_id AND deleted_at IS NULL
FOR UPDATE;
IF v_claim_status != 'pending' THEN
SET p_status = 'error';
SET p_message = 'Claim already processed';
ROLLBACK;
ELSE
-- Update claim status
UPDATE claims
SET status = p_action,
notes = p_notes,
verified_at = NOW(),
verified_by = p_verifier_id
WHERE id = p_claim_id;
-- If approved, update item status
IF p_action = 'approved' THEN
UPDATE items
SET status = 'claimed'
WHERE id = v_item_id;
-- Archive the item
INSERT INTO archives (
item_id, name, category_id, photo_url, location,
description, date_found, status, reporter_name,
reporter_contact, archived_reason, claimed_by
)
SELECT
id, name, category_id, photo_url, location,
description, date_found, status, reporter_name,
reporter_contact, 'case_closed', v_user_id
FROM items
WHERE id = v_item_id;
END IF;
-- Notify user
INSERT INTO notifications (
user_id, type, title, message, entity_type, entity_id
) VALUES (
v_user_id,
CONCAT('claim_', p_action),
IF(p_action = 'approved', 'Klaim Disetujui!', 'Klaim Ditolak'),
CONCAT('Klaim Anda telah ', IF(p_action = 'approved', 'disetujui', 'ditolak')),
'claim',
p_claim_id
);
SET p_status = 'success';
SET p_message = CONCAT('Claim ', p_action, ' successfully');
COMMIT;
END IF;
END$$
-- Procedure: Archive expired items
CREATE PROCEDURE sp_archive_expired_items(
OUT p_archived_count INT
)
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE v_item_id INT;
DECLARE cur CURSOR FOR
SELECT id FROM items
WHERE expires_at < NOW()
AND status = 'unclaimed'
AND deleted_at IS NULL;
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
SET p_archived_count = 0;
OPEN cur;
read_loop: LOOP
FETCH cur INTO v_item_id;
IF done THEN
LEAVE read_loop;
END IF;
-- Archive the item
INSERT INTO archives (
item_id, name, category_id, photo_url, location,
description, date_found, status, reporter_name,
reporter_contact, archived_reason
)
SELECT
id, name, category_id, photo_url, location,
description, date_found, status, reporter_name,
reporter_contact, 'expired'
FROM items
WHERE id = v_item_id;
-- Update item status
UPDATE items
SET status = 'expired'
WHERE id = v_item_id;
SET p_archived_count = p_archived_count + 1;
END LOOP;
CLOSE cur;
END$$
-- Procedure: Auto-match lost items with found items
CREATE PROCEDURE sp_auto_match_items()
BEGIN
DECLARE done INT DEFAULT FALSE;
DECLARE v_lost_id INT;
DECLARE v_item_id INT;
DECLARE v_similarity DECIMAL(5,2);
DECLARE cur CURSOR FOR
SELECT li.id, i.id, fn_calculate_similarity(li.description, i.description)
FROM lost_items li
CROSS JOIN items i
WHERE li.status = 'active'
AND i.status = 'unclaimed'
AND li.category_id = i.category_id
AND li.deleted_at IS NULL
AND i.deleted_at IS NULL
AND NOT EXISTS (
SELECT 1 FROM match_results mr
WHERE mr.lost_item_id = li.id
AND mr.item_id = i.id
AND mr.deleted_at IS NULL
);
DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
OPEN cur;
match_loop: LOOP
FETCH cur INTO v_lost_id, v_item_id, v_similarity;
IF done THEN
LEAVE match_loop;
END IF;
-- Only create match if similarity >= 70%
IF v_similarity >= 70.00 THEN
INSERT INTO match_results (
lost_item_id, item_id, similarity_score,
matched_fields, is_notified
) VALUES (
v_lost_id, v_item_id, v_similarity,
'{"category": 100, "description": ' || v_similarity || '}',
FALSE
);
-- Create notification
INSERT INTO notifications (
user_id, type, title, message, entity_type, entity_id
)
SELECT
li.user_id,
'match_found',
'Barang yang Mirip Ditemukan!',
CONCAT('Kami menemukan barang yang mirip: ', i.name),
'match',
LAST_INSERT_ID()
FROM lost_items li
JOIN items i ON i.id = v_item_id
WHERE li.id = v_lost_id;
END IF;
END LOOP;
CLOSE cur;
END$$
-- ============================================
-- TRIGGERS
-- ============================================
-- Trigger: Auto-set expires_at saat item dibuat (3 bulan dari date_found)
CREATE TRIGGER trg_items_before_insert
BEFORE INSERT ON items
FOR EACH ROW
BEGIN
IF NEW.expires_at IS NULL THEN
SET NEW.expires_at = DATE_ADD(NEW.date_found, INTERVAL 3 MONTH);
END IF;
END$$
-- Trigger: Auto-log ke audit_logs saat user login
CREATE TRIGGER trg_audit_log_after_user_update
AFTER UPDATE ON users
FOR EACH ROW
BEGIN
IF OLD.updated_at != NEW.updated_at THEN
INSERT INTO audit_logs (
user_id, action, entity_type, entity_id, details
) VALUES (
NEW.id,
'update',
'user',
NEW.id,
CONCAT('User updated: ', NEW.name)
);
END IF;
END$$
-- Trigger: Auto-create revision log saat item di-update
CREATE TRIGGER trg_items_after_update
AFTER UPDATE ON items
FOR EACH ROW
BEGIN
IF OLD.name != NEW.name THEN
INSERT INTO revision_logs (item_id, user_id, field_name, old_value, new_value)
VALUES (NEW.id, NEW.reporter_id, 'name', OLD.name, NEW.name);
END IF;
IF OLD.description != NEW.description THEN
INSERT INTO revision_logs (item_id, user_id, field_name, old_value, new_value)
VALUES (NEW.id, NEW.reporter_id, 'description', OLD.description, NEW.description);
END IF;
IF OLD.status != NEW.status THEN
INSERT INTO revision_logs (item_id, user_id, field_name, old_value, new_value)
VALUES (NEW.id, NEW.reporter_id, 'status', OLD.status, NEW.status);
END IF;
END$$
-- Trigger: Prevent delete if item has active claims
CREATE TRIGGER trg_items_before_delete
BEFORE DELETE ON items
FOR EACH ROW
BEGIN
DECLARE v_active_claims INT;
SELECT COUNT(*) INTO v_active_claims
FROM claims
WHERE item_id = OLD.id
AND status = 'pending'
AND deleted_at IS NULL;
IF v_active_claims > 0 THEN
SIGNAL SQLSTATE '45000'
SET MESSAGE_TEXT = 'Cannot delete item with active claims';
END IF;
END$$
-- Trigger: Auto-archive item when claimed
CREATE TRIGGER trg_items_after_status_claimed
AFTER UPDATE ON items
FOR EACH ROW
BEGIN
IF OLD.status != 'claimed' AND NEW.status = 'claimed' THEN
INSERT INTO archives (
item_id, name, category_id, photo_url, location,
description, date_found, status, reporter_name,
reporter_contact, archived_reason
) VALUES (
NEW.id, NEW.name, NEW.category_id, NEW.photo_url,
NEW.location, NEW.description, NEW.date_found,
NEW.status, NEW.reporter_name, NEW.reporter_contact,
'case_closed'
);
END IF;
END$$
DELIMITER ;
-- ============================================
-- VIEWS untuk ETL dan Reporting
-- ============================================
-- View: Dashboard statistics
CREATE OR REPLACE VIEW vw_dashboard_stats AS
SELECT
(SELECT COUNT(*) FROM items WHERE status = 'unclaimed' AND deleted_at IS NULL) AS total_unclaimed,
(SELECT COUNT(*) FROM items WHERE status = 'claimed' AND deleted_at IS NULL) AS total_claimed,
(SELECT COUNT(*) FROM lost_items WHERE status = 'active' AND deleted_at IS NULL) AS total_lost_reports,
(SELECT COUNT(*) FROM claims WHERE status = 'pending' AND deleted_at IS NULL) AS pending_claims,
(SELECT COUNT(*) FROM match_results WHERE is_notified = FALSE AND deleted_at IS NULL) AS unnotified_matches;
-- View: Items dengan informasi kategori dan reporter
CREATE OR REPLACE VIEW vw_items_detail AS
SELECT
i.id,
i.name,
c.name AS category_name,
c.slug AS category_slug,
i.photo_url,
i.location,
i.date_found,
i.status,
i.reporter_name,
i.reporter_contact,
i.expires_at,
u.name AS reporter_user_name,
u.email AS reporter_email,
DATEDIFF(i.expires_at, NOW()) AS days_until_expire,
i.created_at
FROM items i
JOIN categories c ON i.category_id = c.id
JOIN users u ON i.reporter_id = u.id
WHERE i.deleted_at IS NULL;
-- View: Claims dengan detail lengkap
CREATE OR REPLACE VIEW vw_claims_detail AS
SELECT
c.id,
c.status,
i.name AS item_name,
cat.name AS category_name,
u.name AS claimant_name,
u.email AS claimant_email,
u.phone AS claimant_phone,
c.description AS claim_description,
c.contact,
cv.similarity_score,
c.verified_at,
v.name AS verified_by_name,
c.notes,
c.created_at
FROM claims c
JOIN items i ON c.item_id = i.id
JOIN categories cat ON i.category_id = cat.id
JOIN users u ON c.user_id = u.id
LEFT JOIN claim_verifications cv ON c.id = cv.claim_id
LEFT JOIN users v ON c.verified_by = v.id
WHERE c.deleted_at IS NULL;
-- View: Match results dengan detail
CREATE OR REPLACE VIEW vw_match_results_detail AS
SELECT
mr.id,
li.name AS lost_item_name,
li.user_id AS lost_by_user_id,
u.name AS lost_by_user_name,
u.email AS lost_by_email,
i.name AS found_item_name,
i.reporter_name AS found_by_name,
mr.similarity_score,
mr.is_notified,
mr.matched_at,
i.id AS found_item_id,
li.id AS lost_item_id
FROM match_results mr
JOIN lost_items li ON mr.lost_item_id = li.id
JOIN items i ON mr.item_id = i.id
JOIN users u ON li.user_id = u.id
WHERE mr.deleted_at IS NULL
ORDER BY mr.similarity_score DESC;
-- View: Category statistics
CREATE OR REPLACE VIEW vw_category_stats AS
SELECT
c.id,
c.name,
c.slug,
COUNT(DISTINCT i.id) AS total_items,
COUNT(DISTINCT CASE WHEN i.status = 'unclaimed' THEN i.id END) AS unclaimed_items,
COUNT(DISTINCT CASE WHEN i.status = 'claimed' THEN i.id END) AS claimed_items,
COUNT(DISTINCT li.id) AS total_lost_reports
FROM categories c
LEFT JOIN items i ON c.id = i.category_id AND i.deleted_at IS NULL
LEFT JOIN lost_items li ON c.id = li.category_id AND li.deleted_at IS NULL
WHERE c.deleted_at IS NULL
GROUP BY c.id, c.name, c.slug;
-- ============================================
-- EVENT SCHEDULER (untuk auto-archiving)
-- ============================================
-- Enable event scheduler
SET GLOBAL event_scheduler = ON;
-- Event: Archive expired items setiap hari jam 1 pagi
CREATE EVENT IF NOT EXISTS evt_archive_expired_items
ON SCHEDULE EVERY 1 DAY
STARTS CURRENT_TIMESTAMP + INTERVAL 1 DAY
DO
CALL sp_archive_expired_items(@count);
-- Event: Auto-match items setiap 1 jam
CREATE EVENT IF NOT EXISTS evt_auto_match_items
ON SCHEDULE EVERY 1 HOUR
DO
CALL sp_auto_match_items();
-- ============================================
-- SUCCESS MESSAGE
-- ============================================
SELECT '✅ Database enhancements created!' AS Status;
SELECT '📝 Functions: 3' AS Info;
SELECT '⚙️ Procedures: 4' AS Info;
SELECT '🔔 Triggers: 5' AS Info;
SELECT '📊 Views: 5' AS Info;
SELECT '⏰ Events: 2' AS Info;
-- database/schema.sql
-- Lost & Found Database Schema (FIXED - SYNC with ERD)
-- MySQL/MariaDB Database
-- ============================================
-- CREATE DATABASE
-- ============================================
DROP DATABASE IF EXISTS lost_and_found;
CREATE DATABASE lost_and_found CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
USE lost_and_found;
-- Set charset dan collation
SET NAMES utf8mb4;
SET CHARACTER SET utf8mb4;
-- Drop tables if exists (untuk clean migration)
DROP TABLE IF EXISTS notifications;
DROP TABLE IF EXISTS revision_logs;
DROP TABLE IF EXISTS verification_logs;
DROP TABLE IF EXISTS match_results;
DROP TABLE IF EXISTS claim_verifications;
DROP TABLE IF EXISTS audit_logs;
DROP TABLE IF EXISTS archives;
DROP TABLE IF EXISTS claims;
DROP TABLE IF EXISTS attachments;
DROP TABLE IF EXISTS items;
DROP TABLE IF EXISTS lost_items;
DROP TABLE IF EXISTS categories;
DROP TABLE IF EXISTS users;
DROP TABLE IF EXISTS roles;
-- ============================================
-- ROLES TABLE
-- ============================================
CREATE TABLE roles (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(50) UNIQUE NOT NULL,
description TEXT,
permissions JSON DEFAULT NULL COMMENT 'RBAC permissions in JSON format',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
INDEX idx_roles_name (name),
INDEX idx_roles_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- USERS TABLE
-- ============================================
CREATE TABLE users (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) UNIQUE NOT NULL,
password VARCHAR(255) NOT NULL,
nrp VARCHAR(20) UNIQUE DEFAULT NULL,
phone VARCHAR(20) DEFAULT NULL,
role_id INT UNSIGNED NOT NULL DEFAULT 3,
status VARCHAR(20) DEFAULT 'active',
last_login DATETIME DEFAULT NULL COMMENT 'Last login timestamp',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE RESTRICT,
INDEX idx_users_email (email),
INDEX idx_users_nrp (nrp),
INDEX idx_users_role_id (role_id),
INDEX idx_users_status (status),
INDEX idx_users_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- CATEGORIES TABLE
-- ============================================
CREATE TABLE categories (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
slug VARCHAR(100) UNIQUE NOT NULL,
description TEXT,
icon_url VARCHAR(255) DEFAULT NULL COMMENT 'Category icon URL',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
INDEX idx_categories_slug (slug),
INDEX idx_categories_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- ITEMS TABLE (Barang Ditemukan)
-- ============================================
CREATE TABLE items (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
category_id INT UNSIGNED NOT NULL,
photo_url VARCHAR(255) DEFAULT NULL,
location VARCHAR(200) NOT NULL,
description TEXT NOT NULL COMMENT 'Public description',
secret_details TEXT DEFAULT NULL COMMENT 'RAHASIA - untuk verifikasi klaim (hanya visible untuk owner/admin)',
date_found DATE NOT NULL COMMENT 'Tanggal barang ditemukan',
status VARCHAR(50) DEFAULT 'unclaimed' COMMENT 'unclaimed, claimed, expired',
reporter_id INT UNSIGNED NOT NULL,
reporter_name VARCHAR(100) NOT NULL,
reporter_contact VARCHAR(50) NOT NULL,
view_count INT DEFAULT 0 COMMENT 'Total views untuk analytics',
expires_at TIMESTAMP NULL DEFAULT NULL COMMENT 'Tanggal barang akan dihapus (3 bulan dari date_found)',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE RESTRICT,
FOREIGN KEY (reporter_id) REFERENCES users(id) ON DELETE RESTRICT,
INDEX idx_items_category_id (category_id),
INDEX idx_items_status (status),
INDEX idx_items_reporter_id (reporter_id),
INDEX idx_items_date_found (date_found),
INDEX idx_items_expires_at (expires_at),
INDEX idx_items_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- LOST_ITEMS TABLE (Barang Hilang)
-- ============================================
CREATE TABLE lost_items (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
user_id INT UNSIGNED NOT NULL,
name VARCHAR(100) NOT NULL,
category_id INT UNSIGNED NOT NULL,
color VARCHAR(50) DEFAULT NULL,
location VARCHAR(200) DEFAULT NULL,
description TEXT NOT NULL COMMENT 'Deskripsi untuk auto-matching',
date_lost DATE NOT NULL COMMENT 'Tanggal barang hilang',
status VARCHAR(50) DEFAULT 'active' COMMENT 'active, resolved',
resolved_at DATETIME DEFAULT NULL COMMENT 'Kapan laporan hilang ditandai sebagai selesai',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE RESTRICT,
INDEX idx_lost_items_user_id (user_id),
INDEX idx_lost_items_category_id (category_id),
INDEX idx_lost_items_status (status),
INDEX idx_lost_items_date_lost (date_lost),
INDEX idx_lost_items_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- ATTACHMENTS TABLE (Foto Barang)
-- ============================================
CREATE TABLE attachments (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
item_id INT UNSIGNED DEFAULT NULL COMMENT 'FK to items, nullable for lost_items',
lost_item_id INT UNSIGNED DEFAULT NULL COMMENT 'FK to lost_items, nullable for items',
file_url VARCHAR(255) NOT NULL,
file_type VARCHAR(50) DEFAULT NULL COMMENT 'jpg, png, gif, dll',
file_size INT DEFAULT NULL COMMENT 'File size in bytes',
upload_by_user_id INT UNSIGNED DEFAULT NULL,
display_order INT DEFAULT 0 COMMENT 'Order untuk display multiple photos',
is_primary BOOLEAN DEFAULT FALSE COMMENT 'Primary photo untuk display',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
FOREIGN KEY (lost_item_id) REFERENCES lost_items(id) ON DELETE CASCADE,
FOREIGN KEY (upload_by_user_id) REFERENCES users(id) ON DELETE SET NULL,
INDEX idx_attachments_item_id (item_id),
INDEX idx_attachments_lost_item_id (lost_item_id),
INDEX idx_attachments_is_primary (is_primary)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- CLAIMS TABLE (Klaim Barang)
-- ============================================
CREATE TABLE claims (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
item_id INT UNSIGNED NOT NULL,
user_id INT UNSIGNED NOT NULL,
description TEXT NOT NULL COMMENT 'Deskripsi dari user untuk verifikasi',
proof_url VARCHAR(255) DEFAULT NULL,
contact VARCHAR(50) NOT NULL,
status VARCHAR(50) DEFAULT 'pending' COMMENT 'pending, approved, rejected',
notes TEXT DEFAULT NULL COMMENT 'Admin verification notes',
rejection_reason VARCHAR(255) DEFAULT NULL COMMENT 'Alasan penolakan klaim',
attempt_count INT DEFAULT 1 COMMENT 'Jumlah percobaan klaim (fraud prevention)',
verified_at TIMESTAMP NULL DEFAULT NULL,
verified_by INT UNSIGNED DEFAULT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
FOREIGN KEY (verified_by) REFERENCES users(id) ON DELETE SET NULL,
INDEX idx_claims_item_id (item_id),
INDEX idx_claims_user_id (user_id),
INDEX idx_claims_status (status),
INDEX idx_claims_verified_by (verified_by),
INDEX idx_claims_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- CLAIM_VERIFICATIONS TABLE (Data Verifikasi Klaim)
-- ============================================
CREATE TABLE claim_verifications (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
claim_id INT UNSIGNED UNIQUE NOT NULL,
similarity_score DECIMAL(5,2) DEFAULT 0.00 COMMENT 'Similarity score 0-100',
matched_keywords TEXT DEFAULT NULL COMMENT 'Keywords matched (JSON format)',
verification_notes TEXT DEFAULT NULL,
is_auto_matched BOOLEAN DEFAULT FALSE,
verification_method VARCHAR(50) DEFAULT 'manual' COMMENT 'manual, auto, hybrid',
metadata JSON DEFAULT NULL COMMENT 'Additional verification data (extensible)',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (claim_id) REFERENCES claims(id) ON DELETE CASCADE,
INDEX idx_claim_verifications_claim_id (claim_id),
INDEX idx_claim_verifications_similarity_score (similarity_score),
INDEX idx_claim_verifications_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- VERIFICATION_LOGS TABLE (Audit Trail Verifikasi)
-- ============================================
CREATE TABLE verification_logs (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
verification_id INT UNSIGNED NOT NULL,
verified_by_user_id INT UNSIGNED NOT NULL,
action VARCHAR(50) NOT NULL COMMENT 'approve, reject, pending, review',
reason TEXT DEFAULT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (verification_id) REFERENCES claim_verifications(id) ON DELETE CASCADE,
FOREIGN KEY (verified_by_user_id) REFERENCES users(id) ON DELETE RESTRICT,
INDEX idx_verification_logs_verification_id (verification_id),
INDEX idx_verification_logs_verified_by_user_id (verified_by_user_id),
INDEX idx_verification_logs_created_at (created_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- MATCH_RESULTS TABLE (Hasil Auto-Matching)
-- ============================================
CREATE TABLE match_results (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
lost_item_id INT UNSIGNED NOT NULL,
item_id INT UNSIGNED NOT NULL,
similarity_score DECIMAL(5,2) NOT NULL,
matched_fields TEXT DEFAULT NULL COMMENT 'JSON format: {category, description, color}',
match_reason VARCHAR(100) DEFAULT NULL COMMENT 'Reason for matching: color, location, description, etc',
matched_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
is_notified BOOLEAN DEFAULT FALSE,
notified_at DATETIME DEFAULT NULL COMMENT 'Kapan user diberitahu tentang match',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (lost_item_id) REFERENCES lost_items(id) ON DELETE CASCADE,
FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
INDEX idx_match_results_lost_item_id (lost_item_id),
INDEX idx_match_results_item_id (item_id),
INDEX idx_match_results_similarity_score (similarity_score),
INDEX idx_match_results_is_notified (is_notified),
INDEX idx_match_results_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- ARCHIVES TABLE (Barang yang Diarsipkan)
-- ============================================
CREATE TABLE archives (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
item_id INT UNSIGNED UNIQUE NOT NULL COMMENT 'Original item ID',
name VARCHAR(100) NOT NULL,
category_id INT UNSIGNED NOT NULL,
photo_url VARCHAR(255) DEFAULT NULL,
location VARCHAR(200) DEFAULT NULL,
description TEXT DEFAULT NULL,
date_found DATE DEFAULT NULL COMMENT 'Tanggal barang ditemukan (dari items)',
status VARCHAR(50) DEFAULT NULL,
reporter_name VARCHAR(100) DEFAULT NULL,
reporter_contact VARCHAR(50) DEFAULT NULL,
archived_reason VARCHAR(100) DEFAULT NULL COMMENT 'expired, case_closed',
claimed_by INT UNSIGNED DEFAULT NULL,
archived_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (category_id) REFERENCES categories(id) ON DELETE RESTRICT,
FOREIGN KEY (claimed_by) REFERENCES users(id) ON DELETE SET NULL,
INDEX idx_archives_item_id (item_id),
INDEX idx_archives_category_id (category_id),
INDEX idx_archives_archived_reason (archived_reason),
INDEX idx_archives_archived_at (archived_at),
INDEX idx_archives_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- REVISION_LOGS TABLE (Audit Trail Edit Barang)
-- ============================================
CREATE TABLE revision_logs (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
item_id INT UNSIGNED NOT NULL,
user_id INT UNSIGNED NOT NULL,
field_name VARCHAR(50) NOT NULL,
old_value TEXT DEFAULT NULL,
new_value TEXT DEFAULT NULL,
reason TEXT DEFAULT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (item_id) REFERENCES items(id) ON DELETE CASCADE,
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
INDEX idx_revision_logs_item_id (item_id),
INDEX idx_revision_logs_user_id (user_id),
INDEX idx_revision_logs_created_at (created_at),
INDEX idx_revision_logs_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- AUDIT_LOGS TABLE (System Audit Trail)
-- ============================================
CREATE TABLE audit_logs (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
user_id INT UNSIGNED DEFAULT NULL,
action VARCHAR(50) NOT NULL,
entity_type VARCHAR(50) DEFAULT NULL,
entity_id INT UNSIGNED DEFAULT NULL,
details TEXT DEFAULT NULL,
ip_address VARCHAR(50) DEFAULT NULL,
user_agent VARCHAR(255) DEFAULT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
INDEX idx_audit_logs_user_id (user_id),
INDEX idx_audit_logs_action (action),
INDEX idx_audit_logs_entity_type (entity_type),
INDEX idx_audit_logs_entity_id (entity_id),
INDEX idx_audit_logs_created_at (created_at),
INDEX idx_audit_logs_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- NOTIFICATIONS TABLE (Notifikasi User)
-- ============================================
CREATE TABLE notifications (
id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
user_id INT UNSIGNED NOT NULL,
type VARCHAR(50) NOT NULL,
title VARCHAR(200) NOT NULL,
message TEXT NOT NULL,
entity_type VARCHAR(50) DEFAULT NULL,
entity_id INT UNSIGNED DEFAULT NULL,
channel VARCHAR(50) DEFAULT 'push' COMMENT 'email, sms, push',
is_read BOOLEAN DEFAULT FALSE,
read_at TIMESTAMP NULL DEFAULT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
deleted_at TIMESTAMP NULL DEFAULT NULL,
FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
INDEX idx_notifications_user_id (user_id),
INDEX idx_notifications_type (type),
INDEX idx_notifications_is_read (is_read),
INDEX idx_notifications_created_at (created_at),
INDEX idx_notifications_deleted_at (deleted_at)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- ============================================
-- SUCCESS MESSAGE
-- ============================================
SELECT '✅ Database schema created successfully!' AS Status;
SELECT '📋 Total tables: 15 (UPGRADED from 13)' AS Info;
SELECT '🔑 Indexes created on all tables' AS Info;
SELECT '🔗 Foreign keys with proper constraints' AS Info;
SELECT '✨ NOW SYNC with ERD diagram!' AS Info;
SELECT '📝 Next step: Run seed.sql to populate initial data' AS NextStep;
-- database/seed.sql
-- Lost & Found Database Seed Data (FIXED - SYNC with ERD)
-- MySQL/MariaDB Database
SET NAMES utf8mb4;
SET CHARACTER SET utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ============================================
-- SEED ROLES
-- ============================================
INSERT INTO roles (name, description, permissions) VALUES
('admin', 'Administrator with full access', JSON_OBJECT(
'users', JSON_OBJECT('create', true, 'read', true, 'update', true, 'delete', true),
'items', JSON_OBJECT('create', true, 'read', true, 'update', true, 'delete', true),
'claims', JSON_OBJECT('create', true, 'read', true, 'update', true, 'delete', true, 'verify', true),
'reports', JSON_OBJECT('access', true)
)),
('manager', 'Manager/Cleaning Service - can verify claims', JSON_OBJECT(
'items', JSON_OBJECT('read', true, 'update', true),
'claims', JSON_OBJECT('read', true, 'verify', true),
'reports', JSON_OBJECT('access', true)
)),
('user', 'Regular user/student', JSON_OBJECT(
'items', JSON_OBJECT('read', true),
'lost_items', JSON_OBJECT('create', true, 'read', true, 'update', true),
'claims', JSON_OBJECT('create', true, 'read', true)
));
-- ============================================
-- SEED CATEGORIES
-- ============================================
INSERT INTO categories (name, slug, description, icon_url) VALUES
('Pakaian', 'pakaian', 'Jaket, baju, celana, dll', '/icons/clothing.png'),
('Alat Makan', 'alat_makan', 'Botol minum, lunchbox, dll', '/icons/food.png'),
('Aksesoris', 'aksesoris', 'Jam tangan, gelang, kacamata, dll', '/icons/accessories.png'),
('Elektronik', 'elektronik', 'Kalkulator, mouse, headset, charger, dll', '/icons/electronics.png'),
('Alat Tulis', 'alat_tulis', 'Buku, pulpen, tipe-x, dll', '/icons/stationery.png'),
('Lainnya', 'lainnya', 'Kategori lainnya', '/icons/others.png');
-- ============================================
-- SEED USERS
-- Password untuk semua user: "password123"
-- Hash bcrypt: $2a$10$92IXUNpkjO0rOQ5byMi.Ye4oKoEa3Ro9llC/.og/at2.uheWG/igi
-- ============================================
-- Admin User
INSERT INTO users (name, email, password, nrp, phone, role_id, status, last_login) VALUES
('Admin System', 'admin@lostandfound.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '1234567890', '081234567890', 1, 'active', '2024-02-10 14:30:00');
-- Manager Users
INSERT INTO users (name, email, password, nrp, phone, role_id, status, last_login) VALUES
('Pak Budi', 'manager1@lostandfound.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '2234567890', '081234567891', 2, 'active', '2024-02-10 13:00:00'),
('Bu Siti', 'manager2@lostandfound.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '2234567891', '081234567892', 2, 'active', '2024-02-09 15:30:00');
-- Regular Users (Students)
INSERT INTO users (name, email, password, nrp, phone, role_id, status, last_login) VALUES
('Ahmad Rizki', 'ahmad@student.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '5025211001', '081234567893', 3, 'active', '2024-02-10 10:15:00'),
('Siti Nurhaliza', 'siti@student.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '5025211002', '081234567894', 3, 'active', '2024-02-08 14:45:00'),
('Budi Santoso', 'budi@student.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '5025211003', '081234567895', 3, 'active', '2024-02-07 11:20:00'),
('Dewi Lestari', 'dewi@student.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '5025211004', '081234567896', 3, 'active', '2024-02-05 09:30:00'),
('Eko Prasetyo', 'eko@student.com', '$2a$10$zhRlU9e1v6T2x4/bPwOZNOAqSktHjj6QFgXV3i2/0pITlKasUpv4G', '5025211005', '081234567897', 3, 'active', '2024-02-04 16:00:00');
-- ============================================
-- SEED ITEMS (Barang Ditemukan)
-- ============================================
INSERT INTO items (name, category_id, photo_url, location, description, secret_details, date_found, status, reporter_id, reporter_name, reporter_contact, view_count, expires_at) VALUES
-- Pakaian
('Jaket Hitam Nike', 1, '/photos/item1.jpg', 'Gedung A lantai 2', 'Jaket hitam merk Nike ukuran M, ada logo putih di dada kiri, resleting berwarna silver', 'Resleting sudah rusak di bagian bawah, ada tambalan kecil di saku kanan', '2024-01-15', 'unclaimed', 2, 'Pak Budi', '081234567891', 24, '2024-04-15 09:30:00'),
('Sweater Abu-abu', 1, '/photos/item2.jpg', 'Perpustakaan', 'Sweater abu-abu polos, ada tulisan "ITS" di punggung dengan huruf biru', 'Kancing di tengah ada yang hilang, halus dan lembut', '2024-01-18', 'unclaimed', 3, 'Bu Siti', '081234567892', 18, '2024-04-18 14:20:00'),
-- Alat Makan
('Botol Minum Tupperware Biru', 2, '/photos/item3.jpg', 'Kantin Utama', 'Botol minum tupperware warna biru tua, ada stiker nama "RARA" di samping, tutup warna putih', 'Stiker nama hampir hilang, ada goresan di dasar botol', '2024-01-20', 'unclaimed', 2, 'Pak Budi', '081234567891', 31, '2024-04-20 12:00:00'),
('Lunchbox Pink', 2, '/photos/item4.jpg', 'Gedung B lantai 1', 'Kotak makan plastik warna pink dengan 2 sekat, ada gambar Hello Kitty di tutup', 'Plastik agak kusam, ada bekas noda coklat di sekat bawah', '2024-01-22', 'unclaimed', 3, 'Bu Siti', '081234567892', 15, '2024-04-22 11:30:00'),
-- Elektronik
('Kalkulator Casio FX-991ID Plus', 4, '/photos/item5.jpg', 'Ruang Kelas C101', 'Kalkulator scientific Casio FX-991ID Plus, warna hitam, ada goresan kecil di layar', 'Baterai masih bagus, layar LCD cerah, tidak ada tombol yang macet', '2024-01-25', 'unclaimed', 2, 'Pak Budi', '081234567891', 42, '2024-04-25 08:15:00'),
('Mouse Wireless Logitech', 4, '/photos/item6.jpg', 'Lab Komputer', 'Mouse wireless Logitech M185, warna merah, tidak ada baterai dan receiver USB', 'Receiver USB hilang, butuh baterai AA 2 pcs untuk penggantinya', '2024-01-28', 'unclaimed', 3, 'Bu Siti', '081234567892', 19, '2024-04-28 15:45:00'),
('Charger Laptop HP', 4, '/photos/item7.jpg', 'Perpustakaan meja 15', 'Charger laptop HP original 65W, kabel agak kusut, ujung konektor bulat', 'Konektor terlihat bagus, output stabil, tested working', '2024-02-01', 'unclaimed', 2, 'Pak Budi', '081234567891', 27, '2024-05-01 10:20:00'),
-- Aksesoris
('Jam Tangan Casio G-Shock', 3, '/photos/item8.jpg', 'Toilet Gedung A', 'Jam tangan Casio G-Shock warna hitam dengan strip orange, tali karet, ada goresan di layar', 'Baterai berusia 2 tahun, tali karet masih lentur, tahan air', '2024-02-03', 'unclaimed', 3, 'Bu Siti', '081234567892', 35, '2024-05-03 13:00:00'),
('Kacamata Minus', 3, '/photos/item9.jpg', 'Masjid Kampus', 'Kacamata minus frame hitam persegi, lensa agak tebal, ada case warna coklat', 'Minus -4.00 untuk kedua mata, lensa anti radiasi, frame bagus', '2024-02-05', 'unclaimed', 2, 'Pak Budi', '081234567891', 22, '2024-05-05 16:30:00'),
-- Alat Tulis
('Buku Kalkulus', 5, '/photos/item10.jpg', 'Gedung C lantai 3', 'Buku Kalkulus karangan Purcell edisi 9, sampul biru, ada coretan nama di halaman pertama (nama dicoret)', 'Halaman lengkap, tidak ada yang hilang, tulisan tangan di margin', '2024-02-08', 'unclaimed', 3, 'Bu Siti', '081234567892', 13, '2024-05-08 09:00:00'),
('Pensil Mekanik Rotring', 5, '/photos/item11.jpg', 'Studio Gambar', 'Pensil mekanik Rotring Rapid Pro 0.5mm warna silver, agak berat, ada penyok kecil di badan', 'Grip karet masih bagus, mekanisme click terasa presisi', '2024-02-10', 'unclaimed', 2, 'Pak Budi', '081234567891', 8, '2024-05-10 14:45:00');
-- ============================================
-- SEED LOST_ITEMS (Barang Hilang)
-- ============================================
INSERT INTO lost_items (user_id, name, category_id, color, location, description, date_lost, status, resolved_at) VALUES
-- User Ahmad
(4, 'Jaket Hitam', 1, 'Hitam', 'Gedung A', 'Jaket hitam merk Nike ukuran M dengan logo putih di dada, resleting silver', '2024-01-15', 'active', NULL),
(4, 'Kalkulator Casio Scientific', 4, 'Hitam', 'Ruang Kelas', 'Kalkulator scientific Casio FX-991ID Plus warna hitam', '2024-01-25', 'active', NULL),
-- User Siti
(5, 'Botol Minum Biru', 2, 'Biru', 'Kantin', 'Botol tupperware biru dengan stiker nama RARA', '2024-01-20', 'active', NULL),
(5, 'Jam Tangan Casio', 3, 'Hitam', 'Toilet', 'Jam tangan G-Shock hitam dengan strip orange', '2024-02-03', 'active', NULL),
-- User Budi
(6, 'Mouse Wireless', 4, 'Merah', 'Lab Komputer', 'Mouse wireless Logitech warna merah tanpa receiver', '2024-01-28', 'active', NULL),
-- User Dewi
(7, 'Buku Kalkulus', 5, 'Biru', 'Gedung C', 'Buku Kalkulus Purcell edisi 9 sampul biru', '2024-02-08', 'active', NULL),
-- User Eko
(8, 'Kacamata Minus', 3, 'Hitam', 'Masjid', 'Kacamata frame hitam persegi dengan case coklat', '2024-02-05', 'active', NULL);
-- ============================================
-- SEED ATTACHMENTS (Foto Barang)
-- ============================================
INSERT INTO attachments (item_id, lost_item_id, file_url, file_type, file_size, upload_by_user_id, display_order, is_primary) VALUES
-- Attachments untuk items (barang ditemukan)
(1, NULL, '/photos/items/jaket-nike-1.jpg', 'jpg', 2048576, 2, 1, TRUE),
(1, NULL, '/photos/items/jaket-nike-2.jpg', 'jpg', 1843200, 2, 2, FALSE),
(3, NULL, '/photos/items/botol-tupperware-1.jpg', 'jpg', 1536000, 2, 1, TRUE),
(5, NULL, '/photos/items/kalkulator-casio-1.jpg', 'jpg', 1920000, 2, 1, TRUE),
(5, NULL, '/photos/items/kalkulator-casio-2.jpg', 'jpg', 1720320, 2, 2, FALSE),
(8, NULL, '/photos/items/jam-tangan-1.jpg', 'jpg', 2150400, 3, 1, TRUE),
-- Attachments untuk lost_items (barang hilang)
(NULL, 1, '/photos/lost_items/jaket-hilang-1.jpg', 'jpg', 1843200, 4, 1, TRUE),
(NULL, 3, '/photos/lost_items/botol-hilang-1.jpg', 'jpg', 1638400, 5, 1, TRUE),
(NULL, 4, '/photos/lost_items/jam-tangan-hilang-1.jpg', 'jpg', 2048576, 5, 1, TRUE),
(NULL, 5, '/photos/lost_items/mouse-hilang-1.jpg', 'jpg', 1434880, 6, 1, TRUE);
-- ============================================
-- SEED CLAIMS (Klaim Barang)
-- ============================================
INSERT INTO claims (item_id, user_id, description, proof_url, contact, status, notes, rejection_reason, attempt_count, verified_at, verified_by) VALUES
-- Claim pending (belum diverifikasi)
(1, 4, 'Jaket Nike hitam ukuran M, ada logo putih di dada kiri, resleting silver', '/proofs/claim1.jpg', '081234567893', 'pending', NULL, NULL, 1, NULL, NULL),
(3, 5, 'Botol tupperware biru dengan stiker nama RARA di samping, tutup putih', '/proofs/claim2.jpg', '081234567894', 'pending', NULL, NULL, 1, NULL, NULL),
-- Claim yang sudah approved
(5, 4, 'Kalkulator Casio FX-991ID Plus warna hitam, ada goresan kecil di layar, baterai masih bagus', '/proofs/claim3.jpg', '081234567893', 'approved', 'Deskripsi cocok dengan secret details, barang diserahkan tanggal 2024-02-09', NULL, 1, '2024-02-09 10:30:00', 2);
-- ============================================
-- SEED CLAIM_VERIFICATIONS
-- ============================================
INSERT INTO claim_verifications (claim_id, similarity_score, matched_keywords, verification_notes, is_auto_matched, verification_method, metadata) VALUES
(1, 85.50, '["jaket", "nike", "hitam", "logo", "putih", "resleting", "silver"]', 'High similarity detected in description and secret details', FALSE, 'manual', JSON_OBJECT(
'description_match', 85,
'keywords_match', 90,
'confidence', 'high',
'reviewer_notes', 'Sangat sesuai dengan foto dan deskripsi'
)),
(2, 92.30, '["botol", "tupperware", "biru", "stiker", "rara", "tutup", "putih"]', 'Very high similarity - likely owner, specific details match perfectly', FALSE, 'manual', JSON_OBJECT(
'description_match', 95,
'keywords_match', 94,
'confidence', 'very_high',
'reviewer_notes', 'Pemilik tahu detail spesifik dari botol'
)),
(3, 88.70, '["kalkulator", "casio", "hitam", "goresan", "layar", "baterai"]', 'Verified and approved - exact match with secret details', TRUE, 'hybrid', JSON_OBJECT(
'description_match', 92,
'keywords_match', 89,
'confidence', 'very_high',
'auto_match_score', 85,
'manual_review', 'Confirmed by manager'
));
-- ============================================
-- SEED VERIFICATION_LOGS
-- ============================================
INSERT INTO verification_logs (verification_id, verified_by_user_id, action, reason) VALUES
(3, 2, 'approve', 'Deskripsi dan detail rahasia cocok sempurna. Klaim disetujui dan barang sudah diserahkan kepada Ahmad Rizki pada 2024-02-09 pukul 10:30 dengan tanda tangan.'),
(1, 2, 'pending', 'Menunggu konfirmasi lebih lanjut dari manajer. Saat ini sedang dalam review awal.'),
(2, 2, 'pending', 'Dalam proses verifikasi. Akan hubungi claimant untuk konfirmasi lebih detail.');
-- ============================================
-- SEED MATCH_RESULTS (Auto-Matching)
-- ============================================
INSERT INTO match_results (lost_item_id, item_id, similarity_score, matched_fields, match_reason, matched_at, is_notified, notified_at) VALUES
(1, 1, 87.50, '{"name": 85, "category": 100, "description": 90, "color": 100}', 'color, description, category match', '2024-01-15 10:00:00', TRUE, '2024-01-15 10:15:00'),
(2, 5, 89.20, '{"name": 88, "category": 100, "description": 91}', 'name, category, description match', '2024-01-25 09:00:00', TRUE, '2024-01-25 09:30:00'),
(3, 3, 91.80, '{"name": 90, "category": 100, "color": 100, "description": 89}', 'color, category match perfectly', '2024-01-20 13:00:00', TRUE, '2024-01-20 13:45:00'),
(4, 8, 86.40, '{"name": 82, "category": 100, "color": 100, "description": 85}', 'color, category match', '2024-02-03 14:00:00', TRUE, '2024-02-03 14:20:00'),
(5, 6, 84.60, '{"name": 80, "category": 100, "color": 100, "description": 88}', 'color, category match', '2024-01-28 16:00:00', FALSE, NULL);
-- ============================================
-- SEED NOTIFICATIONS
-- ============================================
INSERT INTO notifications (user_id, type, title, message, entity_type, entity_id, channel, is_read, read_at) VALUES
-- Notifikasi match ditemukan
(4, 'match_found', 'Barang yang Mirip Ditemukan!', 'Kami menemukan barang yang mirip dengan laporan kehilangan Anda: Jaket Hitam Nike. Similarity Score: 87.5%', 'match', 1, 'push', TRUE, '2024-01-15 11:00:00'),
(4, 'match_found', 'Barang yang Mirip Ditemukan!', 'Kami menemukan barang yang mirip dengan laporan kehilangan Anda: Kalkulator Casio FX-991ID Plus. Similarity Score: 89.2%', 'match', 2, 'push', FALSE, NULL),
(5, 'match_found', 'Barang yang Mirip Ditemukan!', 'Kami menemukan barang yang mirip dengan laporan kehilangan Anda: Botol Minum Tupperware Biru. Similarity Score: 91.8%', 'match', 3, 'push', FALSE, NULL),
-- Notifikasi klaim disetujui
(4, 'claim_approved', 'Klaim Disetujui!', 'Klaim Anda untuk barang Kalkulator Casio FX-991ID Plus telah disetujui. Silakan ambil barang di tempat yang ditentukan.', 'claim', 3, 'email', FALSE, NULL),
-- Notifikasi untuk manager (pending claims)
(2, 'new_claim', 'Klaim Baru', 'Ada klaim baru untuk barang: Jaket Hitam Nike dari Ahmad Rizki. Similarity Score: 85.5%', 'claim', 1, 'push', FALSE, NULL),
(2, 'new_claim', 'Klaim Baru', 'Ada klaim baru untuk barang: Botol Minum Tupperware Biru dari Siti Nurhaliza. Similarity Score: 92.3%', 'claim', 2, 'push', FALSE, NULL);
-- ============================================
-- SEED AUDIT_LOGS
-- ============================================
INSERT INTO audit_logs (user_id, action, entity_type, entity_id, details, ip_address, user_agent) VALUES
-- Login activities
(1, 'login', 'user', 1, 'Admin logged in', '127.0.0.1', 'Mozilla/5.0'),
(2, 'login', 'user', 2, 'Manager logged in', '127.0.0.1', 'Mozilla/5.0'),
(4, 'login', 'user', 4, 'User logged in', '127.0.0.1', 'Mozilla/5.0'),
-- Item creation activities
(2, 'create', 'item', 1, 'Item created: Jaket Hitam Nike', '127.0.0.1', 'Mozilla/5.0'),
(3, 'create', 'item', 2, 'Item created: Sweater Abu-abu', '127.0.0.1', 'Mozilla/5.0'),
(2, 'create', 'item', 3, 'Item created: Botol Minum Tupperware Biru', '127.0.0.1', 'Mozilla/5.0'),
-- Lost item creation activities
(4, 'create', 'lost_item', 1, 'Lost item report created: Jaket Hitam', '127.0.0.1', 'Mozilla/5.0'),
(5, 'create', 'lost_item', 3, 'Lost item report created: Botol Minum Biru', '127.0.0.1', 'Mozilla/5.0'),
-- Claim activities
(4, 'create', 'claim', 1, 'Claim created for item: Jaket Hitam Nike', '127.0.0.1', 'Mozilla/5.0'),
(5, 'create', 'claim', 2, 'Claim created for item: Botol Minum Tupperware Biru', '127.0.0.1', 'Mozilla/5.0'),
(4, 'create', 'claim', 3, 'Claim created for item: Kalkulator Casio FX-991ID Plus', '127.0.0.1', 'Mozilla/5.0'),
-- Claim verification activity
(2, 'approve', 'claim', 3, 'Claim approved: Deskripsi cocok dengan secret details, barang diserahkan', '127.0.0.1', 'Mozilla/5.0'),
-- Attachment upload
(2, 'create', 'attachment', 1, 'Attachment uploaded for item 1', '127.0.0.1', 'Mozilla/5.0'),
(4, 'create', 'attachment', 7, 'Attachment uploaded for lost_item 1', '127.0.0.1', 'Mozilla/5.0');
SET FOREIGN_KEY_CHECKS = 1;
-- ============================================
-- SUCCESS MESSAGE
-- ============================================
SELECT '✅ Database seeded successfully!' AS Status;
SELECT '👥 Users created: 8 (1 admin, 2 managers, 5 students)' AS Info;
SELECT '📦 Items created: 11 found items' AS Info;
SELECT '📝 Lost items created: 7 reports' AS Info;
SELECT '📸 Attachments created: 11 photos' AS Info;
SELECT '🎫 Claims created: 3 (1 approved, 2 pending)' AS Info;
SELECT '✔️ Claim verifications created: 3' AS Info;
SELECT '🔍 Verification logs created: 3' AS Info;
SELECT '🔗 Match results created: 5' AS Info;
SELECT '🔔 Notifications created: 6' AS Info;
SELECT '📋 Audit logs created: 13' AS Info;
SELECT '' AS Empty;
SELECT '🔐 Login Credentials:' AS Credentials;
SELECT 'Admin: admin@lostandfound.com / password123' AS Admin;
SELECT 'Manager: manager1@lostandfound.com / password123' AS Manager1;
SELECT 'Manager: manager2@lostandfound.com / password123' AS Manager2;
SELECT 'Student: ahmad@student.com / password123' AS Student;
SELECT '' AS Empty2;
SELECT '✨ NOW 100% SYNC with ERD!' AS Status2;
SELECT '🚀 Ready to use! Database is production-ready' AS NextStep;
// internal/config/config.go
package config
import (
"os"
)
// Config holds all configuration for the application
type Config struct {
Database DatabaseConfig
JWT JWTConfig
Server ServerConfig
}
// ServerConfig holds server configuration
type ServerConfig struct {
Port string
Environment string
UploadPath string
MaxUploadSize int64
AllowedOrigins []string
}
// GetConfig returns the application configuration
func GetConfig() *Config {
return &Config{
Database: GetDatabaseConfig(),
JWT: GetJWTConfig(),
Server: GetServerConfig(),
}
}
// GetServerConfig returns server configuration from environment
func GetServerConfig() ServerConfig {
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
env := os.Getenv("ENVIRONMENT")
if env == "" {
env = "development"
}
uploadPath := os.Getenv("UPLOAD_PATH")
if uploadPath == "" {
uploadPath = "./uploads"
}
return ServerConfig{
Port: port,
Environment: env,
UploadPath: uploadPath,
MaxUploadSize: 10 * 1024 * 1024, // 10MB
AllowedOrigins: []string{"*"}, // In production, specify exact origins
}
}
// IsProduction checks if running in production environment
func IsProduction() bool {
return os.Getenv("ENVIRONMENT") == "production"
}
// IsDevelopment checks if running in development environment
func IsDevelopment() bool {
return os.Getenv("ENVIRONMENT") != "production"
}
package config
import (
"fmt"
"log"
"lost-and-found/internal/models"
"os"
"strings"
"time"
"gorm.io/driver/mysql"
"gorm.io/gorm"
"gorm.io/gorm/logger"
)
var db *gorm.DB
// DatabaseConfig holds database connection configuration
type DatabaseConfig struct {
Host string
Port string
User string
Password string
DBName string
Charset string
ParseTime string
Loc string
}
// GetDatabaseConfig returns database configuration from environment
func GetDatabaseConfig() DatabaseConfig {
return DatabaseConfig{
Host: getEnv("DB_HOST", "localhost"),
Port: getEnv("DB_PORT", "3306"),
User: getEnv("DB_USER", "root"),
Password: getEnv("DB_PASSWORD", ""),
DBName: getEnv("DB_NAME", "lost_and_found"),
Charset: getEnv("DB_CHARSET", "utf8mb4"),
ParseTime: getEnv("DB_PARSE_TIME", "True"),
Loc: getEnv("DB_LOC", "Local"),
}
}
// InitDB initializes database connection
func InitDB() error {
config := GetDatabaseConfig()
// Step 1: Connect to MySQL without specifying database (to create if not exists)
if err := ensureDatabaseExists(config); err != nil {
return err
}
// Step 2: Connect to the specific database
dsn := fmt.Sprintf(
"%s:%s@tcp(%s:%s)/%s?charset=%s&parseTime=%s&loc=%s&multiStatements=true",
config.User,
config.Password,
config.Host,
config.Port,
config.DBName,
config.Charset,
config.ParseTime,
config.Loc,
)
// Configure GORM logger
gormLogger := logger.Default
if IsDevelopment() {
gormLogger = logger.Default.LogMode(logger.Info)
} else {
gormLogger = logger.Default.LogMode(logger.Error)
}
// Open database connection
var err error
db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
Logger: gormLogger,
NowFunc: func() time.Time {
return time.Now().Local()
},
})
if err != nil {
return fmt.Errorf("failed to connect to database: %w", err)
}
// Get underlying SQL database
sqlDB, err := db.DB()
if err != nil {
return fmt.Errorf("failed to get database instance: %w", err)
}
// Set connection pool settings
sqlDB.SetMaxIdleConns(10)
sqlDB.SetMaxOpenConns(100)
sqlDB.SetConnMaxLifetime(time.Hour)
// Test connection
if err := sqlDB.Ping(); err != nil {
return fmt.Errorf("failed to ping database: %w", err)
}
log.Println("✅ Database connected successfully")
return nil
}
// ensureDatabaseExists checks if database exists, creates it if not
func ensureDatabaseExists(config DatabaseConfig) error {
// Connect to MySQL without specifying a database
dsn := fmt.Sprintf(
"%s:%s@tcp(%s:%s)/?charset=%s&parseTime=%s&loc=%s",
config.User,
config.Password,
config.Host,
config.Port,
config.Charset,
config.ParseTime,
config.Loc,
)
tempDB, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
Logger: logger.Default.LogMode(logger.Silent),
})
if err != nil {
return fmt.Errorf("failed to connect to MySQL server: %w", err)
}
log.Printf("🔍 Checking if database '%s' exists...", config.DBName)
// Check if database exists
var dbExists int64
if err := tempDB.Raw(
"SELECT COUNT(*) FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = ?",
config.DBName,
).Scan(&dbExists).Error; err != nil {
return fmt.Errorf("failed to check database existence: %w", err)
}
if dbExists == 0 {
log.Printf("📝 Creating database '%s'...", config.DBName)
createSQL := fmt.Sprintf(
"CREATE DATABASE IF NOT EXISTS %s CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci",
config.DBName,
)
if err := tempDB.Exec(createSQL).Error; err != nil {
return fmt.Errorf("failed to create database: %w", err)
}
log.Printf("✅ Database '%s' created successfully", config.DBName)
} else {
log.Printf("✅ Database '%s' already exists", config.DBName)
}
// Close temporary connection
sqlDB, _ := tempDB.DB()
sqlDB.Close()
return nil
}
// GetDB returns the database instance
func GetDB() *gorm.DB {
return db
}
// RunMigrations runs database migrations from SQL files
func RunMigrations(db *gorm.DB) error {
log.Println("📊 Starting database migrations...")
// Check if tables already exist
if db.Migrator().HasTable(&models.Role{}) {
log.Println("✅ Database tables already exist, skipping migration")
return nil
}
log.Println("📋 Tables not found, running migration scripts...")
// Step 1: Run schema.sql
if err := runSQLFile(db, "database/schema.sql"); err != nil {
return fmt.Errorf("❌ Failed to run schema.sql: %w", err)
}
log.Println("✅ Schema created successfully")
// Step 2: Run seed.sql
if err := runSQLFile(db, "database/seed.sql"); err != nil {
return fmt.Errorf("❌ Failed to run seed.sql: %w", err)
}
log.Println("✅ Seed data inserted successfully")
// Step 3: Run enhancement.sql (optional - for triggers, procedures, etc)
if err := runSQLFile(db, "database/enhancement.sql"); err != nil {
log.Printf("⚠️ Warning: Failed to run enhancement.sql: %v", err)
log.Println("💡 Enhancement features (triggers, procedures) may not be available")
} else {
log.Println("✅ Enhancement features loaded successfully")
}
log.Println("🎉 Database migration completed!")
log.Println("🔧 Default admin: admin@lostandfound.com / password123")
return nil
}
// runSQLFile executes SQL from file
func runSQLFile(db *gorm.DB, filepath string) error {
// Check if file exists
if _, err := os.Stat(filepath); os.IsNotExist(err) {
return fmt.Errorf("file not found: %s", filepath)
}
log.Printf("📄 Reading SQL file: %s", filepath)
// Read file
content, err := os.ReadFile(filepath)
if err != nil {
return fmt.Errorf("failed to read file: %w", err)
}
// Split SQL content by delimiter
sqlContent := string(content)
// Remove comments and empty lines
sqlContent = removeComments(sqlContent)
// Split by DELIMITER if exists (for procedures/triggers)
if strings.Contains(sqlContent, "DELIMITER") {
return executeSQLWithDelimiter(db, sqlContent)
}
// Execute SQL normally
if err := db.Exec(sqlContent).Error; err != nil {
return fmt.Errorf("failed to execute SQL: %w", err)
}
log.Printf("✅ SQL file executed: %s", filepath)
return nil
}
// executeSQLWithDelimiter handles SQL with custom delimiters (for procedures/triggers)
func executeSQLWithDelimiter(db *gorm.DB, content string) error {
// Split by DELIMITER changes
parts := strings.Split(content, "DELIMITER")
for i, part := range parts {
part = strings.TrimSpace(part)
if part == "" || part == "$$" || part == ";" {
continue
}
// Remove the delimiter declaration line
lines := strings.Split(part, "\n")
if len(lines) > 0 && (strings.HasPrefix(lines[0], "$$") || strings.HasPrefix(lines[0], ";")) {
lines = lines[1:]
}
part = strings.Join(lines, "\n")
// Split by custom delimiter ($$)
if i%2 == 1 { // Odd parts use $$ delimiter
statements := strings.Split(part, "$$")
for _, stmt := range statements {
stmt = strings.TrimSpace(stmt)
if stmt == "" || stmt == ";" {
continue
}
if err := db.Exec(stmt).Error; err != nil {
log.Printf("⚠️ Warning executing statement: %v", err)
// Don't fail on enhancement errors (triggers, procedures)
// These might fail if they already exist or MySQL version issues
}
}
} else { // Even parts use ; delimiter
statements := strings.Split(part, ";")
for _, stmt := range statements {
stmt = strings.TrimSpace(stmt)
if stmt == "" {
continue
}
if err := db.Exec(stmt).Error; err != nil {
return fmt.Errorf("failed to execute statement: %w", err)
}
}
}
}
return nil
}
// removeComments removes SQL comments from content
func removeComments(sql string) string {
lines := strings.Split(sql, "\n")
var cleaned []string
for _, line := range lines {
line = strings.TrimSpace(line)
// Skip empty lines
if line == "" {
continue
}
// Skip single-line comments
if strings.HasPrefix(line, "--") || strings.HasPrefix(line, "#") {
continue
}
// Keep the line
cleaned = append(cleaned, line)
}
return strings.Join(cleaned, "\n")
}
// CloseDB closes database connection
func CloseDB() error {
if db != nil {
sqlDB, err := db.DB()
if err != nil {
return err
}
return sqlDB.Close()
}
return nil
}
// Helper function to get environment variable with default value
func getEnv(key, defaultValue string) string {
value := os.Getenv(key)
if value == "" {
return defaultValue
}
return value
}
// internal/config/jwt.go
package config
import (
"errors"
"os"
"time"
"github.com/golang-jwt/jwt/v5"
)
var jwtConfig *JWTConfig
// JWTConfig holds JWT configuration
type JWTConfig struct {
SecretKey string
ExpirationHours int
Issuer string
}
// JWTClaims represents the JWT claims
type JWTClaims struct {
UserID uint `json:"user_id"`
Email string `json:"email"`
Role string `json:"role"`
jwt.RegisteredClaims
}
// InitJWT initializes JWT configuration
func InitJWT() {
secretKey := os.Getenv("JWT_SECRET_KEY")
if secretKey == "" {
secretKey = "your-secret-key-change-this-in-production" // Default for development
}
jwtConfig = &JWTConfig{
SecretKey: secretKey,
ExpirationHours: 24 * 7, // 7 days
Issuer: "lost-and-found-system",
}
}
// GetJWTConfig returns JWT configuration
func GetJWTConfig() JWTConfig {
if jwtConfig == nil {
InitJWT()
}
return *jwtConfig
}
// GenerateToken generates a new JWT token for a user
func GenerateToken(userID uint, email, role string) (string, error) {
config := GetJWTConfig()
// Create claims
claims := JWTClaims{
UserID: userID,
Email: email,
Role: role,
RegisteredClaims: jwt.RegisteredClaims{
ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * time.Duration(config.ExpirationHours))),
IssuedAt: jwt.NewNumericDate(time.Now()),
Issuer: config.Issuer,
},
}
// Create token
token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
// Sign token with secret key
tokenString, err := token.SignedString([]byte(config.SecretKey))
if err != nil {
return "", err
}
return tokenString, nil
}
// ValidateToken validates a JWT token and returns the claims
func ValidateToken(tokenString string) (*JWTClaims, error) {
config := GetJWTConfig()
// Parse token
token, err := jwt.ParseWithClaims(tokenString, &JWTClaims{}, func(token *jwt.Token) (interface{}, error) {
// Validate signing method
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, errors.New("invalid signing method")
}
return []byte(config.SecretKey), nil
})
if err != nil {
return nil, err
}
// Extract claims
if claims, ok := token.Claims.(*JWTClaims); ok && token.Valid {
return claims, nil
}
return nil, errors.New("invalid token")
}
// RefreshToken generates a new token with extended expiration
func RefreshToken(oldTokenString string) (string, error) {
// Validate old token
claims, err := ValidateToken(oldTokenString)
if err != nil {
return "", err
}
// Generate new token with same user info
return GenerateToken(claims.UserID, claims.Email, claims.Role)
}
// ExtractUserID extracts user ID from token string
func ExtractUserID(tokenString string) (uint, error) {
claims, err := ValidateToken(tokenString)
if err != nil {
return 0, err
}
return claims.UserID, nil
}
// ExtractRole extracts role from token string
func ExtractRole(tokenString string) (string, error) {
claims, err := ValidateToken(tokenString)
if err != nil {
return "", err
}
return claims.Role, nil
}
// internal/controllers/admin_controller.go
package controllers
import (
"lost-and-found/internal/repositories"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type AdminController struct {
userService *services.UserService
itemRepo *repositories.ItemRepository
claimRepo *repositories.ClaimRepository
archiveRepo *repositories.ArchiveRepository
auditService *services.AuditService
}
func NewAdminController(db *gorm.DB) *AdminController {
return &AdminController{
userService: services.NewUserService(db),
itemRepo: repositories.NewItemRepository(db),
claimRepo: repositories.NewClaimRepository(db),
archiveRepo: repositories.NewArchiveRepository(db),
auditService: services.NewAuditService(db),
}
}
// GetDashboardStats gets dashboard statistics (admin/manager)
// GET /api/admin/dashboard
func (c *AdminController) GetDashboardStats(ctx *gin.Context) {
stats := make(map[string]interface{})
// Item statistics
totalItems, _ := c.itemRepo.CountByStatus("")
unclaimedItems, _ := c.itemRepo.CountByStatus("unclaimed")
verifiedItems, _ := c.itemRepo.CountByStatus("verified")
expiredItems, _ := c.itemRepo.CountByStatus("expired")
stats["items"] = map[string]interface{}{
"total": totalItems,
"unclaimed": unclaimedItems,
"verified": verifiedItems,
"expired": expiredItems,
}
// Claim statistics
totalClaims, _ := c.claimRepo.CountByStatus("")
pendingClaims, _ := c.claimRepo.CountByStatus("pending")
approvedClaims, _ := c.claimRepo.CountByStatus("approved")
rejectedClaims, _ := c.claimRepo.CountByStatus("rejected")
stats["claims"] = map[string]interface{}{
"total": totalClaims,
"pending": pendingClaims,
"approved": approvedClaims,
"rejected": rejectedClaims,
}
// Archive statistics
archivedExpired, _ := c.archiveRepo.CountByReason("expired")
archivedClosed, _ := c.archiveRepo.CountByReason("case_closed")
stats["archives"] = map[string]interface{}{
"total": archivedExpired + archivedClosed,
"expired": archivedExpired,
"case_closed": archivedClosed,
}
utils.SuccessResponse(ctx, http.StatusOK, "Dashboard stats retrieved", stats)
}
// GetAuditLogs gets audit logs (admin only)
// GET /api/admin/audit-logs
func (c *AdminController) GetAuditLogs(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "20"))
action := ctx.Query("action")
entityType := ctx.Query("entity_type")
var userID *uint
if userIDStr := ctx.Query("user_id"); userIDStr != "" {
id, _ := strconv.ParseUint(userIDStr, 10, 32)
userID = new(uint)
*userID = uint(id)
}
logs, total, err := c.auditService.GetAllAuditLogs(page, limit, action, entityType, userID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get audit logs", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Audit logs retrieved", logs, total, page, limit)
}
// internal/controllers/archive_controller.go
package controllers
import (
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type ArchiveController struct {
archiveService *services.ArchiveService
}
func NewArchiveController(db *gorm.DB) *ArchiveController {
return &ArchiveController{
archiveService: services.NewArchiveService(db),
}
}
// GetAllArchives gets all archived items
// GET /api/archives
func (c *ArchiveController) GetAllArchives(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
reason := ctx.Query("reason")
search := ctx.Query("search")
archives, total, err := c.archiveService.GetAllArchives(page, limit, reason, search)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get archives", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Archives retrieved", archives, total, page, limit)
}
// GetArchiveByID gets archive by ID
// GET /api/archives/:id
func (c *ArchiveController) GetArchiveByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid archive ID", err.Error())
return
}
archive, err := c.archiveService.GetArchiveByID(uint(id))
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Archive not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Archive retrieved", archive.ToResponse())
}
// GetArchiveStats gets archive statistics
// GET /api/archives/stats
func (c *ArchiveController) GetArchiveStats(ctx *gin.Context) {
stats, err := c.archiveService.GetArchiveStats()
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get stats", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Archive stats retrieved", stats)
}
// internal/controllers/auth_controller.go
package controllers
import (
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type AuthController struct {
authService *services.AuthService
}
func NewAuthController(db *gorm.DB) *AuthController {
return &AuthController{
authService: services.NewAuthService(db),
}
}
// Register handles user registration
// POST /api/register
func (c *AuthController) Register(ctx *gin.Context) {
var req services.RegisterRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
// Get IP and User-Agent
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
// Register user
result, err := c.authService.Register(req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Registration failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusCreated, "Registration successful", result)
}
// Login handles user login
// POST /api/login
func (c *AuthController) Login(ctx *gin.Context) {
var req services.LoginRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
// Get IP and User-Agent
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
// Login user
result, err := c.authService.Login(req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Login failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Login successful", result)
}
// RefreshToken handles token refresh
// POST /api/refresh-token
func (c *AuthController) RefreshToken(ctx *gin.Context) {
var req struct {
Token string `json:"token" binding:"required"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
// Refresh token
newToken, err := c.authService.RefreshToken(req.Token)
if err != nil {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Token refresh failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Token refreshed", gin.H{
"token": newToken,
})
}
// GetMe returns current user info
// GET /api/me
func (c *AuthController) GetMe(ctx *gin.Context) {
user, exists := ctx.Get("user")
if !exists {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "User not found", "")
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User info retrieved", user)
}
// internal/controllers/category_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type CategoryController struct {
categoryService *services.CategoryService
}
func NewCategoryController(db *gorm.DB) *CategoryController {
return &CategoryController{
categoryService: services.NewCategoryService(db),
}
}
// GetAllCategories gets all categories
// GET /api/categories
func (c *CategoryController) GetAllCategories(ctx *gin.Context) {
categories, err := c.categoryService.GetAllCategories()
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get categories", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Categories retrieved", categories)
}
// GetCategoryByID gets category by ID
// GET /api/categories/:id
func (c *CategoryController) GetCategoryByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid category ID", err.Error())
return
}
category, err := c.categoryService.GetCategoryByID(uint(id))
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Category not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Category retrieved", category.ToResponse())
}
// CreateCategory creates a new category (admin only)
// POST /api/categories
func (c *CategoryController) CreateCategory(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
var req services.CreateCategoryRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
category, err := c.categoryService.CreateCategory(admin.ID, req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to create category", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusCreated, "Category created", category.ToResponse())
}
// UpdateCategory updates a category (admin only)
// PUT /api/categories/:id
func (c *CategoryController) UpdateCategory(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
categoryID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid category ID", err.Error())
return
}
var req services.UpdateCategoryRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
category, err := c.categoryService.UpdateCategory(admin.ID, uint(categoryID), req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update category", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Category updated", category.ToResponse())
}
// DeleteCategory deletes a category (admin only)
// DELETE /api/categories/:id
func (c *CategoryController) DeleteCategory(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
categoryID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid category ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.categoryService.DeleteCategory(admin.ID, uint(categoryID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to delete category", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Category deleted", nil)
}
// internal/controllers/claim_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type ClaimController struct {
claimService *services.ClaimService
verificationService *services.VerificationService
}
func NewClaimController(db *gorm.DB) *ClaimController {
return &ClaimController{
claimService: services.NewClaimService(db),
verificationService: services.NewVerificationService(db),
}
}
// GetAllClaims gets all claims
// GET /api/claims
func (c *ClaimController) GetAllClaims(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
status := ctx.Query("status")
var itemID, userID *uint
if itemIDStr := ctx.Query("item_id"); itemIDStr != "" {
id, _ := strconv.ParseUint(itemIDStr, 10, 32)
itemID = new(uint)
*itemID = uint(id)
}
// If regular user, only show their claims
if userObj, exists := ctx.Get("user"); exists {
user := userObj.(*models.User)
if user.IsUser() {
userID = &user.ID
}
}
claims, total, err := c.claimService.GetAllClaims(page, limit, status, itemID, userID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get claims", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Claims retrieved", claims, total, page, limit)
}
// GetClaimByID gets claim by ID
// GET /api/claims/:id
func (c *ClaimController) GetClaimByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid claim ID", err.Error())
return
}
isManager := false
if userObj, exists := ctx.Get("user"); exists {
user := userObj.(*models.User)
isManager = user.IsManager() || user.IsAdmin()
}
claim, err := c.claimService.GetClaimByID(uint(id), isManager)
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Claim not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Claim retrieved", claim)
}
// CreateClaim creates a new claim
// POST /api/claims
func (c *ClaimController) CreateClaim(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.CreateClaimRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
claim, err := c.claimService.CreateClaim(user.ID, req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to create claim", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusCreated, "Claim created", claim.ToResponse())
}
// VerifyClaim verifies a claim (manager only)
// POST /api/claims/:id/verify
func (c *ClaimController) VerifyClaim(ctx *gin.Context) {
managerObj, _ := ctx.Get("user")
manager := managerObj.(*models.User)
claimID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid claim ID", err.Error())
return
}
var req services.VerifyClaimRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
// Auto-verify description similarity
verification, err := c.verificationService.VerifyClaimDescription(uint(claimID))
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Verification failed", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
// Verify the claim
if err := c.claimService.VerifyClaim(
manager.ID,
uint(claimID),
req,
verification.SimilarityScore,
stringSliceToString(verification.MatchedKeywords),
ipAddress,
userAgent,
); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to verify claim", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Claim verified", gin.H{
"verification": verification,
})
}
// GetClaimVerification gets verification data for a claim
// GET /api/claims/:id/verification
func (c *ClaimController) GetClaimVerification(ctx *gin.Context) {
claimID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid claim ID", err.Error())
return
}
verification, err := c.verificationService.VerifyClaimDescription(uint(claimID))
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Verification failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Verification retrieved", verification)
}
// CloseClaim closes a claim (manager only)
// POST /api/claims/:id/close
func (c *ClaimController) CloseClaim(ctx *gin.Context) {
managerObj, _ := ctx.Get("user")
manager := managerObj.(*models.User)
claimID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid claim ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.claimService.CloseClaim(manager.ID, uint(claimID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to close claim", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Claim closed and archived", nil)
}
// DeleteClaim deletes a claim
// DELETE /api/claims/:id
func (c *ClaimController) DeleteClaim(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
claimID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid claim ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.claimService.DeleteClaim(user.ID, uint(claimID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to delete claim", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Claim deleted", nil)
}
// GetClaimsByUser gets claims by user
// GET /api/user/claims
func (c *ClaimController) GetClaimsByUser(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
claims, total, err := c.claimService.GetClaimsByUser(user.ID, page, limit)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get claims", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Claims retrieved", claims, total, page, limit)
}
// Helper function to convert string slice to string
func stringSliceToString(slice []string) string {
if len(slice) == 0 {
return ""
}
result := ""
for i, s := range slice {
if i > 0 {
result += ", "
}
result += s
}
return result
}
// internal/controllers/item_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type ItemController struct {
itemService *services.ItemService
matchService *services.MatchService
}
func NewItemController(db *gorm.DB) *ItemController {
return &ItemController{
itemService: services.NewItemService(db),
matchService: services.NewMatchService(db),
}
}
// GetAllItems gets all items (public)
// GET /api/items
func (c *ItemController) GetAllItems(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
status := ctx.Query("status")
category := ctx.Query("category")
search := ctx.Query("search")
items, total, err := c.itemService.GetAllItems(page, limit, status, category, search)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get items", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Items retrieved", items, total, page, limit)
}
// GetItemByID gets item by ID
// GET /api/items/:id
func (c *ItemController) GetItemByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
// Check if user is manager or admin
isManager := false
if userObj, exists := ctx.Get("user"); exists {
user := userObj.(*models.User)
isManager = user.IsManager() || user.IsAdmin()
}
item, err := c.itemService.GetItemByID(uint(id), isManager)
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Item not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Item retrieved", item)
}
// CreateItem creates a new item
// POST /api/items
func (c *ItemController) CreateItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.CreateItemRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
item, err := c.itemService.CreateItem(user.ID, req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to create item", err.Error())
return
}
// Auto-match with lost items
go c.matchService.AutoMatchNewItem(item.ID)
utils.SuccessResponse(ctx, http.StatusCreated, "Item created", item.ToDetailResponse())
}
// UpdateItem updates an item
// PUT /api/items/:id
func (c *ItemController) UpdateItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
itemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
var req services.UpdateItemRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
item, err := c.itemService.UpdateItem(user.ID, uint(itemID), req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update item", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Item updated", item.ToDetailResponse())
}
// UpdateItemStatus updates item status
// PATCH /api/items/:id/status
func (c *ItemController) UpdateItemStatus(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
itemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
var req struct {
Status string `json:"status" binding:"required"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.itemService.UpdateItemStatus(user.ID, uint(itemID), req.Status, ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update status", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Item status updated", nil)
}
// DeleteItem deletes an item
// DELETE /api/items/:id
func (c *ItemController) DeleteItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
itemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.itemService.DeleteItem(user.ID, uint(itemID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to delete item", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Item deleted", nil)
}
// GetItemsByReporter gets items by reporter
// GET /api/user/items
func (c *ItemController) GetItemsByReporter(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
items, total, err := c.itemService.GetItemsByReporter(user.ID, page, limit)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get items", err.Error())
return
}
var responses []models.ItemDetailResponse
for _, item := range items {
responses = append(responses, item.ToDetailResponse())
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Items retrieved", responses, total, page, limit)
}
// GetItemRevisionHistory gets revision history for an item
// GET /api/items/:id/revisions
func (c *ItemController) GetItemRevisionHistory(ctx *gin.Context) {
itemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
revisions, total, err := c.itemService.GetItemRevisionHistory(uint(itemID), page, limit)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get revision history", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Revision history retrieved", revisions, total, page, limit)
}
// internal/controllers/lost_item_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type LostItemController struct {
lostItemService *services.LostItemService
}
func NewLostItemController(db *gorm.DB) *LostItemController {
return &LostItemController{
lostItemService: services.NewLostItemService(db),
}
}
// GetAllLostItems gets all lost items
// GET /api/lost-items
func (c *LostItemController) GetAllLostItems(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
status := ctx.Query("status")
category := ctx.Query("category")
search := ctx.Query("search")
var userID *uint
// If manager/admin, can see all. If user, only see their own
if userObj, exists := ctx.Get("user"); exists {
user := userObj.(*models.User)
if user.IsUser() {
userID = &user.ID
}
}
lostItems, total, err := c.lostItemService.GetAllLostItems(page, limit, status, category, search, userID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get lost items", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Lost items retrieved", lostItems, total, page, limit)
}
// GetLostItemByID gets lost item by ID
// GET /api/lost-items/:id
func (c *LostItemController) GetLostItemByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
lostItem, err := c.lostItemService.GetLostItemByID(uint(id))
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Lost item not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Lost item retrieved", lostItem.ToResponse())
}
// CreateLostItem creates a new lost item report
// POST /api/lost-items
func (c *LostItemController) CreateLostItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.CreateLostItemRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
lostItem, err := c.lostItemService.CreateLostItem(user.ID, req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to create lost item report", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusCreated, "Lost item report created", lostItem.ToResponse())
}
// UpdateLostItem updates a lost item report
// PUT /api/lost-items/:id
func (c *LostItemController) UpdateLostItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
lostItemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
var req services.UpdateLostItemRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
lostItem, err := c.lostItemService.UpdateLostItem(user.ID, uint(lostItemID), req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update lost item report", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Lost item report updated", lostItem.ToResponse())
}
// UpdateLostItemStatus updates lost item status
// PATCH /api/lost-items/:id/status
func (c *LostItemController) UpdateLostItemStatus(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
lostItemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
var req struct {
Status string `json:"status" binding:"required"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.lostItemService.UpdateLostItemStatus(user.ID, uint(lostItemID), req.Status, ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update status", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Lost item status updated", nil)
}
// DeleteLostItem deletes a lost item report
// DELETE /api/lost-items/:id
func (c *LostItemController) DeleteLostItem(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
lostItemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.lostItemService.DeleteLostItem(user.ID, uint(lostItemID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to delete lost item report", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Lost item report deleted", nil)
}
// GetLostItemsByUser gets lost items by user
// GET /api/user/lost-items
func (c *LostItemController) GetLostItemsByUser(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
lostItems, total, err := c.lostItemService.GetLostItemsByUser(user.ID, page, limit)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get lost items", err.Error())
return
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Lost items retrieved", lostItems, total, page, limit)
}
// internal/controllers/match_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type MatchController struct {
matchService *services.MatchService
}
func NewMatchController(db *gorm.DB) *MatchController {
return &MatchController{
matchService: services.NewMatchService(db),
}
}
// FindSimilarItems finds similar items for a lost item
// POST /api/lost-items/:id/find-similar
func (c *MatchController) FindSimilarItems(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
lostItemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
// Only allow managers or the owner to search
// Add ownership check here if needed
results, err := c.matchService.FindSimilarItems(uint(lostItemID))
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to find similar items", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Similar items found", gin.H{
"total": len(results),
"matches": results,
"user_id": user.ID,
})
}
// GetMatchesForLostItem gets all matches for a lost item
// GET /api/lost-items/:id/matches
func (c *MatchController) GetMatchesForLostItem(ctx *gin.Context) {
lostItemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid lost item ID", err.Error())
return
}
matches, err := c.matchService.GetMatchesForLostItem(uint(lostItemID))
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get matches", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Matches retrieved", matches)
}
// GetMatchesForItem gets all matches for an item
// GET /api/items/:id/matches
func (c *MatchController) GetMatchesForItem(ctx *gin.Context) {
itemID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid item ID", err.Error())
return
}
matches, err := c.matchService.GetMatchesForItem(uint(itemID))
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get matches", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Matches retrieved", matches)
}
// internal/controllers/report_controller.go
package controllers
import (
"fmt"
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"time"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type ReportController struct {
exportService *services.ExportService
}
func NewReportController(db *gorm.DB) *ReportController {
return &ReportController{
exportService: services.NewExportService(db),
}
}
// ExportReport exports report based on request
// POST /api/reports/export
func (c *ReportController) ExportReport(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.ExportRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
var buffer *[]byte
var filename string
var contentType string
var err error
// Generate report based on type and format
switch req.Type {
case "items":
if req.Format == "pdf" {
buf, e := c.exportService.ExportItemsToPDF(req, user.ID, ipAddress, userAgent)
if e != nil {
err = e
} else {
data := buf.Bytes()
buffer = &data
filename = fmt.Sprintf("items_report_%s.pdf", time.Now().Format("20060102"))
contentType = "application/pdf"
}
} else {
buf, e := c.exportService.ExportItemsToExcel(req, user.ID, ipAddress, userAgent)
if e != nil {
err = e
} else {
data := buf.Bytes()
buffer = &data
filename = fmt.Sprintf("items_report_%s.xlsx", time.Now().Format("20060102"))
contentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
}
}
case "archives":
buf, e := c.exportService.ExportArchivesToPDF(req, user.ID, ipAddress, userAgent)
if e != nil {
err = e
} else {
data := buf.Bytes()
buffer = &data
filename = fmt.Sprintf("archives_report_%s.pdf", time.Now().Format("20060102"))
contentType = "application/pdf"
}
case "claims":
buf, e := c.exportService.ExportClaimsToPDF(req, user.ID, ipAddress, userAgent)
if e != nil {
err = e
} else {
data := buf.Bytes()
buffer = &data
filename = fmt.Sprintf("claims_report_%s.pdf", time.Now().Format("20060102"))
contentType = "application/pdf"
}
default:
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid report type", "")
return
}
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to generate report", err.Error())
return
}
// Set headers
ctx.Header("Content-Type", contentType)
ctx.Header("Content-Disposition", fmt.Sprintf("attachment; filename=%s", filename))
ctx.Header("Content-Length", fmt.Sprintf("%d", len(*buffer)))
// Send file
ctx.Data(http.StatusOK, contentType, *buffer)
}
// internal/controllers/user_controller.go
package controllers
import (
"lost-and-found/internal/models"
"lost-and-found/internal/services"
"lost-and-found/internal/utils"
"net/http"
"strconv"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
type UserController struct {
userService *services.UserService
}
func NewUserController(db *gorm.DB) *UserController {
return &UserController{
userService: services.NewUserService(db),
}
}
// GetProfile gets user profile
// GET /api/user/profile
func (c *UserController) GetProfile(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
profile, err := c.userService.GetProfile(user.ID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "Profile not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Profile retrieved", profile.ToResponse())
}
// UpdateProfile updates user profile
// PUT /api/user/profile
func (c *UserController) UpdateProfile(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.UpdateProfileRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
updatedUser, err := c.userService.UpdateProfile(user.ID, req, ipAddress, userAgent)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Update failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Profile updated", updatedUser.ToResponse())
}
// ChangePassword changes user password
// POST /api/user/change-password
func (c *UserController) ChangePassword(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
var req services.ChangePasswordRequest
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.userService.ChangePassword(user.ID, req, ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Password change failed", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Password changed successfully", nil)
}
// GetStats gets user statistics
// GET /api/user/stats
func (c *UserController) GetStats(ctx *gin.Context) {
userObj, _ := ctx.Get("user")
user := userObj.(*models.User)
stats, err := c.userService.GetUserStats(user.ID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get stats", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "Stats retrieved", stats)
}
// GetAllUsers gets all users (admin only)
// GET /api/admin/users
func (c *UserController) GetAllUsers(ctx *gin.Context) {
page, _ := strconv.Atoi(ctx.DefaultQuery("page", "1"))
limit, _ := strconv.Atoi(ctx.DefaultQuery("limit", "10"))
users, total, err := c.userService.GetAllUsers(page, limit)
if err != nil {
utils.ErrorResponse(ctx, http.StatusInternalServerError, "Failed to get users", err.Error())
return
}
var responses []models.UserResponse
for _, user := range users {
responses = append(responses, user.ToResponse())
}
utils.SendPaginatedResponse(ctx, http.StatusOK, "Users retrieved", responses, total, page, limit)
}
// GetUserByID gets user by ID (admin only)
// GET /api/admin/users/:id
func (c *UserController) GetUserByID(ctx *gin.Context) {
id, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid user ID", err.Error())
return
}
user, err := c.userService.GetUserByID(uint(id))
if err != nil {
utils.ErrorResponse(ctx, http.StatusNotFound, "User not found", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User retrieved", user.ToResponse())
}
// UpdateUserRole updates user role (admin only)
// PATCH /api/admin/users/:id/role
func (c *UserController) UpdateUserRole(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
userID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid user ID", err.Error())
return
}
var req struct {
RoleID uint `json:"role_id" binding:"required"`
}
if err := ctx.ShouldBindJSON(&req); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid request data", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.userService.UpdateUserRole(admin.ID, uint(userID), req.RoleID, ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to update role", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User role updated", nil)
}
// BlockUser blocks a user (admin only)
// POST /api/admin/users/:id/block
func (c *UserController) BlockUser(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
userID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid user ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.userService.BlockUser(admin.ID, uint(userID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to block user", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User blocked", nil)
}
// UnblockUser unblocks a user (admin only)
// POST /api/admin/users/:id/unblock
func (c *UserController) UnblockUser(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
userID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid user ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.userService.UnblockUser(admin.ID, uint(userID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to unblock user", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User unblocked", nil)
}
// DeleteUser deletes a user (admin only)
// DELETE /api/admin/users/:id
func (c *UserController) DeleteUser(ctx *gin.Context) {
adminObj, _ := ctx.Get("user")
admin := adminObj.(*models.User)
userID, err := strconv.ParseUint(ctx.Param("id"), 10, 32)
if err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Invalid user ID", err.Error())
return
}
ipAddress := ctx.ClientIP()
userAgent := ctx.Request.UserAgent()
if err := c.userService.DeleteUser(admin.ID, uint(userID), ipAddress, userAgent); err != nil {
utils.ErrorResponse(ctx, http.StatusBadRequest, "Failed to delete user", err.Error())
return
}
utils.SuccessResponse(ctx, http.StatusOK, "User deleted", nil)
}
// internal/middleware/cors.go
package middleware
import (
"github.com/gin-gonic/gin"
)
// CORSMiddleware handles CORS
func CORSMiddleware() gin.HandlerFunc {
return func(ctx *gin.Context) {
ctx.Writer.Header().Set("Access-Control-Allow-Origin", "*")
ctx.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
ctx.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
ctx.Writer.Header().Set("Access-Control-Allow-Methods", "POST, OPTIONS, GET, PUT, DELETE, PATCH")
if ctx.Request.Method == "OPTIONS" {
ctx.AbortWithStatus(204)
return
}
ctx.Next()
}
}
// internal/middleware/jwt_middleware.go
package middleware
import (
"lost-and-found/internal/config"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"net/http"
"strings"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
// JWTMiddleware validates JWT token
func JWTMiddleware(db *gorm.DB) gin.HandlerFunc {
return func(ctx *gin.Context) {
// Get token from Authorization header
authHeader := ctx.GetHeader("Authorization")
if authHeader == "" {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Authorization header required", "")
ctx.Abort()
return
}
// Check if Bearer token
parts := strings.Split(authHeader, " ")
if len(parts) != 2 || parts[0] != "Bearer" {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Invalid authorization format", "")
ctx.Abort()
return
}
tokenString := parts[1]
// Validate token
claims, err := config.ValidateToken(tokenString)
if err != nil {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Invalid or expired token", err.Error())
ctx.Abort()
return
}
// Get user from database
userRepo := repositories.NewUserRepository(db)
user, err := userRepo.FindByID(claims.UserID)
if err != nil {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "User not found", "")
ctx.Abort()
return
}
// Check if user is blocked
if user.IsBlocked() {
utils.ErrorResponse(ctx, http.StatusForbidden, "Account is blocked", "")
ctx.Abort()
return
}
// Set user in context
ctx.Set("user", user)
ctx.Set("user_id", user.ID)
ctx.Set("user_role", user.Role.Name)
ctx.Next()
}
}
// OptionalJWTMiddleware validates JWT token if present (for public routes that can benefit from auth)
func OptionalJWTMiddleware(db *gorm.DB) gin.HandlerFunc {
return func(ctx *gin.Context) {
authHeader := ctx.GetHeader("Authorization")
if authHeader == "" {
ctx.Next()
return
}
parts := strings.Split(authHeader, " ")
if len(parts) != 2 || parts[0] != "Bearer" {
ctx.Next()
return
}
tokenString := parts[1]
claims, err := config.ValidateToken(tokenString)
if err != nil {
ctx.Next()
return
}
userRepo := repositories.NewUserRepository(db)
user, err := userRepo.FindByID(claims.UserID)
if err != nil {
ctx.Next()
return
}
if !user.IsBlocked() {
ctx.Set("user", user)
ctx.Set("user_id", user.ID)
ctx.Set("user_role", user.Role.Name)
}
ctx.Next()
}
}
// internal/middleware/logger.go
package middleware
import (
"fmt"
"time"
"github.com/gin-gonic/gin"
)
// LoggerMiddleware logs HTTP requests
func LoggerMiddleware() gin.HandlerFunc {
return func(ctx *gin.Context) {
// Start timer
startTime := time.Now()
// Process request
ctx.Next()
// Calculate latency
latency := time.Since(startTime)
// Get request info
method := ctx.Request.Method
path := ctx.Request.URL.Path
statusCode := ctx.Writer.Status()
clientIP := ctx.ClientIP()
// Get user ID if authenticated
userID := "guest"
if id, exists := ctx.Get("user_id"); exists {
userID = fmt.Sprintf("%v", id)
}
// Log format
fmt.Printf("[%s] %s | %3d | %13v | %15s | %s | User: %s\n",
time.Now().Format("2006-01-02 15:04:05"),
method,
statusCode,
latency,
clientIP,
path,
userID,
)
}
}
// internal/middleware/rate_limiter.go
package middleware
import (
"lost-and-found/internal/utils"
"net/http"
"sync"
"time"
"github.com/gin-gonic/gin"
)
// RateLimiter stores rate limit data
type RateLimiter struct {
visitors map[string]*Visitor
mu sync.RWMutex
rate int // requests per window
window time.Duration // time window
}
// Visitor represents a visitor's rate limit data
type Visitor struct {
lastSeen time.Time
count int
}
var limiter *RateLimiter
// InitRateLimiter initializes the rate limiter
func InitRateLimiter(rate int, window time.Duration) {
limiter = &RateLimiter{
visitors: make(map[string]*Visitor),
rate: rate,
window: window,
}
// Cleanup old visitors every minute
go limiter.cleanupVisitors()
}
// cleanupVisitors removes old visitor entries
func (rl *RateLimiter) cleanupVisitors() {
for {
time.Sleep(time.Minute)
rl.mu.Lock()
for ip, visitor := range rl.visitors {
if time.Since(visitor.lastSeen) > rl.window {
delete(rl.visitors, ip)
}
}
rl.mu.Unlock()
}
}
// getVisitor retrieves or creates a visitor
func (rl *RateLimiter) getVisitor(ip string) *Visitor {
rl.mu.Lock()
defer rl.mu.Unlock()
visitor, exists := rl.visitors[ip]
if !exists {
visitor = &Visitor{
lastSeen: time.Now(),
count: 0,
}
rl.visitors[ip] = visitor
}
return visitor
}
// isAllowed checks if request is allowed
func (rl *RateLimiter) isAllowed(ip string) bool {
visitor := rl.getVisitor(ip)
rl.mu.Lock()
defer rl.mu.Unlock()
// Reset count if window has passed
if time.Since(visitor.lastSeen) > rl.window {
visitor.count = 0
visitor.lastSeen = time.Now()
}
// Check if limit exceeded
if visitor.count >= rl.rate {
return false
}
visitor.count++
visitor.lastSeen = time.Now()
return true
}
// RateLimiterMiddleware applies rate limiting
func RateLimiterMiddleware() gin.HandlerFunc {
// Initialize rate limiter (100 requests per minute)
if limiter == nil {
InitRateLimiter(100, time.Minute)
}
return func(ctx *gin.Context) {
ip := ctx.ClientIP()
if !limiter.isAllowed(ip) {
utils.ErrorResponse(ctx, http.StatusTooManyRequests, "Rate limit exceeded", "Too many requests, please try again later")
ctx.Abort()
return
}
ctx.Next()
}
}
// internal/middleware/role_middleware.go
package middleware
import (
"lost-and-found/internal/models"
"lost-and-found/internal/utils"
"net/http"
"github.com/gin-gonic/gin"
)
// RequireRole checks if user has required role
func RequireRole(allowedRoles ...string) gin.HandlerFunc {
return func(ctx *gin.Context) {
userObj, exists := ctx.Get("user")
if !exists {
utils.ErrorResponse(ctx, http.StatusUnauthorized, "Authentication required", "")
ctx.Abort()
return
}
user := userObj.(*models.User)
userRole := user.Role.Name
// Check if user has allowed role
hasRole := false
for _, role := range allowedRoles {
if userRole == role {
hasRole = true
break
}
}
if !hasRole {
utils.ErrorResponse(ctx, http.StatusForbidden, "Insufficient permissions", "")
ctx.Abort()
return
}
ctx.Next()
}
}
// RequireAdmin middleware (admin only)
func RequireAdmin() gin.HandlerFunc {
return RequireRole(models.RoleAdmin)
}
// RequireManager middleware (manager and admin)
func RequireManager() gin.HandlerFunc {
return RequireRole(models.RoleAdmin, models.RoleManager)
}
// RequireUser middleware (all authenticated users)
func RequireUser() gin.HandlerFunc {
return RequireRole(models.RoleAdmin, models.RoleManager, models.RoleUser)
}
// internal/models/archive.go
package models
import (
"time"
"gorm.io/gorm"
)
// Archive represents an archived item
type Archive struct {
ID uint `gorm:"primaryKey" json:"id"`
ItemID uint `gorm:"not null;uniqueIndex" json:"item_id"` // Original item ID
Name string `gorm:"type:varchar(100);not null" json:"name"`
CategoryID uint `gorm:"not null" json:"category_id"`
Category Category `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
PhotoURL string `gorm:"type:varchar(255)" json:"photo_url"`
Location string `gorm:"type:varchar(200)" json:"location"`
Description string `gorm:"type:text" json:"description"`
DateFound time.Time `json:"date_found"`
Status string `gorm:"type:varchar(50)" json:"status"` // case_closed, expired
ReporterName string `gorm:"type:varchar(100)" json:"reporter_name"`
ReporterContact string `gorm:"type:varchar(50)" json:"reporter_contact"`
ArchivedReason string `gorm:"type:varchar(100)" json:"archived_reason"` // expired, case_closed
ClaimedBy *uint `json:"claimed_by"` // User who claimed (if applicable)
Claimer *User `gorm:"foreignKey:ClaimedBy" json:"claimer,omitempty"`
ArchivedAt time.Time `json:"archived_at"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for Archive model
func (Archive) TableName() string {
return "archives"
}
// Archive reason constants
const (
ArchiveReasonExpired = "expired"
ArchiveReasonCaseClosed = "case_closed"
)
// BeforeCreate hook
func (a *Archive) BeforeCreate(tx *gorm.DB) error {
if a.ArchivedAt.IsZero() {
a.ArchivedAt = time.Now()
}
return nil
}
// ArchiveResponse represents archive data for API responses
type ArchiveResponse struct {
ID uint `json:"id"`
ItemID uint `json:"item_id"`
Name string `json:"name"`
Category string `json:"category"`
PhotoURL string `json:"photo_url"`
Location string `json:"location"`
DateFound time.Time `json:"date_found"`
Status string `json:"status"`
ArchivedReason string `json:"archived_reason"`
ClaimedBy string `json:"claimed_by,omitempty"`
ArchivedAt time.Time `json:"archived_at"`
}
// ToResponse converts Archive to ArchiveResponse
func (a *Archive) ToResponse() ArchiveResponse {
categoryName := ""
if a.Category.ID != 0 {
categoryName = a.Category.Name
}
claimedByName := ""
if a.Claimer != nil && a.Claimer.ID != 0 {
claimedByName = a.Claimer.Name
}
return ArchiveResponse{
ID: a.ID,
ItemID: a.ItemID,
Name: a.Name,
Category: categoryName,
PhotoURL: a.PhotoURL,
Location: a.Location,
DateFound: a.DateFound,
Status: a.Status,
ArchivedReason: a.ArchivedReason,
ClaimedBy: claimedByName,
ArchivedAt: a.ArchivedAt,
}
}
// CreateFromItem creates an Archive from an Item
func CreateFromItem(item *Item, reason string, claimedBy *uint) *Archive {
return &Archive{
ItemID: item.ID,
Name: item.Name,
CategoryID: item.CategoryID,
PhotoURL: item.PhotoURL,
Location: item.Location,
Description: item.Description,
DateFound: item.DateFound,
Status: item.Status,
ReporterName: item.ReporterName,
ReporterContact: item.ReporterContact,
ArchivedReason: reason,
ClaimedBy: claimedBy,
ArchivedAt: time.Now(),
}
}
// internal/models/audit_log.go
package models
import (
"time"
"gorm.io/gorm"
)
// AuditLog represents an audit log entry
type AuditLog struct {
ID uint `gorm:"primaryKey" json:"id"`
UserID *uint `json:"user_id"` // Nullable for system actions
User *User `gorm:"foreignKey:UserID" json:"user,omitempty"`
Action string `gorm:"type:varchar(50);not null" json:"action"` // create, update, delete, verify, login, etc.
EntityType string `gorm:"type:varchar(50)" json:"entity_type"` // item, claim, user, etc.
EntityID *uint `json:"entity_id"`
Details string `gorm:"type:text" json:"details"`
IPAddress string `gorm:"type:varchar(50)" json:"ip_address"`
UserAgent string `gorm:"type:varchar(255)" json:"user_agent"`
CreatedAt time.Time `json:"created_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for AuditLog model
func (AuditLog) TableName() string {
return "audit_logs"
}
// Action constants
const (
ActionCreate = "create"
ActionUpdate = "update"
ActionDelete = "delete"
ActionVerify = "verify"
ActionLogin = "login"
ActionLogout = "logout"
ActionBlock = "block"
ActionUnblock = "unblock"
ActionApprove = "approve"
ActionReject = "reject"
ActionExport = "export"
)
// Entity type constants
const (
EntityItem = "item"
EntityLostItem = "lost_item"
EntityClaim = "claim"
EntityUser = "user"
EntityCategory = "category"
EntityArchive = "archive"
)
// AuditLogResponse represents audit log data for API responses
type AuditLogResponse struct {
ID uint `json:"id"`
UserName string `json:"user_name,omitempty"`
Action string `json:"action"`
EntityType string `json:"entity_type"`
EntityID *uint `json:"entity_id"`
Details string `json:"details"`
IPAddress string `json:"ip_address"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts AuditLog to AuditLogResponse
func (a *AuditLog) ToResponse() AuditLogResponse {
userName := "System"
if a.User != nil && a.User.ID != 0 {
userName = a.User.Name
}
return AuditLogResponse{
ID: a.ID,
UserName: userName,
Action: a.Action,
EntityType: a.EntityType,
EntityID: a.EntityID,
Details: a.Details,
IPAddress: a.IPAddress,
CreatedAt: a.CreatedAt,
}
}
// CreateAuditLog creates a new audit log entry
func CreateAuditLog(db *gorm.DB, userID *uint, action, entityType string, entityID *uint, details, ipAddress, userAgent string) error {
log := &AuditLog{
UserID: userID,
Action: action,
EntityType: entityType,
EntityID: entityID,
Details: details,
IPAddress: ipAddress,
UserAgent: userAgent,
}
return db.Create(log).Error
}
// internal/models/category.go
package models
import (
"time"
"gorm.io/gorm"
)
// Category represents an item category
type Category struct {
ID uint `gorm:"primaryKey" json:"id"`
Name string `gorm:"type:varchar(100);not null" json:"name"`
Slug string `gorm:"type:varchar(100);uniqueIndex;not null" json:"slug"`
Description string `gorm:"type:text" json:"description"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
Items []Item `gorm:"foreignKey:CategoryID" json:"items,omitempty"`
LostItems []LostItem `gorm:"foreignKey:CategoryID" json:"lost_items,omitempty"`
}
// TableName specifies the table name for Category model
func (Category) TableName() string {
return "categories"
}
// CategoryResponse represents category data for API responses
type CategoryResponse struct {
ID uint `json:"id"`
Name string `json:"name"`
Slug string `json:"slug"`
Description string `json:"description"`
ItemCount int64 `json:"item_count,omitempty"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts Category to CategoryResponse
func (c *Category) ToResponse() CategoryResponse {
return CategoryResponse{
ID: c.ID,
Name: c.Name,
Slug: c.Slug,
Description: c.Description,
CreatedAt: c.CreatedAt,
}
}
// internal/models/claim_verification.go
package models
import (
"time"
"gorm.io/gorm"
)
// ClaimVerification represents verification data for a claim
type ClaimVerification struct {
ID uint `gorm:"primaryKey" json:"id"`
ClaimID uint `gorm:"not null;uniqueIndex" json:"claim_id"`
Claim Claim `gorm:"foreignKey:ClaimID" json:"claim,omitempty"`
SimilarityScore float64 `gorm:"type:decimal(5,2);default:0" json:"similarity_score"` // Percentage match (0-100)
MatchedKeywords string `gorm:"type:text" json:"matched_keywords"` // Keywords that matched
VerificationNotes string `gorm:"type:text" json:"verification_notes"` // Manager's notes
IsAutoMatched bool `gorm:"default:false" json:"is_auto_matched"` // Was it auto-matched?
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for ClaimVerification model
func (ClaimVerification) TableName() string {
return "claim_verifications"
}
// IsHighMatch checks if similarity score is high (>= 70%)
func (cv *ClaimVerification) IsHighMatch() bool {
return cv.SimilarityScore >= 70.0
}
// IsMediumMatch checks if similarity score is medium (50-69%)
func (cv *ClaimVerification) IsMediumMatch() bool {
return cv.SimilarityScore >= 50.0 && cv.SimilarityScore < 70.0
}
// IsLowMatch checks if similarity score is low (< 50%)
func (cv *ClaimVerification) IsLowMatch() bool {
return cv.SimilarityScore < 50.0
}
// GetMatchLevel returns the match level as string
func (cv *ClaimVerification) GetMatchLevel() string {
if cv.IsHighMatch() {
return "high"
} else if cv.IsMediumMatch() {
return "medium"
}
return "low"
}
// ClaimVerificationResponse represents verification data for API responses
type ClaimVerificationResponse struct {
ID uint `json:"id"`
ClaimID uint `json:"claim_id"`
SimilarityScore float64 `json:"similarity_score"`
MatchLevel string `json:"match_level"`
MatchedKeywords string `json:"matched_keywords"`
VerificationNotes string `json:"verification_notes"`
IsAutoMatched bool `json:"is_auto_matched"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts ClaimVerification to ClaimVerificationResponse
func (cv *ClaimVerification) ToResponse() ClaimVerificationResponse {
return ClaimVerificationResponse{
ID: cv.ID,
ClaimID: cv.ClaimID,
SimilarityScore: cv.SimilarityScore,
MatchLevel: cv.GetMatchLevel(),
MatchedKeywords: cv.MatchedKeywords,
VerificationNotes: cv.VerificationNotes,
IsAutoMatched: cv.IsAutoMatched,
CreatedAt: cv.CreatedAt,
}
}
// internal/models/claim.go
package models
import (
"time"
"gorm.io/gorm"
)
// Claim represents a claim for a found item
type Claim struct {
ID uint `gorm:"primaryKey" json:"id"`
ItemID uint `gorm:"not null" json:"item_id"`
Item Item `gorm:"foreignKey:ItemID" json:"item,omitempty"`
UserID uint `gorm:"not null" json:"user_id"`
User User `gorm:"foreignKey:UserID" json:"user,omitempty"`
Description string `gorm:"type:text;not null" json:"description"` // User's description of the item
ProofURL string `gorm:"type:varchar(255)" json:"proof_url"` // Optional proof photo
Contact string `gorm:"type:varchar(50);not null" json:"contact"`
Status string `gorm:"type:varchar(50);default:'pending'" json:"status"` // pending, approved, rejected
Notes string `gorm:"type:text" json:"notes"` // Manager's notes (approval/rejection reason)
VerifiedAt *time.Time `json:"verified_at"`
VerifiedBy *uint `json:"verified_by"` // Manager who verified
Verifier *User `gorm:"foreignKey:VerifiedBy" json:"verifier,omitempty"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
Verification *ClaimVerification `gorm:"foreignKey:ClaimID" json:"verification,omitempty"`
}
// TableName specifies the table name for Claim model
func (Claim) TableName() string {
return "claims"
}
// Claim status constants
const (
ClaimStatusPending = "pending"
ClaimStatusApproved = "approved"
ClaimStatusRejected = "rejected"
)
// BeforeCreate hook
func (c *Claim) BeforeCreate(tx *gorm.DB) error {
if c.Status == "" {
c.Status = ClaimStatusPending
}
return nil
}
// IsPending checks if claim is pending
func (c *Claim) IsPending() bool {
return c.Status == ClaimStatusPending
}
// IsApproved checks if claim is approved
func (c *Claim) IsApproved() bool {
return c.Status == ClaimStatusApproved
}
// IsRejected checks if claim is rejected
func (c *Claim) IsRejected() bool {
return c.Status == ClaimStatusRejected
}
// Approve approves the claim
func (c *Claim) Approve(verifierID uint, notes string) {
c.Status = ClaimStatusApproved
c.VerifiedBy = &verifierID
now := time.Now()
c.VerifiedAt = &now
c.Notes = notes
}
// Reject rejects the claim
func (c *Claim) Reject(verifierID uint, notes string) {
c.Status = ClaimStatusRejected
c.VerifiedBy = &verifierID
now := time.Now()
c.VerifiedAt = &now
c.Notes = notes
}
// ClaimResponse represents claim data for API responses
type ClaimResponse struct {
ID uint `json:"id"`
ItemID uint `json:"item_id"`
ItemName string `json:"item_name"`
UserID uint `json:"user_id"`
UserName string `json:"user_name"`
Description string `json:"description"`
ProofURL string `json:"proof_url"`
Contact string `json:"contact"`
Status string `json:"status"`
Notes string `json:"notes"`
MatchPercentage *float64 `json:"match_percentage,omitempty"`
VerifiedAt *time.Time `json:"verified_at"`
VerifiedBy *uint `json:"verified_by"`
VerifierName string `json:"verifier_name,omitempty"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts Claim to ClaimResponse
func (c *Claim) ToResponse() ClaimResponse {
itemName := ""
if c.Item.ID != 0 {
itemName = c.Item.Name
}
userName := ""
if c.User.ID != 0 {
userName = c.User.Name
}
verifierName := ""
if c.Verifier != nil && c.Verifier.ID != 0 {
verifierName = c.Verifier.Name
}
var matchPercentage *float64
if c.Verification != nil {
matchPercentage = &c.Verification.SimilarityScore
}
return ClaimResponse{
ID: c.ID,
ItemID: c.ItemID,
ItemName: itemName,
UserID: c.UserID,
UserName: userName,
Description: c.Description,
ProofURL: c.ProofURL,
Contact: c.Contact,
Status: c.Status,
Notes: c.Notes,
MatchPercentage: matchPercentage,
VerifiedAt: c.VerifiedAt,
VerifiedBy: c.VerifiedBy,
VerifierName: verifierName,
CreatedAt: c.CreatedAt,
}
}
// ClaimDetailResponse includes item description for verification
type ClaimDetailResponse struct {
ClaimResponse
ItemDescription string `json:"item_description"` // Original item description for comparison
}
// ToDetailResponse converts Claim to ClaimDetailResponse
func (c *Claim) ToDetailResponse() ClaimDetailResponse {
baseResponse := c.ToResponse()
itemDescription := ""
if c.Item.ID != 0 {
itemDescription = c.Item.Description
}
return ClaimDetailResponse{
ClaimResponse: baseResponse,
ItemDescription: itemDescription,
}
}
// internal/models/item.go
package models
import (
"time"
"gorm.io/gorm"
)
// Item represents a found item
type Item struct {
ID uint `gorm:"primaryKey" json:"id"`
Name string `gorm:"type:varchar(100);not null" json:"name"`
CategoryID uint `gorm:"not null" json:"category_id"`
Category Category `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
PhotoURL string `gorm:"type:varchar(255)" json:"photo_url"`
Location string `gorm:"type:varchar(200);not null" json:"location"`
Description string `gorm:"type:text;not null" json:"description"` // Keunikan (rahasia)
DateFound time.Time `gorm:"not null" json:"date_found"`
Status string `gorm:"type:varchar(50);default:'unclaimed'" json:"status"` // unclaimed, pending_claim, verified, case_closed, expired
ReporterID uint `gorm:"not null" json:"reporter_id"`
Reporter User `gorm:"foreignKey:ReporterID" json:"reporter,omitempty"`
ReporterName string `gorm:"type:varchar(100);not null" json:"reporter_name"`
ReporterContact string `gorm:"type:varchar(50);not null" json:"reporter_contact"`
ExpiresAt *time.Time `json:"expires_at"` // Auto-expire after 90 days
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
Claims []Claim `gorm:"foreignKey:ItemID" json:"claims,omitempty"`
MatchResults []MatchResult `gorm:"foreignKey:ItemID" json:"match_results,omitempty"`
RevisionLogs []RevisionLog `gorm:"foreignKey:ItemID" json:"revision_logs,omitempty"`
}
// TableName specifies the table name for Item model
func (Item) TableName() string {
return "items"
}
// Status constants
const (
ItemStatusUnclaimed = "unclaimed"
ItemStatusPendingClaim = "pending_claim"
ItemStatusVerified = "verified"
ItemStatusCaseClosed = "case_closed"
ItemStatusExpired = "expired"
)
// BeforeCreate hook to set expiration date
func (i *Item) BeforeCreate(tx *gorm.DB) error {
// Set default status
if i.Status == "" {
i.Status = ItemStatusUnclaimed
}
// Set expiration date (90 days from date found)
if i.ExpiresAt == nil {
expiresAt := i.DateFound.AddDate(0, 0, 90) // Add 90 days
i.ExpiresAt = &expiresAt
}
return nil
}
// IsExpired checks if item has expired
func (i *Item) IsExpired() bool {
if i.ExpiresAt == nil {
return false
}
return time.Now().After(*i.ExpiresAt)
}
// CanBeClaimed checks if item can be claimed
func (i *Item) CanBeClaimed() bool {
return i.Status == ItemStatusUnclaimed && !i.IsExpired()
}
// CanBeEdited checks if item can be edited
func (i *Item) CanBeEdited() bool {
// Cannot edit if case is closed or expired
return i.Status != ItemStatusCaseClosed && i.Status != ItemStatusExpired
}
// ItemPublicResponse represents item data for public view (without sensitive info)
type ItemPublicResponse struct {
ID uint `json:"id"`
Name string `json:"name"`
Category string `json:"category"`
PhotoURL string `json:"photo_url"`
Location string `json:"location"`
DateFound time.Time `json:"date_found"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
}
// ToPublicResponse converts Item to ItemPublicResponse (hides description, reporter details)
func (i *Item) ToPublicResponse() ItemPublicResponse {
categoryName := ""
if i.Category.ID != 0 {
categoryName = i.Category.Name
}
return ItemPublicResponse{
ID: i.ID,
Name: i.Name,
Category: categoryName,
PhotoURL: i.PhotoURL,
Location: i.Location,
DateFound: i.DateFound,
Status: i.Status,
CreatedAt: i.CreatedAt,
}
}
// ItemDetailResponse represents full item data for authorized users
type ItemDetailResponse struct {
ID uint `json:"id"`
Name string `json:"name"`
Category string `json:"category"`
PhotoURL string `json:"photo_url"`
Location string `json:"location"`
Description string `json:"description"`
DateFound time.Time `json:"date_found"`
Status string `json:"status"`
ReporterName string `json:"reporter_name"`
ReporterContact string `json:"reporter_contact"`
ExpiresAt *time.Time `json:"expires_at"`
CreatedAt time.Time `json:"created_at"`
}
// ToDetailResponse converts Item to ItemDetailResponse (includes all info)
func (i *Item) ToDetailResponse() ItemDetailResponse {
categoryName := ""
if i.Category.ID != 0 {
categoryName = i.Category.Name
}
return ItemDetailResponse{
ID: i.ID,
Name: i.Name,
Category: categoryName,
PhotoURL: i.PhotoURL,
Location: i.Location,
Description: i.Description,
DateFound: i.DateFound,
Status: i.Status,
ReporterName: i.ReporterName,
ReporterContact: i.ReporterContact,
ExpiresAt: i.ExpiresAt,
CreatedAt: i.CreatedAt,
}
}
// internal/models/lost_item.go
package models
import (
"time"
"gorm.io/gorm"
)
// LostItem represents a lost item report
type LostItem struct {
ID uint `gorm:"primaryKey" json:"id"`
UserID uint `gorm:"not null" json:"user_id"`
User User `gorm:"foreignKey:UserID" json:"user,omitempty"`
Name string `gorm:"type:varchar(100);not null" json:"name"`
CategoryID uint `gorm:"not null" json:"category_id"`
Category Category `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
Color string `gorm:"type:varchar(50)" json:"color"`
Location string `gorm:"type:varchar(200)" json:"location"` // Optional
Description string `gorm:"type:text;not null" json:"description"`
DateLost time.Time `gorm:"not null" json:"date_lost"`
Status string `gorm:"type:varchar(50);default:'active'" json:"status"` // active, found, expired
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
MatchResults []MatchResult `gorm:"foreignKey:LostItemID" json:"match_results,omitempty"`
}
// TableName specifies the table name for LostItem model
func (LostItem) TableName() string {
return "lost_items"
}
// LostItem status constants
const (
LostItemStatusActive = "active"
LostItemStatusFound = "found"
LostItemStatusExpired = "expired"
)
// BeforeCreate hook
func (l *LostItem) BeforeCreate(tx *gorm.DB) error {
if l.Status == "" {
l.Status = LostItemStatusActive
}
return nil
}
// IsActive checks if lost item is still active
func (l *LostItem) IsActive() bool {
return l.Status == LostItemStatusActive
}
// LostItemResponse represents lost item data for API responses
type LostItemResponse struct {
ID uint `json:"id"`
UserName string `json:"user_name"`
Name string `json:"name"`
Category string `json:"category"`
Color string `json:"color"`
Location string `json:"location"`
Description string `json:"description"`
DateLost time.Time `json:"date_lost"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts LostItem to LostItemResponse
func (l *LostItem) ToResponse() LostItemResponse {
userName := ""
if l.User.ID != 0 {
userName = l.User.Name
}
categoryName := ""
if l.Category.ID != 0 {
categoryName = l.Category.Name
}
return LostItemResponse{
ID: l.ID,
UserName: userName,
Name: l.Name,
Category: categoryName,
Color: l.Color,
Location: l.Location,
Description: l.Description,
DateLost: l.DateLost,
Status: l.Status,
CreatedAt: l.CreatedAt,
}
}
// internal/models/match_result.go
package models
import (
"time"
"gorm.io/gorm"
)
// MatchResult represents auto-matching result between lost item and found item
type MatchResult struct {
ID uint `gorm:"primaryKey" json:"id"`
LostItemID uint `gorm:"not null" json:"lost_item_id"`
LostItem LostItem `gorm:"foreignKey:LostItemID" json:"lost_item,omitempty"`
ItemID uint `gorm:"not null" json:"item_id"`
Item Item `gorm:"foreignKey:ItemID" json:"item,omitempty"`
SimilarityScore float64 `gorm:"type:decimal(5,2)" json:"similarity_score"` // Percentage match (0-100)
MatchedFields string `gorm:"type:text" json:"matched_fields"` // JSON of matched fields
MatchedAt time.Time `gorm:"not null" json:"matched_at"`
IsNotified bool `gorm:"default:false" json:"is_notified"` // Was user notified?
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for MatchResult model
func (MatchResult) TableName() string {
return "match_results"
}
// BeforeCreate hook
func (mr *MatchResult) BeforeCreate(tx *gorm.DB) error {
if mr.MatchedAt.IsZero() {
mr.MatchedAt = time.Now()
}
return nil
}
// IsHighMatch checks if similarity score is high (>= 70%)
func (mr *MatchResult) IsHighMatch() bool {
return mr.SimilarityScore >= 70.0
}
// IsMediumMatch checks if similarity score is medium (50-69%)
func (mr *MatchResult) IsMediumMatch() bool {
return mr.SimilarityScore >= 50.0 && mr.SimilarityScore < 70.0
}
// IsLowMatch checks if similarity score is low (< 50%)
func (mr *MatchResult) IsLowMatch() bool {
return mr.SimilarityScore < 50.0
}
// GetMatchLevel returns the match level as string
func (mr *MatchResult) GetMatchLevel() string {
if mr.IsHighMatch() {
return "high"
} else if mr.IsMediumMatch() {
return "medium"
}
return "low"
}
// MatchResultResponse represents match result data for API responses
type MatchResultResponse struct {
ID uint `json:"id"`
LostItemID uint `json:"lost_item_id"`
LostItemName string `json:"lost_item_name"`
ItemID uint `json:"item_id"`
ItemName string `json:"item_name"`
ItemPhotoURL string `json:"item_photo_url"`
ItemLocation string `json:"item_location"`
ItemDateFound time.Time `json:"item_date_found"`
ItemStatus string `json:"item_status"`
SimilarityScore float64 `json:"similarity_score"`
MatchLevel string `json:"match_level"`
MatchedFields string `json:"matched_fields"`
MatchedAt time.Time `json:"matched_at"`
IsNotified bool `json:"is_notified"`
}
// ToResponse converts MatchResult to MatchResultResponse
func (mr *MatchResult) ToResponse() MatchResultResponse {
lostItemName := ""
if mr.LostItem.ID != 0 {
lostItemName = mr.LostItem.Name
}
itemName := ""
itemPhotoURL := ""
itemLocation := ""
itemDateFound := time.Time{}
itemStatus := ""
if mr.Item.ID != 0 {
itemName = mr.Item.Name
itemPhotoURL = mr.Item.PhotoURL
itemLocation = mr.Item.Location
itemDateFound = mr.Item.DateFound
itemStatus = mr.Item.Status
}
return MatchResultResponse{
ID: mr.ID,
LostItemID: mr.LostItemID,
LostItemName: lostItemName,
ItemID: mr.ItemID,
ItemName: itemName,
ItemPhotoURL: itemPhotoURL,
ItemLocation: itemLocation,
ItemDateFound: itemDateFound,
ItemStatus: itemStatus,
SimilarityScore: mr.SimilarityScore,
MatchLevel: mr.GetMatchLevel(),
MatchedFields: mr.MatchedFields,
MatchedAt: mr.MatchedAt,
IsNotified: mr.IsNotified,
}
}
// ItemMatchResponse represents simplified item data for matching display
type ItemMatchResponse struct {
ID uint `json:"id"`
Name string `json:"name"`
PhotoURL string `json:"photo_url"`
Location string `json:"location"`
DateFound time.Time `json:"date_found"`
Status string `json:"status"`
Similarity float64 `json:"similarity"`
}
// internal/models/notification.go
package models
import (
"time"
"gorm.io/gorm"
)
// Notification represents a notification for a user
type Notification struct {
ID uint `gorm:"primaryKey" json:"id"`
UserID uint `gorm:"not null" json:"user_id"`
User User `gorm:"foreignKey:UserID" json:"user,omitempty"`
Type string `gorm:"type:varchar(50);not null" json:"type"` // match_found, claim_approved, claim_rejected, item_expired, etc.
Title string `gorm:"type:varchar(200);not null" json:"title"`
Message string `gorm:"type:text;not null" json:"message"`
EntityType string `gorm:"type:varchar(50)" json:"entity_type"` // item, claim, match, etc.
EntityID *uint `json:"entity_id"`
IsRead bool `gorm:"default:false" json:"is_read"`
ReadAt *time.Time `json:"read_at"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for Notification model
func (Notification) TableName() string {
return "notifications"
}
// Notification type constants
const (
NotificationMatchFound = "match_found"
NotificationClaimApproved = "claim_approved"
NotificationClaimRejected = "claim_rejected"
NotificationItemExpired = "item_expired"
NotificationNewClaim = "new_claim"
NotificationItemReturned = "item_returned"
)
// MarkAsRead marks the notification as read
func (n *Notification) MarkAsRead() {
n.IsRead = true
now := time.Now()
n.ReadAt = &now
}
// NotificationResponse represents notification data for API responses
type NotificationResponse struct {
ID uint `json:"id"`
Type string `json:"type"`
Title string `json:"title"`
Message string `json:"message"`
EntityType string `json:"entity_type"`
EntityID *uint `json:"entity_id"`
IsRead bool `json:"is_read"`
ReadAt *time.Time `json:"read_at"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts Notification to NotificationResponse
func (n *Notification) ToResponse() NotificationResponse {
return NotificationResponse{
ID: n.ID,
Type: n.Type,
Title: n.Title,
Message: n.Message,
EntityType: n.EntityType,
EntityID: n.EntityID,
IsRead: n.IsRead,
ReadAt: n.ReadAt,
CreatedAt: n.CreatedAt,
}
}
// CreateNotification creates a new notification
func CreateNotification(db *gorm.DB, userID uint, notifType, title, message, entityType string, entityID *uint) error {
notification := &Notification{
UserID: userID,
Type: notifType,
Title: title,
Message: message,
EntityType: entityType,
EntityID: entityID,
}
return db.Create(notification).Error
}
// CreateMatchNotification creates a notification for match found
func CreateMatchNotification(db *gorm.DB, userID uint, itemName string, matchID uint) error {
return CreateNotification(
db,
userID,
NotificationMatchFound,
"Barang yang Mirip Ditemukan!",
"Kami menemukan barang yang mirip dengan laporan kehilangan Anda: "+itemName,
"match",
&matchID,
)
}
// CreateClaimApprovedNotification creates a notification for approved claim
func CreateClaimApprovedNotification(db *gorm.DB, userID uint, itemName string, claimID uint) error {
return CreateNotification(
db,
userID,
NotificationClaimApproved,
"Klaim Disetujui!",
"Klaim Anda untuk barang '"+itemName+"' telah disetujui. Silakan ambil barang di tempat yang ditentukan.",
"claim",
&claimID,
)
}
// CreateClaimRejectedNotification creates a notification for rejected claim
func CreateClaimRejectedNotification(db *gorm.DB, userID uint, itemName, reason string, claimID uint) error {
return CreateNotification(
db,
userID,
NotificationClaimRejected,
"Klaim Ditolak",
"Klaim Anda untuk barang '"+itemName+"' ditolak. Alasan: "+reason,
"claim",
&claimID,
)
}
// internal/models/revision_log.go
package models
import (
"time"
"gorm.io/gorm"
)
// RevisionLog represents revision history for item edits
type RevisionLog struct {
ID uint `gorm:"primaryKey" json:"id"`
ItemID uint `gorm:"not null" json:"item_id"`
Item Item `gorm:"foreignKey:ItemID" json:"item,omitempty"`
UserID uint `gorm:"not null" json:"user_id"` // Who made the edit
User User `gorm:"foreignKey:UserID" json:"user,omitempty"`
FieldName string `gorm:"type:varchar(50);not null" json:"field_name"` // Which field was edited
OldValue string `gorm:"type:text" json:"old_value"`
NewValue string `gorm:"type:text" json:"new_value"`
Reason string `gorm:"type:text" json:"reason"` // Why was it edited
CreatedAt time.Time `json:"created_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
}
// TableName specifies the table name for RevisionLog model
func (RevisionLog) TableName() string {
return "revision_logs"
}
// RevisionLogResponse represents revision log data for API responses
type RevisionLogResponse struct {
ID uint `json:"id"`
ItemID uint `json:"item_id"`
UserName string `json:"user_name"`
FieldName string `json:"field_name"`
OldValue string `json:"old_value"`
NewValue string `json:"new_value"`
Reason string `json:"reason"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts RevisionLog to RevisionLogResponse
func (rl *RevisionLog) ToResponse() RevisionLogResponse {
userName := ""
if rl.User.ID != 0 {
userName = rl.User.Name
}
return RevisionLogResponse{
ID: rl.ID,
ItemID: rl.ItemID,
UserName: userName,
FieldName: rl.FieldName,
OldValue: rl.OldValue,
NewValue: rl.NewValue,
Reason: rl.Reason,
CreatedAt: rl.CreatedAt,
}
}
// CreateRevisionLog creates a new revision log entry
func CreateRevisionLog(db *gorm.DB, itemID, userID uint, fieldName, oldValue, newValue, reason string) error {
log := &RevisionLog{
ItemID: itemID,
UserID: userID,
FieldName: fieldName,
OldValue: oldValue,
NewValue: newValue,
Reason: reason,
}
return db.Create(log).Error
}
// internal/models/role.go
package models
import (
"time"
"gorm.io/gorm"
)
// Role represents a user role in the system
type Role struct {
ID uint `gorm:"primaryKey" json:"id"`
Name string `gorm:"type:varchar(50);uniqueIndex;not null" json:"name"`
Description string `gorm:"type:text" json:"description"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
Users []User `gorm:"foreignKey:RoleID" json:"users,omitempty"`
}
// TableName specifies the table name for Role model
func (Role) TableName() string {
return "roles"
}
// Role constants
const (
RoleAdmin = "admin"
RoleManager = "manager"
RoleUser = "user"
)
// GetRoleID returns the ID for a given role name
func GetRoleID(db *gorm.DB, roleName string) (uint, error) {
var role Role
if err := db.Where("name = ?", roleName).First(&role).Error; err != nil {
return 0, err
}
return role.ID, nil
}
// IsValidRole checks if a role name is valid
func IsValidRole(roleName string) bool {
validRoles := []string{RoleAdmin, RoleManager, RoleUser}
for _, r := range validRoles {
if r == roleName {
return true
}
}
return false
}
// internal/models/user.go
package models
import (
"time"
"gorm.io/gorm"
)
// User represents a user in the system
type User struct {
ID uint `gorm:"primaryKey" json:"id"`
Name string `gorm:"type:varchar(100);not null" json:"name"`
Email string `gorm:"type:varchar(100);uniqueIndex;not null" json:"email"`
Password string `gorm:"type:varchar(255);not null" json:"-"` // Hide password in JSON
NRP string `gorm:"type:varchar(20);uniqueIndex" json:"nrp"`
Phone string `gorm:"type:varchar(20)" json:"phone"`
RoleID uint `gorm:"not null;default:3" json:"role_id"` // Default to user role
Role Role `gorm:"foreignKey:RoleID" json:"role,omitempty"`
Status string `gorm:"type:varchar(20);default:'active'" json:"status"` // active, blocked
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
DeletedAt gorm.DeletedAt `gorm:"index" json:"-"`
// Relationships
Items []Item `gorm:"foreignKey:ReporterID" json:"items,omitempty"`
LostItems []LostItem `gorm:"foreignKey:UserID" json:"lost_items,omitempty"`
Claims []Claim `gorm:"foreignKey:UserID" json:"claims,omitempty"`
}
// TableName specifies the table name for User model
func (User) TableName() string {
return "users"
}
// BeforeCreate hook to validate user data
func (u *User) BeforeCreate(tx *gorm.DB) error {
// Set default role if not specified
if u.RoleID == 0 {
u.RoleID = 3 // Default to user role
}
// Set default status
if u.Status == "" {
u.Status = "active"
}
return nil
}
// IsAdmin checks if user is admin
func (u *User) IsAdmin() bool {
return u.Role.Name == "admin"
}
// IsManager checks if user is manager
func (u *User) IsManager() bool {
return u.Role.Name == "manager"
}
// IsUser checks if user is regular user
func (u *User) IsUser() bool {
return u.Role.Name == "user"
}
// IsActive checks if user is active
func (u *User) IsActive() bool {
return u.Status == "active"
}
// IsBlocked checks if user is blocked
func (u *User) IsBlocked() bool {
return u.Status == "blocked"
}
// UserResponse represents user data for API responses (without sensitive info)
type UserResponse struct {
ID uint `json:"id"`
Name string `json:"name"`
Email string `json:"email"`
NRP string `json:"nrp"`
Phone string `json:"phone"`
Role string `json:"role"`
Status string `json:"status"`
CreatedAt time.Time `json:"created_at"`
}
// ToResponse converts User to UserResponse
func (u *User) ToResponse() UserResponse {
roleName := ""
if u.Role.ID != 0 {
roleName = u.Role.Name
}
return UserResponse{
ID: u.ID,
Name: u.Name,
Email: u.Email,
NRP: u.NRP,
Phone: u.Phone,
Role: roleName,
Status: u.Status,
CreatedAt: u.CreatedAt,
}
}
// internal/repositories/archive_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type ArchiveRepository struct {
db *gorm.DB
}
func NewArchiveRepository(db *gorm.DB) *ArchiveRepository {
return &ArchiveRepository{db: db}
}
// Create creates a new archive record
func (r *ArchiveRepository) Create(archive *models.Archive) error {
return r.db.Create(archive).Error
}
// FindByID finds archive by ID
func (r *ArchiveRepository) FindByID(id uint) (*models.Archive, error) {
var archive models.Archive
err := r.db.Preload("Category").Preload("Claimer").Preload("Claimer.Role").First(&archive, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("archive not found")
}
return nil, err
}
return &archive, nil
}
// FindAll returns all archived items with filters
func (r *ArchiveRepository) FindAll(page, limit int, reason, search string) ([]models.Archive, int64, error) {
var archives []models.Archive
var total int64
query := r.db.Model(&models.Archive{})
// Apply filters
if reason != "" {
query = query.Where("archived_reason = ?", reason)
}
if search != "" {
query = query.Where("name ILIKE ? OR location ILIKE ?", "%"+search+"%", "%"+search+"%")
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Category").Preload("Claimer").Preload("Claimer.Role").
Order("archived_at DESC").
Offset(offset).Limit(limit).Find(&archives).Error
if err != nil {
return nil, 0, err
}
return archives, total, nil
}
// FindByItemID finds archive by original item ID
func (r *ArchiveRepository) FindByItemID(itemID uint) (*models.Archive, error) {
var archive models.Archive
err := r.db.Where("item_id = ?", itemID).Preload("Category").Preload("Claimer").First(&archive).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("archive not found")
}
return nil, err
}
return &archive, nil
}
// Delete permanently deletes an archive
func (r *ArchiveRepository) Delete(id uint) error {
return r.db.Unscoped().Delete(&models.Archive{}, id).Error
}
// CountByReason counts archives by reason
func (r *ArchiveRepository) CountByReason(reason string) (int64, error) {
var count int64
err := r.db.Model(&models.Archive{}).Where("archived_reason = ?", reason).Count(&count).Error
return count, err
}
// internal/repositories/audit_log_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type AuditLogRepository struct {
db *gorm.DB
}
func NewAuditLogRepository(db *gorm.DB) *AuditLogRepository {
return &AuditLogRepository{db: db}
}
// Create creates a new audit log
func (r *AuditLogRepository) Create(log *models.AuditLog) error {
return r.db.Create(log).Error
}
// FindByID finds audit log by ID
func (r *AuditLogRepository) FindByID(id uint) (*models.AuditLog, error) {
var log models.AuditLog
err := r.db.Preload("User").Preload("User.Role").First(&log, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("audit log not found")
}
return nil, err
}
return &log, nil
}
// FindAll returns all audit logs with filters
func (r *AuditLogRepository) FindAll(page, limit int, action, entityType string, userID *uint) ([]models.AuditLog, int64, error) {
var logs []models.AuditLog
var total int64
query := r.db.Model(&models.AuditLog{})
// Apply filters
if action != "" {
query = query.Where("action = ?", action)
}
if entityType != "" {
query = query.Where("entity_type = ?", entityType)
}
if userID != nil {
query = query.Where("user_id = ?", *userID)
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("User").Preload("User.Role").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&logs).Error
if err != nil {
return nil, 0, err
}
return logs, total, nil
}
// FindByUser finds audit logs by user
func (r *AuditLogRepository) FindByUser(userID uint, page, limit int) ([]models.AuditLog, int64, error) {
return r.FindAll(page, limit, "", "", &userID)
}
// FindByEntity finds audit logs by entity
func (r *AuditLogRepository) FindByEntity(entityType string, entityID uint, page, limit int) ([]models.AuditLog, int64, error) {
var logs []models.AuditLog
var total int64
query := r.db.Model(&models.AuditLog{}).
Where("entity_type = ? AND entity_id = ?", entityType, entityID)
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("User").Preload("User.Role").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&logs).Error
if err != nil {
return nil, 0, err
}
return logs, total, nil
}
// Log creates a new audit log entry (helper method)
func (r *AuditLogRepository) Log(userID *uint, action, entityType string, entityID *uint, details, ipAddress, userAgent string) error {
return models.CreateAuditLog(r.db, userID, action, entityType, entityID, details, ipAddress, userAgent)
}
// internal/repositories/category_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type CategoryRepository struct {
db *gorm.DB
}
func NewCategoryRepository(db *gorm.DB) *CategoryRepository {
return &CategoryRepository{db: db}
}
// Create creates a new category
func (r *CategoryRepository) Create(category *models.Category) error {
return r.db.Create(category).Error
}
// FindByID finds category by ID
func (r *CategoryRepository) FindByID(id uint) (*models.Category, error) {
var category models.Category
err := r.db.First(&category, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("category not found")
}
return nil, err
}
return &category, nil
}
// FindBySlug finds category by slug
func (r *CategoryRepository) FindBySlug(slug string) (*models.Category, error) {
var category models.Category
err := r.db.Where("slug = ?", slug).First(&category).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("category not found")
}
return nil, err
}
return &category, nil
}
// FindAll returns all categories
func (r *CategoryRepository) FindAll() ([]models.Category, error) {
var categories []models.Category
err := r.db.Order("name ASC").Find(&categories).Error
return categories, err
}
// Update updates category data
func (r *CategoryRepository) Update(category *models.Category) error {
return r.db.Save(category).Error
}
// Delete soft deletes a category
func (r *CategoryRepository) Delete(id uint) error {
return r.db.Delete(&models.Category{}, id).Error
}
// GetCategoryWithItemCount gets category with item count
func (r *CategoryRepository) GetCategoryWithItemCount(id uint) (*models.Category, int64, error) {
category, err := r.FindByID(id)
if err != nil {
return nil, 0, err
}
var count int64
if err := r.db.Model(&models.Item{}).Where("category_id = ?", id).Count(&count).Error; err != nil {
return nil, 0, err
}
return category, count, nil
}
// GetAllWithItemCount gets all categories with item counts
func (r *CategoryRepository) GetAllWithItemCount() ([]models.CategoryResponse, error) {
var categories []models.Category
if err := r.db.Order("name ASC").Find(&categories).Error; err != nil {
return nil, err
}
var responses []models.CategoryResponse
for _, cat := range categories {
var count int64
if err := r.db.Model(&models.Item{}).Where("category_id = ?", cat.ID).Count(&count).Error; err != nil {
return nil, err
}
response := cat.ToResponse()
response.ItemCount = count
responses = append(responses, response)
}
return responses, nil
}
// internal/repositories/claim_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type ClaimRepository struct {
db *gorm.DB
}
func NewClaimRepository(db *gorm.DB) *ClaimRepository {
return &ClaimRepository{db: db}
}
// Create creates a new claim
func (r *ClaimRepository) Create(claim *models.Claim) error {
return r.db.Create(claim).Error
}
// FindByID finds claim by ID
func (r *ClaimRepository) FindByID(id uint) (*models.Claim, error) {
var claim models.Claim
err := r.db.Preload("Item").Preload("Item.Category").
Preload("User").Preload("User.Role").
Preload("Verifier").Preload("Verifier.Role").
Preload("Verification").
First(&claim, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("claim not found")
}
return nil, err
}
return &claim, nil
}
// FindAll returns all claims with filters
func (r *ClaimRepository) FindAll(page, limit int, status string, itemID, userID *uint) ([]models.Claim, int64, error) {
var claims []models.Claim
var total int64
query := r.db.Model(&models.Claim{})
// Apply filters
if status != "" {
query = query.Where("status = ?", status)
}
if itemID != nil {
query = query.Where("item_id = ?", *itemID)
}
if userID != nil {
query = query.Where("user_id = ?", *userID)
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Item").Preload("Item.Category").
Preload("User").Preload("User.Role").
Preload("Verifier").Preload("Verifier.Role").
Preload("Verification").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&claims).Error
if err != nil {
return nil, 0, err
}
return claims, total, nil
}
// Update updates claim data
func (r *ClaimRepository) Update(claim *models.Claim) error {
return r.db.Save(claim).Error
}
// Delete soft deletes a claim
func (r *ClaimRepository) Delete(id uint) error {
return r.db.Delete(&models.Claim{}, id).Error
}
// CheckExistingClaim checks if user already claimed an item
func (r *ClaimRepository) CheckExistingClaim(userID, itemID uint) (bool, error) {
var count int64
err := r.db.Model(&models.Claim{}).
Where("user_id = ? AND item_id = ? AND status != ?", userID, itemID, models.ClaimStatusRejected).
Count(&count).Error
if err != nil {
return false, err
}
return count > 0, nil
}
// FindByItem finds claims for an item
func (r *ClaimRepository) FindByItem(itemID uint) ([]models.Claim, error) {
var claims []models.Claim
err := r.db.Where("item_id = ?", itemID).
Preload("User").Preload("User.Role").
Preload("Verification").
Order("created_at DESC").Find(&claims).Error
return claims, err
}
// FindByUser finds claims by user
func (r *ClaimRepository) FindByUser(userID uint, page, limit int) ([]models.Claim, int64, error) {
var claims []models.Claim
var total int64
query := r.db.Model(&models.Claim{}).Where("user_id = ?", userID)
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Item").Preload("Item.Category").
Preload("Verification").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&claims).Error
if err != nil {
return nil, 0, err
}
return claims, total, nil
}
// CountByStatus counts claims by status
func (r *ClaimRepository) CountByStatus(status string) (int64, error) {
var count int64
err := r.db.Model(&models.Claim{}).Where("status = ?", status).Count(&count).Error
return count, err
}
// FindPendingClaims finds all pending claims
func (r *ClaimRepository) FindPendingClaims(page, limit int) ([]models.Claim, int64, error) {
return r.FindAll(page, limit, models.ClaimStatusPending, nil, nil)
}
// internal/repositories/claim_verification_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type ClaimVerificationRepository struct {
db *gorm.DB
}
func NewClaimVerificationRepository(db *gorm.DB) *ClaimVerificationRepository {
return &ClaimVerificationRepository{db: db}
}
// Create creates a new claim verification
func (r *ClaimVerificationRepository) Create(verification *models.ClaimVerification) error {
return r.db.Create(verification).Error
}
// FindByID finds claim verification by ID
func (r *ClaimVerificationRepository) FindByID(id uint) (*models.ClaimVerification, error) {
var verification models.ClaimVerification
err := r.db.Preload("Claim").First(&verification, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("claim verification not found")
}
return nil, err
}
return &verification, nil
}
// FindByClaimID finds claim verification by claim ID
func (r *ClaimVerificationRepository) FindByClaimID(claimID uint) (*models.ClaimVerification, error) {
var verification models.ClaimVerification
err := r.db.Where("claim_id = ?", claimID).Preload("Claim").First(&verification).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil // Return nil if not found (not an error)
}
return nil, err
}
return &verification, nil
}
// Update updates claim verification
func (r *ClaimVerificationRepository) Update(verification *models.ClaimVerification) error {
return r.db.Save(verification).Error
}
// Delete deletes a claim verification
func (r *ClaimVerificationRepository) Delete(id uint) error {
return r.db.Delete(&models.ClaimVerification{}, id).Error
}
// FindHighMatches finds high match verifications (>= 70%)
func (r *ClaimVerificationRepository) FindHighMatches() ([]models.ClaimVerification, error) {
var verifications []models.ClaimVerification
err := r.db.Where("similarity_score >= ?", 70.0).
Preload("Claim").Preload("Claim.Item").Preload("Claim.User").
Order("similarity_score DESC").Find(&verifications).Error
return verifications, err
}
// internal/repositories/item_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"time"
"gorm.io/gorm"
)
type ItemRepository struct {
db *gorm.DB
}
func NewItemRepository(db *gorm.DB) *ItemRepository {
return &ItemRepository{db: db}
}
// Create creates a new item
func (r *ItemRepository) Create(item *models.Item) error {
return r.db.Create(item).Error
}
// FindByID finds item by ID
func (r *ItemRepository) FindByID(id uint) (*models.Item, error) {
var item models.Item
err := r.db.Preload("Category").Preload("Reporter").Preload("Reporter.Role").First(&item, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("item not found")
}
return nil, err
}
return &item, nil
}
// FindAll returns all items with filters
func (r *ItemRepository) FindAll(page, limit int, status, category, search string) ([]models.Item, int64, error) {
var items []models.Item
var total int64
query := r.db.Model(&models.Item{})
// Apply filters
if status != "" {
query = query.Where("status = ?", status)
}
if category != "" {
query = query.Joins("JOIN categories ON categories.id = items.category_id").Where("categories.slug = ?", category)
}
if search != "" {
query = query.Where("name ILIKE ? OR location ILIKE ?", "%"+search+"%", "%"+search+"%")
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Category").Preload("Reporter").Preload("Reporter.Role").
Order("date_found DESC").
Offset(offset).Limit(limit).Find(&items).Error
if err != nil {
return nil, 0, err
}
return items, total, nil
}
// Update updates item data
func (r *ItemRepository) Update(item *models.Item) error {
return r.db.Save(item).Error
}
// UpdateStatus updates item status
func (r *ItemRepository) UpdateStatus(id uint, status string) error {
return r.db.Model(&models.Item{}).Where("id = ?", id).Update("status", status).Error
}
// Delete soft deletes an item
func (r *ItemRepository) Delete(id uint) error {
return r.db.Delete(&models.Item{}, id).Error
}
// FindExpired finds expired items
func (r *ItemRepository) FindExpired() ([]models.Item, error) {
var items []models.Item
now := time.Now()
err := r.db.Where("expires_at <= ? AND status = ?", now, models.ItemStatusUnclaimed).
Preload("Category").Find(&items).Error
return items, err
}
// ArchiveItem moves item to archive
func (r *ItemRepository) ArchiveItem(item *models.Item, reason string, claimedBy *uint) error {
return r.db.Transaction(func(tx *gorm.DB) error {
// Create archive record
archive := models.CreateFromItem(item, reason, claimedBy)
if err := tx.Create(archive).Error; err != nil {
return err
}
// Update item status
if err := tx.Model(item).Updates(map[string]interface{}{
"status": models.ItemStatusExpired,
}).Error; err != nil {
return err
}
return nil
})
}
// CountByStatus counts items by status
func (r *ItemRepository) CountByStatus(status string) (int64, error) {
var count int64
err := r.db.Model(&models.Item{}).Where("status = ?", status).Count(&count).Error
return count, err
}
// FindByReporter finds items by reporter ID
func (r *ItemRepository) FindByReporter(reporterID uint, page, limit int) ([]models.Item, int64, error) {
var items []models.Item
var total int64
query := r.db.Model(&models.Item{}).Where("reporter_id = ?", reporterID)
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Category").Order("date_found DESC").
Offset(offset).Limit(limit).Find(&items).Error
if err != nil {
return nil, 0, err
}
return items, total, nil
}
// SearchForMatching searches items for matching with lost items
func (r *ItemRepository) SearchForMatching(categoryID uint, name, color string) ([]models.Item, error) {
var items []models.Item
query := r.db.Where("status = ? AND category_id = ?", models.ItemStatusUnclaimed, categoryID)
if name != "" {
query = query.Where("name ILIKE ?", "%"+name+"%")
}
err := query.Preload("Category").Order("date_found DESC").Limit(10).Find(&items).Error
return items, err
}
// internal/repositories/lost_item_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type LostItemRepository struct {
db *gorm.DB
}
func NewLostItemRepository(db *gorm.DB) *LostItemRepository {
return &LostItemRepository{db: db}
}
// Create creates a new lost item report
func (r *LostItemRepository) Create(lostItem *models.LostItem) error {
return r.db.Create(lostItem).Error
}
// FindByID finds lost item by ID
func (r *LostItemRepository) FindByID(id uint) (*models.LostItem, error) {
var lostItem models.LostItem
err := r.db.Preload("Category").Preload("User").Preload("User.Role").First(&lostItem, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("lost item not found")
}
return nil, err
}
return &lostItem, nil
}
// FindAll returns all lost items with filters
func (r *LostItemRepository) FindAll(page, limit int, status, category, search string, userID *uint) ([]models.LostItem, int64, error) {
var lostItems []models.LostItem
var total int64
query := r.db.Model(&models.LostItem{})
// Filter by user if specified
if userID != nil {
query = query.Where("user_id = ?", *userID)
}
// Apply filters
if status != "" {
query = query.Where("status = ?", status)
}
if category != "" {
query = query.Joins("JOIN categories ON categories.id = lost_items.category_id").Where("categories.slug = ?", category)
}
if search != "" {
query = query.Where("name ILIKE ? OR description ILIKE ?", "%"+search+"%", "%"+search+"%")
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Category").Preload("User").Preload("User.Role").
Order("date_lost DESC").
Offset(offset).Limit(limit).Find(&lostItems).Error
if err != nil {
return nil, 0, err
}
return lostItems, total, nil
}
// Update updates lost item data
func (r *LostItemRepository) Update(lostItem *models.LostItem) error {
return r.db.Save(lostItem).Error
}
// UpdateStatus updates lost item status
func (r *LostItemRepository) UpdateStatus(id uint, status string) error {
return r.db.Model(&models.LostItem{}).Where("id = ?", id).Update("status", status).Error
}
// Delete soft deletes a lost item
func (r *LostItemRepository) Delete(id uint) error {
return r.db.Delete(&models.LostItem{}, id).Error
}
// FindByUser finds lost items by user ID
func (r *LostItemRepository) FindByUser(userID uint, page, limit int) ([]models.LostItem, int64, error) {
var lostItems []models.LostItem
var total int64
query := r.db.Model(&models.LostItem{}).Where("user_id = ?", userID)
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Category").Order("date_lost DESC").
Offset(offset).Limit(limit).Find(&lostItems).Error
if err != nil {
return nil, 0, err
}
return lostItems, total, nil
}
// CountByStatus counts lost items by status
func (r *LostItemRepository) CountByStatus(status string) (int64, error) {
var count int64
err := r.db.Model(&models.LostItem{}).Where("status = ?", status).Count(&count).Error
return count, err
}
// FindActiveForMatching finds active lost items for matching
func (r *LostItemRepository) FindActiveForMatching(categoryID uint) ([]models.LostItem, error) {
var lostItems []models.LostItem
err := r.db.Where("status = ? AND category_id = ?", models.LostItemStatusActive, categoryID).
Preload("User").Find(&lostItems).Error
return lostItems, err
}
// internal/repositories/match_result_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type MatchResultRepository struct {
db *gorm.DB
}
func NewMatchResultRepository(db *gorm.DB) *MatchResultRepository {
return &MatchResultRepository{db: db}
}
// Create creates a new match result
func (r *MatchResultRepository) Create(match *models.MatchResult) error {
return r.db.Create(match).Error
}
// FindByID finds match result by ID
func (r *MatchResultRepository) FindByID(id uint) (*models.MatchResult, error) {
var match models.MatchResult
err := r.db.Preload("LostItem").Preload("LostItem.User").
Preload("Item").Preload("Item.Category").
First(&match, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("match result not found")
}
return nil, err
}
return &match, nil
}
// FindAll returns all match results with filters
func (r *MatchResultRepository) FindAll(page, limit int, lostItemID, itemID *uint) ([]models.MatchResult, int64, error) {
var matches []models.MatchResult
var total int64
query := r.db.Model(&models.MatchResult{})
// Apply filters
if lostItemID != nil {
query = query.Where("lost_item_id = ?", *lostItemID)
}
if itemID != nil {
query = query.Where("item_id = ?", *itemID)
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("LostItem").Preload("LostItem.User").
Preload("Item").Preload("Item.Category").
Order("similarity_score DESC").
Offset(offset).Limit(limit).Find(&matches).Error
if err != nil {
return nil, 0, err
}
return matches, total, nil
}
// FindByLostItem finds match results for a lost item
func (r *MatchResultRepository) FindByLostItem(lostItemID uint) ([]models.MatchResult, error) {
var matches []models.MatchResult
err := r.db.Where("lost_item_id = ?", lostItemID).
Preload("Item").Preload("Item.Category").
Order("similarity_score DESC").Find(&matches).Error
return matches, err
}
// FindByItem finds match results for an item
func (r *MatchResultRepository) FindByItem(itemID uint) ([]models.MatchResult, error) {
var matches []models.MatchResult
err := r.db.Where("item_id = ?", itemID).
Preload("LostItem").Preload("LostItem.User").
Order("similarity_score DESC").Find(&matches).Error
return matches, err
}
// Update updates match result
func (r *MatchResultRepository) Update(match *models.MatchResult) error {
return r.db.Save(match).Error
}
// MarkAsNotified marks match result as notified
func (r *MatchResultRepository) MarkAsNotified(id uint) error {
return r.db.Model(&models.MatchResult{}).Where("id = ?", id).Update("is_notified", true).Error
}
// FindUnnotifiedMatches finds match results that haven't been notified
func (r *MatchResultRepository) FindUnnotifiedMatches() ([]models.MatchResult, error) {
var matches []models.MatchResult
err := r.db.Where("is_notified = ?", false).
Preload("LostItem").Preload("LostItem.User").
Preload("Item").Preload("Item.Category").
Order("matched_at ASC").Find(&matches).Error
return matches, err
}
// Delete deletes a match result
func (r *MatchResultRepository) Delete(id uint) error {
return r.db.Delete(&models.MatchResult{}, id).Error
}
// CheckExistingMatch checks if a match already exists
func (r *MatchResultRepository) CheckExistingMatch(lostItemID, itemID uint) (bool, error) {
var count int64
err := r.db.Model(&models.MatchResult{}).
Where("lost_item_id = ? AND item_id = ?", lostItemID, itemID).
Count(&count).Error
if err != nil {
return false, err
}
return count > 0, nil
}
// internal/repositories/notification_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type NotificationRepository struct {
db *gorm.DB
}
func NewNotificationRepository(db *gorm.DB) *NotificationRepository {
return &NotificationRepository{db: db}
}
// Create creates a new notification
func (r *NotificationRepository) Create(notification *models.Notification) error {
return r.db.Create(notification).Error
}
// FindByID finds notification by ID
func (r *NotificationRepository) FindByID(id uint) (*models.Notification, error) {
var notification models.Notification
err := r.db.Preload("User").First(&notification, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("notification not found")
}
return nil, err
}
return &notification, nil
}
// FindByUser finds notifications for a user
func (r *NotificationRepository) FindByUser(userID uint, page, limit int, onlyUnread bool) ([]models.Notification, int64, error) {
var notifications []models.Notification
var total int64
query := r.db.Model(&models.Notification{}).Where("user_id = ?", userID)
// Filter unread if specified
if onlyUnread {
query = query.Where("is_read = ?", false)
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Order("created_at DESC").
Offset(offset).Limit(limit).Find(&notifications).Error
if err != nil {
return nil, 0, err
}
return notifications, total, nil
}
// MarkAsRead marks a notification as read
func (r *NotificationRepository) MarkAsRead(id uint) error {
notification, err := r.FindByID(id)
if err != nil {
return err
}
notification.MarkAsRead()
return r.db.Save(notification).Error
}
// MarkAllAsRead marks all notifications for a user as read
func (r *NotificationRepository) MarkAllAsRead(userID uint) error {
return r.db.Model(&models.Notification{}).
Where("user_id = ? AND is_read = ?", userID, false).
Update("is_read", true).Error
}
// Delete deletes a notification
func (r *NotificationRepository) Delete(id uint) error {
return r.db.Delete(&models.Notification{}, id).Error
}
// DeleteAllForUser deletes all notifications for a user
func (r *NotificationRepository) DeleteAllForUser(userID uint) error {
return r.db.Where("user_id = ?", userID).Delete(&models.Notification{}).Error
}
// CountUnread counts unread notifications for a user
func (r *NotificationRepository) CountUnread(userID uint) (int64, error) {
var count int64
err := r.db.Model(&models.Notification{}).
Where("user_id = ? AND is_read = ?", userID, false).
Count(&count).Error
return count, err
}
// Notify creates a notification (helper method)
func (r *NotificationRepository) Notify(userID uint, notifType, title, message, entityType string, entityID *uint) error {
return models.CreateNotification(r.db, userID, notifType, title, message, entityType, entityID)
}
// internal/repositories/revision_log_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type RevisionLogRepository struct {
db *gorm.DB
}
func NewRevisionLogRepository(db *gorm.DB) *RevisionLogRepository {
return &RevisionLogRepository{db: db}
}
// Create creates a new revision log
func (r *RevisionLogRepository) Create(log *models.RevisionLog) error {
return r.db.Create(log).Error
}
// FindByID finds revision log by ID
func (r *RevisionLogRepository) FindByID(id uint) (*models.RevisionLog, error) {
var log models.RevisionLog
err := r.db.Preload("Item").Preload("User").Preload("User.Role").First(&log, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("revision log not found")
}
return nil, err
}
return &log, nil
}
// FindByItem finds revision logs for an item
func (r *RevisionLogRepository) FindByItem(itemID uint, page, limit int) ([]models.RevisionLog, int64, error) {
var logs []models.RevisionLog
var total int64
query := r.db.Model(&models.RevisionLog{}).Where("item_id = ?", itemID)
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("User").Preload("User.Role").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&logs).Error
if err != nil {
return nil, 0, err
}
return logs, total, nil
}
// FindAll returns all revision logs with filters
func (r *RevisionLogRepository) FindAll(page, limit int, userID *uint) ([]models.RevisionLog, int64, error) {
var logs []models.RevisionLog
var total int64
query := r.db.Model(&models.RevisionLog{})
// Apply filters
if userID != nil {
query = query.Where("user_id = ?", *userID)
}
// Count total
if err := query.Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := query.Preload("Item").Preload("User").Preload("User.Role").
Order("created_at DESC").
Offset(offset).Limit(limit).Find(&logs).Error
if err != nil {
return nil, 0, err
}
return logs, total, nil
}
// Log creates a new revision log entry (helper method)
func (r *RevisionLogRepository) Log(itemID, userID uint, fieldName, oldValue, newValue, reason string) error {
return models.CreateRevisionLog(r.db, itemID, userID, fieldName, oldValue, newValue, reason)
}
// internal/repositories/role_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type RoleRepository struct {
db *gorm.DB
}
func NewRoleRepository(db *gorm.DB) *RoleRepository {
return &RoleRepository{db: db}
}
// FindAll returns all roles
func (r *RoleRepository) FindAll() ([]models.Role, error) {
var roles []models.Role
err := r.db.Find(&roles).Error
return roles, err
}
// FindByID finds role by ID
func (r *RoleRepository) FindByID(id uint) (*models.Role, error) {
var role models.Role
err := r.db.First(&role, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("role not found")
}
return nil, err
}
return &role, nil
}
// FindByName finds role by name
func (r *RoleRepository) FindByName(name string) (*models.Role, error) {
var role models.Role
err := r.db.Where("name = ?", name).First(&role).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("role not found")
}
return nil, err
}
return &role, nil
}
// Create creates a new role
func (r *RoleRepository) Create(role *models.Role) error {
return r.db.Create(role).Error
}
// Update updates role data
func (r *RoleRepository) Update(role *models.Role) error {
return r.db.Save(role).Error
}
// Delete deletes a role
func (r *RoleRepository) Delete(id uint) error {
return r.db.Delete(&models.Role{}, id).Error
}
// internal/repositories/user_repo.go
package repositories
import (
"errors"
"lost-and-found/internal/models"
"gorm.io/gorm"
)
type UserRepository struct {
db *gorm.DB
}
func NewUserRepository(db *gorm.DB) *UserRepository {
return &UserRepository{db: db}
}
// Create creates a new user
func (r *UserRepository) Create(user *models.User) error {
return r.db.Create(user).Error
}
// FindByID finds user by ID
func (r *UserRepository) FindByID(id uint) (*models.User, error) {
var user models.User
err := r.db.Preload("Role").First(&user, id).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("user not found")
}
return nil, err
}
return &user, nil
}
// FindByEmail finds user by email
func (r *UserRepository) FindByEmail(email string) (*models.User, error) {
var user models.User
err := r.db.Preload("Role").Where("email = ?", email).First(&user).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("user not found")
}
return nil, err
}
return &user, nil
}
// FindByNRP finds user by NRP
func (r *UserRepository) FindByNRP(nrp string) (*models.User, error) {
var user models.User
err := r.db.Preload("Role").Where("nrp = ?", nrp).First(&user).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return nil, err
}
return &user, nil
}
// FindAll returns all users
func (r *UserRepository) FindAll(page, limit int) ([]models.User, int64, error) {
var users []models.User
var total int64
// Count total
if err := r.db.Model(&models.User{}).Count(&total).Error; err != nil {
return nil, 0, err
}
// Get paginated results
offset := (page - 1) * limit
err := r.db.Preload("Role").Offset(offset).Limit(limit).Find(&users).Error
if err != nil {
return nil, 0, err
}
return users, total, nil
}
// Update updates user data
func (r *UserRepository) Update(user *models.User) error {
return r.db.Save(user).Error
}
// UpdateRole updates user role
func (r *UserRepository) UpdateRole(userID, roleID uint) error {
return r.db.Model(&models.User{}).Where("id = ?", userID).Update("role_id", roleID).Error
}
// UpdateStatus updates user status
func (r *UserRepository) UpdateStatus(userID uint, status string) error {
return r.db.Model(&models.User{}).Where("id = ?", userID).Update("status", status).Error
}
// Delete soft deletes a user
func (r *UserRepository) Delete(id uint) error {
return r.db.Delete(&models.User{}, id).Error
}
// BlockUser blocks a user
func (r *UserRepository) BlockUser(id uint) error {
return r.UpdateStatus(id, "blocked")
}
// UnblockUser unblocks a user
func (r *UserRepository) UnblockUser(id uint) error {
return r.UpdateStatus(id, "active")
}
// CountByRole counts users by role
func (r *UserRepository) CountByRole(roleID uint) (int64, error) {
var count int64
err := r.db.Model(&models.User{}).Where("role_id = ?", roleID).Count(&count).Error
return count, err
}
// GetUserStats gets user statistics
func (r *UserRepository) GetUserStats(userID uint) (map[string]interface{}, error) {
var stats map[string]interface{} = make(map[string]interface{})
// Count items reported
var itemCount int64
if err := r.db.Model(&models.Item{}).Where("reporter_id = ?", userID).Count(&itemCount).Error; err != nil {
return nil, err
}
stats["items_reported"] = itemCount
// Count lost items reported
var lostItemCount int64
if err := r.db.Model(&models.LostItem{}).Where("user_id = ?", userID).Count(&lostItemCount).Error; err != nil {
return nil, err
}
stats["lost_items_reported"] = lostItemCount
// Count claims made
var claimCount int64
if err := r.db.Model(&models.Claim{}).Where("user_id = ?", userID).Count(&claimCount).Error; err != nil {
return nil, err
}
stats["claims_made"] = claimCount
// Count approved claims
var approvedClaimCount int64
if err := r.db.Model(&models.Claim{}).Where("user_id = ? AND status = ?", userID, models.ClaimStatusApproved).Count(&approvedClaimCount).Error; err != nil {
return nil, err
}
stats["claims_approved"] = approvedClaimCount
return stats, nil
}
// internal/routes/routes.go
package routes
import (
"lost-and-found/internal/controllers"
"lost-and-found/internal/middleware"
"github.com/gin-gonic/gin"
"gorm.io/gorm"
)
// SetupRoutes configures all application routes
func SetupRoutes(router *gin.Engine, db *gorm.DB) {
// Initialize controllers
authController := controllers.NewAuthController(db)
userController := controllers.NewUserController(db)
itemController := controllers.NewItemController(db)
lostItemController := controllers.NewLostItemController(db)
claimController := controllers.NewClaimController(db)
matchController := controllers.NewMatchController(db)
categoryController := controllers.NewCategoryController(db)
archiveController := controllers.NewArchiveController(db)
adminController := controllers.NewAdminController(db)
reportController := controllers.NewReportController(db)
// API group
api := router.Group("/api")
{
// Public routes (no authentication required)
api.POST("/register", authController.Register)
api.POST("/login", authController.Login)
api.POST("/refresh-token", authController.RefreshToken)
// Public categories
api.GET("/categories", categoryController.GetAllCategories)
api.GET("/categories/:id", categoryController.GetCategoryByID)
// Public items (read-only, limited info)
api.GET("/items", itemController.GetAllItems)
api.GET("/items/:id", itemController.GetItemByID)
// Authenticated routes (all users)
authenticated := api.Group("")
authenticated.Use(middleware.JWTMiddleware(db))
authenticated.Use(middleware.RequireUser())
{
// User profile
authenticated.GET("/me", authController.GetMe)
authenticated.GET("/user/profile", userController.GetProfile)
authenticated.PUT("/user/profile", userController.UpdateProfile)
authenticated.POST("/user/change-password", userController.ChangePassword)
authenticated.GET("/user/stats", userController.GetStats)
// User items
authenticated.GET("/user/items", itemController.GetItemsByReporter)
authenticated.POST("/items", itemController.CreateItem)
// User lost items
authenticated.GET("/user/lost-items", lostItemController.GetLostItemsByUser)
authenticated.GET("/lost-items", lostItemController.GetAllLostItems)
authenticated.GET("/lost-items/:id", lostItemController.GetLostItemByID)
authenticated.POST("/lost-items", lostItemController.CreateLostItem)
authenticated.PUT("/lost-items/:id", lostItemController.UpdateLostItem)
authenticated.PATCH("/lost-items/:id/status", lostItemController.UpdateLostItemStatus)
authenticated.DELETE("/lost-items/:id", lostItemController.DeleteLostItem)
// User claims
authenticated.GET("/user/claims", claimController.GetClaimsByUser)
authenticated.GET("/claims", claimController.GetAllClaims)
authenticated.GET("/claims/:id", claimController.GetClaimByID)
authenticated.POST("/claims", claimController.CreateClaim)
authenticated.DELETE("/claims/:id", claimController.DeleteClaim)
// Matches (for lost items)
authenticated.GET("/lost-items/:id/matches", matchController.GetMatchesForLostItem)
authenticated.POST("/lost-items/:id/find-similar", matchController.FindSimilarItems)
}
// Manager routes (manager and admin)
manager := api.Group("")
manager.Use(middleware.JWTMiddleware(db))
manager.Use(middleware.RequireManager())
{
// Item management
manager.PUT("/items/:id", itemController.UpdateItem)
manager.PATCH("/items/:id/status", itemController.UpdateItemStatus)
manager.DELETE("/items/:id", itemController.DeleteItem)
manager.GET("/items/:id/revisions", itemController.GetItemRevisionHistory)
manager.GET("/items/:id/matches", matchController.GetMatchesForItem)
// Claim verification
manager.POST("/claims/:id/verify", claimController.VerifyClaim)
manager.GET("/claims/:id/verification", claimController.GetClaimVerification)
manager.POST("/claims/:id/close", claimController.CloseClaim)
// Archives
manager.GET("/archives", archiveController.GetAllArchives)
manager.GET("/archives/:id", archiveController.GetArchiveByID)
manager.GET("/archives/stats", archiveController.GetArchiveStats)
// Dashboard
manager.GET("/manager/dashboard", adminController.GetDashboardStats)
}
// Admin routes (admin only)
admin := api.Group("/admin")
admin.Use(middleware.JWTMiddleware(db))
admin.Use(middleware.RequireAdmin())
{
// User management
admin.GET("/users", userController.GetAllUsers)
admin.GET("/users/:id", userController.GetUserByID)
admin.PATCH("/users/:id/role", userController.UpdateUserRole)
admin.POST("/users/:id/block", userController.BlockUser)
admin.POST("/users/:id/unblock", userController.UnblockUser)
admin.DELETE("/users/:id", userController.DeleteUser)
// Category management
admin.POST("/categories", categoryController.CreateCategory)
admin.PUT("/categories/:id", categoryController.UpdateCategory)
admin.DELETE("/categories/:id", categoryController.DeleteCategory)
// Dashboard & Reports
admin.GET("/dashboard", adminController.GetDashboardStats)
admin.GET("/audit-logs", adminController.GetAuditLogs)
admin.POST("/reports/export", reportController.ExportReport)
}
}
}
// internal/services/archive_service.go
package services
import (
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"gorm.io/gorm"
)
type ArchiveService struct {
archiveRepo *repositories.ArchiveRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewArchiveService(db *gorm.DB) *ArchiveService {
return &ArchiveService{
archiveRepo: repositories.NewArchiveRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// GetAllArchives gets all archived items
func (s *ArchiveService) GetAllArchives(page, limit int, reason, search string) ([]models.ArchiveResponse, int64, error) {
archives, total, err := s.archiveRepo.FindAll(page, limit, reason, search)
if err != nil {
return nil, 0, err
}
var responses []models.ArchiveResponse
for _, archive := range archives {
responses = append(responses, archive.ToResponse())
}
return responses, total, nil
}
// GetArchiveByID gets archive by ID
func (s *ArchiveService) GetArchiveByID(id uint) (*models.Archive, error) {
return s.archiveRepo.FindByID(id)
}
// GetArchiveByItemID gets archive by original item ID
func (s *ArchiveService) GetArchiveByItemID(itemID uint) (*models.Archive, error) {
return s.archiveRepo.FindByItemID(itemID)
}
// GetArchiveStats gets archive statistics
func (s *ArchiveService) GetArchiveStats() (map[string]interface{}, error) {
stats := make(map[string]interface{})
// Count by reason
expiredCount, err := s.archiveRepo.CountByReason(models.ArchiveReasonExpired)
if err != nil {
return nil, err
}
stats["expired"] = expiredCount
caseClosedCount, err := s.archiveRepo.CountByReason(models.ArchiveReasonCaseClosed)
if err != nil {
return nil, err
}
stats["case_closed"] = caseClosedCount
stats["total"] = expiredCount + caseClosedCount
return stats, nil
}
// internal/services/audit_service.go
package services
import (
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"gorm.io/gorm"
)
type AuditService struct {
auditLogRepo *repositories.AuditLogRepository
}
func NewAuditService(db *gorm.DB) *AuditService {
return &AuditService{
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// GetAllAuditLogs gets all audit logs
func (s *AuditService) GetAllAuditLogs(page, limit int, action, entityType string, userID *uint) ([]models.AuditLogResponse, int64, error) {
logs, total, err := s.auditLogRepo.FindAll(page, limit, action, entityType, userID)
if err != nil {
return nil, 0, err
}
var responses []models.AuditLogResponse
for _, log := range logs {
responses = append(responses, log.ToResponse())
}
return responses, total, nil
}
// GetAuditLogsByUser gets audit logs by user
func (s *AuditService) GetAuditLogsByUser(userID uint, page, limit int) ([]models.AuditLogResponse, int64, error) {
logs, total, err := s.auditLogRepo.FindByUser(userID, page, limit)
if err != nil {
return nil, 0, err
}
var responses []models.AuditLogResponse
for _, log := range logs {
responses = append(responses, log.ToResponse())
}
return responses, total, nil
}
// GetAuditLogsByEntity gets audit logs by entity
func (s *AuditService) GetAuditLogsByEntity(entityType string, entityID uint, page, limit int) ([]models.AuditLogResponse, int64, error) {
logs, total, err := s.auditLogRepo.FindByEntity(entityType, entityID, page, limit)
if err != nil {
return nil, 0, err
}
var responses []models.AuditLogResponse
for _, log := range logs {
responses = append(responses, log.ToResponse())
}
return responses, total, nil
}
// LogAction creates a new audit log entry
func (s *AuditService) LogAction(userID *uint, action, entityType string, entityID *uint, details, ipAddress, userAgent string) error {
return s.auditLogRepo.Log(userID, action, entityType, entityID, details, ipAddress, userAgent)
}
// internal/services/auth_service.go
package services
import (
"errors"
"log"
"lost-and-found/internal/config"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"gorm.io/gorm"
)
type AuthService struct {
userRepo *repositories.UserRepository
roleRepo *repositories.RoleRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewAuthService(db *gorm.DB) *AuthService {
return &AuthService{
userRepo: repositories.NewUserRepository(db),
roleRepo: repositories.NewRoleRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// RegisterRequest represents registration data
type RegisterRequest struct {
Name string `json:"name" binding:"required"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required,min=6"`
NRP string `json:"nrp"`
Phone string `json:"phone"`
}
// LoginRequest represents login data
type LoginRequest struct {
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required"`
}
// AuthResponse represents authentication response
type AuthResponse struct {
Token string `json:"token"`
User models.UserResponse `json:"user"`
}
// Register registers a new user
func (s *AuthService) Register(req RegisterRequest, ipAddress, userAgent string) (*AuthResponse, error) {
// Check if email already exists
existingUser, _ := s.userRepo.FindByEmail(req.Email)
if existingUser != nil {
return nil, errors.New("email already registered")
}
// Check if NRP already exists
if req.NRP != "" {
existingNRP, _ := s.userRepo.FindByNRP(req.NRP)
if existingNRP != nil {
return nil, errors.New("NRP already registered")
}
}
// Hash password
hashedPassword, err := utils.HashPassword(req.Password)
if err != nil {
return nil, errors.New("failed to hash password")
}
// Get user role ID
userRole, err := s.roleRepo.FindByName(models.RoleUser)
if err != nil {
return nil, errors.New("failed to get user role")
}
// Create user
user := &models.User{
Name: req.Name,
Email: req.Email,
Password: hashedPassword,
NRP: req.NRP,
Phone: req.Phone,
RoleID: userRole.ID,
Status: "active",
}
if err := s.userRepo.Create(user); err != nil {
return nil, errors.New("failed to create user")
}
// Load user with role
user, err = s.userRepo.FindByID(user.ID)
if err != nil {
return nil, err
}
// Generate JWT token
token, err := config.GenerateToken(user.ID, user.Email, user.Role.Name)
if err != nil {
return nil, errors.New("failed to generate token")
}
// Log audit
s.auditLogRepo.Log(&user.ID, models.ActionCreate, models.EntityUser, &user.ID,
"User registered", ipAddress, userAgent)
return &AuthResponse{
Token: token,
User: user.ToResponse(),
}, nil
}
func (s *AuthService) Login(req LoginRequest, ipAddress, userAgent string) (*AuthResponse, error) {
// DEBUG: Print request info
log.Printf("🔍 [LOGIN] Attempting login for email: %s", req.Email)
log.Printf("🔍 [LOGIN] Password length: %d characters", len(req.Password))
// Find user by email
user, err := s.userRepo.FindByEmail(req.Email)
if err != nil {
log.Printf("❌ [LOGIN] User not found in database: %s - Error: %v", req.Email, err)
return nil, errors.New("invalid email or password")
}
log.Printf("✅ [LOGIN] User found in DB - ID: %d, Name: %s, Email: %s", user.ID, user.Name, user.Email)
log.Printf("🔍 [LOGIN] User role ID: %d", user.RoleID)
log.Printf("🔍 [LOGIN] User status: %s", user.Status)
log.Printf("🔍 [LOGIN] Password hash from DB: %s", user.Password)
// Check if user is blocked
if user.IsBlocked() {
log.Printf("❌ [LOGIN] User is blocked: %s", user.Email)
return nil, errors.New("account is blocked")
}
log.Printf("✅ [LOGIN] User is active, checking password...")
// Verify password
log.Printf("🔍 [LOGIN] Checking password: '%s' against hash", req.Password)
passwordMatch := utils.CheckPasswordHash(req.Password, user.Password)
log.Printf("🔍 [LOGIN] Password match result: %v", passwordMatch)
if !passwordMatch {
log.Printf("❌ [LOGIN] Password mismatch for user: %s", user.Email)
return nil, errors.New("invalid email or password")
}
log.Printf("✅ [LOGIN] Password correct! Generating token...")
// Check if Role is loaded
if user.Role.ID == 0 {
log.Printf("⚠️ [LOGIN] Role not loaded! RoleID: %d, Role.Name: %s", user.RoleID, user.Role.Name)
log.Printf("🔧 [LOGIN] Attempting to load role manually...")
// Reload user with role
user, err = s.userRepo.FindByID(user.ID)
if err != nil {
log.Printf("❌ [LOGIN] Failed to reload user with role: %v", err)
return nil, errors.New("failed to load user data")
}
log.Printf("✅ [LOGIN] Role reloaded - Role.ID: %d, Role.Name: %s", user.Role.ID, user.Role.Name)
} else {
log.Printf("✅ [LOGIN] Role loaded - ID: %d, Name: %s", user.Role.ID, user.Role.Name)
}
// Generate JWT token
token, err := config.GenerateToken(user.ID, user.Email, user.Role.Name)
if err != nil {
log.Printf("❌ [LOGIN] Failed to generate token: %v", err)
return nil, errors.New("failed to generate token")
}
log.Printf("✅ [LOGIN] Token generated successfully for %s (Role: %s)", user.Email, user.Role.Name)
// Log audit
s.auditLogRepo.Log(&user.ID, models.ActionLogin, models.EntityUser, &user.ID,
"User logged in", ipAddress, userAgent)
log.Printf("✅ [LOGIN] Audit log created")
log.Printf("🎉 [LOGIN] Login successful for %s - Returning response", user.Email)
return &AuthResponse{
Token: token,
User: user.ToResponse(),
}, nil
}
// ValidateToken validates JWT token and returns user
func (s *AuthService) ValidateToken(tokenString string) (*models.User, error) {
// Validate token
claims, err := config.ValidateToken(tokenString)
if err != nil {
return nil, errors.New("invalid token")
}
// Get user
user, err := s.userRepo.FindByID(claims.UserID)
if err != nil {
return nil, errors.New("user not found")
}
// Check if user is blocked
if user.IsBlocked() {
return nil, errors.New("account is blocked")
}
return user, nil
}
// RefreshToken refreshes JWT token
func (s *AuthService) RefreshToken(oldToken string) (string, error) {
return config.RefreshToken(oldToken)
}
// internal/services/category_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"strings"
"gorm.io/gorm"
)
type CategoryService struct {
categoryRepo *repositories.CategoryRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewCategoryService(db *gorm.DB) *CategoryService {
return &CategoryService{
categoryRepo: repositories.NewCategoryRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// CreateCategoryRequest represents category creation data
type CreateCategoryRequest struct {
Name string `json:"name" binding:"required"`
Description string `json:"description"`
}
// UpdateCategoryRequest represents category update data
type UpdateCategoryRequest struct {
Name string `json:"name"`
Description string `json:"description"`
}
// GetAllCategories gets all categories
func (s *CategoryService) GetAllCategories() ([]models.CategoryResponse, error) {
return s.categoryRepo.GetAllWithItemCount()
}
// GetCategoryByID gets category by ID
func (s *CategoryService) GetCategoryByID(id uint) (*models.Category, error) {
return s.categoryRepo.FindByID(id)
}
// GetCategoryBySlug gets category by slug
func (s *CategoryService) GetCategoryBySlug(slug string) (*models.Category, error) {
return s.categoryRepo.FindBySlug(slug)
}
// CreateCategory creates a new category (admin only)
func (s *CategoryService) CreateCategory(adminID uint, req CreateCategoryRequest, ipAddress, userAgent string) (*models.Category, error) {
// Generate slug from name
slug := s.generateSlug(req.Name)
// Check if slug already exists
existing, _ := s.categoryRepo.FindBySlug(slug)
if existing != nil {
return nil, errors.New("category with similar name already exists")
}
category := &models.Category{
Name: req.Name,
Slug: slug,
Description: req.Description,
}
if err := s.categoryRepo.Create(category); err != nil {
return nil, errors.New("failed to create category")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionCreate, models.EntityCategory, &category.ID,
"Category created: "+category.Name, ipAddress, userAgent)
return category, nil
}
// UpdateCategory updates a category (admin only)
func (s *CategoryService) UpdateCategory(adminID, categoryID uint, req UpdateCategoryRequest, ipAddress, userAgent string) (*models.Category, error) {
category, err := s.categoryRepo.FindByID(categoryID)
if err != nil {
return nil, err
}
// Update fields
if req.Name != "" {
category.Name = req.Name
category.Slug = s.generateSlug(req.Name)
}
if req.Description != "" {
category.Description = req.Description
}
if err := s.categoryRepo.Update(category); err != nil {
return nil, errors.New("failed to update category")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionUpdate, models.EntityCategory, &categoryID,
"Category updated: "+category.Name, ipAddress, userAgent)
return category, nil
}
// DeleteCategory deletes a category (admin only)
func (s *CategoryService) DeleteCategory(adminID, categoryID uint, ipAddress, userAgent string) error {
category, err := s.categoryRepo.FindByID(categoryID)
if err != nil {
return err
}
// Check if category has items
_, count, err := s.categoryRepo.GetCategoryWithItemCount(categoryID)
if err != nil {
return err
}
if count > 0 {
return errors.New("cannot delete category with existing items")
}
if err := s.categoryRepo.Delete(categoryID); err != nil {
return errors.New("failed to delete category")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionDelete, models.EntityCategory, &categoryID,
"Category deleted: "+category.Name, ipAddress, userAgent)
return nil
}
// generateSlug generates URL-friendly slug from name
func (s *CategoryService) generateSlug(name string) string {
slug := strings.ToLower(name)
slug = strings.ReplaceAll(slug, " ", "_")
slug = strings.ReplaceAll(slug, "/", "_")
// Remove special characters
validChars := "abcdefghijklmnopqrstuvwxyz0123456789_"
result := ""
for _, char := range slug {
if strings.ContainsRune(validChars, char) {
result += string(char)
}
}
return result
}
// internal/services/claim_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"gorm.io/gorm"
)
type ClaimService struct {
db *gorm.DB // Tambahkan ini
claimRepo *repositories.ClaimRepository
itemRepo *repositories.ItemRepository
verificationRepo *repositories.ClaimVerificationRepository
notificationRepo *repositories.NotificationRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewClaimService(db *gorm.DB) *ClaimService {
return &ClaimService{
db: db, // Tambahkan ini
claimRepo: repositories.NewClaimRepository(db),
itemRepo: repositories.NewItemRepository(db),
verificationRepo: repositories.NewClaimVerificationRepository(db),
notificationRepo: repositories.NewNotificationRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// CreateClaimRequest represents claim creation data
type CreateClaimRequest struct {
ItemID uint `json:"item_id" binding:"required"`
Description string `json:"description" binding:"required"`
ProofURL string `json:"proof_url"`
Contact string `json:"contact" binding:"required"`
}
// VerifyClaimRequest represents claim verification data
type VerifyClaimRequest struct {
Status string `json:"status" binding:"required"` // approved or rejected
Notes string `json:"notes"`
}
// CreateClaim creates a new claim
func (s *ClaimService) CreateClaim(userID uint, req CreateClaimRequest, ipAddress, userAgent string) (*models.Claim, error) {
// Check if item exists
item, err := s.itemRepo.FindByID(req.ItemID)
if err != nil {
return nil, err
}
// Check if item can be claimed
if !item.CanBeClaimed() {
return nil, errors.New("item cannot be claimed")
}
// Check if user already claimed this item
exists, err := s.claimRepo.CheckExistingClaim(userID, req.ItemID)
if err != nil {
return nil, err
}
if exists {
return nil, errors.New("you already claimed this item")
}
// Create claim
claim := &models.Claim{
ItemID: req.ItemID,
UserID: userID,
Description: req.Description,
ProofURL: req.ProofURL,
Contact: req.Contact,
Status: models.ClaimStatusPending,
}
if err := s.claimRepo.Create(claim); err != nil {
return nil, errors.New("failed to create claim")
}
// Update item status to pending claim
s.itemRepo.UpdateStatus(req.ItemID, models.ItemStatusPendingClaim)
// Log audit
s.auditLogRepo.Log(&userID, models.ActionCreate, models.EntityClaim, &claim.ID,
"Claim created for item: "+item.Name, ipAddress, userAgent)
// Load claim with relations
return s.claimRepo.FindByID(claim.ID)
}
// GetAllClaims gets all claims
func (s *ClaimService) GetAllClaims(page, limit int, status string, itemID, userID *uint) ([]models.ClaimResponse, int64, error) {
claims, total, err := s.claimRepo.FindAll(page, limit, status, itemID, userID)
if err != nil {
return nil, 0, err
}
var responses []models.ClaimResponse
for _, claim := range claims {
responses = append(responses, claim.ToResponse())
}
return responses, total, nil
}
// GetClaimByID gets claim by ID
func (s *ClaimService) GetClaimByID(id uint, isManager bool) (interface{}, error) {
claim, err := s.claimRepo.FindByID(id)
if err != nil {
return nil, err
}
// Manager can see full details including item description
if isManager {
return claim.ToDetailResponse(), nil
}
return claim.ToResponse(), nil
}
// GetClaimsByUser gets claims by user
func (s *ClaimService) GetClaimsByUser(userID uint, page, limit int) ([]models.ClaimResponse, int64, error) {
claims, total, err := s.claimRepo.FindByUser(userID, page, limit)
if err != nil {
return nil, 0, err
}
var responses []models.ClaimResponse
for _, claim := range claims {
responses = append(responses, claim.ToResponse())
}
return responses, total, nil
}
// VerifyClaim verifies a claim (manager only)
func (s *ClaimService) VerifyClaim(managerID, claimID uint, req VerifyClaimRequest, similarityScore float64, matchedKeywords string, ipAddress, userAgent string) error {
claim, err := s.claimRepo.FindByID(claimID)
if err != nil {
return err
}
if !claim.IsPending() {
return errors.New("claim is not pending")
}
// Create or update verification record
verification, _ := s.verificationRepo.FindByClaimID(claimID)
if verification == nil {
verification = &models.ClaimVerification{
ClaimID: claimID,
SimilarityScore: similarityScore,
MatchedKeywords: matchedKeywords,
VerificationNotes: req.Notes,
IsAutoMatched: false,
}
s.verificationRepo.Create(verification)
} else {
verification.VerificationNotes = req.Notes
s.verificationRepo.Update(verification)
}
// Update claim status
if req.Status == models.ClaimStatusApproved {
claim.Approve(managerID, req.Notes)
// Update item status to verified
s.itemRepo.UpdateStatus(claim.ItemID, models.ItemStatusVerified)
// Send approval notification - PERBAIKAN DI SINI
item, _ := s.itemRepo.FindByID(claim.ItemID)
models.CreateClaimApprovedNotification(s.db, claim.UserID, item.Name, claimID)
// Log audit
s.auditLogRepo.Log(&managerID, models.ActionApprove, models.EntityClaim, &claimID,
"Claim approved", ipAddress, userAgent)
} else if req.Status == models.ClaimStatusRejected {
claim.Reject(managerID, req.Notes)
// Check if there are other pending claims for this item
otherClaims, _ := s.claimRepo.FindByItem(claim.ItemID)
hasPendingClaims := false
for _, c := range otherClaims {
if c.ID != claimID && c.IsPending() {
hasPendingClaims = true
break
}
}
// If no other pending claims, set item back to unclaimed
if !hasPendingClaims {
s.itemRepo.UpdateStatus(claim.ItemID, models.ItemStatusUnclaimed)
}
// Send rejection notification - PERBAIKAN DI SINI
item, _ := s.itemRepo.FindByID(claim.ItemID)
models.CreateClaimRejectedNotification(s.db, claim.UserID, item.Name, req.Notes, claimID)
// Log audit
s.auditLogRepo.Log(&managerID, models.ActionReject, models.EntityClaim, &claimID,
"Claim rejected: "+req.Notes, ipAddress, userAgent)
} else {
return errors.New("invalid status")
}
if err := s.claimRepo.Update(claim); err != nil {
return errors.New("failed to verify claim")
}
return nil
}
// CloseClaim closes a claim and moves item to archive (manager only)
func (s *ClaimService) CloseClaim(managerID, claimID uint, ipAddress, userAgent string) error {
claim, err := s.claimRepo.FindByID(claimID)
if err != nil {
return err
}
if !claim.IsApproved() {
return errors.New("only approved claims can be closed")
}
// Update item status to case_closed
if err := s.itemRepo.UpdateStatus(claim.ItemID, models.ItemStatusCaseClosed); err != nil {
return errors.New("failed to close case")
}
// Archive the item
item, _ := s.itemRepo.FindByID(claim.ItemID)
s.itemRepo.ArchiveItem(item, models.ArchiveReasonCaseClosed, &claim.UserID)
// Log audit
s.auditLogRepo.Log(&managerID, models.ActionUpdate, models.EntityItem, &item.ID,
"Case closed and archived", ipAddress, userAgent)
return nil
}
// DeleteClaim deletes a claim
func (s *ClaimService) DeleteClaim(userID, claimID uint, ipAddress, userAgent string) error {
claim, err := s.claimRepo.FindByID(claimID)
if err != nil {
return err
}
// Only pending claims can be deleted by users
if !claim.IsPending() && claim.UserID == userID {
return errors.New("cannot delete non-pending claim")
}
if err := s.claimRepo.Delete(claimID); err != nil {
return errors.New("failed to delete claim")
}
// Check if item should go back to unclaimed
otherClaims, _ := s.claimRepo.FindByItem(claim.ItemID)
if len(otherClaims) == 0 {
s.itemRepo.UpdateStatus(claim.ItemID, models.ItemStatusUnclaimed)
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionDelete, models.EntityClaim, &claimID,
"Claim deleted", ipAddress, userAgent)
return nil
}
// internal/services/export_service.go
package services
import (
"bytes"
"fmt"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"time"
"gorm.io/gorm"
)
type ExportService struct {
itemRepo *repositories.ItemRepository
archiveRepo *repositories.ArchiveRepository
claimRepo *repositories.ClaimRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewExportService(db *gorm.DB) *ExportService {
return &ExportService{
itemRepo: repositories.NewItemRepository(db),
archiveRepo: repositories.NewArchiveRepository(db),
claimRepo: repositories.NewClaimRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// ExportRequest represents export request data
type ExportRequest struct {
Type string `json:"type"` // items, archives, claims, audit_logs
Format string `json:"format"` // pdf, excel
StartDate *time.Time `json:"start_date"`
EndDate *time.Time `json:"end_date"`
Status string `json:"status"`
}
// ExportItemsToPDF exports items to PDF
func (s *ExportService) ExportItemsToPDF(req ExportRequest, userID uint, ipAddress, userAgent string) (*bytes.Buffer, error) {
// Get items
items, _, err := s.itemRepo.FindAll(1, 10000, req.Status, "", "")
if err != nil {
return nil, err
}
// Filter by date range if provided
var filteredItems []models.Item
for _, item := range items {
if req.StartDate != nil && item.DateFound.Before(*req.StartDate) {
continue
}
if req.EndDate != nil && item.DateFound.After(*req.EndDate) {
continue
}
filteredItems = append(filteredItems, item)
}
// Generate PDF
pdf := utils.NewPDFExporter()
pdf.AddTitle("Laporan Barang Ditemukan")
pdf.AddSubtitle(fmt.Sprintf("Periode: %s - %s",
formatDate(req.StartDate),
formatDate(req.EndDate)))
pdf.AddNewLine()
// Add table
headers := []string{"No", "Nama Barang", "Kategori", "Lokasi", "Tanggal Ditemukan", "Status"}
var data [][]string
for i, item := range filteredItems {
data = append(data, []string{
fmt.Sprintf("%d", i+1),
item.Name,
item.Category.Name,
item.Location,
item.DateFound.Format("02 Jan 2006"),
item.Status,
})
}
pdf.AddTable(headers, data)
// Add footer
pdf.AddNewLine()
pdf.AddText(fmt.Sprintf("Total: %d barang", len(filteredItems)))
pdf.AddText(fmt.Sprintf("Dicetak pada: %s", time.Now().Format("02 January 2006 15:04")))
// Log audit
s.auditLogRepo.Log(&userID, models.ActionExport, "report", nil,
fmt.Sprintf("Exported items report (PDF, %d items)", len(filteredItems)),
ipAddress, userAgent)
return pdf.Output(), nil
}
// ExportItemsToExcel exports items to Excel
func (s *ExportService) ExportItemsToExcel(req ExportRequest, userID uint, ipAddress, userAgent string) (*bytes.Buffer, error) {
// Get items
items, _, err := s.itemRepo.FindAll(1, 10000, req.Status, "", "")
if err != nil {
return nil, err
}
// Filter by date range if provided
var filteredItems []models.Item
for _, item := range items {
if req.StartDate != nil && item.DateFound.Before(*req.StartDate) {
continue
}
if req.EndDate != nil && item.DateFound.After(*req.EndDate) {
continue
}
filteredItems = append(filteredItems, item)
}
// Generate Excel
excel := utils.NewExcelExporter()
excel.SetSheetName("Barang Ditemukan")
// Add headers
headers := []string{"No", "Nama Barang", "Kategori", "Lokasi", "Deskripsi",
"Tanggal Ditemukan", "Status", "Pelapor", "Kontak"}
excel.AddRow(headers)
// Add data
for i, item := range filteredItems {
excel.AddRow([]string{
fmt.Sprintf("%d", i+1),
item.Name,
item.Category.Name,
item.Location,
item.Description,
item.DateFound.Format("02 Jan 2006"),
item.Status,
item.ReporterName,
item.ReporterContact,
})
}
// Auto-size columns
excel.AutoSizeColumns(len(headers))
// Log audit
s.auditLogRepo.Log(&userID, models.ActionExport, "report", nil,
fmt.Sprintf("Exported items report (Excel, %d items)", len(filteredItems)),
ipAddress, userAgent)
return excel.Output()
}
// ExportArchivesToPDF exports archives to PDF
func (s *ExportService) ExportArchivesToPDF(req ExportRequest, userID uint, ipAddress, userAgent string) (*bytes.Buffer, error) {
archives, _, err := s.archiveRepo.FindAll(1, 10000, "", "")
if err != nil {
return nil, err
}
// Filter by date range
var filteredArchives []models.Archive
for _, archive := range archives {
if req.StartDate != nil && archive.ArchivedAt.Before(*req.StartDate) {
continue
}
if req.EndDate != nil && archive.ArchivedAt.After(*req.EndDate) {
continue
}
filteredArchives = append(filteredArchives, archive)
}
pdf := utils.NewPDFExporter()
pdf.AddTitle("Laporan Barang yang Diarsipkan")
pdf.AddSubtitle(fmt.Sprintf("Periode: %s - %s",
formatDate(req.StartDate),
formatDate(req.EndDate)))
pdf.AddNewLine()
headers := []string{"No", "Nama Barang", "Kategori", "Alasan Arsip", "Tanggal Arsip"}
var data [][]string
for i, archive := range filteredArchives {
data = append(data, []string{
fmt.Sprintf("%d", i+1),
archive.Name,
archive.Category.Name,
archive.ArchivedReason,
archive.ArchivedAt.Format("02 Jan 2006"),
})
}
pdf.AddTable(headers, data)
pdf.AddNewLine()
pdf.AddText(fmt.Sprintf("Total: %d barang", len(filteredArchives)))
s.auditLogRepo.Log(&userID, models.ActionExport, "report", nil,
fmt.Sprintf("Exported archives report (PDF, %d items)", len(filteredArchives)),
ipAddress, userAgent)
return pdf.Output(), nil
}
// ExportClaimsToPDF exports claims to PDF
func (s *ExportService) ExportClaimsToPDF(req ExportRequest, userID uint, ipAddress, userAgent string) (*bytes.Buffer, error) {
claims, _, err := s.claimRepo.FindAll(1, 10000, req.Status, nil, nil)
if err != nil {
return nil, err
}
// Filter by date range
var filteredClaims []models.Claim
for _, claim := range claims {
if req.StartDate != nil && claim.CreatedAt.Before(*req.StartDate) {
continue
}
if req.EndDate != nil && claim.CreatedAt.After(*req.EndDate) {
continue
}
filteredClaims = append(filteredClaims, claim)
}
pdf := utils.NewPDFExporter()
pdf.AddTitle("Laporan Klaim Barang")
pdf.AddSubtitle(fmt.Sprintf("Periode: %s - %s",
formatDate(req.StartDate),
formatDate(req.EndDate)))
pdf.AddNewLine()
headers := []string{"No", "Barang", "Pengklaim", "Status", "Tanggal Klaim"}
var data [][]string
for i, claim := range filteredClaims {
data = append(data, []string{
fmt.Sprintf("%d", i+1),
claim.Item.Name,
claim.User.Name,
claim.Status,
claim.CreatedAt.Format("02 Jan 2006"),
})
}
pdf.AddTable(headers, data)
pdf.AddNewLine()
pdf.AddText(fmt.Sprintf("Total: %d klaim", len(filteredClaims)))
s.auditLogRepo.Log(&userID, models.ActionExport, "report", nil,
fmt.Sprintf("Exported claims report (PDF, %d claims)", len(filteredClaims)),
ipAddress, userAgent)
return pdf.Output(), nil
}
// Helper function to format date
func formatDate(date *time.Time) string {
if date == nil {
return "N/A"
}
return date.Format("02 Jan 2006")
}
// internal/services/item_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"time"
"gorm.io/gorm"
)
type ItemService struct {
itemRepo *repositories.ItemRepository
categoryRepo *repositories.CategoryRepository
auditLogRepo *repositories.AuditLogRepository
revisionRepo *repositories.RevisionLogRepository
}
func NewItemService(db *gorm.DB) *ItemService {
return &ItemService{
itemRepo: repositories.NewItemRepository(db),
categoryRepo: repositories.NewCategoryRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
revisionRepo: repositories.NewRevisionLogRepository(db),
}
}
// CreateItemRequest represents create item data
type CreateItemRequest struct {
Name string `json:"name" binding:"required"`
CategoryID uint `json:"category_id" binding:"required"`
PhotoURL string `json:"photo_url"`
Location string `json:"location" binding:"required"`
Description string `json:"description" binding:"required"`
DateFound time.Time `json:"date_found" binding:"required"`
ReporterName string `json:"reporter_name" binding:"required"`
ReporterContact string `json:"reporter_contact" binding:"required"`
}
// UpdateItemRequest represents update item data
type UpdateItemRequest struct {
Name string `json:"name"`
CategoryID uint `json:"category_id"`
Location string `json:"location"`
Description string `json:"description"`
DateFound time.Time `json:"date_found"`
ReporterName string `json:"reporter_name"`
ReporterContact string `json:"reporter_contact"`
Reason string `json:"reason"` // Reason for edit
}
// GetAllItems gets all items (public view)
func (s *ItemService) GetAllItems(page, limit int, status, category, search string) ([]models.ItemPublicResponse, int64, error) {
items, total, err := s.itemRepo.FindAll(page, limit, status, category, search)
if err != nil {
return nil, 0, err
}
var responses []models.ItemPublicResponse
for _, item := range items {
responses = append(responses, item.ToPublicResponse())
}
return responses, total, nil
}
// GetItemByID gets item by ID
func (s *ItemService) GetItemByID(id uint, isManager bool) (interface{}, error) {
item, err := s.itemRepo.FindByID(id)
if err != nil {
return nil, err
}
// Manager can see full details
if isManager {
return item.ToDetailResponse(), nil
}
// Public can only see limited info
return item.ToPublicResponse(), nil
}
// CreateItem creates a new item
func (s *ItemService) CreateItem(reporterID uint, req CreateItemRequest, ipAddress, userAgent string) (*models.Item, error) {
// Verify category exists
if _, err := s.categoryRepo.FindByID(req.CategoryID); err != nil {
return nil, errors.New("invalid category")
}
item := &models.Item{
Name: req.Name,
CategoryID: req.CategoryID,
PhotoURL: req.PhotoURL,
Location: req.Location,
Description: req.Description,
DateFound: req.DateFound,
Status: models.ItemStatusUnclaimed,
ReporterID: reporterID,
ReporterName: req.ReporterName,
ReporterContact: req.ReporterContact,
}
if err := s.itemRepo.Create(item); err != nil {
return nil, errors.New("failed to create item")
}
// Log audit
s.auditLogRepo.Log(&reporterID, models.ActionCreate, models.EntityItem, &item.ID,
"Item created: "+item.Name, ipAddress, userAgent)
return item, nil
}
// UpdateItem updates an item
func (s *ItemService) UpdateItem(userID, itemID uint, req UpdateItemRequest, ipAddress, userAgent string) (*models.Item, error) {
item, err := s.itemRepo.FindByID(itemID)
if err != nil {
return nil, err
}
// Check if item can be edited
if !item.CanBeEdited() {
return nil, errors.New("cannot edit item with status: " + item.Status)
}
// Track changes for revision log
if req.Name != "" && req.Name != item.Name {
s.revisionRepo.Log(itemID, userID, "name", item.Name, req.Name, req.Reason)
item.Name = req.Name
}
if req.CategoryID != 0 && req.CategoryID != item.CategoryID {
oldCat, _ := s.categoryRepo.FindByID(item.CategoryID)
newCat, _ := s.categoryRepo.FindByID(req.CategoryID)
s.revisionRepo.Log(itemID, userID, "category", oldCat.Name, newCat.Name, req.Reason)
item.CategoryID = req.CategoryID
}
if req.Location != "" && req.Location != item.Location {
s.revisionRepo.Log(itemID, userID, "location", item.Location, req.Location, req.Reason)
item.Location = req.Location
}
if req.Description != "" && req.Description != item.Description {
s.revisionRepo.Log(itemID, userID, "description", item.Description, req.Description, req.Reason)
item.Description = req.Description
}
if err := s.itemRepo.Update(item); err != nil {
return nil, errors.New("failed to update item")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityItem, &itemID,
"Item updated: "+item.Name, ipAddress, userAgent)
return item, nil
}
// UpdateItemStatus updates item status
func (s *ItemService) UpdateItemStatus(userID, itemID uint, status string, ipAddress, userAgent string) error {
if err := s.itemRepo.UpdateStatus(itemID, status); err != nil {
return errors.New("failed to update item status")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityItem, &itemID,
"Item status updated to: "+status, ipAddress, userAgent)
return nil
}
// DeleteItem deletes an item
func (s *ItemService) DeleteItem(userID, itemID uint, ipAddress, userAgent string) error {
item, err := s.itemRepo.FindByID(itemID)
if err != nil {
return err
}
// Cannot delete verified or case closed items
if item.Status == models.ItemStatusVerified || item.Status == models.ItemStatusCaseClosed {
return errors.New("cannot delete item with status: " + item.Status)
}
if err := s.itemRepo.Delete(itemID); err != nil {
return errors.New("failed to delete item")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionDelete, models.EntityItem, &itemID,
"Item deleted: "+item.Name, ipAddress, userAgent)
return nil
}
// GetItemsByReporter gets items by reporter
func (s *ItemService) GetItemsByReporter(reporterID uint, page, limit int) ([]models.Item, int64, error) {
return s.itemRepo.FindByReporter(reporterID, page, limit)
}
// GetItemRevisionHistory gets revision history for an item
func (s *ItemService) GetItemRevisionHistory(itemID uint, page, limit int) ([]models.RevisionLogResponse, int64, error) {
logs, total, err := s.revisionRepo.FindByItem(itemID, page, limit)
if err != nil {
return nil, 0, err
}
var responses []models.RevisionLogResponse
for _, log := range logs {
responses = append(responses, log.ToResponse())
}
return responses, total, nil
}
// internal/services/lost_item_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"time"
"gorm.io/gorm"
)
type LostItemService struct {
lostItemRepo *repositories.LostItemRepository
categoryRepo *repositories.CategoryRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewLostItemService(db *gorm.DB) *LostItemService {
return &LostItemService{
lostItemRepo: repositories.NewLostItemRepository(db),
categoryRepo: repositories.NewCategoryRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// CreateLostItemRequest represents create lost item data
type CreateLostItemRequest struct {
Name string `json:"name" binding:"required"`
CategoryID uint `json:"category_id" binding:"required"`
Color string `json:"color"`
Location string `json:"location"`
Description string `json:"description" binding:"required"`
DateLost time.Time `json:"date_lost" binding:"required"`
}
// UpdateLostItemRequest represents update lost item data
type UpdateLostItemRequest struct {
Name string `json:"name"`
CategoryID uint `json:"category_id"`
Color string `json:"color"`
Location string `json:"location"`
Description string `json:"description"`
DateLost time.Time `json:"date_lost"`
}
// GetAllLostItems gets all lost items
func (s *LostItemService) GetAllLostItems(page, limit int, status, category, search string, userID *uint) ([]models.LostItemResponse, int64, error) {
lostItems, total, err := s.lostItemRepo.FindAll(page, limit, status, category, search, userID)
if err != nil {
return nil, 0, err
}
var responses []models.LostItemResponse
for _, lostItem := range lostItems {
responses = append(responses, lostItem.ToResponse())
}
return responses, total, nil
}
// GetLostItemByID gets lost item by ID
func (s *LostItemService) GetLostItemByID(id uint) (*models.LostItem, error) {
return s.lostItemRepo.FindByID(id)
}
// CreateLostItem creates a new lost item report
func (s *LostItemService) CreateLostItem(userID uint, req CreateLostItemRequest, ipAddress, userAgent string) (*models.LostItem, error) {
// Verify category exists
if _, err := s.categoryRepo.FindByID(req.CategoryID); err != nil {
return nil, errors.New("invalid category")
}
lostItem := &models.LostItem{
UserID: userID,
Name: req.Name,
CategoryID: req.CategoryID,
Color: req.Color,
Location: req.Location,
Description: req.Description,
DateLost: req.DateLost,
Status: models.LostItemStatusActive,
}
if err := s.lostItemRepo.Create(lostItem); err != nil {
return nil, errors.New("failed to create lost item report")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionCreate, models.EntityLostItem, &lostItem.ID,
"Lost item report created: "+lostItem.Name, ipAddress, userAgent)
// Load with relations
return s.lostItemRepo.FindByID(lostItem.ID)
}
// UpdateLostItem updates a lost item report
func (s *LostItemService) UpdateLostItem(userID, lostItemID uint, req UpdateLostItemRequest, ipAddress, userAgent string) (*models.LostItem, error) {
lostItem, err := s.lostItemRepo.FindByID(lostItemID)
if err != nil {
return nil, err
}
// Only owner can update
if lostItem.UserID != userID {
return nil, errors.New("unauthorized to update this lost item report")
}
// Only active reports can be updated
if !lostItem.IsActive() {
return nil, errors.New("cannot update non-active lost item report")
}
// Update fields
if req.Name != "" {
lostItem.Name = req.Name
}
if req.CategoryID != 0 {
// Verify category exists
if _, err := s.categoryRepo.FindByID(req.CategoryID); err != nil {
return nil, errors.New("invalid category")
}
lostItem.CategoryID = req.CategoryID
}
if req.Color != "" {
lostItem.Color = req.Color
}
if req.Location != "" {
lostItem.Location = req.Location
}
if req.Description != "" {
lostItem.Description = req.Description
}
if !req.DateLost.IsZero() {
lostItem.DateLost = req.DateLost
}
if err := s.lostItemRepo.Update(lostItem); err != nil {
return nil, errors.New("failed to update lost item report")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityLostItem, &lostItemID,
"Lost item report updated: "+lostItem.Name, ipAddress, userAgent)
return lostItem, nil
}
// UpdateLostItemStatus updates lost item status
func (s *LostItemService) UpdateLostItemStatus(userID, lostItemID uint, status string, ipAddress, userAgent string) error {
lostItem, err := s.lostItemRepo.FindByID(lostItemID)
if err != nil {
return err
}
// Only owner can update
if lostItem.UserID != userID {
return errors.New("unauthorized to update this lost item report")
}
if err := s.lostItemRepo.UpdateStatus(lostItemID, status); err != nil {
return errors.New("failed to update lost item status")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityLostItem, &lostItemID,
"Lost item status updated to: "+status, ipAddress, userAgent)
return nil
}
// DeleteLostItem deletes a lost item report
func (s *LostItemService) DeleteLostItem(userID, lostItemID uint, ipAddress, userAgent string) error {
lostItem, err := s.lostItemRepo.FindByID(lostItemID)
if err != nil {
return err
}
// Only owner can delete
if lostItem.UserID != userID {
return errors.New("unauthorized to delete this lost item report")
}
if err := s.lostItemRepo.Delete(lostItemID); err != nil {
return errors.New("failed to delete lost item report")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionDelete, models.EntityLostItem, &lostItemID,
"Lost item report deleted: "+lostItem.Name, ipAddress, userAgent)
return nil
}
// GetLostItemsByUser gets lost items by user
func (s *LostItemService) GetLostItemsByUser(userID uint, page, limit int) ([]models.LostItemResponse, int64, error) {
lostItems, total, err := s.lostItemRepo.FindByUser(userID, page, limit)
if err != nil {
return nil, 0, err
}
var responses []models.LostItemResponse
for _, lostItem := range lostItems {
responses = append(responses, lostItem.ToResponse())
}
return responses, total, nil
}
// internal/services/match_service.go
package services
import (
"encoding/json"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"gorm.io/gorm"
)
type MatchService struct {
db *gorm.DB // Tambahkan ini
matchRepo *repositories.MatchResultRepository
itemRepo *repositories.ItemRepository
lostItemRepo *repositories.LostItemRepository
notificationRepo *repositories.NotificationRepository
}
func NewMatchService(db *gorm.DB) *MatchService {
return &MatchService{
db: db, // Tambahkan ini
matchRepo: repositories.NewMatchResultRepository(db),
itemRepo: repositories.NewItemRepository(db),
lostItemRepo: repositories.NewLostItemRepository(db),
notificationRepo: repositories.NewNotificationRepository(db),
}
}
// MatchedField represents a matched field between items
type MatchedField struct {
Field string `json:"field"`
LostValue string `json:"lost_value"`
FoundValue string `json:"found_value"`
Score float64 `json:"score"`
}
// FindSimilarItems finds similar items for a lost item report
func (s *MatchService) FindSimilarItems(lostItemID uint) ([]models.MatchResultResponse, error) {
lostItem, err := s.lostItemRepo.FindByID(lostItemID)
if err != nil {
return nil, err
}
// Search for items in same category
items, err := s.itemRepo.SearchForMatching(lostItem.CategoryID, lostItem.Name, lostItem.Color)
if err != nil {
return nil, err
}
var results []models.MatchResultResponse
for _, item := range items {
// Calculate similarity
score, matchedFields := s.calculateSimilarity(lostItem, &item)
// Only include if score is reasonable (>= 30%)
if score >= 30.0 {
// Check if match already exists
exists, _ := s.matchRepo.CheckExistingMatch(lostItemID, item.ID)
if !exists {
// Create match result
matchedFieldsJSON, _ := json.Marshal(matchedFields)
match := &models.MatchResult{
LostItemID: lostItemID,
ItemID: item.ID,
SimilarityScore: score,
MatchedFields: string(matchedFieldsJSON),
IsNotified: false,
}
s.matchRepo.Create(match)
// Reload with relations
match, _ = s.matchRepo.FindByID(match.ID)
results = append(results, match.ToResponse())
}
}
}
return results, nil
}
// GetMatchesForLostItem gets all matches for a lost item
func (s *MatchService) GetMatchesForLostItem(lostItemID uint) ([]models.MatchResultResponse, error) {
matches, err := s.matchRepo.FindByLostItem(lostItemID)
if err != nil {
return nil, err
}
var responses []models.MatchResultResponse
for _, match := range matches {
responses = append(responses, match.ToResponse())
}
return responses, nil
}
// GetMatchesForItem gets all matches for an item
func (s *MatchService) GetMatchesForItem(itemID uint) ([]models.MatchResultResponse, error) {
matches, err := s.matchRepo.FindByItem(itemID)
if err != nil {
return nil, err
}
var responses []models.MatchResultResponse
for _, match := range matches {
responses = append(responses, match.ToResponse())
}
return responses, nil
}
// AutoMatchNewItem automatically matches a new item with lost items
func (s *MatchService) AutoMatchNewItem(itemID uint) error {
item, err := s.itemRepo.FindByID(itemID)
if err != nil {
return err
}
// Find active lost items in same category
lostItems, err := s.lostItemRepo.FindActiveForMatching(item.CategoryID)
if err != nil {
return err
}
for _, lostItem := range lostItems {
// Calculate similarity
score, matchedFields := s.calculateSimilarity(&lostItem, item)
// Create match if score is high enough (>= 50% for auto-match)
if score >= 50.0 {
// Check if match already exists
exists, _ := s.matchRepo.CheckExistingMatch(lostItem.ID, itemID)
if !exists {
matchedFieldsJSON, _ := json.Marshal(matchedFields)
match := &models.MatchResult{
LostItemID: lostItem.ID,
ItemID: itemID,
SimilarityScore: score,
MatchedFields: string(matchedFieldsJSON),
IsNotified: false,
}
s.matchRepo.Create(match)
// Send notification to lost item owner - PERBAIKAN DI SINI
models.CreateMatchNotification(s.db, lostItem.UserID, item.Name, match.ID)
s.matchRepo.MarkAsNotified(match.ID)
}
}
}
return nil
}
// calculateSimilarity calculates similarity between lost item and found item
func (s *MatchService) calculateSimilarity(lostItem *models.LostItem, item *models.Item) (float64, []MatchedField) {
var matchedFields []MatchedField
totalScore := 0.0
maxScore := 0.0
// Category match (20 points)
maxScore += 20
if lostItem.CategoryID == item.CategoryID {
totalScore += 20
matchedFields = append(matchedFields, MatchedField{
Field: "category",
LostValue: lostItem.Category.Name,
FoundValue: item.Category.Name,
Score: 20,
})
}
// Name similarity (30 points)
maxScore += 30
nameSimilarity := utils.CalculateStringSimilarity(lostItem.Name, item.Name)
nameScore := nameSimilarity * 30
totalScore += nameScore
if nameScore > 10 {
matchedFields = append(matchedFields, MatchedField{
Field: "name",
LostValue: lostItem.Name,
FoundValue: item.Name,
Score: nameScore,
})
}
// Color match (15 points)
if lostItem.Color != "" {
maxScore += 15
colorSimilarity := utils.CalculateStringSimilarity(lostItem.Color, item.Name+" "+item.Description)
colorScore := colorSimilarity * 15
totalScore += colorScore
if colorScore > 5 {
matchedFields = append(matchedFields, MatchedField{
Field: "color",
LostValue: lostItem.Color,
FoundValue: "matched in description",
Score: colorScore,
})
}
}
// Location match (20 points)
if lostItem.Location != "" {
maxScore += 20
locationSimilarity := utils.CalculateStringSimilarity(lostItem.Location, item.Location)
locationScore := locationSimilarity * 20
totalScore += locationScore
if locationScore > 10 {
matchedFields = append(matchedFields, MatchedField{
Field: "location",
LostValue: lostItem.Location,
FoundValue: item.Location,
Score: locationScore,
})
}
}
// Description keywords match (15 points)
maxScore += 15
descSimilarity := utils.CalculateStringSimilarity(lostItem.Description, item.Description)
descScore := descSimilarity * 15
totalScore += descScore
if descScore > 5 {
matchedFields = append(matchedFields, MatchedField{
Field: "description",
LostValue: "keywords matched",
FoundValue: "keywords matched",
Score: descScore,
})
}
// Calculate percentage
percentage := (totalScore / maxScore) * 100
if percentage > 100 {
percentage = 100
}
return percentage, matchedFields
}
// internal/services/notification_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"gorm.io/gorm"
)
type NotificationService struct {
db *gorm.DB // Tambahkan ini
notificationRepo *repositories.NotificationRepository
}
func NewNotificationService(db *gorm.DB) *NotificationService {
return &NotificationService{
db: db, // Tambahkan ini
notificationRepo: repositories.NewNotificationRepository(db),
}
}
// GetUserNotifications gets notifications for a user
func (s *NotificationService) GetUserNotifications(userID uint, page, limit int, onlyUnread bool) ([]models.NotificationResponse, int64, error) {
notifications, total, err := s.notificationRepo.FindByUser(userID, page, limit, onlyUnread)
if err != nil {
return nil, 0, err
}
var responses []models.NotificationResponse
for _, notification := range notifications {
responses = append(responses, notification.ToResponse())
}
return responses, total, nil
}
// GetNotificationByID gets notification by ID
func (s *NotificationService) GetNotificationByID(userID, notificationID uint) (*models.Notification, error) {
notification, err := s.notificationRepo.FindByID(notificationID)
if err != nil {
return nil, err
}
// Check ownership
if notification.UserID != userID {
return nil, errors.New("unauthorized")
}
return notification, nil
}
// MarkAsRead marks a notification as read
func (s *NotificationService) MarkAsRead(userID, notificationID uint) error {
notification, err := s.notificationRepo.FindByID(notificationID)
if err != nil {
return err
}
// Check ownership
if notification.UserID != userID {
return errors.New("unauthorized")
}
return s.notificationRepo.MarkAsRead(notificationID)
}
// MarkAllAsRead marks all notifications as read for a user
func (s *NotificationService) MarkAllAsRead(userID uint) error {
return s.notificationRepo.MarkAllAsRead(userID)
}
// DeleteNotification deletes a notification
func (s *NotificationService) DeleteNotification(userID, notificationID uint) error {
notification, err := s.notificationRepo.FindByID(notificationID)
if err != nil {
return err
}
// Check ownership
if notification.UserID != userID {
return errors.New("unauthorized")
}
return s.notificationRepo.Delete(notificationID)
}
// DeleteAllNotifications deletes all notifications for a user
func (s *NotificationService) DeleteAllNotifications(userID uint) error {
return s.notificationRepo.DeleteAllForUser(userID)
}
// CountUnread counts unread notifications for a user
func (s *NotificationService) CountUnread(userID uint) (int64, error) {
return s.notificationRepo.CountUnread(userID)
}
// CreateNotification creates a new notification
func (s *NotificationService) CreateNotification(userID uint, notifType, title, message, entityType string, entityID *uint) error {
return s.notificationRepo.Notify(userID, notifType, title, message, entityType, entityID)
}
// SendMatchNotification sends notification when a match is found
func (s *NotificationService) SendMatchNotification(userID uint, itemName string, matchID uint) error {
return models.CreateMatchNotification(s.db, userID, itemName, matchID)
}
// SendClaimApprovedNotification sends notification when claim is approved
func (s *NotificationService) SendClaimApprovedNotification(userID uint, itemName string, claimID uint) error {
return models.CreateClaimApprovedNotification(s.db, userID, itemName, claimID)
}
// SendClaimRejectedNotification sends notification when claim is rejected
func (s *NotificationService) SendClaimRejectedNotification(userID uint, itemName, reason string, claimID uint) error {
return models.CreateClaimRejectedNotification(s.db, userID, itemName, reason, claimID)
}
// internal/services/user_service.go
package services
import (
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"gorm.io/gorm"
)
type UserService struct {
userRepo *repositories.UserRepository
roleRepo *repositories.RoleRepository
auditLogRepo *repositories.AuditLogRepository
}
func NewUserService(db *gorm.DB) *UserService {
return &UserService{
userRepo: repositories.NewUserRepository(db),
roleRepo: repositories.NewRoleRepository(db),
auditLogRepo: repositories.NewAuditLogRepository(db),
}
}
// UpdateProfileRequest represents profile update data
type UpdateProfileRequest struct {
Name string `json:"name"`
Phone string `json:"phone"`
NRP string `json:"nrp"`
}
// ChangePasswordRequest represents password change data
type ChangePasswordRequest struct {
OldPassword string `json:"old_password" binding:"required"`
NewPassword string `json:"new_password" binding:"required,min=6"`
}
// GetProfile gets user profile
func (s *UserService) GetProfile(userID uint) (*models.User, error) {
return s.userRepo.FindByID(userID)
}
// UpdateProfile updates user profile
func (s *UserService) UpdateProfile(userID uint, req UpdateProfileRequest, ipAddress, userAgent string) (*models.User, error) {
user, err := s.userRepo.FindByID(userID)
if err != nil {
return nil, err
}
// Update fields
if req.Name != "" {
user.Name = req.Name
}
if req.Phone != "" {
user.Phone = req.Phone
}
if req.NRP != "" {
// Check if NRP already exists for another user
existingNRP, _ := s.userRepo.FindByNRP(req.NRP)
if existingNRP != nil && existingNRP.ID != userID {
return nil, errors.New("NRP already used by another user")
}
user.NRP = req.NRP
}
if err := s.userRepo.Update(user); err != nil {
return nil, errors.New("failed to update profile")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityUser, &userID,
"Profile updated", ipAddress, userAgent)
return user, nil
}
// ChangePassword changes user password
func (s *UserService) ChangePassword(userID uint, req ChangePasswordRequest, ipAddress, userAgent string) error {
user, err := s.userRepo.FindByID(userID)
if err != nil {
return err
}
// Verify old password
if !utils.CheckPasswordHash(req.OldPassword, user.Password) {
return errors.New("invalid old password")
}
// Hash new password
hashedPassword, err := utils.HashPassword(req.NewPassword)
if err != nil {
return errors.New("failed to hash password")
}
user.Password = hashedPassword
if err := s.userRepo.Update(user); err != nil {
return errors.New("failed to change password")
}
// Log audit
s.auditLogRepo.Log(&userID, models.ActionUpdate, models.EntityUser, &userID,
"Password changed", ipAddress, userAgent)
return nil
}
// GetUserStats gets user statistics
func (s *UserService) GetUserStats(userID uint) (map[string]interface{}, error) {
return s.userRepo.GetUserStats(userID)
}
// GetAllUsers gets all users (admin only)
func (s *UserService) GetAllUsers(page, limit int) ([]models.User, int64, error) {
return s.userRepo.FindAll(page, limit)
}
// GetUserByID gets user by ID (admin only)
func (s *UserService) GetUserByID(id uint) (*models.User, error) {
return s.userRepo.FindByID(id)
}
// UpdateUserRole updates user role (admin only)
func (s *UserService) UpdateUserRole(adminID, userID, roleID uint, ipAddress, userAgent string) error {
// Verify role exists
role, err := s.roleRepo.FindByID(roleID)
if err != nil {
return errors.New("invalid role")
}
// Update role
if err := s.userRepo.UpdateRole(userID, roleID); err != nil {
return errors.New("failed to update user role")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionUpdate, models.EntityUser, &userID,
"Role updated to: "+role.Name, ipAddress, userAgent)
return nil
}
// BlockUser blocks a user (admin only)
func (s *UserService) BlockUser(adminID, userID uint, ipAddress, userAgent string) error {
// Cannot block self
if adminID == userID {
return errors.New("cannot block yourself")
}
if err := s.userRepo.BlockUser(userID); err != nil {
return errors.New("failed to block user")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionBlock, models.EntityUser, &userID,
"User blocked", ipAddress, userAgent)
return nil
}
// UnblockUser unblocks a user (admin only)
func (s *UserService) UnblockUser(adminID, userID uint, ipAddress, userAgent string) error {
if err := s.userRepo.UnblockUser(userID); err != nil {
return errors.New("failed to unblock user")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionUnblock, models.EntityUser, &userID,
"User unblocked", ipAddress, userAgent)
return nil
}
// DeleteUser deletes a user (admin only)
func (s *UserService) DeleteUser(adminID, userID uint, ipAddress, userAgent string) error {
// Cannot delete self
if adminID == userID {
return errors.New("cannot delete yourself")
}
if err := s.userRepo.Delete(userID); err != nil {
return errors.New("failed to delete user")
}
// Log audit
s.auditLogRepo.Log(&adminID, models.ActionDelete, models.EntityUser, &userID,
"User deleted", ipAddress, userAgent)
return nil
}
// internal/services/verification_service.go
package services
import (
"encoding/json"
"errors"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"lost-and-found/internal/utils"
"gorm.io/gorm"
)
type VerificationService struct {
verificationRepo *repositories.ClaimVerificationRepository
claimRepo *repositories.ClaimRepository
itemRepo *repositories.ItemRepository
}
func NewVerificationService(db *gorm.DB) *VerificationService {
return &VerificationService{
verificationRepo: repositories.NewClaimVerificationRepository(db),
claimRepo: repositories.NewClaimRepository(db),
itemRepo: repositories.NewItemRepository(db),
}
}
// VerificationResult represents the verification result
type VerificationResult struct {
SimilarityScore float64 `json:"similarity_score"`
MatchLevel string `json:"match_level"`
MatchedKeywords []string `json:"matched_keywords"`
Details map[string]string `json:"details"`
Recommendation string `json:"recommendation"`
}
// VerifyClaimDescription verifies claim description against item description
func (s *VerificationService) VerifyClaimDescription(claimID uint) (*VerificationResult, error) {
claim, err := s.claimRepo.FindByID(claimID)
if err != nil {
return nil, err
}
item, err := s.itemRepo.FindByID(claim.ItemID)
if err != nil {
return nil, err
}
// Calculate similarity between claim description and item description
similarity := utils.CalculateStringSimilarity(claim.Description, item.Description)
similarityPercent := similarity * 100
// Extract matched keywords
claimKeywords := utils.ExtractKeywords(claim.Description)
itemKeywords := utils.ExtractKeywords(item.Description)
matchedKeywords := utils.FindMatchedKeywords(claimKeywords, itemKeywords)
// Determine match level
matchLevel := "low"
recommendation := "REJECT - Deskripsi tidak cocok"
if similarityPercent >= 70.0 {
matchLevel = "high"
recommendation = "APPROVE - Deskripsi sangat cocok"
} else if similarityPercent >= 50.0 {
matchLevel = "medium"
recommendation = "REVIEW - Perlu verifikasi lebih lanjut"
}
// Create or update verification record
verification, _ := s.verificationRepo.FindByClaimID(claimID)
if verification == nil {
verification = &models.ClaimVerification{
ClaimID: claimID,
SimilarityScore: similarityPercent,
MatchedKeywords: stringSliceToJSON(matchedKeywords),
IsAutoMatched: false,
}
s.verificationRepo.Create(verification)
} else {
verification.SimilarityScore = similarityPercent
verification.MatchedKeywords = stringSliceToJSON(matchedKeywords)
s.verificationRepo.Update(verification)
}
return &VerificationResult{
SimilarityScore: similarityPercent,
MatchLevel: matchLevel,
MatchedKeywords: matchedKeywords,
Details: map[string]string{
"claim_description": claim.Description,
"item_description": item.Description,
"matched_count": string(len(matchedKeywords)),
},
Recommendation: recommendation,
}, nil
}
// GetVerificationByClaimID gets verification data for a claim
func (s *VerificationService) GetVerificationByClaimID(claimID uint) (*models.ClaimVerification, error) {
verification, err := s.verificationRepo.FindByClaimID(claimID)
if err != nil {
return nil, err
}
if verification == nil {
return nil, errors.New("verification not found")
}
return verification, nil
}
// GetHighMatchVerifications gets all high match verifications
func (s *VerificationService) GetHighMatchVerifications() ([]models.ClaimVerificationResponse, error) {
verifications, err := s.verificationRepo.FindHighMatches()
if err != nil {
return nil, err
}
var responses []models.ClaimVerificationResponse
for _, v := range verifications {
responses = append(responses, v.ToResponse())
}
return responses, nil
}
// CompareDescriptions provides detailed comparison between two descriptions
func (s *VerificationService) CompareDescriptions(desc1, desc2 string) map[string]interface{} {
similarity := utils.CalculateStringSimilarity(desc1, desc2)
keywords1 := utils.ExtractKeywords(desc1)
keywords2 := utils.ExtractKeywords(desc2)
matchedKeywords := utils.FindMatchedKeywords(keywords1, keywords2)
return map[string]interface{}{
"similarity_score": similarity * 100,
"description_1": desc1,
"description_2": desc2,
"keywords_1": keywords1,
"keywords_2": keywords2,
"matched_keywords": matchedKeywords,
"total_keywords_1": len(keywords1),
"total_keywords_2": len(keywords2),
"matched_count": len(matchedKeywords),
}
}
// Helper function to convert string slice to JSON
func stringSliceToJSON(slice []string) string {
if len(slice) == 0 {
return "[]"
}
data, _ := json.Marshal(slice)
return string(data)
}
// internal/utils/error.go
package utils
import "fmt"
// AppError represents a custom application error
type AppError struct {
Code string
Message string
Err error
}
func (e *AppError) Error() string {
if e.Err != nil {
return fmt.Sprintf("%s: %s (%v)", e.Code, e.Message, e.Err)
}
return fmt.Sprintf("%s: %s", e.Code, e.Message)
}
// NewAppError creates a new application error
func NewAppError(code, message string, err error) *AppError {
return &AppError{
Code: code,
Message: message,
Err: err,
}
}
// Common error codes
const (
ErrCodeValidation = "VALIDATION_ERROR"
ErrCodeNotFound = "NOT_FOUND"
ErrCodeUnauthorized = "UNAUTHORIZED"
ErrCodeForbidden = "FORBIDDEN"
ErrCodeInternal = "INTERNAL_ERROR"
ErrCodeDuplicate = "DUPLICATE_ERROR"
ErrCodeBadRequest = "BAD_REQUEST"
)
// Error constructors
func ValidationError(message string) *AppError {
return NewAppError(ErrCodeValidation, message, nil)
}
func NotFoundError(message string) *AppError {
return NewAppError(ErrCodeNotFound, message, nil)
}
func UnauthorizedError(message string) *AppError {
return NewAppError(ErrCodeUnauthorized, message, nil)
}
func ForbiddenError(message string) *AppError {
return NewAppError(ErrCodeForbidden, message, nil)
}
func InternalError(message string, err error) *AppError {
return NewAppError(ErrCodeInternal, message, err)
}
func DuplicateError(message string) *AppError {
return NewAppError(ErrCodeDuplicate, message, nil)
}
func BadRequestError(message string) *AppError {
return NewAppError(ErrCodeBadRequest, message, nil)
}
// internal/utils/excel_export.go
package utils
import (
"bytes"
"fmt"
"github.com/xuri/excelize/v2"
)
// ExcelExporter handles Excel file generation
type ExcelExporter struct {
file *excelize.File
sheetName string
rowIndex int
}
// NewExcelExporter creates a new Excel exporter
func NewExcelExporter() *ExcelExporter {
f := excelize.NewFile()
return &ExcelExporter{
file: f,
sheetName: "Sheet1",
rowIndex: 1,
}
}
// SetSheetName sets the active sheet name
func (e *ExcelExporter) SetSheetName(name string) {
e.file.SetSheetName("Sheet1", name)
e.sheetName = name
}
// AddRow adds a row of data
func (e *ExcelExporter) AddRow(data []string) error {
for colIndex, value := range data {
cell := fmt.Sprintf("%s%d", getColumnName(colIndex), e.rowIndex)
if err := e.file.SetCellValue(e.sheetName, cell, value); err != nil {
return err
}
}
e.rowIndex++
return nil
}
// AddHeader adds a header row with bold style
func (e *ExcelExporter) AddHeader(headers []string) error {
style, err := e.file.NewStyle(&excelize.Style{
Font: &excelize.Font{
Bold: true,
},
Fill: excelize.Fill{
Type: "pattern",
Color: []string{"#D3D3D3"},
Pattern: 1,
},
})
if err != nil {
return err
}
for colIndex, header := range headers {
cell := fmt.Sprintf("%s%d", getColumnName(colIndex), e.rowIndex)
if err := e.file.SetCellValue(e.sheetName, cell, header); err != nil {
return err
}
if err := e.file.SetCellStyle(e.sheetName, cell, cell, style); err != nil {
return err
}
}
e.rowIndex++
return nil
}
// AutoSizeColumns auto-sizes columns
func (e *ExcelExporter) AutoSizeColumns(columnCount int) {
for i := 0; i < columnCount; i++ {
col := getColumnName(i)
e.file.SetColWidth(e.sheetName, col, col, 15)
}
}
// Output returns the Excel file as bytes
func (e *ExcelExporter) Output() (*bytes.Buffer, error) {
buf := new(bytes.Buffer)
if err := e.file.Write(buf); err != nil {
return nil, err
}
return buf, nil
}
// getColumnName converts column index to Excel column name (A, B, C, ..., AA, AB, ...)
func getColumnName(index int) string {
name := ""
for index >= 0 {
name = string(rune('A'+(index%26))) + name
index = index/26 - 1
}
return name
}
// internal/utils/hash.go
package utils
import (
"golang.org/x/crypto/bcrypt"
)
// HashPassword hashes a password using bcrypt
func HashPassword(password string) (string, error) {
bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
return string(bytes), err
}
// CheckPasswordHash compares a password with a hash
func CheckPasswordHash(password, hash string) bool {
err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
return err == nil
}
// internal/utils/image_handler.go
package utils
import (
"errors"
"fmt"
"image"
"image/jpeg"
"image/png"
"io"
"mime/multipart"
"os"
"path/filepath"
"strings"
"time"
"github.com/nfnt/resize"
)
// ImageHandler handles image upload and processing
type ImageHandler struct {
uploadPath string
maxSize int64
allowedTypes []string
maxWidth uint
maxHeight uint
}
// NewImageHandler creates a new image handler
func NewImageHandler(uploadPath string) *ImageHandler {
return &ImageHandler{
uploadPath: uploadPath,
maxSize: 10 * 1024 * 1024, // 10MB
allowedTypes: []string{"image/jpeg", "image/jpg", "image/png"},
maxWidth: 1920,
maxHeight: 1080,
}
}
// UploadImage uploads and processes an image
func (h *ImageHandler) UploadImage(file *multipart.FileHeader, subfolder string) (string, error) {
// Check file size
if file.Size > h.maxSize {
return "", errors.New("file size exceeds maximum allowed size")
}
// Check file type
if !h.isAllowedType(file.Header.Get("Content-Type")) {
return "", errors.New("file type not allowed")
}
// Open uploaded file
src, err := file.Open()
if err != nil {
return "", err
}
defer src.Close()
// Generate unique filename
ext := filepath.Ext(file.Filename)
filename := fmt.Sprintf("%d_%s%s", time.Now().Unix(), generateRandomString(8), ext)
// Create upload directory if not exists
uploadDir := filepath.Join(h.uploadPath, subfolder)
if err := os.MkdirAll(uploadDir, os.ModePerm); err != nil {
return "", err
}
// Full file path
filePath := filepath.Join(uploadDir, filename)
// Decode image
img, format, err := image.Decode(src)
if err != nil {
return "", errors.New("invalid image file")
}
// Resize if necessary
if uint(img.Bounds().Dx()) > h.maxWidth || uint(img.Bounds().Dy()) > h.maxHeight {
img = resize.Thumbnail(h.maxWidth, h.maxHeight, img, resize.Lanczos3)
}
// Create destination file
dst, err := os.Create(filePath)
if err != nil {
return "", err
}
defer dst.Close()
// Encode and save image
switch format {
case "jpeg", "jpg":
if err := jpeg.Encode(dst, img, &jpeg.Options{Quality: 90}); err != nil {
return "", err
}
case "png":
if err := png.Encode(dst, img); err != nil {
return "", err
}
default:
return "", errors.New("unsupported image format")
}
// Return relative path
return filepath.Join(subfolder, filename), nil
}
// UploadImageSimple uploads image without processing
func (h *ImageHandler) UploadImageSimple(file *multipart.FileHeader, subfolder string) (string, error) {
// Check file size
if file.Size > h.maxSize {
return "", errors.New("file size exceeds maximum allowed size")
}
// Check file type
if !h.isAllowedType(file.Header.Get("Content-Type")) {
return "", errors.New("file type not allowed")
}
// Open uploaded file
src, err := file.Open()
if err != nil {
return "", err
}
defer src.Close()
// Generate unique filename
ext := filepath.Ext(file.Filename)
filename := fmt.Sprintf("%d_%s%s", time.Now().Unix(), generateRandomString(8), ext)
// Create upload directory if not exists
uploadDir := filepath.Join(h.uploadPath, subfolder)
if err := os.MkdirAll(uploadDir, os.ModePerm); err != nil {
return "", err
}
// Full file path
filePath := filepath.Join(uploadDir, filename)
// Create destination file
dst, err := os.Create(filePath)
if err != nil {
return "", err
}
defer dst.Close()
// Copy file
if _, err := io.Copy(dst, src); err != nil {
return "", err
}
// Return relative path
return filepath.Join(subfolder, filename), nil
}
// DeleteImage deletes an image file
func (h *ImageHandler) DeleteImage(relativePath string) error {
if relativePath == "" {
return nil
}
filePath := filepath.Join(h.uploadPath, relativePath)
if _, err := os.Stat(filePath); os.IsNotExist(err) {
return nil // File doesn't exist, no error
}
return os.Remove(filePath)
}
// isAllowedType checks if file type is allowed
func (h *ImageHandler) isAllowedType(contentType string) bool {
for _, allowed := range h.allowedTypes {
if strings.EqualFold(contentType, allowed) {
return true
}
}
return false
}
// generateRandomString generates a random string
func generateRandomString(length int) string {
const charset = "abcdefghijklmnopqrstuvwxyz0123456789"
b := make([]byte, length)
for i := range b {
b[i] = charset[time.Now().UnixNano()%int64(len(charset))]
}
return string(b)
}
// internal/utils/matching.go
package utils
import (
"strings"
)
// CalculateMatchScore calculates match score between two items
func CalculateMatchScore(item1, item2 map[string]interface{}) float64 {
totalScore := 0.0
maxScore := 0.0
// Name matching (30%)
maxScore += 30
if name1, ok1 := item1["name"].(string); ok1 {
if name2, ok2 := item2["name"].(string); ok2 {
similarity := CalculateStringSimilarity(name1, name2)
totalScore += similarity * 30
}
}
// Category matching (20%)
maxScore += 20
if cat1, ok1 := item1["category"].(string); ok1 {
if cat2, ok2 := item2["category"].(string); ok2 {
if strings.EqualFold(cat1, cat2) {
totalScore += 20
}
}
}
// Color matching (15%)
if color1, ok1 := item1["color"].(string); ok1 {
if color1 != "" {
maxScore += 15
if color2, ok2 := item2["color"].(string); ok2 {
if strings.Contains(strings.ToLower(color2), strings.ToLower(color1)) {
totalScore += 15
}
}
}
}
// Location matching (20%)
if loc1, ok1 := item1["location"].(string); ok1 {
if loc1 != "" {
maxScore += 20
if loc2, ok2 := item2["location"].(string); ok2 {
similarity := CalculateStringSimilarity(loc1, loc2)
totalScore += similarity * 20
}
}
}
// Description matching (15%)
maxScore += 15
if desc1, ok1 := item1["description"].(string); ok1 {
if desc2, ok2 := item2["description"].(string); ok2 {
similarity := CalculateStringSimilarity(desc1, desc2)
totalScore += similarity * 15
}
}
if maxScore == 0 {
return 0
}
return (totalScore / maxScore) * 100
}
// MatchItems matches items based on criteria
func MatchItems(lostItem, foundItems []map[string]interface{}, threshold float64) []map[string]interface{} {
var matches []map[string]interface{}
if len(lostItem) == 0 || len(foundItems) == 0 {
return matches
}
lost := lostItem[0]
for _, found := range foundItems {
score := CalculateMatchScore(lost, found)
if score >= threshold {
match := make(map[string]interface{})
match["item"] = found
match["score"] = score
match["level"] = getMatchLevel(score)
matches = append(matches, match)
}
}
return matches
}
// getMatchLevel returns match level based on score
func getMatchLevel(score float64) string {
if score >= 70 {
return "high"
} else if score >= 50 {
return "medium"
}
return "low"
}
// internal/utils/pdf_export.go
package utils
import (
"bytes"
"fmt"
"github.com/jung-kurt/gofpdf"
)
// PDFExporter handles PDF generation
type PDFExporter struct {
pdf *gofpdf.Fpdf
}
// NewPDFExporter creates a new PDF exporter
func NewPDFExporter() *PDFExporter {
pdf := gofpdf.New("P", "mm", "A4", "")
pdf.AddPage()
pdf.SetFont("Arial", "", 12)
return &PDFExporter{
pdf: pdf,
}
}
// AddTitle adds a title to the PDF
func (e *PDFExporter) AddTitle(title string) {
e.pdf.SetFont("Arial", "B", 16)
e.pdf.Cell(0, 10, title)
e.pdf.Ln(12)
e.pdf.SetFont("Arial", "", 12)
}
// AddSubtitle adds a subtitle to the PDF
func (e *PDFExporter) AddSubtitle(subtitle string) {
e.pdf.SetFont("Arial", "I", 11)
e.pdf.Cell(0, 8, subtitle)
e.pdf.Ln(10)
e.pdf.SetFont("Arial", "", 12)
}
// AddText adds regular text
func (e *PDFExporter) AddText(text string) {
e.pdf.SetFont("Arial", "", 10)
e.pdf.MultiCell(0, 6, text, "", "", false)
e.pdf.Ln(4)
}
// AddNewLine adds a new line
func (e *PDFExporter) AddNewLine() {
e.pdf.Ln(6)
}
// AddTable adds a table to the PDF
func (e *PDFExporter) AddTable(headers []string, data [][]string) {
// Calculate column widths
pageWidth, _ := e.pdf.GetPageSize()
margins := 20.0 // Left + Right margins
tableWidth := pageWidth - margins
colWidth := tableWidth / float64(len(headers))
// Add headers
e.pdf.SetFont("Arial", "B", 10)
e.pdf.SetFillColor(200, 200, 200)
for _, header := range headers {
e.pdf.CellFormat(colWidth, 8, header, "1", 0, "C", true, 0, "")
}
e.pdf.Ln(-1)
// Add data rows
e.pdf.SetFont("Arial", "", 9)
e.pdf.SetFillColor(255, 255, 255)
fill := false
for _, row := range data {
for _, cell := range row {
if fill {
e.pdf.SetFillColor(245, 245, 245)
} else {
e.pdf.SetFillColor(255, 255, 255)
}
e.pdf.CellFormat(colWidth, 7, cell, "1", 0, "L", true, 0, "")
}
e.pdf.Ln(-1)
fill = !fill
}
}
// AddPageNumber adds page numbers
func (e *PDFExporter) AddPageNumber() {
e.pdf.AliasNbPages("")
e.pdf.SetY(-15)
e.pdf.SetFont("Arial", "I", 8)
e.pdf.CellFormat(0, 10, fmt.Sprintf("Halaman %d/{nb}", e.pdf.PageNo()), "", 0, "C", false, 0, "")
}
// Output returns the PDF as bytes
func (e *PDFExporter) Output() *bytes.Buffer {
var buf bytes.Buffer
err := e.pdf.Output(&buf)
if err != nil {
return nil
}
return &buf
}
// internal/utils/response.go
package utils
import (
"github.com/gin-gonic/gin"
)
// Response represents a standard API response
type Response struct {
Success bool `json:"success"`
Message string `json:"message"`
Data interface{} `json:"data,omitempty"`
Error string `json:"error,omitempty"`
}
// PaginatedResponse represents a paginated API response
type PaginatedResponse struct {
Success bool `json:"success"`
Message string `json:"message"`
Data interface{} `json:"data"`
Pagination Pagination `json:"pagination"`
}
// Pagination represents pagination metadata
type Pagination struct {
CurrentPage int `json:"current_page"`
PerPage int `json:"per_page"`
TotalPages int `json:"total_pages"`
TotalRecords int64 `json:"total_records"`
}
// SuccessResponse sends a success response
func SuccessResponse(ctx *gin.Context, statusCode int, message string, data interface{}) {
ctx.JSON(statusCode, Response{
Success: true,
Message: message,
Data: data,
})
}
// ErrorResponse sends an error response
func ErrorResponse(ctx *gin.Context, statusCode int, message string, error string) {
ctx.JSON(statusCode, Response{
Success: false,
Message: message,
Error: error,
})
}
// SendPaginatedResponse sends a paginated response (nama fungsi diubah untuk menghindari konflik)
func SendPaginatedResponse(ctx *gin.Context, statusCode int, message string, data interface{}, total int64, page, limit int) {
totalPages := int(total) / limit
if int(total)%limit != 0 {
totalPages++
}
ctx.JSON(statusCode, PaginatedResponse{
Success: true,
Message: message,
Data: data,
Pagination: Pagination{
CurrentPage: page,
PerPage: limit,
TotalPages: totalPages,
TotalRecords: total,
},
})
}
// internal/utils/similarity.go
package utils
import (
"math"
"strings"
"unicode"
)
// CalculateStringSimilarity calculates similarity between two strings using Levenshtein distance
func CalculateStringSimilarity(s1, s2 string) float64 {
// Normalize strings
s1 = normalizeString(s1)
s2 = normalizeString(s2)
if s1 == s2 {
return 1.0
}
if len(s1) == 0 || len(s2) == 0 {
return 0.0
}
// Calculate Levenshtein distance
distance := levenshteinDistance(s1, s2)
maxLen := math.Max(float64(len(s1)), float64(len(s2)))
similarity := 1.0 - (float64(distance) / maxLen)
return math.Max(0, similarity)
}
// levenshteinDistance calculates the Levenshtein distance between two strings
func levenshteinDistance(s1, s2 string) int {
len1 := len(s1)
len2 := len(s2)
// Create a 2D slice for dynamic programming
dp := make([][]int, len1+1)
for i := range dp {
dp[i] = make([]int, len2+1)
}
// Initialize first row and column
for i := 0; i <= len1; i++ {
dp[i][0] = i
}
for j := 0; j <= len2; j++ {
dp[0][j] = j
}
// Fill the dp table
for i := 1; i <= len1; i++ {
for j := 1; j <= len2; j++ {
cost := 0
if s1[i-1] != s2[j-1] {
cost = 1
}
dp[i][j] = min3(
dp[i-1][j]+1, // deletion
dp[i][j-1]+1, // insertion
dp[i-1][j-1]+cost, // substitution
)
}
}
return dp[len1][len2]
}
// ExtractKeywords extracts keywords from a string
func ExtractKeywords(text string) []string {
// Normalize and split text
text = normalizeString(text)
words := strings.Fields(text)
// Filter stopwords and short words
var keywords []string
stopwords := getStopwords()
for _, word := range words {
if len(word) > 2 && !contains(stopwords, word) {
keywords = append(keywords, word)
}
}
return keywords
}
// FindMatchedKeywords finds common keywords between two lists
func FindMatchedKeywords(keywords1, keywords2 []string) []string {
var matched []string
for _, k1 := range keywords1 {
for _, k2 := range keywords2 {
if strings.EqualFold(k1, k2) || CalculateStringSimilarity(k1, k2) > 0.8 {
if !contains(matched, k1) {
matched = append(matched, k1)
}
break
}
}
}
return matched
}
// normalizeString normalizes a string (lowercase, remove extra spaces)
func normalizeString(s string) string {
// Convert to lowercase
s = strings.ToLower(s)
// Remove punctuation and extra spaces
var result strings.Builder
for _, r := range s {
if unicode.IsLetter(r) || unicode.IsDigit(r) || unicode.IsSpace(r) {
result.WriteRune(r)
} else {
result.WriteRune(' ')
}
}
// Remove multiple spaces
s = strings.Join(strings.Fields(result.String()), " ")
return strings.TrimSpace(s)
}
// getStopwords returns common Indonesian stopwords
func getStopwords() []string {
return []string{
"dan", "atau", "dengan", "untuk", "dari", "ke", "di", "yang", "ini", "itu",
"ada", "adalah", "akan", "telah", "sudah", "pada", "oleh", "sebagai", "dalam",
"juga", "saya", "kamu", "dia", "kita", "mereka", "kami", "the", "a", "an",
"of", "to", "in", "for", "on", "at", "by", "with", "from",
}
}
// contains checks if a slice contains a string
func contains(slice []string, str string) bool {
for _, s := range slice {
if strings.EqualFold(s, str) {
return true
}
}
return false
}
// min3 returns the minimum of three integers
func min3(a, b, c int) int {
if a < b {
if a < c {
return a
}
return c
}
if b < c {
return b
}
return c
}
// internal/utils/validator.go
package utils
import (
"regexp"
"strings"
"github.com/go-playground/validator/v10"
)
var validate *validator.Validate
// InitValidator initializes the validator
func InitValidator() {
validate = validator.New()
// Register custom validators
validate.RegisterValidation("phone", validatePhone)
validate.RegisterValidation("nrp", validateNRP)
}
// ValidateStruct validates a struct
func ValidateStruct(s interface{}) error {
if validate == nil {
InitValidator()
}
return validate.Struct(s)
}
// validatePhone validates Indonesian phone numbers
func validatePhone(fl validator.FieldLevel) bool {
phone := fl.Field().String()
if phone == "" {
return true // Allow empty (use required tag separately)
}
// Remove spaces and dashes
phone = strings.ReplaceAll(phone, " ", "")
phone = strings.ReplaceAll(phone, "-", "")
// Check if starts with 0 or +62 or 62
pattern := `^(0|\+?62)[0-9]{8,12}$`
matched, _ := regexp.MatchString(pattern, phone)
return matched
}
// validateNRP validates NRP (Nomor Registrasi Pokok)
func validateNRP(fl validator.FieldLevel) bool {
nrp := fl.Field().String()
if nrp == "" {
return true // Allow empty (use required tag separately)
}
// NRP format: 10 digits
pattern := `^[0-9]{10}$`
matched, _ := regexp.MatchString(pattern, nrp)
return matched
}
// IsValidEmail checks if email is valid
func IsValidEmail(email string) bool {
pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
matched, _ := regexp.MatchString(pattern, email)
return matched
}
// IsValidURL checks if URL is valid
func IsValidURL(url string) bool {
pattern := `^https?://[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}(/.*)?$`
matched, _ := regexp.MatchString(pattern, url)
return matched
}
// SanitizeString removes potentially dangerous characters
func SanitizeString(s string) string {
// Remove control characters
s = strings.Map(func(r rune) rune {
if r < 32 && r != '\n' && r != '\r' && r != '\t' {
return -1
}
return r
}, s)
return strings.TrimSpace(s)
}
// internal/workers/audit_worker.go
package workers
import (
"log"
"lost-and-found/internal/repositories"
"time"
"gorm.io/gorm"
)
// AuditWorker handles audit log background tasks
type AuditWorker struct {
db *gorm.DB
auditLogRepo *repositories.AuditLogRepository
stopChan chan bool
}
// NewAuditWorker creates a new audit worker
func NewAuditWorker(db *gorm.DB) *AuditWorker {
return &AuditWorker{
db: db,
auditLogRepo: repositories.NewAuditLogRepository(db),
stopChan: make(chan bool),
}
}
// Start starts the audit worker
func (w *AuditWorker) Start() {
log.Println("🔍 Audit Worker started")
ticker := time.NewTicker(24 * time.Hour) // Run daily
defer ticker.Stop()
for {
select {
case <-ticker.C:
w.cleanupOldLogs()
case <-w.stopChan:
log.Println("🔍 Audit Worker stopped")
return
}
}
}
// Stop stops the audit worker
func (w *AuditWorker) Stop() {
w.stopChan <- true
}
// cleanupOldLogs removes audit logs older than 1 year
func (w *AuditWorker) cleanupOldLogs() {
log.Println("🧹 Cleaning up old audit logs...")
cutoffDate := time.Now().AddDate(-1, 0, 0) // 1 year ago
result := w.db.Unscoped().Where("created_at < ?", cutoffDate).Delete(&struct {
tableName struct{} `gorm:"audit_logs"`
}{})
if result.Error != nil {
log.Printf("❌ Failed to cleanup audit logs: %v", result.Error)
return
}
log.Printf("✅ Cleaned up %d old audit log entries", result.RowsAffected)
}
// RunNow runs cleanup immediately (for testing)
func (w *AuditWorker) RunNow() {
log.Println("▶️ Running audit cleanup manually...")
w.cleanupOldLogs()
}
// internal/workers/expire_worker.go
package workers
import (
"log"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"time"
"gorm.io/gorm"
)
// ExpireWorker handles item expiration background tasks
type ExpireWorker struct {
db *gorm.DB
itemRepo *repositories.ItemRepository
archiveRepo *repositories.ArchiveRepository
stopChan chan bool
}
// NewExpireWorker creates a new expire worker
func NewExpireWorker(db *gorm.DB) *ExpireWorker {
return &ExpireWorker{
db: db,
itemRepo: repositories.NewItemRepository(db),
archiveRepo: repositories.NewArchiveRepository(db),
stopChan: make(chan bool),
}
}
// Start starts the expire worker
func (w *ExpireWorker) Start() {
log.Println("⏰ Expire Worker started")
// Run immediately on start
w.expireItems()
// Then run every hour
ticker := time.NewTicker(1 * time.Hour)
defer ticker.Stop()
for {
select {
case <-ticker.C:
w.expireItems()
case <-w.stopChan:
log.Println("⏰ Expire Worker stopped")
return
}
}
}
// Stop stops the expire worker
func (w *ExpireWorker) Stop() {
w.stopChan <- true
}
// expireItems finds and expires items that have passed their expiration date
func (w *ExpireWorker) expireItems() {
log.Println("🔍 Checking for expired items...")
// Find expired items
expiredItems, err := w.itemRepo.FindExpired()
if err != nil {
log.Printf("❌ Error finding expired items: %v", err)
return
}
if len(expiredItems) == 0 {
log.Println("✅ No expired items found")
return
}
log.Printf("📦 Found %d expired items", len(expiredItems))
// Process each expired item
expiredCount := 0
for _, item := range expiredItems {
if err := w.archiveExpiredItem(&item); err != nil {
log.Printf("❌ Failed to archive item ID %d: %v", item.ID, err)
continue
}
expiredCount++
}
log.Printf("✅ Successfully archived %d expired items", expiredCount)
}
// archiveExpiredItem archives an expired item
func (w *ExpireWorker) archiveExpiredItem(item *models.Item) error {
// Archive the item
if err := w.itemRepo.ArchiveItem(item, models.ArchiveReasonExpired, nil); err != nil {
return err
}
log.Printf("📦 Archived expired item: %s (ID: %d)", item.Name, item.ID)
return nil
}
// RunNow runs expiration check immediately (for testing)
func (w *ExpireWorker) RunNow() {
log.Println("▶️ Running expiration check manually...")
w.expireItems()
}
// internal/workers/matching_worker.go
package workers
import (
"log"
"lost-and-found/internal/repositories"
"lost-and-found/internal/services"
"time"
"gorm.io/gorm"
)
// MatchingWorker handles automatic matching of lost and found items
type MatchingWorker struct {
db *gorm.DB
matchService *services.MatchService
itemRepo *repositories.ItemRepository
lostItemRepo *repositories.LostItemRepository
stopChan chan bool
}
// NewMatchingWorker creates a new matching worker
func NewMatchingWorker(db *gorm.DB) *MatchingWorker {
return &MatchingWorker{
db: db,
matchService: services.NewMatchService(db),
itemRepo: repositories.NewItemRepository(db),
lostItemRepo: repositories.NewLostItemRepository(db),
stopChan: make(chan bool),
}
}
// Start starts the matching worker
func (w *MatchingWorker) Start() {
log.Println("🔗 Matching Worker started")
// Run every 30 minutes
ticker := time.NewTicker(30 * time.Minute)
defer ticker.Stop()
for {
select {
case <-ticker.C:
w.performMatching()
case <-w.stopChan:
log.Println("🔗 Matching Worker stopped")
return
}
}
}
// Stop stops the matching worker
func (w *MatchingWorker) Stop() {
w.stopChan <- true
}
// performMatching performs automatic matching between lost and found items
func (w *MatchingWorker) performMatching() {
log.Println("🔍 Performing automatic matching...")
// Get all unclaimed items
items, _, err := w.itemRepo.FindAll(1, 1000, "unclaimed", "", "")
if err != nil {
log.Printf("❌ Error fetching items: %v", err)
return
}
if len(items) == 0 {
log.Println("✅ No unclaimed items to match")
return
}
matchCount := 0
for _, item := range items {
// Auto-match with lost items
if err := w.matchService.AutoMatchNewItem(item.ID); err != nil {
log.Printf("❌ Failed to match item ID %d: %v", item.ID, err)
continue
}
matchCount++
}
log.Printf("✅ Completed matching for %d items", matchCount)
}
// RunNow runs matching immediately (for testing)
func (w *MatchingWorker) RunNow() {
log.Println("▶️ Running matching manually...")
w.performMatching()
}
// internal/workers/notification_worker.go
package workers
import (
"log"
"lost-and-found/internal/models"
"lost-and-found/internal/repositories"
"time"
"gorm.io/gorm"
)
// NotificationWorker handles sending notifications asynchronously
type NotificationWorker struct {
db *gorm.DB
notificationRepo *repositories.NotificationRepository
matchRepo *repositories.MatchResultRepository
stopChan chan bool
}
// NewNotificationWorker creates a new notification worker
func NewNotificationWorker(db *gorm.DB) *NotificationWorker {
return &NotificationWorker{
db: db,
notificationRepo: repositories.NewNotificationRepository(db),
matchRepo: repositories.NewMatchResultRepository(db),
stopChan: make(chan bool),
}
}
// Start starts the notification worker
func (w *NotificationWorker) Start() {
log.Println("📬 Notification Worker started")
// Run every 5 minutes
ticker := time.NewTicker(5 * time.Minute)
defer ticker.Stop()
for {
select {
case <-ticker.C:
w.sendPendingNotifications()
case <-w.stopChan:
log.Println("📬 Notification Worker stopped")
return
}
}
}
// Stop stops the notification worker
func (w *NotificationWorker) Stop() {
w.stopChan <- true
}
// sendPendingNotifications sends notifications for unnotified matches
func (w *NotificationWorker) sendPendingNotifications() {
log.Println("🔍 Checking for pending notifications...")
// Get unnotified matches
matches, err := w.matchRepo.FindUnnotifiedMatches()
if err != nil {
log.Printf("❌ Error fetching unnotified matches: %v", err)
return
}
if len(matches) == 0 {
log.Println("✅ No pending notifications")
return
}
log.Printf("📧 Found %d pending notifications", len(matches))
sentCount := 0
for _, match := range matches {
// Send notification to lost item owner
if err := w.sendMatchNotification(&match); err != nil {
log.Printf("❌ Failed to send notification for match ID %d: %v", match.ID, err)
continue
}
// Mark as notified
if err := w.matchRepo.MarkAsNotified(match.ID); err != nil {
log.Printf("❌ Failed to mark match ID %d as notified: %v", match.ID, err)
continue
}
sentCount++
}
log.Printf("✅ Sent %d notifications", sentCount)
}
// sendMatchNotification sends a match notification
func (w *NotificationWorker) sendMatchNotification(match *models.MatchResult) error {
// Create notification
err := models.CreateMatchNotification(
w.db,
match.LostItem.UserID,
match.Item.Name,
match.ID,
)
if err != nil {
return err
}
log.Printf("📧 Sent match notification to user ID %d for item: %s",
match.LostItem.UserID, match.Item.Name)
return nil
}
// RunNow runs notification sending immediately (for testing)
func (w *NotificationWorker) RunNow() {
log.Println("▶️ Running notification sending manually...")
w.sendPendingNotifications()
}
/* web/css/style.css */
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary: #2563eb;
--primary-dark: #1e40af;
--danger: #ef4444;
--success: #10b981;
--warning: #f59e0b;
--light: #f8fafc;
--dark: #1e293b;
--secondary: #64748b;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: #f1f5f9;
}
/* Navbar */
.navbar {
background: white;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
padding: 15px 30px;
display: flex;
justify-content: space-between;
align-items: center;
position: sticky;
top: 0;
z-index: 100;
}
.navbar-brand {
font-size: 1.5rem;
font-weight: 700;
color: var(--primary);
}
.navbar-menu {
display: flex;
gap: 20px;
align-items: center;
}
.nav-link {
text-decoration: none;
color: var(--dark);
font-weight: 500;
padding: 8px 15px;
border-radius: 8px;
transition: all 0.3s;
}
.nav-link:hover {
background: var(--light);
color: var(--primary);
}
.user-info {
display: flex;
align-items: center;
gap: 10px;
}
.user-avatar {
width: 40px;
height: 40px;
border-radius: 50%;
background: var(--primary);
color: white;
display: flex;
align-items: center;
justify-content: center;
font-weight: 600;
}
.user-role {
padding: 4px 10px;
border-radius: 12px;
font-size: 0.8rem;
font-weight: 600;
}
.btn-logout {
background: var(--danger);
color: white;
border: none;
padding: 8px 20px;
border-radius: 8px;
cursor: pointer;
font-weight: 600;
transition: all 0.3s;
}
.btn-logout:hover {
background: #dc2626;
}
/* Container */
.container {
max-width: 1400px;
margin: 30px auto;
padding: 0 20px;
}
.page-header {
margin-bottom: 30px;
}
.page-header h1 {
color: var(--dark);
font-size: 2rem;
margin-bottom: 10px;
}
/* Stats Grid */
.stats-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 20px;
margin-bottom: 30px;
}
.stats-grid-4 {
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
}
.stat-card {
background: white;
padding: 25px;
border-radius: 15px;
box-shadow: 0 2px 10px rgba(0,0,0,0.05);
}
.stat-card h3 {
color: var(--secondary);
font-size: 0.9rem;
margin-bottom: 10px;
}
.stat-number {
font-size: 2.5rem;
font-weight: 700;
color: var(--primary);
}
.stat-success {
color: var(--success);
}
.stat-warning {
color: var(--warning);
}
.stat-danger {
color: var(--danger);
}
/* Tabs */
.tabs {
display: flex;
gap: 10px;
margin-bottom: 30px;
flex-wrap: wrap;
}
.tab-btn {
padding: 12px 25px;
background: white;
border: 2px solid #e2e8f0;
border-radius: 10px;
cursor: pointer;
font-weight: 600;
color: var(--secondary);
transition: all 0.3s;
}
.tab-btn.active {
background: var(--primary);
color: white;
border-color: var(--primary);
}
.tab-content {
display: none;
}
.tab-content.active {
display: block;
}
/* Card */
.card {
background: white;
border-radius: 15px;
padding: 25px;
box-shadow: 0 2px 10px rgba(0,0,0,0.05);
margin-bottom: 20px;
}
.card-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 20px;
}
.card-title {
font-size: 1.3rem;
color: var(--dark);
font-weight: 600;
}
/* Buttons */
.btn {
padding: 10px 20px;
border: none;
border-radius: 8px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s;
}
.btn-primary {
background: var(--primary);
color: white;
}
.btn-primary:hover {
background: var(--primary-dark);
}
.btn-success {
background: var(--success);
color: white;
}
.btn-success:hover {
background: #059669;
}
.btn-danger {
background: var(--danger);
color: white;
}
.btn-danger:hover {
background: #dc2626;
}
.btn-warning {
background: var(--warning);
color: white;
}
.btn-warning:hover {
background: #d97706;
}
.btn-sm {
padding: 6px 12px;
font-size: 0.85rem;
}
/* Search Box */
.search-box {
display: flex;
gap: 10px;
margin-bottom: 20px;
flex-wrap: wrap;
}
.search-input {
flex: 1;
min-width: 200px;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
.search-input:focus {
outline: none;
border-color: var(--primary);
}
.filter-select {
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
/* Items Grid */
.items-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
gap: 20px;
}
.item-card {
background: white;
border: 2px solid #e2e8f0;
border-radius: 15px;
overflow: hidden;
transition: all 0.3s;
cursor: pointer;
}
.item-card:hover {
transform: translateY(-5px);
box-shadow: 0 10px 25px rgba(0,0,0,0.1);
}
.item-image {
width: 100%;
height: 200px;
object-fit: cover;
background: var(--light);
}
.item-body {
padding: 15px;
}
.item-title {
font-size: 1.1rem;
font-weight: 600;
color: var(--dark);
margin-bottom: 8px;
}
.item-meta {
display: flex;
flex-direction: column;
gap: 5px;
color: var(--secondary);
font-size: 0.9rem;
margin-bottom: 10px;
}
.item-actions {
display: flex;
gap: 8px;
margin-top: 10px;
}
/* Badge */
.badge {
display: inline-block;
padding: 5px 12px;
border-radius: 20px;
font-size: 0.85rem;
font-weight: 600;
}
.badge-success {
background: #d1fae5;
color: var(--success);
}
.badge-warning {
background: #fef3c7;
color: var(--warning);
}
.badge-danger {
background: #fee2e2;
color: var(--danger);
}
.badge-primary {
background: #dbeafe;
color: var(--primary);
}
/* Modal */
.modal {
display: none;
position: fixed;
z-index: 1000;
left: 0;
top: 0;
width: 100%;
height: 100%;
background: rgba(0,0,0,0.5);
animation: fadeIn 0.3s;
}
.modal.active {
display: flex;
align-items: center;
justify-content: center;
}
.modal-content {
background: white;
border-radius: 20px;
max-width: 600px;
width: 90%;
max-height: 90vh;
overflow-y: auto;
animation: slideUp 0.3s;
}
.modal-large {
max-width: 900px;
}
.modal-header {
padding: 25px;
border-bottom: 1px solid #e2e8f0;
display: flex;
justify-content: space-between;
align-items: center;
}
.modal-title {
font-size: 1.5rem;
font-weight: 600;
}
.close-btn {
background: none;
border: none;
font-size: 1.5rem;
cursor: pointer;
color: var(--secondary);
}
.modal-body {
padding: 25px;
}
/* Form */
.form-group {
margin-bottom: 20px;
}
.form-group label {
display: block;
margin-bottom: 8px;
font-weight: 600;
color: var(--dark);
}
.form-group input,
.form-group textarea,
.form-group select {
width: 100%;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
.form-group textarea {
resize: vertical;
min-height: 100px;
}
/* Table */
.table-container {
overflow-x: auto;
}
.data-table {
width: 100%;
border-collapse: collapse;
margin-top: 20px;
}
.data-table thead {
background: var(--light);
}
.data-table th,
.data-table td {
padding: 15px;
text-align: left;
border-bottom: 1px solid #e2e8f0;
}
.data-table th {
font-weight: 600;
color: var(--dark);
}
.data-table tr:hover {
background: var(--light);
}
/* Claims List */
.claims-list {
display: flex;
flex-direction: column;
gap: 15px;
}
.claim-card {
background: white;
border: 2px solid #e2e8f0;
border-radius: 15px;
padding: 20px;
transition: all 0.3s;
}
.claim-card:hover {
box-shadow: 0 5px 15px rgba(0,0,0,0.1);
}
.claim-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 15px;
}
.claim-info {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 10px;
margin-bottom: 15px;
}
.claim-actions {
display: flex;
gap: 10px;
}
/* Categories Grid */
.categories-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
gap: 20px;
}
.category-card {
background: white;
border: 2px solid #e2e8f0;
border-radius: 15px;
padding: 20px;
text-align: center;
transition: all 0.3s;
}
.category-card:hover {
transform: translateY(-5px);
box-shadow: 0 5px 15px rgba(0,0,0,0.1);
}
.category-icon {
font-size: 3rem;
margin-bottom: 10px;
}
/* Report Section */
.report-section {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 30px;
}
.report-filters,
.report-preview {
background: var(--light);
padding: 20px;
border-radius: 15px;
}
.report-actions {
display: flex;
gap: 10px;
margin-top: 20px;
}
.report-stats {
display: flex;
flex-direction: column;
gap: 10px;
margin-top: 15px;
}
.report-stat-item {
display: flex;
justify-content: space-between;
padding: 10px;
background: white;
border-radius: 8px;
}
/* Empty State */
.empty-state {
text-align: center;
padding: 60px 20px;
color: var(--secondary);
}
.empty-state-icon {
font-size: 4rem;
margin-bottom: 20px;
}
/* Loading */
.loading {
display: inline-block;
width: 20px;
height: 20px;
border: 3px solid rgba(255,255,255,.3);
border-radius: 50%;
border-top-color: white;
animation: spin 1s ease-in-out infinite;
}
/* Animations */
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
@keyframes slideUp {
from {
transform: translateY(50px);
opacity: 0;
}
to {
transform: translateY(0);
opacity: 1;
}
}
@keyframes spin {
to { transform: rotate(360deg); }
}
/* Responsive */
@media (max-width: 768px) {
.navbar {
flex-direction: column;
gap: 15px;
}
.navbar-menu {
flex-direction: column;
width: 100%;
}
.items-grid {
grid-template-columns: 1fr;
}
.search-box {
flex-direction: column;
}
.search-input {
width: 100%;
}
.report-section {
grid-template-columns: 1fr;
}
.data-table {
font-size: 0.9rem;
}
.data-table th,
.data-table td {
padding: 10px;
}
}
// web/js/admin.js
// Dashboard Admin JavaScript - FIXED ENDPOINTS
let allUsers = [];
let allCategories = [];
let allAuditLogs = [];
// Initialize dashboard
window.addEventListener("DOMContentLoaded", async () => {
const user = checkAuth();
if (!user || user.role !== "admin") {
window.location.href = "/login";
return;
}
await loadStats();
await loadUsers();
setupSearchAndFilters();
setupReportFilters();
});
// Load statistics - FIXED
async function loadStats() {
try {
const stats = await apiCall("/api/admin/dashboard");
document.getElementById("statTotalUsers").textContent =
stats.total_users || 0;
document.getElementById("statTotalItems").textContent =
stats.total_items || 0;
document.getElementById("statTotalClaims").textContent =
stats.total_claims || 0;
document.getElementById("statTotalArchive").textContent =
stats.total_archive || 0;
} catch (error) {
console.error("Error loading stats:", error);
}
}
// Load users - CORRECT (sudah sesuai)
async function loadUsers() {
try {
const response = await apiCall("/api/admin/users");
allUsers = response.data || [];
renderUsers(allUsers);
} catch (error) {
console.error("Error loading users:", error);
showAlert("Gagal memuat data user", "danger");
}
}
// Render users
function renderUsers(users) {
const tbody = document.getElementById("usersTableBody");
if (!users || users.length === 0) {
tbody.innerHTML = `
<tr>
<td colspan="6" style="text-align: center; padding: 40px; color: #64748b;">
Belum ada data user
</td>
</tr>
`;
return;
}
tbody.innerHTML = users
.map(
(user) => `
<tr>
<td>${user.name}</td>
<td>${user.email}</td>
<td>${user.nrp}</td>
<td>${getRoleBadge(user.role)}</td>
<td>${getStatusBadge(user.status || "active")}</td>
<td>
<button class="btn btn-warning btn-sm" onclick="editUser(${
user.id
})">Edit</button>
${
user.status === "active"
? `<button class="btn btn-danger btn-sm" onclick="blockUser(${user.id})">Block</button>`
: `<button class="btn btn-success btn-sm" onclick="unblockUser(${user.id})">Unblock</button>`
}
</td>
</tr>
`
)
.join("");
}
// Edit user
async function editUser(userId) {
try {
const user = await apiCall(`/api/admin/users/${userId}`);
const form = document.getElementById("editUserForm");
form.elements.user_id.value = user.id;
form.elements.name.value = user.name;
form.elements.email.value = user.email;
form.elements.nrp.value = user.nrp;
form.elements.phone.value = user.phone || "";
form.elements.role.value = user.role;
openModal("editUserModal");
} catch (error) {
console.error("Error loading user:", error);
showAlert("Gagal memuat data user", "danger");
}
}
// Submit edit user
document
.getElementById("editUserForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
const userId = formData.get("user_id");
const role = formData.get("role");
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Menyimpan...';
// Update role
await apiCall(`/api/admin/users/${userId}/role`, {
method: "PATCH",
body: JSON.stringify({ role }),
});
showAlert("User berhasil diupdate!", "success");
closeModal("editUserModal");
await loadUsers();
} catch (error) {
console.error("Error updating user:", error);
showAlert(error.message || "Gagal update user", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Update User";
}
}
});
// Block user
async function blockUser(userId) {
if (!confirmAction("Block user ini?")) return;
try {
await apiCall(`/api/admin/users/${userId}/block`, {
method: "POST",
});
showAlert("User berhasil diblock!", "success");
await loadUsers();
} catch (error) {
console.error("Error blocking user:", error);
showAlert(error.message || "Gagal block user", "danger");
}
}
// Unblock user
async function unblockUser(userId) {
if (!confirmAction("Unblock user ini?")) return;
try {
await apiCall(`/api/admin/users/${userId}/unblock`, {
method: "POST",
});
showAlert("User berhasil di-unblock!", "success");
await loadUsers();
} catch (error) {
console.error("Error unblocking user:", error);
showAlert(error.message || "Gagal unblock user", "danger");
}
}
// Load categories
async function loadCategories() {
try {
const response = await apiCall("/api/categories");
allCategories = response.data || [];
renderCategories(allCategories);
} catch (error) {
console.error("Error loading categories:", error);
showAlert("Gagal memuat data kategori", "danger");
}
}
// Render categories
function renderCategories(categories) {
const grid = document.getElementById("categoriesGrid");
if (!categories || categories.length === 0) {
grid.innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">🏷️</div>
<p>Belum ada kategori</p>
</div>
`;
return;
}
const icons = {
pakaian: "👕",
alat_makan: "🍽️",
aksesoris: "👓",
elektronik: "💻",
alat_tulis: "✏️",
lainnya: "📦",
};
grid.innerHTML = categories
.map(
(cat) => `
<div class="category-card">
<div class="category-icon">${icons[cat.slug] || "📦"}</div>
<h3>${cat.name}</h3>
${
cat.description
? `<p style="color: #64748b; font-size: 0.9rem; margin-top: 8px;">${cat.description}</p>`
: ""
}
<div style="display: flex; gap: 8px; margin-top: 15px; justify-content: center;">
<button class="btn btn-warning btn-sm" onclick="editCategory(${
cat.id
})">Edit</button>
<button class="btn btn-danger btn-sm" onclick="deleteCategory(${
cat.id
})">Hapus</button>
</div>
</div>
`
)
.join("");
}
// Submit add category
document
.getElementById("addCategoryForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
const data = Object.fromEntries(formData);
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Menyimpan...';
await apiCall("/api/admin/categories", {
method: "POST",
body: JSON.stringify(data),
});
showAlert("Kategori berhasil ditambahkan!", "success");
closeModal("addCategoryModal");
e.target.reset();
await loadCategories();
} catch (error) {
console.error("Error adding category:", error);
showAlert(error.message || "Gagal menambahkan kategori", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Tambah Kategori";
}
}
});
// Edit category
async function editCategory(catId) {
const newName = prompt("Nama kategori baru:");
if (!newName) return;
try {
await apiCall(`/api/admin/categories/${catId}`, {
method: "PUT",
body: JSON.stringify({ name: newName }),
});
showAlert("Kategori berhasil diupdate!", "success");
await loadCategories();
} catch (error) {
console.error("Error updating category:", error);
showAlert(error.message || "Gagal update kategori", "danger");
}
}
// Delete category
async function deleteCategory(catId) {
if (!confirmAction("Hapus kategori ini?")) return;
try {
await apiCall(`/api/admin/categories/${catId}`, {
method: "DELETE",
});
showAlert("Kategori berhasil dihapus!", "success");
await loadCategories();
} catch (error) {
console.error("Error deleting category:", error);
showAlert(error.message || "Gagal hapus kategori", "danger");
}
}
// Setup report filters - SIMPLIFIED (remove preview)
function setupReportFilters() {
// Remove preview functionality since endpoint doesn't exist
// Just setup the export buttons
}
// Export report
async function exportReport(format) {
const period = document.getElementById("reportPeriod")?.value;
const type = document.getElementById("reportType")?.value;
const startDate = document.getElementById("reportStartDate")?.value;
const endDate = document.getElementById("reportEndDate")?.value;
let url = `/api/admin/reports/export?format=${format}&period=${period}&type=${type}`;
if (period === "custom" && startDate && endDate) {
url += `&start_date=${startDate}&end_date=${endDate}`;
}
try {
const token = getToken();
const response = await fetch(`${API_URL}${url}`, {
headers: {
Authorization: `Bearer ${token}`,
},
});
if (!response.ok) {
throw new Error("Export failed");
}
const blob = await response.blob();
const downloadUrl = window.URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = downloadUrl;
a.download = `laporan_${type}_${period}.${
format === "pdf" ? "pdf" : "xlsx"
}`;
document.body.appendChild(a);
a.click();
window.URL.revokeObjectURL(downloadUrl);
a.remove();
showAlert(
`Laporan ${format.toUpperCase()} berhasil didownload!`,
"success"
);
} catch (error) {
console.error("Error exporting report:", error);
showAlert("Gagal export laporan", "danger");
}
}
// Load audit logs
async function loadAudit() {
try {
const response = await apiCall("/api/admin/audit-logs");
allAuditLogs = response.data || [];
renderAuditLogs(allAuditLogs);
} catch (error) {
console.error("Error loading audit logs:", error);
showAlert("Gagal memuat audit log", "danger");
}
}
// Render audit logs
function renderAuditLogs(logs) {
const tbody = document.getElementById("auditTableBody");
if (!logs || logs.length === 0) {
tbody.innerHTML = `
<tr>
<td colspan="5" style="text-align: center; padding: 40px; color: #64748b;">
Belum ada audit log
</td>
</tr>
`;
return;
}
tbody.innerHTML = logs
.map(
(log) => `
<tr>
<td>${formatDateTime(log.created_at)}</td>
<td>${log.user_name}</td>
<td><span class="badge badge-primary">${log.action}</span></td>
<td>${log.details || "-"}</td>
<td>${log.ip_address || "-"}</td>
</tr>
`
)
.join("");
}
// Setup search and filters
function setupSearchAndFilters() {
const searchUsers = document.getElementById("searchUsers");
const roleFilter = document.getElementById("roleFilter");
const statusFilter = document.getElementById("statusFilter");
const performUsersSearch = debounce(() => {
const searchTerm = searchUsers?.value.toLowerCase() || "";
const role = roleFilter?.value || "";
const status = statusFilter?.value || "";
let filtered = allUsers.filter((user) => {
const matchesSearch =
user.name.toLowerCase().includes(searchTerm) ||
user.email.toLowerCase().includes(searchTerm) ||
user.nrp.includes(searchTerm);
const matchesRole = !role || user.role === role;
const matchesStatus = !status || user.status === status;
return matchesSearch && matchesRole && matchesStatus;
});
renderUsers(filtered);
}, 300);
searchUsers?.addEventListener("input", performUsersSearch);
roleFilter?.addEventListener("change", performUsersSearch);
statusFilter?.addEventListener("change", performUsersSearch);
}
// web/js/main.js
// Main.js - Shared functions across all dashboards
const API_URL = "http://localhost:8080";
// Auth utilities
function getToken() {
return localStorage.getItem("token");
}
function getCurrentUser() {
const user = localStorage.getItem("user");
return user ? JSON.parse(user) : null;
}
function setAuth(token, user) {
localStorage.setItem("token", token);
localStorage.setItem("user", JSON.stringify(user));
}
function clearAuth() {
localStorage.removeItem("token");
localStorage.removeItem("user");
}
// Check authentication - FIXED
function checkAuth() {
const token = getToken();
const user = getCurrentUser();
if (!token || !user) {
// FIXED: Jangan langsung redirect di sini
// Biarkan halaman yang memanggil yang handle redirect
return null;
}
return user;
}
// Logout - FIXED
function logout() {
if (confirm("Apakah Anda yakin ingin logout?")) {
clearAuth();
window.location.href = "/login"; // FIXED: tambah /
}
}
// API call helper
async function apiCall(endpoint, options = {}) {
const token = getToken();
const defaultOptions = {
headers: {
"Content-Type": "application/json",
...(token && { Authorization: `Bearer ${token}` }),
},
};
const finalOptions = {
...defaultOptions,
...options,
headers: {
...defaultOptions.headers,
...options.headers,
},
};
try {
const response = await fetch(`${API_URL}${endpoint}`, finalOptions);
const data = await response.json();
if (!response.ok) {
// Handle 401 Unauthorized
if (response.status === 401) {
showAlert("Session expired. Please login again.", "danger");
setTimeout(() => {
clearAuth();
window.location.href = "/login"; // FIXED: tambah /
}, 1500);
throw new Error("Unauthorized");
}
throw new Error(data.error || "Request failed");
}
return data;
} catch (error) {
console.error("API call error:", error);
throw error;
}
}
// API call for file upload - FIXED: support PUT method
async function apiUpload(endpoint, formData, method = "POST") {
const token = getToken();
try {
const response = await fetch(`${API_URL}${endpoint}`, {
method: method, // FIXED: bisa POST atau PUT
headers: {
...(token && { Authorization: `Bearer ${token}` }),
// JANGAN set Content-Type untuk FormData, browser akan set otomatis dengan boundary
},
body: formData,
});
const data = await response.json();
if (!response.ok) {
if (response.status === 401) {
showAlert("Session expired. Please login again.", "danger");
setTimeout(() => {
clearAuth();
window.location.href = "/login"; // FIXED: tambah /
}, 1500);
throw new Error("Unauthorized");
}
throw new Error(data.error || "Upload failed");
}
return data;
} catch (error) {
console.error("Upload error:", error);
throw error;
}
}
// Tab switching
function switchTab(tabName) {
// Remove active class from all tabs
document.querySelectorAll(".tab-btn").forEach((btn) => {
btn.classList.remove("active");
});
document.querySelectorAll(".tab-content").forEach((content) => {
content.classList.remove("active");
});
// Add active class to selected tab
event.target.classList.add("active");
document.getElementById(tabName + "Tab").classList.add("active");
// Trigger load function for specific tab if exists
const loadFunctionName = `load${capitalize(tabName)}`;
if (typeof window[loadFunctionName] === "function") {
window[loadFunctionName]();
}
}
// Modal utilities
function openModal(modalId) {
document.getElementById(modalId).classList.add("active");
}
function closeModal(modalId) {
document.getElementById(modalId).classList.remove("active");
}
// Close modal when clicking outside
window.addEventListener("click", (e) => {
if (e.target.classList.contains("modal")) {
e.target.classList.remove("active");
}
});
// Alert notification
function showAlert(message, type = "info") {
const alertDiv = document.createElement("div");
alertDiv.className = `alert alert-${type}`;
alertDiv.textContent = message;
alertDiv.style.cssText = `
position: fixed;
top: 80px;
right: 20px;
padding: 15px 20px;
border-radius: 10px;
box-shadow: 0 5px 15px rgba(0,0,0,0.2);
z-index: 9999;
animation: slideInRight 0.3s;
`;
// Set colors based on type
const colors = {
success: { bg: "#d1fae5", color: "#10b981", border: "#10b981" },
danger: { bg: "#fee2e2", color: "#ef4444", border: "#ef4444" },
warning: { bg: "#fef3c7", color: "#f59e0b", border: "#f59e0b" },
info: { bg: "#dbeafe", color: "#2563eb", border: "#2563eb" },
};
const colorScheme = colors[type] || colors.info;
alertDiv.style.background = colorScheme.bg;
alertDiv.style.color = colorScheme.color;
alertDiv.style.border = `2px solid ${colorScheme.border}`;
document.body.appendChild(alertDiv);
setTimeout(() => {
alertDiv.style.animation = "slideOutRight 0.3s";
setTimeout(() => alertDiv.remove(), 300);
}, 3000);
}
// Format date
function formatDate(dateString) {
const date = new Date(dateString);
const options = { year: "numeric", month: "long", day: "numeric" };
return date.toLocaleDateString("id-ID", options);
}
// Format datetime
function formatDateTime(dateString) {
const date = new Date(dateString);
const options = {
year: "numeric",
month: "long",
day: "numeric",
hour: "2-digit",
minute: "2-digit",
};
return date.toLocaleDateString("id-ID", options);
}
// Capitalize first letter
function capitalize(str) {
return str.charAt(0).toUpperCase() + str.slice(1);
}
// Get status badge HTML
function getStatusBadge(status) {
const statusMap = {
unclaimed: { label: "Unclaimed", class: "badge-primary" },
pending_claim: { label: "Pending Claim", class: "badge-warning" },
verified: { label: "Verified", class: "badge-success" },
case_closed: { label: "Case Closed", class: "badge-success" },
expired: { label: "Expired", class: "badge-danger" },
pending: { label: "Pending", class: "badge-warning" },
approved: { label: "Approved", class: "badge-success" },
rejected: { label: "Rejected", class: "badge-danger" },
active: { label: "Active", class: "badge-success" },
blocked: { label: "Blocked", class: "badge-danger" },
};
const statusInfo = statusMap[status] || {
label: status,
class: "badge-primary",
};
return `<span class="badge ${statusInfo.class}">${statusInfo.label}</span>`;
}
// Get role badge HTML
function getRoleBadge(role) {
const roleMap = {
admin: { label: "Admin", class: "badge-danger" },
manager: { label: "Manager", class: "badge-warning" },
user: { label: "User", class: "badge-primary" },
};
const roleInfo = roleMap[role] || { label: role, class: "badge-primary" };
return `<span class="badge ${roleInfo.class}">${roleInfo.label}</span>`;
}
// Confirm dialog
function confirmAction(message) {
return confirm(message);
}
// Loading state
function setLoading(elementId, isLoading) {
const element = document.getElementById(elementId);
if (!element) return;
if (isLoading) {
element.innerHTML = `
<div class="empty-state">
<div class="loading" style="width: 50px; height: 50px; border-width: 5px;"></div>
<p style="margin-top: 20px;">Loading...</p>
</div>
`;
}
}
// Empty state
function showEmptyState(elementId, icon, message) {
const element = document.getElementById(elementId);
if (!element) return;
element.innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">${icon}</div>
<h3>Tidak ada data</h3>
<p>${message}</p>
</div>
`;
}
// Debounce function for search
function debounce(func, wait) {
let timeout;
return function executedFunction(...args) {
const later = () => {
clearTimeout(timeout);
func(...args);
};
clearTimeout(timeout);
timeout = setTimeout(later, wait);
};
}
// Add CSS animation styles
const style = document.createElement("style");
style.textContent = `
@keyframes slideInRight {
from {
transform: translateX(100%);
opacity: 0;
}
to {
transform: translateX(0);
opacity: 1;
}
}
@keyframes slideOutRight {
from {
transform: translateX(0);
opacity: 1;
}
to {
transform: translateX(100%);
opacity: 0;
}
}
`;
document.head.appendChild(style);
// Initialize user info in navbar
function initUserInfo() {
const user = getCurrentUser();
if (!user) return;
const userNameEl = document.getElementById("userName");
const userAvatarEl = document.getElementById("userAvatar");
if (userNameEl) userNameEl.textContent = user.name;
if (userAvatarEl)
userAvatarEl.textContent = user.name.charAt(0).toUpperCase();
}
// Initialize on page load
window.addEventListener("DOMContentLoaded", () => {
initUserInfo();
});
// web/js/manager.js
// Dashboard Manager JavaScript - FIXED ENDPOINTS
let allItems = [];
let allClaims = [];
let allLostItems = [];
let allArchive = [];
// Initialize dashboard
window.addEventListener("DOMContentLoaded", async () => {
const user = checkAuth();
if (!user || user.role !== "manager") {
window.location.href = "/login";
return;
}
await loadStats();
await loadItems();
setupSearchAndFilters();
});
// Load statistics - FIXED
async function loadStats() {
try {
const stats = await apiCall("/api/manager/dashboard");
document.getElementById("statTotalItems").textContent =
stats.total_items || 0;
document.getElementById("statPendingClaims").textContent =
stats.pending_claims || 0;
document.getElementById("statVerified").textContent = stats.verified || 0;
document.getElementById("statExpired").textContent = stats.expired || 0;
} catch (error) {
console.error("Error loading stats:", error);
}
}
// Load items - FIXED
async function loadItems() {
setLoading("itemsGrid", true);
try {
const response = await apiCall("/api/items");
allItems = response.data || [];
renderItems(allItems);
} catch (error) {
console.error("Error loading items:", error);
showEmptyState("itemsGrid", "📦", "Gagal memuat data barang");
}
}
// Render items
function renderItems(items) {
const grid = document.getElementById("itemsGrid");
if (!items || items.length === 0) {
showEmptyState("itemsGrid", "📦", "Belum ada barang");
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card">
<img src="${
item.photo_url || "https://via.placeholder.com/280x200?text=No+Image"
}"
alt="${item.name}"
class="item-image"
onerror="this.src='https://via.placeholder.com/280x200?text=No+Image'">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>📍 ${item.location}</span>
<span>📅 ${formatDate(item.date_found)}</span>
<span>${getStatusBadge(item.status)}</span>
</div>
<div class="item-actions">
<button class="btn btn-primary btn-sm" onclick="viewItemDetail(${
item.id
})">Detail</button>
${
item.status !== "case_closed" && item.status !== "expired"
? `<button class="btn btn-warning btn-sm" onclick="editItem(${item.id})">Edit</button>`
: ""
}
${
item.status === "verified"
? `<button class="btn btn-success btn-sm" onclick="closeCase(${item.id})">Close Case</button>`
: ""
}
</div>
</div>
</div>
`
)
.join("");
}
// View item detail - FIXED
async function viewItemDetail(itemId) {
try {
const item = await apiCall(`/api/items/${itemId}`);
const modalContent = document.getElementById("itemDetailContent");
modalContent.innerHTML = `
<img src="${
item.photo_url || "https://via.placeholder.com/600x400?text=No+Image"
}"
alt="${item.name}"
style="width: 100%; max-height: 400px; object-fit: cover; border-radius: 10px; margin-bottom: 20px;"
onerror="this.src='https://via.placeholder.com/600x400?text=No+Image'">
<h3>${item.name}</h3>
<div style="display: grid; gap: 15px; margin-top: 20px;">
<div><strong>Kategori:</strong> ${item.category}</div>
<div><strong>Lokasi Ditemukan:</strong> ${item.location}</div>
<div><strong>Tanggal Ditemukan:</strong> ${formatDate(
item.date_found
)}</div>
<div><strong>Status:</strong> ${getStatusBadge(item.status)}</div>
<div><strong>Pelapor:</strong> ${item.reporter_name}</div>
<div><strong>Kontak:</strong> ${item.reporter_contact}</div>
<div style="background: #f8fafc; padding: 15px; border-radius: 10px;">
<strong>Deskripsi Keunikan (Rahasia):</strong><br>
${item.description}
</div>
</div>
`;
openModal("itemDetailModal");
} catch (error) {
console.error("Error loading item detail:", error);
showAlert("Gagal memuat detail barang", "danger");
}
}
// Edit item - FIXED
async function editItem(itemId) {
try {
const item = await apiCall(`/api/items/${itemId}`);
const form = document.getElementById("editItemForm");
form.elements.item_id.value = item.id;
form.elements.name.value = item.name;
form.elements.category.value = item.category;
form.elements.location.value = item.location;
form.elements.description.value = item.description;
form.elements.reporter_name.value = item.reporter_name;
form.elements.reporter_contact.value = item.reporter_contact;
form.elements.date_found.value = item.date_found.split("T")[0];
openModal("editItemModal");
} catch (error) {
console.error("Error loading item:", error);
showAlert("Gagal memuat data barang", "danger");
}
}
// Submit edit item - FIXED
document
.getElementById("editItemForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
const itemId = formData.get("item_id");
formData.delete("item_id");
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Menyimpan...';
await apiUpload(`/api/items/${itemId}`, formData, "PUT");
showAlert("Barang berhasil diupdate!", "success");
closeModal("editItemModal");
await loadItems();
await loadStats();
} catch (error) {
console.error("Error updating item:", error);
showAlert(error.message || "Gagal update barang", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Update";
}
}
});
// Close case - FIXED
async function closeCase(itemId) {
if (!confirmAction("Tutup kasus ini? Barang akan dipindahkan ke arsip."))
return;
try {
await apiCall(`/api/items/${itemId}/status`, {
method: "PATCH",
body: JSON.stringify({ status: "case_closed" }),
});
showAlert("Kasus berhasil ditutup!", "success");
await loadItems();
await loadStats();
} catch (error) {
console.error("Error closing case:", error);
showAlert(error.message || "Gagal menutup kasus", "danger");
}
}
// Load claims - FIXED
async function loadClaims() {
setLoading("claimsList", true);
try {
const response = await apiCall("/api/claims");
allClaims = response.data || [];
renderClaims(allClaims);
} catch (error) {
console.error("Error loading claims:", error);
document.getElementById("claimsList").innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">🤝</div>
<p>Gagal memuat data klaim</p>
</div>
`;
}
}
// Render claims
function renderClaims(claims) {
const list = document.getElementById("claimsList");
if (!claims || claims.length === 0) {
list.innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">🤝</div>
<p>Belum ada klaim yang masuk</p>
</div>
`;
return;
}
list.innerHTML = claims
.map(
(claim) => `
<div class="claim-card">
<div class="claim-header">
<h3>${claim.item_name}</h3>
${getStatusBadge(claim.status)}
</div>
<div class="claim-info">
<div><strong>Pengklaim:</strong> ${claim.user_name}</div>
<div><strong>Kontak:</strong> ${claim.contact}</div>
<div><strong>Tanggal Klaim:</strong> ${formatDate(
claim.created_at
)}</div>
${
claim.match_percentage
? `
<div><strong>Match:</strong>
<span style="color: ${
claim.match_percentage >= 70 ? "#10b981" : "#f59e0b"
}; font-weight: 600;">
${claim.match_percentage}%
</span>
</div>
`
: ""
}
</div>
<div style="background: #f8fafc; padding: 15px; border-radius: 10px; margin-bottom: 15px;">
<strong>Deskripsi dari Pengklaim:</strong><br>
${claim.description}
</div>
${
claim.status === "pending"
? `
<div class="claim-actions">
<button class="btn btn-primary btn-sm" onclick="verifyClaim(${claim.id})">Verifikasi</button>
<button class="btn btn-success btn-sm" onclick="approveClaim(${claim.id})">Approve</button>
<button class="btn btn-danger btn-sm" onclick="rejectClaim(${claim.id})">Reject</button>
</div>
`
: ""
}
${
claim.status === "rejected" && claim.notes
? `
<div style="color: #ef4444; margin-top: 10px;">
<strong>Alasan:</strong> ${claim.notes}
</div>
`
: ""
}
</div>
`
)
.join("");
}
// Verify claim - FIXED
async function verifyClaim(claimId) {
try {
const claim = await apiCall(`/api/claims/${claimId}`);
const modalContent = document.getElementById("verifyClaimContent");
modalContent.innerHTML = `
<div style="display: grid; grid-template-columns: 1fr 1fr; gap: 30px;">
<div>
<h4>Deskripsi Asli Barang</h4>
<div style="background: #f8fafc; padding: 15px; border-radius: 10px; margin-top: 10px;">
${claim.item_description}
</div>
</div>
<div>
<h4>Deskripsi dari Pengklaim</h4>
<div style="background: #fef3c7; padding: 15px; border-radius: 10px; margin-top: 10px;">
${claim.description}
</div>
</div>
</div>
${
claim.proof_url
? `
<div style="margin-top: 20px;">
<h4>Bukti Pendukung</h4>
<img src="${claim.proof_url}" style="width: 100%; max-height: 300px; object-fit: contain; border-radius: 10px; margin-top: 10px;">
</div>
`
: ""
}
${
claim.match_percentage
? `
<div style="margin-top: 20px; padding: 15px; background: ${
claim.match_percentage >= 70 ? "#d1fae5" : "#fef3c7"
}; border-radius: 10px; text-align: center;">
<strong>Similarity Match:</strong>
<span style="font-size: 2rem; font-weight: 700; color: ${
claim.match_percentage >= 70 ? "#10b981" : "#f59e0b"
};">
${claim.match_percentage}%
</span>
</div>
`
: ""
}
<div style="margin-top: 20px;">
<strong>Info Pengklaim:</strong>
<div style="margin-top: 10px;">
<div>Nama: ${claim.user_name}</div>
<div>Kontak: ${claim.contact}</div>
</div>
</div>
<div style="display: flex; gap: 10px; margin-top: 30px;">
<button class="btn btn-success" onclick="approveClaim(${claimId})" style="flex: 1;">✓ Approve Klaim</button>
<button class="btn btn-danger" onclick="rejectClaim(${claimId})" style="flex: 1;">✗ Reject Klaim</button>
</div>
`;
openModal("verifyClaimModal");
} catch (error) {
console.error("Error loading claim:", error);
showAlert("Gagal memuat data klaim", "danger");
}
}
// Approve claim - FIXED
async function approveClaim(claimId) {
const notes = prompt("Catatan (opsional):");
try {
await apiCall(`/api/claims/${claimId}/verify`, {
method: "POST",
body: JSON.stringify({
approved: true,
notes: notes || "",
}),
});
showAlert("Klaim berhasil diapprove!", "success");
closeModal("verifyClaimModal");
await loadClaims();
await loadItems();
await loadStats();
} catch (error) {
console.error("Error approving claim:", error);
showAlert(error.message || "Gagal approve klaim", "danger");
}
}
// Reject claim - FIXED
async function rejectClaim(claimId) {
const notes = prompt("Alasan penolakan (wajib):");
if (!notes) {
showAlert("Alasan penolakan harus diisi!", "warning");
return;
}
try {
await apiCall(`/api/claims/${claimId}/verify`, {
method: "POST",
body: JSON.stringify({
approved: false,
notes,
}),
});
showAlert("Klaim berhasil ditolak!", "success");
closeModal("verifyClaimModal");
await loadClaims();
await loadStats();
} catch (error) {
console.error("Error rejecting claim:", error);
showAlert(error.message || "Gagal reject klaim", "danger");
}
}
// Load lost items - FIXED
async function loadLost() {
setLoading("lostItemsGrid", true);
try {
const response = await apiCall("/api/lost-items");
allLostItems = response.data || [];
renderLostItems(allLostItems);
} catch (error) {
console.error("Error loading lost items:", error);
showEmptyState("lostItemsGrid", "😢", "Gagal memuat data barang hilang");
}
}
// Render lost items
function renderLostItems(items) {
const grid = document.getElementById("lostItemsGrid");
if (!items || items.length === 0) {
showEmptyState("lostItemsGrid", "😢", "Belum ada laporan barang hilang");
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>🏷️ ${item.category}</span>
<span>🎨 ${item.color}</span>
<span>📅 ${formatDate(item.date_lost)}</span>
${item.location ? `<span>📍 ${item.location}</span>` : ""}
</div>
<p style="color: #64748b; font-size: 0.9rem; margin-top: 10px;">${
item.description
}</p>
<div style="margin-top: 10px;">
<small><strong>Pelapor:</strong> ${item.user_name}</small>
</div>
<button class="btn btn-primary btn-sm" onclick="findSimilarItems(${
item.id
})" style="margin-top: 10px; width: 100%;">
🔍 Cari Barang yang Mirip
</button>
</div>
</div>
`
)
.join("");
}
// Find similar items - FIXED
async function findSimilarItems(lostItemId) {
try {
setLoading("matchItemsContent", true);
openModal("matchItemsModal");
const response = await apiCall(`/api/lost-items/${lostItemId}/matches`);
const matches = response.data || [];
const modalContent = document.getElementById("matchItemsContent");
if (matches.length === 0) {
modalContent.innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">🔍</div>
<h3>Tidak ada barang yang cocok</h3>
<p>Belum ada barang ditemukan yang mirip dengan laporan ini</p>
</div>
`;
return;
}
modalContent.innerHTML = `
<p style="margin-bottom: 20px; color: #64748b;">Ditemukan ${
matches.length
} barang yang mungkin cocok:</p>
<div class="items-grid">
${matches
.map(
(match) => `
<div class="item-card" style="border: 2px solid ${
match.similarity >= 70 ? "#10b981" : "#f59e0b"
};">
<img src="${
match.photo_url ||
"https://via.placeholder.com/280x200?text=No+Image"
}"
alt="${match.name}"
class="item-image"
onerror="this.src='https://via.placeholder.com/280x200?text=No+Image'">
<div class="item-body">
<div style="text-align: center; margin-bottom: 10px;">
<span style="font-size: 1.5rem; font-weight: 700; color: ${
match.similarity >= 70 ? "#10b981" : "#f59e0b"
};">
${match.similarity}% Match
</span>
</div>
<h3 class="item-title">${match.name}</h3>
<div class="item-meta">
<span>📍 ${match.location}</span>
<span>📅 ${formatDate(match.date_found)}</span>
<span>${getStatusBadge(match.status)}</span>
</div>
<button class="btn btn-primary btn-sm" onclick="viewItemDetail(${
match.id
})" style="width: 100%; margin-top: 10px;">
Lihat Detail
</button>
</div>
</div>
`
)
.join("")}
</div>
`;
} catch (error) {
console.error("Error finding similar items:", error);
document.getElementById("matchItemsContent").innerHTML = `
<div class="empty-state">
<div class="empty-state-icon">❌</div>
<p>Gagal mencari barang yang mirip</p>
</div>
`;
}
}
// Load archive - FIXED
async function loadArchive() {
setLoading("archiveGrid", true);
try {
const response = await apiCall("/api/archives");
allArchive = response.data || [];
renderArchive(allArchive);
} catch (error) {
console.error("Error loading archive:", error);
showEmptyState("archiveGrid", "📂", "Gagal memuat data arsip");
}
}
// Render archive
function renderArchive(items) {
const grid = document.getElementById("archiveGrid");
if (!items || items.length === 0) {
showEmptyState("archiveGrid", "📂", "Belum ada barang di arsip");
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card">
<img src="${
item.photo_url || "https://via.placeholder.com/280x200?text=No+Image"
}"
alt="${item.name}"
class="item-image"
onerror="this.src='https://via.placeholder.com/280x200?text=No+Image'">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>📍 ${item.location}</span>
<span>📅 ${formatDate(item.date_found)}</span>
<span>${getStatusBadge(item.status)}</span>
</div>
</div>
</div>
`
)
.join("");
}
// Report found item - FIXED
function openReportFoundModal() {
openModal("reportFoundModal");
}
// Submit found item report - FIXED
document
.getElementById("reportFoundForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Mengirim...';
await apiUpload("/api/items", formData);
showAlert("Barang berhasil ditambahkan!", "success");
closeModal("reportFoundModal");
e.target.reset();
await loadItems();
await loadStats();
} catch (error) {
console.error("Error submitting item:", error);
showAlert(error.message || "Gagal menambahkan barang", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Submit";
}
}
});
// Setup search and filters
function setupSearchAndFilters() {
// Items tab
const searchItems = document.getElementById("searchItems");
const categoryFilterItems = document.getElementById("categoryFilterItems");
const statusFilterItems = document.getElementById("statusFilterItems");
const sortItems = document.getElementById("sortItems");
const performItemsSearch = debounce(() => {
const searchTerm = searchItems?.value.toLowerCase() || "";
const category = categoryFilterItems?.value || "";
const status = statusFilterItems?.value || "";
const sort = sortItems?.value || "date_desc";
let filtered = allItems.filter((item) => {
const matchesSearch =
item.name.toLowerCase().includes(searchTerm) ||
item.location.toLowerCase().includes(searchTerm);
const matchesCategory = !category || item.category === category;
const matchesStatus = !status || item.status === status;
return matchesSearch && matchesCategory && matchesStatus;
});
// Sort
filtered.sort((a, b) => {
switch (sort) {
case "date_desc":
return new Date(b.date_found) - new Date(a.date_found);
case "date_asc":
return new Date(a.date_found) - new Date(b.date_found);
case "name_asc":
return a.name.localeCompare(b.name);
case "name_desc":
return b.name.localeCompare(a.name);
default:
return 0;
}
});
renderItems(filtered);
}, 300);
searchItems?.addEventListener("input", performItemsSearch);
categoryFilterItems?.addEventListener("change", performItemsSearch);
statusFilterItems?.addEventListener("change", performItemsSearch);
sortItems?.addEventListener("change", performItemsSearch);
// Claims tab
const searchClaims = document.getElementById("searchClaims");
const statusFilterClaims = document.getElementById("statusFilterClaims");
const performClaimsSearch = debounce(() => {
const searchTerm = searchClaims?.value.toLowerCase() || "";
const status = statusFilterClaims?.value || "";
let filtered = allClaims.filter((claim) => {
const matchesSearch =
claim.item_name.toLowerCase().includes(searchTerm) ||
claim.user_name.toLowerCase().includes(searchTerm);
const matchesStatus = !status || claim.status === status;
return matchesSearch && matchesStatus;
});
renderClaims(filtered);
}, 300);
searchClaims?.addEventListener("input", performClaimsSearch);
statusFilterClaims?.addEventListener("change", performClaimsSearch);
}
// Create edit item modal if not exists
if (!document.getElementById("editItemModal")) {
const editItemModal = document.createElement("div");
editItemModal.id = "editItemModal";
editItemModal.className = "modal";
editItemModal.innerHTML = `
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Edit Barang</h3>
<button class="close-btn" onclick="closeModal('editItemModal')">&times;</button>
</div>
<div class="modal-body">
<form id="editItemForm">
<input type="hidden" name="item_id">
<div class="form-group">
<label>Foto Barang (Opsional - Kosongkan jika tidak ingin mengubah)</label>
<input type="file" name="photo" accept="image/*">
</div>
<div class="form-group">
<label>Nama Barang *</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Kategori *</label>
<select name="category" required>
<option value="">Pilih Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="form-group">
<label>Lokasi Ditemukan *</label>
<input type="text" name="location" required>
</div>
<div class="form-group">
<label>Deskripsi Keunikan *</label>
<textarea name="description" required></textarea>
</div>
<div class="form-group">
<label>Nama Pelapor *</label>
<input type="text" name="reporter_name" required>
</div>
<div class="form-group">
<label>Kontak Pelapor *</label>
<input type="text" name="reporter_contact" required>
</div>
<div class="form-group">
<label>Tanggal Ditemukan *</label>
<input type="date" name="date_found" required>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Update</button>
</form>
</div>
</div>
`;
document.body.appendChild(editItemModal);
}
// web/js/user.js
// Dashboard User JavaScript - FIXED ENDPOINTS
let allItems = [];
let allLostItems = [];
let allClaims = [];
// Initialize dashboard
window.addEventListener("DOMContentLoaded", async () => {
const user = checkAuth();
// FIXED: Tambahkan pengecekan role yang lebih spesifik
if (!user) {
window.location.href = "/login";
return;
}
if (user.role !== "user") {
// Redirect ke dashboard yang sesuai dengan role
if (user.role === "admin") {
window.location.href = "/admin";
} else if (user.role === "manager") {
window.location.href = "/manager";
}
return;
}
// Lanjutkan load data untuk user
await loadStats();
await loadBrowseItems();
setupSearchAndFilters();
});
// Load statistics - CORRECT (sudah sesuai)
async function loadStats() {
try {
const stats = await apiCall("/api/user/stats");
document.getElementById("statLost").textContent = stats.lost_items || 0;
document.getElementById("statFound").textContent = stats.found_items || 0;
document.getElementById("statClaims").textContent = stats.claims || 0;
} catch (error) {
console.error("Error loading stats:", error);
}
}
// Load browse items - CORRECT (sudah sesuai)
async function loadBrowseItems() {
setLoading("itemsGrid", true);
try {
const response = await apiCall("/api/items");
allItems = response.data || [];
renderItems(allItems);
} catch (error) {
console.error("Error loading items:", error);
showEmptyState("itemsGrid", "📦", "Gagal memuat data barang");
}
}
// Render items
function renderItems(items) {
const grid = document.getElementById("itemsGrid");
if (!items || items.length === 0) {
showEmptyState("itemsGrid", "📦", "Belum ada barang ditemukan");
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card" onclick="viewItemDetail(${item.id})">
<img src="${
item.photo_url || "https://via.placeholder.com/280x200?text=No+Image"
}"
alt="${item.name}"
class="item-image"
onerror="this.src='https://via.placeholder.com/280x200?text=No+Image'">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>📍 ${item.location}</span>
<span>📅 ${formatDate(item.date_found)}</span>
<span>${getStatusBadge(item.status)}</span>
</div>
${
item.status === "unclaimed"
? `<button class="btn btn-primary btn-sm" onclick="event.stopPropagation(); openClaimModal(${item.id})">Klaim Barang</button>`
: ""
}
</div>
</div>
`
)
.join("");
}
// View item detail - CORRECT (sudah sesuai)
async function viewItemDetail(itemId) {
try {
const item = await apiCall(`/api/items/${itemId}`);
const modalContent = document.getElementById("itemDetailContent");
modalContent.innerHTML = `
<img src="${
item.photo_url || "https://via.placeholder.com/600x400?text=No+Image"
}"
alt="${item.name}"
style="width: 100%; max-height: 400px; object-fit: cover; border-radius: 10px; margin-bottom: 20px;"
onerror="this.src='https://via.placeholder.com/600x400?text=No+Image'">
<h3>${item.name}</h3>
<div style="display: grid; gap: 15px; margin-top: 20px;">
<div><strong>Kategori:</strong> ${item.category}</div>
<div><strong>Lokasi Ditemukan:</strong> ${item.location}</div>
<div><strong>Tanggal Ditemukan:</strong> ${formatDate(
item.date_found
)}</div>
<div><strong>Status:</strong> ${getStatusBadge(item.status)}</div>
</div>
${
item.status === "unclaimed"
? `<button class="btn btn-primary" onclick="openClaimModal(${item.id})" style="width: 100%; margin-top: 20px;">Klaim Barang Ini</button>`
: ""
}
`;
openModal("itemDetailModal");
} catch (error) {
console.error("Error loading item detail:", error);
showAlert("Gagal memuat detail barang", "danger");
}
}
// Open claim modal
function openClaimModal(itemId) {
closeModal("itemDetailModal");
const modalContent = document.getElementById("claimModalContent");
modalContent.innerHTML = `
<form id="claimForm" onsubmit="submitClaim(event, ${itemId})">
<div class="form-group">
<label>Deskripsi Barang (Jelaskan ciri-ciri barang Anda) *</label>
<textarea name="description" required placeholder="Jelaskan ciri khusus barang yang hanya Anda tahu..."></textarea>
</div>
<div class="form-group">
<label>Bukti Pendukung (Opsional)</label>
<input type="file" name="proof" accept="image/*">
<small style="color: #64748b;">Upload foto barang saat Anda masih memilikinya (opsional)</small>
</div>
<div class="form-group">
<label>No. Kontak *</label>
<input type="text" name="contact" required placeholder="08123456789">
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Submit Klaim</button>
</form>
`;
openModal("claimModal");
}
// Submit claim - CORRECT (sudah sesuai)
async function submitClaim(event, itemId) {
event.preventDefault();
const form = event.target;
const formData = new FormData(form);
formData.append("item_id", itemId);
try {
const submitBtn = form.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Mengirim...';
await apiUpload("/api/claims", formData);
showAlert(
"Klaim berhasil disubmit! Menunggu verifikasi dari manager.",
"success"
);
closeModal("claimModal");
await loadBrowseItems();
await loadStats();
} catch (error) {
console.error("Error submitting claim:", error);
showAlert(error.message || "Gagal submit klaim", "danger");
} finally {
const submitBtn = form.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Submit Klaim";
}
}
}
// Load my lost items - CORRECT (sudah sesuai)
async function loadLost() {
setLoading("lostItemsGrid", true);
try {
const response = await apiCall("/api/user/lost-items");
allLostItems = response.data || [];
renderLostItems(allLostItems);
} catch (error) {
console.error("Error loading lost items:", error);
showEmptyState("lostItemsGrid", "😢", "Gagal memuat data barang hilang");
}
}
// Render lost items
function renderLostItems(items) {
const grid = document.getElementById("lostItemsGrid");
if (!items || items.length === 0) {
showEmptyState(
"lostItemsGrid",
"😢",
"Anda belum melaporkan barang hilang"
);
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>🏷️ ${item.category}</span>
<span>🎨 ${item.color}</span>
<span>📅 ${formatDate(item.date_lost)}</span>
${item.location ? `<span>📍 ${item.location}</span>` : ""}
</div>
<p style="color: #64748b; font-size: 0.9rem; margin-top: 10px;">${
item.description
}</p>
</div>
</div>
`
)
.join("");
}
// Load my found items - FIXED
async function loadFound() {
setLoading("foundItemsGrid", true);
try {
const response = await apiCall("/api/user/items");
const items = response.data || [];
renderFoundItems(items);
} catch (error) {
console.error("Error loading found items:", error);
showEmptyState(
"foundItemsGrid",
"🎉",
"Gagal memuat data barang yang ditemukan"
);
}
}
// Render found items
function renderFoundItems(items) {
const grid = document.getElementById("foundItemsGrid");
if (!items || items.length === 0) {
showEmptyState(
"foundItemsGrid",
"🎉",
"Anda belum melaporkan penemuan barang"
);
return;
}
grid.innerHTML = items
.map(
(item) => `
<div class="item-card">
<img src="${
item.photo_url || "https://via.placeholder.com/280x200?text=No+Image"
}"
alt="${item.name}"
class="item-image"
onerror="this.src='https://via.placeholder.com/280x200?text=No+Image'">
<div class="item-body">
<h3 class="item-title">${item.name}</h3>
<div class="item-meta">
<span>📍 ${item.location}</span>
<span>📅 ${formatDate(item.date_found)}</span>
<span>${getStatusBadge(item.status)}</span>
</div>
</div>
</div>
`
)
.join("");
}
// Load my claims - CORRECT (sudah sesuai)
async function loadClaims() {
setLoading("claimsGrid", true);
try {
const response = await apiCall("/api/user/claims");
allClaims = response.data || [];
renderClaims(allClaims);
} catch (error) {
console.error("Error loading claims:", error);
showEmptyState("claimsGrid", "🤝", "Gagal memuat data klaim");
}
}
// Render claims
function renderClaims(claims) {
const grid = document.getElementById("claimsGrid");
if (!claims || claims.length === 0) {
showEmptyState("claimsGrid", "🤝", "Anda belum pernah mengajukan klaim");
return;
}
grid.innerHTML = claims
.map(
(claim) => `
<div class="item-card">
<div class="item-body">
<h3 class="item-title">${claim.item_name}</h3>
<div class="item-meta">
<span>📅 ${formatDate(claim.created_at)}</span>
<span>${getStatusBadge(claim.status)}</span>
</div>
<p style="color: #64748b; font-size: 0.9rem; margin-top: 10px;">
${claim.description}
</p>
${
claim.status === "rejected" && claim.notes
? `
<p style="color: #ef4444; font-size: 0.9rem; margin-top: 10px;">
<strong>Alasan ditolak:</strong> ${claim.notes}
</p>
`
: ""
}
</div>
</div>
`
)
.join("");
}
// Report lost item
function openReportLostModal() {
openModal("reportLostModal");
}
// Submit lost item report - CORRECT (sudah sesuai)
document
.getElementById("reportLostForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
const data = Object.fromEntries(formData);
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Mengirim...';
await apiCall("/api/lost-items", {
method: "POST",
body: JSON.stringify(data),
});
showAlert("Laporan kehilangan berhasil disubmit!", "success");
closeModal("reportLostModal");
e.target.reset();
await loadLost();
await loadStats();
} catch (error) {
console.error("Error submitting lost item:", error);
showAlert(error.message || "Gagal submit laporan", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Submit Laporan";
}
}
});
// Report found item
function openReportFoundModal() {
openModal("reportFoundModal");
}
// Submit found item report - CORRECT (sudah sesuai)
document
.getElementById("reportFoundForm")
?.addEventListener("submit", async (e) => {
e.preventDefault();
const formData = new FormData(e.target);
try {
const submitBtn = e.target.querySelector('button[type="submit"]');
submitBtn.disabled = true;
submitBtn.innerHTML = '<span class="loading"></span> Mengirim...';
await apiUpload("/api/items", formData);
showAlert("Laporan penemuan berhasil disubmit!", "success");
closeModal("reportFoundModal");
e.target.reset();
await loadFound();
await loadStats();
} catch (error) {
console.error("Error submitting found item:", error);
showAlert(error.message || "Gagal submit laporan", "danger");
} finally {
const submitBtn = e.target.querySelector('button[type="submit"]');
if (submitBtn) {
submitBtn.disabled = false;
submitBtn.textContent = "Submit Penemuan";
}
}
});
// Setup search and filters
function setupSearchAndFilters() {
const searchInput = document.getElementById("searchInput");
const categoryFilter = document.getElementById("categoryFilter");
const sortBy = document.getElementById("sortBy");
const performSearch = debounce(() => {
const searchTerm = searchInput?.value.toLowerCase() || "";
const category = categoryFilter?.value || "";
const sort = sortBy?.value || "date_desc";
let filtered = allItems.filter((item) => {
const matchesSearch =
item.name.toLowerCase().includes(searchTerm) ||
item.location.toLowerCase().includes(searchTerm);
const matchesCategory = !category || item.category === category;
return matchesSearch && matchesCategory;
});
// Sort
filtered.sort((a, b) => {
switch (sort) {
case "date_desc":
return new Date(b.date_found) - new Date(a.date_found);
case "date_asc":
return new Date(a.date_found) - new Date(b.date_found);
case "name_asc":
return a.name.localeCompare(b.name);
case "name_desc":
return b.name.localeCompare(a.name);
default:
return 0;
}
});
renderItems(filtered);
}, 300);
searchInput?.addEventListener("input", performSearch);
categoryFilter?.addEventListener("change", performSearch);
sortBy?.addEventListener("change", performSearch);
}
// Create claim modal if not exists
if (!document.getElementById("claimModal")) {
const claimModal = document.createElement("div");
claimModal.id = "claimModal";
claimModal.className = "modal";
claimModal.innerHTML = `
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Klaim Barang</h3>
<button class="close-btn" onclick="closeModal('claimModal')">&times;</button>
</div>
<div class="modal-body" id="claimModalContent"></div>
</div>
`;
document.body.appendChild(claimModal);
}
// Create item detail modal if not exists
if (!document.getElementById("itemDetailModal")) {
const itemDetailModal = document.createElement("div");
itemDetailModal.id = "itemDetailModal";
itemDetailModal.className = "modal";
itemDetailModal.innerHTML = `
<div class="modal-content modal-large">
<div class="modal-header">
<h3 class="modal-title">Detail Barang</h3>
<button class="close-btn" onclick="closeModal('itemDetailModal')">&times;</button>
</div>
<div class="modal-body" id="itemDetailContent"></div>
</div>
`;
document.body.appendChild(itemDetailModal);
}
<!-- web/admin.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Dashboard Admin - Lost & Found</title>
<link rel="stylesheet" href="css/style.css">
</head>
<body>
<nav class="navbar">
<div class="navbar-brand">🔍 Lost & Found</div>
<div class="navbar-menu">
<div class="user-info">
<div class="user-avatar" id="userAvatar">A</div>
<span id="userName">Admin</span>
<span class="user-role badge-danger">Admin</span>
</div>
<button class="btn-logout" onclick="logout()">Logout</button>
</div>
</nav>
<div class="container">
<div class="page-header">
<h1>Dashboard Admin</h1>
<p>Kelola sistem Lost & Found</p>
</div>
<div class="stats-grid stats-grid-4">
<div class="stat-card">
<h3>Total User</h3>
<div class="stat-number" id="statTotalUsers">0</div>
</div>
<div class="stat-card">
<h3>Total Barang</h3>
<div class="stat-number" id="statTotalItems">0</div>
</div>
<div class="stat-card">
<h3>Total Klaim</h3>
<div class="stat-number" id="statTotalClaims">0</div>
</div>
<div class="stat-card">
<h3>Di Arsip</h3>
<div class="stat-number" id="statTotalArchive">0</div>
</div>
</div>
<div class="tabs">
<button class="tab-btn active" onclick="switchTab('users')">👥 Kelola User</button>
<button class="tab-btn" onclick="switchTab('categories')">🏷️ Kategori</button>
<button class="tab-btn" onclick="switchTab('reports')">📊 Laporan</button>
<button class="tab-btn" onclick="switchTab('audit')">🔍 Audit Log</button>
</div>
<!-- Tab: Kelola User -->
<div id="usersTab" class="tab-content active">
<div class="card">
<div class="card-header">
<h2 class="card-title">Daftar User</h2>
<button class="btn btn-primary" onclick="openAddUserModal()">+ Tambah User</button>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari user..." id="searchUsers">
<select class="filter-select" id="roleFilter">
<option value="">Semua Role</option>
<option value="user">User</option>
<option value="manager">Manager</option>
<option value="admin">Admin</option>
</select>
<select class="filter-select" id="statusFilter">
<option value="">Semua Status</option>
<option value="active">Active</option>
<option value="blocked">Blocked</option>
</select>
</div>
<div class="table-container">
<table class="data-table" id="usersTable">
<thead>
<tr>
<th>Nama</th>
<th>Email</th>
<th>NRP</th>
<th>Role</th>
<th>Status</th>
<th>Aksi</th>
</tr>
</thead>
<tbody id="usersTableBody"></tbody>
</table>
</div>
</div>
</div>
<!-- Tab: Kategori -->
<div id="categoriesTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Kelola Kategori</h2>
<button class="btn btn-primary" onclick="openAddCategoryModal()">+ Tambah Kategori</button>
</div>
<div class="categories-grid" id="categoriesGrid"></div>
</div>
</div>
<!-- Tab: Laporan -->
<div id="reportsTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Export Laporan</h2>
</div>
<div class="report-section">
<div class="report-filters">
<h3>Filter Laporan</h3>
<div class="form-group">
<label>Periode</label>
<select id="reportPeriod">
<option value="month">Bulan Ini</option>
<option value="semester">Semester Ini</option>
<option value="year">Tahun Ini</option>
<option value="custom">Custom Range</option>
</select>
</div>
<div class="form-group" id="customDateRange" style="display: none;">
<label>Tanggal Mulai</label>
<input type="date" id="reportStartDate">
<label>Tanggal Akhir</label>
<input type="date" id="reportEndDate">
</div>
<div class="form-group">
<label>Tipe Laporan</label>
<select id="reportType">
<option value="all">Semua Data</option>
<option value="items">Barang Ditemukan</option>
<option value="lost">Barang Hilang</option>
<option value="claims">Klaim</option>
<option value="archive">Arsip</option>
</select>
</div>
<div class="report-actions">
<button class="btn btn-success" onclick="exportReport('pdf')">📄 Export PDF</button>
<button class="btn btn-success" onclick="exportReport('excel')">📊 Export Excel</button>
</div>
</div>
<div class="report-preview" id="reportPreview">
<h3>Preview Laporan</h3>
<div class="report-stats">
<div class="report-stat-item">
<strong>Total Barang:</strong>
<span id="previewTotalItems">-</span>
</div>
<div class="report-stat-item">
<strong>Diklaim:</strong>
<span id="previewClaimed">-</span>
</div>
<div class="report-stat-item">
<strong>Expired:</strong>
<span id="previewExpired">-</span>
</div>
</div>
</div>
</div>
</div>
</div>
<!-- Tab: Audit Log -->
<div id="auditTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Audit Log</h2>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari log..." id="searchAudit">
<select class="filter-select" id="actionFilter">
<option value="">Semua Aksi</option>
<option value="create">Create</option>
<option value="update">Update</option>
<option value="delete">Delete</option>
<option value="verify">Verify</option>
</select>
<input type="date" class="filter-select" id="dateFilter">
</div>
<div class="table-container">
<table class="data-table" id="auditTable">
<thead>
<tr>
<th>Waktu</th>
<th>User</th>
<th>Aksi</th>
<th>Detail</th>
<th>IP Address</th>
</tr>
</thead>
<tbody id="auditTableBody"></tbody>
</table>
</div>
</div>
</div>
</div>
<!-- Modal Add User -->
<div id="addUserModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Tambah User</h3>
<button class="close-btn" onclick="closeModal('addUserModal')">&times;</button>
</div>
<div class="modal-body">
<form id="addUserForm">
<div class="form-group">
<label>Nama Lengkap *</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Email *</label>
<input type="email" name="email" required>
</div>
<div class="form-group">
<label>NRP *</label>
<input type="text" name="nrp" required>
</div>
<div class="form-group">
<label>No. Telepon *</label>
<input type="tel" name="phone" required>
</div>
<div class="form-group">
<label>Role *</label>
<select name="role" required>
<option value="user">User</option>
<option value="manager">Manager</option>
<option value="admin">Admin</option>
</select>
</div>
<div class="form-group">
<label>Password *</label>
<input type="password" name="password" required>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Tambah User</button>
</form>
</div>
</div>
</div>
<!-- Modal Edit User -->
<div id="editUserModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Edit User</h3>
<button class="close-btn" onclick="closeModal('editUserModal')">&times;</button>
</div>
<div class="modal-body">
<form id="editUserForm">
<input type="hidden" name="user_id">
<div class="form-group">
<label>Nama Lengkap *</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Email *</label>
<input type="email" name="email" required>
</div>
<div class="form-group">
<label>NRP *</label>
<input type="text" name="nrp" required>
</div>
<div class="form-group">
<label>No. Telepon *</label>
<input type="tel" name="phone" required>
</div>
<div class="form-group">
<label>Role *</label>
<select name="role" required>
<option value="user">User</option>
<option value="manager">Manager</option>
<option value="admin">Admin</option>
</select>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Update User</button>
</form>
</div>
</div>
</div>
<!-- Modal Add Category -->
<div id="addCategoryModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Tambah Kategori</h3>
<button class="close-btn" onclick="closeModal('addCategoryModal')">&times;</button>
</div>
<div class="modal-body">
<form id="addCategoryForm">
<div class="form-group">
<label>Nama Kategori *</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Deskripsi</label>
<textarea name="description"></textarea>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Tambah Kategori</button>
</form>
</div>
</div>
</div>
<!-- REFACTORED: Update script references -->
<script src="js/main.js"></script>
<script src="js/admin.js"></script>
</body>
</html>
<!-- web/index.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Lost & Found System</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary: #2563eb;
--primary-dark: #1e40af;
--secondary: #64748b;
--success: #10b981;
--danger: #ef4444;
--warning: #f59e0b;
--light: #f8fafc;
--dark: #1e293b;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
padding: 20px;
}
.container {
max-width: 1200px;
width: 100%;
}
.hero {
background: white;
border-radius: 20px;
box-shadow: 0 20px 60px rgba(0,0,0,0.3);
overflow: hidden;
}
.hero-header {
background: linear-gradient(135deg, var(--primary) 0%, var(--primary-dark) 100%);
color: white;
padding: 60px 40px;
text-align: center;
}
.hero-header h1 {
font-size: 3rem;
margin-bottom: 10px;
font-weight: 700;
}
.hero-header p {
font-size: 1.2rem;
opacity: 0.9;
}
.hero-body {
padding: 50px 40px;
}
.features {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 30px;
margin-bottom: 40px;
}
.feature-card {
background: var(--light);
padding: 30px;
border-radius: 15px;
text-align: center;
transition: transform 0.3s, box-shadow 0.3s;
}
.feature-card:hover {
transform: translateY(-5px);
box-shadow: 0 10px 30px rgba(0,0,0,0.1);
}
.feature-icon {
font-size: 3rem;
margin-bottom: 15px;
}
.feature-card h3 {
color: var(--dark);
margin-bottom: 10px;
font-size: 1.3rem;
}
.feature-card p {
color: var(--secondary);
line-height: 1.6;
}
.cta-section {
text-align: center;
padding: 40px 0;
}
.cta-buttons {
display: flex;
gap: 20px;
justify-content: center;
flex-wrap: wrap;
}
.btn {
padding: 15px 40px;
border: none;
border-radius: 10px;
font-size: 1.1rem;
font-weight: 600;
cursor: pointer;
transition: all 0.3s;
text-decoration: none;
display: inline-block;
}
.btn-primary {
background: var(--primary);
color: white;
}
.btn-primary:hover {
background: var(--primary-dark);
transform: translateY(-2px);
box-shadow: 0 10px 20px rgba(37, 99, 235, 0.3);
}
.btn-outline {
background: transparent;
color: var(--primary);
border: 2px solid var(--primary);
}
.btn-outline:hover {
background: var(--primary);
color: white;
}
.stats {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
gap: 20px;
margin-top: 50px;
padding: 40px;
background: var(--light);
border-radius: 15px;
}
.stat-item {
text-align: center;
}
.stat-number {
font-size: 2.5rem;
font-weight: 700;
color: var(--primary);
margin-bottom: 5px;
}
.stat-label {
color: var(--secondary);
font-size: 0.9rem;
}
@media (max-width: 768px) {
.hero-header h1 {
font-size: 2rem;
}
.hero-header p {
font-size: 1rem;
}
.hero-header, .hero-body {
padding: 40px 20px;
}
.features {
grid-template-columns: 1fr;
}
.cta-buttons {
flex-direction: column;
align-items: stretch;
}
.btn {
width: 100%;
}
}
.footer {
text-align: center;
padding: 30px;
color: white;
margin-top: 20px;
}
.footer p {
opacity: 0.8;
}
</style>
</head>
<body>
<div class="container">
<div class="hero">
<div class="hero-header">
<h1>🔍 Lost & Found System</h1>
<p>Sistem Manajemen Barang Hilang & Temuan Kampus</p>
</div>
<div class="hero-body">
<div class="features">
<div class="feature-card">
<div class="feature-icon">📢</div>
<h3>Lapor Kehilangan</h3>
<p>Laporkan barang yang hilang dengan mudah dan cepat</p>
</div>
<div class="feature-card">
<div class="feature-icon">📦</div>
<h3>Temukan Barang</h3>
<p>Cari barang temuanmu di database kami</p>
</div>
<div class="feature-card">
<div class="feature-icon">🤝</div>
<h3>Klaim Barang</h3>
<p>Proses klaim yang aman dengan verifikasi</p>
</div>
<div class="feature-card">
<div class="feature-icon">⚡</div>
<h3>Auto Matching</h3>
<p>Sistem otomatis mencocokkan barang hilang</p>
</div>
</div>
<div class="cta-section">
<h2 style="margin-bottom: 30px; color: var(--dark);">Mulai Sekarang</h2>
<div class="cta-buttons">
<a href="/login" class="btn btn-primary">🔐 Login</a>
<a href="/register" class="btn btn-outline">📝 Register</a>
</div>
</div>
<div class="stats">
<div class="stat-item">
<div class="stat-number" id="totalItems">0</div>
<div class="stat-label">Barang Ditemukan</div>
</div>
<div class="stat-item">
<div class="stat-number" id="totalClaimed">0</div>
<div class="stat-label">Sudah Diklaim</div>
</div>
<div class="stat-item">
<div class="stat-number" id="totalUsers">0</div>
<div class="stat-label">Pengguna Terdaftar</div>
</div>
</div>
</div>
</div>
<div class="footer">
<p>&copy; 2025 Lost & Found System. Built with Go & Love ❤️</p>
</div>
</div>
<script>
// Animasi counter
function animateCounter(id, target) {
const element = document.getElementById(id);
let current = 0;
const increment = target / 50;
const timer = setInterval(() => {
current += increment;
if (current >= target) {
element.textContent = target;
clearInterval(timer);
} else {
element.textContent = Math.floor(current);
}
}, 30);
}
// Simulasi data (nanti akan diganti dengan API call ke backend)
window.addEventListener('load', () => {
animateCounter('totalItems', 127);
animateCounter('totalClaimed', 89);
animateCounter('totalUsers', 234);
});
// Uncomment ini ketika backend sudah siap
/*
async function fetchStats() {
try {
const response = await fetch('http://localhost:8080/stats');
const data = await response.json();
document.getElementById('totalItems').textContent = data.total_items;
document.getElementById('totalClaimed').textContent = data.total_claimed;
document.getElementById('totalUsers').textContent = data.total_users;
} catch (error) {
console.error('Error fetching stats:', error);
}
}
fetchStats();
*/
</script>
</body>
</html>
<!-- web/login.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Login - Lost & Found</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary: #2563eb;
--primary-dark: #1e40af;
--danger: #ef4444;
--success: #10b981;
--light: #f8fafc;
--dark: #1e293b;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
padding: 20px;
}
.login-container {
background: white;
border-radius: 20px;
box-shadow: 0 20px 60px rgba(0,0,0,0.3);
overflow: hidden;
max-width: 450px;
width: 100%;
}
.login-header {
background: linear-gradient(135deg, var(--primary) 0%, var(--primary-dark) 100%);
color: white;
padding: 40px 30px;
text-align: center;
}
.login-header h1 {
font-size: 2rem;
margin-bottom: 10px;
}
.login-header p {
opacity: 0.9;
}
.login-body {
padding: 40px 30px;
}
.form-group {
margin-bottom: 25px;
}
.form-group label {
display: block;
margin-bottom: 8px;
color: var(--dark);
font-weight: 600;
}
.form-group input {
width: 100%;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
transition: border-color 0.3s;
}
.form-group input:focus {
outline: none;
border-color: var(--primary);
}
.form-group input.error {
border-color: var(--danger);
}
.error-message {
color: var(--danger);
font-size: 0.85rem;
margin-top: 5px;
display: none;
}
.error-message.show {
display: block;
}
.alert {
padding: 12px 15px;
border-radius: 10px;
margin-bottom: 20px;
display: none;
}
.alert.show {
display: block;
}
.alert-error {
background: #fee;
color: var(--danger);
border: 1px solid var(--danger);
}
.alert-success {
background: #efe;
color: var(--success);
border: 1px solid var(--success);
}
.btn-login {
width: 100%;
padding: 15px;
background: var(--primary);
color: white;
border: none;
border-radius: 10px;
font-size: 1.1rem;
font-weight: 600;
cursor: pointer;
transition: all 0.3s;
}
.btn-login:hover {
background: var(--primary-dark);
transform: translateY(-2px);
box-shadow: 0 10px 20px rgba(37, 99, 235, 0.3);
}
.btn-login:disabled {
background: #94a3b8;
cursor: not-allowed;
transform: none;
}
.divider {
text-align: center;
margin: 25px 0;
color: #64748b;
position: relative;
}
.divider::before,
.divider::after {
content: '';
position: absolute;
top: 50%;
width: 45%;
height: 1px;
background: #e2e8f0;
}
.divider::before {
left: 0;
}
.divider::after {
right: 0;
}
.register-link {
text-align: center;
margin-top: 20px;
}
.register-link a {
color: var(--primary);
text-decoration: none;
font-weight: 600;
}
.register-link a:hover {
text-decoration: underline;
}
.back-home {
text-align: center;
margin-top: 15px;
}
.back-home a {
color: #64748b;
text-decoration: none;
font-size: 0.9rem;
}
.back-home a:hover {
color: var(--primary);
}
.loading {
display: inline-block;
width: 20px;
height: 20px;
border: 3px solid rgba(255,255,255,.3);
border-radius: 50%;
border-top-color: white;
animation: spin 1s ease-in-out infinite;
}
@keyframes spin {
to { transform: rotate(360deg); }
}
@media (max-width: 768px) {
.login-container {
margin: 10px;
}
.login-header {
padding: 30px 20px;
}
.login-body {
padding: 30px 20px;
}
}
</style>
</head>
<body>
<div class="login-container">
<div class="login-header">
<h1>🔐 Login</h1>
<p>Masuk ke Lost & Found System</p>
</div>
<div class="login-body">
<div id="alertBox" class="alert"></div>
<form id="loginForm">
<div class="form-group">
<label for="email">Email</label>
<input type="email" id="email" name="email" placeholder="mahasiswa@example.com" required>
<div class="error-message" id="emailError">Email tidak valid</div>
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" id="password" name="password" placeholder="********" required>
<div class="error-message" id="passwordError">Password minimal 6 karakter</div>
</div>
<button type="submit" class="btn-login" id="loginBtn">
Login
</button>
</form>
<div class="divider">atau</div>
<div class="register-link">
<p>Belum punya akun? <a href="/register">Register disini</a></p>
</div>
<div class="back-home">
<a href="/">← Kembali ke Beranda</a>
</div>
</div>
</div>
<script>
const API_URL = 'http://localhost:8080/api';
const loginForm = document.getElementById('loginForm');
const emailInput = document.getElementById('email');
const passwordInput = document.getElementById('password');
const loginBtn = document.getElementById('loginBtn');
const alertBox = document.getElementById('alertBox');
// Validasi Email
function validateEmail(email) {
const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return re.test(email);
}
// Show Alert
function showAlert(message, type = 'error') {
alertBox.textContent = message;
alertBox.className = `alert alert-${type} show`;
setTimeout(() => {
alertBox.classList.remove('show');
}, 5000);
}
// Clear errors
function clearErrors() {
document.querySelectorAll('.error-message').forEach(el => {
el.classList.remove('show');
});
document.querySelectorAll('input').forEach(el => {
el.classList.remove('error');
});
}
// Form submit
loginForm.addEventListener('submit', async (e) => {
e.preventDefault();
clearErrors();
const email = emailInput.value.trim();
const password = passwordInput.value;
// Validasi frontend
let hasError = false;
if (!validateEmail(email)) {
emailInput.classList.add('error');
document.getElementById('emailError').classList.add('show');
hasError = true;
}
if (password.length < 6) {
passwordInput.classList.add('error');
document.getElementById('passwordError').classList.add('show');
hasError = true;
}
if (hasError) return;
// Disable button dan tampilkan loading
loginBtn.disabled = true;
loginBtn.innerHTML = '<span class="loading"></span> Logging in...';
try {
const response = await fetch(`${API_URL}/login`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ email, password })
});
const data = await response.json();
if (response.ok) {
console.log('Login response:', data); // DEBUG
// Simpan token dan user info
localStorage.setItem('token', data.data.token);
localStorage.setItem('user', JSON.stringify(data.data.user));
console.log('Token saved:', localStorage.getItem('token')); // DEBUG
console.log('User saved:', localStorage.getItem('user')); // DEBUG
showAlert('Login berhasil! Mengalihkan...', 'success');
setTimeout(() => {
const role = data.data.user.role;
console.log('Redirecting to:', role); // DEBUG
if (role === 'admin') {
window.location.href = '/admin';
} else if (role === 'manager') {
window.location.href = '/manager';
} else {
window.location.href = '/user';
}
}, 500);
} else {
showAlert(data.error || 'Email atau password salah!');
}
} catch (error) {
console.error('Login error:', error);
showAlert('Terjadi kesalahan. Pastikan server berjalan di port 8080');
} finally {
loginBtn.disabled = false;
loginBtn.textContent = 'Login';
}
});
// Check jika sudah login - FIXED: gunakan underscore
window.addEventListener('load', () => {
const token = localStorage.getItem('token');
const user = JSON.parse(localStorage.getItem('user') || '{}');
if (token && user.role) {
// Redirect ke dashboard sesuai role
if (user.role === 'admin') {
window.location.href = '/admin'; // ✅ FIXED
} else if (user.role === 'manager') {
window.location.href = '/manager'; // ✅ FIXED
} else {
window.location.href = '/user'; // ✅ FIXED
}
}
});
</script>
</body>
</html>
<!-- web/manager.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Dashboard Manager - Lost & Found</title>
<link rel="stylesheet" href="css/style.css">
</head>
<body>
<nav class="navbar">
<div class="navbar-brand">🔍 Lost & Found</div>
<div class="navbar-menu">
<div class="user-info">
<div class="user-avatar" id="userAvatar">M</div>
<span id="userName">Manager</span>
<span class="user-role">Manager</span>
</div>
<button class="btn-logout" onclick="logout()">Logout</button>
</div>
</nav>
<div class="container">
<div class="page-header">
<h1>Dashboard Manager</h1>
<p>Kelola barang temuan dan verifikasi klaim</p>
</div>
<div class="stats-grid">
<div class="stat-card">
<h3>Total Barang</h3>
<div class="stat-number" id="statTotalItems">0</div>
</div>
<div class="stat-card">
<h3>Pending Claim</h3>
<div class="stat-number stat-warning" id="statPendingClaims">0</div>
</div>
<div class="stat-card">
<h3>Verified</h3>
<div class="stat-number stat-success" id="statVerified">0</div>
</div>
<div class="stat-card">
<h3>Expired</h3>
<div class="stat-number stat-danger" id="statExpired">0</div>
</div>
</div>
<div class="tabs">
<button class="tab-btn active" onclick="switchTab('items')">📦 Kelola Barang</button>
<button class="tab-btn" onclick="switchTab('claims')">🤝 Verifikasi Klaim</button>
<button class="tab-btn" onclick="switchTab('lost')">😢 Barang Hilang</button>
<button class="tab-btn" onclick="switchTab('archive')">📂 Arsip</button>
</div>
<!-- Tab: Kelola Barang -->
<div id="itemsTab" class="tab-content active">
<div class="card">
<div class="card-header">
<h2 class="card-title">Daftar Barang Ditemukan</h2>
<button class="btn btn-primary" onclick="openReportFoundModal()">+ Tambah Barang</button>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari barang..." id="searchItems">
<select class="filter-select" id="categoryFilterItems">
<option value="">Semua Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
<select class="filter-select" id="statusFilterItems">
<option value="">Semua Status</option>
<option value="unclaimed">Unclaimed</option>
<option value="pending_claim">Pending Claim</option>
<option value="verified">Verified</option>
<option value="case_closed">Case Closed</option>
</select>
<select class="filter-select" id="sortItems">
<option value="date_desc">Terbaru</option>
<option value="date_asc">Terlama</option>
<option value="name_asc">Nama A-Z</option>
<option value="name_desc">Nama Z-A</option>
</select>
</div>
<div class="items-grid" id="itemsGrid"></div>
</div>
</div>
<!-- Tab: Verifikasi Klaim -->
<div id="claimsTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Daftar Klaim</h2>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari klaim..." id="searchClaims">
<select class="filter-select" id="statusFilterClaims">
<option value="">Semua Status</option>
<option value="pending">Pending</option>
<option value="approved">Approved</option>
<option value="rejected">Rejected</option>
</select>
</div>
<div class="claims-list" id="claimsList"></div>
</div>
</div>
<!-- Tab: Barang Hilang -->
<div id="lostTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Barang Hilang</h2>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari barang hilang..." id="searchLost">
<select class="filter-select" id="categoryFilterLost">
<option value="">Semua Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="items-grid" id="lostItemsGrid"></div>
</div>
</div>
<!-- Tab: Arsip -->
<div id="archiveTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Arsip Barang</h2>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari arsip..." id="searchArchive">
<select class="filter-select" id="categoryFilterArchive">
<option value="">Semua Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="items-grid" id="archiveGrid"></div>
</div>
</div>
</div>
<!-- Modal Report Found -->
<div id="reportFoundModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Tambah Barang Ditemukan</h3>
<button class="close-btn" onclick="closeModal('reportFoundModal')">&times;</button>
</div>
<div class="modal-body">
<form id="reportFoundForm">
<div class="form-group">
<label>Foto Barang *</label>
<input type="file" name="photo" accept="image/*" required>
</div>
<div class="form-group">
<label>Nama Barang *</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Kategori *</label>
<select name="category" required>
<option value="">Pilih Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="form-group">
<label>Lokasi Ditemukan *</label>
<input type="text" name="location" required>
</div>
<div class="form-group">
<label>Deskripsi Keunikan (Rahasia) *</label>
<textarea name="description" required placeholder="Ciri khusus untuk verifikasi..."></textarea>
</div>
<div class="form-group">
<label>Nama Pelapor *</label>
<input type="text" name="reporter_name" required>
</div>
<div class="form-group">
<label>Kontak Pelapor *</label>
<input type="text" name="reporter_contact" required>
</div>
<div class="form-group">
<label>Tanggal Ditemukan *</label>
<input type="date" name="date_found" required>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Submit</button>
</form>
</div>
</div>
</div>
<!-- Modal Detail Item -->
<div id="itemDetailModal" class="modal">
<div class="modal-content modal-large">
<div class="modal-header">
<h3 class="modal-title">Detail Barang</h3>
<button class="close-btn" onclick="closeModal('itemDetailModal')">&times;</button>
</div>
<div class="modal-body" id="itemDetailContent"></div>
</div>
</div>
<!-- Modal Verify Claim -->
<div id="verifyClaimModal" class="modal">
<div class="modal-content modal-large">
<div class="modal-header">
<h3 class="modal-title">Verifikasi Klaim</h3>
<button class="close-btn" onclick="closeModal('verifyClaimModal')">&times;</button>
</div>
<div class="modal-body" id="verifyClaimContent"></div>
</div>
</div>
<!-- Modal Match Items -->
<div id="matchItemsModal" class="modal">
<div class="modal-content modal-large">
<div class="modal-header">
<h3 class="modal-title">Cari Barang yang Mirip</h3>
<button class="close-btn" onclick="closeModal('matchItemsModal')">&times;</button>
</div>
<div class="modal-body" id="matchItemsContent"></div>
</div>
</div>
<script src="js/main.js"></script>
<script src="js/manager.js"></script>
</body>
</html>
<!-- web/register.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Register - Lost & Found</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary: #2563eb;
--primary-dark: #1e40af;
--danger: #ef4444;
--success: #10b981;
--warning: #f59e0b;
--light: #f8fafc;
--dark: #1e293b;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
min-height: 100vh;
display: flex;
align-items: center;
justify-content: center;
padding: 20px;
}
.register-container {
background: white;
border-radius: 20px;
box-shadow: 0 20px 60px rgba(0,0,0,0.3);
overflow: hidden;
max-width: 500px;
width: 100%;
margin: 20px auto;
}
.register-header {
background: linear-gradient(135deg, var(--primary) 0%, var(--primary-dark) 100%);
color: white;
padding: 40px 30px;
text-align: center;
}
.register-header h1 {
font-size: 2rem;
margin-bottom: 10px;
}
.register-header p {
opacity: 0.9;
}
.register-body {
padding: 40px 30px;
}
.form-group {
margin-bottom: 20px;
}
.form-group label {
display: block;
margin-bottom: 8px;
color: var(--dark);
font-weight: 600;
}
.form-group input,
.form-group select {
width: 100%;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
transition: border-color 0.3s;
}
.form-group input:focus,
.form-group select:focus {
outline: none;
border-color: var(--primary);
}
.form-group input.error,
.form-group select.error {
border-color: var(--danger);
}
.error-message {
color: var(--danger);
font-size: 0.85rem;
margin-top: 5px;
display: none;
}
.error-message.show {
display: block;
}
.alert {
padding: 12px 15px;
border-radius: 10px;
margin-bottom: 20px;
display: none;
}
.alert.show {
display: block;
}
.alert-error {
background: #fee;
color: var(--danger);
border: 1px solid var(--danger);
}
.alert-success {
background: #efe;
color: var(--success);
border: 1px solid var(--success);
}
.password-strength {
margin-top: 5px;
font-size: 0.85rem;
}
.strength-weak {
color: var(--danger);
}
.strength-medium {
color: var(--warning);
}
.strength-strong {
color: var(--success);
}
.btn-register {
width: 100%;
padding: 15px;
background: var(--primary);
color: white;
border: none;
border-radius: 10px;
font-size: 1.1rem;
font-weight: 600;
cursor: pointer;
transition: all 0.3s;
margin-top: 10px;
}
.btn-register:hover {
background: var(--primary-dark);
transform: translateY(-2px);
box-shadow: 0 10px 20px rgba(37, 99, 235, 0.3);
}
.btn-register:disabled {
background: #94a3b8;
cursor: not-allowed;
transform: none;
}
.divider {
text-align: center;
margin: 25px 0;
color: #64748b;
position: relative;
}
.divider::before,
.divider::after {
content: '';
position: absolute;
top: 50%;
width: 45%;
height: 1px;
background: #e2e8f0;
}
.divider::before {
left: 0;
}
.divider::after {
right: 0;
}
.login-link {
text-align: center;
margin-top: 20px;
}
.login-link a {
color: var(--primary);
text-decoration: none;
font-weight: 600;
}
.login-link a:hover {
text-decoration: underline;
}
.back-home {
text-align: center;
margin-top: 15px;
}
.back-home a {
color: #64748b;
text-decoration: none;
font-size: 0.9rem;
}
.back-home a:hover {
color: var(--primary);
}
.loading {
display: inline-block;
width: 20px;
height: 20px;
border: 3px solid rgba(255,255,255,.3);
border-radius: 50%;
border-top-color: white;
animation: spin 1s ease-in-out infinite;
}
@keyframes spin {
to { transform: rotate(360deg); }
}
.form-row {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 15px;
}
@media (max-width: 768px) {
.register-container {
margin: 10px;
}
.register-header {
padding: 30px 20px;
}
.register-body {
padding: 30px 20px;
}
.form-row {
grid-template-columns: 1fr;
}
}
</style>
</head>
<body>
<div class="register-container">
<div class="register-header">
<h1>🔐 Register</h1>
<p>Buat akun Lost & Found System</p>
</div>
<div class="register-body">
<div id="alertBox" class="alert"></div>
<form id="registerForm">
<div class="form-group">
<label for="name">Nama Lengkap</label>
<input type="text" id="name" name="name" placeholder="John Doe" required>
<div class="error-message" id="nameError">Nama minimal 3 karakter</div>
</div>
<div class="form-group">
<label for="email">Email</label>
<input type="email" id="email" name="email" placeholder="mahasiswa@example.com" required>
<div class="error-message" id="emailError">Email tidak valid</div>
</div>
<div class="form-row">
<div class="form-group">
<label for="nrp">NRP</label>
<input type="text" id="nrp" name="nrp" placeholder="5026211234" required>
<div class="error-message" id="nrpError">NRP minimal 10 digit</div>
</div>
<div class="form-group">
<label for="phone">No. Telepon</label>
<input type="tel" id="phone" name="phone" placeholder="08123456789" required>
<div class="error-message" id="phoneError">Nomor tidak valid</div>
</div>
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" id="password" name="password" placeholder="********" required>
<div class="password-strength" id="passwordStrength"></div>
<div class="error-message" id="passwordError">Password minimal 8 karakter</div>
</div>
<div class="form-group">
<label for="confirmPassword">Konfirmasi Password</label>
<input type="password" id="confirmPassword" name="confirmPassword" placeholder="********" required>
<div class="error-message" id="confirmPasswordError">Password tidak cocok</div>
</div>
<button type="submit" class="btn-register" id="registerBtn">
Register
</button>
</form>
<div class="divider">atau</div>
<div class="login-link">
<p>Sudah punya akun? <a href="/login">Login disini</a></p>
</div>
<div class="back-home">
<a href="/">← Kembali ke Beranda</a>
</div>
</div>
</div>
<script>
const API_URL = 'http://localhost:8080/api';
const registerForm = document.getElementById('registerForm');
const nameInput = document.getElementById('name');
const emailInput = document.getElementById('email');
const nrpInput = document.getElementById('nrp');
const phoneInput = document.getElementById('phone');
const passwordInput = document.getElementById('password');
const confirmPasswordInput = document.getElementById('confirmPassword');
const registerBtn = document.getElementById('registerBtn');
const alertBox = document.getElementById('alertBox');
// Validasi Email
function validateEmail(email) {
const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
return re.test(email);
}
// Validasi Phone
function validatePhone(phone) {
const re = /^(08|62)[0-9]{9,12}$/;
return re.test(phone);
}
// Check password strength
function checkPasswordStrength(password) {
const strengthEl = document.getElementById('passwordStrength');
let strength = 0;
if (password.length >= 8) strength++;
if (password.match(/[a-z]+/)) strength++;
if (password.match(/[A-Z]+/)) strength++;
if (password.match(/[0-9]+/)) strength++;
if (password.match(/[$@#&!]+/)) strength++;
if (password.length < 8) {
strengthEl.textContent = '';
strengthEl.className = 'password-strength';
} else if (strength <= 2) {
strengthEl.textContent = '⚠️ Password lemah';
strengthEl.className = 'password-strength strength-weak';
} else if (strength <= 4) {
strengthEl.textContent = '✓ Password sedang';
strengthEl.className = 'password-strength strength-medium';
} else {
strengthEl.textContent = '✓ Password kuat';
strengthEl.className = 'password-strength strength-strong';
}
}
// Show Alert
function showAlert(message, type = 'error') {
alertBox.textContent = message;
alertBox.className = `alert alert-${type} show`;
setTimeout(() => {
alertBox.classList.remove('show');
}, 5000);
}
// Clear errors
function clearErrors() {
document.querySelectorAll('.error-message').forEach(el => {
el.classList.remove('show');
});
document.querySelectorAll('input').forEach(el => {
el.classList.remove('error');
});
}
// Password strength checker
passwordInput.addEventListener('input', (e) => {
checkPasswordStrength(e.target.value);
});
// Form submit
registerForm.addEventListener('submit', async (e) => {
e.preventDefault();
clearErrors();
const name = nameInput.value.trim();
const email = emailInput.value.trim();
const nrp = nrpInput.value.trim();
const phone = phoneInput.value.trim();
const password = passwordInput.value;
const confirmPassword = confirmPasswordInput.value;
// Validasi frontend
let hasError = false;
if (name.length < 3) {
nameInput.classList.add('error');
document.getElementById('nameError').classList.add('show');
hasError = true;
}
if (!validateEmail(email)) {
emailInput.classList.add('error');
document.getElementById('emailError').classList.add('show');
hasError = true;
}
if (nrp.length < 10) {
nrpInput.classList.add('error');
document.getElementById('nrpError').classList.add('show');
hasError = true;
}
if (!validatePhone(phone)) {
phoneInput.classList.add('error');
document.getElementById('phoneError').classList.add('show');
hasError = true;
}
if (password.length < 8) {
passwordInput.classList.add('error');
document.getElementById('passwordError').classList.add('show');
hasError = true;
}
if (password !== confirmPassword) {
confirmPasswordInput.classList.add('error');
document.getElementById('confirmPasswordError').classList.add('show');
hasError = true;
}
if (hasError) return;
// Disable button dan tampilkan loading
registerBtn.disabled = true;
registerBtn.innerHTML = '<span class="loading"></span> Registering...';
try {
const response = await fetch(`${API_URL}/register`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
name,
email,
nrp,
phone,
password
})
});
const data = await response.json();
if (response.ok) {
showAlert('Registrasi berhasil! Mengalihkan ke login...', 'success');
setTimeout(() => {
window.location.href = '/login';
}, 2000);
} else {
showAlert(data.error || 'Registrasi gagal!');
}
} catch (error) {
console.error('Register error:', error);
showAlert('Terjadi kesalahan. Pastikan server berjalan di port 8080');
} finally {
registerBtn.disabled = false;
registerBtn.textContent = 'Register';
}
});
// Check jika sudah login - REFACTORED: URL lebih simple
window.addEventListener('load', () => {
const token = localStorage.getItem('token');
const user = JSON.parse(localStorage.getItem('user') || '{}');
if (token && user.role) {
// Redirect ke dashboard sesuai role
if (user.role === 'admin') {
window.location.href = '/admin'; // ✅ REFACTORED
} else if (user.role === 'manager') {
window.location.href = '/manager'; // ✅ REFACTORED
} else {
window.location.href = '/user'; // ✅ REFACTORED
}
}
});
</script>
</body>
</html>
<!-- web/user.html -->
<!DOCTYPE html>
<html lang="id">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Dashboard User - Lost & Found</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary: #2563eb;
--primary-dark: #1e40af;
--danger: #ef4444;
--success: #10b981;
--warning: #f59e0b;
--light: #f8fafc;
--dark: #1e293b;
--secondary: #64748b;
}
body {
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
background: #f1f5f9;
}
.navbar {
background: white;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
padding: 15px 30px;
display: flex;
justify-content: space-between;
align-items: center;
position: sticky;
top: 0;
z-index: 100;
}
.navbar-brand {
font-size: 1.5rem;
font-weight: 700;
color: var(--primary);
}
.navbar-menu {
display: flex;
gap: 20px;
align-items: center;
}
.nav-link {
text-decoration: none;
color: var(--dark);
font-weight: 500;
padding: 8px 15px;
border-radius: 8px;
transition: all 0.3s;
}
.nav-link:hover {
background: var(--light);
color: var(--primary);
}
.user-info {
display: flex;
align-items: center;
gap: 10px;
}
.user-avatar {
width: 40px;
height: 40px;
border-radius: 50%;
background: var(--primary);
color: white;
display: flex;
align-items: center;
justify-content: center;
font-weight: 600;
}
.btn-logout {
background: var(--danger);
color: white;
border: none;
padding: 8px 20px;
border-radius: 8px;
cursor: pointer;
font-weight: 600;
transition: all 0.3s;
}
.btn-logout:hover {
background: #dc2626;
}
.container {
max-width: 1200px;
margin: 30px auto;
padding: 0 20px;
}
.page-header {
margin-bottom: 30px;
}
.page-header h1 {
color: var(--dark);
font-size: 2rem;
margin-bottom: 10px;
}
.tabs {
display: flex;
gap: 10px;
margin-bottom: 30px;
flex-wrap: wrap;
}
.tab-btn {
padding: 12px 25px;
background: white;
border: 2px solid #e2e8f0;
border-radius: 10px;
cursor: pointer;
font-weight: 600;
color: var(--secondary);
transition: all 0.3s;
}
.tab-btn.active {
background: var(--primary);
color: white;
border-color: var(--primary);
}
.tab-content {
display: none;
}
.tab-content.active {
display: block;
}
.stats-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 20px;
margin-bottom: 30px;
}
.stat-card {
background: white;
padding: 25px;
border-radius: 15px;
box-shadow: 0 2px 10px rgba(0,0,0,0.05);
}
.stat-card h3 {
color: var(--secondary);
font-size: 0.9rem;
margin-bottom: 10px;
}
.stat-number {
font-size: 2.5rem;
font-weight: 700;
color: var(--primary);
}
.card {
background: white;
border-radius: 15px;
padding: 25px;
box-shadow: 0 2px 10px rgba(0,0,0,0.05);
margin-bottom: 20px;
}
.card-header {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 20px;
}
.card-title {
font-size: 1.3rem;
color: var(--dark);
font-weight: 600;
}
.btn {
padding: 10px 20px;
border: none;
border-radius: 8px;
font-weight: 600;
cursor: pointer;
transition: all 0.3s;
}
.btn-primary {
background: var(--primary);
color: white;
}
.btn-primary:hover {
background: var(--primary-dark);
}
.search-box {
display: flex;
gap: 10px;
margin-bottom: 20px;
}
.search-input {
flex: 1;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
.search-input:focus {
outline: none;
border-color: var(--primary);
}
.filter-select {
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
.items-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
gap: 20px;
}
.item-card {
background: white;
border: 2px solid #e2e8f0;
border-radius: 15px;
overflow: hidden;
transition: all 0.3s;
cursor: pointer;
}
.item-card:hover {
transform: translateY(-5px);
box-shadow: 0 10px 25px rgba(0,0,0,0.1);
}
.item-image {
width: 100%;
height: 200px;
object-fit: cover;
background: var(--light);
}
.item-body {
padding: 15px;
}
.item-title {
font-size: 1.1rem;
font-weight: 600;
color: var(--dark);
margin-bottom: 8px;
}
.item-meta {
display: flex;
flex-direction: column;
gap: 5px;
color: var(--secondary);
font-size: 0.9rem;
margin-bottom: 10px;
}
.badge {
display: inline-block;
padding: 5px 12px;
border-radius: 20px;
font-size: 0.85rem;
font-weight: 600;
}
.badge-success {
background: #d1fae5;
color: var(--success);
}
.badge-warning {
background: #fef3c7;
color: var(--warning);
}
.badge-danger {
background: #fee2e2;
color: var(--danger);
}
.badge-primary {
background: #dbeafe;
color: var(--primary);
}
.modal {
display: none;
position: fixed;
z-index: 1000;
left: 0;
top: 0;
width: 100%;
height: 100%;
background: rgba(0,0,0,0.5);
animation: fadeIn 0.3s;
}
.modal.active {
display: flex;
align-items: center;
justify-content: center;
}
.modal-content {
background: white;
border-radius: 20px;
max-width: 600px;
width: 90%;
max-height: 90vh;
overflow-y: auto;
animation: slideUp 0.3s;
}
.modal-header {
padding: 25px;
border-bottom: 1px solid #e2e8f0;
display: flex;
justify-content: space-between;
align-items: center;
}
.modal-title {
font-size: 1.5rem;
font-weight: 600;
}
.close-btn {
background: none;
border: none;
font-size: 1.5rem;
cursor: pointer;
color: var(--secondary);
}
.modal-body {
padding: 25px;
}
.form-group {
margin-bottom: 20px;
}
.form-group label {
display: block;
margin-bottom: 8px;
font-weight: 600;
color: var(--dark);
}
.form-group input,
.form-group textarea,
.form-group select {
width: 100%;
padding: 12px 15px;
border: 2px solid #e2e8f0;
border-radius: 10px;
font-size: 1rem;
}
.form-group textarea {
resize: vertical;
min-height: 100px;
}
.empty-state {
text-align: center;
padding: 60px 20px;
color: var(--secondary);
}
.empty-state-icon {
font-size: 4rem;
margin-bottom: 20px;
}
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
@keyframes slideUp {
from {
transform: translateY(50px);
opacity: 0;
}
to {
transform: translateY(0);
opacity: 1;
}
}
@media (max-width: 768px) {
.navbar {
flex-direction: column;
gap: 15px;
}
.navbar-menu {
flex-direction: column;
width: 100%;
}
.items-grid {
grid-template-columns: 1fr;
}
}
</style>
</head>
<body>
<nav class="navbar">
<div class="navbar-brand">🔍 Lost & Found</div>
<div class="navbar-menu">
<div class="user-info">
<div class="user-avatar" id="userAvatar">U</div>
<span id="userName">User</span>
</div>
<button class="btn-logout" onclick="logout()">Logout</button>
</div>
</nav>
<div class="container">
<div class="page-header">
<h1>Dashboard User</h1>
<p>Selamat datang di Lost & Found System</p>
</div>
<div class="stats-grid">
<div class="stat-card">
<h3>Barang Hilang Saya</h3>
<div class="stat-number" id="statLost">0</div>
</div>
<div class="stat-card">
<h3>Barang yang Saya Temukan</h3>
<div class="stat-number" id="statFound">0</div>
</div>
<div class="stat-card">
<h3>Klaim Saya</h3>
<div class="stat-number" id="statClaims">0</div>
</div>
</div>
<div class="tabs">
<button class="tab-btn active" onclick="switchTab('browse')">📦 Cari Barang</button>
<button class="tab-btn" onclick="switchTab('lost')">😢 Barang Hilang Saya</button>
<button class="tab-btn" onclick="switchTab('found')">🎉 Barang yang Saya Temukan</button>
<button class="tab-btn" onclick="switchTab('claims')">🤝 Riwayat Klaim</button>
</div>
<!-- Tab: Browse Items -->
<div id="browseTab" class="tab-content active">
<div class="card">
<div class="card-header">
<h2 class="card-title">Barang Ditemukan</h2>
</div>
<div class="search-box">
<input type="text" class="search-input" placeholder="Cari barang..." id="searchInput">
<select class="filter-select" id="categoryFilter">
<option value="">Semua Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
<select class="filter-select" id="sortBy">
<option value="date_desc">Terbaru</option>
<option value="date_asc">Terlama</option>
<option value="name_asc">Nama A-Z</option>
<option value="name_desc">Nama Z-A</option>
</select>
</div>
<div class="items-grid" id="itemsGrid"></div>
</div>
</div>
<!-- Tab: My Lost Items -->
<div id="lostTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Barang Hilang Saya</h2>
<button class="btn btn-primary" onclick="openReportLostModal()">+ Lapor Kehilangan</button>
</div>
<div class="items-grid" id="lostItemsGrid"></div>
</div>
</div>
<!-- Tab: My Found Items -->
<div id="foundTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Barang yang Saya Temukan</h2>
<button class="btn btn-primary" onclick="openReportFoundModal()">+ Lapor Penemuan</button>
</div>
<div class="items-grid" id="foundItemsGrid"></div>
</div>
</div>
<!-- Tab: My Claims -->
<div id="claimsTab" class="tab-content">
<div class="card">
<div class="card-header">
<h2 class="card-title">Riwayat Klaim</h2>
</div>
<div class="items-grid" id="claimsGrid"></div>
</div>
</div>
</div>
<!-- Modal Report Lost -->
<div id="reportLostModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Lapor Barang Hilang</h3>
<button class="close-btn" onclick="closeModal('reportLostModal')">&times;</button>
</div>
<div class="modal-body">
<form id="reportLostForm">
<div class="form-group">
<label>Nama Barang</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Kategori</label>
<select name="category" required>
<option value="">Pilih Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="form-group">
<label>Warna</label>
<input type="text" name="color" required>
</div>
<div class="form-group">
<label>Lokasi Hilang (Opsional)</label>
<input type="text" name="location">
</div>
<div class="form-group">
<label>Deskripsi</label>
<textarea name="description" required></textarea>
</div>
<div class="form-group">
<label>Tanggal Hilang</label>
<input type="date" name="date_lost" required>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Submit Laporan</button>
</form>
</div>
</div>
</div>
<!-- Modal Report Found -->
<div id="reportFoundModal" class="modal">
<div class="modal-content">
<div class="modal-header">
<h3 class="modal-title">Lapor Penemuan Barang</h3>
<button class="close-btn" onclick="closeModal('reportFoundModal')">&times;</button>
</div>
<div class="modal-body">
<form id="reportFoundForm">
<div class="form-group">
<label>Foto Barang</label>
<input type="file" name="photo" accept="image/*" required>
</div>
<div class="form-group">
<label>Nama Barang</label>
<input type="text" name="name" required>
</div>
<div class="form-group">
<label>Kategori</label>
<select name="category" required>
<option value="">Pilih Kategori</option>
<option value="pakaian">Pakaian</option>
<option value="alat_makan">Alat Makan</option>
<option value="aksesoris">Aksesoris</option>
<option value="elektronik">Elektronik</option>
<option value="alat_tulis">Alat Tulis</option>
<option value="lainnya">Lainnya</option>
</select>
</div>
<div class="form-group">
<label>Lokasi Ditemukan</label>
<input type="text" name="location" required>
</div>
<div class="form-group">
<label>Deskripsi Keunikan (Rahasia untuk Verifikasi)</label>
<textarea name="description" required placeholder="Ciri khusus yang hanya pemilik tahu..."></textarea>
</div>
<div class="form-group">
<label>Tanggal Ditemukan</label>
<input type="date" name="date_found" required>
</div>
<button type="submit" class="btn btn-primary" style="width: 100%;">Submit Penemuan</button>
</form>
</div>
</div>
</div>
<script src="js/main.js"></script>
<script src="js/user.js"></script>
</body>
</html>
# .env
# Server Configuration
PORT=8080
ENVIRONMENT=development
# Database Configuration (MySQL/MariaDB)
DB_HOST=localhost
DB_PORT=3306
DB_USER=root
DB_PASSWORD=
DB_NAME=lost_and_found
DB_CHARSET=utf8mb4
DB_PARSE_TIME=True
DB_LOC=Local
# JWT Configuration
JWT_SECRET_KEY=L0stF0und$ecureK3y2024!@#M4h4s1sw4UAS*Pr0j3ct&BackendD3v
# Upload Configuration
UPLOAD_PATH=./uploads
MAX_UPLOAD_SIZE=10485760
# CORS Configuration
ALLOWED_ORIGINS=*
// go.mod
module lost-and-found
go 1.25.0
require (
github.com/gin-gonic/gin v1.11.0
github.com/go-playground/validator/v10 v10.28.0
github.com/golang-jwt/jwt/v5 v5.3.0
github.com/joho/godotenv v1.5.1
github.com/jung-kurt/gofpdf v1.16.2
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646
github.com/xuri/excelize/v2 v2.10.0
golang.org/x/crypto v0.44.0
gorm.io/driver/mysql v1.6.0
gorm.io/gorm v1.31.1
)
require (
filippo.io/edwards25519 v1.1.0 // indirect
github.com/bytedance/sonic v1.14.0 // indirect
github.com/bytedance/sonic/loader v0.3.0 // indirect
github.com/cloudwego/base64x v0.1.6 // indirect
github.com/gabriel-vasile/mimetype v1.4.10 // indirect
github.com/gin-contrib/sse v1.1.0 // indirect
github.com/go-playground/locales v0.14.1 // indirect
github.com/go-playground/universal-translator v0.18.1 // indirect
github.com/go-sql-driver/mysql v1.8.1 // indirect
github.com/goccy/go-json v0.10.2 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
github.com/json-iterator/go v1.1.12 // indirect
github.com/klauspost/cpuid/v2 v2.3.0 // indirect
github.com/leodido/go-urn v1.4.0 // indirect
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/quic-go/qpack v0.5.1 // indirect
github.com/quic-go/quic-go v0.54.0 // indirect
github.com/richardlehane/mscfb v1.0.4 // indirect
github.com/richardlehane/msoleps v1.0.4 // indirect
github.com/tiendc/go-deepcopy v1.7.1 // indirect
github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
github.com/ugorji/go/codec v1.3.0 // indirect
github.com/xuri/efp v0.0.1 // indirect
github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 // indirect
go.uber.org/mock v0.5.0 // indirect
golang.org/x/arch v0.20.0 // indirect
golang.org/x/mod v0.29.0 // indirect
golang.org/x/net v0.46.0 // indirect
golang.org/x/sync v0.18.0 // indirect
golang.org/x/sys v0.38.0 // indirect
golang.org/x/text v0.31.0 // indirect
golang.org/x/tools v0.38.0 // indirect
google.golang.org/protobuf v1.36.9 // indirect
)
filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
github.com/boombuler/barcode v1.0.0/go.mod h1:paBWMcWSl3LHKBqUq+rly7CNSldXjb2rDl3JlRe0mD8=
github.com/bytedance/sonic v1.14.0 h1:/OfKt8HFw0kh2rj8N0F6C/qPGRESq0BbaNZgcNXXzQQ=
github.com/bytedance/sonic v1.14.0/go.mod h1:WoEbx8WTcFJfzCe0hbmyTGrfjt8PzNEBdxlNUO24NhA=
github.com/bytedance/sonic/loader v0.3.0 h1:dskwH8edlzNMctoruo8FPTJDF3vLtDT0sXZwvZJyqeA=
github.com/bytedance/sonic/loader v0.3.0/go.mod h1:N8A3vUdtUebEY2/VQC0MyhYeKUFosQU6FxH2JmUe6VI=
github.com/cloudwego/base64x v0.1.6 h1:t11wG9AECkCDk5fMSoxmufanudBtJ+/HemLstXDLI2M=
github.com/cloudwego/base64x v0.1.6/go.mod h1:OFcloc187FXDaYHvrNIjxSe8ncn0OOM8gEHfghB2IPU=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/gabriel-vasile/mimetype v1.4.10 h1:zyueNbySn/z8mJZHLt6IPw0KoZsiQNszIpU+bX4+ZK0=
github.com/gabriel-vasile/mimetype v1.4.10/go.mod h1:d+9Oxyo1wTzWdyVUPMmXFvp4F9tea18J8ufA774AB3s=
github.com/gin-contrib/sse v1.1.0 h1:n0w2GMuUpWDVp7qSpvze6fAu9iRxJY4Hmj6AmBOU05w=
github.com/gin-contrib/sse v1.1.0/go.mod h1:hxRZ5gVpWMT7Z0B0gSNYqqsSCNIJMjzvm6fqCz9vjwM=
github.com/gin-gonic/gin v1.11.0 h1:OW/6PLjyusp2PPXtyxKHU0RbX6I/l28FTdDlae5ueWk=
github.com/gin-gonic/gin v1.11.0/go.mod h1:+iq/FyxlGzII0KHiBGjuNn4UNENUlKbGlNmc+W50Dls=
github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.28.0 h1:Q7ibns33JjyW48gHkuFT91qX48KG0ktULL6FgHdG688=
github.com/go-playground/validator/v10 v10.28.0/go.mod h1:GoI6I1SjPBh9p7ykNE/yj3fFYbyDOpwMn5KXd+m2hUU=
github.com/go-sql-driver/mysql v1.8.1 h1:LedoTUt/eveggdHS9qUFC1EFSa8bU2+1pZjSRpvNJ1Y=
github.com/go-sql-driver/mysql v1.8.1/go.mod h1:wEBSXgmK//2ZFJyE+qWnIsVGmvmEKlqwuVSjsCm7DZg=
github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
github.com/goccy/go-yaml v1.18.0/go.mod h1:XBurs7gK8ATbW4ZPGKgcbrY1Br56PdM69F7LkFRi1kA=
github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jung-kurt/gofpdf v1.0.0/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
github.com/jung-kurt/gofpdf v1.16.2 h1:jgbatWHfRlPYiK85qgevsZTHviWXKwB1TTiKdz5PtRc=
github.com/jung-kurt/gofpdf v1.16.2/go.mod h1:1hl7y57EsiPAkLbOwzpzqgx1A30nQCk/YmFV8S2vmK0=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OHLH3mGKHDcjJRFFRrJa6eAM5H+CtDdOsPc=
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646 h1:zYyBkD/k9seD2A7fsi6Oo2LfFZAehjjQMERAvZLEDnQ=
github.com/nfnt/resize v0.0.0-20180221191011-83c6a9932646/go.mod h1:jpp1/29i3P1S/RLdc7JQKbRpFeM1dOBd8T9ki5s+AY8=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
github.com/phpdave11/gofpdi v1.0.7/go.mod h1:vBmVV0Do6hSBHC8uKUQ71JGW+ZGQq74llk/7bXwjDoI=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
github.com/richardlehane/mscfb v1.0.4 h1:WULscsljNPConisD5hR0+OyZjwK46Pfyr6mPu5ZawpM=
github.com/richardlehane/mscfb v1.0.4/go.mod h1:YzVpcZg9czvAuhk9T+a3avCpcFPMUWm7gK3DypaEsUk=
github.com/richardlehane/msoleps v1.0.1/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
github.com/richardlehane/msoleps v1.0.4 h1:WuESlvhX3gH2IHcd8UqyCuFY5yiq/GR/yqaSM/9/g00=
github.com/richardlehane/msoleps v1.0.4/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
github.com/ruudk/golang-pdf417 v0.0.0-20181029194003-1af4ab5afa58/go.mod h1:6lfFZQK844Gfx8o5WFuvpxWRwnSoipWe/p622j1v06w=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
github.com/tiendc/go-deepcopy v1.7.1 h1:LnubftI6nYaaMOcaz0LphzwraqN8jiWTwm416sitff4=
github.com/tiendc/go-deepcopy v1.7.1/go.mod h1:4bKjNC2r7boYOkD2IOuZpYjmlDdzjbpTRyCx+goBCJQ=
github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
github.com/ugorji/go/codec v1.3.0 h1:Qd2W2sQawAfG8XSvzwhBeoGq71zXOC/Q1E9y/wUcsUA=
github.com/ugorji/go/codec v1.3.0/go.mod h1:pRBVtBSKl77K30Bv8R2P+cLSGaTtex6fsA2Wjqmfxj4=
github.com/xuri/efp v0.0.1 h1:fws5Rv3myXyYni8uwj2qKjVaRP30PdjeYe2Y6FDsCL8=
github.com/xuri/efp v0.0.1/go.mod h1:ybY/Jr0T0GTCnYjKqmdwxyxn2BQf2RcQIIvex5QldPI=
github.com/xuri/excelize/v2 v2.10.0 h1:8aKsP7JD39iKLc6dH5Tw3dgV3sPRh8uRVXu/fMstfW4=
github.com/xuri/excelize/v2 v2.10.0/go.mod h1:SC5TzhQkaOsTWpANfm+7bJCldzcnU/jrhqkTi/iBHBU=
github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9 h1:+C0TIdyyYmzadGaL/HBLbf3WdLgC29pgyhTjAT/0nuE=
github.com/xuri/nfp v0.0.2-0.20250530014748-2ddeb826f9a9/go.mod h1:WwHg+CVyzlv/TX9xqBFXEZAuxOPxn2k1GNHwG41IIUQ=
go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
golang.org/x/crypto v0.44.0 h1:A97SsFvM3AIwEEmTBiaxPPTYpDC47w720rdiiUvgoAU=
golang.org/x/crypto v0.44.0/go.mod h1:013i+Nw79BMiQiMsOPcVCB5ZIJbYkerPrGnOa00tvmc=
golang.org/x/image v0.0.0-20190910094157-69e4b8554b2a/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
golang.org/x/image v0.25.0 h1:Y6uW6rH1y5y/LK1J8BPWZtr6yZ7hrsy6hFrXjgsc2fQ=
golang.org/x/image v0.25.0/go.mod h1:tCAmOEGthTtkalusGp1g3xa2gke8J6c2N565dTyl9Rs=
golang.org/x/mod v0.29.0 h1:HV8lRxZC4l2cr3Zq1LvtOsi/ThTgWnUk/y64QSs8GwA=
golang.org/x/mod v0.29.0/go.mod h1:NyhrlYXJ2H4eJiRy/WDBO6HMqZQ6q9nk4JzS3NuCK+w=
golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
golang.org/x/tools v0.38.0 h1:Hx2Xv8hISq8Lm16jvBZ2VQf+RLmbd7wVUsALibYI/IQ=
golang.org/x/tools v0.38.0/go.mod h1:yEsQ/d/YK8cjh0L6rZlY8tgtlKiBNTL14pGDJPJpYQs=
google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/driver/mysql v1.6.0 h1:eNbLmNTpPpTOVZi8MMxCi2aaIm0ZpInbORNXDwyLGvg=
gorm.io/driver/mysql v1.6.0/go.mod h1:D/oCC2GWK3M/dqoLxnOlaNKmXz8WNTfcS9y5ovaSqKo=
gorm.io/gorm v1.31.1 h1:7CA8FTFz/gRfgqgpeKIBcervUn3xSyPUmr6B2WXJ7kg=
gorm.io/gorm v1.31.1/go.mod h1:XyQVbO2k6YkOis7C2437jSit3SsDK72s7n7rsSHd+Gs=
Reference in New Issue View Git Blame Copy Permalink