productstock

internal/database/migrations/20251030134527_recreate_project_chikins_table.up.sql

@@ -29,7 +29,7 @@ ADD CONSTRAINT fk_project_chickins_kandang FOREIGN KEY (project_flock_kandang_id
 
 -- Relasi ke product_warehouses
 ALTER TABLE project_chickins
-ADD CONSTRAINT fk_project_chickins_warehouse FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses (id) ON DELETE RESTRICT ON UPDATE CASCADE;
+ADD CONSTRAINT fk_project_chickins_warehouse FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses (id) ON DELETE CASCADE ON UPDATE CASCADE;
 
 -- Relasi ke users
 ALTER TABLE project_chickins

internal/database/migrations/20251224033033_create_payment_table.down.sql

@@ -0,0 +1,3 @@
+DROP INDEX IF EXISTS idx_payments_bank_id;
+DROP INDEX IF EXISTS payments_party_polymorphic;
+DROP TABLE IF EXISTS payments;

internal/database/migrations/20251224033033_create_payment_table.up.sql

@@ -0,0 +1,22 @@
+CREATE TABLE IF NOT EXISTS payments (
+    id BIGSERIAL PRIMARY KEY,
+    payment_code VARCHAR(50) NOT NULL,
+    reference_number VARCHAR(100) NULL,
+    transaction_type VARCHAR(50),
+    party_type VARCHAR(50) NOT NULL,
+    party_id BIGINT NOT NULL,
+    payment_date TIMESTAMPTZ NOT NULL,
+    payment_method VARCHAR(20) NOT NULL,
+    bank_id BIGINT NULL REFERENCES banks(id) ON DELETE RESTRICT ON UPDATE CASCADE,
+    direction VARCHAR(5) NOT NULL,
+    nominal NUMERIC(15, 3) NOT NULL,
+    notes TEXT NOT NULL,
+    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+    deleted_at TIMESTAMPTZ NULL,
+    created_by BIGINT REFERENCES users (id) ON DELETE SET NULL ON UPDATE CASCADE
+);
+
+-- Indexes
+CREATE INDEX payments_party_polymorphic ON payments (party_type, party_id);
+CREATE INDEX idx_payments_bank_id ON payments (bank_id);

internal/database/migrations/20251224043019_add_soft_delete_fk_triggers.down.sql

@@ -0,0 +1,18 @@
+DO $$
+DECLARE
+    r record;
+    trigger_name text;
+BEGIN
+    FOR r IN
+        SELECT table_schema, table_name
+        FROM information_schema.columns
+        WHERE column_name = 'deleted_at'
+          AND table_schema = 'public'
+        GROUP BY table_schema, table_name
+    LOOP
+        trigger_name := format('trg_soft_delete_fk_%s', r.table_name);
+        EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I.%I', trigger_name, r.table_schema, r.table_name);
+    END LOOP;
+END $$;
+
+DROP FUNCTION IF EXISTS soft_delete_handle_fk();

internal/database/migrations/20251224043019_add_soft_delete_fk_triggers.up.sql

@@ -0,0 +1,126 @@
+CREATE OR REPLACE FUNCTION soft_delete_handle_fk() RETURNS TRIGGER AS $$
+DECLARE
+    fk record;
+    child_column text;
+    parent_column text;
+    parent_value text;
+    child_has_deleted_at boolean;
+    ref_exists boolean;
+    sql text;
+BEGIN
+    IF OLD.deleted_at IS NULL AND NEW.deleted_at IS NOT NULL THEN
+        FOR fk IN
+            SELECT conrelid::regclass AS child_table,
+                   conkey AS child_cols,
+                   confkey AS parent_cols,
+                   confdeltype
+            FROM pg_constraint
+            WHERE contype = 'f'
+              AND confrelid = TG_RELID
+        LOOP
+            IF array_length(fk.child_cols, 1) IS DISTINCT FROM 1
+                OR array_length(fk.parent_cols, 1) IS DISTINCT FROM 1 THEN
+                RAISE NOTICE 'soft_delete_handle_fk skipped composite fk on %', fk.child_table;
+                CONTINUE;
+            END IF;
+
+            SELECT attname INTO child_column
+            FROM pg_attribute
+            WHERE attrelid = fk.child_table
+              AND attnum = fk.child_cols[1]
+              AND NOT attisdropped;
+
+            SELECT attname INTO parent_column
+            FROM pg_attribute
+            WHERE attrelid = TG_RELID
+              AND attnum = fk.parent_cols[1]
+              AND NOT attisdropped;
+
+            EXECUTE format('SELECT ($1).%I', parent_column)
+                INTO parent_value
+                USING OLD;
+
+            SELECT EXISTS (
+                SELECT 1
+                FROM pg_attribute
+                WHERE attrelid = fk.child_table
+                  AND attname = 'deleted_at'
+                  AND NOT attisdropped
+            ) INTO child_has_deleted_at;
+
+            IF fk.confdeltype IN ('r', 'a') THEN
+                sql := format(
+                    'SELECT EXISTS (SELECT 1 FROM %s WHERE %I = $1 %s)',
+                    fk.child_table,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql INTO ref_exists USING parent_value;
+                IF ref_exists THEN
+                    RAISE EXCEPTION 'Cannot soft delete %, still referenced by %',
+                        TG_TABLE_NAME, fk.child_table;
+                END IF;
+            ELSIF fk.confdeltype = 'n' THEN
+                sql := format(
+                    'UPDATE %s SET %I = NULL WHERE %I = $1 %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            ELSIF fk.confdeltype = 'c' THEN
+                IF child_has_deleted_at THEN
+                    sql := format(
+                        'UPDATE %s SET deleted_at = NOW() WHERE %I = $1 AND deleted_at IS NULL',
+                        fk.child_table,
+                        child_column
+                    );
+                    EXECUTE sql USING parent_value;
+                ELSE
+                    sql := format(
+                        'DELETE FROM %s WHERE %I = $1',
+                        fk.child_table,
+                        child_column
+                    );
+                    EXECUTE sql USING parent_value;
+                END IF;
+            ELSIF fk.confdeltype = 'd' THEN
+                sql := format(
+                    'UPDATE %s SET %I = DEFAULT WHERE %I = $1 %s',
+                    fk.child_table,
+                    child_column,
+                    child_column,
+                    CASE WHEN child_has_deleted_at THEN 'AND deleted_at IS NULL' ELSE '' END
+                );
+                EXECUTE sql USING parent_value;
+            END IF;
+        END LOOP;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+DO $$
+DECLARE
+    r record;
+    trigger_name text;
+BEGIN
+    FOR r IN
+        SELECT table_schema, table_name
+        FROM information_schema.columns
+        WHERE column_name = 'deleted_at'
+          AND table_schema = 'public'
+        GROUP BY table_schema, table_name
+    LOOP
+        trigger_name := format('trg_soft_delete_fk_%s', r.table_name);
+        EXECUTE format('DROP TRIGGER IF EXISTS %I ON %I.%I', trigger_name, r.table_schema, r.table_name);
+        EXECUTE format(
+            'CREATE TRIGGER %I BEFORE UPDATE OF deleted_at ON %I.%I FOR EACH ROW EXECUTE FUNCTION soft_delete_handle_fk()',
+            trigger_name,
+            r.table_schema,
+            r.table_name
+        );
+    END LOOP;
+END $$;

internal/database/migrations/20251224130000_create_payment_code_sequence.down.sql

@@ -0,0 +1 @@
+DROP SEQUENCE IF EXISTS payments_code_seq;

internal/database/migrations/20251224130000_create_payment_code_sequence.up.sql

@@ -0,0 +1 @@
+CREATE SEQUENCE IF NOT EXISTS payments_code_seq START WITH 1 INCREMENT BY 1;

internal/database/migrations/20251227100000_update_expense_table.down.sql

@@ -0,0 +1,24 @@
+-- Rollback: Update expense and expense_nonstocks tables
+
+-- Drop indexes
+DROP INDEX IF EXISTS idx_expenses_project_flock_id;
+DROP INDEX IF EXISTS idx_expenses_location_id;
+
+-- Drop Foreign Key constraint
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_expenses_location_id'
+    ) THEN
+        ALTER TABLE expenses
+            DROP CONSTRAINT fk_expenses_location_id;
+    END IF;
+END $$;
+
+-- Drop columns from expenses table
+ALTER TABLE expenses
+DROP COLUMN IF EXISTS project_flock_id;
+
+ALTER TABLE expenses
+DROP COLUMN IF EXISTS location_id;

internal/database/migrations/20251227100000_update_expense_table.up.sql

@@ -0,0 +1,29 @@
+-- Migration: Update expense and expense_nonstocks tables
+
+-- Add location_id column to expenses table
+ALTER TABLE expenses
+ADD COLUMN IF NOT EXISTS location_id BIGINT NOT NULL DEFAULT 1;
+
+-- Add project_flock_id column to expenses table (JSON type)
+ALTER TABLE expenses
+ADD COLUMN IF NOT EXISTS project_flock_id JSON NULL;
+
+-- Add Foreign Key constraint to locations table
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'locations') THEN
+        ALTER TABLE expenses
+            ADD CONSTRAINT fk_expenses_location_id
+            FOREIGN KEY (location_id) REFERENCES locations(id) ON DELETE RESTRICT ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+-- Create index for location_id
+CREATE INDEX IF NOT EXISTS idx_expenses_location_id ON expenses (location_id);
+
+-- Create index for project_flock_id
+CREATE INDEX IF NOT EXISTS idx_expenses_project_flock_id ON expenses ((project_flock_id::text));
+
+-- Ensure kandang_id is nullable in expense_nonstocks table
+ALTER TABLE expense_nonstocks
+ALTER COLUMN kandang_id DROP NOT NULL;

internal/database/migrations/20251228015437_add_fifo_fields_to_stock_transfer_details.down.sql

@@ -0,0 +1,42 @@
+-- ===============================================================
+--  ROLLBACK: Remove FIFO fields from STOCK_TRANSFER_DETAILS
+-- ===============================================================
+
+-- Drop indexes
+DROP INDEX IF EXISTS idx_stock_transfer_details_dest_pw;
+DROP INDEX IF EXISTS idx_stock_transfer_details_source_pw;
+
+-- Drop foreign keys
+DO $$
+BEGIN
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_stock_transfer_details_source_pw'
+    ) THEN
+        EXECUTE 'ALTER TABLE stock_transfer_details
+                 DROP CONSTRAINT fk_stock_transfer_details_source_pw';
+    END IF;
+
+    IF EXISTS (
+        SELECT 1 FROM pg_constraint
+        WHERE conname = 'fk_stock_transfer_details_dest_pw'
+    ) THEN
+        EXECUTE 'ALTER TABLE stock_transfer_details
+                 DROP CONSTRAINT fk_stock_transfer_details_dest_pw';
+    END IF;
+END $$;
+
+-- Drop FIFO columns
+ALTER TABLE stock_transfer_details
+DROP COLUMN IF EXISTS total_used,
+DROP COLUMN IF EXISTS total_qty,
+DROP COLUMN IF EXISTS pending_qty,
+DROP COLUMN IF EXISTS usage_qty,
+DROP COLUMN IF EXISTS dest_product_warehouse_id,
+DROP COLUMN IF EXISTS source_product_warehouse_id;
+
+-- Restore original columns (in case rollback)
+ALTER TABLE stock_transfer_details
+ADD COLUMN IF NOT EXISTS quantity NUMERIC(15, 3) NOT NULL DEFAULT 0,
+ADD COLUMN IF NOT EXISTS before_quantity NUMERIC(15, 3),
+ADD COLUMN IF NOT EXISTS after_quantity NUMERIC(15, 3);

