WooCommerce RESTful API: מדריך מקיף למפתחים 2025

במדריך זה נלמד:

הקמת והגדרת WooCommerce API
אותנטיקציה ואבטחה
עבודה עם נקודות קצה (Endpoints)
ניהול מוצרים והזמנות דרך API
אינטגרציה עם מערכות חיצוניות

1. הקדמה ל-WooCommerce API

ב-2025, ה-REST API של WooCommerce הפך לכלי חיוני עבור מפתחים וחברות בניית אתרים המעוניינים לבנות אינטגרציות מתקדמות עם חנויות מקוונות. הגרסה העדכנית תומכת ב-GraphQL לצד REST המסורתי, ומציעה יכולות מתקדמות לניהול מלאי בזמן אמת, סנכרון מול מערכות ERP, ואוטומציה של תהליכי מכירה.

2. הגדרת API והאותנטיקציה

# יצירת מפתחות API בצד השרת
function generate_api_keys() {
    // יצירת Consumer Key
    $consumer_key = 'ck_' . wc_rand_hash();
    
    // יצירת Consumer Secret
    $consumer_secret = 'cs_' . wc_rand_hash();
    
    // שמירת המפתחות במסד הנתונים
    update_option('woocommerce_api_keys', [
        'consumer_key' => $consumer_key,
        'consumer_secret' => $consumer_secret
    ]);
    
    return [
        'consumer_key' => $consumer_key,
        'consumer_secret' => $consumer_secret
    ];
}

2.1 יישום אותנטיקציה בסיסית

9. אוטומציה ותזמון משימות

class WC_Task_Scheduler {
    private $wc_api;
    private $schedule = [
        'inventory_sync' => '*/30 * * * *',    // כל 30 דקות
        'price_update' => '0 */4 * * *',       // כל 4 שעות
        'order_export' => '0 */2 * * *',       // כל שעתיים
        'performance_report' => '0 0 * * *'     // פעם ביום
    ];
    
    public function __construct() {
        $this->wc_api = new WC_API_Handler();
        $this->register_cron_tasks();
    }
    
    private function register_cron_tasks() {
        foreach ($this->schedule as $task => $schedule) {
            if (!wp_next_scheduled("wc_api_{$task}")) {
                wp_schedule_event(time(), $schedule, "wc_api_{$task}");
            }
            
            add_action("wc_api_{$task}", [$this, $task]);
        }
    }
    
    public function inventory_sync() {
        try {
            $inventory_manager = new Inventory_Manager($this->wc_api);
            $result = $inventory_manager->sync_with_external_system();
            
            $this->log_task_result('inventory_sync', $result);
        } catch (Exception $e) {
            $this->handle_task_error('inventory_sync', $e);
        }
    }
    
    public function price_update() {
        try {
            $price_manager = new Price_Manager($this->wc_api);
            
            // עדכון מחירים לפי כללים עסקיים
            $rules = $this->get_price_update_rules();
            foreach ($rules as $rule) {
                $price_manager->apply_price_rule($rule);
            }
            
            $this->log_task_result('price_update', 'Success');
        } catch (Exception $e) {
            $this->handle_task_error('price_update', $e);
        }
    }
    
    private function handle_task_error($task, $error) {
        error_log("WC API Task Error - {$task}: " . $error->getMessage());
        
        // שליחת התראה
        wp_mail(
            get_option('admin_email'),
            "WooCommerce API Task Failed: {$task}",
            $error->getMessage()
        );
        
        // תיעוד השגיאה
        $this->log_task_result($task, 'Failed: ' . $error->getMessage());
    }
    
    private function get_price_update_rules() {
        return [
            [
                'type' => 'category_discount',
                'category_id' => 15,
                'discount' => 10
            ],
            [
                'type' => 'bulk_markup',
                'condition' => 'stock > 100',
                'markup' => 5
            ],
            [
                'type' => 'clearance',
                'condition' => 'stock < 5', 'discount' => 20
            ]
        ];
    }
}

