track_click($ref, $landing, $camp ?: null, $event_id, $occurred_at, $user_agent); } // Un 4xx di validazione torna come array (401/402/403 e 5xx tornano // null dalla 0.17.0): l'unica prova di successo e' `ok`. if (!$result || empty($result['ok'])) { self::queue_click($event_id, $ref, $landing, $camp ?: null, $occurred_at, $user_agent); set_transient('atcwc_click_pause', 1, 300); } else { delete_transient('atcwc_click_pause'); } $days = ($result && isset($result['cookie_days'])) ? (int) $result['cookie_days'] : 30; setcookie(ATCWC_COOKIE, $ref, time() + $days * DAY_IN_SECONDS, '/', '', is_ssl(), true); $_COOKIE[ATCWC_COOKIE] = $ref; // La campagna viaggia in un cookie a parte: cambiare il formato di // `atcwc_ref` invaliderebbe i cookie gia' in giro. if ($camp) { setcookie(ATCWC_CAMP_COOKIE, $camp, time() + $days * DAY_IN_SECONDS, '/', '', is_ssl(), true); $_COOKIE[ATCWC_CAMP_COOKIE] = $camp; } elseif (isset($_COOKIE[ATCWC_CAMP_COOKIE])) { // Nuovo referral senza campagna: quella vecchia non vale piu'. setcookie(ATCWC_CAMP_COOKIE, '', time() - DAY_IN_SECONDS, '/', '', is_ssl(), true); unset($_COOKIE[ATCWC_CAMP_COOKIE]); } } /* ——— Coda dei click ——— */ private static function click_sending_paused() { return (bool) get_transient('atcwc_click_pause'); } private static function queue_click($event_id, $ref, $landing, $camp, $occurred_at, $user_agent) { global $wpdb; // INSERT diretta e non $wpdb->insert() per via di IGNORE: un doppione // sullo stesso event_id non deve generare un errore nei log. $table = atcwc_click_queue_table(); $wpdb->query( $wpdb->prepare( "INSERT IGNORE INTO %i (event_id, referral_code, landing_url, campaign, user_agent, occurred_at, attempts) VALUES (%s, %s, %s, %s, %s, %s, 0)", $table, $event_id, $ref, substr($landing, 0, 512), $camp, (string) $user_agent, gmdate('Y-m-d H:i:s', strtotime($occurred_at)) ) ); } /** * Svuota la coda dei click. Chiamata dal cron orario. * * Cancella sia gli accettati sia i rifiutati in via definitiva (codice * referral non piu' valido, troppo vecchi): se restassero, riproverebbero * all'infinito. */ private static function flush_click_queue($api) { global $wpdb; $table = atcwc_click_queue_table(); // Rete di sicurezza: un negozio scollegato per mesi si porterebbe // dietro una coda che la piattaforma rifiuta comunque (oltre 90 giorni). $wpdb->query($wpdb->prepare('DELETE FROM %i WHERE occurred_at < DATE_SUB(UTC_TIMESTAMP(), INTERVAL 90 DAY) OR attempts >= 50', $table)); $rows = $wpdb->get_results($wpdb->prepare('SELECT event_id, referral_code, landing_url, campaign, user_agent, occurred_at FROM %i ORDER BY occurred_at ASC LIMIT 200', $table), ARRAY_A); if (empty($rows)) { return; } $payload = array(); foreach ($rows as $r) { $click = array( 'client_event_id' => $r['event_id'], 'referral_code' => $r['referral_code'], 'landing_url' => $r['landing_url'], 'campaign' => $r['campaign'], 'occurred_at' => gmdate('c', strtotime($r['occurred_at'] . ' UTC')), ); // NULL = accodato prima della 0.19.0: senza il campo la // piattaforma lo conta come sempre, con un vuoto sarebbe un bot. if (null !== $r['user_agent']) { $click['user_agent'] = $r['user_agent']; } $payload[] = $click; } $resp = $api->track_clicks($payload); if (!$resp || empty($resp['ok'])) { // Ancora irraggiungibile: si segna il tentativo e si riprova al giro // dopo. Niente cancellazioni, la coda e' l'unica copia. $ids = wp_list_pluck($rows, 'event_id'); $placeholders = implode(',', array_fill(0, count($ids), '%s')); // $placeholders contiene solo segnaposto %s, uno per id. // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare $wpdb->query($wpdb->prepare("UPDATE %i SET attempts = attempts + 1 WHERE event_id IN ($placeholders)", array_merge(array($table), $ids))); return; } $done = (array) ($resp['stored'] ?? array()); foreach ((array) ($resp['rejected'] ?? array()) as $rej) { if (!empty($rej['client_event_id'])) { $done[] = $rej['client_event_id']; } } if ($done) { $placeholders = implode(',', array_fill(0, count($done), '%s')); // $placeholders contiene solo segnaposto %s, uno per id. // phpcs:ignore WordPress.DB.PreparedSQL.InterpolatedNotPrepared, WordPress.DB.PreparedSQLPlaceholders.UnfinishedPrepare $wpdb->query($wpdb->prepare("DELETE FROM %i WHERE event_id IN ($placeholders)", array_merge(array($table), $done))); } } /* ——— Ordini ——— */ public static function order_created($order_id) { $order = wc_get_order($order_id); if ($order) { self::order_created_obj($order); } } public static function order_created_obj($order) { $ref = isset($_COOKIE[ATCWC_COOKIE]) ? sanitize_text_field(wp_unslash($_COOKIE[ATCWC_COOKIE])) : ''; $camp = isset($_COOKIE[ATCWC_CAMP_COOKIE]) ? sanitize_text_field(wp_unslash($_COOKIE[ATCWC_CAMP_COOKIE])) : ''; if (!$order instanceof WC_Order) { return; } // Plugin non ancora configurato: nessuno a cui parlare, e marcare // l'ordine come "da comunicare" farebbe rimandare dal cron, a chiave // inserita, ordini che non c'entrano con il programma. if (!get_option('atcwc_api_key')) { return; } // Senza cookie l'ordine si comunica lo stesso SOLO in modalita' // "lifetime" (quella EFFICACE, vedi track_mode(): basta un affiliato // ad averla): li' l'attribuzione la fa la piattaforma dal legame // cliente→affiliato, e un ordine mai comunicato non puo' essere // attribuito. In "first" un ordine senza cookie non frutta a nessuno. // Modalita' sconosciuta (piattaforma giu' a cache fredda): si // comunica comunque — in "first" la piattaforma risponde // `no_attribution`, in "lifetime" l'ordine non va perso. // Un ordine fatto con il codice di un influencer parte sempre: il // codice vince sul link e non ha bisogno del cookie. if (!$ref && 'first' === self::track_mode() && !Atcwc_Codes::has_influencer_code($order)) { return; } // Doppio hook (checkout classico + Store API): evita il doppio invio. if (self::is_tracked($order)) { return; } $order->update_meta_data('_atcwc_ref', $ref); $order->update_meta_data('_atcwc_tracked', '1'); if ($camp) { $order->update_meta_data('_atcwc_camp', $camp); } $order->save(); $payload = self::payload($order, $ref, $camp); $resp = atcwc_api()->order_event('order.created', $payload); if ($resp && !empty($resp['ok'])) { $order->update_meta_data('_atcwc_sent', '1'); // Lo stato appena comunicato e' gia' confermato: senza annotarlo il // primo cron rimandava un `status_changed` identico. $order->update_meta_data('_atcwc_state', $payload['state']); $order->save(); } } /* Ordine di cui la piattaforma deve sapere: attribuito da cookie, oppure comunicato per la modalita' lifetime (referral vuoto). */ private static function is_tracked(WC_Order $order) { return (bool) ($order->get_meta('_atcwc_ref') || $order->get_meta('_atcwc_tracked')); } /* Modalita' di tracciamento EFFICACE, in cache un'ora: serve a ogni ordine e non puo' costare una chiamata HTTP dentro il checkout. Non e' quella del programma: `affiliates.track_mode` la sovrascrive per singolo affiliato, e basta un affiliato in "lifetime" perche' gli ordini senza cookie debbano partire lo stesso. Il conto lo fa la piattaforma in `track_mode_effective`, perche' noi gli affiliati non li conosciamo. */ private static function track_mode() { $cached = get_transient('atcwc_track_mode'); if ($cached) { return $cached; } $resp = atcwc_api()->settings_full(); if (!is_array($resp) || empty($resp['settings'])) { // Piattaforma non raggiungibile: vale l'ultimo valore noto, mai // un "first" inventato che farebbe scartare ordini lifetime. return get_option('atcwc_track_mode_last', 'unknown'); } // Ripiego su settings.track_mode per le piattaforme non aggiornate. $declared = isset($resp['track_mode_effective']) ? $resp['track_mode_effective'] : ($resp['settings']['track_mode'] ?? 'first'); $mode = 'lifetime' === $declared ? 'lifetime' : 'first'; set_transient('atcwc_track_mode', $mode, HOUR_IN_SECONDS); update_option('atcwc_track_mode_last', $mode, false); return $mode; } public static function status_changed($order_id, $from, $to, $order) { $state = self::semantic_state($to); if ('pending' === $state || !self::is_tracked($order)) { return; } $resp = atcwc_api()->order_event('order.status_changed', array( 'external_id' => (string) $order_id, 'state' => $state, )); if ($resp && !empty($resp['ok'])) { self::remember_state($order, $state); } } /* Ultimo stato CONFERMATO dalla piattaforma, da cui la manutenzione capisce cosa e' gia' arrivato e cosa no. Si scrive SOLO su risposta positiva: finche' la piattaforma non conferma, l'ordine resta in coda e si riprova al giro dopo, quindi saltarlo non puo' perdere un evento. */ private static function remember_state(WC_Order $order, $state) { $order->update_meta_data('_atcwc_state', $state); $order->save(); } public static function payload(WC_Order $order, $ref, $camp = '') { $shipping = (float) $order->get_shipping_total() + (float) $order->get_shipping_tax(); $products = 0.0; $no_discount = 0.0; foreach ($order->get_items() as $item) { $line = (float) $item->get_total() + (float) $item->get_total_tax(); $products += $line; // Scontato se il prodotto era in saldo o la riga ha uno sconto applicato. $product = is_callable(array($item, 'get_product')) ? $item->get_product() : null; $discounted = ((float) $item->get_subtotal() > (float) $item->get_total()) || ($product && $product->is_on_sale()); if (!$discounted) { $no_discount += $line; } } $cid = $order->get_customer_id() ? (string) $order->get_customer_id() : 'guest:' . strtolower((string) $order->get_billing_email()); return array( 'external_id' => (string) $order->get_id(), 'external_customer_id' => $cid, 'referral_code' => $ref ? $ref : null, 'campaign' => $camp ? $camp : null, 'state' => self::semantic_state($order->get_status()), 'total_paid' => (float) $order->get_total(), 'total_products' => round($products, 2), 'total_products_nodiscount' => round($no_discount, 2), 'total_shipping' => round($shipping, 2), // Valuta dell'ordine, non quella di default del negozio: con un // plugin multivaluta i totali qui sopra sono in QUELLA. 'currency' => (string) $order->get_currency(), // Codici sconto dell'ordine ed email del cliente: servono ai // codici degli influencer (chi usa il proprio codice non conta). 'discount_codes' => Atcwc_Codes::order_codes($order), 'customer_email' => (string) $order->get_billing_email(), ); } // Stati Woo -> stato semantico della piattaforma. private static function semantic_state($status) { $status = str_replace('wc-', '', (string) $status); if (in_array($status, array('cancelled', 'refunded', 'failed'), true)) { return 'cancelled'; } if (in_array($status, array('processing', 'completed'), true)) { return 'approved'; } return 'pending'; } /* ——— Manutenzione: ordini, codici, sconti COIN, fatturato ——— */ /** * Manutenzione chiesta dalla piattaforma (piattaforma 0.70.34+): quando il * merchant assegna, toglie o cambia un codice, la piattaforma chiama * `/?atcwc_maint=1&ts=…&sig=…` e il codice si applica in pochi secondi * invece che al giro orario. La firma e' l'HMAC-SHA256 del timestamp con * la chiave API del negozio, valida 5 minuti: nessun altro la conosce. * Con `async=1` si risponde subito e si lavora dopo, dove il server lo * permette (PHP-FPM, LiteSpeed); altrimenti si lavora fino in fondo anche * se chi ha chiamato smette di aspettare. */ public static function maintenance_request() { // phpcs:disable WordPress.Security.NonceVerification.Recommended -- chiamata firmata dalla piattaforma, non un form: la firma HMAC fa da nonce. if (!isset($_GET['atcwc_maint'])) { return; } $ts = isset($_GET['ts']) ? sanitize_text_field(wp_unslash($_GET['ts'])) : ''; $sig = isset($_GET['sig']) ? sanitize_text_field(wp_unslash($_GET['sig'])) : ''; $async = !empty($_GET['async']); // phpcs:enable WordPress.Security.NonceVerification.Recommended $key = (string) get_option('atcwc_api_key', ''); if ('' === $key || !ctype_digit($ts) || '' === $sig || abs(time() - (int) $ts) > 300 || !hash_equals(hash_hmac('sha256', $ts, $key), $sig)) { status_header(403); nocache_headers(); exit('forbidden'); } nocache_headers(); $finish = function_exists('fastcgi_finish_request') ? 'fastcgi_finish_request' : (function_exists('litespeed_finish_request') ? 'litespeed_finish_request' : null); if ($async && $finish) { // Non wp_send_json(): chiude la richiesta, e il lavoro va fatto dopo. header('Content-Type: application/json; charset=utf-8'); echo wp_json_encode(array('ok' => true, 'queued' => true)); if (session_id()) { session_write_close(); } $finish(); } ignore_user_abort(true); // phpcs:ignore Squiz.PHP.DiscouragedFunctions.Discouraged -- la manutenzione puo' superare il limite di default con un recupero lungo. @set_time_limit(300); $result = self::run_maintenance(); wp_send_json(array('ok' => true, 'result' => $result)); } /** * Una manutenzione alla volta: WP-Cron e la chiamata della piattaforma * possono arrivare insieme, e due giri paralleli creerebbero due volte lo * stesso coupon o manderebbero due volte lo stesso recupero. Il blocco e' * GET_LOCK di MySQL, che si libera da solo se il processo muore. Chi * arriva durante un giro lascia un segno e il giro in corso ne fa un * altro alla fine (al massimo due in piu'), cosi' una modifica fatta * mentre girava non aspetta l'ora successiva. */ public static function run_maintenance() { global $wpdb; $lock = 'atcwc_maint_' . md5(DB_NAME . $wpdb->prefix); // phpcs:disable WordPress.DB.DirectDatabaseQuery -- blocco e segno vanno letti dal database, non dalla cache delle opzioni. if (!(int) $wpdb->get_var($wpdb->prepare('SELECT GET_LOCK(%s, 0)', $lock))) { $wpdb->query("INSERT INTO {$wpdb->options} (option_name, option_value, autoload) VALUES ('atcwc_maint_again', '1', 'off') ON DUPLICATE KEY UPDATE option_value = '1'"); return 'busy'; } $result = null; for ($i = 0; $i < 3; $i++) { $wpdb->query("DELETE FROM {$wpdb->options} WHERE option_name = 'atcwc_maint_again'"); $result = self::cron(); if (!$wpdb->get_var("SELECT option_value FROM {$wpdb->options} WHERE option_name = 'atcwc_maint_again'")) { break; } } $wpdb->query($wpdb->prepare('SELECT RELEASE_LOCK(%s)', $lock)); // phpcs:enable WordPress.DB.DirectDatabaseQuery wp_cache_delete('atcwc_maint_again', 'options'); return $result; } public static function cron() { $api = atcwc_api(); delete_transient('atcwc_track_mode'); self::track_mode(); // Riconciliazione su ordini recenti (compatibile CPT e HPOS: il filtro // sui meta _atcwc_* avviene in PHP, meta_query non è supportata ovunque). // Solo `shop_order`: senza, arrivano anche i rimborsi (oggetti // OrderRefund), e prima della 0.18.0 il primo rimborso degli ultimi // 60 giorni faceva cadere la manutenzione con un errore fatale. foreach (wc_get_orders(array( 'type' => 'shop_order', 'date_created' => '>' . (time() - 60 * DAY_IN_SECONDS), 'limit' => 300, 'return' => 'ids', )) as $oid) { $o = wc_get_order($oid); if (!$o instanceof WC_Order || !self::is_tracked($o)) { continue; } if (!$o->get_meta('_atcwc_sent')) { // Ordine attribuito mai arrivato alla piattaforma: reinvio. $payload = self::payload($o, $o->get_meta('_atcwc_ref'), $o->get_meta('_atcwc_camp')); $resp = $api->order_event('order.created', $payload); if ($resp && !empty($resp['ok'])) { $o->update_meta_data('_atcwc_sent', '1'); $o->update_meta_data('_atcwc_state', $payload['state']); $o->save(); } continue; } // Sync dello stato corrente: si ritrasmette solo cio' che e' // CAMBIATO rispetto all'ultimo stato confermato (_atcwc_state). // // Prima si rispedivano tutti e 300 gli ordini a ogni giro anche se // invariati: la piattaforma li scartava correttamente grazie // all'idempotenza, ma erano 300 chiamate HTTP inutili a ogni giro // di cron. Gemello del fix del connettore PrestaShop v0.18.0. // // Chi aggiorna da una versione precedente non ha il meta: il primo // giro e' quindi una sincronizzazione completa, e poi silenzio. $state = self::semantic_state($o->get_status()); if ('pending' !== $state && $state !== $o->get_meta('_atcwc_state')) { $resp = $api->order_event('order.status_changed', array( 'external_id' => (string) $oid, 'state' => $state, )); if ($resp && !empty($resp['ok'])) { self::remember_state($o, $state); } } } $codes = Atcwc_Codes::sync($api); $pending = $api->pending_discounts(); foreach ((array) ($pending['requests'] ?? array()) as $req) { $user_id = self::user_by_affiliate($req['affiliate_id']); // Affiliato non mappato a un utente di QUESTO negozio: senza email // il coupon nascerebbe valido per chiunque. Meglio un "failed" (i // COIN tornano indietro) che uno sconto globale. if (!$user_id) { $api->confirm_discount($req['id'], 'failed', ''); continue; } $code = self::create_coupon( (float) $req['value_eur'], $user_id, (int) ($req['expiry_days'] ?? 365), !isset($req['single_use']) || $req['single_use'] ); $api->confirm_discount($req['id'], $code ? 'created' : 'failed', $code); } // Fatturato ultimi 12 mesi (ordini pagati) per la verifica della fascia. $revenue = 0.0; foreach (wc_get_orders(array( 'type' => 'shop_order', 'status' => array('wc-processing', 'wc-completed'), 'date_created' => '>' . (time() - YEAR_IN_SECONDS), 'limit' => -1, 'return' => 'ids', )) as $oid) { $o = wc_get_order($oid); if ($o) { $revenue += (float) $o->get_total(); } } $api->report_revenue($revenue, get_woocommerce_currency()); // Per ultimo di proposito: se la piattaforma e' tornata su, i passaggi // qui sopra l'hanno gia' dimostrato, e non si spreca un lotto da 200 // per scoprire che e' ancora giu'. self::flush_click_queue($api); // Serve al pannello "Manutenzione automatica" in wp-admin per dire al // merchant quando è girata l'ultima volta (WP-Cron è innescato dal // traffico: senza visite non parte, e senza questo dato non si vede). update_option('atcwc_last_maintenance', time(), false); return array('codes' => $codes); } public static function user_by_affiliate($affiliate_id) { $users = get_users(array( 'meta_key' => '_atcwc_affiliate_id', 'meta_value' => $affiliate_id, 'fields' => 'ID', 'number' => 1, )); return $users ? (int) $users[0] : 0; } public static function create_coupon($value_eur, $user_id, $expiry_days = 365, $single_use = true) { $code = 'COIN-' . strtoupper(wp_generate_password(8, false, false)); $coupon = new WC_Coupon(); $coupon->set_code($code); $coupon->set_discount_type('fixed_cart'); $coupon->set_amount($value_eur); $coupon->set_usage_limit($single_use ? 1 : 1000); $coupon->set_usage_limit_per_user($single_use ? 1 : 1000); if ($user_id) { $user = get_userdata($user_id); if ($user) { $coupon->set_email_restrictions(array($user->user_email)); } } $coupon->set_date_expires(time() + max(1, (int) $expiry_days) * DAY_IN_SECONDS); return $coupon->save() ? $code : false; } }