internal/database/migrations/20251228015437_add_fifo_fields_to_stock_transfer_details.up.sql

@@ -0,0 +1,83 @@
+-- ===============================================================
+--  ADD FIFO FIELDS TO STOCK_TRANSFER_DETAILS
+--  Enable transfer module to work with FIFO stock system
+--
+--  Notes:
+--  - Field 'quantity' will be removed (replaced by usage_qty + pending_qty)
+--  - Fields 'before_quantity' & 'after_quantity' will be removed (unused legacy)
+--  - New FIFO fields track actual allocation instead of requested quantity
+-- ===============================================================
+
+-- Add FIFO tracking fields
+ALTER TABLE stock_transfer_details
+ADD COLUMN IF NOT EXISTS source_product_warehouse_id BIGINT,
+ADD COLUMN IF NOT EXISTS dest_product_warehouse_id BIGINT,
+ADD COLUMN IF NOT EXISTS usage_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS pending_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS total_qty NUMERIC(15, 3) DEFAULT 0,
+ADD COLUMN IF NOT EXISTS total_used NUMERIC(15, 3) DEFAULT 0;
+
+-- Remove obsolete columns (quantity replaced by FIFO fields, legacy fields never used)
+ALTER TABLE stock_transfer_details
+DROP COLUMN IF EXISTS quantity,
+DROP COLUMN IF EXISTS before_quantity,
+DROP COLUMN IF EXISTS after_quantity;
+
+-- Add foreign keys for product warehouse references
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'product_warehouses') THEN
+        -- Source warehouse foreign key
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint
+            WHERE conname = 'fk_stock_transfer_details_source_pw'
+        ) THEN
+            EXECUTE
+                'ALTER TABLE stock_transfer_details
+                 ADD CONSTRAINT fk_stock_transfer_details_source_pw
+                 FOREIGN KEY (source_product_warehouse_id)
+                 REFERENCES product_warehouses(id)
+                 ON DELETE SET NULL ON UPDATE CASCADE';
+        END IF;
+
+        -- Destination warehouse foreign key
+        IF NOT EXISTS (
+            SELECT 1 FROM pg_constraint
+            WHERE conname = 'fk_stock_transfer_details_dest_pw'
+        ) THEN
+            EXECUTE
+                'ALTER TABLE stock_transfer_details
+                 ADD CONSTRAINT fk_stock_transfer_details_dest_pw
+                 FOREIGN KEY (dest_product_warehouse_id)
+                 REFERENCES product_warehouses(id)
+                 ON DELETE SET NULL ON UPDATE CASCADE';
+        END IF;
+    END IF;
+END $$;
+
+-- Add indexes for FIFO operations
+CREATE INDEX IF NOT EXISTS idx_stock_transfer_details_source_pw
+ON stock_transfer_details (source_product_warehouse_id);
+
+CREATE INDEX IF NOT EXISTS idx_stock_transfer_details_dest_pw
+ON stock_transfer_details (dest_product_warehouse_id);
+
+-- Add comments for documentation
+COMMENT ON COLUMN stock_transfer_details.source_product_warehouse_id IS
+'Source product warehouse ID - referensi warehouse asal (FIFO usable)';
+
+COMMENT ON COLUMN stock_transfer_details.dest_product_warehouse_id IS
+'Destination product warehouse ID - referensi warehouse tujuan (FIFO stockable)';
+
+COMMENT ON COLUMN stock_transfer_details.usage_qty IS
+'Actual quantity successfully taken from source warehouse (FIFO usable tracking) - replaces quantity field';
+
+COMMENT ON COLUMN stock_transfer_details.pending_qty IS
+'Quantity waiting for stock availability (FIFO usable tracking)';
+
+COMMENT ON COLUMN stock_transfer_details.total_qty IS
+'Total lot quantity available at destination warehouse (FIFO stockable tracking)';
+
+COMMENT ON COLUMN stock_transfer_details.total_used IS
+'Quantity already consumed from this lot at destination warehouse (FIFO stockable tracking)';
+