10. ניתוח ביצועים ואופטימיזציה

class Performance_Analyzer {
    private $metrics = [];
    private $thresholds = [
        'response_time' => 2.0,    // שניות
        'error_rate' => 0.05,      // 5%
        'success_rate' => 0.95     // 95%
    ];
    
    public function analyze_api_performance($time_range = '24h') {
        $logs = $this->get_api_logs($time_range);
        
        $analysis = [
            'total_requests' => count($logs),
            'success_count' => 0,
            'error_count' => 0,
            'avg_response_time' => 0,
            'endpoints' => []
        ];
        
        foreach ($logs as $log) {
            // ניתוח לפי נקודת קצה
            $endpoint = $log['endpoint'];
            if (!isset($analysis['endpoints'][$endpoint])) {
                $analysis['endpoints'][$endpoint] = [
                    'calls' => 0,
                    'errors' => 0,
                    'avg_time' => 0
                ];
            }
            
            $analysis['endpoints'][$endpoint]['calls']++;
            
            if ($log['status'] >= 400) {
                $analysis['error_count']++;
                $analysis['endpoints'][$endpoint]['errors']++;
            } else {
                $analysis['success_count']++;
            }
            
            $analysis['avg_response_time'] += $log['response_time'];
            $analysis['endpoints'][$endpoint]['avg_time'] += $log['response_time'];
        }
        
        // חישוב ממוצעים
        if ($analysis['total_requests'] > 0) {
            $analysis['avg_response_time'] /= $analysis['total_requests'];
            
            foreach ($analysis['endpoints'] as &$endpoint_data) {
                $endpoint_data['avg_time'] /= $endpoint_data['calls'];
            }
        }
        
        return $this->generate_recommendations($analysis);
    }
    
    private function generate_recommendations($analysis) {
        $recommendations = [];
        
        // בדיקת זמני תגובה
        if ($analysis['avg_response_time'] > $this->thresholds['response_time']) {
            $recommendations[] = [
                'type' => 'performance',
                'severity' => 'high',
                'message' => 'Average response time exceeds threshold',
                'action' => 'Consider implementing caching or optimizing queries'
            ];
        }
        
        // בדיקת שיעור שגיאות
        $error_rate = $analysis['error_count'] / $analysis['total_requests'];
        if ($error_rate > $this->thresholds['error_rate']) {
            $recommendations[] = [
                'type' => 'reliability',
                'severity' => 'high',
                'message' => 'High error rate detected',
                'action' => 'Review error logs and implement better error handling'
            ];
        }
        
        // ניתוח נקודות קצה בעייתיות
        foreach ($analysis['endpoints'] as $endpoint => $data) {
            $endpoint_error_rate = $data['errors'] / $data['calls'];
            
            if ($endpoint_error_rate > $this->thresholds['error_rate']) {
                $recommendations[] = [
                    'type' => 'endpoint',
                    'severity' => 'medium',
                    'message' => "High error rate for endpoint: {$endpoint}",
                    'action' => 'Review endpoint implementation and error handling'
                ];
            }
            
            if ($data['avg_time'] > $this->thresholds['response_time']) {
                $recommendations[] = [
                    'type' => 'endpoint',
                    'severity' => 'medium',
                    'message' => "Slow response time for endpoint: {$endpoint}",
                    'action' => 'Optimize endpoint performance'
                ];
            }
        }
        
        return $recommendations;
    }
}

11. שאלות נפוצות ופתרונות

11.1 בעיות נפוצות ופתרונן

בעיה	סיבה אפשרית	פתרון
Request Timeout	עיבוד ממושך מדי	שימוש ב-Batch Requests או Async Processing
Authentication Failed	מפתחות API לא תקינים	וידוא תקינות המפתחות ורענון במידת הצורך
Too Many Requests	חריגה מ-Rate Limiting	יישום מנגנון תור ו-Throttling

12. מקרי בוחן מהשטח

