چگونه من 10 ساعت در هفته با اسکریپت های اتوماسیون Node.js ذخیره می کنم

const axios = require('axios');
const nodemailer = require('nodemailer');
const fs = require('fs');
const moment = require('moment');

async function generateReport() {
  // Get date range for the past week
  const endDate = moment().format('YYYY-MM-DD');
  const startDate = moment().subtract(7, 'days').format('YYYY-MM-DD');

  console.log(`Generating report for ${startDate} to ${endDate}...`);

  try {
    // Fetch data with proper authentication
    const { data } = await axios.get('https://client-cms.com/api/posts', {
      headers: { 'Authorization': `Bearer ${process.env.API_KEY}` },
      params: { start: startDate, end: endDate }
    });

    // Process the data into a readable format
    const reportData = {
      totalPosts: data.length,
      viewCount: data.reduce((sum, post) => sum + post.views, 0),
      topPerforming: data.sort((a, b) => b.views - a.views).slice(0, 5),
      dateRange: { startDate, endDate }
    };

    // Write formatted report
    const reportPath = `./reports/weekly-report-${endDate}.json`;
    fs.writeFileSync(reportPath, JSON.stringify(reportData, null, 2));

    return reportPath;
  } catch (error) {
    console.error('Error generating report:', error.message);
    throw error;
  }
}

async function sendEmail(reportPath) {
  // Create reusable transporter using environment variables for security
  let transporter = nodemailer.createTransport({
    service: 'gmail',
    auth: {
      user: process.env.EMAIL_USER,
      pass: process.env.EMAIL_PASS,
    },
  });

  // Format date for email subject
  const reportDate = moment().format('MMMM D, YYYY');

  // Send mail with defined transport object
  await transporter.sendMail({
    from: '"Weekly Report Bot" ',
    to: 'client@example.com, account-manager@youragency.com',
    subject: `Content Performance Report - Week of ${reportDate}`,
    text: `Please find attached the weekly content performance report for ${reportDate}.`,
    attachments: [{ filename: `weekly-report-${reportDate}.json`, path: reportPath }],
  });

  console.log('Report sent successfully!');
}

// Run the workflow
generateReport()
  .then(sendEmail)
  .catch(err => console.error('Workflow failed:', err));

const chokidar = require('chokidar');
const sharp = require('sharp');
const path = require('path');
const fs = require('fs');

// Create output directory if it doesn't exist
const outputDir = './processed-images';
if (!fs.existsSync(outputDir)) {
  fs.mkdirSync(outputDir);
}

// Set up file watcher
const watcher = chokidar.watch('./incoming-images', {
  ignored: /(^|\/)\.[^\/\.]/g, // ignore dotfiles
  persistent: true
});

// Process function to resize and center image on white background
async function processImage(filePath) {
  const fileName = path.basename(filePath);
  const outputPath = path.join(outputDir, fileName);

  try {
    // Get image dimensions
    const metadata = await sharp(filePath).metadata();

    // Create 1200x1200 white canvas
    const canvas = sharp({
      create: {
        width: 1200,
        height: 1200,
        channels: 4,
        background: { r: 255, g: 255, b: 255, alpha: 1 }
      }
    });

    // Resize original image to fit within 1100x1100 (leaving some margins)
    const resized = await sharp(filePath)
      .resize(1100, 1100, { 
        fit: 'contain',
        background: { r: 0, g: 0, b: 0, alpha: 0 }
      })
      .toBuffer();

    // Composite resized image onto white canvas (centered)
    await canvas.composite([{ 
      input: resized,
      gravity: 'center'
    }])
    .toFile(outputPath);

    console.log(`✅ Processed: ${fileName}`);
  } catch (err) {
    console.error(`❌ Error processing ${fileName}:`, err);
  }
}

// Set up watcher events
watcher
  .on('add', filePath => {
    console.log(`File added: ${filePath}`);
    processImage(filePath);
  })
  .on('error', error => console.error(`Watcher error: ${error}`));

console.log('Image processor running! Drop files into ./incoming-images');

const csv = require('csvtojson');
const axios = require('axios');
const fs = require('fs');
const path = require('path');

// Configuration
const API_ENDPOINT = 'https://api.client-store.com/products';
const API_KEY = process.env.PRODUCT_API_KEY;
const csvFilePath = process.argv[2] || './product-updates.csv';

if (!fs.existsSync(csvFilePath)) {
  console.error(`Error: File not found at ${csvFilePath}`);
  process.exit(1);
}

// Setup API client
const api = axios.create({
  baseURL: API_ENDPOINT,
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  }
});

async function updateProducts() {
  // Keep track of success/failure
  const results = {
    success: 0,
    failed: 0,
    errors: []
  };

  try {
    // Parse CSV to JSON
    const products = await csv().fromFile(csvFilePath);
    console.log(`Found ${products.length} products to update`);

    // Process each product
    for (let [index, product] of products.entries()) {
      try {
        // Simple validation
        if (!product.id || !product.sku) {
          throw new Error('Missing required product identifier (id or sku)');
        }

        console.log(`[${index + 1}/${products.length}] Updating product ${product.sku}...`);

        // Send update to API
        await api.put(`/${product.id}`, product);
        results.success++;

      } catch (err) {
        results.failed++;
        results.errors.push(`Product ${product.sku || index}: ${err.message}`);
        console.error(`  Failed: ${err.message}`);
      }

      // Small delay to avoid rate limiting
      await new Promise(resolve => setTimeout(resolve, 100));
    }

    // Log results
    console.log('\n--- Update Complete ---');
    console.log(`✅ Successfully updated: ${results.success} products`);
    console.log(`❌ Failed updates: ${results.failed} products`);

    if (results.errors.length > 0) {
      fs.writeFileSync(
        './update-errors.log', 
        results.errors.join('\n'), 
        'utf8'
      );
      console.log('See update-errors.log for details on failed updates');
    }

  } catch (err) {
    console.error('Fatal error:', err);
  }
}

updateProducts();

// Bad
await processFile(filePath);

// Good
console.log(`Starting to process: ${filePath}`);
try {
  await processFile(filePath);
  console.log(`Successfully processed: ${filePath}`);
} catch (err) {
  console.error(`Failed to process ${filePath}: ${err.message}`);
}