internal/database/migrations/20251228112012_create_adjustment_stocks_table.down.sql

@@ -0,0 +1,16 @@
+-- Rollback: Drop adjustment_stocks table
+
+BEGIN;
+
+DROP INDEX IF EXISTS idx_adjustment_stocks_product_warehouse;
+DROP INDEX IF EXISTS idx_adjustment_stocks_stock_log;
+
+ALTER TABLE adjustment_stocks
+DROP CONSTRAINT IF EXISTS fk_adjustment_stocks_product_warehouse;
+
+ALTER TABLE adjustment_stocks
+DROP CONSTRAINT IF EXISTS fk_adjustment_stocks_stock_log;
+
+DROP TABLE IF EXISTS adjustment_stocks;
+
+COMMIT;

internal/database/migrations/20251228112012_create_adjustment_stocks_table.up.sql

@@ -0,0 +1,40 @@
+-- Migration: Create adjustment_stocks table for FIFO tracking
+-- This table tracks FIFO allocation for stock adjustments (both increase and decrease)
+
+BEGIN;
+
+CREATE TABLE IF NOT EXISTS adjustment_stocks (
+    id BIGSERIAL PRIMARY KEY,
+    stock_log_id BIGINT NOT NULL,
+    product_warehouse_id BIGINT NOT NULL,
+
+    -- FIFO fields for Adjustment INCREASE (Stockable)
+    -- Tracks stock added to warehouse via adjustment
+    total_qty NUMERIC(15, 3) DEFAULT 0,
+    total_used NUMERIC(15, 3) DEFAULT 0,
+
+    -- FIFO fields for Adjustment DECREASE (Usable)
+    -- Tracks stock consumed from warehouse via adjustment
+    usage_qty NUMERIC(15, 3) DEFAULT 0,
+    pending_qty NUMERIC(15, 3) DEFAULT 0,
+
+    created_at TIMESTAMPTZ DEFAULT now(),
+    updated_at TIMESTAMPTZ DEFAULT now()
+);
+
+-- Foreign keys
+ALTER TABLE adjustment_stocks
+ADD CONSTRAINT fk_adjustment_stocks_stock_log
+FOREIGN KEY (stock_log_id) REFERENCES stock_logs(id)
+ON DELETE CASCADE ON UPDATE CASCADE;
+
+ALTER TABLE adjustment_stocks
+ADD CONSTRAINT fk_adjustment_stocks_product_warehouse
+FOREIGN KEY (product_warehouse_id) REFERENCES product_warehouses(id)
+ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- Indexes
+CREATE INDEX idx_adjustment_stocks_stock_log ON adjustment_stocks(stock_log_id);
+CREATE INDEX idx_adjustment_stocks_product_warehouse ON adjustment_stocks(product_warehouse_id);
+
+COMMIT;

internal/database/migrations/20251229125951_adjustment_standart_production_projectflock.down.sql

@@ -0,0 +1,7 @@
+DROP INDEX IF EXISTS idx_project_flocks_production_standard_id;
+
+ALTER TABLE project_flocks
+    DROP CONSTRAINT IF EXISTS fk_project_flocks_production_standard_id;
+
+ALTER TABLE project_flocks
+    DROP COLUMN IF EXISTS production_standard_id;