12.1 סנכרון מלאי בזמן אמת

class RealTime_Inventory_Sync {
    private $wc_api;
    private $external_system;
    private $webhook_handler;
    
    public function __construct() {
        $this->wc_api = new WC_API_Handler();
        $this->external_system = new External_System_Client();
        $this->setup_webhooks();
    }
    
    private function setup_webhooks() {
        add_action('woocommerce_order_status_changed', 
            [$this, 'handle_order_status_change'], 10, 3);
        add_action('woocommerce_product_stock_changed',
            [$this, 'handle_stock_change'], 10, 3);
    }
    
    public function handle_stock_change($product_id, $old_stock, $new_stock) {
        try {
            // עדכון במערכת החיצונית
            $this->external_system->update_stock([
                'product_id' => $product_id,
                'quantity' => $new_stock,
                'timestamp' => current_time('mysql')
            ]);
            
            // תיעוד השינוי
            $this->log_stock_change($product_id, $old_stock, $new_stock);
            
        } catch (Exception $e) {
            // טיפול בשגיאות
            $this->handle_sync_error($e, 'stock_update', $product_id);
        }
    }
    
    public function handle_order_status_change($order_id, $old_status, $new_status) {
        if ($new_status === 'completed') {
            try {
                $order = wc_get_order($order_id);
                foreach ($order->get_items() as $item) {
                    $this->sync_order_item_stock($item);
                }
            } catch (Exception $e) {
                $this->handle_sync_error($e, 'order_completion', $order_id);
            }
        }
    }
    
    private function sync_order_item_stock($item) {
        $product_id = $item->get_product_id();
        $quantity = $item->get_quantity();
        
        // עדכון מלאי במערכת החיצונית
        $this->external_system->update_stock([
            'product_id' => $product_id,
            'quantity_change' => -$quantity,
            'reason' => 'order_completion',
            'timestamp' => current_time('mysql')
        ]);
    }
    
    private function handle_sync_error($error, $context, $reference_id) {
        // תיעוד השגיאה
        error_log("Sync Error ({$context} - ID: {$reference_id}): " . 
            $error->getMessage());
        
        // ניסיון סנכרון מחדש
        $this->schedule_retry($context, $reference_id);
        
        // שליחת התראה
        $this->notify_admin_of_sync_error($error, $context, $reference_id);
    }
}

נקודות מפתח לסיכום:

תמיד לתכנן את האינטגרציה עם חשיבה על סקלביליות
להשתמש במנגנוני Retry וטיפול בשגיאות
לתעד כל פעולה ושינוי
לבצע ניטור מתמיד של ביצועים
לשמור על אבטחה קפדנית

שאלות ותשובות מעמיקות – WooCommerce API

שאלה 1: כיצד ניתן לטפל ביעילות בקריאות API מרובות תוך שמירה על ביצועים טובים?

תשובה:

טיפול יעיל בקריאות API מרובות דורש אסטרטגיה מקיפה הכוללת מספר רבדים. ראשית, חשוב להשתמש ב-Batch Operations כדי לצמצם את מספר הקריאות הנדרשות. במקום לבצע קריאה נפרדת עבור כל פעולה, ניתן לקבץ מספר פעולות יחד.

class API_Batch_Handler {
    private $batch_size = 50;
    private $operations = [];
    
    public function add_operation($type, $data) {
        $this->operations[] = [
            'type' => $type,
            'data' => $data
        ];
        
        // כאשר מגיעים לגודל ה-batch, מבצעים שליחה
        if (count($this->operations) >= $this->batch_size) {
            $this->process_batch();
        }
    }
    
    private function process_batch() {
        $batch_data = [
            'create' => [],
            'update' => [],
            'delete' => []
        ];
        
        foreach ($this->operations as $operation) {
            $batch_data[$operation['type']][] = $operation['data'];
        }
        
        try {
            $response = wp_remote_post(
                site_url('/wp-json/wc/v3/products/batch'),
                [
                    'headers' => $this->get_auth_headers(),
                    'body' => json_encode($batch_data)
                ]
            );
            
            $this->handle_batch_response($response);
            
        } catch (Exception $e) {
            $this->handle_batch_error($e);
        }
        
        // איפוס המערך
        $this->operations = [];
    }
    
