9s-fe-core/dist/providers/FeatureProvider.js

Core functionalities for authentication, configuration, and repository management.

"use strict";
// FeatureProvider.tsx
'use client';
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FeatureProvider = exports.useFeatures = void 0;
const jsx_runtime_1 = require("react/jsx-runtime");
const react_1 = require("react");
const authentication_1 = require("../authentication"); // Đảm bảo đường dẫn đúng
const repository_1 = require("../repository");
const env_1 = require("../configs/env");
const FeatureContext = (0, react_1.createContext)(undefined);
const useFeatures = () => {
    const context = (0, react_1.useContext)(FeatureContext);
    if (!context) {
        throw new Error('useFeatures must be used within a FeatureProvider');
    }
    return context;
};
exports.useFeatures = useFeatures;
const FeatureProvider = ({ children }) => {
    const { isAuthenticated } = (0, authentication_1.useAuth)();
    const [modules, setModules] = (0, react_1.useState)([]);
    const [features, setFeatures] = (0, react_1.useState)([]);
    const [isLoading, setIsLoading] = (0, react_1.useState)(true);
    const { moduleKeys } = (0, env_1.getConfig)();
    // Step 1: Fetch modules
    (0, react_1.useEffect)(() => {
        const fetchModules = () => __awaiter(void 0, void 0, void 0, function* () {
            var _a;
            const { moduleEndpoints } = (0, env_1.getConfig)();
            const request = {
                apiUrl: moduleEndpoints.moduleList,
                httpMethod: repository_1.HttpMethod.GET,
            };
            try {
                const rawResponse = yield repository_1.baseRepository.submitRequest(request);
                const scopes = ((_a = rawResponse === null || rawResponse === void 0 ? void 0 : rawResponse.dataResponse) === null || _a === void 0 ? void 0 : _a.scopes) || [];
                setModules(scopes);
            }
            catch (error) {
                console.error('Failed to fetch features:', error);
            }
            finally {
                setIsLoading(false);
            }
        });
        if (isAuthenticated) {
            fetchModules();
        }
    }, [isAuthenticated]);
    // Step 2: Fetch featureReponse when modules change
    const [schemaFeatured, setSchemaFeatured] = (0, react_1.useState)(null);
    (0, react_1.useEffect)(() => {
        const fetchFeatureReponse = () => __awaiter(void 0, void 0, void 0, function* () {
            const menuKey = moduleKeys.featureKey;
            const featureModule = modules.find(module => module.key === menuKey);
            if (!featureModule)
                return;
            try {
                const featureReponse = yield repository_1.baseRepository.submitRequest({
                    httpMethod: repository_1.HttpMethod.GET,
                    apiUrl: featureModule.path,
                });
                if (featureReponse.status === 200) {
                    const schema = featureReponse.dataResponse;
                    setSchemaFeatured(schema);
                }
            }
            catch (error) {
                console.error('Failed to fetch featureReponse:', error);
            }
        });
        if (modules.length > 0) {
            fetchFeatureReponse();
        }
    }, [modules, moduleKeys]);
    // Step 3: Fetch fetchFeatureList when schemaFeatured changes
    const fetchFeatures = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
        if (!schemaFeatured)
            return;
        const schemaDataList = schemaFeatured['list'];
        if (!schemaDataList)
            return;
        const apiData = schemaDataList.api;
        try {
            const requestData = {
                type: apiData.type,
                apiUrl: apiData.path,
                httpMethod: apiData.method,
            };
            const responseFeatureList = yield repository_1.baseRepository.submitRequest(requestData);
            if (responseFeatureList.status === 200) {
                setFeatures(responseFeatureList.dataResponse);
            }
        }
        catch (error) {
            console.error('Failed to fetch responseFeatureList:', error);
        }
    }), [schemaFeatured]);
    // Gọi fetchFeatures khi modules thay đổi
    (0, react_1.useEffect)(() => {
        fetchFeatures();
    }, [fetchFeatures]);
    // Hàm refreshFeatures để làm mới danh sách features
    const refreshFeatures = (0, react_1.useCallback)(() => __awaiter(void 0, void 0, void 0, function* () {
        setIsLoading(true);
        yield fetchFeatures();
        setIsLoading(false);
    }), [fetchFeatures]);
    return ((0, jsx_runtime_1.jsx)(FeatureContext.Provider, { value: { modules, features, isLoading, refreshFeatures }, children: children }));
};
exports.FeatureProvider = FeatureProvider;