गूगल ट्रेंड्स ट्रैकर को पाइपड्रीम पर कैसे प्राप्त करें?

import { axios } from "@pipedream/platform"

export default defineComponent({
  async run({ steps, $ }) {
    const keywords = ["AI", "Machine Learning", "Data Science"];
    const allResults = {};
    
    for (const keyword of keywords) {
      console.log(`प्रसंस्करण कीवर्ड: ${keyword}`);
      
      const payload = {
        actor: "scraper.google.trends",
        input: {
          q: keyword,
          date: "today 1-m",
          data_type: "interest_over_time",
          hl: "en",
          tz: "420",
          geo: "",
          cat: "",
          property: "",
        },
        proxy: {
          country: "",
        }
      };

      try {
        const response = await axios($, {
          method: 'POST',
          url: 'https://api.scrapeless.com/api/v1/scraper/request',
          headers: {
            'Content-Type': 'application/json',
            'x-api-token': 'Scrapeless API KEY'
          },
          data: payload
        });
        
        console.log(`प्रतिक्रिया ${keyword} के लिए:`, response);
        
        if (response.job_id) {
          console.log(`नौकरी बनाई गई ${keyword} के लिए, आईडी: ${response.job_id}`);
          
          let attempts = 0;
          const maxAttempts = 12;
          let jobResult = null;
          
          while (attempts < maxAttempts) {
            await new Promise(resolve => setTimeout(resolve, 10000));
            attempts++;
            
            try {
              const resultResponse = await axios($, {
                method: 'GET',
                url: `https://api.scrapeless.com/api/v1/scraper/result/${response.job_id}`,
                headers: {
                  'x-api-token': 'Scrapeless API KEY'
                }
              });
              
              console.log(`कोशिश ${attempts} ${keyword} के लिए:`, resultResponse);
              
              if (resultResponse.status === 'completed') {
                jobResult = resultResponse.result;

console.log(`काम पूरा हुआ ${keyword} के लिए:`, jobResult);
                break;
              } else if (resultResponse.status === 'failed') {
                console.error(`काम विफल हुआ ${keyword} के लिए:`, resultResponse);
                break;
              } else {
                console.log(`काम अभी भी चल रहा है ${keyword} के लिए, स्थिति: ${resultResponse.status}`);
              }
            } catch (error) {
              console.error(`काम की स्थिति की जांच करते समय त्रुटि ${keyword} के लिए:`, error);
            }
          }
          
          if (jobResult) {
            allResults[keyword] = jobResult;
          } else {
            allResults[keyword] = { 
              error: `काम टाइमआउट या ${attempts} प्रयासों के बाद विफल`,
              job_id: response.job_id 
            };
          }
          
        } else {
          allResults[keyword] = response;
        }
        
      } catch (error) {
        console.error(`त्रुटि ${keyword} के लिए:`, error);
        allResults[keyword] = { 
          error: `अनुरोध विफल: ${error.message}` 
        };
      }
    }
    
    console.log("अंतिम परिणाम:", JSON.stringify(allResults, null, 2));
    return allResults;
  },
})