    private function handle_batch_response($response) {
        if (is_wp_error($response)) {
            throw new Exception($response->get_error_message());
        }
        
        $body = json_decode(wp_remote_retrieve_body($response), true);
        
        // בדיקת שגיאות ספציפיות
        if (!empty($body['errors'])) {
            foreach ($body['errors'] as $error) {
                error_log("Batch operation error: " . $error['message']);
            }
        }
        
        return $body;
    }
}

שנית, חשוב ליישם מערכת קאשינג יעילה. ניתן להשתמש ב-Object Cache של WordPress או במערכות כמו Redis לשמירת תוצאות של קריאות API נפוצות.

בנוסף, יש ליישם מנגנון Rate Limiting כדי למנוע עומס יתר על השרת. מנגנון זה צריך לווסת את קצב הקריאות ולמנוע חריגה ממגבלות השרת.

לבסוף, חשוב לנהל תור של בקשות במקרים של עומס גבוה. ניתן להשתמש במערכת התורים של WordPress (WP Cron) או במערכת תורים חיצונית.

שאלה 2: איך ניתן להבטיח את אמינות הנתונים בזמן סנכרון בין WooCommerce למערכות חיצוניות?

תשובה:

אמינות הנתונים בסנכרון היא קריטית. ראשית, יש ליישם מנגנון של Transactional Updates – כל פעולת סנכרון צריכה להיות אטומית, כך שאו שהיא מתבצעת במלואה או שלא מתבצעת כלל.

class Sync_Manager {
    private $external_system;
    private $wc_api;
    private $log_manager;
    
    public function sync_product($product_id) {
        global $wpdb;
        
        try {
            // התחלת טרנזקציה
            $wpdb->query('START TRANSACTION');
            
            // קבלת נתוני מוצר מהמערכת החיצונית
            $external_data = $this->external_system->get_product($product_id);
            
            // וידוא תקינות הנתונים
            if (!$this->validate_product_data($external_data)) {
                throw new Exception('Invalid product data');
            }
            
            // עדכון המוצר ב-WooCommerce
            $wc_update = $this->wc_api->update_product($product_id, [
                'name' => $external_data['name'],
                'price' => $external_data['price'],
                'stock_quantity' => $external_data['stock']
            ]);
            
            // וידוא שהעדכון הצליח
            if (!$wc_update) {
                throw new Exception('WooCommerce update failed');
            }
            
            // שמירת לוג הסנכרון
            $this->log_manager->log_sync_success($product_id, $external_data);
            
            // אישור הטרנזקציה
            $wpdb->query('COMMIT');
            
            return true;
            
        } catch (Exception $e) {
            // ביטול הטרנזקציה במקרה של שגיאה
            $wpdb->query('ROLLBACK');
            
            $this->log_manager->log_sync_error($product_id, $e->getMessage());
            return false;
        }
    }
    
    private function validate_product_data($data) {
        $required_fields = ['name', 'price', 'stock'];
        
        foreach ($required_fields as $field) {
            if (!isset($data[$field])) {
                return false;
            }
        }
        
        // וידוא תקינות המחיר
        if (!is_numeric($data['price']) || $data['price'] < 0) {
            return false;
        }
        
        // וידוא תקינות המלאי
        if (!is_int($data['stock']) || $data['stock'] < 0) {
            return false;
        }
        
        return true;
    }
}

שנית, חשוב ליישם מערכת Version Control לנתונים. כל שינוי צריך לכלול חותמת זמן ומזהה גרסה, כך שניתן יהיה לזהות ולפתור קונפליקטים.

