775 lines
29 KiB
PHP
775 lines
29 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace App\Http\Controllers\Market;
|
|
|
|
use App\Http\Controllers\Helpers\ResponseHelper;
|
|
use App\Models\Market\PosSession;
|
|
use App\Models\Market\PosTransaction;
|
|
use App\Models\Market\PosSessionArchive;
|
|
use App\Models\Market\Product;
|
|
use App\Models\Market\Store;
|
|
use Hypervel\Http\Request;
|
|
use Hypervel\Support\Facades\Auth;
|
|
use Hypervel\Support\Facades\Response;
|
|
use Hyperf\Stringable\Str;
|
|
use App\Models\Market\PosAccessKey;
|
|
use App\Models\Market\Customer;
|
|
use Hypervel\Support\Facades\DB;
|
|
use App\Http\Controllers\Helpers\Permissions\UserPermissions;
|
|
use App\Enums\UserActions;
|
|
use Hyperf\Coroutine\Coroutine;
|
|
use App\Http\Controllers\Helpers\CacheHelper;
|
|
|
|
class PosController
|
|
{
|
|
public function startSession(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'store_hash' => 'nullable|string',
|
|
'customer_name' => 'nullable|string|max:255',
|
|
'access_key' => 'nullable|string',
|
|
]);
|
|
|
|
$store = null;
|
|
$accessKeyObj = null;
|
|
|
|
if ($request->input('access_key')) {
|
|
$accessKeyObj = PosAccessKey::where('access_key', $request->input('access_key'))
|
|
->where('status', 'active')
|
|
->first();
|
|
|
|
if ($accessKeyObj) {
|
|
|
|
if ($accessKeyObj->isExpired()) {
|
|
$accessKeyObj->status = 'inactive';
|
|
$accessKeyObj->save();
|
|
return ResponseHelper::returnError('Access key has expired', 401);
|
|
}
|
|
|
|
$store = $accessKeyObj->store;
|
|
} elseif (!Auth::check()) {
|
|
|
|
return ResponseHelper::returnError('Invalid or inactive access key', 401);
|
|
}
|
|
}
|
|
|
|
if (!$store && !empty($validated['store_hash'])) {
|
|
$store = Store::where('hashkey', $validated['store_hash'])->first();
|
|
}
|
|
|
|
if (!$store) {
|
|
return ResponseHelper::returnError('No store found. Please open the POS from a store page or use a valid access key.', 422);
|
|
}
|
|
|
|
// Authorization check
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $store)) {
|
|
return ResponseHelper::returnError('You are not authorized to start a POS session for this store.', 403);
|
|
}
|
|
|
|
/** @var PosSession $session */
|
|
$session = PosSession::create([
|
|
'access_key' => $accessKeyObj ? $accessKeyObj->access_key : Str::random(32),
|
|
'store_id' => $store->id,
|
|
'customer_name' => $validated['customer_name'] ?? null,
|
|
'status' => 'active',
|
|
'created_by' => Auth::id(),
|
|
]);
|
|
|
|
if ($accessKeyObj) {
|
|
$accessKeyObj->last_used_at = now();
|
|
$accessKeyObj->save();
|
|
}
|
|
|
|
$this->archiveSession($session, 'Session initialized');
|
|
$this->invalidateSessionCache($session);
|
|
|
|
return ResponseHelper::returnSuccessResponse([
|
|
'hashkey' => $session->hashkey,
|
|
'access_key' => $session->access_key,
|
|
], $session->hashkey, 'POS Session started');
|
|
}
|
|
|
|
public function getSession(Request $request)
|
|
{
|
|
$hashkey = ResponseHelper::getTargetHash();
|
|
$accessKey = $request->input('access_key');
|
|
|
|
if (!$hashkey && !$accessKey) {
|
|
return ResponseHelper::returnError('No key provided', 400);
|
|
}
|
|
|
|
$session = null;
|
|
|
|
if ($hashkey) {
|
|
$q = $this->getBaseSessionQuery()->where('hashkey', $hashkey);
|
|
$session = CacheHelper::get_cache($q);
|
|
|
|
if (!$session) {
|
|
$session = $q->first();
|
|
if ($session) {
|
|
CacheHelper::set_cache($q, $session);
|
|
}
|
|
}
|
|
|
|
// If not a session hash, check if it's a store hash
|
|
if (!$session) {
|
|
$sq = Store::where('hashkey', $hashkey);
|
|
$store = CacheHelper::get_cache($sq);
|
|
if (!$store) {
|
|
$store = $sq->first();
|
|
if ($store) {
|
|
CacheHelper::set_cache($sq, $store);
|
|
}
|
|
}
|
|
|
|
if ($store) {
|
|
$q = $this->getBaseSessionQuery()
|
|
->where('store_id', $store->id)
|
|
->where('status', 'active')
|
|
->orderBy('id', 'desc');
|
|
|
|
$session = CacheHelper::get_cache($q);
|
|
if (!$session) {
|
|
$session = $q->first();
|
|
if ($session) {
|
|
CacheHelper::set_cache($q, $session);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If still no session and we have an accessKey, try that (as fallback or primary if no hashkey)
|
|
if (!$session && $accessKey) {
|
|
$q = $this->getBaseSessionQuery()
|
|
->where('access_key', $accessKey)
|
|
->orderBy('id', 'desc');
|
|
|
|
$session = CacheHelper::get_cache($q);
|
|
if (!$session) {
|
|
$session = $q->first();
|
|
if ($session) {
|
|
CacheHelper::set_cache($q, $session);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$session) {
|
|
return ResponseHelper::returnError('Session not found', 404);
|
|
}
|
|
|
|
// Authorization check
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $session->store_id)) {
|
|
return ResponseHelper::returnError('You are not authorized to access this POS session.', 403);
|
|
}
|
|
|
|
// Return the full session with all eager loaded relations
|
|
return ResponseHelper::returnSuccessResponse($session, $session->hashkey);
|
|
}
|
|
|
|
private function getBaseSessionQuery()
|
|
{
|
|
return PosSession::with([
|
|
'transactions.product' => function ($q) {
|
|
// Only fetch minimal columns needed for the POS to reduce serialization time
|
|
$q->select(['id', 'hashkey', 'name', 'price', 'photourl', 'unitname', 'category']);
|
|
},
|
|
'store'
|
|
]);
|
|
}
|
|
|
|
public function addItem(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'session_hash' => 'required|string',
|
|
'product_hash' => 'required|string',
|
|
'quantity' => 'required|integer|min:1',
|
|
'price' => 'nullable|numeric|min:0',
|
|
]);
|
|
|
|
$sq = PosSession::where('hashkey', $validated['session_hash']);
|
|
$session = CacheHelper::get_cache($sq);
|
|
if (!$session) {
|
|
$session = $sq->first();
|
|
if ($session) {
|
|
CacheHelper::set_cache($sq, $session);
|
|
}
|
|
}
|
|
|
|
$pq = Product::select(['id', 'hashkey', 'price', 'is_active', 'name'])->where('hashkey', $validated['product_hash']);
|
|
$product = CacheHelper::get_cache($pq);
|
|
if (!$product) {
|
|
$product = $pq->first();
|
|
if ($product) {
|
|
CacheHelper::set_cache($pq, $product);
|
|
}
|
|
}
|
|
|
|
if (!$session || !$product) {
|
|
return ResponseHelper::returnError('Session or Product not found', 404);
|
|
}
|
|
|
|
$sessionNeedsSave = false;
|
|
if ($session->status !== 'active') {
|
|
$session->status = 'active';
|
|
$sessionNeedsSave = true;
|
|
}
|
|
|
|
$price = (int) $product->price;
|
|
$isActive = $product->is_active;
|
|
|
|
if ($session->store_id) {
|
|
$psq = DB::table('prd_str')
|
|
->where('store_id', $session->store_id)
|
|
->where('product_id', $product->id)
|
|
->select('price', 'is_active');
|
|
|
|
$storeProduct = CacheHelper::get_cache($psq);
|
|
if (!$storeProduct) {
|
|
$storeProduct = $psq->first();
|
|
if ($storeProduct) {
|
|
CacheHelper::set_cache($psq, $storeProduct, [], 3600); // 1 hour
|
|
}
|
|
}
|
|
|
|
if ($storeProduct) {
|
|
if (isset($storeProduct->price)) {
|
|
$price = (int) $storeProduct->price;
|
|
}
|
|
if (isset($storeProduct->is_active)) {
|
|
$isActive = (bool) $storeProduct->is_active;
|
|
}
|
|
} else {
|
|
return ResponseHelper::returnError('Product not available in this store', 403);
|
|
}
|
|
}
|
|
|
|
if (!$isActive) {
|
|
return ResponseHelper::returnError('Product is currently inactive in this store', 403);
|
|
}
|
|
|
|
// Use custom price if provided, otherwise use calculated store/product price
|
|
if ($request->has('price')) {
|
|
$price = (int) $validated['price'];
|
|
}
|
|
|
|
// Update or create the transaction using raw DB for max speed
|
|
$existingTx = DB::table('pos_transactions')
|
|
->where('pos_session_id', $session->id)
|
|
->where('product_id', $product->id)
|
|
->first();
|
|
|
|
if ($existingTx) {
|
|
DB::table('pos_transactions')->where('id', $existingTx->id)->update([
|
|
'quantity' => $validated['quantity'],
|
|
'price_at_sale' => $price,
|
|
'total_price' => $price * $validated['quantity'],
|
|
'updated_at' => now(),
|
|
]);
|
|
} else {
|
|
DB::table('pos_transactions')->insert([
|
|
'pos_session_id' => $session->id,
|
|
'product_id' => $product->id,
|
|
'quantity' => $validated['quantity'],
|
|
'price_at_sale' => $price,
|
|
'total_price' => $price * $validated['quantity'],
|
|
'hashkey' => \Hyperf\Stringable\Str::uuid()->toString() . \Hyperf\Stringable\Str::random(100),
|
|
'created_at' => now(),
|
|
'updated_at' => now(),
|
|
'created_by' => Auth::id() ?? null,
|
|
]);
|
|
}
|
|
|
|
// Load specific columns to be fast, just like in getSession to reduce payload and memory
|
|
$session->load([
|
|
'transactions.product' => function ($q) {
|
|
$q->select(['id', 'hashkey', 'name', 'price', 'photourl', 'unitname', 'category']);
|
|
},
|
|
'store'
|
|
]);
|
|
$t_load = microtime(true);
|
|
|
|
// Update session totals in memory
|
|
$total = $session->transactions->where('is_void', false)->sum('total_price');
|
|
|
|
$updateData = [];
|
|
if ($session->total_amount !== (int) $total) {
|
|
$session->total_amount = (int) $total;
|
|
$updateData['total_amount'] = (int) $total;
|
|
}
|
|
if ($sessionNeedsSave) {
|
|
$updateData['status'] = $session->status;
|
|
}
|
|
|
|
// Use raw DB update to skip ModelSavingListener overhead while making sure we still record who updated it
|
|
if (!empty($updateData)) {
|
|
$updateData['updated_at'] = now();
|
|
$updateData['updated_by'] = Auth::id();
|
|
DB::table('pos_sessions')->where('id', $session->id)->update($updateData);
|
|
}
|
|
$t_db = microtime(true);
|
|
|
|
// Invalidate all possible session cache keys
|
|
$this->invalidateSessionCache($session);
|
|
|
|
// Archive the session using already loaded transaction data (deferred to background coroutine)
|
|
$this->archiveSession($session, 'Item added/updated: ' . $product->name, $session->transactions);
|
|
|
|
return ResponseHelper::returnSuccessResponse($session, $session->hashkey, 'Item added to session');
|
|
}
|
|
|
|
public function removeItem(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'session_hash' => 'required|string',
|
|
'transaction_id' => 'required|integer',
|
|
]);
|
|
|
|
$session = PosSession::where('hashkey', $validated['session_hash'])->first();
|
|
if (!$session) {
|
|
return ResponseHelper::returnError('Session not found', 404);
|
|
}
|
|
|
|
$transaction = PosTransaction::where('id', $validated['transaction_id'])
|
|
->where('pos_session_id', $session->id)
|
|
->first();
|
|
|
|
if ($transaction) {
|
|
$transaction->delete();
|
|
|
|
// Re-calculate and archive efficiently
|
|
// Load relations ONCE with only necessary columns
|
|
$session->load([
|
|
'transactions.product' => function ($q) {
|
|
$q->select(['id', 'hashkey', 'name', 'price', 'photourl', 'unitname', 'category']);
|
|
},
|
|
'store'
|
|
]);
|
|
|
|
$total = $session->transactions->where('is_void', false)->sum('total_price');
|
|
$session->total_amount = (int) $total;
|
|
DB::table('pos_sessions')->where('id', $session->id)->update([
|
|
'total_amount' => (int) $total,
|
|
'updated_at' => now(),
|
|
'updated_by' => Auth::id(),
|
|
]);
|
|
|
|
// Invalidate all possible session cache keys
|
|
$this->invalidateSessionCache($session);
|
|
|
|
$this->archiveSession($session, 'Item removed', $session->transactions);
|
|
} else {
|
|
$session->load([
|
|
'transactions.product' => function ($q) {
|
|
$q->select(['id', 'hashkey', 'name', 'price', 'photourl', 'unitname', 'category']);
|
|
},
|
|
'store'
|
|
]);
|
|
}
|
|
|
|
return ResponseHelper::returnSuccessResponse($session, $session->hashkey, 'Item removed from session');
|
|
}
|
|
|
|
public function completeSession(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'session_hash' => 'required|string',
|
|
'received_amount' => 'required|integer|min:0',
|
|
'payment_method' => 'required|string',
|
|
'payment_field' => 'nullable|string',
|
|
'customer_name' => 'nullable|string|max:255',
|
|
]);
|
|
|
|
$session = PosSession::where('hashkey', $validated['session_hash'])->first();
|
|
if (!$session) {
|
|
return ResponseHelper::returnError('Session not found', 404);
|
|
}
|
|
|
|
$session->received_amount = $validated['received_amount'];
|
|
$session->change_amount = $validated['received_amount'] - $session->total_amount;
|
|
$session->payment_method = $validated['payment_method'];
|
|
$session->payment_details = ['payment_field' => $validated['payment_field']];
|
|
if (!empty($validated['customer_name'])) {
|
|
$session->customer_name = $validated['customer_name'];
|
|
}
|
|
$session->status = 'completed';
|
|
$session->save();
|
|
|
|
// Invalidate cache
|
|
$this->invalidateSessionCache($session);
|
|
|
|
if (!empty($validated['customer_name'])) {
|
|
$customerName = trim($validated['customer_name']);
|
|
$customer = Customer::where('name', $customerName)
|
|
->where(function ($q) use ($session) {
|
|
$q->where('store_id', $session->store_id)
|
|
->orWhereNull('store_id');
|
|
})
|
|
->first();
|
|
|
|
if (!$customer) {
|
|
Customer::create([
|
|
'name' => $customerName,
|
|
'store_id' => $session->store_id,
|
|
'created_by' => Auth::id(),
|
|
]);
|
|
} else {
|
|
$customer->updated_at = now();
|
|
$customer->save();
|
|
}
|
|
}
|
|
|
|
$this->archiveSession($session, 'Session completed');
|
|
|
|
return ResponseHelper::returnSuccessResponse($session, $session->hashkey, 'Transaction completed');
|
|
}
|
|
|
|
public function syncOffline(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'transactions' => 'required|array',
|
|
'transactions.*.store_hash' => 'required|string',
|
|
'transactions.*.customer_name' => 'nullable|string',
|
|
'transactions.*.items' => 'required|array',
|
|
'transactions.*.total' => 'required|numeric',
|
|
'transactions.*.received' => 'required|numeric',
|
|
'transactions.*.method' => 'required|string',
|
|
'transactions.*.timestamp' => 'required|string',
|
|
'transactions.*.local_id' => 'nullable|integer',
|
|
]);
|
|
|
|
$syncedCount = 0;
|
|
$syncedIds = [];
|
|
$errors = [];
|
|
$affectedStoreIds = [];
|
|
|
|
foreach ($validated['transactions'] as $txn) {
|
|
try {
|
|
DB::beginTransaction();
|
|
|
|
$store = Store::where('hashkey', $txn['store_hash'])->first();
|
|
if (!$store) {
|
|
throw new \Exception('Store not found for hash: ' . $txn['store_hash']);
|
|
}
|
|
|
|
// Convert ISO 8601 timestamp to MySQL datetime format
|
|
$offlineTimestamp = date('Y-m-d H:i:s', strtotime($txn['timestamp']));
|
|
|
|
// Create the session
|
|
$session = new PosSession([
|
|
'store_id' => $store->id,
|
|
'customer_name' => $txn['customer_name'] ?? null,
|
|
'total_amount' => (int) $txn['total'],
|
|
'received_amount' => (int) $txn['received'],
|
|
'change_amount' => (int) ($txn['received'] - $txn['total']),
|
|
'payment_method' => $txn['method'],
|
|
'status' => 'completed',
|
|
'created_by' => Auth::id(),
|
|
'access_key' => 'synced-' . Str::random(32),
|
|
'hashkey' => Str::random(32) . '-' . Str::random(100),
|
|
]);
|
|
|
|
// Manually set timestamps to preserve offline time
|
|
$session->created_at = $offlineTimestamp;
|
|
$session->updated_at = $offlineTimestamp;
|
|
$session->save();
|
|
|
|
// Add Items
|
|
foreach ($txn['items'] as $item) {
|
|
$product = Product::where('hashkey', $item['product_hashkey'])->first();
|
|
if (!$product) continue;
|
|
|
|
DB::table('pos_transactions')->insert([
|
|
'pos_session_id' => $session->id,
|
|
'product_id' => $product->id,
|
|
'quantity' => $item['quantity'],
|
|
'price_at_sale' => (int) $item['price_at_sale'],
|
|
'total_price' => (int) ($item['price_at_sale'] * $item['quantity']),
|
|
'hashkey' => Str::uuid()->toString() . Str::random(100),
|
|
'created_at' => $offlineTimestamp,
|
|
'updated_at' => now(),
|
|
'created_by' => Auth::id(),
|
|
]);
|
|
}
|
|
|
|
// Handle Customer
|
|
if (!empty($txn['customer_name'])) {
|
|
$customerName = trim($txn['customer_name']);
|
|
$customer = Customer::where('name', $customerName)
|
|
->where(function ($q) use ($store) {
|
|
$q->where('store_id', $store->id)
|
|
->orWhereNull('store_id');
|
|
})
|
|
->first();
|
|
|
|
if (!$customer) {
|
|
Customer::create([
|
|
'name' => $customerName,
|
|
'store_id' => $store->id,
|
|
'created_by' => Auth::id(),
|
|
]);
|
|
}
|
|
}
|
|
|
|
$this->archiveSession($session, 'Offline synced transaction');
|
|
$this->invalidateSessionCache($session);
|
|
|
|
DB::commit();
|
|
$syncedCount++;
|
|
|
|
if (isset($txn['local_id'])) {
|
|
$syncedIds[] = $txn['local_id'];
|
|
}
|
|
|
|
if (!in_array($store->id, $affectedStoreIds)) {
|
|
$affectedStoreIds[] = $store->id;
|
|
}
|
|
} catch (\Exception $e) {
|
|
DB::rollBack();
|
|
$errors[] = $e->getMessage();
|
|
}
|
|
}
|
|
|
|
return ResponseHelper::returnSuccessResponse([
|
|
'synced_count' => $syncedCount,
|
|
'synced_ids' => $syncedIds,
|
|
'errors' => $errors
|
|
], 'sync_offline', "Synced $syncedCount transactions");
|
|
}
|
|
|
|
public function voidSession(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'session_hash' => 'required|string',
|
|
'remarks' => 'nullable|string',
|
|
]);
|
|
|
|
$session = PosSession::where('hashkey', $validated['session_hash'])->first();
|
|
if (!$session) {
|
|
return ResponseHelper::returnError('Session not found', 404);
|
|
}
|
|
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $session->store_id)) {
|
|
return ResponseHelper::returnError('You are not authorized to void this POS session.', 403);
|
|
}
|
|
|
|
$session->status = 'voided';
|
|
$session->is_void = true;
|
|
$session->save();
|
|
|
|
// Invalidate cache
|
|
$this->invalidateSessionCache($session);
|
|
|
|
$this->archiveSession($session, 'Session voided: ' . ($validated['remarks'] ?? 'No remarks'));
|
|
|
|
return ResponseHelper::returnSuccessResponse($session, $session->hashkey, 'Transaction voided');
|
|
}
|
|
|
|
public function getPosSessions(Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'store_hash' => 'required|string',
|
|
'page' => 'nullable|integer|min:1',
|
|
'per_page' => 'nullable|integer|min:1|max:100',
|
|
]);
|
|
|
|
$store = Store::where('hashkey', $validated['store_hash'])->first();
|
|
if (!$store) {
|
|
return ResponseHelper::returnError('Store not found', 404);
|
|
}
|
|
|
|
// Authorization check
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $store)) {
|
|
return ResponseHelper::returnError('You are not authorized to view sessions for this store.', 403);
|
|
}
|
|
|
|
$page = (int) ($validated['page'] ?? 1);
|
|
$perPage = (int) ($validated['per_page'] ?? 10);
|
|
$offset = ($page - 1) * $perPage;
|
|
|
|
$query = PosSession::with(['transactions.product'])
|
|
->where('store_id', $store->id)
|
|
->where('status', '!=', 'active')
|
|
->orderBy('id', 'desc');
|
|
|
|
$totalCount = $query->count();
|
|
$sessions = $query->limit($perPage)->offset($offset)->get();
|
|
|
|
// Map sessions to include item count and simplify if needed
|
|
$sessions = $sessions->map(function ($session) {
|
|
return [
|
|
'hashkey' => $session->hashkey,
|
|
'status' => $session->status,
|
|
'total_amount' => $session->total_amount,
|
|
'customer_name' => $session->customer_name,
|
|
'payment_method' => $session->payment_method,
|
|
'items_count' => $session->transactions->count(),
|
|
'created_at' => $session->created_at,
|
|
'transactions' => $session->transactions,
|
|
];
|
|
});
|
|
|
|
return ResponseHelper::returnSuccessResponse([
|
|
'sessions' => $sessions,
|
|
'total_count' => $totalCount,
|
|
'page' => $page,
|
|
'per_page' => $perPage,
|
|
], $store->hashkey, 'POS sessions fetched');
|
|
}
|
|
|
|
public function getTodayStats(Request $request)
|
|
{
|
|
if (!UserPermissions::isActionPermitted(Auth::user()->acct_type, UserActions::ViewPosReports)) {
|
|
return ResponseHelper::returnUnauthorized();
|
|
}
|
|
|
|
$date = now()->format('Y-m-d');
|
|
$query = PosSession::where('status', 'completed')
|
|
->whereDate('created_at', $date);
|
|
|
|
$storeName = null;
|
|
$storePhoto = null;
|
|
// If store_hash is provided, filter by store
|
|
if ($request->input('store_hash')) {
|
|
$store = Store::where('hashkey', $request->input('store_hash'))->first();
|
|
if ($store) {
|
|
// Authorization check
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $store)) {
|
|
return ResponseHelper::returnError('You are not authorized to view reports for this store.', 403);
|
|
}
|
|
$query->where('store_id', $store->id);
|
|
$storeName = $store->name;
|
|
$storePhoto = $store->photourl;
|
|
}
|
|
}
|
|
|
|
$stats = CacheHelper::get_cache($query);
|
|
if ($stats) {
|
|
return ResponseHelper::returnSuccessResponse($stats, 'today_stats');
|
|
}
|
|
|
|
$stats = [
|
|
'count' => (int) $query->count(),
|
|
'total' => (int) $query->sum('total_amount'),
|
|
'store_name' => $storeName,
|
|
'store_photo' => $storePhoto,
|
|
];
|
|
|
|
CacheHelper::set_cache($query, $stats, [], 300); // 5 minutes
|
|
|
|
return ResponseHelper::returnSuccessResponse($stats, 'today_stats');
|
|
}
|
|
|
|
public function getCustomers(Request $request)
|
|
{
|
|
if (!UserPermissions::isActionPermitted(Auth::user()->acct_type, UserActions::ViewCustomers)) {
|
|
return ResponseHelper::returnUnauthorized();
|
|
}
|
|
|
|
$queryText = $request->input('query');
|
|
$storeHash = $request->input('store_hash');
|
|
|
|
$customerQuery = Customer::where('is_active', true);
|
|
|
|
if ($storeHash) {
|
|
$store = Store::where('hashkey', $storeHash)->first();
|
|
if ($store) {
|
|
// Authorization check
|
|
if (!UserPermissions::isUserAllowedAccessToStore(Auth::user(), $store)) {
|
|
return ResponseHelper::returnError('You are not authorized to view customers for this store.', 403);
|
|
}
|
|
$customerQuery->where(function ($q) use ($store) {
|
|
$q->where('store_id', $store->id)
|
|
->orWhereNull('store_id');
|
|
});
|
|
}
|
|
}
|
|
|
|
if ($queryText) {
|
|
$customerQuery->where('name', 'like', '%' . $queryText . '%');
|
|
}
|
|
|
|
$finalQuery = $customerQuery->orderBy('name', 'asc')->limit(10);
|
|
$customers = CacheHelper::get_cache($finalQuery);
|
|
|
|
if (!$customers) {
|
|
$customers = $finalQuery->get();
|
|
CacheHelper::set_cache($finalQuery, $customers, [], 3600); // 1 hour
|
|
}
|
|
|
|
return ResponseHelper::returnSuccessResponse($customers, 'customer_suggestions');
|
|
}
|
|
|
|
private function updateSessionTotals(PosSession $session)
|
|
{
|
|
$total = $session->transactions()->where('is_void', false)->sum('total_price');
|
|
$session->total_amount = (int) $total;
|
|
$session->save();
|
|
}
|
|
|
|
private function archiveSession(PosSession $session, string $remarks = '', $transactions = null)
|
|
{
|
|
// Serialize all data NOW before spawning coroutine to avoid context issues
|
|
$sessionData = $session->toArray();
|
|
$sessionId = $session->id;
|
|
$sessionHashkey = $session->hashkey;
|
|
$userId = Auth::id();
|
|
|
|
if ($transactions !== null) {
|
|
$transactionsData = $transactions->toArray();
|
|
} else {
|
|
$transactionsData = $session->transactions()->with('product')->get()->toArray();
|
|
}
|
|
|
|
// Defer the archive INSERT to a background coroutine so it doesn't block the response
|
|
Coroutine::create(function () use ($sessionId, $sessionHashkey, $sessionData, $transactionsData, $userId, $remarks) {
|
|
try {
|
|
PosSessionArchive::create([
|
|
'pos_session_id' => $sessionId,
|
|
'hashkey' => $sessionHashkey,
|
|
'session_snapshot' => $sessionData,
|
|
'transactions_snapshot' => $transactionsData,
|
|
'created_by' => $userId,
|
|
'remarks' => $remarks,
|
|
]);
|
|
} catch (\Throwable $e) {
|
|
// Silently fail — archive is non-critical audit data
|
|
}
|
|
});
|
|
}
|
|
|
|
private function invalidateSessionCache(PosSession $session)
|
|
{
|
|
// 1. Invalidate by hashkey (with relations)
|
|
CacheHelper::erase_cache($this->getBaseSessionQuery()->where('hashkey', $session->hashkey));
|
|
|
|
// 1b. Invalidate simple hashkey lookup (used in addItem)
|
|
CacheHelper::erase_cache(PosSession::where('hashkey', $session->hashkey));
|
|
|
|
// 2. Invalidate by store_id (last active session)
|
|
if ($session->store_id) {
|
|
CacheHelper::erase_cache($this->getBaseSessionQuery()
|
|
->where('store_id', $session->store_id)
|
|
->where('status', 'active')
|
|
->orderBy('id', 'desc'));
|
|
}
|
|
|
|
// 3. Invalidate by access_key
|
|
if ($session->access_key) {
|
|
CacheHelper::erase_cache($this->getBaseSessionQuery()
|
|
->where('access_key', $session->access_key)
|
|
->orderBy('id', 'desc'));
|
|
}
|
|
// 4. Invalidate today stats cache for the store
|
|
if ($session->store_id) {
|
|
$date = now()->format('Y-m-d');
|
|
$statsQuery = PosSession::where('status', 'completed')
|
|
->whereDate('created_at', $date)
|
|
->where('store_id', $session->store_id);
|
|
CacheHelper::erase_cache($statsQuery);
|
|
}
|
|
}
|
|
}
|