Jeppe Bundgaard
0cca597fdc
Fix XLVask usage-log import metadata and period-scoped Selvvask automation.
1396 lines
54 KiB
PHP
1396 lines
54 KiB
PHP
<?php
|
|
|
|
namespace classes;
|
|
|
|
require_once WD . '/classes/xlvask_usage_logs_schema_bootstrap.php';
|
|
|
|
use Exception;
|
|
use helpers\xlvask_usage_log;
|
|
use objects\order_items_o;
|
|
use objects\orders_o;
|
|
use objects\xlvask_usage_logs_o;
|
|
|
|
class xlvask_automation_service
|
|
{
|
|
private const ACTION_ATTACH = 'attach_order';
|
|
private const ACTION_CREATE = 'create_order';
|
|
private const ACTION_NONE = 'none';
|
|
|
|
private const STATUS_SUGGESTED = 'suggested';
|
|
private const STATUS_AUTO_ACCEPTED = 'auto_accepted';
|
|
private const STATUS_ACCEPTED = 'accepted';
|
|
private const STATUS_DENIED = 'denied';
|
|
private const STATUS_FAILED = 'failed';
|
|
private const STATUS_NONE = 'none';
|
|
|
|
private const SOURCE_DETERMINISTIC = 'deterministic';
|
|
private const SOURCE_FUZZY = 'fuzzy';
|
|
private const SOURCE_HISTORY = 'history';
|
|
private const SOURCE_OPENAI = 'openai';
|
|
|
|
private const AUTOMATION_CASHIER_ID = 2285;
|
|
private const MIN_SUGGESTION_CONFIDENCE = 0.70;
|
|
private const AUTO_ATTACH_CONFIDENCE = 0.92;
|
|
private const AUTO_CREATE_CONFIDENCE = 0.97;
|
|
private const CREATE_MIN_AGE_HOURS = 6.0;
|
|
private const OPENAI_CACHE_VERSION = 1;
|
|
|
|
public function __construct()
|
|
{
|
|
xlvask_usage_logs_schema_bootstrap::ensureTables();
|
|
}
|
|
|
|
public function evaluateUsageLogById(int $usageLogId, ?int $actorId = null, bool $allowExecute = true): array
|
|
{
|
|
$row = $this->loadUsageLogRow($usageLogId);
|
|
if ($row === null) {
|
|
return $this->emptyAutomation('XL Vask-vasken blev ikke fundet.');
|
|
}
|
|
|
|
return $this->evaluateUsageLogRow($row, $actorId, $allowExecute);
|
|
}
|
|
|
|
public function evaluateUsageLogRow(array $row, ?int $actorId = null, bool $allowExecute = true): array
|
|
{
|
|
$usageLogId = (int)($row['id'] ?? 0);
|
|
if ($usageLogId < 1) {
|
|
return $this->emptyAutomation('XL Vask-vasken mangler et gyldigt id.');
|
|
}
|
|
|
|
try {
|
|
$log = $this->usageLogFromRow($row);
|
|
$guard = $this->guardReason($log);
|
|
$existing = $this->latestTerminalSuggestion($usageLogId);
|
|
if ($guard !== null) {
|
|
if ($existing !== null && in_array((string)$existing['status'], [
|
|
self::STATUS_AUTO_ACCEPTED,
|
|
self::STATUS_ACCEPTED,
|
|
self::STATUS_DENIED,
|
|
], true)) {
|
|
return $this->formatSuggestion($existing);
|
|
}
|
|
|
|
return $this->emptyAutomation($guard);
|
|
}
|
|
|
|
if ($existing !== null) {
|
|
if ((string)$existing['status'] === self::STATUS_SUGGESTED) {
|
|
$context = $this->buildContext($usageLogId, $log);
|
|
$contextGuard = $this->contextGuardReason($context);
|
|
if ($contextGuard !== null) {
|
|
return $this->emptyAutomation($contextGuard);
|
|
}
|
|
|
|
$freshSuggestion = $this->buildSuggestionForContext($context);
|
|
if ($freshSuggestion !== null) {
|
|
$suggestionId = $this->persistSuggestion($context, $freshSuggestion, $actorId);
|
|
$existing = $this->loadSuggestion($suggestionId) ?? $existing;
|
|
}
|
|
|
|
if ($allowExecute && $this->shouldAutoExecute($existing, $context)) {
|
|
return $this->executeSuggestion($existing, $context, $actorId, true);
|
|
}
|
|
}
|
|
|
|
return $this->formatSuggestion($existing);
|
|
}
|
|
|
|
$context = $this->buildContext($usageLogId, $log);
|
|
$contextGuard = $this->contextGuardReason($context);
|
|
if ($contextGuard !== null) {
|
|
return $this->emptyAutomation($contextGuard);
|
|
}
|
|
|
|
if ($this->hasDeniedFeedback($context['signature_hash'], self::ACTION_ATTACH)
|
|
&& $this->hasDeniedFeedback($context['signature_hash'], self::ACTION_CREATE)) {
|
|
return $this->emptyAutomation('Tidligere afvist for samme køretøjsmønster.');
|
|
}
|
|
|
|
$suggestion = $this->buildSuggestionForContext($context);
|
|
|
|
if ($suggestion === null || $suggestion['confidence'] < self::MIN_SUGGESTION_CONFIDENCE) {
|
|
return $this->emptyAutomation('Ingen sikker automatiseringshandling fundet.');
|
|
}
|
|
|
|
if ($this->hasDeniedFeedback($context['signature_hash'], $suggestion['action'])) {
|
|
return $this->emptyAutomation('Tidligere afvist for samme køretøjsmønster.');
|
|
}
|
|
|
|
$suggestionId = $this->persistSuggestion($context, $suggestion, $actorId);
|
|
$suggestionRow = $this->loadSuggestion($suggestionId);
|
|
if ($suggestionRow === null) {
|
|
return $this->emptyAutomation('Forslaget kunne ikke gemmes.');
|
|
}
|
|
|
|
if ($allowExecute && $this->shouldAutoExecute($suggestionRow, $context)) {
|
|
return $this->executeSuggestion($suggestionRow, $context, $actorId, true);
|
|
}
|
|
|
|
return $this->formatSuggestion($suggestionRow);
|
|
} catch (Exception $e) {
|
|
return [
|
|
...$this->emptyAutomation('Automatiseringen kunne ikke evaluere vasken.'),
|
|
'status' => self::STATUS_FAILED,
|
|
'error' => $e->getMessage(),
|
|
];
|
|
}
|
|
}
|
|
|
|
public function acceptUsageLogById(int $usageLogId, ?int $actorId = null, ?int $suggestionId = null, ?string $reason = null): array
|
|
{
|
|
$row = $this->loadUsageLogRow($usageLogId);
|
|
if ($row === null) {
|
|
return $this->emptyAutomation('XL Vask-vasken blev ikke fundet.');
|
|
}
|
|
|
|
$log = $this->usageLogFromRow($row);
|
|
$guard = $this->guardReason($log);
|
|
if ($guard !== null) {
|
|
return $this->emptyAutomation($guard);
|
|
}
|
|
|
|
$context = $this->buildContext($usageLogId, $log);
|
|
$contextGuard = $this->contextGuardReason($context);
|
|
if ($contextGuard !== null) {
|
|
return $this->emptyAutomation($contextGuard);
|
|
}
|
|
|
|
$suggestion = $suggestionId !== null ? $this->loadSuggestion($suggestionId) : $this->latestActionableSuggestion($usageLogId);
|
|
if ($suggestion === null) {
|
|
$this->evaluateUsageLogRow($row, $actorId, false);
|
|
$suggestion = $this->latestActionableSuggestion($usageLogId);
|
|
}
|
|
|
|
if ($suggestion === null) {
|
|
return $this->emptyAutomation('Der er intet forslag at acceptere.');
|
|
}
|
|
|
|
$result = $this->executeSuggestion($suggestion, $context, $actorId, false);
|
|
$this->persistFeedback($context, (string)$suggestion['action'], 'accepted', (int)($result['matched_order_id'] ?? $result['created_order_id'] ?? 0), $actorId, $reason);
|
|
|
|
return $result;
|
|
}
|
|
|
|
public function denyUsageLogById(int $usageLogId, ?int $actorId = null, ?int $suggestionId = null, ?string $reason = null): array
|
|
{
|
|
$row = $this->loadUsageLogRow($usageLogId);
|
|
if ($row === null) {
|
|
return $this->emptyAutomation('XL Vask-vasken blev ikke fundet.');
|
|
}
|
|
|
|
$log = $this->usageLogFromRow($row);
|
|
$context = $this->buildContext($usageLogId, $log);
|
|
$suggestion = $suggestionId !== null ? $this->loadSuggestion($suggestionId) : $this->latestActionableSuggestion($usageLogId);
|
|
|
|
if ($suggestion === null) {
|
|
return $this->emptyAutomation('Der er intet forslag at afvise.');
|
|
}
|
|
|
|
$this->updateSuggestionStatus((int)$suggestion['id'], self::STATUS_DENIED, $actorId);
|
|
$this->persistFeedback($context, (string)$suggestion['action'], 'denied', (int)($suggestion['matched_order_id'] ?? 0), $actorId, $reason);
|
|
|
|
return $this->formatSuggestion($this->loadSuggestion((int)$suggestion['id']) ?? $suggestion);
|
|
}
|
|
|
|
public function runPending(?string $dateFrom = null, ?string $dateTo = null, array $ids = [], int $limit = 100, ?int $actorId = null): array
|
|
{
|
|
$rows = $ids !== [] ? $this->loadUsageLogRowsByIds($ids) : $this->loadPendingRows($dateFrom, $dateTo, $limit);
|
|
$results = [];
|
|
foreach ($rows as $row) {
|
|
$results[] = $this->evaluateUsageLogRow($row, $actorId, true);
|
|
}
|
|
|
|
return [
|
|
'processed' => count($results),
|
|
'results' => $results,
|
|
];
|
|
}
|
|
|
|
public static function normalizeRegistrationForAutomation(string $registration): string
|
|
{
|
|
return strtoupper(preg_replace('/[^A-Z0-9]/i', '', $registration) ?? '');
|
|
}
|
|
|
|
public static function itemSignaturePartsForAutomation(array $items): array
|
|
{
|
|
$parts = [];
|
|
foreach ($items as $item) {
|
|
if (!is_array($item)) {
|
|
continue;
|
|
}
|
|
|
|
$parts[] = implode(':', [
|
|
(int)($item['product_id'] ?? 0),
|
|
(int)($item['quantity'] ?? 0),
|
|
(int)($item['price'] ?? 0),
|
|
]);
|
|
}
|
|
|
|
sort($parts, SORT_STRING);
|
|
return $parts;
|
|
}
|
|
|
|
public static function scoreItemMatchForAutomation(array $usageItems, array $orderItems): array
|
|
{
|
|
$usageSignature = self::itemSignaturePartsForAutomation($usageItems);
|
|
$orderSignature = self::itemSignaturePartsForAutomation($orderItems);
|
|
$usageTotal = self::itemsTotalForAutomation($usageItems);
|
|
$orderTotal = self::itemsTotalForAutomation($orderItems);
|
|
|
|
if ($usageSignature === $orderSignature && $usageTotal === $orderTotal) {
|
|
return [
|
|
'confidence' => 0.95,
|
|
'source' => self::SOURCE_DETERMINISTIC,
|
|
'reason' => 'Produkterne og prisen matcher en ordre fra samme dag.',
|
|
];
|
|
}
|
|
|
|
$usagePrimary = (int)($usageItems[0]['product_id'] ?? 0);
|
|
$orderPrimary = (int)($orderItems[0]['product_id'] ?? 0);
|
|
if ($usagePrimary < 1 || $usagePrimary !== $orderPrimary) {
|
|
return ['confidence' => 0.0, 'source' => self::SOURCE_DETERMINISTIC, 'reason' => ''];
|
|
}
|
|
|
|
$overlap = self::productOverlapForAutomation($usageItems, $orderItems);
|
|
$totalDiff = abs($usageTotal - $orderTotal);
|
|
if ($overlap >= 0.70 && $totalDiff <= 50) {
|
|
return [
|
|
'confidence' => 0.93,
|
|
'source' => self::SOURCE_FUZZY,
|
|
'reason' => 'Samme primære produkt og relaterede tilføjelser matcher en ordre fra samme dag.',
|
|
];
|
|
}
|
|
|
|
if ($overlap >= 0.50 && $totalDiff <= 150) {
|
|
return [
|
|
'confidence' => 0.80,
|
|
'source' => self::SOURCE_FUZZY,
|
|
'reason' => 'Vasken ligner en ordre fra samme dag, men kræver manuel godkendelse.',
|
|
];
|
|
}
|
|
|
|
$matchableUsageItems = self::matchableUsageItemsForAutomation($usageItems);
|
|
$matchableOverlap = self::productOverlapForAutomation($matchableUsageItems, $orderItems);
|
|
if (
|
|
$matchableUsageItems !== []
|
|
&& $matchableOverlap >= 0.95
|
|
&& self::orderHasAdditionsBeyondUsage($matchableUsageItems, $orderItems)
|
|
) {
|
|
return [
|
|
'confidence' => 0.88,
|
|
'source' => self::SOURCE_FUZZY,
|
|
'reason' => 'Ordren indeholder XL Vask-produkterne samt ekstra ydelser fra samme dag.',
|
|
];
|
|
}
|
|
|
|
return ['confidence' => 0.0, 'source' => self::SOURCE_DETERMINISTIC, 'reason' => ''];
|
|
}
|
|
|
|
public static function itemsTotalForAutomation(array $items): int
|
|
{
|
|
return array_reduce($items, fn(int $total, array $item): int => $total + ((int)($item['price'] ?? 0) * (int)($item['quantity'] ?? 0)), 0);
|
|
}
|
|
|
|
public static function productOverlapForAutomation(array $usageItems, array $orderItems): float
|
|
{
|
|
$usageBag = self::productBagForAutomation($usageItems);
|
|
$orderBag = self::productBagForAutomation($orderItems);
|
|
$usageTotal = array_sum($usageBag);
|
|
if ($usageTotal <= 0) {
|
|
return 0.0;
|
|
}
|
|
|
|
$overlap = 0;
|
|
foreach ($usageBag as $productId => $quantity) {
|
|
$overlap += min($quantity, $orderBag[$productId] ?? 0);
|
|
}
|
|
|
|
return $overlap / $usageTotal;
|
|
}
|
|
|
|
public static function productBagForAutomation(array $items): array
|
|
{
|
|
$bag = [];
|
|
foreach ($items as $item) {
|
|
$productId = (int)($item['product_id'] ?? 0);
|
|
if ($productId < 1) {
|
|
continue;
|
|
}
|
|
$bag[$productId] = ($bag[$productId] ?? 0) + max(1, (int)($item['quantity'] ?? 1));
|
|
}
|
|
|
|
return $bag;
|
|
}
|
|
|
|
private static function matchableUsageItemsForAutomation(array $items): array
|
|
{
|
|
$positiveItems = array_values(array_filter($items, static function (array $item): bool {
|
|
return (int)($item['product_id'] ?? 0) > 0
|
|
&& (int)($item['quantity'] ?? 0) > 0
|
|
&& (int)($item['price'] ?? 0) > 0;
|
|
}));
|
|
|
|
if ($positiveItems !== []) {
|
|
return $positiveItems;
|
|
}
|
|
|
|
return array_values(array_filter($items, static function (array $item): bool {
|
|
return (int)($item['product_id'] ?? 0) > 0
|
|
&& (int)($item['quantity'] ?? 0) > 0;
|
|
}));
|
|
}
|
|
|
|
private static function orderHasAdditionsBeyondUsage(array $usageItems, array $orderItems): bool
|
|
{
|
|
$usageBag = self::productBagForAutomation($usageItems);
|
|
foreach (self::productBagForAutomation($orderItems) as $productId => $quantity) {
|
|
if ($quantity > ($usageBag[$productId] ?? 0)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static function normalizeUsageLogRowForAutomation(array $row): array
|
|
{
|
|
unset($row['id']);
|
|
|
|
$washItems = $row['WashItems'] ?? [];
|
|
if (is_string($washItems)) {
|
|
$decoded = json_decode($washItems, true);
|
|
$row['WashItems'] = is_array($decoded) ? $decoded : [];
|
|
} elseif (!is_array($washItems)) {
|
|
$row['WashItems'] = [];
|
|
}
|
|
|
|
return $row;
|
|
}
|
|
|
|
public static function openAiCacheKeyForAutomation(
|
|
string $schemaName,
|
|
string $prompt,
|
|
array $payload,
|
|
array $schema,
|
|
float $temperature
|
|
): string {
|
|
$input = [
|
|
'version' => self::OPENAI_CACHE_VERSION,
|
|
'schema_name' => $schemaName,
|
|
'prompt' => $prompt,
|
|
'payload' => $payload,
|
|
'schema' => $schema,
|
|
'temperature' => round($temperature, 4),
|
|
];
|
|
|
|
return hash('sha256', self::stableJsonForAutomation($input));
|
|
}
|
|
|
|
public static function stableJsonForAutomation(mixed $value): string
|
|
{
|
|
$encoded = json_encode(
|
|
self::normalizeForStableJson($value),
|
|
JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION
|
|
);
|
|
|
|
if ($encoded === false) {
|
|
throw new Exception('Kunne ikke opbygge en stabil cache-nøgle for XL Vask-automatisering.');
|
|
}
|
|
|
|
return $encoded;
|
|
}
|
|
|
|
private static function normalizeForStableJson(mixed $value): mixed
|
|
{
|
|
if (!is_array($value)) {
|
|
return $value;
|
|
}
|
|
|
|
$normalized = array_map(fn(mixed $item): mixed => self::normalizeForStableJson($item), $value);
|
|
$isList = $normalized === [] || array_keys($normalized) === range(0, count($normalized) - 1);
|
|
if (!$isList) {
|
|
ksort($normalized, SORT_STRING);
|
|
}
|
|
|
|
return $normalized;
|
|
}
|
|
|
|
private function buildDeterministicSuggestion(array $context): ?array
|
|
{
|
|
$best = null;
|
|
foreach ($context['candidate_orders'] as $candidate) {
|
|
$score = $this->scoreOrderMatch($context['items'], $candidate['order_items']);
|
|
if ($score['confidence'] < self::MIN_SUGGESTION_CONFIDENCE) {
|
|
continue;
|
|
}
|
|
|
|
$candidateSuggestion = [
|
|
'action' => self::ACTION_ATTACH,
|
|
'confidence' => $score['confidence'],
|
|
'source' => $score['source'],
|
|
'matched_order_id' => (int)$candidate['id'],
|
|
'created_order_id' => null,
|
|
'candidate_order' => $candidate,
|
|
'proposed_order' => $context['proposed_order'],
|
|
'reason' => $score['reason'] . ' Ordre #' . (int)$candidate['id'] . '.',
|
|
];
|
|
|
|
if ($best === null || $candidateSuggestion['confidence'] > $best['confidence']) {
|
|
$best = $candidateSuggestion;
|
|
}
|
|
}
|
|
|
|
if ($best !== null && $this->hasAcceptedFeedback($context['signature_hash'], self::ACTION_ATTACH)) {
|
|
$best['confidence'] = max($best['confidence'], 0.96);
|
|
$best['source'] = self::SOURCE_HISTORY;
|
|
$best['reason'] = 'Tidligere godkendt mønster for køretøjet matcher ordre #' . (int)$best['matched_order_id'] . '.';
|
|
}
|
|
|
|
if ($best !== null) {
|
|
return $best;
|
|
}
|
|
|
|
if ($context['age_hours'] >= self::CREATE_MIN_AGE_HOURS) {
|
|
$history = $this->findMatchingHistoricalOrder($context);
|
|
if ($history !== null || $this->hasAcceptedFeedback($context['signature_hash'], self::ACTION_CREATE)) {
|
|
return [
|
|
'action' => self::ACTION_CREATE,
|
|
'confidence' => 0.98,
|
|
'source' => self::SOURCE_HISTORY,
|
|
'matched_order_id' => null,
|
|
'created_order_id' => null,
|
|
'candidate_order' => $history,
|
|
'proposed_order' => $context['proposed_order'],
|
|
'reason' => 'Vasken er over 6 timer gammel og matcher et tidligere godkendt køretøjsmønster.',
|
|
];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function buildSuggestionForContext(array $context): ?array
|
|
{
|
|
$suggestion = $this->buildDeterministicSuggestion($context);
|
|
|
|
if (
|
|
($suggestion === null || $suggestion['confidence'] < self::MIN_SUGGESTION_CONFIDENCE)
|
|
&& $this->isOpenAiEnabled()
|
|
) {
|
|
$suggestion = $this->buildOpenAiSuggestion($context) ?? $suggestion;
|
|
}
|
|
|
|
if ($suggestion === null || $suggestion['confidence'] < self::MIN_SUGGESTION_CONFIDENCE) {
|
|
return null;
|
|
}
|
|
|
|
if ($this->hasDeniedFeedback($context['signature_hash'], $suggestion['action'])) {
|
|
return null;
|
|
}
|
|
|
|
return $suggestion;
|
|
}
|
|
|
|
private function buildOpenAiSuggestion(array $context): ?array
|
|
{
|
|
try {
|
|
$schemaName = 'xlvask_automation';
|
|
$prompt = 'Vurder om en XL Vask-vask skal tilknyttes en eksisterende ordre, oprettes som ordre eller ikke behandles. Returner kun JSON efter skemaet.';
|
|
$temperature = 0.1;
|
|
$schema = [
|
|
'type' => 'object',
|
|
'properties' => [
|
|
'action' => ['type' => 'string', 'enum' => [self::ACTION_ATTACH, self::ACTION_CREATE, self::ACTION_NONE]],
|
|
'confidence' => ['type' => 'number'],
|
|
'reason_da' => ['type' => 'string'],
|
|
'candidate_order_id' => ['type' => ['integer', 'null']],
|
|
'proposed_order_items' => [
|
|
'type' => 'array',
|
|
'items' => [
|
|
'type' => 'object',
|
|
'properties' => [
|
|
'product_id' => ['type' => 'integer'],
|
|
'quantity' => ['type' => 'integer'],
|
|
'price' => ['type' => 'integer'],
|
|
],
|
|
'required' => ['product_id', 'quantity', 'price'],
|
|
'additionalProperties' => false,
|
|
],
|
|
],
|
|
'risk_flags' => ['type' => 'array', 'items' => ['type' => 'string']],
|
|
],
|
|
'required' => ['action', 'confidence', 'reason_da', 'candidate_order_id', 'proposed_order_items', 'risk_flags'],
|
|
'additionalProperties' => false,
|
|
];
|
|
|
|
$creationAllowed = $context['age_hours'] >= self::CREATE_MIN_AGE_HOURS;
|
|
$payload = [
|
|
'usage_log' => [
|
|
'wash_id' => $context['wash_id'],
|
|
'registration' => $context['signature']['registration'],
|
|
'customer_number' => $context['signature']['customer_number'],
|
|
'department_id' => $context['signature']['department_id'],
|
|
'lane' => $context['signature']['lane'],
|
|
'created_at' => $context['proposed_order']['created_at'] ?? null,
|
|
'total_net_amount' => $context['total'],
|
|
'items' => $this->compactItems($context['items']),
|
|
'creation_allowed' => $creationAllowed,
|
|
'age_bucket' => $creationAllowed ? 'older_than_6_hours' : 'newer_than_6_hours',
|
|
],
|
|
'candidate_orders' => array_map(fn(array $candidate): array => [
|
|
'id' => (int)$candidate['id'],
|
|
'created_at' => $candidate['created_at'] ?? null,
|
|
'total_net_amount' => (int)($candidate['total_net_amount'] ?? 0),
|
|
'items' => $this->compactItems($candidate['order_items'] ?? []),
|
|
], $context['candidate_orders']),
|
|
];
|
|
|
|
$cacheKey = self::openAiCacheKeyForAutomation($schemaName, $prompt, $payload, $schema, $temperature);
|
|
$result = $this->loadOpenAiCacheResult($cacheKey);
|
|
if ($result === null) {
|
|
$openai = new openai();
|
|
$result = $openai->jsonTask($schemaName, $prompt, $payload, $schema, $temperature);
|
|
$this->persistOpenAiCacheResult($cacheKey, $schemaName, $payload, $schema, $prompt, $temperature, $result);
|
|
}
|
|
|
|
$action = (string)($result['action'] ?? self::ACTION_NONE);
|
|
$confidence = (float)($result['confidence'] ?? 0);
|
|
if (!in_array($action, [self::ACTION_ATTACH, self::ACTION_CREATE], true) || $confidence < self::MIN_SUGGESTION_CONFIDENCE) {
|
|
return null;
|
|
}
|
|
|
|
if ($action === self::ACTION_CREATE && $context['age_hours'] < self::CREATE_MIN_AGE_HOURS) {
|
|
return null;
|
|
}
|
|
|
|
$candidate = null;
|
|
$candidateOrderId = (int)($result['candidate_order_id'] ?? 0);
|
|
if ($action === self::ACTION_ATTACH) {
|
|
foreach ($context['candidate_orders'] as $candidateOrder) {
|
|
if ((int)$candidateOrder['id'] === $candidateOrderId) {
|
|
$candidate = $candidateOrder;
|
|
break;
|
|
}
|
|
}
|
|
if ($candidate === null) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
return [
|
|
'action' => $action,
|
|
'confidence' => min(1.0, max(0.0, $confidence)),
|
|
'source' => self::SOURCE_OPENAI,
|
|
'matched_order_id' => $candidateOrderId > 0 ? $candidateOrderId : null,
|
|
'created_order_id' => null,
|
|
'candidate_order' => $candidate,
|
|
'proposed_order' => $context['proposed_order'],
|
|
'reason' => (string)($result['reason_da'] ?? 'OpenAI foreslår handlingen ud fra tilgængelige ordredata.'),
|
|
];
|
|
} catch (Exception) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private function shouldAutoExecute(array $suggestion, array $context): bool
|
|
{
|
|
$confidence = (float)$suggestion['confidence'];
|
|
$action = (string)$suggestion['action'];
|
|
$xlvask = new xlvask();
|
|
|
|
if ($action === self::ACTION_ATTACH) {
|
|
return $xlvask->config->automatic_order_attachment_enabled->isTrue()
|
|
&& $confidence >= self::AUTO_ATTACH_CONFIDENCE;
|
|
}
|
|
|
|
if ($action === self::ACTION_CREATE) {
|
|
return $xlvask->config->automatic_order_creation_enabled->isTrue()
|
|
&& $context['age_hours'] >= self::CREATE_MIN_AGE_HOURS
|
|
&& $confidence >= self::AUTO_CREATE_CONFIDENCE;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private function executeSuggestion(array $suggestion, array $context, ?int $actorId, bool $automatic): array
|
|
{
|
|
try {
|
|
$action = (string)$suggestion['action'];
|
|
if ($action === self::ACTION_ATTACH) {
|
|
$orderId = (int)$suggestion['matched_order_id'];
|
|
if ($orderId < 1) {
|
|
throw new Exception('Forslaget mangler en ordre at tilknytte.');
|
|
}
|
|
|
|
if ((new orders_o())->selectByWashId($context['wash_id']) !== null) {
|
|
throw new Exception('Vasken er allerede tilknyttet en ordre.');
|
|
}
|
|
|
|
$order = (new orders_o())->select($orderId);
|
|
$order->wash_id->set($context['wash_id']);
|
|
$this->updateSuggestionExecution((int)$suggestion['id'], $automatic ? self::STATUS_AUTO_ACCEPTED : self::STATUS_ACCEPTED, $actorId, $orderId, null);
|
|
} elseif ($action === self::ACTION_CREATE) {
|
|
if ($context['age_hours'] < self::CREATE_MIN_AGE_HOURS) {
|
|
throw new Exception('Vasken er ikke gammel nok til automatisk ordreoprettelse.');
|
|
}
|
|
|
|
if ((new orders_o())->selectByWashId($context['wash_id']) !== null) {
|
|
throw new Exception('Vasken er allerede tilknyttet en ordre.');
|
|
}
|
|
|
|
$order = $this->createOrderFromContext($context);
|
|
$this->updateSuggestionExecution((int)$suggestion['id'], $automatic ? self::STATUS_AUTO_ACCEPTED : self::STATUS_ACCEPTED, $actorId, null, (int)$order->id);
|
|
} else {
|
|
throw new Exception('Ukendt automatiseringshandling.');
|
|
}
|
|
|
|
$latest = $this->loadSuggestion((int)$suggestion['id']) ?? $suggestion;
|
|
if ($automatic) {
|
|
$this->persistFeedback($context, $action, 'accepted', (int)($latest['matched_order_id'] ?? $latest['created_order_id'] ?? 0), $actorId, 'Automatisk accepteret.');
|
|
}
|
|
|
|
return $this->formatSuggestion($latest);
|
|
} catch (Exception $e) {
|
|
$this->updateSuggestionFailure((int)$suggestion['id'], $e->getMessage(), $actorId);
|
|
return [
|
|
...$this->formatSuggestion($this->loadSuggestion((int)$suggestion['id']) ?? $suggestion),
|
|
'status' => self::STATUS_FAILED,
|
|
'error' => $e->getMessage(),
|
|
];
|
|
}
|
|
}
|
|
|
|
private function createOrderFromContext(array $context): orders_o
|
|
{
|
|
$orderData = $context['proposed_order'];
|
|
$items = $context['items'];
|
|
|
|
$order = new orders_o();
|
|
$order->add(
|
|
(int)$orderData['customer_id'],
|
|
self::AUTOMATION_CASHIER_ID,
|
|
(string)($orderData['reference'] ?? ''),
|
|
(string)($orderData['notes'] ?? ''),
|
|
(int)$orderData['department_id'],
|
|
(string)($orderData['reg_1'] ?? ''),
|
|
(string)($orderData['reg_2'] ?? ''),
|
|
(string)($orderData['reg_3'] ?? '')
|
|
);
|
|
$order->wash_id->set($context['wash_id']);
|
|
if (isset($orderData['lane'])) {
|
|
$order->lane->set((int)$orderData['lane']);
|
|
}
|
|
if (!empty($orderData['created_at'])) {
|
|
$order->created_at->set((string)$orderData['created_at']);
|
|
}
|
|
|
|
$firstItemId = null;
|
|
foreach ($items as $item) {
|
|
$orderItem = new order_items_o();
|
|
$orderItem->add(
|
|
(int)$order->id,
|
|
(int)$item['product_id'],
|
|
(string)($item['reference'] ?? ''),
|
|
(string)($item['notes'] ?? ''),
|
|
self::AUTOMATION_CASHIER_ID,
|
|
(int)$item['price'],
|
|
(int)$item['quantity'],
|
|
$firstItemId
|
|
);
|
|
if ($firstItemId === null) {
|
|
$firstItemId = (int)$orderItem->id;
|
|
}
|
|
}
|
|
|
|
$order->objectChanged();
|
|
return $order;
|
|
}
|
|
|
|
private function buildContext(int $usageLogId, xlvask_usage_log $log): array
|
|
{
|
|
$simulated = (new orders_o())->simulateOrderFromXLVask($log, true);
|
|
$proposedOrder = $simulated['order'] ?? [];
|
|
$items = $simulated['order_items'] ?? [];
|
|
$signature = $this->buildSignature($log, $proposedOrder, $items);
|
|
$signatureJson = json_encode($signature, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
|
|
if ($signatureJson === false) {
|
|
throw new Exception('Kunne ikke opbygge signatur for XL Vask-vasken.');
|
|
}
|
|
|
|
return [
|
|
'usage_log_id' => $usageLogId,
|
|
'wash_id' => (string)$log->WashId,
|
|
'log' => $log,
|
|
'proposed_order' => $proposedOrder,
|
|
'items' => $items,
|
|
'total' => $this->itemsTotal($items),
|
|
'signature' => $signature,
|
|
'signature_json' => $signatureJson,
|
|
'signature_hash' => hash('sha256', $signatureJson),
|
|
'age_hours' => max(0.0, (time() - strtotime((string)$log->StartTime)) / 3600),
|
|
'candidate_orders' => $this->findSameDayCandidateOrders($log, $proposedOrder),
|
|
];
|
|
}
|
|
|
|
private function contextGuardReason(array $context): ?string
|
|
{
|
|
if ((int)($context['proposed_order']['customer_id'] ?? 0) < 1) {
|
|
return 'Vasken mangler en gyldig kundemapping.';
|
|
}
|
|
|
|
if ((int)($context['proposed_order']['department_id'] ?? 0) < 1) {
|
|
return 'Vasken mangler en gyldig afdelingsmapping.';
|
|
}
|
|
|
|
if (!is_array($context['items'] ?? null) || count($context['items']) < 1) {
|
|
return 'Vasken mangler gyldige produkter.';
|
|
}
|
|
|
|
foreach ($context['items'] as $item) {
|
|
if (!is_array($item) || (int)($item['product_id'] ?? 0) < 1) {
|
|
return 'Vasken mangler gyldige produkter.';
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function buildSignature(xlvask_usage_log $log, array $proposedOrder, array $items): array
|
|
{
|
|
return [
|
|
'registration' => $this->normalizeRegistration((string)$log->RegistrationNumber),
|
|
'customer_number' => (int)$log->CustomerId,
|
|
'department_id' => (int)($proposedOrder['department_id'] ?? 0),
|
|
'lane' => (int)($proposedOrder['lane'] ?? 0),
|
|
'primary_product_id' => (int)($items[0]['product_id'] ?? 0),
|
|
'items' => $this->itemSignatureParts($items),
|
|
'total_net_amount' => $this->itemsTotal($items),
|
|
];
|
|
}
|
|
|
|
private function scoreOrderMatch(array $usageItems, array $orderItems): array
|
|
{
|
|
return self::scoreItemMatchForAutomation($usageItems, $orderItems);
|
|
|
|
$usageSignature = $this->itemSignatureParts($usageItems);
|
|
$orderSignature = $this->itemSignatureParts($orderItems);
|
|
$usageTotal = $this->itemsTotal($usageItems);
|
|
$orderTotal = $this->itemsTotal($orderItems);
|
|
|
|
if ($usageSignature === $orderSignature && $usageTotal === $orderTotal) {
|
|
return [
|
|
'confidence' => 0.95,
|
|
'source' => self::SOURCE_DETERMINISTIC,
|
|
'reason' => 'Produkterne og prisen matcher en ordre fra samme dag.',
|
|
];
|
|
}
|
|
|
|
$usagePrimary = (int)($usageItems[0]['product_id'] ?? 0);
|
|
$orderPrimary = (int)($orderItems[0]['product_id'] ?? 0);
|
|
if ($usagePrimary < 1 || $usagePrimary !== $orderPrimary) {
|
|
return ['confidence' => 0.0, 'source' => self::SOURCE_DETERMINISTIC, 'reason' => ''];
|
|
}
|
|
|
|
$overlap = $this->productOverlap($usageItems, $orderItems);
|
|
$totalDiff = abs($usageTotal - $orderTotal);
|
|
if ($overlap >= 0.70 && $totalDiff <= 50) {
|
|
return [
|
|
'confidence' => 0.93,
|
|
'source' => self::SOURCE_FUZZY,
|
|
'reason' => 'Samme primære produkt og relaterede tillæg matcher en ordre fra samme dag.',
|
|
];
|
|
}
|
|
|
|
if ($overlap >= 0.50 && $totalDiff <= 150) {
|
|
return [
|
|
'confidence' => 0.80,
|
|
'source' => self::SOURCE_FUZZY,
|
|
'reason' => 'Vasken ligner en ordre fra samme dag, men kræver manuel godkendelse.',
|
|
];
|
|
}
|
|
|
|
return ['confidence' => 0.0, 'source' => self::SOURCE_DETERMINISTIC, 'reason' => ''];
|
|
}
|
|
|
|
private function findSameDayCandidateOrders(xlvask_usage_log $log, array $proposedOrder): array
|
|
{
|
|
global $db;
|
|
|
|
$registration = $db->escape_string($this->normalizeRegistration((string)$log->RegistrationNumber));
|
|
$rawRegistration = $db->escape_string(trim((string)$log->RegistrationNumber));
|
|
$customerNumber = (int)$log->CustomerId;
|
|
$departmentId = (int)($proposedOrder['department_id'] ?? 0);
|
|
$date = date('Y-m-d', strtotime((string)$log->StartTime));
|
|
$from = $db->escape_string($date . ' 00:00:00');
|
|
$to = $db->escape_string($date . ' 23:59:59');
|
|
|
|
if ($registration === '' || $customerNumber < 1 || $departmentId < 1) {
|
|
return [];
|
|
}
|
|
|
|
$sql = "SELECT *
|
|
FROM orders
|
|
WHERE deleted_at IS NULL
|
|
AND customer_id = {$customerNumber}
|
|
AND department_id = {$departmentId}
|
|
AND cashier_id <> " . self::AUTOMATION_CASHIER_ID . "
|
|
AND created_at BETWEEN '{$from}' AND '{$to}'
|
|
AND (wash_id IS NULL OR wash_id = '')
|
|
AND (
|
|
REPLACE(UPPER(reg_1), ' ', '') IN ('{$registration}', '{$rawRegistration}')
|
|
OR REPLACE(UPPER(reg_2), ' ', '') IN ('{$registration}', '{$rawRegistration}')
|
|
OR REPLACE(UPPER(reg_3), ' ', '') IN ('{$registration}', '{$rawRegistration}')
|
|
)
|
|
ORDER BY ABS(TIMESTAMPDIFF(SECOND, created_at, '" . $db->escape_string(date('Y-m-d H:i:s', strtotime((string)$log->StartTime))) . "')) ASC
|
|
LIMIT 20";
|
|
|
|
$rows = $db->fetch_all($db->query($sql));
|
|
return array_map(function (array $row): array {
|
|
$orderItems = (new orders_o())->getOrderItems((int)$row['id']);
|
|
return [
|
|
...$row,
|
|
'id' => (int)$row['id'],
|
|
'total_net_amount' => (int)($row['total_net_amount'] ?? $this->itemsTotal($orderItems)),
|
|
'order_items' => $orderItems,
|
|
];
|
|
}, $rows);
|
|
}
|
|
|
|
private function findMatchingHistoricalOrder(array $context): ?array
|
|
{
|
|
global $db;
|
|
|
|
$signature = $context['signature'];
|
|
$registration = $db->escape_string((string)$signature['registration']);
|
|
$customerNumber = (int)$signature['customer_number'];
|
|
$departmentId = (int)$signature['department_id'];
|
|
$createdBefore = $db->escape_string((string)($context['proposed_order']['created_at'] ?? date('Y-m-d H:i:s')));
|
|
|
|
if ($registration === '' || $customerNumber < 1 || $departmentId < 1) {
|
|
return null;
|
|
}
|
|
|
|
$sql = "SELECT *
|
|
FROM orders
|
|
WHERE deleted_at IS NULL
|
|
AND customer_id = {$customerNumber}
|
|
AND department_id = {$departmentId}
|
|
AND created_at < '{$createdBefore}'
|
|
AND (
|
|
REPLACE(UPPER(reg_1), ' ', '') = '{$registration}'
|
|
OR REPLACE(UPPER(reg_2), ' ', '') = '{$registration}'
|
|
OR REPLACE(UPPER(reg_3), ' ', '') = '{$registration}'
|
|
)
|
|
ORDER BY created_at DESC
|
|
LIMIT 10";
|
|
|
|
foreach ($db->fetch_all($db->query($sql)) as $row) {
|
|
$orderItems = (new orders_o())->getOrderItems((int)$row['id']);
|
|
if ($this->itemSignatureParts($orderItems) === $signature['items']) {
|
|
return [
|
|
...$row,
|
|
'id' => (int)$row['id'],
|
|
'order_items' => $orderItems,
|
|
];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function guardReason(xlvask_usage_log $log): ?string
|
|
{
|
|
if (!empty($log->ignored_at)) {
|
|
return 'Vasken er ignoreret.';
|
|
}
|
|
|
|
if (!$log->isCompleted()) {
|
|
return 'Vasken er ikke afsluttet.';
|
|
}
|
|
|
|
if (!$log->hasBillableCustomer()) {
|
|
return 'Vasken mangler en fakturerbar kunde.';
|
|
}
|
|
|
|
if ((new orders_o())->selectByWashId($log->WashId) !== null) {
|
|
return 'Vasken er allerede tilknyttet en ordre.';
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private function persistSuggestion(array $context, array $suggestion, ?int $actorId): int
|
|
{
|
|
global $db;
|
|
|
|
$existing = $this->latestActionableSuggestion((int)$context['usage_log_id']);
|
|
if ($existing !== null) {
|
|
$this->updateSuggestionProposal((int)$existing['id'], $context, $suggestion, $actorId);
|
|
return (int)$existing['id'];
|
|
}
|
|
|
|
$fields = [
|
|
'usage_log_id' => (int)$context['usage_log_id'],
|
|
'wash_id' => (string)$context['wash_id'],
|
|
'signature_hash' => (string)$context['signature_hash'],
|
|
'signature_json' => (string)$context['signature_json'],
|
|
'action' => (string)$suggestion['action'],
|
|
'status' => self::STATUS_SUGGESTED,
|
|
'confidence' => (float)$suggestion['confidence'],
|
|
'source' => (string)$suggestion['source'],
|
|
'matched_order_id' => $suggestion['matched_order_id'] === null ? null : (int)$suggestion['matched_order_id'],
|
|
'created_order_id' => null,
|
|
'proposed_order_json' => json_encode($suggestion['proposed_order'], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
|
|
'candidate_order_json' => json_encode($suggestion['candidate_order'], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
|
|
'reason' => (string)$suggestion['reason'],
|
|
'created_by' => $actorId,
|
|
];
|
|
|
|
$columns = [];
|
|
$values = [];
|
|
foreach ($fields as $column => $value) {
|
|
$columns[] = "`{$column}`";
|
|
if ($value === null) {
|
|
$values[] = 'NULL';
|
|
} elseif (is_int($value) || is_float($value)) {
|
|
$values[] = (string)$value;
|
|
} else {
|
|
$values[] = "'" . $db->escape_string((string)$value) . "'";
|
|
}
|
|
}
|
|
|
|
$db->query('INSERT INTO xlvask_automation_suggestions (' . implode(', ', $columns) . ') VALUES (' . implode(', ', $values) . ')');
|
|
return (int)$db->insert_id();
|
|
}
|
|
|
|
private function updateSuggestionProposal(int $suggestionId, array $context, array $suggestion, ?int $actorId): void
|
|
{
|
|
global $db;
|
|
|
|
$fields = [
|
|
'signature_hash' => (string)$context['signature_hash'],
|
|
'signature_json' => (string)$context['signature_json'],
|
|
'action' => (string)$suggestion['action'],
|
|
'confidence' => (float)$suggestion['confidence'],
|
|
'source' => (string)$suggestion['source'],
|
|
'matched_order_id' => $suggestion['matched_order_id'] === null ? null : (int)$suggestion['matched_order_id'],
|
|
'created_order_id' => null,
|
|
'proposed_order_json' => json_encode($suggestion['proposed_order'], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
|
|
'candidate_order_json' => json_encode($suggestion['candidate_order'], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES),
|
|
'reason' => (string)$suggestion['reason'],
|
|
];
|
|
|
|
if ($actorId !== null) {
|
|
$fields['created_by'] = $actorId;
|
|
}
|
|
|
|
$assignments = [];
|
|
foreach ($fields as $column => $value) {
|
|
if ($value === null) {
|
|
$sqlValue = 'NULL';
|
|
} elseif (is_int($value) || is_float($value)) {
|
|
$sqlValue = (string)$value;
|
|
} else {
|
|
$sqlValue = "'" . $db->escape_string((string)$value) . "'";
|
|
}
|
|
$assignments[] = "`{$column}` = {$sqlValue}";
|
|
}
|
|
|
|
$db->query(
|
|
'UPDATE xlvask_automation_suggestions SET ' . implode(', ', $assignments) .
|
|
" WHERE id = {$suggestionId} AND status = '" . self::STATUS_SUGGESTED . "'"
|
|
);
|
|
}
|
|
|
|
private function persistFeedback(array $context, string $action, string $decision, int $orderId = 0, ?int $actorId = null, ?string $reason = null): void
|
|
{
|
|
global $db;
|
|
|
|
$values = [
|
|
'usage_log_id' => (int)$context['usage_log_id'],
|
|
'wash_id' => (string)$context['wash_id'],
|
|
'signature_hash' => (string)$context['signature_hash'],
|
|
'signature_json' => (string)$context['signature_json'],
|
|
'action' => $action,
|
|
'decision' => $decision,
|
|
'order_id' => $orderId > 0 ? $orderId : null,
|
|
'reason' => $reason,
|
|
'created_by' => $actorId,
|
|
];
|
|
|
|
$columns = [];
|
|
$sqlValues = [];
|
|
foreach ($values as $column => $value) {
|
|
$columns[] = "`{$column}`";
|
|
if ($value === null) {
|
|
$sqlValues[] = 'NULL';
|
|
} elseif (is_int($value)) {
|
|
$sqlValues[] = (string)$value;
|
|
} else {
|
|
$sqlValues[] = "'" . $db->escape_string((string)$value) . "'";
|
|
}
|
|
}
|
|
|
|
$db->query('INSERT INTO xlvask_automation_feedback (' . implode(', ', $columns) . ') VALUES (' . implode(', ', $sqlValues) . ')');
|
|
}
|
|
|
|
private function loadOpenAiCacheResult(string $cacheKey): ?array
|
|
{
|
|
global $db;
|
|
|
|
$cacheKey = $db->escape_string($cacheKey);
|
|
$result = $db->query(
|
|
"SELECT result_json FROM xlvask_automation_openai_cache
|
|
WHERE cache_key = '{$cacheKey}'
|
|
LIMIT 1"
|
|
);
|
|
if ($result === false || $result->num_rows < 1) {
|
|
return null;
|
|
}
|
|
|
|
$row = $db->fetch_assoc($result);
|
|
$decoded = json_decode((string)($row['result_json'] ?? ''), true);
|
|
if (json_last_error() !== JSON_ERROR_NONE || !is_array($decoded)) {
|
|
return null;
|
|
}
|
|
|
|
$db->query(
|
|
"UPDATE xlvask_automation_openai_cache
|
|
SET hits = hits + 1, last_hit_at = NOW()
|
|
WHERE cache_key = '{$cacheKey}'"
|
|
);
|
|
|
|
return $decoded;
|
|
}
|
|
|
|
private function persistOpenAiCacheResult(
|
|
string $cacheKey,
|
|
string $schemaName,
|
|
array $payload,
|
|
array $schema,
|
|
string $prompt,
|
|
float $temperature,
|
|
array $result
|
|
): void {
|
|
global $db;
|
|
|
|
$input = [
|
|
'version' => self::OPENAI_CACHE_VERSION,
|
|
'schema_name' => $schemaName,
|
|
'prompt' => $prompt,
|
|
'payload' => $payload,
|
|
'schema' => $schema,
|
|
'temperature' => round($temperature, 4),
|
|
];
|
|
|
|
$inputJson = self::stableJsonForAutomation($input);
|
|
$resultJson = json_encode($result, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES | JSON_PRESERVE_ZERO_FRACTION);
|
|
if ($resultJson === false) {
|
|
return;
|
|
}
|
|
|
|
$cacheKey = $db->escape_string($cacheKey);
|
|
$schemaName = $db->escape_string($schemaName);
|
|
$inputJson = $db->escape_string($inputJson);
|
|
$resultJson = $db->escape_string($resultJson);
|
|
|
|
$db->query(
|
|
"INSERT INTO xlvask_automation_openai_cache
|
|
(cache_key, schema_name, input_json, result_json)
|
|
VALUES
|
|
('{$cacheKey}', '{$schemaName}', '{$inputJson}', '{$resultJson}')
|
|
ON DUPLICATE KEY UPDATE
|
|
result_json = VALUES(result_json),
|
|
input_json = VALUES(input_json),
|
|
updated_at = NOW()"
|
|
);
|
|
}
|
|
|
|
private function hasAcceptedFeedback(string $signatureHash, string $action): bool
|
|
{
|
|
return $this->hasFeedbackDecision($signatureHash, $action, 'accepted');
|
|
}
|
|
|
|
private function hasDeniedFeedback(string $signatureHash, string $action): bool
|
|
{
|
|
return $this->hasFeedbackDecision($signatureHash, $action, 'denied');
|
|
}
|
|
|
|
private function hasFeedbackDecision(string $signatureHash, string $action, string $decision): bool
|
|
{
|
|
global $db;
|
|
$signatureHash = $db->escape_string($signatureHash);
|
|
$action = $db->escape_string($action);
|
|
$decision = $db->escape_string($decision);
|
|
$result = $db->query(
|
|
"SELECT id FROM xlvask_automation_feedback
|
|
WHERE signature_hash = '{$signatureHash}' AND action = '{$action}' AND decision = '{$decision}'
|
|
ORDER BY id DESC LIMIT 1"
|
|
);
|
|
return $result !== false && $result->num_rows > 0;
|
|
}
|
|
|
|
private function latestTerminalSuggestion(int $usageLogId): ?array
|
|
{
|
|
return $this->latestSuggestionWhere($usageLogId, [
|
|
self::STATUS_SUGGESTED,
|
|
self::STATUS_AUTO_ACCEPTED,
|
|
self::STATUS_ACCEPTED,
|
|
self::STATUS_DENIED,
|
|
]);
|
|
}
|
|
|
|
private function latestActionableSuggestion(int $usageLogId): ?array
|
|
{
|
|
return $this->latestSuggestionWhere($usageLogId, [self::STATUS_SUGGESTED]);
|
|
}
|
|
|
|
private function latestSuggestionWhere(int $usageLogId, array $statuses): ?array
|
|
{
|
|
global $db;
|
|
$statusSql = implode(',', array_map(fn(string $status): string => "'" . $db->escape_string($status) . "'", $statuses));
|
|
$result = $db->query(
|
|
"SELECT * FROM xlvask_automation_suggestions
|
|
WHERE usage_log_id = {$usageLogId} AND status IN ({$statusSql})
|
|
ORDER BY id DESC LIMIT 1"
|
|
);
|
|
if ($result === false || $result->num_rows < 1) {
|
|
return null;
|
|
}
|
|
|
|
return $db->fetch_assoc($result);
|
|
}
|
|
|
|
private function loadSuggestion(int $suggestionId): ?array
|
|
{
|
|
global $db;
|
|
$result = $db->query("SELECT * FROM xlvask_automation_suggestions WHERE id = {$suggestionId} LIMIT 1");
|
|
if ($result === false || $result->num_rows < 1) {
|
|
return null;
|
|
}
|
|
return $db->fetch_assoc($result);
|
|
}
|
|
|
|
private function updateSuggestionStatus(int $suggestionId, string $status, ?int $actorId): void
|
|
{
|
|
global $db;
|
|
$status = $db->escape_string($status);
|
|
$actorSql = $actorId === null ? 'NULL' : (string)(int)$actorId;
|
|
$db->query(
|
|
"UPDATE xlvask_automation_suggestions
|
|
SET status = '{$status}', decided_by = {$actorSql}, decided_at = NOW()
|
|
WHERE id = {$suggestionId}"
|
|
);
|
|
}
|
|
|
|
private function updateSuggestionExecution(int $suggestionId, string $status, ?int $actorId, ?int $matchedOrderId, ?int $createdOrderId): void
|
|
{
|
|
global $db;
|
|
$status = $db->escape_string($status);
|
|
$actorSql = $actorId === null ? 'NULL' : (string)(int)$actorId;
|
|
$matchedSql = $matchedOrderId === null ? 'matched_order_id' : (string)(int)$matchedOrderId;
|
|
$createdSql = $createdOrderId === null ? 'created_order_id' : (string)(int)$createdOrderId;
|
|
$db->query(
|
|
"UPDATE xlvask_automation_suggestions
|
|
SET status = '{$status}',
|
|
decided_by = {$actorSql},
|
|
decided_at = NOW(),
|
|
executed_at = NOW(),
|
|
matched_order_id = {$matchedSql},
|
|
created_order_id = {$createdSql}
|
|
WHERE id = {$suggestionId}"
|
|
);
|
|
}
|
|
|
|
private function updateSuggestionFailure(int $suggestionId, string $message, ?int $actorId): void
|
|
{
|
|
global $db;
|
|
$actorSql = $actorId === null ? 'NULL' : (string)(int)$actorId;
|
|
$message = $db->escape_string($message);
|
|
$db->query(
|
|
"UPDATE xlvask_automation_suggestions
|
|
SET status = '" . self::STATUS_FAILED . "',
|
|
reason = CONCAT(COALESCE(reason, ''), ' Fejl: {$message}'),
|
|
decided_by = {$actorSql},
|
|
decided_at = NOW()
|
|
WHERE id = {$suggestionId}"
|
|
);
|
|
}
|
|
|
|
private function loadUsageLogRow(int $usageLogId): ?array
|
|
{
|
|
global $db;
|
|
(new xlvask_usage_logs_o())->structure();
|
|
$result = $db->query("SELECT * FROM xlvask_usage_logs WHERE id = {$usageLogId} LIMIT 1");
|
|
if ($result === false || $result->num_rows < 1) {
|
|
return null;
|
|
}
|
|
|
|
return $db->fetch_assoc($result);
|
|
}
|
|
|
|
private function loadUsageLogRowsByIds(array $ids): array
|
|
{
|
|
global $db;
|
|
$ids = array_values(array_filter(array_map('intval', $ids), fn(int $id): bool => $id > 0));
|
|
if ($ids === []) {
|
|
return [];
|
|
}
|
|
|
|
(new xlvask_usage_logs_o())->structure();
|
|
$result = $db->query('SELECT * FROM xlvask_usage_logs WHERE id IN (' . implode(',', $ids) . ')');
|
|
return $db->fetch_all($result);
|
|
}
|
|
|
|
private function loadPendingRows(?string $dateFrom, ?string $dateTo, int $limit): array
|
|
{
|
|
global $db;
|
|
(new xlvask_usage_logs_o())->structure();
|
|
$startTimeExpression = "STR_TO_DATE(REPLACE(SUBSTRING(StartTime, 1, 19), 'T', ' '), '%Y-%m-%d %H:%i:%s')";
|
|
$where = [
|
|
'FinishStatus = 1',
|
|
'(ignored_at IS NULL OR ignored_at = "")',
|
|
];
|
|
|
|
if ($dateFrom !== null && strtotime($dateFrom) !== false) {
|
|
$where[] = "{$startTimeExpression} >= '" . $db->escape_string(date('Y-m-d 00:00:00', strtotime($dateFrom))) . "'";
|
|
} else {
|
|
$where[] = "{$startTimeExpression} >= '" . $db->escape_string(date('Y-m-d H:i:s', strtotime('-7 days'))) . "'";
|
|
}
|
|
|
|
if ($dateTo !== null && strtotime($dateTo) !== false) {
|
|
$where[] = "{$startTimeExpression} <= '" . $db->escape_string(date('Y-m-d 23:59:59', strtotime($dateTo))) . "'";
|
|
}
|
|
|
|
$limit = max(1, min(500, $limit));
|
|
$result = $db->query('SELECT * FROM xlvask_usage_logs WHERE ' . implode(' AND ', $where) . " ORDER BY StartTime DESC LIMIT {$limit}");
|
|
return $db->fetch_all($result);
|
|
}
|
|
|
|
private function usageLogFromRow(array $row): xlvask_usage_log
|
|
{
|
|
$row = self::normalizeUsageLogRowForAutomation($row);
|
|
|
|
$xlvask = new xlvask();
|
|
return $xlvask->new($xlvask->helpers->xlvask_usage_log)->setProperties($row);
|
|
}
|
|
|
|
private function formatSuggestion(array $row): array
|
|
{
|
|
$status = (string)($row['status'] ?? self::STATUS_NONE);
|
|
return [
|
|
'id' => isset($row['id']) ? (int)$row['id'] : null,
|
|
'status' => $status,
|
|
'action' => (string)($row['action'] ?? self::ACTION_NONE),
|
|
'confidence' => isset($row['confidence']) ? (float)$row['confidence'] : 0.0,
|
|
'source' => (string)($row['source'] ?? ''),
|
|
'reason' => (string)($row['reason'] ?? ''),
|
|
'matched_order_id' => isset($row['matched_order_id']) && $row['matched_order_id'] !== null ? (int)$row['matched_order_id'] : null,
|
|
'created_order_id' => isset($row['created_order_id']) && $row['created_order_id'] !== null ? (int)$row['created_order_id'] : null,
|
|
'candidate_order' => $this->decodeJsonField($row['candidate_order_json'] ?? null),
|
|
'proposed_order' => $this->decodeJsonField($row['proposed_order_json'] ?? null),
|
|
'can_accept' => $status === self::STATUS_SUGGESTED,
|
|
'can_deny' => $status === self::STATUS_SUGGESTED,
|
|
];
|
|
}
|
|
|
|
private function emptyAutomation(string $reason = ''): array
|
|
{
|
|
return [
|
|
'id' => null,
|
|
'status' => self::STATUS_NONE,
|
|
'action' => self::ACTION_NONE,
|
|
'confidence' => 0.0,
|
|
'source' => '',
|
|
'reason' => $reason,
|
|
'matched_order_id' => null,
|
|
'created_order_id' => null,
|
|
'candidate_order' => null,
|
|
'proposed_order' => null,
|
|
'can_accept' => false,
|
|
'can_deny' => false,
|
|
];
|
|
}
|
|
|
|
private function decodeJsonField(?string $value): mixed
|
|
{
|
|
if ($value === null || $value === '') {
|
|
return null;
|
|
}
|
|
|
|
$decoded = json_decode($value, true);
|
|
return json_last_error() === JSON_ERROR_NONE ? $decoded : null;
|
|
}
|
|
|
|
private function itemSignatureParts(array $items): array
|
|
{
|
|
return self::itemSignaturePartsForAutomation($items);
|
|
}
|
|
|
|
private function compactItems(array $items): array
|
|
{
|
|
return array_map(fn(array $item): array => [
|
|
'product_id' => (int)($item['product_id'] ?? 0),
|
|
'product_name' => (string)($item['product']['name'] ?? $item['product_name'] ?? ''),
|
|
'quantity' => (int)($item['quantity'] ?? 0),
|
|
'price' => (int)($item['price'] ?? 0),
|
|
], $items);
|
|
}
|
|
|
|
private function itemsTotal(array $items): int
|
|
{
|
|
return array_reduce($items, fn(int $total, array $item): int => $total + ((int)($item['price'] ?? 0) * (int)($item['quantity'] ?? 0)), 0);
|
|
}
|
|
|
|
private function productOverlap(array $usageItems, array $orderItems): float
|
|
{
|
|
$usageBag = $this->productBag($usageItems);
|
|
$orderBag = $this->productBag($orderItems);
|
|
$usageTotal = array_sum($usageBag);
|
|
if ($usageTotal <= 0) {
|
|
return 0.0;
|
|
}
|
|
|
|
$overlap = 0;
|
|
foreach ($usageBag as $productId => $quantity) {
|
|
$overlap += min($quantity, $orderBag[$productId] ?? 0);
|
|
}
|
|
|
|
return $overlap / $usageTotal;
|
|
}
|
|
|
|
private function productBag(array $items): array
|
|
{
|
|
$bag = [];
|
|
foreach ($items as $item) {
|
|
$productId = (int)($item['product_id'] ?? 0);
|
|
if ($productId < 1) {
|
|
continue;
|
|
}
|
|
$bag[$productId] = ($bag[$productId] ?? 0) + max(1, (int)($item['quantity'] ?? 1));
|
|
}
|
|
|
|
return $bag;
|
|
}
|
|
|
|
private function normalizeRegistration(string $registration): string
|
|
{
|
|
return self::normalizeRegistrationForAutomation($registration);
|
|
}
|
|
|
|
private function isOpenAiEnabled(): bool
|
|
{
|
|
try {
|
|
$xlvask = new xlvask();
|
|
if (!$xlvask->config->openai_integration_enabled->isTrue()) {
|
|
return false;
|
|
}
|
|
|
|
$openai = new openai();
|
|
return $openai->config->enabled->isTrue();
|
|
} catch (Exception) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|