Hệ thống Báo cáo Tự động Google Trends (Pipedream + Scrapeless + Discord)

import { axios } from "@pipedream/platform"

export default defineComponent({
  async run({ steps, $ }) {
    const keywords = ["AI", "Học Máy", "Khoa Học Dữ Liệu"];
    const allResults = {};
    
    for (const keyword of keywords) {
      console.log(`Đang xử lý từ khóa: ${keyword}`);
      
      const payload = {
        actor: "scraper.google.trends",
        input: {
          q: keyword,
          date: "hôm nay 1-tháng",
          data_type: "interest_over_time",
          hl: "vi",
          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(`Phản hồi cho ${keyword}:`, response);
        
        if (response.job_id) {
          console.log(`Công việc đã được tạo cho ${keyword}, ID: ${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(`Cố gắng ${attempts} cho ${keyword}:`, resultResponse);
              
              if (resultResponse.status === 'completed') {
                jobResult = resultResponse.result;
```javascript
console.log(`Công việc đã hoàn thành cho ${keyword}:`, jobResult);
                break;
              } else if (resultResponse.status === 'failed') {
                console.error(`Công việc thất bại cho ${keyword}:`, resultResponse);
                break;
              } else {
                console.log(`Công việc vẫn đang chạy cho ${keyword}, trạng thái: ${resultResponse.status}`);
              }
            } catch (error) {
              console.error(`Lỗi kiểm tra trạng thái công việc cho ${keyword}:`, error);
            }
          }
          
          if (jobResult) {
            allResults[keyword] = jobResult;
          } else {
            allResults[keyword] = { 
              error: `Công việc hết thời gian hoặc thất bại sau ${attempts} lần thử`,
              job_id: response.job_id 
            };
          }
          
        } else {
          allResults[keyword] = response;
        }
        
      } catch (error) {
        console.error(`Lỗi cho ${keyword}:`, error);
        allResults[keyword] = { 
          error: `Yêu cầu thất bại: ${error.message}` 
        };
      }
    }
    
    console.log("Kết quả cuối cùng:", JSON.stringify(allResults, null, 2));
    return allResults;
  },
})

từ khóa,
          trung bình: 0,
          xu hướng: 0,
          xu hướng hàng tuần: 0,
          giá trị: [],
          tối đa: 0,
          tối thiểu: 0,
          điểm dữ liệu: 0,
          là một phần: sai,
          lỗi: "Không tìm thấy dữ liệu thời gian",
          trạng thái: 'lỗi',
          các khóa có sẵn: dữ liệu ? Object.keys(data) : []
        };
      }
    }
    
    tóm tắt = {
      dấu thời gian,
      tổng số từ khóa: Object.keys(processedData).length,
      từ khóa thành công: Object.values(processedData).filter(d => d.status === 'success').length,
      khoảng thời gian: "hôm nay 1-m",
      dữ liệu: processedData
    };
    
    console.log("Dữ liệu đã xử lý cuối cùng:", JSON.stringify(tóm tắt, null, 2));
    return tóm tắt;
  },
})

import { axios } từ "@pipedream/platform"

xuất mặc định defineComponent({
  async run({ steps, $ }) {
    const processedData = steps.Code_step.$return_value;
    
    const discordWebhookUrl = "https://discord.com/api/webhooks/1380448411299614821/MXzmQ14TOPK912lWhle_7qna2VQJBjWrdCkmHjdEloHKhYXw0fpBrp-0FS4MDpDB8tGh";
    
    console.log("Đang xử lý dữ liệu cho Discord:", JSON.stringify(processedData, null, 2));
    
    const currentDate = new Date().toLocaleString('en-US');
    
    const keywords = Object.values(processedData.data);
    const successful = keywords.filter(k => k.status === 'success');
    
    let bestPerformer = null;
    let worstPerformer = null;
    let strongestTrend = null;
    
    if (successful.length > 0) {
      bestPerformer = successful.reduce((max, curr) => curr.average > max.average ? curr : max);
      worstPerformer = successful.reduce((min, curr) => curr.average < min.average ? curr : min);
      strongestTrend = successful.reduce((max, curr) => Math.abs(curr.weeklyTrend) > Math.abs(max.weeklyTrend) ? curr : max);
    }
    
    const discordMessage = {
      content: `📊 **Báo cáo Google Trends** - ${currentDate}`,
      embeds: [
        {
          title: "🔍 Phân tích Xu hướng",
          color: 3447003,
          timestamp: new Date().toISOString(),
          fields: [
            {
              name: "📈 Tóm tắt",
              value: `**Thời gian:** Tháng trước\n**Từ khóa đã phân tích:** ${processedData.totalKeywords}\n**Thành công:** ${processedData.successfulKeywords}/${processedData.totalKeywords}`,
              inline: false
            }
          ]
        }
      ]
    };
    
    if (successful.length > 0) {
      const keywordDetails = successful.map(data => {
        const trendIcon = data.weeklyTrend > 5 ? '🚀' : 
                         data.weeklyTrend > 0 ? '📈' : 
                         data.weeklyTrend < -5 ? '📉' : 
                         data.weeklyTrend < 0 ? '⬇️' : '➡️';
        
        const performanceIcon = data.average > 70 ? '🔥' : 
                               data.average > 40 ? '✅' : 
                               data.average > 20 ? '🟡' : '🔴';
        
        return {
          name: `${performanceIcon} ${data.keyword}`,
          value: `**Điểm:** ${data.average}/100\n**Xu hướng:** ${trendIcon} ${data.weeklyTrend > 0 ? '+' : ''}${data.weeklyTrend}\n**Phạm vi:** ${data.min}-${data.max}`,
          inline: true
        };
      });
      
      discordMessage.embeds[0].fields.push(...keywordDetails);
    }
    
    if (bestPerformer && successful.length > 1) {
      discordMessage.embeds.push({
        title: "🏆 Điểm nổi bật chính",
        color: 15844367,
        fields: [
          {
            name: "🥇 Người thực hiện hàng đầu",
            value: `**${bestPerformer.keyword}** (${bestPerformer.average}/100)`,
            inline: true
          },
          {
            name: "📊 Điểm thấp nhất",
            value: `**${worstPerformer.keyword}** (${worstPerformer.average}/100)`,
            inline: true
          },
          {
            name: "⚡ Xu hướng mạnh nhất",
            value: `**${strongestTrend.keyword}** (${strongestTrend.weeklyTrend > 0 ? '+' : ''}${strongestTrend.weeklyTrend})`,
            inline: true
          }
        ]
      });
    }
    
    const failed = keywords.filter(k => k.status === 'error');
    if (failed.length > 0) {
      discordMessage.embeds.push({
        title: "❌ Lỗi",
        color: 15158332,
        fields: failed.map(data => ({
          name: data.keyword,
          value: data.error || "Lỗi không rõ",
          inline: true
        }))
      });

}
    
    console.log("Tin nhắn Discord để gửi:", JSON.stringify(discordMessage, null, 2));
    
    try {
      const response = await axios($, {
        method: 'POST',
        url: discordWebhookUrl,
        headers: {
          'Content-Type': 'application/json'
        },
        data: discordMessage
      });
      
      console.log("Phản hồi webhook Discord:", 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("Lỗi webhook Discord:", error);
      
      const simpleMessage = {
        content: `📊 **Báo cáo Google Trends - ${currentDate}**\n\n` +
                `📈 **Kết quả (${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❌ **Lỗi:** ${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("Lỗi dự phòng Discord:", 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
          }
        };
      }
    }
  },
})