export default defineComponent({
  async run({ steps, $ }) {
    const httpData = steps.http.$return_value;
    
    console.log("प्राप्त HTTP डेटा:", JSON.stringify(httpData, null, 2));
    
    const processedData = {};
    const timestamp = new Date().toISOString();
    
    for (const [keyword, data] of Object.entries(httpData)) {
      console.log(`प्रोसेसिंग ${keyword}:`, data);
      
      let timelineData = null;
      let isPartial = false;
      
      if (data?.interest_over_time?.timeline_data) {
        timelineData = data.interest_over_time.timeline_data;
        isPartial = data.interest_over_time.isPartial || false;
      } else if (data?.timeline_data) {
        timelineData = data.timeline_data;
      } else if (data?.interest_over_time && Array.isArray(data.interest_over_time)) {
        timelineData = data.interest_over_time;
      }
      
      if (timelineData && Array.isArray(timelineData) && timelineData.length > 0) {
        console.log(`कुल ${timelineData.length} डेटा बिंदु पाए गए ${keyword} के लिए`);
        
        const values = timelineData.map(item => {
          const value = item.value || item.interest || item.score || item.y || 0;
          return parseInt(value) || 0;
        });
        
        const validValues = values.filter(v => v >= 0);
        
        if (validValues.length > 0) {
          const average = Math.round(validValues.reduce((sum, val) => sum + val, 0) / validValues.length);
          const trend = validValues.length >= 2 ? validValues[validValues.length - 1] - validValues[0] : 0;
          const max = Math.max(...validValues);
          const min = Math.min(...validValues);
          
          const recentValues = validValues.slice(-7);
          const earlyValues = validValues.slice(0, 7);
          const recentAvg = recentValues.length > 0 ? recentValues.reduce((a, b) => a + b, 0) / recentValues.length : 0;
          const earlyAvg = earlyValues.length > 0 ? earlyValues.reduce((a, b) => a + b, 0) / earlyValues.length : 0;
          const weeklyTrend = Math.round(recentAvg - earlyAvg);
          
          processedData[keyword] = {
            keyword,
            average,
            trend,
            weeklyTrend,
            values: validValues,
            max,
            min,
            dataPoints: validValues.length,
            isPartial,
            timestamps: timelineData.map(item => item.time || item.date || item.timestamp),
            lastValue: validValues[validValues.length - 1],
            firstValue: validValues[0],
            volatility: Math.round(Math.sqrt(validValues.map(x => Math.pow(x - average, 2)).reduce((a, b) => a + b, 0) / validValues.length)),
            status: 'सफलता'
          };
        } else {
          processedData[keyword] = {
            keyword,
            average: 0,
            trend: 0,
            weeklyTrend: 0,
            values: [],
            max: 0,
            min: 0,
            dataPoints: 0,
            isPartial: false,
            error: "समयरेखा डेटा में कोई मान्य मान नहीं मिला",
            status: 'त्रुटि',
            rawTimelineLength: timelineData.length
          };
        }
      } else {
        processedData[keyword] = {

संक्षेपण = {
  समयस्टाम्प,
  कुल कीवर्ड: ऑब्जेक्ट कीज (प्रोसेस डेटा).लंबाई,
  सफल कीवर्ड: ऑब्जेक्ट वैल्यूज (प्रोसेस डेटा).फिल्टर(d => d.स्थिति === 'सफलता').लंबाई,
  अवधि: "आज 1-म",
  डेटा: प्रोसेस डेटा
};

कंसोल.log("अंतिम प्रोसेस किया हुआ डेटा:", JSON.stringify(संक्षेपण, null, 2));
लौटाएँ संक्षेपण;

---

यह स्क्रैपलेस द्वारा लौटाए गए डेटा के आधार पर निम्नलिखित मीट्रिक की गणना करेगा:

* **औसत मूल्य**
* **साप्ताहिक प्रवृत्ति में बदलाव** (अंतिम 7 दिन बनाम पिछले 7 दिन)
* **अधिकतम / न्यूनतम मान**
* **अस्थिरता**

**नोट:**

* प्रत्येक कीवर्ड एक विस्तृत विश्लेषण ऑब्जेक्ट उत्पन्न करेगा, जिससे दृश्यता और आगे की सूचनाओं के लिए आसान हो जाएगा।

### चरण 4 - डिस्कॉर्ड_नोटिफाई (विश्लेषण रिपोर्ट को डिस्कॉर्ड में पुश करें)

![चरण 4 - डिस्कॉर्ड_नोटिफाई (विश्लेषण रिपोर्ट को डिस्कॉर्ड में पुश करें)](https://assets.scrapeless.com/prod/posts/build-google-trends-monitor-with-pipedream/f18726b4fe24fa4e2815d32624288b79.png)

1. अंतिम Node.js चरण जोड़ें, निम्नलिखित कोड उदाहरण है

const डिस्कॉर्डवेबहुकयूआरएल = "https://discord.com/api/webhooks/1380448411299614821/MXzmQ14TOPK912lWhle_7qna2VQJBjWrdCkmHjdEloHKhYXw0fpBrp-0FS4MDpDB8tGh";

कंसोल.log("डिस्कॉर्ड के लिए डेटा प्रोसेसिंग:", JSON.stringify(प्रोसेस डेटा, null, 2));

const वर्तमान दिनांक = नया तारीख().toLocaleString('en-US');

const कीवर्ड = ऑब्जेक्ट वैल्यूज (प्रोसेस डेटा.डेटा);
const सफल = कीवर्ड.फिल्टर(k => k.स्थिति === 'सफलता');

let सबसे अच्छा प्रदर्शन करने वाला = शून्य;
let सबसे खराब प्रदर्शन करने वाला = शून्य;
let सबसे मजबूत प्रवृत्ति = शून्य;

यदि (सफल.लंबाई > 0) {
  सबसे अच्छा प्रदर्शन करने वाला = सफल.घटा (अधिकतम, वर्तमान) => वर्तमान.औसत > अधिकतम.औसत ? वर्तमान : अधिकतम);
  सबसे खराब प्रदर्शन करने वाला = सफल.घटा (न्यूनतम, वर्तमान) => वर्तमान.औसत < न्यूनतम.औसत ? वर्तमान : न्यूनतम);
  सबसे मजबूत प्रवृत्ति = सफल.घटा (अधिकतम, वर्तमान) => Math.abs(वर्तमान.साप्ताहिक प्रवृत्ति) > Math.abs(अधिकतम.साप्ताहिक प्रवृत्ति) ? वर्तमान : अधिकतम);
}

const डिस्कॉर्ड संदेश = {
  सामग्री: `📊 **गूगल ट्रेंड्स रिपोर्ट** - ${वर्तमान दिनांक}`,
  एम्बेड्स: [
    {
      शीर्षक: "🔍 प्रवृत्तियों का विश्लेषण",
      रंग: 3447003,
      समयस्टाम्प: नया दिनांक().toISOString(),
      क्षेत्र: [
        {
          नाम: "📈 संक्षेपण",
          मान: `**अवधि:** पिछले महीने\n**विश्लेषित कीवर्ड:** ${प्रोसेस डेटा.कुल कीवर्ड}\n**सफलता:** ${प्रोसेस डेटा.सफल कीवर्ड}/${प्रोसेस डेटा.कुल कीवर्ड}`,
          अंतर्निहित: गलत
        }
      ]
    }
  ]
};

यदि (सफल.लंबाई > 0) {
  const कीवर्ड विवरण = सफल.मानचित्र (डेटा => {
    const प्रवृत्ति आइकन = डेटा.साप्ताहिक प्रवृत्ति > 5 ? '🚀' : 
                     डेटा.साप्ताहिक प्रवृत्ति > 0 ? '📈' : 
                     डेटा.साप्ताहिक प्रवृत्ति < -5 ? '📉' : 
                     डेटा.साप्ताहिक प्रवृत्ति < 0 ? '⬇️' : '➡️';
    
    const प्रदर्शन आइकन = डेटा.औसत > 70 ? '🔥' : 
                           डेटा.औसत > 40 ? '✅' : 
                           डेटा.औसत > 20 ? '🟡' : '🔴';
    
    लौटाना {
      नाम: `${प्रदर्शन आइकन} ${डेटा.कीवर्ड}`,
      मान: `**स्कोर:** ${डेटा.औसत}/100\n**प्रवृत्ति:** ${प्रवृत्ति आइकन} ${डेटा.साप्ताहिक प्रवृत्ति > 0 ? '+' : ''}${डेटा.साप्ताहिक प्रवृत्ति}\n**रेंज:** ${डेटा.न्यूनतम}-${डेटा.अधिकतम}`,
      अंतर्निहित: सच
    };
  });
  
  डिस्कॉर्ड संदेश.एम्बेड्स[0].क्षेत्र.push(...कीवर्ड विवरण);
}

यदि (सबसे अच्छा प्रदर्शन करने वाला && सफल.लंबाई > 1) {
  डिस्कॉर्ड संदेश.एम्बेड्स.push({
    शीर्षक: "🏆 कुंजी हाइलाइट",
    रंग: 15844367,
    क्षेत्र: [
      {
        नाम: "🥇 शीर्ष प्रदर्शन करने वाला",
        मान: `**${सबसे अच्छा प्रदर्शन करने वाला.कीवर्ड}** (${सबसे अच्छा प्रदर्शन करने वाला.औसत}/100)`,
        अंतर्निहित: सच
      },
      {
        नाम: "📊 सबसे कम स्कोर",
        मान: `**${सबसे खराब प्रदर्शन करने वाला.कीवर्ड}** (${सबसे खराब प्रदर्शन करने वाला.औसत}/100)`,
        अंतर्निहित: सच
      },
      {
        नाम: "⚡ सबसे मजबूत प्रवृत्ति",
        मान: `**${सबसे मजबूत प्रवृत्ति.कीवर्ड}** (${सबसे मजबूत प्रवृत्ति.साप्ताहिक प्रवृत्ति > 0 ? '+' : ''}${सबसे मजबूत प्रवृत्ति.साप्ताहिक प्रवृत्ति})`,
        अंतर्निहित: सच
      }
    ]
  });
}

const असफल = कीवर्ड.फिल्टर(k => k.स्थिति === 'त्रुटि');
यदि (असफल.लंबाई > 0) {
  डिस्कॉर्ड संदेश.एम्बेड्स.push({
    शीर्षक: "❌ त्रुटियाँ",
    रंग: 15158332,
    क्षेत्र: असफल.मानचित्र (डेटा => ({
      नाम: डेटा.कीवर्ड,
      मान: डेटा.त्रुटि || "अज्ञात त्रुटि",
      अंतर्निहित: सच
    }))
  });

}
    
console.log("डिस्कॉर्ड संदेश भेजने के लिए:", JSON.stringify(discordMessage, null, 2));
    
try {
  const response = await axios($, {
    method: 'POST',
    url: discordWebhookUrl,
    headers: {
      'Content-Type': 'application/json'
    },
    data: discordMessage
  });
  
  console.log("डिस्कॉर्ड वेबहुक प्रतिक्रिया:", response);
  
  return {
    webhook_sent: true,
    platform: "discord",
    message_sent: true,
    keywords_analyzed: processedData.totalKeywords,
    successful_keywords: processedData.successfulKeywords,
    timestamp: currentDate,
    discord_response: response
  };
  
} catch (error) {
  console.error("डिस्कॉर्ड वेबहुक त्रुटि:", error);
  
  const simpleMessage = {
    content: `📊 **गूगल ट्रेंड रिपोर्ट - ${currentDate}**\n\n` +
            `📈 **परिणाम (${processedData.successfulKeywords}/${processedData.totalKeywords}):**\n` +
            successful.map(data => 
              `• **${data.keyword}**: ${data.average}/100 (${data.weeklyTrend > 0 ? '+' : ''}${data.weeklyTrend})`
            ).join('\n') +
            (failed.length > 0 ? `\n\n❌ **त्रुटियाँ:** ${failed.map(d => d.keyword).join(', ')}` : '')
  };
  
  try {
    const fallbackResponse = await axios($, {
      method: 'POST',
      url: discordWebhookUrl,
      headers: {
        'Content-Type': 'application/json'
      },
      data: simpleMessage
    });
    
    return {
      webhook_sent: true,
      platform: "discord",
      message_sent: true,
      fallback_used: true,
      discord_response: fallbackResponse
    };
    
  } catch (fallbackError) {
    console.error("डिस्कॉर्ड फॉलबैक त्रुटि:", fallbackError);
    
    return {
      webhook_sent: false,
      platform: "discord",
      error: error.message,
      fallback_error: fallbackError.message,
      data_summary: {
        keywords: processedData.totalKeywords,
        successful: processedData.successfulKeywords,
        best_performer: bestPerformer?.keyword,
        best_score: bestPerformer?.average
      }
    };
  }
}
},
})