purpose === 'provision') { return (int) $invoice->due_at; } return max((int) $invoice->due_at, (int) $invoice->created_at) + self::PAYMENT_GRACE_SECONDS; } public static function paymentDeadlinePassed(CloudInvoice $invoice, ?int $now = null): bool { return self::paymentDeadline($invoice) <= ($now ?? time()); } public static function instanceDeleting(CloudInstance $instance): bool { return in_array((string) $instance->status, ['deleting', 'delete_failed', 'deleted'], true) || in_array((string) $instance->service_status, ['purge_stopping', 'purge_stop_failed', 'purge_deleting', 'purge_failed'], true); } /** Create the initial bill for a validated, encrypted provisioning order. */ public static function issueProvision(CloudOrder $order, Shop $plan, CloudOffer $offer, int $now): CloudInvoice { $existing = CloudInvoice::where('order_id', $order->id)->first(); if ($existing !== null) { return $existing; } if ((string) $order->status !== 'awaiting_payment' || (int) $order->plan_id !== (int) $plan->id || (int) $order->offer_id !== (int) $offer->id || (int) $offer->plan_id !== (int) $plan->id || !is_string($order->payload_cipher) || trim((string) $order->payload_cipher) === '') { throw new CloudError('开通订单状态无效', 409); } $invoice = new CloudInvoice(); $invoice->invoice_no = self::invoiceNumber(); $invoice->purpose = 'provision'; $invoice->instance_id = null; $invoice->order_id = $order->id; $invoice->user_id = $order->user_id; $invoice->plan_id = $order->plan_id; $invoice->offer_id = $order->offer_id; $invoice->renewal_id = null; $invoice->renews_expires_at = null; $invoice->due_at = $now + CloudOrderService::PAYMENT_WINDOW_SECONDS; $invoice->amount = $order->amount; $invoice->currency = 'USD'; $invoice->validity_days = (int) $plan->validity_days; $invoice->traffic_quota_bytes = max(0, (int) $plan->traffic_quota_bytes); $invoice->status = 'open'; $invoice->paid_via = null; $invoice->payment_reference = null; $invoice->paid_at = null; $invoice->created_at = $invoice->updated_at = $now; $invoice->save(); return $invoice; } /** Expire abandoned initial bills and return their finite stock safely. */ public static function expireProvision(int $limit = 200): int { $now = time(); $ids = CloudInvoice::where('purpose', 'provision') ->whereIn('status', ['open', 'overdue']) ->where('due_at', '<=', $now)->orderBy('id') ->limit(max(1, min(1000, $limit)))->pluck('id')->all(); $expired = 0; foreach ($ids as $id) { $expired += (new User())->getConnection()->transaction(function () use ($id, $now) { $ownerId = CloudInvoice::where('id', $id)->value('user_id'); if ($ownerId === null) { return 0; } // Match payment settlement's user -> invoice -> order -> plan // lock order so expiry and a callback cannot both win. User::where('id', (int) $ownerId)->lockForUpdate()->first(); $invoice = CloudInvoice::where('id', $id)->lockForUpdate()->first(); if ($invoice === null || (string) $invoice->purpose !== 'provision' || !in_array((string) $invoice->status, ['open', 'overdue'], true) || (int) $invoice->due_at > $now) { return 0; } $order = CloudOrder::where('id', $invoice->order_id) ->lockForUpdate()->first(); if ($order !== null && (string) $order->status === 'awaiting_payment') { CloudOrderService::releaseStock($order); $order->status = 'expired'; $order->payload_cipher = null; $order->updated_at = $now; $order->save(); } $invoice->status = 'expired'; $invoice->updated_at = $now; $invoice->save(); return 1; }, 3); } return $expired; } public static function issueDue(int $limit = 200): int { self::$observedErrors['issue_due'] = []; $now = time(); $ids = CloudInstance::where('status', '<>', 'deleted') ->whereNotIn('status', ['deleting', 'delete_failed']) ->where('service_status', '<>', 'exempt') ->whereNotIn('service_status', ['purge_stopping', 'purge_stop_failed', 'purge_deleting', 'purge_failed']) ->whereNotNull('expires_at') ->whereNotNull('renewal_price') ->where('renewal_days', '>', 0) ->where('expires_at', '<=', $now + self::REMINDER_SECONDS) ->whereNotExists(function ($query) { $query->selectRaw('1')->from('cloud_invoices') ->whereColumn('cloud_invoices.instance_id', 'cloud_instances.id') ->whereColumn('cloud_invoices.renews_expires_at', 'cloud_instances.expires_at') ->where('cloud_invoices.status', '<>', 'void'); }) ->orderBy('expires_at')->orderBy('id') ->limit(max(1, min(1000, $limit))) ->pluck('id')->all(); $created = 0; foreach ($ids as $id) { try { $created += self::issueOne((int) $id, $now) ? 1 : 0; } catch (\Throwable $error) { self::$observedErrors['issue_due']['invoice_generation_failed'] = true; error_log('cloud invoice generation failed for instance ' . (int) $id . ': ' . get_class($error)); } } return $created; } private static function issueOne(int $instanceId, int $now): bool { return (new CloudInstance())->getConnection()->transaction(function () use ($instanceId, $now) { $instance = CloudInstance::where('id', $instanceId)->lockForUpdate()->first(); if ($instance === null || (string) $instance->status === 'deleted' || self::instanceDeleting($instance) || (string) $instance->service_status === 'exempt' || $instance->expires_at === null || $instance->renewal_price === null || (int) $instance->renewal_days < 1 || (int) $instance->expires_at > $now + self::REMINDER_SECONDS) { return false; } $expiry = (int) $instance->expires_at; if (CloudInvoice::where('instance_id', $instance->id) ->where('renews_expires_at', $expiry) ->where('status', '<>', 'void')->exists()) { return false; } $amount = CloudMoney::decimal(CloudMoney::cents((string) $instance->renewal_price)); $invoice = new CloudInvoice(); $invoice->invoice_no = self::invoiceNumber(); $invoice->purpose = 'renewal'; $invoice->instance_id = $instance->id; $invoice->order_id = null; $invoice->user_id = $instance->user_id; $invoice->plan_id = $instance->plan_id; $invoice->renewal_id = null; $invoice->renews_expires_at = $expiry; $invoice->due_at = $expiry; $invoice->amount = $amount; $invoice->validity_days = (int) $instance->renewal_days; $invoice->traffic_quota_bytes = max(0, (int) $instance->renewal_traffic_bytes); $invoice->status = 'open'; $invoice->paid_via = null; $invoice->payment_reference = null; $invoice->paid_at = null; $invoice->created_at = $invoice->updated_at = $now; $invoice->save(); self::enqueueMail($invoice, 'renewal_due', $now); return true; }, 3); } /** Queue one idempotent notification after a paid instance is available. */ public static function queueProvisionSucceeded(CloudInvoice $invoice, int $now): bool { if ((string) $invoice->purpose !== 'provision' || (string) $invoice->status !== 'paid' || $invoice->instance_id === null) { return false; } return self::enqueueMail($invoice, 'provision_succeeded', $now); } private static function enqueueMail(CloudInvoice $invoice, string $kind, int $now): bool { if (!in_array($kind, ['renewal_due', 'provision_succeeded'], true)) { throw new \InvalidArgumentException('Unsupported cloud mail kind'); } if (CloudMailOutbox::where('invoice_id', $invoice->id) ->where('kind', $kind)->exists()) { return false; } // Do not use mass assignment here. Models intentionally keep // Illuminate's guarded defaults, and both callers already hold the // authoritative invoice/instance transaction locks. The database // unique key on (invoice_id, kind) is the final concurrency guard. $mail = new CloudMailOutbox(); $mail->invoice_id = $invoice->id; $mail->kind = $kind; $mail->status = 'pending'; $mail->attempts = 0; $mail->available_at = $now; $mail->lease_token = null; $mail->lease_until = 0; $mail->sent_at = null; $mail->last_error = ''; $mail->created_at = $mail->updated_at = $now; $mail->save(); return true; } public static function deliverReminders(int $limit = 20): int { self::$observedErrors['notifications'] = []; $sent = 0; for ($index = 0; $index < max(1, min(100, $limit)); $index++) { $claimed = self::claimMail(); if ($claimed === null) { break; } [$message, $token] = $claimed; $invoice = CloudInvoice::find($message->invoice_id); $user = $invoice === null ? null : User::find($invoice->user_id); $instance = $invoice === null ? null : CloudInstance::find($invoice->instance_id); $kind = (string) $message->kind; $order = $kind !== 'provision_succeeded' || $invoice === null || $invoice->order_id === null ? null : CloudOrder::where('id', $invoice->order_id) ->where('user_id', $invoice->user_id) ->where('instance_id', $invoice->instance_id)->first(); $job = $order === null ? null : CloudJob::where('order_id', $order->id) ->where('user_id', $invoice->user_id) ->where('instance_id', $invoice->instance_id)->first(); $ok = false; $error = ''; $cancel = false; if ($invoice === null || $user === null || $instance === null || (int) $instance->user_id !== (int) $invoice->user_id || self::instanceDeleting($instance)) { $error = '账单或收件人已不可用'; $cancel = true; } elseif ($kind === 'renewal_due' && ((string) $invoice->purpose !== 'renewal' || !in_array((string) $invoice->status, ['open', 'overdue'], true) || self::paymentDeadlinePassed($invoice))) { $error = '续费账单已不可用'; $cancel = true; } elseif ($kind === 'provision_succeeded' && ((string) $invoice->purpose !== 'provision' || (string) $invoice->status !== 'paid' || (string) $instance->status !== 'active' || $order === null || (string) $order->status !== 'succeeded' || $job === null || (string) $job->status !== 'succeeded')) { $error = '实例开通通知已不可用'; $cancel = true; } elseif (!in_array($kind, ['renewal_due', 'provision_succeeded'], true)) { $error = '邮件通知类型无效'; $cancel = true; } elseif (filter_var((string) $user->email, FILTER_VALIDATE_EMAIL) === false) { $error = '用户邮箱无效'; } else { $base = rtrim((string) Config::get('baseUrl', ''), '/'); $appName = trim((string) Config::get('appName', '')); if ($kind === 'renewal_due') { $ok = Mail::send((string) $user->email, ($appName !== '' ? $appName . ' - ' : '') . '实例续费账单已生成', 'cloud/invoice.tpl', [ 'invoice_id' => (string) $invoice->id, 'instance_name' => (string) $instance->name, 'amount' => (string) $invoice->amount, 'due_at' => date('Y-m-d H:i:s', (int) $invoice->due_at), 'invoice_url' => $base . '/user/cloud/invoices/' . (int) $invoice->id, ], [], 'cloud_renewal_invoice'); } else { $spec = json_decode((string) $instance->spec_json, true); $spec = is_array($spec) && !array_is_list($spec) ? $spec : []; $cidr = is_string($spec['public_ip_cidr'] ?? null) ? trim($spec['public_ip_cidr']) : ''; $ip = explode('/', $cidr, 2)[0]; if (filter_var($ip, FILTER_VALIDATE_IP) === false) { $ip = '—'; } $region = trim((string) ($spec['region'] ?? '')); $osName = trim((string) ($spec['os_name'] ?? $spec['template_id'] ?? '')); $loginName = trim((string) ($spec['login_name'] ?? '')); $ok = Mail::send((string) $user->email, ($appName !== '' ? $appName . ' - ' : '') . '实例开通成功', 'cloud/provision-success.tpl', [ 'instance_name' => (string) $instance->name, 'instance_id' => (string) $instance->id, 'region' => $region !== '' ? $region : '—', 'public_ip' => $ip, 'os_name' => $osName !== '' ? $osName : '云镜像系统', 'login_name' => preg_match( '/^[A-Za-z_][A-Za-z0-9_.-]{0,31}$/D', $loginName ) === 1 ? $loginName : 'root', 'created_at' => date('Y-m-d H:i:s', (int) $instance->created_at), 'expires_at' => $instance->expires_at === null ? '未设置' : date('Y-m-d H:i:s', (int) $instance->expires_at), 'instance_url' => $base . '/user/cloud/instances/' . (int) $instance->id, ], [], 'cloud_provision_success'); } if (!$ok) { $error = '邮件服务未接受消息'; } } if (!$ok && !$cancel) { self::$observedErrors['notifications']['notification_failed'] = true; } self::finishMail((int) $message->id, $token, $ok, $error, $cancel); $sent += $ok ? 1 : 0; } return $sent; } private static function claimMail(): ?array { return (new CloudMailOutbox())->getConnection()->transaction(function () { $now = time(); $message = CloudMailOutbox::where(function ($query) use ($now) { $query->where('status', 'pending') ->orWhere(function ($leased) use ($now) { $leased->where('status', 'sending')->where('lease_until', '<=', $now); }); })->where('available_at', '<=', $now) ->orderBy('id')->lockForUpdate()->first(); if ($message === null) { return null; } $token = bin2hex(random_bytes(16)); $message->status = 'sending'; $message->lease_token = $token; $message->lease_until = $now + 300; $message->updated_at = $now; $message->save(); return [$message, $token]; }, 3); } private static function finishMail(int $id, string $token, bool $ok, string $error, bool $cancel = false): void { (new CloudMailOutbox())->getConnection()->transaction(function () use ( $id, $token, $ok, $error, $cancel ) { $message = CloudMailOutbox::where('id', $id)->where('lease_token', $token) ->lockForUpdate()->first(); if ($message === null) { return; } $now = time(); $message->attempts = (int) $message->attempts + 1; $message->lease_token = null; $message->lease_until = 0; $message->updated_at = $now; if ($ok) { $message->status = 'sent'; $message->sent_at = $now; $message->last_error = ''; } elseif ($cancel) { $message->status = 'cancelled'; $message->last_error = mb_substr($error, 0, 500); } else { $message->status = 'pending'; $message->available_at = $now + min(21600, 60 * (1 << min(8, (int) $message->attempts - 1))); $message->last_error = mb_substr($error, 0, 500); } $message->save(); }, 3); } /** * Build the compact rows used by the paginated invoice list without * loading the order, instance and job once for every invoice. * * @param iterable $invoices * @return array> */ public static function listSummaries(iterable $invoices): array { $records = []; $orderIds = []; $renewalInstanceIds = []; $ownerIds = []; foreach ($invoices as $invoice) { if (!$invoice instanceof CloudInvoice) { continue; } $records[] = $invoice; $ownerIds[(int) $invoice->user_id] = (int) $invoice->user_id; $purpose = (string) ($invoice->purpose ?: 'renewal'); if ($purpose === 'provision' && $invoice->order_id !== null) { $orderIds[(int) $invoice->order_id] = (int) $invoice->order_id; } elseif ($purpose === 'renewal' && $invoice->instance_id !== null) { $renewalInstanceIds[(int) $invoice->instance_id] = (int) $invoice->instance_id; } } if ($records === []) { return []; } $orders = []; if ($orderIds !== []) { foreach (CloudOrder::whereIn('id', array_values($orderIds)) ->whereIn('user_id', array_values($ownerIds)) ->get(['id', 'user_id', 'status']) as $order) { $orders[self::listKey((int) $order->user_id, (int) $order->id)] = $order; } } $instances = []; if ($renewalInstanceIds !== []) { foreach (CloudInstance::whereIn('id', array_values($renewalInstanceIds)) ->whereIn('user_id', array_values($ownerIds)) ->get(['id', 'user_id', 'status']) as $instance) { $instances[self::listKey((int) $instance->user_id, (int) $instance->id)] = $instance; } } $jobs = []; if ($orderIds !== []) { foreach (CloudJob::whereIn('order_id', array_values($orderIds)) ->whereIn('user_id', array_values($ownerIds)) ->get(['id', 'order_id', 'user_id', 'status']) as $job) { $jobs[self::listKey((int) $job->user_id, (int) $job->order_id)] = $job; } } $now = time(); $summaries = []; foreach ($records as $invoice) { $ownerId = (int) $invoice->user_id; $purpose = (string) ($invoice->purpose ?: 'renewal'); $title = match ($purpose) { 'recharge' => '余额充值', 'provision' => '实例开通', 'renewal' => '实例续费', default => '账单', }; $order = $purpose === 'provision' && $invoice->order_id !== null ? ($orders[self::listKey($ownerId, (int) $invoice->order_id)] ?? null) : null; $job = $order === null ? null : ($jobs[self::listKey($ownerId, (int) $order->id)] ?? null); $instance = $purpose === 'renewal' && $invoice->instance_id !== null ? ($instances[self::listKey($ownerId, (int) $invoice->instance_id)] ?? null) : null; $status = self::publicStatus($invoice, $purpose, $instance, $now); $summaries[] = [ 'id' => (string) $invoice->id, 'title' => $title, 'type_label' => $title, 'purpose' => $purpose, 'amount' => (string) $invoice->amount, 'status' => $status, 'created_at' => (int) $invoice->created_at, 'order_status' => $order?->status, 'fulfillment_status' => $job?->status ?? $order?->status, 'job_status' => $job?->status, ]; } return $summaries; } private static function listKey(int $userId, int $recordId): string { return $userId . ':' . $recordId; } /** Derive the user-visible status shared by list, detail and polling. */ private static function publicStatus(CloudInvoice $invoice, string $purpose, $instance, int $now): string { $status = (string) $invoice->status; if ($purpose === 'renewal' && ($instance === null || (string) $instance->status === 'deleted')) { if (in_array($status, ['open', 'overdue'], true)) { return 'void'; } } elseif ($status === 'open' && (int) $invoice->due_at <= $now) { return 'overdue'; } return $status; } /** * Derive the public invoice state once for both full detail responses and * lightweight polling responses. The callers deliberately load different * columns, but payment eligibility must never drift between them. * * @return array{status: string, deadline: int, payable: bool} */ private static function publicState(CloudInvoice $invoice, string $purpose, $order, $instance, int $now): array { $status = self::publicStatus($invoice, $purpose, $instance, $now); $deadline = self::paymentDeadline($invoice); if ($purpose === 'provision') { $payable = in_array($status, ['open', 'overdue'], true) && $order !== null && (string) $order->status === 'awaiting_payment' && $deadline > $now; } else { $payable = in_array($status, ['open', 'overdue'], true) && $instance !== null && !self::instanceDeleting($instance) && $deadline > $now; } return ['status' => $status, 'deadline' => $deadline, 'payable' => $payable]; } /** * Return only the mutable fields needed while a browser waits for an * invoice payment or a provisioning job. This deliberately avoids plan * snapshots, payment-method discovery and the other detail-only work in * display(). */ public static function status(CloudInvoice $invoice): array { $now = time(); $purpose = (string) ($invoice->purpose ?: 'renewal'); $order = null; $instance = null; $job = null; if ($purpose === 'provision' && $invoice->order_id !== null) { $order = CloudOrder::where('id', $invoice->order_id) ->where('user_id', $invoice->user_id) ->first(['id', 'user_id', 'status', 'instance_id']); if ($order !== null) { $job = CloudJob::where('order_id', $order->id) ->where('user_id', $invoice->user_id) ->first(['id', 'order_id', 'user_id', 'kind', 'status', 'attempts', 'updated_at', 'error_code', 'result_json']); } } elseif ($purpose === 'renewal' && $invoice->instance_id !== null) { $instance = CloudInstance::where('id', $invoice->instance_id) ->where('user_id', $invoice->user_id) ->first(['id', 'user_id', 'status', 'service_status']); } $publicState = self::publicState($invoice, $purpose, $order, $instance, $now); $status = $publicState['status']; $deadline = $publicState['deadline']; $payable = $publicState['payable']; $decodedJobResult = $job === null || $job->result_json === null ? null : json_decode((string) $job->result_json, true); $safeJobResult = is_array($decodedJobResult) ? CloudOperationErrorCatalog::result($decodedJobResult, false, (string) ($job?->kind ?? 'create'), (string) ($job?->status ?? $order?->status), true) : null; $jobPhase = CloudOperationErrorCatalog::userPhase( $safeJobResult['phase'] ?? null, (string) ($job?->status ?? $order?->status), (string) ($job?->kind ?? 'create') ); $linkedInstanceId = $purpose === 'provision' ? ($order?->instance_id ?? $invoice->instance_id) : $invoice->instance_id; $linkedInstance = $purpose === 'renewal' ? $instance : ($linkedInstanceId === null ? null : CloudInstance::where('id', $linkedInstanceId) ->where('user_id', $invoice->user_id) ->first(['id', 'user_id'])); $instanceId = $linkedInstance?->id; // A job status originates from the engine/worker lifecycle. Keep the // user DTO on the reviewed status vocabulary instead of reflecting a // future host-controlled value into the browser. $jobStatus = $job === null ? null : (CloudOperationErrorCatalog::userStatus($job->status) ?? 'unknown'); $fulfillmentStatus = $jobStatus ?? $order?->status; $jobError = $job === null ? null : CloudOperationErrorCatalog::userMessage( (string) ($job->kind ?? 'create'), (string) $job->status, $job->error_code, true ); return [ 'id' => (string) $invoice->id, 'purpose' => $purpose, 'status' => $status, 'payable' => $payable, 'paid_at' => $invoice->paid_at === null ? null : (int) $invoice->paid_at, 'paid_via' => $invoice->paid_via, 'payment_deadline_at' => $deadline, 'deletion_at' => $purpose === 'renewal' ? $deadline : null, 'instance_id' => $instanceId === null ? null : (string) $instanceId, 'order_status' => $order?->status, 'fulfillment_status' => $fulfillmentStatus, 'job_id' => $job === null ? null : (string) $job->id, 'job_status' => $jobStatus, 'job_attempts' => $job === null ? 0 : max(0, (int) $job->attempts), 'job_updated_at' => $job === null ? null : max(0, (int) $job->updated_at), 'phase' => $jobPhase, 'error' => $jobError, 'fulfillment' => $purpose === 'provision' ? [ 'order_id' => $order === null ? null : (string) $order->id, 'order_status' => $order?->status, 'job_id' => $job === null ? null : (string) $job->id, 'job_status' => $jobStatus, 'attempts' => $job === null ? 0 : max(0, (int) $job->attempts), 'updated_at' => $job === null ? null : max(0, (int) $job->updated_at), 'instance_id' => $instanceId === null ? null : (string) $instanceId, 'phase' => $jobPhase, 'error' => $jobError, ] : null, ]; } public static function display(CloudInvoice $invoice): array { $now = time(); $purpose = (string) ($invoice->purpose ?: 'renewal'); $title = match ($purpose) { 'recharge' => '余额充值', 'provision' => '实例开通', 'renewal' => '实例续费', default => '账单', }; $order = $purpose !== 'provision' || $invoice->order_id === null ? null : CloudOrder::where('id', $invoice->order_id) ->where('user_id', $invoice->user_id) ->first(['id', 'user_id', 'instance_id', 'status', 'spec_json']); $linkedInstanceId = $purpose === 'provision' ? ($order?->instance_id ?? $invoice->instance_id) : $invoice->instance_id; $instance = $linkedInstanceId === null ? null : CloudInstance::where('id', $linkedInstanceId) ->where('user_id', $invoice->user_id) ->first(['id', 'user_id', 'name', 'status', 'service_status', 'spec_json']); $job = $order === null ? null : CloudJob::where('order_id', $order->id) ->where('user_id', $invoice->user_id) ->first(['id', 'order_id', 'user_id', 'kind', 'status', 'attempts', 'updated_at', 'error_code']); // Successful workers persist both links. Keep the invoice-side link // as a defensive fallback for an interrupted upgrade or a repaired // order row so the unified bill can still open the created instance. $provisionInstanceId = $instance?->id; $decodedOrderSpec = $order === null ? null : json_decode((string) $order->spec_json, true); $decodedInstanceSpec = $instance === null ? null : json_decode((string) $instance->spec_json, true); $orderSpec = is_array($decodedOrderSpec) ? $decodedOrderSpec : []; $instanceSpec = is_array($decodedInstanceSpec) ? $decodedInstanceSpec : []; $spec = $orderSpec !== [] ? $orderSpec : $instanceSpec; $planName = trim((string) ($orderSpec['plan_name'] ?? $instanceSpec['plan_name'] ?? '')); $cpuCores = (int) ($spec['cpu_cores'] ?? $spec['vcpu'] ?? 0); $memoryMiB = (int) ($spec['memory_mib'] ?? 0); $diskGiB = (int) ($spec['disk_gib'] ?? 0); $bandwidthMbps = (int) ($spec['bandwidth_mbps'] ?? 0); $cpuCores = $cpuCores > 0 ? $cpuCores : null; $memoryMiB = $memoryMiB > 0 ? $memoryMiB : null; $diskGiB = $diskGiB > 0 ? $diskGiB : null; $bandwidthMbps = $bandwidthMbps > 0 ? $bandwidthMbps : null; $publicState = self::publicState($invoice, $purpose, $order, $instance, $now); $status = $publicState['status']; $deadline = $publicState['deadline']; $payable = $publicState['payable']; $jobError = $job === null ? null : CloudOperationErrorCatalog::userMessage( (string) ($job->kind ?? 'create'), (string) $job->status, $job->error_code, true ); $jobStatus = $job === null ? null : (CloudOperationErrorCatalog::userStatus($job->status) ?? 'unknown'); return [ 'id' => (string) $invoice->id, 'title' => $title, 'type_label' => $title, 'purpose' => $purpose, 'instance_id' => $instance === null ? null : (string) $instance->id, 'instance_name' => $purpose === 'provision' ? (string) ($spec['name'] ?? '待开通实例') : ($instance?->name ?? '已删除实例'), 'requested_name' => $purpose === 'provision' ? (string) ($spec['name'] ?? '') : null, 'plan_name' => $planName, 'cpu_cores' => $cpuCores, 'memory_mib' => $memoryMiB, 'disk_gib' => $diskGiB, 'bandwidth_mbps' => $bandwidthMbps, 'specification' => [ 'cpu_cores' => $cpuCores, 'memory_mib' => $memoryMiB, 'disk_gib' => $diskGiB, 'bandwidth_mbps' => $bandwidthMbps, ], 'order_id' => $order === null ? null : (string) $order->id, 'order_status' => $order?->status, 'fulfillment_status' => $jobStatus ?? $order?->status, 'job_id' => $job === null ? null : (string) $job->id, 'job_status' => $jobStatus, 'job_attempts' => $job === null ? 0 : max(0, (int) $job->attempts), 'job_updated_at' => $job === null ? null : max(0, (int) $job->updated_at), 'error' => $jobError, 'fulfillment' => $purpose === 'provision' ? [ 'order_id' => $order === null ? null : (string) $order->id, 'order_status' => $order?->status, 'job_id' => $job === null ? null : (string) $job->id, 'job_status' => $jobStatus, 'attempts' => $job === null ? 0 : max(0, (int) $job->attempts), 'updated_at' => $job === null ? null : max(0, (int) $job->updated_at), 'instance_id' => $provisionInstanceId === null ? null : (string) $provisionInstanceId, 'error' => $jobError, ] : null, 'amount' => (string) $invoice->amount, 'validity_days' => (int) $invoice->validity_days, 'service_days' => (int) $invoice->validity_days, 'traffic_quota_bytes' => (int) $invoice->traffic_quota_bytes, 'status' => $status, 'due_at' => (int) $invoice->due_at, 'renews_expires_at' => $invoice->renews_expires_at === null ? null : (int) $invoice->renews_expires_at, 'payment_deadline_at' => $deadline, 'deletion_at' => $purpose === 'renewal' ? $deadline : null, 'payable' => $payable, 'paid_at' => $invoice->paid_at === null ? null : (int) $invoice->paid_at, 'paid_via' => $invoice->paid_via, 'created_at' => (int) $invoice->created_at, ]; } public static function payBalance(CloudInvoice $invoice, array $actor, string $idempotency): CloudInvoice { if ((int) $invoice->user_id !== (int) $actor['user_id']) { throw new CloudError('只能支付自己的账单', 403); } $result = self::settle($invoice, $actor, $idempotency, 'balance', ''); if ($result['outcome'] === 'stale') { throw new CloudError('账单已失效,请刷新账单列表', 409); } return $result['invoice']; } /** * Settle an invoice after a provider callback has already credited the * exact payment to the wallet in the same outer database transaction. * Expected business conflicts keep that money in the wallet. */ public static function settleCreditedPayment(CloudInvoicePayment $payment): string { $invoice = CloudInvoice::where('id', $payment->invoice_id)->first(); $amountMatches = false; if ($invoice !== null) { try { $amountMatches = CloudMoney::cents((string) $payment->amount) === CloudMoney::cents((string) $invoice->amount); } catch (\Throwable $error) { $amountMatches = false; } } if ($invoice === null || (int) $invoice->user_id !== (int) $payment->user_id || !$amountMatches) { $payment->status = 'credited_balance'; $payment->updated_at = time(); $payment->save(); return 'credited_balance'; } $actor = ['user_id' => (int) $payment->user_id, 'is_admin' => false, 'is_super_admin' => false, 'can_manage' => false, 'session_id' => '']; try { $result = self::settle($invoice, $actor, 'invoice-payment-' . (int) $payment->id, (string) $payment->provider, (string) $payment->provider_order_no); $payment->status = $result['outcome'] === 'paid' ? 'paid_invoice' : 'credited_balance'; } catch (CloudError $error) { $payment->status = 'credited_balance'; } $payment->updated_at = time(); $payment->save(); return (string) $payment->status; } private static function settle(CloudInvoice $source, array $actor, string $idempotency, string $paidVia, string $reference): array { if (preg_match('/^[A-Za-z0-9_.-]{16,128}$/D', $idempotency) !== 1) { throw new CloudError('支付请求标识无效'); } return (new User())->getConnection()->transaction(function () use ( $source, $actor, $idempotency, $paidVia, $reference ) { $user = User::where('id', (int) $actor['user_id'])->lockForUpdate()->first(); if ($user === null || (int) $user->enable !== 1) { throw new CloudError('账户不存在或不可用', 403); } if ((int) $user->restrict_balance_purchase === 1) { throw new CloudError('账户套餐购买服务已被管理员停用', 403); } $sourcePurpose = (string) ($source->purpose ?: 'renewal'); $instance = null; if ($sourcePurpose !== 'provision') { // Keep the established lifecycle lock order for renewals: // user -> instance -> invoice. $instance = CloudInstance::where('id', (int) $source->instance_id) ->lockForUpdate()->first(); } $invoice = CloudInvoice::where('id', $source->id)->lockForUpdate()->first(); if ($invoice === null || (int) $invoice->user_id !== (int) $user->id) { throw new CloudError('账单不存在', 404); } if ((string) $invoice->status === 'paid') { return ['outcome' => 'already_paid', 'invoice' => $invoice]; } $purpose = (string) ($invoice->purpose ?: 'renewal'); if ($purpose !== $sourcePurpose) { throw new CloudError('账单类型已变更,请刷新后重试', 409); } if ($purpose === 'provision') { $order = CloudOrder::where('id', $invoice->order_id) ->where('user_id', $user->id)->lockForUpdate()->first(); if ($order === null || in_array((string) $invoice->status, ['expired', 'void'], true) || self::paymentDeadlinePassed($invoice) || (string) $order->status !== 'awaiting_payment') { if ($order !== null && (string) $order->status === 'awaiting_payment') { CloudOrderService::releaseStock($order); $order->status = 'expired'; $order->payload_cipher = null; $order->updated_at = time(); $order->save(); } if (in_array((string) $invoice->status, ['open', 'overdue'], true)) { $invoice->status = 'expired'; $invoice->updated_at = time(); $invoice->save(); } return ['outcome' => 'stale', 'invoice' => $invoice]; } if ((int) $order->plan_id !== (int) $invoice->plan_id || (int) $order->offer_id !== (int) $invoice->offer_id || strtoupper((string) $order->currency) !== 'USD' || strtoupper((string) $invoice->currency) !== 'USD' || CloudMoney::cents((string) $order->amount) !== CloudMoney::cents((string) $invoice->amount)) { CloudOrderService::releaseStock($order); $order->status = 'expired'; $order->payload_cipher = null; $order->updated_at = time(); $order->save(); $invoice->status = 'void'; $invoice->updated_at = time(); $invoice->save(); return ['outcome' => 'stale', 'invoice' => $invoice]; } $price = CloudMoney::cents((string) $invoice->amount); $balance = CloudMoney::cents((string) $user->money); if ($balance < $price) { throw new CloudError('账户余额不足', 409); } CloudOrderService::queuePaidProvision($invoice, $order); $user->money = CloudMoney::decimal($balance - $price); $user->save(); $invoice->status = 'paid'; $invoice->paid_via = mb_substr($paidVia, 0, 32); $invoice->payment_reference = $reference === '' ? null : mb_substr($reference, 0, 80); $invoice->paid_at = time(); $invoice->updated_at = time(); $invoice->save(); return ['outcome' => 'paid', 'invoice' => $invoice, 'order' => $order->fresh() ?? $order]; } if (($instance !== null && self::instanceDeleting($instance)) || in_array((string) $invoice->status, ['expired'], true) || (in_array((string) $invoice->status, ['open', 'overdue'], true) && self::paymentDeadlinePassed($invoice))) { if (in_array((string) $invoice->status, ['open', 'overdue'], true)) { $invoice->status = 'expired'; $invoice->updated_at = time(); $invoice->save(); } return ['outcome' => 'stale', 'invoice' => $invoice]; } if ($instance === null || (string) $instance->status === 'deleted' || !in_array((string) $invoice->status, ['open', 'overdue'], true) || (int) $instance->user_id !== (int) $user->id || $instance->expires_at === null || (int) $instance->expires_at !== (int) $invoice->renews_expires_at || CloudMoney::cents((string) $instance->renewal_price) !== CloudMoney::cents((string) $invoice->amount) || (int) $instance->renewal_days !== (int) $invoice->validity_days || (int) $instance->renewal_traffic_bytes !== (int) $invoice->traffic_quota_bytes) { $invoice->status = 'void'; $invoice->updated_at = time(); $invoice->save(); return ['outcome' => 'stale', 'invoice' => $invoice]; } // Scope the renewal key to this bill. A client key reused in a // later billing period must never resolve to an older renewal. $renewal = CloudRenewalService::renew($instance, [ 'idempotency_key' => 'invoice-' . (int) $invoice->id . '-' . hash('sha256', $idempotency), ], $actor); $invoice->status = 'paid'; $invoice->renewal_id = $renewal->id; $invoice->paid_via = mb_substr($paidVia, 0, 32); $invoice->payment_reference = $reference === '' ? null : mb_substr($reference, 0, 80); $invoice->paid_at = time(); $invoice->updated_at = time(); $invoice->save(); return ['outcome' => 'paid', 'invoice' => $invoice, 'renewal' => $renewal]; }, 3); } private static function invoiceNumber(): string { return 'VC' . gmdate('YmdHis') . strtoupper(bin2hex(random_bytes(8))); } }