internal/database/migrations/20251229125951_adjustment_standart_production_projectflock.up.sql

@@ -0,0 +1,15 @@
+-- Add production_standard_id to project_flocks
+ALTER TABLE project_flocks
+    ADD COLUMN IF NOT EXISTS production_standard_id BIGINT;
+
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM pg_tables WHERE tablename = 'production_standards') THEN
+        ALTER TABLE project_flocks
+            ADD CONSTRAINT fk_project_flocks_production_standard_id
+            FOREIGN KEY (production_standard_id) REFERENCES production_standards (id) ON DELETE RESTRICT ON UPDATE CASCADE;
+    END IF;
+END $$;
+
+CREATE INDEX IF NOT EXISTS idx_project_flocks_production_standard_id
+    ON project_flocks (production_standard_id);

internal/database/migrations/20251230014159_alter_table_production_standards_add_fcr_column.down.sql

@@ -0,0 +1,3 @@
+-- Remove standard_fcr column from production_standard_details table
+ALTER TABLE production_standard_details
+DROP COLUMN IF EXISTS standard_fcr;

internal/database/migrations/20251230014159_alter_table_production_standards_add_fcr_column.up.sql

@@ -0,0 +1,3 @@
+-- Add standard_fcr column to production_standard_details table
+ALTER TABLE production_standard_details
+ADD COLUMN standard_fcr NUMERIC(15, 3);

internal/database/seed/seeder.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"strings"
-	"time"
 
 	entity "gitlab.com/mbugroup/lti-api.git/internal/entities"
 	"gitlab.com/mbugroup/lti-api.git/internal/utils"
@@ -25,66 +24,20 @@ func Run(db *gorm.DB) error {
 			return err
 		}
 
-		areas, err := seedAreas(tx, adminID)
-		if err != nil {
-			return err
-		}
-
-		locations, err := seedLocations(tx, adminID, areas)
-		if err != nil {
-			return err
-		}
-
 		productCategories, err := seedProductCategories(tx, adminID)
 		if err != nil {
 			return err
 		}
 
-		if _, err := seedFlocks(tx, adminID); err != nil {
-			return err
-		}
-
-		if _, err := seedFcr(tx, adminID); err != nil {
-			return err
-		}
-
-		kandangs, err := seedKandangs(tx, adminID, locations, users)
-		if err != nil {
-			return err
-		}
-
-		if err := seedWarehouses(tx, adminID, areas, locations, kandangs); err != nil {
-			return err
-		}
-
 		suppliers, err := seedSuppliers(tx, adminID)
 		if err != nil {
 			return err
 		}
 
-		if err := seedCustomers(tx, adminID, users); err != nil {
-			return err
-		}
-
 		if err := seedProducts(tx, adminID, uoms, productCategories, suppliers); err != nil {
 			return err
 		}
 
-		if err := seedNonstocks(tx, adminID, uoms, suppliers); err != nil {
-			return err
-		}
-
-		if err := seedBanks(tx, adminID); err != nil {
-			return err
-		}
-
-		if err := seedProductWarehouse(tx, adminID); err != nil {
-			return err
-		}
-
-		if err := seedTransferStock(tx); err != nil {
-			return err
-		}
 		fmt.Println("✅ Master data seeding completed")
 		return nil
 	})
@@ -141,224 +94,6 @@ func seedUoms(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
 	return result, nil
 }
 