בנוסף, יש ליישם מנגנון Retry במקרה של כשלים. המערכת צריכה לנסות לבצע את הסנכרון מספר פעמים לפני שהיא מוותרת, עם השהייה הולכת וגדלה בין הניסיונות.

לבסוף, חשוב לתעד כל פעולת סנכרון ולשמור היסטוריה מלאה של השינויים, כולל מי ביצע אותם ומתי.

שאלה 3: מהן השיטות המומלצות לניטור וטיפול בשגיאות ב-WooCommerce API?

תשובה:

ניטור וטיפול בשגיאות הם קריטיים להצלחת האינטגרציה. ראשית, יש להקים מערכת ניטור מקיפה שתעקוב אחר כל הקריאות וההצלחות/כשלונות שלהן.

class API_Monitor {
    private $metrics = [];
    private $error_threshold = [
        'rate' => 0.05,     // 5% שגיאות מקסימום
        'count' => 50       // 50 שגיאות מקסימום בשעה
    ];
    
    public function track_request($endpoint, $method, $response) {
        $status = wp_remote_retrieve_response_code($response);
        $timestamp = time();
        
        // שמירת המטריקה
        $this->metrics[] = [
            'endpoint' => $endpoint,
            'method' => $method,
            'status' => $status,
            'timestamp' => $timestamp,
            'response_time' => $this->calculate_response_time($response)
        ];
        
        // בדיקת חריגות
        $this->check_error_threshold();
    }
    
    private function check_error_threshold() {
        $recent_metrics = array_filter($this->metrics, function($metric) {
            return $metric['timestamp'] > (time() - 3600);
        });
        
        $error_count = count(array_filter($recent_metrics, function($metric) {
            return $metric['status'] >= 400;
        }));
        
        $error_rate = $error_count / count($recent_metrics);
        
        if ($error_rate > $this->error_threshold['rate'] || 
            $error_count > $this->error_threshold['count']) {
            $this->trigger_alert([
                'type' => 'high_error_rate',
                'rate' => $error_rate,
                'count' => $error_count
            ]);
        }
    }
    
    private function trigger_alert($alert_data) {
        // שליחת התראה למנהל
        $message = sprintf(
            'API Error Alert: Rate %.2f%%, Count: %d',
            $alert_data['rate'] * 100,
            $alert_data['count']
        );
        
        wp_mail(
            get_option('admin_email'),
            'WooCommerce API Alert',
            $message
        );
        
        // תיעוד ההתראה
        error_log("WooCommerce API Alert: " . json_encode($alert_data));
    }
    
    public function generate_report() {
        $report = [
            'total_requests' => count($this->metrics),
            'error_rate' => $this->calculate_error_rate(),
            'avg_response_time' => $this->calculate_avg_response_time(),
            'endpoints' => $this->analyze_endpoints()
        ];
        
        return $report;
    }
}

שנית, יש ליישם מערכת לוגים מפורטת שתתעד כל שגיאה עם מספיק מידע לשחזור ופתרון הבעיה. זה כולל את הבקשה המקורית, התגובה שהתקבלה, וכל מידע רלוונטי נוסף.

חשוב גם ליישם מנגנון התאוששות אוטומטי מכשלים. המערכת צריכה לזהות סוגים שונים של שגיאות ולהגיב בהתאם – למשל, ניסיון חוזר במקרה של שגיאות רשת, או התראה למנהל במקרה של שגיאות חמורות יותר.

לבסוף, מומלץ להגדיר KPIs ברורים לביצועי ה-API ולנטר אותם באופן שוטף. זה יכול לכלול מדדים כמו זמני תגובה, שיעור הצלחה, וזמינות המערכת.
כמובן שבמידה והדברים לא ברורים יש להתייעץ עם מומחה בניית אתרים

חפשו גם:

חברה לבניית אתרים

מומחה בניית אתרים

בניית אתרים תדמית

בניית אתר מכירות/ סחר

בניית אתרי קטלוג

בניית אתרים בהתאמה אישית