<?php

namespace App\Console\Commands\Etl;

use App\Services\Etl\OrderExtractor;
use Illuminate\Console\Command;
use Illuminate\Support\Facades\Log;
use Throwable;

class ExtractOrdersCommand extends Command
{
    protected $signature = 'etl:extract-orders
                            {--biz-date= : 业务日期，如 2026-05-31}
                            {--batch-id= : 本次 ETL 批次号}';

    protected $description = '抽取指定业务日期的订单数据到 ODS 层';

    public function __construct(private readonly OrderExtractor $extractor)
    {
        parent::__construct();
    }

    public function handle(): int
    {
        $bizDate = $this->option('biz-date');
        $batchId = $this->option('batch-id');

        if (!$bizDate || !$batchId) {
            $this->error('biz-date and batch-id are required');
            return self::FAILURE;
        }

        try {
            $result = $this->extractor->handle($bizDate, $batchId);

            Log::info('etl.extract_orders.success', [
                'biz_date' => $bizDate,
                'batch_id' => $batchId,
                'affected_rows' => $result['affected_rows'],
                'duration_ms' => $result['duration_ms'],
            ]);

            $this->info(json_encode([
                'status' => 'success',
                'biz_date' => $bizDate,
                'batch_id' => $batchId,
                'affected_rows' => $result['affected_rows'],
            ], JSON_UNESCAPED_UNICODE));

            return self::SUCCESS;
        } catch (Throwable $e) {
            Log::error('etl.extract_orders.failed', [
                'biz_date' => $bizDate,
                'batch_id' => $batchId,
                'message' => $e->getMessage(),
                'trace' => $e->getTraceAsString(),
            ]);

            $this->error($e->getMessage());
            return self::FAILURE;
        }
    }
}

<?php

namespace App\Services\Airflow;

use Illuminate\Support\Facades\Http;
use RuntimeException;

class AirflowClient
{
    public function triggerDag(string $dagId, array $conf = []): array
    {
        $baseUrl = config('services.airflow.base_url');
        $username = config('services.airflow.username');
        $password = config('services.airflow.password');

        $response = Http::withBasicAuth($username, $password)
            ->acceptJson()
            ->post("{$baseUrl}/api/v1/dags/{$dagId}/dagRuns", [
                'conf' => $conf,
            ]);

        if ($response->failed()) {
            throw new RuntimeException('Trigger Airflow DAG failed: ' . $response->body());
        }

        return $response->json();
    }
}

<?php

namespace App\Console;

use App\Services\Airflow\AirflowClient;
use Illuminate\Console\Scheduling\Schedule;
use Illuminate\Foundation\Console\Kernel as ConsoleKernel;
use Illuminate\Support\Carbon;

class Kernel extends ConsoleKernel
{
    protected function schedule(Schedule $schedule): void
    {
        $schedule->call(function (AirflowClient $client) {
            $bizDate = Carbon::yesterday('Asia/Shanghai')->toDateString();

            $client->triggerDag('laravel_order_etl_pipeline', [
                'biz_date' => $bizDate,
                'trigger_source' => 'laravel_scheduler',
            ]);
        })->dailyAt('02:25')->name('trigger-order-etl-dag');
    }
}

<?php

namespace App\Services\Etl;

use App\Models\Order;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\DB;