-func seedAreas(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
-	names := []string{"Priangan", "Banten"}
-	result := make(map[string]uint, len(names))
-
-	for _, name := range names {
-		var area entity.Area
-		err := tx.Where("name = ?", name).First(&area).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			area = entity.Area{Name: name, CreatedBy: createdBy}
-			if err := tx.Create(&area).Error; err != nil {
-				return nil, err
-			}
-		} else if err != nil {
-			return nil, err
-		}
-		result[name] = area.Id
-	}
-
-	return result, nil
-}
-
-func seedLocations(tx *gorm.DB, createdBy uint, areas map[string]uint) (map[string]uint, error) {
-	seeds := []struct {
-		Name    string
-		Address string
-		Area    string
-	}{
-		{"Singaparna", "Tasik", "Priangan"},
-		{"Cikaum", "Cikaum", "Banten"},
-	}
-
-	result := make(map[string]uint, len(seeds))
-
-	for _, seed := range seeds {
-		areaID, ok := areas[seed.Area]
-		if !ok {
-			return nil, fmt.Errorf("area %s not seeded", seed.Area)
-		}
-
-		var loc entity.Location
-		err := tx.Where("name = ?", seed.Name).First(&loc).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			loc = entity.Location{
-				Name:      seed.Name,
-				Address:   seed.Address,
-				AreaId:    areaID,
-				CreatedBy: createdBy,
-			}
-			if err := tx.Create(&loc).Error; err != nil {
-				return nil, err
-			}
-		} else if err != nil {
-			return nil, err
-		}
-		result[seed.Name] = loc.Id
-	}
-
-	return result, nil
-}
-
-func seedFlocks(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
-	names := []string{"Flock Priangan", "Flock Banten"}
-	result := make(map[string]uint, len(names))
-
-	for _, name := range names {
-		var flock entity.Flock
-		err := tx.Where("name = ?", name).First(&flock).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			flock = entity.Flock{
-				Name:      name,
-				CreatedBy: createdBy,
-			}
-			if err := tx.Create(&flock).Error; err != nil {
-				return nil, err
-			}
-		} else if err != nil {
-			return nil, err
-		} else {
-			if err := tx.Model(&entity.Flock{}).Where("id = ?", flock.Id).Updates(map[string]any{
-				"created_by": createdBy,
-			}).Error; err != nil {
-				return nil, err
-			}
-		}
-		result[name] = flock.Id
-	}
-
-	return result, nil
-}
-
-func seedKandangs(tx *gorm.DB, createdBy uint, locations map[string]uint, users map[string]uint) (map[string]uint, error) {
-	seeds := []struct {
-		Name     string
-		Status   utils.KandangStatus
-		Capacity float64
-		Location string
-		PicKey   string
-	}{
-		{Name: "Singaparna 1", Status: utils.KandangStatusNonActive, Capacity: 50000, Location: "Singaparna", PicKey: "admin"},
-		{Name: "Singaparna 2", Status: utils.KandangStatusNonActive, Capacity: 50000, Location: "Singaparna", PicKey: "admin"},
-		{Name: "Cikaum 1", Status: utils.KandangStatusNonActive, Capacity: 50000, Location: "Cikaum", PicKey: "admin"},
-		{Name: "Cikaum 2", Status: utils.KandangStatusNonActive, Capacity: 50000, Location: "Cikaum", PicKey: "admin"},
-	}
-
-	result := make(map[string]uint, len(seeds))
-
-	for _, seed := range seeds {
-		locID, ok := locations[seed.Location]
-		if !ok {
-			return nil, fmt.Errorf("location %s not seeded", seed.Location)
-		}
-		picID, ok := users[seed.PicKey]
-		if !ok {
-			return nil, fmt.Errorf("user %s not seeded", seed.PicKey)
-		}
-
-		var kandang entity.Kandang
-		err := tx.Where("name = ?", seed.Name).First(&kandang).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			kandang = entity.Kandang{
-				Name:       seed.Name,
-				Status:     string(seed.Status),
-				LocationId: locID,
-				PicId:      picID,
-				CreatedBy:  createdBy,
-			}
-			if err := tx.Create(&kandang).Error; err != nil {
-				return nil, err
-			}
-		} else if err != nil {
-			return nil, err
-		} else {
-			updates := map[string]any{
-				"location_id": locID,
-				"pic_id":      picID,
-				"status":      string(seed.Status),
-			}
-			if err := tx.Model(&entity.Kandang{}).Where("id = ?", kandang.Id).Updates(updates).Error; err != nil {
-				return nil, err
-			}
-		}
-		result[seed.Name] = kandang.Id
-	}
-
-	return result, nil
-}
-
-func seedWarehouses(tx *gorm.DB, createdBy uint, areas map[string]uint, locations map[string]uint, kandangs map[string]uint) error {
-	seeds := []struct {
-		Name     string
-		Type     string
-		Area     string
-		Location *string
-		Kandang  *string
-	}{
-		{Name: "Gudang Priangan", Type: string(utils.WarehouseTypeArea), Area: "Priangan"},
-		{Name: "Gudang Singaparna", Type: string(utils.WarehouseTypeLokasi), Area: "Priangan", Location: strPtr("Singaparna")},
-		{Name: "Gudang Singaparna 1", Type: string(utils.WarehouseTypeKandang), Area: "Priangan", Location: strPtr("Singaparna"), Kandang: strPtr("Singaparna 1")},
-		{Name: "Gudang Singaparna 2", Type: string(utils.WarehouseTypeKandang), Area: "Priangan", Location: strPtr("Singaparna"), Kandang: strPtr("Singaparna 2")},
-		{Name: "Gudang Banten", Type: string(utils.WarehouseTypeArea), Area: "Banten"},
-		{Name: "Gudang Cikaum", Type: string(utils.WarehouseTypeLokasi), Area: "Banten", Location: strPtr("Cikaum")},
-		{Name: "Gudang Cikaum 1", Type: string(utils.WarehouseTypeKandang), Area: "Banten", Location: strPtr("Cikaum"), Kandang: strPtr("Cikaum 1")},
-		{Name: "Gudang Cikaum 2", Type: string(utils.WarehouseTypeKandang), Area: "Banten", Location: strPtr("Cikaum"), Kandang: strPtr("Cikaum 2")},
-	}
-
-	for _, seed := range seeds {
-		areaID, ok := areas[seed.Area]
-		if !ok {
-			return fmt.Errorf("area %s not seeded", seed.Area)
-		}
-
-		var warehouse entity.Warehouse
-		err := tx.Where("name = ?", seed.Name).First(&warehouse).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			warehouse = entity.Warehouse{
-				Name:      seed.Name,
-				Type:      seed.Type,
-				AreaId:    areaID,
-				CreatedBy: createdBy,
-			}
-		} else if err != nil {
-			return err
-		}
-
-		if seed.Location != nil {
-			locID, ok := locations[*seed.Location]
-			if !ok {
-				return fmt.Errorf("location %s not seeded", *seed.Location)
-			}
-			warehouse.LocationId = uintPtr(locID)
-		}
-		if seed.Kandang != nil {
-			kandangID, ok := kandangs[*seed.Kandang]
-			if !ok {
-				return fmt.Errorf("kandang %s not seeded", *seed.Kandang)
-			}
-			warehouse.KandangId = uintPtr(kandangID)
-		}
-
-		if warehouse.Id == 0 {
-			if err := tx.Create(&warehouse).Error; err != nil {
-				return err
-			}
-		} else {
-			if err := tx.Model(&entity.Warehouse{}).Where("id = ?", warehouse.Id).Updates(map[string]any{
-				"type":        warehouse.Type,
-				"area_id":     warehouse.AreaId,
-				"location_id": warehouse.LocationId,
-				"kandang_id":  warehouse.KandangId,
-			}).Error; err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
 func seedProductCategories(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
 	seeds := []struct {
 		Name string
@@ -440,113 +175,6 @@ func seedSuppliers(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
 	return result, nil
 }
 
-func seedCustomers(tx *gorm.DB, createdBy uint, users map[string]uint) error {
-	seeds := []struct {
-		Name    string
-		PicKey  string
-		Address string
-		Phone   string
-		Email   string
-	}{
-		{"Abdul Azis", "admin", "Jl. Raya Utama 1, Bekasi", "082100000001", "abdul.azis@gmail.com"},
-	}
-
-	for idx, seed := range seeds {
-		picID, ok := users[seed.PicKey]
-		if !ok {
-			return fmt.Errorf("user %s not seeded", seed.PicKey)
-		}
-
-		var customer entity.Customer
-		err := tx.Where("name = ?", seed.Name).First(&customer).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			customer = entity.Customer{
-				Name:          seed.Name,
-				PicId:         picID,
-				Type:          string(utils.CustomerSupplierTypeBisnis),
-				Address:       seed.Address,
-				Phone:         seed.Phone,
-				Email:         seed.Email,
-				AccountNumber: *strPtr(fmt.Sprintf("%03d", idx+1)),
-				CreatedBy:     createdBy,
-			}
-			if err := tx.Create(&customer).Error; err != nil {
-				return err
-			}
-		} else if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
-func seedFcr(tx *gorm.DB, createdBy uint) (map[string]uint, error) {
-	seeds := []struct {
-		Name      string
-		Standards []struct {
-			Weight    float64
-			FcrNumber float64
-			Mortality float64
-		}
-	}{
-		{
-			Name: "FCR Layer",
-			Standards: []struct {
-				Weight    float64
-				FcrNumber float64
-				Mortality float64
-			}{
-				{Weight: 0.8, FcrNumber: 1.60, Mortality: 2.0},
-				{Weight: 1.5, FcrNumber: 1.75, Mortality: 3.5},
-			},
-		},
-	}
-
-	result := make(map[string]uint, len(seeds))
-
-	for _, seed := range seeds {
-		var fcr entity.Fcr
-		err := tx.Where("name = ?", seed.Name).First(&fcr).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			fcr = entity.Fcr{Name: seed.Name, CreatedBy: createdBy}
-			if err := tx.Create(&fcr).Error; err != nil {
-				return nil, err
-			}
-		} else if err != nil {
-			return nil, err
-		}
-		result[seed.Name] = fcr.Id
-
-		for _, std := range seed.Standards {
-			var standard entity.FcrStandard
-			err := tx.Where("fcr_id = ? AND weight = ?", fcr.Id, std.Weight).First(&standard).Error
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				standard = entity.FcrStandard{
-					FcrID:     fcr.Id,
-					Weight:    std.Weight,
-					FcrNumber: std.FcrNumber,
-					Mortality: std.Mortality,
-				}
-				if err := tx.Create(&standard).Error; err != nil {
-					return nil, err
-				}
-			} else if err != nil {
-				return nil, err
-			} else {
-				if err := tx.Model(&entity.FcrStandard{}).Where("id = ?", standard.Id).Updates(map[string]any{
-					"fcr_number": std.FcrNumber,
-					"mortality":  std.Mortality,
-				}).Error; err != nil {
-					return nil, err
-				}
-			}
-		}
-	}
-
-	return result, nil
-}
-
 func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories map[string]uint, suppliers map[string]uint) error {
 	seeds := []struct {
 		Name      string
@@ -560,92 +188,88 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 		Expiry    *int
 		Suppliers []string
 		Flags     []utils.FlagType
+		IsVisible bool
 	}{
 		{
-			Name:      "DOC Broiler",
-			Brand:     "MBU Broiler",
-			Sku:       "BRO0001",
+			Name:      "ISA Brown",
+			Brand:     "ISA Brown",
+			Sku:       "ISA0001",
 			Uom:       "Ekor",
 			Category:  "Day Old Chick",
 			Price:     7500,
 			Suppliers: []string{"PT CHAROEN POKPHAND INDONESIA Tbk"},
-			Flags:     []utils.FlagType{utils.FlagDOC},
+			Flags:     []utils.FlagType{utils.FlagDOC, utils.FlagPullet, utils.FlagLayer},
+			IsVisible: true,
 		},
 		{
-			Name:      "Ayam Pullet",
-			Brand:     "MBU Pullet",
-			Sku:       "PLT0001",
-			Uom:       "Ekor",
-			Category:  "Pullet",
-			Price:     15000,
-			Suppliers: []string{"PT CHAROEN POKPHAND INDONESIA Tbk"},
-			Flags:     []utils.FlagType{utils.FlagPullet},
-		},
-		{
-			Name:     "Ayam Afkir",
-			Brand:    "-",
-			Sku:      "1",
-			Uom:      "Ekor",
-			Category: "Day Old Chick",
-			Price:    1,
-			Flags:    []utils.FlagType{utils.FlagAyamAfkir},
-		},
-		{
-			Name:     "Ayam Mati",
-			Brand:    "-",
-			Sku:      "2",
-			Uom:      "Ekor",
-			Category: "Day Old Chick",
-			Price:    1,
-			Flags:    []utils.FlagType{utils.FlagAyamMati},
-		},
-		{
-			Name:     "Ayam Culling",
-			Brand:    "-",
-			Sku:      "3",
-			Uom:      "Ekor",
-			Category: "Day Old Chick",
-			Price:    1,
-			Flags:    []utils.FlagType{utils.FlagAyamCulling},
-		},
-		{
-			Name:     "Telur Konsumsi Baik",
-			Brand:    "-",
-			Sku:      "4",
-			Uom:      "Unit",
-			Category: "Telur",
-			Price:    1,
-			Flags:    []utils.FlagType{utils.FlagTelurUtuh},
-		},
-		{
-			Name:     "Telur Pecah",
-			Brand:    "-",
-			Sku:      "5",
-			Uom:      "Unit",
-			Category: "Telur",
-			Price:    1,
-			Flags:    []utils.FlagType{utils.FlagTelurPecah},
-		},
-		{
-			Name:      "281 SPECIAL STARTER",
-			Brand:     "281 STARTER",
-			Sku:       "281",
-			Uom:       "Kilogram",
-			Category:  "Bahan Baku",
-			Price:     7850,
-			Expiry:    intPtr(60),
-			Suppliers: []string{"PT CHAROEN POKPHAND INDONESIA Tbk"},
-			Flags:     []utils.FlagType{utils.FlagPakan, utils.FlagStarter},
-		},
-		{
-			Name:      "Ayam Layer",
+			Name:      "Ayam Afkir",
 			Brand:     "-",
-			Sku:       "LYR0001",
+			Sku:       "1",
 			Uom:       "Ekor",
-			Category:  "Pullet",
-			Price:     20000,
-			Suppliers: []string{"PT CHAROEN POKPHAND INDONESIA Tbk"},
-			Flags:     []utils.FlagType{utils.FlagLayer},
+			Category:  "Day Old Chick",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagAyamAfkir},
+			IsVisible: false,
+		},
+		{
+			Name:      "Ayam Mati",
+			Brand:     "-",
+			Sku:       "2",
+			Uom:       "Ekor",
+			Category:  "Day Old Chick",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagAyamMati},
+			IsVisible: false,
+		},
+		{
+			Name:      "Ayam Culling",
+			Brand:     "-",
+			Sku:       "3",
+			Uom:       "Ekor",
+			Category:  "Day Old Chick",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagAyamCulling},
+			IsVisible: false,
+		},
+		{
+			Name:      "Telur Utuh",
+			Brand:     "-",
+			Sku:       "4",
+			Uom:       "Gram",
+			Category:  "Telur",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagTelurUtuh},
+			IsVisible: false,
+		},
+		{
+			Name:      "Telur Pecah",
+			Brand:     "-",
+			Sku:       "5",
+			Uom:       "Gram",
+			Category:  "Telur",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagTelurPecah},
+			IsVisible: false,
+		},
+		{
+			Name:      "Telur Putih",
+			Brand:     "-",
+			Sku:       "6",
+			Uom:       "Gram",
+			Category:  "Telur",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagTelurPutih},
+			IsVisible: false,
+		},
+		{
+			Name:      "Telur Retak",
+			Brand:     "-",
+			Sku:       "7",
+			Uom:       "Gram",
+			Category:  "Telur",
+			Price:     1,
+			Flags:     []utils.FlagType{utils.FlagTelurRetak},
+			IsVisible: false,
 		},
 	}
 
