473 lines
17 KiB
PHP
473 lines
17 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Http\Controllers\Market;
|
|
|
|
use App\Enums\UserTypes;
|
|
use App\Http\Controllers\Helpers\ResponseHelper;
|
|
use App\Models\Market\PosSession;
|
|
use App\Models\Market\PosTransaction;
|
|
use App\Models\Market\Product;
|
|
use App\Models\Market\Store;
|
|
use App\Models\User;
|
|
use Hyperf\Stringable\Str;
|
|
use Hypervel\Http\Request;
|
|
use Hypervel\Support\Facades\DB;
|
|
use Hypervel\Support\Facades\Hash;
|
|
use Hypervel\Support\Facades\Response;
|
|
|
|
/**
|
|
* Performance / load-testing endpoints.
|
|
*
|
|
* These bypass session auth so a client machine can hit them with curl.
|
|
* Auth is via header `X-Perf-Token` matched against env `PERF_API_TOKEN`.
|
|
* If `PERF_API_TOKEN` is unset the endpoints are disabled (403 for all).
|
|
*
|
|
* All endpoints return timing metrics (ms) so the caller can chart how the
|
|
* box behaves under different batch sizes.
|
|
*/
|
|
class PerformanceController
|
|
{
|
|
private const DEFAULT_LIMIT = 1000;
|
|
|
|
private function authorize(Request $request)
|
|
{
|
|
$expected = (string) env('PERF_API_TOKEN', '');
|
|
if ($expected === '') {
|
|
return ResponseHelper::returnError('Performance API is disabled (PERF_API_TOKEN not set)', 403);
|
|
}
|
|
$provided = (string) ($request->header('X-Perf-Token') ?? $request->input('token', ''));
|
|
if (!hash_equals($expected, $provided)) {
|
|
return ResponseHelper::returnError('Invalid perf token', 401);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private function actingUser(): ?User
|
|
{
|
|
$hash = (string) env('PERF_ACTOR_HASH', '');
|
|
if ($hash !== '') {
|
|
$u = User::where('hashkey', $hash)->first();
|
|
if ($u) return $u;
|
|
}
|
|
return User::where('acct_type', UserTypes::ULTIMATE->value)
|
|
->orderBy('id', 'asc')
|
|
->first();
|
|
}
|
|
|
|
private function clampCount($raw): int
|
|
{
|
|
$n = (int) $raw;
|
|
if ($n < 1) $n = 1;
|
|
if ($n > self::DEFAULT_LIMIT) $n = self::DEFAULT_LIMIT;
|
|
return $n;
|
|
}
|
|
|
|
private function ms(float $start): float
|
|
{
|
|
return round((microtime(true) - $start) * 1000, 3);
|
|
}
|
|
|
|
public function ping(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
return Response::json([
|
|
'success' => true,
|
|
'ts' => now()->toIso8601String(),
|
|
'php' => PHP_VERSION,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Core user seeder, returns ['hashes' => [...], 'ms' => float].
|
|
*/
|
|
private function _seedUsers(User $actor, int $count, string $type, ?int $parentId, string $prefix): array
|
|
{
|
|
$parentId = $parentId ?? $actor->id;
|
|
$hashed = Hash::make('Perf12345!');
|
|
$start = microtime(true);
|
|
$created = [];
|
|
DB::beginTransaction();
|
|
try {
|
|
foreach (range(1, $count) as $i) {
|
|
$suffix = Str::random(10);
|
|
$u = User::create([
|
|
'username' => "{$prefix}_{$suffix}",
|
|
'name' => "Perf User {$i}",
|
|
'mobile_number' => '09' . str_pad((string) random_int(0, 999999999), 9, '0', STR_PAD_LEFT),
|
|
'password' => $hashed,
|
|
'acct_type' => $type,
|
|
'parentuid' => $parentId,
|
|
'active' => true,
|
|
]);
|
|
$created[] = $u->hashkey;
|
|
}
|
|
DB::commit();
|
|
} catch (\Throwable $e) {
|
|
DB::rollBack();
|
|
throw $e;
|
|
}
|
|
return ['hashes' => $created, 'ms' => $this->ms($start)];
|
|
}
|
|
|
|
private function _seedStores(User $actor, int $count, string $category, ?int $ownerId, string $prefix): array
|
|
{
|
|
$start = microtime(true);
|
|
$created = [];
|
|
DB::beginTransaction();
|
|
try {
|
|
foreach (range(1, $count) as $i) {
|
|
$storeCode = StoreController::generateStoreCode($category);
|
|
$s = Store::create([
|
|
'storecode' => $storeCode,
|
|
'name' => "{$prefix} " . Str::random(8),
|
|
'description' => "Synthetic store for perf testing #{$i}",
|
|
'address' => 'Perf Lane ' . random_int(1, 9999),
|
|
'category' => $category,
|
|
'subcategory' => '',
|
|
'owner_id' => $ownerId,
|
|
'created_by' => $actor->id,
|
|
'is_active' => true,
|
|
'status' => 'active',
|
|
]);
|
|
$created[] = $s->hashkey;
|
|
}
|
|
DB::commit();
|
|
} catch (\Throwable $e) {
|
|
DB::rollBack();
|
|
throw $e;
|
|
}
|
|
return ['hashes' => $created, 'ms' => $this->ms($start)];
|
|
}
|
|
|
|
private function _seedProducts(User $actor, int $count, ?Store $store, bool $attach, string $prefix): array
|
|
{
|
|
$start = microtime(true);
|
|
$created = [];
|
|
DB::beginTransaction();
|
|
try {
|
|
foreach (range(1, $count) as $i) {
|
|
$price = random_int(10, 5000);
|
|
$available = random_int(10, 500);
|
|
$p = Product::create([
|
|
'name' => "{$prefix} " . Str::random(8),
|
|
'description' => "Synthetic product for perf testing #{$i}",
|
|
'price' => $price,
|
|
'unitname' => 'pc',
|
|
'available' => $available,
|
|
'category' => 'Perf',
|
|
'subcategory' => 'Synthetic',
|
|
'created_by' => $actor->id,
|
|
'is_active' => true,
|
|
]);
|
|
if ($store && $attach) {
|
|
$store->products()->attach($p->id, [
|
|
'available' => $available,
|
|
'price' => $price,
|
|
'description' => $p->description,
|
|
'is_active' => true,
|
|
]);
|
|
}
|
|
$created[] = $p->hashkey;
|
|
}
|
|
DB::commit();
|
|
} catch (\Throwable $e) {
|
|
DB::rollBack();
|
|
throw $e;
|
|
}
|
|
return ['hashes' => $created, 'ms' => $this->ms($start)];
|
|
}
|
|
|
|
/**
|
|
* POST /api/perf/seed/users
|
|
* body: { count, type?, parent_hash?, prefix? }
|
|
*/
|
|
public function seedUsers(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
$actor = $this->actingUser();
|
|
if (!$actor) return ResponseHelper::returnError('No actor user available', 500);
|
|
|
|
$count = $this->clampCount($request->input('count', 10));
|
|
$type = (string) $request->input('type', UserTypes::USER->value);
|
|
$prefix = (string) $request->input('prefix', 'perf');
|
|
if (!UserTypes::tryFrom($type)) {
|
|
return ResponseHelper::returnError("Invalid user type '{$type}'", 422);
|
|
}
|
|
$parentId = null;
|
|
if ($p = $request->input('parent_hash')) {
|
|
$parent = User::where('hashkey', (string) $p)->first();
|
|
if ($parent) $parentId = $parent->id;
|
|
}
|
|
try {
|
|
$r = $this->_seedUsers($actor, $count, $type, $parentId, $prefix);
|
|
} catch (\Throwable $e) {
|
|
return ResponseHelper::returnError($e->getMessage());
|
|
}
|
|
return Response::json([
|
|
'success' => true,
|
|
'count' => count($r['hashes']),
|
|
'total_ms' => $r['ms'],
|
|
'avg_ms' => round($r['ms'] / max(1, count($r['hashes'])), 3),
|
|
'sample' => array_slice($r['hashes'], 0, 5),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* POST /api/perf/seed/stores
|
|
* body: { count, owner_hash?, category?, prefix? }
|
|
*/
|
|
public function seedStores(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
$actor = $this->actingUser();
|
|
if (!$actor) return ResponseHelper::returnError('No actor user available', 500);
|
|
|
|
$count = $this->clampCount($request->input('count', 10));
|
|
$category = (string) $request->input('category', 'General');
|
|
$prefix = (string) $request->input('prefix', 'PerfStore');
|
|
$ownerId = null;
|
|
if ($h = $request->input('owner_hash')) {
|
|
$owner = User::where('hashkey', (string) $h)->first();
|
|
if ($owner) $ownerId = $owner->id;
|
|
}
|
|
try {
|
|
$r = $this->_seedStores($actor, $count, $category, $ownerId, $prefix);
|
|
} catch (\Throwable $e) {
|
|
return ResponseHelper::returnError($e->getMessage());
|
|
}
|
|
return Response::json([
|
|
'success' => true,
|
|
'count' => count($r['hashes']),
|
|
'total_ms' => $r['ms'],
|
|
'avg_ms' => round($r['ms'] / max(1, count($r['hashes'])), 3),
|
|
'sample' => array_slice($r['hashes'], 0, 5),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* POST /api/perf/seed/products
|
|
* body: { count, target_store_hash?, prefix?, attach_to_store? }
|
|
*/
|
|
public function seedProducts(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
$actor = $this->actingUser();
|
|
if (!$actor) return ResponseHelper::returnError('No actor user available', 500);
|
|
|
|
$count = $this->clampCount($request->input('count', 10));
|
|
$prefix = (string) $request->input('prefix', 'PerfProduct');
|
|
$attach = (bool) $request->input('attach_to_store', true);
|
|
$store = null;
|
|
if ($h = $request->input('target_store_hash')) {
|
|
$store = Store::where('hashkey', (string) $h)->first();
|
|
if (!$store) return ResponseHelper::returnError('Target store not found', 404);
|
|
}
|
|
try {
|
|
$r = $this->_seedProducts($actor, $count, $store, $attach, $prefix);
|
|
} catch (\Throwable $e) {
|
|
return ResponseHelper::returnError($e->getMessage());
|
|
}
|
|
return Response::json([
|
|
'success' => true,
|
|
'count' => count($r['hashes']),
|
|
'total_ms' => $r['ms'],
|
|
'avg_ms' => round($r['ms'] / max(1, count($r['hashes'])), 3),
|
|
'attached_to_store' => $store?->hashkey,
|
|
'sample' => array_slice($r['hashes'], 0, 5),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* POST /api/perf/seed/batch
|
|
* body: { users?, stores?, products?, prefix?, type?, category? }
|
|
* Runs all three seeders sequentially with per-phase timings.
|
|
*/
|
|
public function seedBatch(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
$actor = $this->actingUser();
|
|
if (!$actor) return ResponseHelper::returnError('No actor user available', 500);
|
|
|
|
$prefix = (string) $request->input('prefix', 'perf');
|
|
$type = (string) $request->input('type', UserTypes::USER->value);
|
|
if (!UserTypes::tryFrom($type)) {
|
|
return ResponseHelper::returnError("Invalid user type '{$type}'", 422);
|
|
}
|
|
$category = (string) $request->input('category', 'General');
|
|
|
|
$users = max(0, (int) $request->input('users', 0));
|
|
$stores = max(0, (int) $request->input('stores', 0));
|
|
$products = max(0, (int) $request->input('products', 0));
|
|
|
|
$phases = [];
|
|
$totalStart = microtime(true);
|
|
|
|
try {
|
|
if ($users > 0) {
|
|
$r = $this->_seedUsers($actor, $this->clampCount($users), $type, null, $prefix);
|
|
$phases['users'] = ['count' => count($r['hashes']), 'ms' => $r['ms']];
|
|
}
|
|
if ($stores > 0) {
|
|
$r = $this->_seedStores($actor, $this->clampCount($stores), $category, null, $prefix . 'Store');
|
|
$phases['stores'] = ['count' => count($r['hashes']), 'ms' => $r['ms']];
|
|
}
|
|
if ($products > 0) {
|
|
$r = $this->_seedProducts($actor, $this->clampCount($products), null, false, $prefix . 'Product');
|
|
$phases['products'] = ['count' => count($r['hashes']), 'ms' => $r['ms']];
|
|
}
|
|
} catch (\Throwable $e) {
|
|
return ResponseHelper::returnError($e->getMessage());
|
|
}
|
|
|
|
return Response::json([
|
|
'success' => true,
|
|
'total_ms' => $this->ms($totalStart),
|
|
'phases' => $phases,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* POST /api/perf/pos/simulate
|
|
* body: { store_hash, items?, cycles?, complete? }
|
|
*
|
|
* Runs end-to-end POS cycles entirely server-side: open session, add N
|
|
* line items, optionally complete + archive. Returns per-phase timings.
|
|
*/
|
|
public function simulatePos(Request $request)
|
|
{
|
|
$deny = $this->authorize($request);
|
|
if ($deny) return $deny;
|
|
|
|
$actor = $this->actingUser();
|
|
if (!$actor) return ResponseHelper::returnError('No actor user available', 500);
|
|
|
|
$storeHash = (string) $request->input('store_hash', '');
|
|
if ($storeHash === '') return ResponseHelper::returnError('store_hash is required', 422);
|
|
|
|
$store = Store::where('hashkey', $storeHash)->first();
|
|
if (!$store) return ResponseHelper::returnError('Store not found', 404);
|
|
|
|
$items = max(1, min(200, (int) $request->input('items', 5)));
|
|
$cycles = max(1, min(100, (int) $request->input('cycles', 1)));
|
|
$complete = (bool) $request->input('complete', true);
|
|
|
|
// Pull a pool of products attached to this store; fall back to global
|
|
// active products if the store has none yet.
|
|
$productIds = DB::table('prd_str')
|
|
->where('store_id', $store->id)
|
|
->where('is_active', true)
|
|
->pluck('product_id')
|
|
->toArray();
|
|
|
|
if (empty($productIds)) {
|
|
$productIds = Product::where('is_active', true)
|
|
->limit(max(50, $items * 2))
|
|
->pluck('id')
|
|
->toArray();
|
|
}
|
|
|
|
if (empty($productIds)) {
|
|
return ResponseHelper::returnError('No products available to simulate sales', 422);
|
|
}
|
|
|
|
$products = Product::whereIn('id', $productIds)->get(['id', 'hashkey', 'price'])->keyBy('id');
|
|
|
|
$cycleResults = [];
|
|
$totalStart = microtime(true);
|
|
|
|
for ($c = 1; $c <= $cycles; $c++) {
|
|
$cStart = microtime(true);
|
|
|
|
// 1. Open session
|
|
$t = microtime(true);
|
|
$session = PosSession::create([
|
|
'access_key' => Str::random(32),
|
|
'store_id' => $store->id,
|
|
'customer_name' => 'Perf Customer ' . $c,
|
|
'status' => 'active',
|
|
'created_by' => $actor->id,
|
|
]);
|
|
$openMs = $this->ms($t);
|
|
|
|
// 2. Add items (raw inserts for speed, mirrors PosController::addItem)
|
|
$t = microtime(true);
|
|
$now = now();
|
|
$rows = [];
|
|
$total = 0;
|
|
for ($i = 0; $i < $items; $i++) {
|
|
$pid = $productIds[array_rand($productIds)];
|
|
$product = $products[$pid] ?? null;
|
|
if (!$product) continue;
|
|
$qty = random_int(1, 5);
|
|
$price = (int) $product->price;
|
|
$line = $price * $qty;
|
|
$total += $line;
|
|
$rows[] = [
|
|
'pos_session_id' => $session->id,
|
|
'product_id' => $pid,
|
|
'quantity' => $qty,
|
|
'price_at_sale' => $price,
|
|
'total_price' => $line,
|
|
'hashkey' => Str::uuid()->toString() . Str::random(100),
|
|
'created_at' => $now,
|
|
'updated_at' => $now,
|
|
'created_by' => $actor->id,
|
|
];
|
|
}
|
|
if (!empty($rows)) {
|
|
DB::table('pos_transactions')->insert($rows);
|
|
}
|
|
$addMs = $this->ms($t);
|
|
|
|
// 3. Optionally complete the session
|
|
$completeMs = null;
|
|
if ($complete) {
|
|
$t = microtime(true);
|
|
DB::table('pos_sessions')->where('id', $session->id)->update([
|
|
'total_amount' => $total,
|
|
'received_amount' => $total,
|
|
'change_amount' => 0,
|
|
'status' => 'completed',
|
|
'payment_method' => 'cash',
|
|
'updated_at' => $now,
|
|
'updated_by' => $actor->id,
|
|
]);
|
|
$completeMs = $this->ms($t);
|
|
}
|
|
|
|
$cycleResults[] = [
|
|
'session_hash' => $session->hashkey,
|
|
'items' => count($rows),
|
|
'total' => $total,
|
|
'open_ms' => $openMs,
|
|
'add_items_ms' => $addMs,
|
|
'complete_ms' => $completeMs,
|
|
'cycle_ms' => $this->ms($cStart),
|
|
];
|
|
}
|
|
|
|
$totalMs = $this->ms($totalStart);
|
|
$cycleMsValues = array_column($cycleResults, 'cycle_ms');
|
|
$avg = $cycleMsValues ? array_sum($cycleMsValues) / count($cycleMsValues) : 0.0;
|
|
|
|
return Response::json([
|
|
'success' => true,
|
|
'store_hash' => $store->hashkey,
|
|
'cycles' => $cycles,
|
|
'items_per_cycle' => $items,
|
|
'total_ms' => $totalMs,
|
|
'avg_cycle_ms' => round($avg, 3),
|
|
'min_cycle_ms' => $cycleMsValues ? min($cycleMsValues) : 0,
|
|
'max_cycle_ms' => $cycleMsValues ? max($cycleMsValues) : 0,
|
|
'detail' => $cycleResults,
|
|
]);
|
|
}
|
|
}
|