class OrderExtractor
{
    public function handle(string $bizDate, string $batchId): array
    {
        $start = microtime(true);

        $windowStart = Carbon::parse($bizDate, 'Asia/Shanghai')->startOfDay();
        $windowEnd = Carbon::parse($bizDate, 'Asia/Shanghai')->addDay()->startOfDay()->addHours(6);

        $affectedRows = 0;

        Order::query()
            ->whereBetween('updated_at', [$windowStart, $windowEnd])
            ->orderBy('id')
            ->chunkById(1000, function ($orders) use ($bizDate, $batchId, &$affectedRows) {
                $rows = [];

                foreach ($orders as $order) {
                    $rows[] = [
                        'biz_date' => $bizDate,
                        'batch_id' => $batchId,
                        'order_id' => $order->id,
                        'user_id' => $order->user_id,
                        'status' => $order->status,
                        'currency' => $order->currency,
                        'total_amount' => $order->total_amount,
                        'discount_amount' => $order->discount_amount,
                        'shipping_amount' => $order->shipping_amount,
                        'paid_amount' => $order->paid_amount,
                        'created_at_source' => $order->created_at,
                        'updated_at_source' => $order->updated_at,
                        'extracted_at' => now(),
                    ];
                }

                DB::table('ods_orders')->upsert(
                    $rows,
                    ['biz_date', 'order_id'],
                    [
                        'batch_id',
                        'user_id',
                        'status',
                        'currency',
                        'total_amount',
                        'discount_amount',
                        'shipping_amount',
                        'paid_amount',
                        'created_at_source',
                        'updated_at_source',
                        'extracted_at',
                    ]
                );

                $affectedRows += count($rows);
            });

        return [
            'affected_rows' => $affectedRows,
            'duration_ms' => (int) ((microtime(true) - $start) * 1000),
        ];
    }
}

<?php

namespace App\Services\Etl;

use Illuminate\Support\Facades\DB;

class OrderDetailBuilder
{
    public function handle(string $bizDate, string $batchId): array
    {
        $start = microtime(true);

        DB::transaction(function () use ($bizDate, $batchId) {
            DB::table('dwd_order_detail')
                ->where('biz_date', $bizDate)
                ->delete();

            DB::statement(
                "
                INSERT INTO dwd_order_detail (
                    biz_date,
                    batch_id,
                    order_id,
                    user_id,
                    order_status,
                    total_amount,
                    paid_amount,
                    refund_amount,
                    is_created,
                    is_paid,
                    is_refunded,
                    is_canceled,
                    is_net_valid,
                    order_created_at,
                    payment_paid_at,
                    refund_success_at,
                    channel,
                    device_type,
                    category_id,
                    province,
                    created_at,
                    updated_at
                )
                SELECT
                    o.biz_date,
                    ?,
                    o.order_id,
                    o.user_id,
                    o.status,
                    o.total_amount,
                    COALESCE(p.success_paid_amount, 0) AS paid_amount,
                    COALESCE(r.success_refund_amount, 0) AS refund_amount,
                    1 AS is_created,
                    CASE WHEN p.success_paid_amount > 0 THEN 1 ELSE 0 END AS is_paid,
                    CASE WHEN r.success_refund_amount > 0 THEN 1 ELSE 0 END AS is_refunded,
                    CASE WHEN o.status IN ('canceled', 'closed') THEN 1 ELSE 0 END AS is_canceled,
                    CASE
                        WHEN p.success_paid_amount > 0
                             AND COALESCE(r.success_refund_amount, 0) < COALESCE(p.success_paid_amount, 0)
                             AND o.status NOT IN ('canceled', 'closed')
                        THEN 1 ELSE 0
                    END AS is_net_valid,
                    o.created_at_source,
                    p.last_paid_at,
                    r.last_refund_success_at,
                    u.register_channel,
                    u.device_type,
                    oi.main_category_id,
                    u.province,
                    NOW(),
                    NOW()
                FROM ods_orders o
                LEFT JOIN (
                    SELECT
                        order_id,
                        SUM(CASE WHEN payment_status = 'success' THEN paid_amount ELSE 0 END) AS success_paid_amount,
                        MAX(CASE WHEN payment_status = 'success' THEN paid_at END) AS last_paid_at
                    FROM ods_payments
                    WHERE biz_date = ?
                    GROUP BY order_id
                ) p ON p.order_id = o.order_id
                LEFT JOIN (
                    SELECT
                        order_id,
                        SUM(CASE WHEN refund_status = 'success' THEN refund_amount ELSE 0 END) AS success_refund_amount,
                        MAX(CASE WHEN refund_status = 'success' THEN refund_success_at END) AS last_refund_success_at
                    FROM ods_refunds
                    WHERE biz_date = ?
                    GROUP BY order_id
                ) r ON r.order_id = o.order_id
                LEFT JOIN users u ON u.id = o.user_id
                LEFT JOIN (
                    SELECT order_id, MAX(category_id) AS main_category_id
                    FROM order_items
                    GROUP BY order_id
                ) oi ON oi.order_id = o.order_id
                WHERE o.biz_date = ?
                ",
                [$batchId, $bizDate, $bizDate, $bizDate]
            );
        });

        $count = DB::table('dwd_order_detail')->where('biz_date', $bizDate)->count();

        return [
            'affected_rows' => $count,
            'duration_ms' => (int) ((microtime(true) - $start) * 1000),
        ];
    }
}