@@ -724,78 +348,78 @@ func seedProducts(tx *gorm.DB, createdBy uint, uoms map[string]uint, categories
 	return nil
 }
 
-func seedNonstocks(tx *gorm.DB, createdBy uint, uoms map[string]uint, suppliers map[string]uint) error {
-	seeds := []struct {
-		Name      string
-		Uom       string
-		Suppliers []string
-		Flags     []utils.FlagType
-	}{
-		{
-			Name:      "Expedisi DOC",
-			Uom:       "Ekor",
-			Suppliers: []string{"Ekspedisi"},
-			Flags:     []utils.FlagType{utils.FlagEkspedisi},
-		},
-		{
-			Name:      "Solar",
-			Uom:       "Liter",
-			Suppliers: []string{"BOP Vendor"},
-			Flags:     []utils.FlagType{},
-		},
-	}
+// func seedNonstocks(tx *gorm.DB, createdBy uint, uoms map[string]uint, suppliers map[string]uint) error {
+// 	seeds := []struct {
+// 		Name      string
+// 		Uom       string
+// 		Suppliers []string
+// 		Flags     []utils.FlagType
+// 	}{
+// 		{
+// 			Name:      "LAJ",
+// 			Uom:       "Unit",
+// 			Suppliers: []string{"Ekspedisi"},
+// 			Flags:     []utils.FlagType{utils.FlagEkspedisi},
+// 		},
+// 		{
+// 			Name:      "Solar",
+// 			Uom:       "Liter",
+// 			Suppliers: []string{"BOP Vendor"},
+// 			Flags:     []utils.FlagType{},
+// 		},
+// 	}
 
-	for _, seed := range seeds {
-		uomID, ok := uoms[seed.Uom]
-		if !ok {
-			return fmt.Errorf("uom %s not seeded", seed.Uom)
-		}
+// 	for _, seed := range seeds {
+// 		uomID, ok := uoms[seed.Uom]
+// 		if !ok {
+// 			return fmt.Errorf("uom %s not seeded", seed.Uom)
+// 		}
 
-		var nonstock entity.Nonstock
-		err := tx.Where("name = ?", seed.Name).First(&nonstock).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			nonstock = entity.Nonstock{
-				Name:      seed.Name,
-				UomId:     uomID,
-				CreatedBy: createdBy,
-			}
-			if err := tx.Create(&nonstock).Error; err != nil {
-				return err
-			}
-		} else if err != nil {
-			return err
-		} else {
-			if err := tx.Model(&entity.Nonstock{}).Where("id = ?", nonstock.Id).Updates(map[string]any{
-				"uom_id": uomID,
-			}).Error; err != nil {
-				return err
-			}
-		}
+// 		var nonstock entity.Nonstock
+// 		err := tx.Where("name = ?", seed.Name).First(&nonstock).Error
+// 		if errors.Is(err, gorm.ErrRecordNotFound) {
+// 			nonstock = entity.Nonstock{
+// 				Name:      seed.Name,
+// 				UomId:     uomID,
+// 				CreatedBy: createdBy,
+// 			}
+// 			if err := tx.Create(&nonstock).Error; err != nil {
+// 				return err
+// 			}
+// 		} else if err != nil {
+// 			return err
+// 		} else {
+// 			if err := tx.Model(&entity.Nonstock{}).Where("id = ?", nonstock.Id).Updates(map[string]any{
+// 				"uom_id": uomID,
+// 			}).Error; err != nil {
+// 				return err
+// 			}
+// 		}
 
-		for _, supplierName := range seed.Suppliers {
-			supplierID, ok := suppliers[supplierName]
-			if !ok {
-				return fmt.Errorf("supplier %s not seeded", supplierName)
-			}
-			var existing entity.NonstockSupplier
-			err := tx.Where("nonstock_id = ? AND supplier_id = ?", nonstock.Id, supplierID).First(&existing).Error
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				link := entity.NonstockSupplier{NonstockId: nonstock.Id, SupplierId: supplierID}
-				if err := tx.Create(&link).Error; err != nil {
-					return err
-				}
-			} else if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
-				return err
-			}
-		}
+// 		for _, supplierName := range seed.Suppliers {
+// 			supplierID, ok := suppliers[supplierName]
+// 			if !ok {
+// 				return fmt.Errorf("supplier %s not seeded", supplierName)
+// 			}
+// 			var existing entity.NonstockSupplier
+// 			err := tx.Where("nonstock_id = ? AND supplier_id = ?", nonstock.Id, supplierID).First(&existing).Error
+// 			if errors.Is(err, gorm.ErrRecordNotFound) {
+// 				link := entity.NonstockSupplier{NonstockId: nonstock.Id, SupplierId: supplierID}
+// 				if err := tx.Create(&link).Error; err != nil {
+// 					return err
+// 				}
+// 			} else if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+// 				return err
+// 			}
+// 		}
 
