387 lines
18 KiB
PHP
387 lines
18 KiB
PHP
<?php
|
|
|
|
/**
|
|
* MagoSalesStats - funzioni comuni alle pagine statistiche ordini cliente
|
|
* (sales_orders_stats.php e sales_orders_years.php).
|
|
* Legge SOLO dalle tabelle locali sincronizzate da Mago.
|
|
*/
|
|
class MagoSalesStats
|
|
{
|
|
const CUSTOMER_TYPE = 3211264;
|
|
|
|
/*
|
|
* MAPPATURA DATE DI CONSEGNA (righe e testata usano gli stessi nomi colonna)
|
|
*
|
|
* Data ZIBO = data comunicata da Zibo al cliente → è la SCADENZA che conta (ritardo in rosso)
|
|
* Data cliente = data desiderata dal cliente → riferimento (ritardo in arancione)
|
|
*
|
|
* Per invertirle basta scambiare i due valori qui sotto.
|
|
*/
|
|
// Verificato sui dati reali (13/10/2026): la data ZIBO è ExpectedDeliveryDate, la data cliente è ConfirmedDeliveryDate
|
|
const ZIBO_DATE_COL = 'expected_delivery_date'; // Mago: ExpectedDeliveryDate ("Data ZIBO")
|
|
const CLIENT_DATE_COL = 'confirmed_delivery_date'; // Mago: ConfirmedDeliveryDate ("DATA CLIENTE")
|
|
|
|
/*
|
|
* DATA ZIBO = SETTIMANA DI CONSEGNA
|
|
* In Mago la data ZIBO è il primo giorno della settimana: per il cliente significa "entro quella settimana".
|
|
* La scadenza reale è quindi la fine di quella settimana; durante la settimana compare un avviso.
|
|
* ZIBO_IS_WEEK = false → la data ZIBO torna a valere come giorno preciso
|
|
* ZIBO_WEEK_END_DAYS = giorni dopo il lunedì: 6 = domenica, 4 = venerdì
|
|
*/
|
|
const ZIBO_IS_WEEK = true;
|
|
const ZIBO_WEEK_END_DAYS = 6;
|
|
|
|
/*
|
|
* ORDINI ESCLUSI da tutte le statistiche: parole cercate (senza distinzione maiuscole/minuscole) in
|
|
* numero ordine esterno, nostro/vostro riferimento, note di testata, descrizioni e note delle righe.
|
|
* Lasciare l'elenco vuoto per non escludere nulla.
|
|
*/
|
|
const EXCLUDE_KEYWORDS = ['listino'];
|
|
|
|
/** Data ZIBO "valida" di una riga/testata: in Mago, se non compilata, resta uguale alla data ordine. */
|
|
public static function ziboDate($a)
|
|
{
|
|
$c = $a . '.' . self::ZIBO_DATE_COL;
|
|
return "CASE WHEN $c > $a.order_date THEN $c END";
|
|
}
|
|
|
|
public static function clientDate($a)
|
|
{
|
|
$c = $a . '.' . self::CLIENT_DATE_COL;
|
|
return "CASE WHEN $c > $a.order_date THEN $c END";
|
|
}
|
|
|
|
/** Scadenza della data ZIBO: fine della settimana indicata (o il giorno stesso se ZIBO_IS_WEEK = false). */
|
|
public static function ziboDeadline($a)
|
|
{
|
|
$z = self::ziboDate($a);
|
|
if (!self::ZIBO_IS_WEEK) return $z;
|
|
return "DATE_ADD($z, INTERVAL (" . (int)self::ZIBO_WEEK_END_DAYS . " - WEEKDAY($z)) DAY)";
|
|
}
|
|
|
|
/**
|
|
* FATTURATO: tipi di documento di vendita che contano (verificati sui dati reali il 14/10/2026)
|
|
* e segno con cui contano. Esclusi: DDT 3407873, DDT non valorizzati 3407881,
|
|
* proforma 3407888, movimenti deposito 3407890.
|
|
*/
|
|
const INVOICE_TYPES = [
|
|
3407874 => 1, // Fattura (immediata / differita) serie A ...
|
|
3407883 => 1, // Fattura d'acconto (TD02) serie B
|
|
3407876 => -1, // Nota di credito (TD04) → in negativo serie D ...
|
|
];
|
|
|
|
/** Vista fatture/note di credito (alias i) con imponibile già col segno giusto (revenue). */
|
|
public static function invoiceFrom()
|
|
{
|
|
$types = implode(',', array_map('intval', array_keys(self::INVOICE_TYPES)));
|
|
$sign = 'CASE d.document_type';
|
|
foreach (self::INVOICE_TYPES as $t => $sg) $sign .= ' WHEN ' . (int)$t . ' THEN ' . ((int)$sg < 0 ? -1 : 1);
|
|
$sign .= ' ELSE 0 END';
|
|
|
|
return "(
|
|
SELECT d.sale_doc_id, d.document_type, d.doc_no, d.document_date,
|
|
d.customer, d.salesperson, d.area,
|
|
COALESCE(NULLIF(c.company_name, ''), d.customer) AS company_name,
|
|
($sign) * COALESCE(d.taxable_amount, 0) AS revenue,
|
|
($sign) < 0 AS is_credit_note,
|
|
d.summary_tb_modified IS NULL AS no_amount
|
|
FROM mago_sale_doc d
|
|
LEFT JOIN mago_cust_supp c
|
|
ON c.cust_supp_type = " . self::CUSTOMER_TYPE . " AND c.cust_supp = d.customer
|
|
WHERE d.document_type IN ($types) AND d.cancelled = 0
|
|
) i";
|
|
}
|
|
|
|
/** Scadenza di testata (usata solo per ordini senza righe). */
|
|
public static function headerDue($a)
|
|
{
|
|
return "COALESCE(" . self::ziboDeadline($a) . ", " . self::clientDate($a) . ", $a.compulsory_delivery_date)";
|
|
}
|
|
|
|
/** Scadenza effettiva di una riga: fine settimana ZIBO, se manca la data cliente. */
|
|
public static function lineDue($a)
|
|
{
|
|
return "COALESCE(" . self::ziboDeadline($a) . ", " . self::clientDate($a) . ")";
|
|
}
|
|
|
|
/**
|
|
* Condizione SQL che ESCLUDE gli ordini contenenti una delle parole in EXCLUDE_KEYWORDS
|
|
* (alias della testata: $a). Stringa vuota se non c'è nulla da escludere.
|
|
*/
|
|
public static function excludeCondition($a)
|
|
{
|
|
$words = array_filter(array_map('trim', self::EXCLUDE_KEYWORDS));
|
|
if (!$words) return '1=1';
|
|
|
|
$parts = [];
|
|
foreach ($words as $w) {
|
|
$like = "'%" . str_replace(["\\", "'", '%', '_'], ["\\\\", "''", '\\%', '\\_'], $w) . "%'";
|
|
foreach (['external_ord_no', 'our_reference', 'your_reference', 'notes'] as $col) {
|
|
$parts[] = "COALESCE($a.$col, '') LIKE $like"; // COALESCE: un campo NULL non deve escludere l'ordine
|
|
}
|
|
$parts[] = "EXISTS (SELECT 1 FROM mago_sale_ord_detail ex
|
|
WHERE ex.sale_ord_id = $a.sale_ord_id
|
|
AND (COALESCE(ex.description, '') LIKE $like OR COALESCE(ex.notes, '') LIKE $like))";
|
|
}
|
|
return 'NOT (' . implode(' OR ', $parts) . ')';
|
|
}
|
|
|
|
/** Aggregati per ordine calcolati dalle righe (alias l). */
|
|
public static function lineAggregates()
|
|
{
|
|
$open = "(d.delivered = 0 AND d.cancelled = 0)";
|
|
$due = self::lineDue('d');
|
|
return "(
|
|
SELECT d.sale_ord_id,
|
|
COUNT(*) AS lines_total,
|
|
SUM($open) AS open_lines,
|
|
MIN(CASE WHEN $open THEN " . self::ziboDate('d') . " END) AS next_zibo,
|
|
MIN(CASE WHEN $open THEN " . self::clientDate('d') . " END) AS next_client,
|
|
MIN(" . self::ziboDate('d') . ") AS first_zibo,
|
|
MIN(" . self::clientDate('d') . ") AS first_client,
|
|
MIN(CASE WHEN $open THEN $due END) AS next_due,
|
|
MIN($due) AS first_due,
|
|
COUNT(DISTINCT CASE WHEN $open THEN $due END) AS open_dates,
|
|
SUM($open AND $due < CURDATE()) AS late_lines,
|
|
SUM($open AND " . self::clientDate('d') . " < CURDATE()) AS late_lines_client,
|
|
SUM($open AND $due >= CURDATE() AND YEARWEEK($due, 3) = YEARWEEK(CURDATE(), 3)) AS week_lines
|
|
FROM mago_sale_ord_detail d
|
|
WHERE d.item <> '' OR d.qty <> 0
|
|
GROUP BY d.sale_ord_id
|
|
) l";
|
|
}
|
|
|
|
/** Risposta JSON e fine script (pulisce l'output di headscript). */
|
|
public static function jsonOut(array $data)
|
|
{
|
|
while (ob_get_level()) ob_end_clean();
|
|
header('Content-Type: application/json; charset=utf-8');
|
|
echo json_encode($data, JSON_UNESCAPED_UNICODE);
|
|
exit;
|
|
}
|
|
|
|
public static function isValidDate($d)
|
|
{
|
|
return is_string($d) && preg_match('/^\d{4}-\d{2}-\d{2}$/', $d) && strtotime($d) !== false;
|
|
}
|
|
|
|
/** Parametro GET multiplo (es. customers[]) come array pulito. */
|
|
public static function arrParam($key)
|
|
{
|
|
$v = $_GET[$key] ?? [];
|
|
if (!is_array($v)) $v = [$v];
|
|
return array_values(array_filter(array_map(function ($x) {
|
|
return trim((string)$x);
|
|
}, $v), function ($x) {
|
|
return $x !== '';
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* Vista base: ordini + nome cliente + stato + date di consegna (alias x).
|
|
*
|
|
* zibo_date = prima data ZIBO tra le righe ancora da consegnare (se tutte consegnate: la prima in assoluto);
|
|
* senza righe: data ZIBO di testata
|
|
* client_date = stessa logica con la data cliente
|
|
* due_date = scadenza dell'ordine: la più vicina tra le righe aperte (riga: data ZIBO, se manca data cliente)
|
|
* late_lines / open_lines = righe aperte in ritardo / righe aperte (per il "ritardo parziale")
|
|
*/
|
|
public static function baseFrom()
|
|
{
|
|
return "(
|
|
SELECT
|
|
o.*,
|
|
COALESCE(NULLIF(c.company_name, ''), o.customer) AS company_name,
|
|
COALESCE(l.next_zibo, l.first_zibo, " . self::ziboDate('o') . ") AS zibo_date,
|
|
COALESCE(l.next_client, l.first_client, " . self::clientDate('o') . ") AS client_date,
|
|
-- scadenza = la più vicina tra le righe aperte, dove ogni riga scade alla sua data ZIBO
|
|
-- (o alla data cliente se la data ZIBO non è compilata)
|
|
COALESCE(
|
|
l.next_due, l.first_due,
|
|
" . self::ziboDeadline('o') . ", " . self::clientDate('o') . ", o.compulsory_delivery_date
|
|
) AS due_date,
|
|
COALESCE(l.lines_total, 0) AS lines_total,
|
|
COALESCE(l.open_lines, 0) AS open_lines,
|
|
COALESCE(l.open_dates, 0) AS open_dates,
|
|
COALESCE(l.late_lines, 0) AS late_lines,
|
|
COALESCE(l.late_lines_client, 0) AS late_lines_client,
|
|
COALESCE(l.week_lines, 0) AS week_lines,
|
|
-- RITARDO calcolato sulle RIGHE: un ordine è in ritardo solo se ha almeno una riga aperta scaduta.
|
|
-- (Solo se l'ordine non ha righe si usa la data di testata.)
|
|
CASE WHEN o.cancelled = 0 AND o.delivered = 0 AND (
|
|
(COALESCE(l.lines_total, 0) > 0 AND l.late_lines > 0)
|
|
OR (COALESCE(l.lines_total, 0) = 0 AND " . self::headerDue('o') . " < CURDATE())
|
|
) THEN 1 ELSE 0 END AS is_late,
|
|
CASE WHEN o.cancelled = 0 AND o.delivered = 0 AND (
|
|
(COALESCE(l.lines_total, 0) > 0 AND l.late_lines_client > 0)
|
|
OR (COALESCE(l.lines_total, 0) = 0 AND " . self::clientDate('o') . " < CURDATE())
|
|
) THEN 1 ELSE 0 END AS is_late_client,
|
|
-- scadenza delle sole righe ancora aperte (per il grafico scadenze)
|
|
CASE WHEN COALESCE(l.lines_total, 0) > 0 THEN l.next_due ELSE " . self::headerDue('o') . " END AS open_due,
|
|
CASE
|
|
WHEN o.cancelled = 1 THEN 'annullato'
|
|
WHEN o.delivered = 1 THEN 'evaso'
|
|
WHEN o.is_blocked = 1 THEN 'bloccato'
|
|
ELSE 'aperto'
|
|
END AS status
|
|
FROM mago_sale_ord o
|
|
LEFT JOIN mago_cust_supp c
|
|
ON c.cust_supp_type = " . self::CUSTOMER_TYPE . " AND c.cust_supp = o.customer
|
|
LEFT JOIN " . self::lineAggregates() . " ON l.sale_ord_id = o.sale_ord_id
|
|
WHERE " . self::excludeCondition('o') . "
|
|
) x";
|
|
}
|
|
|
|
/**
|
|
* Vista righe aperte (alias r) per la pagina Consegne: riga + ordine + date effettive.
|
|
*/
|
|
public static function openLinesFrom()
|
|
{
|
|
return "(
|
|
SELECT
|
|
d.sale_ord_id, d.sub_id, d.line, d.position, d.item, d.description, d.uom,
|
|
d.qty, d.delivered_qty,
|
|
GREATEST(d.qty - d.delivered_qty, 0) AS residual_qty,
|
|
CASE WHEN d.qty > 0 THEN ROUND(d.taxable_amount * GREATEST(d.qty - d.delivered_qty, 0) / d.qty, 2)
|
|
ELSE d.taxable_amount END AS residual_value,
|
|
d.taxable_amount,
|
|
" . self::ziboDate('d') . " AS zibo_date,
|
|
" . self::clientDate('d') . " AS client_date,
|
|
" . self::lineDue('d') . " AS due_date,
|
|
x.internal_ord_no, x.order_date, x.customer, x.company_name,
|
|
x.salesperson, x.area, x.status, x.your_reference, x.external_ord_no
|
|
FROM mago_sale_ord_detail d
|
|
JOIN " . self::baseFrom() . " ON x.sale_ord_id = d.sale_ord_id
|
|
WHERE d.delivered = 0 AND d.cancelled = 0
|
|
AND x.status IN ('aperto','bloccato')
|
|
AND (d.item <> '' OR d.qty <> 0)
|
|
) r";
|
|
}
|
|
|
|
/**
|
|
* WHERE + parametri dai filtri in querystring.
|
|
* $override sostituisce from/to (stringa vuota = nessun filtro data).
|
|
*/
|
|
public static function buildWhere(array $override = [])
|
|
{
|
|
$w = ['1=1'];
|
|
$p = [];
|
|
|
|
$from = array_key_exists('from', $override) ? $override['from'] : ($_GET['from'] ?? '');
|
|
$to = array_key_exists('to', $override) ? $override['to'] : ($_GET['to'] ?? '');
|
|
|
|
if (self::isValidDate($from)) {
|
|
$w[] = 'x.order_date >= :from';
|
|
$p['from'] = $from;
|
|
}
|
|
if (self::isValidDate($to)) {
|
|
$w[] = 'x.order_date <= :to';
|
|
$p['to'] = $to;
|
|
}
|
|
|
|
$multi = [
|
|
'customers' => 'x.customer',
|
|
'salespeople' => 'x.salesperson',
|
|
'areas' => 'x.area',
|
|
];
|
|
foreach ($multi as $key => $col) {
|
|
$vals = self::arrParam($key);
|
|
if (!$vals) continue;
|
|
$ph = [];
|
|
foreach ($vals as $i => $v) {
|
|
$name = $key . $i;
|
|
$ph[] = ':' . $name;
|
|
$p[$name] = $v;
|
|
}
|
|
$w[] = "$col IN (" . implode(',', $ph) . ")";
|
|
}
|
|
|
|
$statusMap = [
|
|
'aperto' => "x.status = 'aperto'",
|
|
'evaso' => "x.status = 'evaso'",
|
|
'annullato' => "x.status = 'annullato'",
|
|
'bloccato' => "x.status = 'bloccato'",
|
|
'ritardo' => "x.is_late = 1",
|
|
'ritardo_cliente' => "x.is_late_client = 1",
|
|
'settimana' => "(x.status IN ('aperto','bloccato') AND x.week_lines > 0)", // righe da consegnare questa settimana
|
|
'da_fatturare' => "(x.delivered = 1 AND x.invoiced = 0 AND x.cancelled = 0)",
|
|
'fatturato' => "x.invoiced = 1",
|
|
];
|
|
$statuses = array_intersect(self::arrParam('statuses'), array_keys($statusMap));
|
|
if ($statuses) {
|
|
$w[] = '(' . implode(' OR ', array_map(function ($s) use ($statusMap) {
|
|
return $statusMap[$s];
|
|
}, $statuses)) . ')';
|
|
}
|
|
|
|
$q = trim((string)($_GET['q'] ?? ''));
|
|
if ($q !== '') {
|
|
$like = '%' . $q . '%';
|
|
$w[] = '(x.internal_ord_no LIKE :q1 OR x.external_ord_no LIKE :q2 OR x.your_reference LIKE :q3 OR x.company_name LIKE :q4 OR x.customer LIKE :q5)';
|
|
$p['q1'] = $p['q2'] = $p['q3'] = $p['q4'] = $p['q5'] = $like;
|
|
}
|
|
|
|
return [implode(' AND ', $w), $p];
|
|
}
|
|
|
|
public static function fetchAllQ(PDO $pdo, $sql, array $params)
|
|
{
|
|
$st = $pdo->prepare($sql);
|
|
$st->execute($params);
|
|
return $st->fetchAll(PDO::FETCH_ASSOC);
|
|
}
|
|
|
|
/** Stato dell'ultima sincronizzazione (per il badge in alto). */
|
|
public static function syncInfo(PDO $pdo)
|
|
{
|
|
try {
|
|
$rows = $pdo->query("SELECT * FROM mago_sync_state")->fetchAll(PDO::FETCH_ASSOC);
|
|
$out = [];
|
|
foreach ($rows as $r) {
|
|
$out[$r['entity']] = [
|
|
'last_run_at' => $r['last_run_at'] ? date('d/m/Y H:i', strtotime($r['last_run_at'])) : '',
|
|
'last_status' => $r['last_status'],
|
|
'last_message' => $r['last_message'],
|
|
'records' => (int)$r['records_last_run'],
|
|
];
|
|
}
|
|
$out['total_orders'] = (int)$pdo->query("SELECT COUNT(*) FROM mago_sale_ord")->fetchColumn();
|
|
return $out;
|
|
} catch (Throwable $e) {
|
|
return ['error' => 'Tabelle Mago non presenti: eseguire la migrazione Phinx', 'total_orders' => 0];
|
|
}
|
|
}
|
|
|
|
/** Opzioni dei filtri (clienti, agenti, aree, anni disponibili). */
|
|
public static function filterOptions(PDO $pdo)
|
|
{
|
|
try {
|
|
$customers = $pdo->query("
|
|
SELECT o.customer AS code, COALESCE(NULLIF(c.company_name,''), o.customer) AS name, COUNT(*) AS n
|
|
FROM mago_sale_ord o
|
|
LEFT JOIN mago_cust_supp c ON c.cust_supp_type = " . self::CUSTOMER_TYPE . " AND c.cust_supp = o.customer
|
|
WHERE o.customer <> ''
|
|
GROUP BY o.customer, name
|
|
ORDER BY name
|
|
")->fetchAll(PDO::FETCH_ASSOC);
|
|
|
|
$salespeople = $pdo->query("SELECT salesperson AS code, COUNT(*) AS n FROM mago_sale_ord WHERE salesperson <> '' GROUP BY salesperson ORDER BY salesperson")->fetchAll(PDO::FETCH_ASSOC);
|
|
$areas = $pdo->query("SELECT area AS code, COUNT(*) AS n FROM mago_sale_ord WHERE area <> '' GROUP BY area ORDER BY area")->fetchAll(PDO::FETCH_ASSOC);
|
|
$range = $pdo->query("SELECT MIN(order_date) AS min_date, MAX(order_date) AS max_date FROM mago_sale_ord")->fetch(PDO::FETCH_ASSOC);
|
|
$years = array_map('intval', $pdo->query("SELECT DISTINCT YEAR(order_date) FROM mago_sale_ord WHERE order_date IS NOT NULL ORDER BY 1")->fetchAll(PDO::FETCH_COLUMN));
|
|
|
|
return [
|
|
'success' => true,
|
|
'customers' => $customers,
|
|
'salespeople' => $salespeople,
|
|
'areas' => $areas,
|
|
'range' => $range,
|
|
'years' => $years,
|
|
'sync' => self::syncInfo($pdo),
|
|
];
|
|
} catch (Throwable $e) {
|
|
return ['success' => false, 'message' => $e->getMessage(), 'sync' => self::syncInfo($pdo)];
|
|
}
|
|
}
|
|
}
|