Anjing Webshells

Website : rimsha.abasa.com
: / var / www / talha_silentcontent / src / components /
Filename : DataProvider.tsx
back
// @ts-nocheck

"use client";

import router from "next/router";
import React, { createContext, useState, useContext, useEffect, useRef } from "react";
import { toast } from "./ui/use-toast";
import axios from "axios";
import { QueryClient, useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import Papa from 'papaparse';
import { useForm } from "react-hook-form";
import fetch from 'node-fetch';
import { Agent } from "undici";

interface Keyword {
  _id: string;
  keyword: string;
  response: string;
  status: string;
}

const DataContext = createContext([]);

export const DataProvider = ({ children }: { children: React.ReactNode }) => {
  const [keywordsData, setKeywordsData] = useState([]);
  const [responseData, setResponseData] = useState([]);
  const responsesRef = useRef([]);
  const [keywordsDB, setKeywordsDB] = useState<Keyword[]>([]);
  const [loadingIndex, setLoadingIndex] = useState<number>(0);
  const form = useForm();

  const submitKeywords = (keywords: string) => {
    // const keywordsSplit = keywords.trim().split(/, | |,(?![ ,])/);
    const keywordsSplit = keywords.trim().split(/\n/);
    return keywordsSplit;
  };
  
  // @ts-ignore
  const onSubmit = async (data) => {

    let keywordsArr;
    let secondaryKeywordArr;
    if (data.keywordsCsv) {
      const file = data.keywordsCsv;
  
      // Wrap the parsing logic in a Promise to make it awaitable
      const parseKeywords = () => {
        return new Promise((resolve) => {
          Papa.parse(file, {
            header: true,
            dynamicTyping: true,  // Automatically convert values to appropriate data types
            skipEmptyLines: true,
            complete: (result) => {
              console.log('Parsed CSV data:', result.data);
              const keywords = result.data.map((row) => row.PrimaryKeyword);
              const secondaryKeywords = result.data.map((row) => {
                const secondaryKeywordsArray = row.SecondaryKeywords?.split(',').map(keyword => keyword.trim());
                return secondaryKeywordsArray?.join(', '); // Combine secondary keywords into a single string
              });
  
              console.log('primary keywords:', keywords);
              console.log('secondary keywords:', secondaryKeywords);
              data.keywords = keywords;
              data.secondaryKeywords = secondaryKeywords;
  
              const keywordData = { keywords, secondaryKeywords };
              resolve(keywordData);  // Resolve the promise with the parsed keywords
            },
          });
        });
      };
      // Wait for the CSV parsing to complete and get the parsed keywords
      const keywordData = await parseKeywords();
      // @ts-ignore
      const { keywords, secondaryKeywords } = keywordData
      keywordsArr = keywords;
      secondaryKeywordArr = secondaryKeywords;
      console.log('Parsed keywords:', data);
    } else {
       keywordsArr = submitKeywords(data.keywords);
    }

    console.log(data);
    

    
    const keywordData = { data: { ...data, keywords: keywordsArr, secondaryKeywords: secondaryKeywordArr }};

    const { API, GPT, selectPrompt, batch, keywords, secondaryKeywords, customOutlinePrompt, customSectionPrompt} = keywordData.data;

    //@ts-ignore
    const payloads = keywords.map((keyword: any, index) => ({
      API,
      GPT,
      selectPrompt,
      batch,
      keyword,
      secondaryKeywords: secondaryKeywords ? secondaryKeywords[index] : null,
      scraping: data.scraping === true ? true : false,
      wordCount: data.wordCount,
      customOutlinePrompt,
      customSectionPrompt,
    }));



    // setResponseData([]);
    // setKeywordsData(payloads);

    const payload = {
      payloads,
    }

    let csvType;
    if (data.keywordsCsv){
      csvType = true;
    }

    console.log('payload is', payload);
    // const response = await axios.post("/api/articles", payload, {
    //   headers: {'Content-Type': 'application/json'}});
    //@ts-ignore
    // await initializeKeywords(payload, csvType);
    // @ts-ignore

    try {
      if (csvType){
        toast({
          title: "Keywords submitted",
          description: "Keywords have been submitted",
        });
      }

      const response = await axios.post("/api/articles", payload);
      console.log('hit /api/articles')
      toast({
        title: "Keywords submitted",
        description: "Keywords have been submitted",
      });
      setTimeout(() => {
        window.location.reload(true);
      }, 2000); 
    }
    catch (error) {
      toast({
        title: "Keywords not submitted",
        description: "There are errors in the submission",
      });
      setTimeout(() => {
        window.location.reload(true);
      }, 2000); 
    }
    form.reset()

    // @ts-ignore
    // window.location.reload(true);
  };

  //map the keywordsData in useMutation functions

//   const {mutate: initializeKeywords} = useMutation({
//     mutationFn: async (payload, csvType) => {
//       const response = await axios.post("/api/articles", payload);
//       console.log('response is', response.data)

//       return response.data;
//     },
//     onSuccess: (data) => {
//       console.log('data is', data)
//       toast({
//         title: "Keywords submitted",
//         description: "Keywords have been submitted",
//       });
//       setTimeout(() => {
//         window.location.reload(true);
//       }, 2000);    
// }})

  const {data: keywords, isLoading, isError, refetch} = useQuery(['keywords'], fetchData,
  {
    refetchInterval: 2000,
    refetchIntervalInBackground: true,
  })

  async function fetchData() {
    const response = await axios.get('/api/articles');
    const keywords = response.data.data.keywords;

    // Manually update the cache with the fetched data
    // queryClient.setQueryData('keywords', keywords);

    // Set the local state with the fetched data
    setKeywordsDB(keywords);
    return keywords;
  }
  
  const keywordQuery = useQueryClient();
  
  // const {mutateAsync: patchTest} = useMutation({
  //   mutationFn: async (testPatcher) => {
  //     const response = await axios.patch(`/api/articles/`, testPatcher, { timeout: 12000000 });
  //     return response.data;
  //   },
  //   onSuccess: (data) => {
  //     keywordQuery.invalidateQueries(['keywords']);
  //   }
  // })

  const { mutateAsync: patchTest } = useMutation({
    mutationFn: async (testPatcher) => {
      try {
        const response = await axios.patch(`/api/articles/`, testPatcher, { timeout: 12000000 });
        return response.data;
      } catch (error) {
        if (axios.isAxiosError(error) && error.code === 'ECONNABORTED') {
          // Handle timeout error
          console.error('Request timed out:', error.message);
          // You can retry the request or take other appropriate actions here
        } else {
          // Handle other errors
          console.error('Error:', error.message);
        }
        throw error; // Rethrow the error to propagate it further if needed
      }
    },
    onSuccess: (data) => {
      keywordQuery.invalidateQueries(['keywords']);
      // Additional success handling if needed
    }
  });

  // useEffect(() => {
  //   const updateLoadingState = async () => {
  //     for (let index = 0; index < keywordsDB.length; index++) {
  //       if (index < loadingIndex || keywordsDB[index].status !== 'not started') {
  //         setLoadingIndex(index); // Update loadingIndex for 'in progress' status
  //         continue;
  //       }
  
  //       const keywordToUpdate = keywordsDB[index];
  
  //       try {
  //         if (keywordToUpdate.status === 'completed'){
  //           continue;
  //         }
  //         // @ts-ignore
  //         if (keywordToUpdate.status === 'not started') {
  //           console.log('generating before the response');
  //         }
  //         // @ts-ignore
  //         const response = await patchTest(keywordToUpdate);
  //         console.log('data:', response);
  //       } catch (error) {
  //         console.error('Error generating response', error);
  //         throw error;
  //       }
  //     }
  //   };
  //   updateLoadingState();
  //   // eslint-disable-next-line react-hooks/exhaustive-deps
  // }, [keywordsDB]);



  return (
    <DataContext.Provider
      value={{
        // @ts-ignore
        onSubmit,
        keywordsData,
        setKeywordsData,
        responseData,
        setResponseData,
        responsesRef,
        keywordsDB,
        refetch,
        form,
        loadingIndex
      }}
    >
      {children}
    </DataContext.Provider>
  );
};

export const useData = () => {
  return useContext(DataContext);
};