<?php

namespace App\Services\Etl;

use Illuminate\Support\Facades\DB;

class DailyMetricsAggregator
{
    public function handle(string $bizDate, string $batchId): array
    {
        $start = microtime(true);

        DB::transaction(function () use ($bizDate, $batchId) {
            DB::table('ads_daily_metrics')->where('biz_date', $bizDate)->delete();

            $rows = DB::table('dwd_order_detail')
                ->selectRaw('biz_date')
                ->selectRaw('? as batch_id', [$batchId])
                ->selectRaw('COUNT(DISTINCT CASE WHEN is_created = 1 THEN order_id END) as order_count')
                ->selectRaw('COUNT(DISTINCT CASE WHEN is_paid = 1 THEN order_id END) as paid_order_count')
                ->selectRaw('COUNT(DISTINCT CASE WHEN is_paid = 1 THEN user_id END) as paid_user_count')
                ->selectRaw('SUM(CASE WHEN is_created = 1 THEN total_amount ELSE 0 END) as order_amount')
                ->selectRaw('SUM(CASE WHEN is_paid = 1 THEN paid_amount ELSE 0 END) as paid_amount')
                ->selectRaw('SUM(CASE WHEN is_refunded = 1 THEN refund_amount ELSE 0 END) as refund_amount')
                ->selectRaw('SUM(CASE WHEN is_net_valid = 1 THEN paid_amount - refund_amount ELSE 0 END) as net_gmv')
                ->where('biz_date', $bizDate)
                ->groupBy('biz_date')
                ->get()
                ->map(fn ($row) => (array) $row)
                ->all();

            if (!empty($rows)) {
                DB::table('ads_daily_metrics')->insert(array_map(function ($row) {
                    $row['created_at'] = now();
                    $row['updated_at'] = now();
                    return $row;
                }, $rows));
            }
        });

        return [
            'affected_rows' => DB::table('ads_daily_metrics')->where('biz_date', $bizDate)->count(),
            'duration_ms' => (int) ((microtime(true) - $start) * 1000),
        ];
    }
}

<?php

namespace App\Services\Etl;

use Illuminate\Support\Facades\DB;

class DashboardLoader
{
    public function handle(string $bizDate, string $batchId): array
    {
        $start = microtime(true);

        DB::transaction(function () use ($bizDate, $batchId) {
            $metric = DB::table('ads_daily_metrics')->where('biz_date', $bizDate)->first();

            if (!$metric) {
                throw new \RuntimeException("ads_daily_metrics not found for {$bizDate}");
            }

            DB::table('dashboard_daily_stats')->upsert([
                [
                    'biz_date' => $bizDate,
                    'batch_id' => $batchId,
                    'order_count' => $metric->order_count,
                    'paid_order_count' => $metric->paid_order_count,
                    'paid_user_count' => $metric->paid_user_count,
                    'order_amount' => $metric->order_amount,
                    'paid_amount' => $metric->paid_amount,
                    'refund_amount' => $metric->refund_amount,
                    'net_gmv' => $metric->net_gmv,
                    'load_status' => 'ready',
                    'created_at' => now(),
                    'updated_at' => now(),
                ]
            ], ['biz_date'], [
                'batch_id',
                'order_count',
                'paid_order_count',
                'paid_user_count',
                'order_amount',
                'paid_amount',
                'refund_amount',
                'net_gmv',
                'load_status',
                'updated_at',
            ]);
        });

        return [
            'affected_rows' => 1,
            'duration_ms' => (int) ((microtime(true) - $start) * 1000),
        ];
    }
}

use Illuminate\Support\Facades\DB;
use Throwable;

