golscontrol-frontend-v1/src/modules/fixed-assets/services/fixedAssetsService.ts

import api from '../../../services/api';
import type { UsefulLifeCatalogOption, FiscalDepreciationRateOption, UsefulLifeCalculationResult } from '../types/fixedAsset';

export interface Asset {
    id: number;
    sku: string;
    asset_tag: string | null;
    status: { id: number; name: string };
    estimated_useful_life: number | null;
    depreciation_method: string;
    residual_value: string;
    accumulated_depreciation: string;
    book_value: string;
    warranty_days: number | null;
    warranty_end_date: string | null;
    fiscal_depreciation_rate_id: number | null;
    useful_life_catalog_id: number | null;
    fiscal_depreciation_rate: { id: number; name: string; depreciation_rate: string } | null;
    useful_life_catalog: { id: number; name: string; min_years: number; max_years: number } | null;
    inventory_warehouse: {
        id: number;
        product: {
            id: number;
            name: string;
            serial_number?: string;
            category?: string;
        };
    } | null;
    active_assignment: {
        id: number;
        employee: {
            id: number;
            name: string;
            department: {
                id: number;
                name: string;
            } | null;
        };
    } | null;
}

export interface AssetsPaginatedResponse {
    status: string;
    data: {
        current_page: number;
        data: Asset[];
        last_page: number;
        per_page: number;
        total: number;
    };
}

export interface AssetsListResponse {
    status: string;
    data: {
        data: Asset[];
    };
}

export interface AssetDetailResponse {
    status: string;
    data: {
        data: Asset;
    };
}

export interface StatusOption {
    id: number;
    name: string;
}

export interface StatusOptionsResponse {
    status: string;
    data: {
        data: StatusOption[];
    };
}

interface AssetFilters {
    q?: string;
    status?: number;
    page?: number;
    paginate?: boolean;
}

export interface AssetAssignment {
    id: number;
    asset_id: number;
    employee_id: number;
    assigned_at: string;
    returned_at: string | null;
    receipt_folio: string | null;
    notes: string | null;
    status: { id: number; name: string };
    asset: Asset | null;
    employee: {
        id: number;
        name: string;
        paternal: string;
        maternal: string;
        department: { id: number; name: string } | null;
    } | null;
}

export interface AssetAssignmentResponse {
    status: string;
    data: { data: AssetAssignment };
}

export interface AssetAssignmentsPaginatedResponse {
    status: string;
    data: {
        data: {
            current_page: number;
            data: AssetAssignment[];
            last_page: number;
            per_page: number;
            total: number;
        };
    };
}

export interface UserOption {
    id: number;
    name: string;
    paternal: string;
    maternal: string;
    full_name: string;
}

export interface UsersResponse {
    data: UserOption[];
}

interface AssignAssetData {
    employee_id: number;
    assigned_at?: string;
    receipt_folio?: string;
    authorized_by?: number;
    delivered_by?: number;
    notes?: string;
}

interface ReturnAssetData {
    returned_at?: string;
    notes?: string;
}

class FixedAssetsService {
    async getAssets(filters: AssetFilters = {}): Promise<AssetsPaginatedResponse> {
        const params: Record<string, string | number | boolean> = {};

        if (filters.q) params.q = filters.q;
        if (filters.status) params.status = filters.status;
        if (filters.page) params.page = filters.page;
        if (filters.paginate !== undefined) params.paginate = filters.paginate;

        const response = await api.get<AssetsPaginatedResponse>('/api/assets', { params });
        return response.data;
    }

    async getAsset(id: number): Promise<AssetDetailResponse> {
        const response = await api.get<AssetDetailResponse>(`/api/assets/${id}`);
        return response.data;
    }

    async createAsset(data: Record<string, unknown>): Promise<AssetDetailResponse> {
        const response = await api.post<AssetDetailResponse>('/api/assets', data);
        return response.data;
    }

    async updateAsset(id: number, data: Record<string, unknown>): Promise<AssetDetailResponse> {
        const response = await api.put<AssetDetailResponse>(`/api/assets/${id}`, data);
        return response.data;
    }

    async deleteAsset(id: number): Promise<void> {
        await api.delete(`/api/assets/${id}`);
    }

    async getStatusOptions(): Promise<StatusOption[]> {
        const response = await api.get<StatusOptionsResponse>('/api/assets/options/status');
        return response.data.data.data;
    }

    async getAssignments(filters: { q?: string; status?: number; page?: number; paginate?: boolean } = {}): Promise<AssetAssignmentsPaginatedResponse> {
        const params: Record<string, string | number | boolean> = {};
        if (filters.q) params.q = filters.q;
        if (filters.status !== undefined) params.status = filters.status;
        if (filters.page) params.page = filters.page;
        if (filters.paginate !== undefined) params.paginate = filters.paginate;

        const response = await api.get<AssetAssignmentsPaginatedResponse>('/api/assets/assignments', { params });
        return response.data;
    }

    async assignAsset(assetId: number, data: AssignAssetData): Promise<AssetAssignmentResponse> {
        const response = await api.post<AssetAssignmentResponse>(`/api/assets/${assetId}/assignments`, data);
        return response.data;
    }

    async returnAsset(assetId: number, assignmentId: number, data: ReturnAssetData): Promise<AssetAssignmentResponse> {
        const response = await api.put<AssetAssignmentResponse>(`/api/assets/${assetId}/assignments/${assignmentId}/return`, data);
        return response.data;
    }

    async getUsers(): Promise<UserOption[]> {
        const response = await api.get<UsersResponse>('/api/rh/employees', { params: { paginate: false } });
        return response.data.data.map((e: any) => ({
            ...e,
            full_name: `${e.name} ${e.paternal} ${e.maternal ?? ''}`.trim(),
        }));
    }

    async getUsefulLifeCatalog(): Promise<UsefulLifeCatalogOption[]> {
        const response = await api.get('/api/catalogs/useful-life-catalog', { params: { paginate: false } });
        return response.data.data.data;
    }

    async getFiscalDepreciationRates(): Promise<FiscalDepreciationRateOption[]> {
        const response = await api.get('/api/catalogs/fiscal-depreciation-rates', { params: { paginate: false } });
        return response.data.data.data;
    }

    async calculateUsefulLife(params: { useful_life_catalog_id?: number }): Promise<UsefulLifeCalculationResult> {
        const response = await api.get('/api/assets/options/calculate-useful-life', { params });
        return response.data.data;
    }

    async downloadResguardo(assetId: number, assignmentId: number): Promise<void> {
        const response = await api.get(
            `/api/assets/${assetId}/assignments/${assignmentId}/resguardo`,
            { responseType: 'blob' }
        );
        const blobUrl = URL.createObjectURL(new Blob([response.data], { type: 'application/pdf' }));
        const link = document.createElement('a');
        link.href = blobUrl;
        link.target = '_blank';
        link.click();
        URL.revokeObjectURL(blobUrl);
    }
}

export const fixedAssetsService = new FixedAssetsService();
export default fixedAssetsService;