-		if err := seedFlags(tx, nonstock.Id, entity.FlagableTypeNonstock, seed.Flags); err != nil {
-			return err
-		}
-	}
+// 		if err := seedFlags(tx, nonstock.Id, entity.FlagableTypeNonstock, seed.Flags); err != nil {
+// 			return err
+// 		}
+// 	}
 
-	return nil
-}
+// 	return nil
+// }
 
 // nanti saya isi
 
@@ -823,213 +447,6 @@ func seedFlags(tx *gorm.DB, flagableID uint, flagableType string, flags []utils.
 	return nil
 }
 
-func seedBanks(tx *gorm.DB, createdBy uint) error {
-	seeds := []struct {
-		Name          string
-		Alias         string
-		Owner         *string
-		AccountNumber string
-	}{
-		{
-			Name:          "Bank Central Asia",
-			Alias:         "BCA",
-			AccountNumber: "1234567890",
-			Owner:         ptr("PT MBU Group"),
-		},
-		{
-			Name:          "Bank Rakyat Indonesia",
-			Alias:         "BRI",
-			AccountNumber: "9876543210",
-			Owner:         ptr("PT MBU Group"),
-		},
-		{
-			Name:          "Bank Mandiri",
-			Alias:         "MAND",
-			AccountNumber: "1122334455",
-			Owner:         ptr("PT MBU Group"),
-		},
-	}
-
-	for _, seed := range seeds {
-		var bank entity.Bank
-		err := tx.Where("name = ?", seed.Name).First(&bank).Error
-
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			bank = entity.Bank{
-				Name:          seed.Name,
-				Alias:         seed.Alias,
-				Owner:         seed.Owner,
-				AccountNumber: seed.AccountNumber,
-				CreatedBy:     createdBy,
-				CreatedAt:     time.Now(),
-				UpdatedAt:     time.Now(),
-			}
-			if err := tx.Create(&bank).Error; err != nil {
-				return err
-			}
-		} else if err != nil {
-			return err
-		} else {
-			// update data jika sudah ada
-			if err := tx.Model(&entity.Bank{}).Where("id = ?", bank.Id).Updates(map[string]any{
-				"alias":          seed.Alias,
-				"owner":          seed.Owner,
-				"account_number": seed.AccountNumber,
-				"updated_at":     time.Now(),
-			}).Error; err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func seedProductWarehouse(tx *gorm.DB, createdBy uint) error {
-	seeds := []struct {
-		ProductName   string
-		WarehouseName string
-		Quantity      float64
-	}{
-		{ProductName: "DOC Broiler", WarehouseName: "Gudang Priangan", Quantity: 100},
-		{ProductName: "281 SPECIAL STARTER", WarehouseName: "Gudang Singaparna", Quantity: 200},
-		{ProductName: "281 SPECIAL STARTER", WarehouseName: "Gudang Banten", Quantity: 300},
-		{ProductName: "DOC Broiler", WarehouseName: "Gudang Singaparna 1", Quantity: 5000},
-		{ProductName: "Telur Konsumsi Baik", WarehouseName: "Gudang Singaparna 1", Quantity: 600},
-		{ProductName: "Telur Pecah", WarehouseName: "Gudang Singaparna 1", Quantity: 80},
-		{ProductName: "Telur Konsumsi Baik", WarehouseName: "Gudang Cikaum 1", Quantity: 450},
-		{ProductName: "Telur Pecah", WarehouseName: "Gudang Cikaum 1", Quantity: 60},
-	}
-
-	for _, seed := range seeds {
-		var product entity.Product
-		if err := tx.Where("name = ?", seed.ProductName).First(&product).Error; err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fmt.Errorf("product %q not found for product warehouse seeding", seed.ProductName)
-			}
-			return err
-		}
-
-		var warehouse entity.Warehouse
-		if err := tx.Where("name = ?", seed.WarehouseName).First(&warehouse).Error; err != nil {
-			if errors.Is(err, gorm.ErrRecordNotFound) {
-				return fmt.Errorf("warehouse %q not found for product warehouse seeding", seed.WarehouseName)
-			}
-			return err
-		}
-
-		var productWarehouse entity.ProductWarehouse
-		err := tx.Where("product_id = ? AND warehouse_id = ?", product.Id, warehouse.Id).First(&productWarehouse).Error
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			productWarehouse = entity.ProductWarehouse{
-				ProductId:   product.Id,
-				WarehouseId: warehouse.Id,
-				Quantity:    seed.Quantity,
-				// CreatedBy:   createdBy,
-			}
-			if err := tx.Create(&productWarehouse).Error; err != nil {
-				return err
-			}
-		} else if err != nil {
-			return err
-		} else {
-			if err := tx.Model(&productWarehouse).Updates(map[string]any{
-				"quantity": seed.Quantity,
-			}).Error; err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
-
-func seedTransferStock(tx *gorm.DB) error {
-
-	transfer := entity.StockTransfer{
-		FromWarehouseId: 1,
-		ToWarehouseId:   2,
-		Reason:          "Seed transfer stock",
-		TransferDate:    time.Now(),
-		MovementNumber:  "SEED-TRF-00001",
-		CreatedBy:       1,
-	}
-	if err := tx.Create(&transfer).Error; err != nil {
-		return err
-	}
-
-	details := []entity.StockTransferDetail{
-		{
-			StockTransferId: transfer.Id,
-			ProductId:       1,
-			Quantity:        10,
-		},
-		{
-			StockTransferId: transfer.Id,
-			ProductId:       2,
-			Quantity:        5,
-		},
-	}
-	for i := range details {
-		if err := tx.Create(&details[i]).Error; err != nil {
-			return err
-		}
-	}
-
-	deliveries := []entity.StockTransferDelivery{
-		{
-			StockTransferId:   transfer.Id,
-			SupplierId:        1,
-			VehiclePlate:      "B 1234 XYZ",
-			DriverName:        "Driver Seed",
-			DocumentPath:      "seed.pdf",
-			ShippingCostItem:  1000,
-			ShippingCostTotal: 2000,
-		},
-	}
-	for i := range deliveries {
-		if err := tx.Create(&deliveries[i]).Error; err != nil {
-			return err
-		}
-	}
-
-	detailMap := make(map[uint64]uint64)
-	for _, d := range details {
-		detailMap[d.ProductId] = d.Id
-	}
-
-	deliveryItems := []entity.StockTransferDeliveryItem{
-		{
-			StockTransferDeliveryId: deliveries[0].Id,
-			StockTransferDetailId:   detailMap[1],
-			Quantity:                50,
-		},
-		{
-			StockTransferDeliveryId: deliveries[0].Id,
-			StockTransferDetailId:   detailMap[2],
-			Quantity:                30,
-		},
-	}
-	for i := range deliveryItems {
-		if err := tx.Create(&deliveryItems[i]).Error; err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-func ptr[T any](v T) *T {
-	return &v
-}
-
 func strPtr(s string) *string {
 	return &s
 }
-
-func intPtr(v int) *int {
-	return &v
-}
-
-func uintPtr(v uint) *uint {
-	return &v
-}