function retryTransaction(callable $callback, int $times = 3, int $sleepMs = 500)
{
    $attempt = 0;

    beginning:
    $attempt++;

    try {
        return DB::transaction($callback, 3);
    } catch (Throwable $e) {
        $message = $e->getMessage();

        $retryable = str_contains($message, 'Deadlock')
            || str_contains($message, 'Lock wait timeout')
            || str_contains($message, 'server has gone away');

        if ($retryable && $attempt < $times) {
            usleep($sleepMs * 1000);
            goto beginning;
        }

        throw $e;
    }
}

<?php

namespace App\Services\Etl;

use Illuminate\Support\Facades\DB;
use RuntimeException;

class MetricsVerifier
{
    public function handle(string $bizDate, string $batchId): array
    {
        $start = microtime(true);

        $detailCount = DB::table('dwd_order_detail')
            ->where('biz_date', $bizDate)
            ->count();

        $duplicateCount = DB::table('dwd_order_detail')
            ->select('order_id')
            ->where('biz_date', $bizDate)
            ->groupBy('order_id')
            ->havingRaw('COUNT(*) > 1')
            ->get()
            ->count();

        $adsMetric = DB::table('ads_daily_metrics')
            ->where('biz_date', $bizDate)
            ->first();

        if (!$adsMetric) {
            throw new RuntimeException("ads metrics missing for {$bizDate}");
        }

        $recalculated = DB::table('dwd_order_detail')
            ->where('biz_date', $bizDate)
            ->selectRaw('SUM(CASE WHEN is_paid = 1 THEN paid_amount ELSE 0 END) as paid_amount')
            ->selectRaw('SUM(CASE WHEN is_refunded = 1 THEN refund_amount ELSE 0 END) as refund_amount')
            ->first();

        if ($duplicateCount > 0) {
            throw new RuntimeException("duplicate order rows found: {$duplicateCount}");
        }

        if (abs((float) $adsMetric->paid_amount - (float) $recalculated->paid_amount) > 0.01) {
            throw new RuntimeException('paid_amount verification failed');
        }

        if ($detailCount === 0) {
            throw new RuntimeException("empty detail rows for {$bizDate}");
        }

        DB::table('etl_data_quality_reports')->insert([
            'biz_date' => $bizDate,
            'batch_id' => $batchId,
            'check_name' => 'daily_metrics_verification',
            'check_status' => 'passed',
            'check_payload' => json_encode([
                'detail_count' => $detailCount,
                'duplicate_count' => $duplicateCount,
                'paid_amount' => $recalculated->paid_amount,
                'refund_amount' => $recalculated->refund_amount,
            ], JSON_UNESCAPED_UNICODE),
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        return [
            'affected_rows' => 1,
            'duration_ms' => (int) ((microtime(true) - $start) * 1000),
        ];
    }
}

<?php

namespace App\Services\Etl;

use Illuminate\Support\Facades\DB;
use RuntimeException;

class EtlLockService
{
    public function acquire(string $lockKey, string $owner, int $ttlSeconds = 7200): void
    {
        $expiredAt = now()->addSeconds($ttlSeconds);

        try {
            DB::table('etl_job_locks')->insert([
                'lock_key' => $lockKey,
                'owner' => $owner,
                'expired_at' => $expiredAt,
                'created_at' => now(),
                'updated_at' => now(),
            ]);
        } catch (\Throwable $e) {
            $existing = DB::table('etl_job_locks')->where('lock_key', $lockKey)->first();

            if ($existing && now()->lt($existing->expired_at)) {
                throw new RuntimeException("lock already acquired: {$lockKey}");
            }

            DB::table('etl_job_locks')
                ->where('lock_key', $lockKey)
                ->update([
                    'owner' => $owner,
                    'expired_at' => $expiredAt,
                    'updated_at' => now(),
                ]);
        }
    }

    public function release(string $lockKey): void
    {
        DB::table('etl_job_locks')->where('lock_key', $lockKey)->delete();
    }
}

<?php

namespace App\Console\Commands\Etl;

use Illuminate\Console\Command;
use Illuminate\Support\Facades\DB;
use Throwable;

abstract class BaseEtlCommand extends Command
{
    abstract protected function process(string $bizDate, string $batchId): array;

    public function handle(): int
    {
        $bizDate = $this->option('biz-date');
        $batchId = $this->option('batch-id');
        $jobName = static::class;
        $startedAt = now();

        if (!$bizDate || !$batchId) {
            $this->error('biz-date and batch-id are required');
            return self::FAILURE;
        }

        DB::table('etl_job_runs')->insert([
            'dag_id' => env('ETL_DAG_ID', 'unknown'),
            'task_id' => $this->getName(),
            'job_name' => $jobName,
            'biz_date' => $bizDate,
            'batch_id' => $batchId,
            'status' => 'running',
            'attempt' => 1,
            'started_at' => $startedAt,
            'finished_at' => null,
            'duration_ms' => 0,
            'affected_rows' => 0,
            'created_at' => now(),
            'updated_at' => now(),
        ]);

        try {
            $result = $this->process($bizDate, $batchId);

            DB::table('etl_job_runs')
                ->where('task_id', $this->getName())
                ->where('biz_date', $bizDate)
                ->where('batch_id', $batchId)
                ->orderByDesc('id')
                ->limit(1)
                ->update([
                    'status' => 'success',
                    'finished_at' => now(),
                    'duration_ms' => $result['duration_ms'] ?? 0,
                    'affected_rows' => $result['affected_rows'] ?? 0,
                    'updated_at' => now(),
                ]);

            return self::SUCCESS;
        } catch (Throwable $e) {
            DB::table('etl_job_runs')
                ->where('task_id', $this->getName())
                ->where('biz_date', $bizDate)
                ->where('batch_id', $batchId)
                ->orderByDesc('id')
                ->limit(1)
                ->update([
                    'status' => 'failed',
                    'finished_at' => now(),
                    'error_message' => mb_substr($e->getMessage(), 0, 1000),
                    'updated_at' => now(),
                ]);

            $this->error($e->getMessage());
            return self::FAILURE;
        }
    }
}

public function test_paid_and_partially_refunded_order_should_be_net_valid(): void
{
    $builder = app(OrderDetailBuilder::class);

    // 准备 ODS 订单、支付、退款测试数据
    // 执行 build
    // 断言 dwd_order_detail 中 is_net_valid = 1
}

<?php
// app/MCP/Server.php

namespace App\MCP;

use App\MCP\Tools\QueryTool;
use App\MCP\Tools\DeployTool;
use App\MCP\Tools\LogTool;
use Illuminate\Http\Request;
use Illuminate\Http\JsonResponse;

class Server
{
    protected array $tools = [];
    protected array $resources = [];

    public function __construct()
    {
        $this->registerTools();
        $this->registerResources();
    }

    protected function registerTools(): void
    {
        $this->tools = [
            'query_database' => new QueryTool(),
            'deploy_service' => new DeployTool(),
            'view_logs' => new LogTool(),
        ];
    }

    protected function registerResources(): void
    {
        $this->resources = [
            'service_config' => new ConfigResource(),
        ];
    }

    /**
     * 处理 MCP 协议请求
     */
    public function handle(Request $request): JsonResponse
    {
        $method = $request->input('method');
        $params = $request->input('params', []);
        $id = $request->input('id');

        return match ($method) {
            'tools/list' => $this->listTools($id),
            'tools/call' => $this->callTool($id, $params),
            'resources/list' => $this->listResources($id),
            'resources/read' => $this->readResource($id, $params),
            'initialize' => $this->initialize($id, $params),
            default => $this->error($id, -32601, "Method not found: {$method}"),
        };
    }

    protected function initialize($id, $params): JsonResponse
    {
        return response()->json([
            'jsonrpc' => '2.0',
            'id' => $id,
            'result' => [
                'protocolVersion' => '2024-11-05',
                'serverInfo' => [
                    'name' => 'kkday-copilot-extension',
                    'version' => '1.0.0',
                ],
                'capabilities' => [
                    'tools' => new \stdClass(),
                    'resources' => [
                        'subscribe' => false,
                        'listChanged' => false,
                    ],
                ],
            ],
        ]);
    }

    protected function listTools($id): JsonResponse
    {
        $tools = array_map(fn($tool) => $tool->schema(), $this->tools);

        return response()->json([
            'jsonrpc' => '2.0',
            'id' => $id,
            'result' => ['tools' => array_values($tools)],
        ]);
    }

    protected function callTool($id, $params): JsonResponse
    {
        $name = $params['name'] ?? '';
        $arguments = $params['arguments'] ?? [];

        if (!isset($this->tools[$name])) {
            return $this->error($id, -32602, "Unknown tool: {$name}");
        }

        try {
            $result = $this->tools[$name]->execute($arguments);

            return response()->json([
                'jsonrpc' => '2.0',
                'id' => $id,
                'result' => [
                    'content' => [
                        ['type' => 'text', 'text' => $result],
                    ],
                ],
            ]);
        } catch (\Throwable $e) {
            return $this->error($id, -32000, $e->getMessage());
        }
    }

    protected function listResources($id): JsonResponse
    {
        $resources = array_map(fn($r) => $r->metadata(), $this->resources);

        return response()->json([
            'jsonrpc' => '2.0',
            'id' => $id,
            'result' => ['resources' => array_values($resources)],
        ]);
    }

    protected function readResource($id, $params): JsonResponse
    {
        $uri = $params['uri'] ?? '';

        foreach ($this->resources as $resource) {
            if ($resource->metadata()['uri'] === $uri) {
                return response()->json([
                    'jsonrpc' => '2.0',
                    'id' => $id,
                    'result' => [
                        'contents' => [
                            [
                                'uri' => $uri,
                                'mimeType' => 'application/json',
                                'text' => $resource->read(),
                            ],
                        ],
                    ],
                ]);
            }
        }

        return $this->error($id, -32602, "Unknown resource: {$uri}");
    }

    protected function error($id, $code, $message): JsonResponse
    {
        return response()->json([
            'jsonrpc' => '2.0',
            'id' => $id,
            'error' => ['code' => $code, 'message' => $message],
        ]);
    }
}

<?php
// app/MCP/Tools/QueryTool.php

namespace App\MCP\Tools;

use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class QueryTool
{
    protected array $allowedTables = [
        'orders', 'users', 'products', 'bookings',
    ];

    public function schema(): array
    {
        return [
            'name' => 'query_database',
            'description' => '查询 KKday 业务数据库，支持只读查询。可查询订单、用户、产品、预订等表。',
            'inputSchema' => [
                'type' => 'object',
                'properties' => [
                    'table' => [
                        'type' => 'string',
                        'description' => '要查询的表名',
                        'enum' => $this->allowedTables,
                    ],
                    'conditions' => [
                        'type' => 'object',
                        'description' => '查询条件，格式: {"field": "value"}',
                    ],
                    'select' => [
                        'type' => 'array',
                        'items' => ['type' => 'string'],
                        'description' => '要查询的字段，默认 *',
                    ],
                    'limit' => [
                        'type' => 'integer',
                        'description' => '返回行数，默认 10，最大 100',
                        'default' => 10,
                        'maximum' => 100,
                    ],
                ],
                'required' => ['table'],
            ],
        ];
    }

    public function execute(array $arguments): string
    {
        $table = $arguments['table'];
        $conditions = $arguments['conditions'] ?? [];
        $select = $arguments['select'] ?? ['*'];
        $limit = min($arguments['limit'] ?? 10, 100);

        // 安全校验：只允许白名单表
        if (!in_array($table, $this->allowedTables)) {
            throw new \InvalidArgumentException("Table not allowed: {$table}");
        }

        // 安全校验：只允许简单等值条件
        foreach ($conditions as $field => $value) {
            if (!is_string($value) && !is_numeric($value)) {
                throw new \InvalidArgumentException(
                    "Only simple equality conditions are supported. Got complex value for: {$field}"
                );
            }
        }

        Log::info('MCP QueryTool', [
            'table' => $table,
            'conditions' => $conditions,
            'user' => auth()->user()?->id ?? 'system',
        ]);

        $query = DB::table($table)->select($select);

        foreach ($conditions as $field => $value) {
            $query->where($field, '=', $value);
        }

        $results = $query->limit($limit)->get();

        return json_encode([
            'table' => $table,
            'count' => $results->count(),
            'rows' => $results->toArray(),
        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
    }
}