KnowledgeBase_frontend/src/store/knowledgeBase/knowledgeBase.thunks.js

import { createAsyncThunk } from '@reduxjs/toolkit';
import { get, post, put, del } from '../../services/api';

/**
 * Fetch knowledge bases with pagination
 * @param {Object} params - Pagination parameters
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const fetchKnowledgeBases = createAsyncThunk(
    'knowledgeBase/fetchKnowledgeBases',
    async ({ page = 1, page_size = 10 } = {}, { rejectWithValue }) => {
        try {
            const response = await get('/knowledge-bases/', { page, page_size });
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to fetch knowledge bases');
        }
    }
);

/**
 * Search knowledge bases
 * @param {Object} params - Search parameters
 * @param {string} params.keyword - Search keyword
 * @param {number} params.page - Page number (default: 1)
 * @param {number} params.page_size - Page size (default: 10)
 */
export const searchKnowledgeBases = createAsyncThunk(
    'knowledgeBase/searchKnowledgeBases',
    async ({ keyword, page = 1, page_size = 10 }, { rejectWithValue }) => {
        try {
            const response = await get('/knowledge-bases/search/', {
                keyword,
                page,
                page_size,
            });
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to search knowledge bases');
        }
    }
);

/**
 * Create a new knowledge base
 */
export const createKnowledgeBase = createAsyncThunk(
    'knowledgeBase/createKnowledgeBase',
    async (knowledgeBaseData, { rejectWithValue }) => {
        try {
            const response = await post('/knowledge-bases/', knowledgeBaseData);
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to create knowledge base');
        }
    }
);

/**
 * Get knowledge base details by ID
 */
export const getKnowledgeBaseById = createAsyncThunk(
    'knowledgeBase/getKnowledgeBaseById',
    async (id, { rejectWithValue }) => {
        try {
            const response = await get(`/knowledge-bases/${id}/`);
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to get knowledge base details');
        }
    }
);

/**
 * Update knowledge base
 * @param {Object} params - Update parameters
 * @param {string} params.id - Knowledge base ID
 * @param {Object} params.data - Update data (name, desc)
 */
export const updateKnowledgeBase = createAsyncThunk(
    'knowledgeBase/updateKnowledgeBase',
    async ({ id, data }, { rejectWithValue }) => {
        try {
            const response = await put(`/knowledge-bases/${id}/`, data);
            return response.data;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to update knowledge base');
        }
    }
);

/**
 * Delete knowledge base
 * @param {string} id - Knowledge base ID
 */
export const deleteKnowledgeBase = createAsyncThunk(
    'knowledgeBase/deleteKnowledgeBase',
    async (id, { rejectWithValue }) => {
        try {
            await del(`/knowledge-bases/${id}/`);
            return id;
        } catch (error) {
            return rejectWithValue(error.response?.data || 'Failed to delete knowledge base');
        }
    }
);