1125 lines
47 KiB
PHP
1125 lines
47 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Http\Requests\StoreContractRequest;
|
|
use App\Http\Requests\UpdateContractRequest;
|
|
use App\Models\ClientCase;
|
|
use App\Models\Contract;
|
|
use App\Models\Document;
|
|
use Exception;
|
|
use Illuminate\Database\QueryException;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Inertia\Inertia;
|
|
|
|
class ClientCaseContoller extends Controller
|
|
{
|
|
/**
|
|
* Display a listing of the resource.
|
|
*/
|
|
public function index(ClientCase $clientCase, Request $request)
|
|
{
|
|
$query = $clientCase::query()
|
|
->with(['person', 'client.person'])
|
|
->where('active', 1)
|
|
->when($request->input('search'), function ($que, $search) {
|
|
$que->whereHas('person', function ($q) use ($search) {
|
|
$q->where('full_name', 'ilike', '%'.$search.'%');
|
|
});
|
|
})
|
|
->addSelect([
|
|
// Count of active contracts (a contract is considered active if it has an active pivot in contract_segment)
|
|
'active_contracts_count' => \DB::query()
|
|
->from('contracts')
|
|
->selectRaw('COUNT(*)')
|
|
->whereColumn('contracts.client_case_id', 'client_cases.id')
|
|
->whereNull('contracts.deleted_at')
|
|
->whereExists(function ($q) {
|
|
$q->from('contract_segment')
|
|
->whereColumn('contract_segment.contract_id', 'contracts.id')
|
|
->where('contract_segment.active', true);
|
|
}),
|
|
// Sum of balances for accounts of active contracts
|
|
'active_contracts_balance_sum' => \DB::query()
|
|
->from('contracts')
|
|
->join('accounts', 'accounts.contract_id', '=', 'contracts.id')
|
|
->selectRaw('COALESCE(SUM(accounts.balance_amount), 0)')
|
|
->whereColumn('contracts.client_case_id', 'client_cases.id')
|
|
->whereNull('contracts.deleted_at')
|
|
->whereExists(function ($q) {
|
|
$q->from('contract_segment')
|
|
->whereColumn('contract_segment.contract_id', 'contracts.id')
|
|
->where('contract_segment.active', true);
|
|
}),
|
|
])
|
|
->orderByDesc('created_at');
|
|
|
|
return Inertia::render('Cases/Index', [
|
|
'client_cases' => $query
|
|
->paginate(15, ['*'], 'client-cases-page')
|
|
->withQueryString(),
|
|
'filters' => $request->only(['search']),
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Show the form for creating a new resource.
|
|
*/
|
|
public function create()
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Store a newly created resource in storage.
|
|
*/
|
|
public function store(Request $request)
|
|
{
|
|
//
|
|
$cuuid = $request->input('client_uuid');
|
|
|
|
$client = \App\Models\Client::where('uuid', $cuuid)->firstOrFail();
|
|
|
|
if (isset($client->id)) {
|
|
|
|
\DB::transaction(function () use ($request, $client) {
|
|
$pq = $request->input('person');
|
|
|
|
$person = $client->person()->create([
|
|
'nu' => rand(100000, 200000),
|
|
'first_name' => $pq['first_name'],
|
|
'last_name' => $pq['last_name'],
|
|
'full_name' => $pq['full_name'],
|
|
'gender' => null,
|
|
'birthday' => null,
|
|
'tax_number' => $pq['tax_number'],
|
|
'social_security_number' => $pq['social_security_number'],
|
|
'description' => $pq['description'],
|
|
'group_id' => 2,
|
|
'type_id' => 1,
|
|
]);
|
|
|
|
$person->addresses()->create([
|
|
'address' => $pq['address']['address'],
|
|
'country' => $pq['address']['country'],
|
|
'type_id' => $pq['address']['type_id'],
|
|
]);
|
|
|
|
$person->phones()->create([
|
|
'nu' => $pq['phone']['nu'],
|
|
'country_code' => $pq['phone']['country_code'],
|
|
'type_id' => $pq['phone']['type_id'],
|
|
]);
|
|
|
|
$person->clientCase()->create([
|
|
'client_id' => $client->id,
|
|
]);
|
|
});
|
|
}
|
|
|
|
return to_route('client.show', $client);
|
|
}
|
|
|
|
public function storeContract(ClientCase $clientCase, StoreContractRequest $request)
|
|
{
|
|
|
|
\DB::transaction(function () use ($request, $clientCase) {
|
|
|
|
// Create contract
|
|
$contract = $clientCase->contracts()->create([
|
|
'reference' => $request->input('reference'),
|
|
'start_date' => date('Y-m-d', strtotime($request->input('start_date'))),
|
|
'type_id' => $request->input('type_id'),
|
|
'description' => $request->input('description'),
|
|
]);
|
|
|
|
// Note: Contract config auto-application is handled in Contract model created hook.
|
|
|
|
// Optionally create related account with amounts and/or type
|
|
$initial = $request->input('initial_amount');
|
|
$balance = $request->input('balance_amount');
|
|
$accountTypeId = $request->input('account_type_id');
|
|
if (! is_null($initial) || ! is_null($balance) || ! is_null($accountTypeId)) {
|
|
$contract->account()->create([
|
|
'type_id' => $accountTypeId,
|
|
'initial_amount' => $initial ?? 0,
|
|
'balance_amount' => $balance ?? 0,
|
|
]);
|
|
}
|
|
|
|
});
|
|
|
|
// Preserve segment filter if present
|
|
$segment = request('segment');
|
|
|
|
return to_route('clientCase.show', ['client_case' => $clientCase, 'segment' => $segment]);
|
|
}
|
|
|
|
public function updateContract(ClientCase $clientCase, string $uuid, UpdateContractRequest $request)
|
|
{
|
|
$contract = Contract::where('uuid', $uuid)->firstOrFail();
|
|
|
|
\DB::transaction(function () use ($request, $contract) {
|
|
$contract->update([
|
|
'reference' => $request->input('reference'),
|
|
'type_id' => $request->input('type_id'),
|
|
'description' => $request->input('description'),
|
|
'start_date' => $request->filled('start_date') ? date('Y-m-d', strtotime($request->input('start_date'))) : $contract->start_date,
|
|
]);
|
|
|
|
$initial = $request->input('initial_amount');
|
|
$balance = $request->input('balance_amount');
|
|
$shouldUpsertAccount = (! is_null($initial)) || (! is_null($balance)) || $request->has('account_type_id');
|
|
if ($shouldUpsertAccount) {
|
|
$accountData = [];
|
|
// Track old balance before applying changes
|
|
$oldBalance = (float) optional($contract->account)->balance_amount;
|
|
if (! is_null($initial)) {
|
|
$accountData['initial_amount'] = $initial;
|
|
}
|
|
if (! is_null($balance)) {
|
|
$accountData['balance_amount'] = $balance;
|
|
}
|
|
if ($request->has('account_type_id')) {
|
|
$accountData['type_id'] = $request->input('account_type_id');
|
|
}
|
|
|
|
if ($contract->account) {
|
|
$contract->account->update($accountData);
|
|
} else {
|
|
// For create, ensure defaults exist if not provided
|
|
$accountData = array_merge(['initial_amount' => 0, 'balance_amount' => 0], $accountData);
|
|
$contract->account()->create($accountData);
|
|
}
|
|
|
|
// After update/create, if balance_amount changed (and not through a payment), log an activity with before/after
|
|
if (array_key_exists('balance_amount', $accountData)) {
|
|
$newBalance = (float) optional($contract->account)->fresh()->balance_amount;
|
|
if ($newBalance !== $oldBalance) {
|
|
try {
|
|
$currency = optional(\App\Models\PaymentSetting::query()->first())->default_currency ?? 'EUR';
|
|
$beforeStr = number_format($oldBalance, 2, ',', '.').' '.$currency;
|
|
$afterStr = number_format($newBalance, 2, ',', '.').' '.$currency;
|
|
$note = 'Sprememba stanja (Stanje pred: '.$beforeStr.', Stanje po: '.$afterStr.'; Izvor: sprememba)';
|
|
\App\Models\Activity::create([
|
|
'due_date' => null,
|
|
'amount' => null,
|
|
'note' => $note,
|
|
'action_id' => null,
|
|
'decision_id' => null,
|
|
'client_case_id' => $contract->client_case_id,
|
|
'contract_id' => $contract->id,
|
|
]);
|
|
} catch (\Throwable $e) {
|
|
// non-fatal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
});
|
|
|
|
// Preserve segment filter if present
|
|
$segment = request('segment');
|
|
|
|
return to_route('clientCase.show', ['client_case' => $clientCase, 'segment' => $segment]);
|
|
}
|
|
|
|
public function storeActivity(ClientCase $clientCase, Request $request)
|
|
{
|
|
try {
|
|
$attributes = $request->validate([
|
|
'due_date' => 'nullable|date',
|
|
'amount' => 'nullable|decimal:0,4',
|
|
'note' => 'nullable|string',
|
|
'action_id' => 'exists:\App\Models\Action,id',
|
|
'decision_id' => 'exists:\App\Models\Decision,id',
|
|
'contract_uuid' => 'nullable|uuid',
|
|
]);
|
|
|
|
// Map contract_uuid to contract_id within the same client case, if provided
|
|
$contractId = null;
|
|
if (! empty($attributes['contract_uuid'])) {
|
|
$contract = $clientCase->contracts()->where('uuid', $attributes['contract_uuid'])->firstOrFail('id');
|
|
if ($contract) {
|
|
$contractId = $contract->id;
|
|
}
|
|
}
|
|
|
|
// Create activity
|
|
$row = $clientCase->activities()->create([
|
|
'due_date' => $attributes['due_date'] ?? null,
|
|
'amount' => $attributes['amount'] ?? null,
|
|
'note' => $attributes['note'] ?? null,
|
|
'action_id' => $attributes['action_id'],
|
|
'decision_id' => $attributes['decision_id'],
|
|
'contract_id' => $contractId,
|
|
]);
|
|
/*foreach ($activity->decision->events as $e) {
|
|
$class = '\\App\\Events\\' . $e->name;
|
|
event(new $class($clientCase));
|
|
}*/
|
|
|
|
logger()->info('Activity successfully inserted', $attributes);
|
|
|
|
// Stay on the current page (desktop or phone) instead of forcing a redirect to the desktop route.
|
|
// Use 303 to align with Inertia's recommended POST/Redirect/GET behavior.
|
|
return back(303)->with('success', 'Successful created!');
|
|
} catch (QueryException $e) {
|
|
logger()->error('Database error occurred:', ['error' => $e->getMessage()]);
|
|
|
|
return back()->with('error', 'Failed to insert activity. '.$e->getMessage());
|
|
} catch (Exception $e) {
|
|
logger()->error('An unexpected error occurred:', ['error' => $e->getMessage()]);
|
|
|
|
// Return a generic error response
|
|
return back()->with('error', 'An unexpected error occurred. Please try again later.');
|
|
}
|
|
|
|
}
|
|
|
|
public function deleteActivity(ClientCase $clientCase, \App\Models\Activity $activity, Request $request)
|
|
{
|
|
// Ensure activity belongs to this case
|
|
if ($activity->client_case_id !== $clientCase->id) {
|
|
abort(404);
|
|
}
|
|
|
|
\DB::transaction(function () use ($activity) {
|
|
$activity->delete();
|
|
});
|
|
|
|
return back()->with('success', 'Activity deleted.');
|
|
}
|
|
|
|
public function deleteContract(ClientCase $clientCase, string $uuid, Request $request)
|
|
{
|
|
$contract = Contract::where('uuid', $uuid)->firstOrFail();
|
|
|
|
\DB::transaction(function () use ($contract) {
|
|
$contract->delete();
|
|
});
|
|
|
|
// Preserve segment filter if present
|
|
$segment = request('segment');
|
|
|
|
return to_route('clientCase.show', ['client_case' => $clientCase, 'segment' => $segment]);
|
|
}
|
|
|
|
public function updateContractSegment(ClientCase $clientCase, string $uuid, Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'segment_id' => ['required', 'integer', 'exists:segments,id'],
|
|
]);
|
|
|
|
$contract = $clientCase->contracts()->where('uuid', $uuid)->firstOrFail();
|
|
|
|
\DB::transaction(function () use ($contract, $validated) {
|
|
// Deactivate current active relation(s)
|
|
\DB::table('contract_segment')
|
|
->where('contract_id', $contract->id)
|
|
->where('active', true)
|
|
->update(['active' => false]);
|
|
|
|
// Attach or update the selected segment as active
|
|
$existing = \DB::table('contract_segment')
|
|
->where('contract_id', $contract->id)
|
|
->where('segment_id', $validated['segment_id'])
|
|
->first();
|
|
|
|
if ($existing) {
|
|
\DB::table('contract_segment')
|
|
->where('id', $existing->id)
|
|
->update(['active' => true, 'updated_at' => now()]);
|
|
} else {
|
|
$contract->segments()->attach($validated['segment_id'], ['active' => true, 'created_at' => now(), 'updated_at' => now()]);
|
|
}
|
|
});
|
|
|
|
return back()->with('success', 'Contract segment updated.');
|
|
}
|
|
|
|
public function attachSegment(ClientCase $clientCase, Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'segment_id' => ['required', 'integer', 'exists:segments,id'],
|
|
'contract_uuid' => ['nullable', 'uuid'],
|
|
'make_active_for_contract' => ['sometimes', 'boolean'],
|
|
]);
|
|
|
|
\DB::transaction(function () use ($clientCase, $validated) {
|
|
// Attach segment to client case if not already attached
|
|
$attached = \DB::table('client_case_segment')
|
|
->where('client_case_id', $clientCase->id)
|
|
->where('segment_id', $validated['segment_id'])
|
|
->first();
|
|
if (! $attached) {
|
|
$clientCase->segments()->attach($validated['segment_id'], ['active' => true]);
|
|
} elseif (! $attached->active) {
|
|
\DB::table('client_case_segment')
|
|
->where('id', $attached->id)
|
|
->update(['active' => true, 'updated_at' => now()]);
|
|
}
|
|
|
|
// Optionally make it active for a specific contract
|
|
if (! empty($validated['contract_uuid']) && ($validated['make_active_for_contract'] ?? false)) {
|
|
$contract = $clientCase->contracts()->where('uuid', $validated['contract_uuid'])->firstOrFail();
|
|
\DB::table('contract_segment')
|
|
->where('contract_id', $contract->id)
|
|
->where('active', true)
|
|
->update(['active' => false]);
|
|
|
|
$existing = \DB::table('contract_segment')
|
|
->where('contract_id', $contract->id)
|
|
->where('segment_id', $validated['segment_id'])
|
|
->first();
|
|
if ($existing) {
|
|
\DB::table('contract_segment')
|
|
->where('id', $existing->id)
|
|
->update(['active' => true, 'updated_at' => now()]);
|
|
} else {
|
|
$contract->segments()->attach($validated['segment_id'], ['active' => true, 'created_at' => now(), 'updated_at' => now()]);
|
|
}
|
|
}
|
|
});
|
|
|
|
return back()->with('success', 'Segment attached to case.');
|
|
}
|
|
|
|
public function storeDocument(ClientCase $clientCase, Request $request)
|
|
{
|
|
$validated = $request->validate([
|
|
'file' => 'required|file|max:25600|mimes:doc,docx,pdf,txt,csv,xls,xlsx,jpeg,png', // 25MB and allowed types
|
|
'name' => 'nullable|string|max:255',
|
|
'description' => 'nullable|string',
|
|
'is_public' => 'sometimes|boolean',
|
|
'contract_uuid' => 'nullable|uuid',
|
|
]);
|
|
|
|
$file = $validated['file'];
|
|
$disk = 'public';
|
|
$contract = null;
|
|
if (! empty($validated['contract_uuid'])) {
|
|
$contract = $clientCase->contracts()->where('uuid', $validated['contract_uuid'])->first();
|
|
}
|
|
$directory = $contract
|
|
? ('contracts/'.$contract->uuid.'/documents')
|
|
: ('cases/'.$clientCase->uuid.'/documents');
|
|
$path = $file->store($directory, $disk);
|
|
|
|
$doc = new Document([
|
|
'name' => $validated['name'] ?? pathinfo($file->getClientOriginalName(), PATHINFO_FILENAME),
|
|
'description' => $validated['description'] ?? null,
|
|
'user_id' => optional($request->user())->id,
|
|
'disk' => $disk,
|
|
'path' => $path,
|
|
'file_name' => basename($path),
|
|
'original_name' => $file->getClientOriginalName(),
|
|
'extension' => $file->getClientOriginalExtension(),
|
|
'mime_type' => $file->getMimeType(),
|
|
'size' => $file->getSize(),
|
|
'checksum' => null,
|
|
'is_public' => (bool) ($validated['is_public'] ?? false),
|
|
]);
|
|
|
|
if ($contract) {
|
|
$contract->documents()->save($doc);
|
|
} else {
|
|
$clientCase->documents()->save($doc);
|
|
}
|
|
|
|
// Generate preview immediately for Office docs to avoid first-view delay
|
|
$ext = strtolower($doc->extension ?? pathinfo($doc->original_name ?? $doc->file_name, PATHINFO_EXTENSION));
|
|
if (in_array($ext, ['doc', 'docx'])) {
|
|
\App\Jobs\GenerateDocumentPreview::dispatch($doc->id);
|
|
}
|
|
|
|
return back()->with('success', 'Document uploaded.');
|
|
}
|
|
|
|
public function viewDocument(ClientCase $clientCase, Document $document, Request $request)
|
|
{
|
|
// Ensure the document belongs to this client case or its contracts
|
|
$belongsToCase = $document->documentable_type === ClientCase::class && $document->documentable_id === $clientCase->id;
|
|
$belongsToContractOfCase = false;
|
|
if ($document->documentable_type === Contract::class) {
|
|
// Include soft-deleted contracts when verifying ownership to this case
|
|
$belongsToContractOfCase = Contract::withTrashed()
|
|
->where('id', $document->documentable_id)
|
|
->where('client_case_id', $clientCase->id)
|
|
->exists();
|
|
|
|
}
|
|
if (! ($belongsToCase || $belongsToContractOfCase)) {
|
|
logger()->warning('Document view 404: document does not belong to case or its contracts', [
|
|
'document_id' => $document->id,
|
|
'document_uuid' => $document->uuid,
|
|
'documentable_type' => $document->documentable_type,
|
|
'documentable_id' => $document->documentable_id,
|
|
'client_case_id' => $clientCase->id,
|
|
'client_case_uuid' => $clientCase->uuid,
|
|
]);
|
|
abort(404);
|
|
}
|
|
|
|
// Optional: add authz checks here (e.g., policies)
|
|
$disk = $document->disk ?: 'public';
|
|
// Normalize relative path (handle legacy 'public/' or 'public\\' prefixes and backslashes on Windows)
|
|
$relPath = $document->path ?? '';
|
|
$relPath = str_replace('\\', '/', $relPath); // unify slashes
|
|
$relPath = ltrim($relPath, '/');
|
|
if (str_starts_with($relPath, 'public/')) {
|
|
$relPath = substr($relPath, 7);
|
|
}
|
|
|
|
// If a preview exists (e.g., PDF generated for doc/docx), stream that
|
|
$previewDisk = config('files.preview_disk', 'public');
|
|
if ($document->preview_path && Storage::disk($previewDisk)->exists($document->preview_path)) {
|
|
$stream = Storage::disk($previewDisk)->readStream($document->preview_path);
|
|
if ($stream === false) {
|
|
abort(404);
|
|
}
|
|
|
|
return response()->stream(function () use ($stream) {
|
|
fpassthru($stream);
|
|
}, 200, [
|
|
'Content-Type' => $document->preview_mime ?: 'application/pdf',
|
|
'Content-Disposition' => 'inline; filename="'.addslashes(($document->original_name ?: $document->file_name).'.pdf').'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
|
|
// If it's a DOC/DOCX and no preview yet, queue generation and show 202 Accepted
|
|
$ext = strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION));
|
|
if (in_array($ext, ['doc', 'docx'])) {
|
|
\App\Jobs\GenerateDocumentPreview::dispatch($document->id);
|
|
|
|
return response('Preview is being generated. Please try again shortly.', 202);
|
|
}
|
|
|
|
// Try multiple path candidates to account for legacy prefixes
|
|
$candidates = [];
|
|
$candidates[] = $relPath;
|
|
// also try raw original (normalized slashes, trimmed)
|
|
$raw = $document->path ? ltrim(str_replace('\\', '/', $document->path), '/') : null;
|
|
if ($raw && $raw !== $relPath) {
|
|
$candidates[] = $raw;
|
|
}
|
|
// if path accidentally contains 'storage/' prefix (public symlink), strip it
|
|
if (str_starts_with($relPath, 'storage/')) {
|
|
$candidates[] = substr($relPath, 8);
|
|
}
|
|
if ($raw && str_starts_with($raw, 'storage/')) {
|
|
$candidates[] = substr($raw, 8);
|
|
}
|
|
|
|
$existsOnDisk = false;
|
|
foreach ($candidates as $cand) {
|
|
if (Storage::disk($disk)->exists($cand)) {
|
|
$existsOnDisk = true;
|
|
$relPath = $cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (! $existsOnDisk) {
|
|
// Fallback: some legacy files may live directly under public/, attempt to stream from there
|
|
$publicFull = public_path($relPath);
|
|
$real = @realpath($publicFull);
|
|
$publicRoot = @realpath(public_path());
|
|
$realN = $real ? str_replace('\\', '/', $real) : null;
|
|
$rootN = $publicRoot ? str_replace('\\', '/', $publicRoot) : null;
|
|
if ($realN && $rootN && str_starts_with($realN, $rootN) && is_file($real)) {
|
|
logger()->info('Document view fallback: serving from public path', [
|
|
'document_id' => $document->id,
|
|
'path' => $realN,
|
|
]);
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp === false) {
|
|
abort(404);
|
|
}
|
|
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'inline; filename="'.addslashes((($document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME)).'.'.strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION)))).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
|
|
logger()->warning('Document view 404: file missing on disk and public fallback failed', [
|
|
'document_id' => $document->id,
|
|
'document_uuid' => $document->uuid,
|
|
'disk' => $disk,
|
|
'path' => $document->path,
|
|
'normalizedCandidates' => $candidates,
|
|
'public_candidate' => $publicFull,
|
|
]);
|
|
abort(404);
|
|
}
|
|
|
|
$stream = Storage::disk($disk)->readStream($relPath);
|
|
if ($stream === false) {
|
|
logger()->warning('Document view: readStream failed, attempting fallbacks', [
|
|
'document_id' => $document->id,
|
|
'disk' => $disk,
|
|
'relPath' => $relPath,
|
|
]);
|
|
|
|
$headers = [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'inline; filename="'.addslashes((($document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME)).'.'.strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION)))).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
];
|
|
|
|
// Fallback 1: get() the bytes directly
|
|
try {
|
|
$bytes = Storage::disk($disk)->get($relPath);
|
|
} catch (\Throwable $e) {
|
|
$bytes = null;
|
|
}
|
|
if (! is_null($bytes) && $bytes !== false) {
|
|
return response($bytes, 200, $headers);
|
|
}
|
|
|
|
// Fallback 2: open via absolute path (local driver)
|
|
$abs = null;
|
|
try {
|
|
if (method_exists(Storage::disk($disk), 'path')) {
|
|
$abs = Storage::disk($disk)->path($relPath);
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$abs = null;
|
|
}
|
|
if ($abs && is_file($abs)) {
|
|
$fp = @fopen($abs, 'rb');
|
|
if ($fp !== false) {
|
|
logger()->info('Document view fallback: serving from absolute storage path', [
|
|
'document_id' => $document->id,
|
|
'abs' => str_replace('\\\\', '/', (string) realpath($abs)),
|
|
]);
|
|
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
// Fallback 3: serve from public path if available
|
|
$publicFull = public_path($relPath);
|
|
$real = @realpath($publicFull);
|
|
$publicRoot = @realpath(public_path());
|
|
$realN = $real ? str_replace('\\\\', '/', $real) : null;
|
|
$rootN = $publicRoot ? str_replace('\\\\', '/', $publicRoot) : null;
|
|
if ($realN && $rootN && str_starts_with($realN, $rootN) && is_file($real)) {
|
|
logger()->info('Document view fallback: serving from public path (post-readStream failure)', [
|
|
'document_id' => $document->id,
|
|
'path' => $realN,
|
|
]);
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp !== false) {
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
logger()->warning('Document view 404: all fallbacks failed after readStream failure', [
|
|
'document_id' => $document->id,
|
|
'disk' => $disk,
|
|
'relPath' => $relPath,
|
|
]);
|
|
abort(404);
|
|
}
|
|
|
|
return response()->stream(function () use ($stream) {
|
|
fpassthru($stream);
|
|
}, 200, [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'inline; filename="'.addslashes((($document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME)).'.'.strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION)))).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
|
|
public function downloadDocument(ClientCase $clientCase, Document $document, Request $request)
|
|
{
|
|
$belongsToCase = $document->documentable_type === ClientCase::class && $document->documentable_id === $clientCase->id;
|
|
$belongsToContractOfCase = false;
|
|
if ($document->documentable_type === Contract::class) {
|
|
$belongsToContractOfCase = Contract::withTrashed()
|
|
->where('id', $document->documentable_id)
|
|
->where('client_case_id', $clientCase->id)
|
|
->exists();
|
|
}
|
|
if (! ($belongsToCase || $belongsToContractOfCase)) {
|
|
logger()->warning('Document download 404: document does not belong to case or its contracts', [
|
|
'document_id' => $document->id,
|
|
'document_uuid' => $document->uuid,
|
|
'documentable_type' => $document->documentable_type,
|
|
'documentable_id' => $document->documentable_id,
|
|
'client_case_id' => $clientCase->id,
|
|
'client_case_uuid' => $clientCase->uuid,
|
|
]);
|
|
abort(404);
|
|
}
|
|
$disk = $document->disk ?: 'public';
|
|
// Normalize relative path for Windows and legacy prefixes
|
|
$relPath = $document->path ?? '';
|
|
$relPath = str_replace('\\', '/', $relPath);
|
|
$relPath = ltrim($relPath, '/');
|
|
if (str_starts_with($relPath, 'public/')) {
|
|
$relPath = substr($relPath, 7);
|
|
}
|
|
|
|
$candidates = [];
|
|
$candidates[] = $relPath;
|
|
$raw = $document->path ? ltrim(str_replace('\\', '/', $document->path), '/') : null;
|
|
if ($raw && $raw !== $relPath) {
|
|
$candidates[] = $raw;
|
|
}
|
|
if (str_starts_with($relPath, 'storage/')) {
|
|
$candidates[] = substr($relPath, 8);
|
|
}
|
|
if ($raw && str_starts_with($raw, 'storage/')) {
|
|
$candidates[] = substr($raw, 8);
|
|
}
|
|
|
|
$existsOnDisk = false;
|
|
foreach ($candidates as $cand) {
|
|
if (Storage::disk($disk)->exists($cand)) {
|
|
$existsOnDisk = true;
|
|
$relPath = $cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (! $existsOnDisk) {
|
|
// Fallback to public/ direct path if present
|
|
$publicFull = public_path($relPath);
|
|
$real = @realpath($publicFull);
|
|
$publicRoot = @realpath(public_path());
|
|
$realN = $real ? str_replace('\\', '/', $real) : null;
|
|
$rootN = $publicRoot ? str_replace('\\', '/', $publicRoot) : null;
|
|
if ($realN && $rootN && str_starts_with($realN, $rootN) && is_file($real)) {
|
|
logger()->info('Document download fallback: serving from public path', [
|
|
'document_id' => $document->id,
|
|
'path' => $realN,
|
|
]);
|
|
$nameBase = $document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME);
|
|
$ext = strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION));
|
|
$name = $ext ? ($nameBase.'.'.$ext) : $nameBase;
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp === false) {
|
|
abort(404);
|
|
}
|
|
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'attachment; filename="'.addslashes($name).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
|
|
logger()->warning('Document download 404: file missing on disk and public fallback failed', [
|
|
'document_id' => $document->id,
|
|
'document_uuid' => $document->uuid,
|
|
'disk' => $disk,
|
|
'path' => $document->path,
|
|
'normalizedCandidates' => $candidates,
|
|
'public_candidate' => $publicFull,
|
|
]);
|
|
abort(404);
|
|
}
|
|
$nameBase = $document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME);
|
|
$ext = strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION));
|
|
$name = $ext ? ($nameBase.'.'.$ext) : $nameBase;
|
|
$stream = Storage::disk($disk)->readStream($relPath);
|
|
if ($stream === false) {
|
|
logger()->warning('Document download: readStream failed, attempting fallbacks', [
|
|
'document_id' => $document->id,
|
|
'disk' => $disk,
|
|
'relPath' => $relPath,
|
|
]);
|
|
|
|
$headers = [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'attachment; filename="'.addslashes($name).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
];
|
|
|
|
// Fallback 1: get() the bytes directly
|
|
try {
|
|
$bytes = Storage::disk($disk)->get($relPath);
|
|
} catch (\Throwable $e) {
|
|
$bytes = null;
|
|
}
|
|
if (! is_null($bytes) && $bytes !== false) {
|
|
return response($bytes, 200, $headers);
|
|
}
|
|
|
|
// Fallback 2: open via absolute storage path
|
|
$abs = null;
|
|
try {
|
|
if (method_exists(Storage::disk($disk), 'path')) {
|
|
$abs = Storage::disk($disk)->path($relPath);
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$abs = null;
|
|
}
|
|
if ($abs && is_file($abs)) {
|
|
$fp = @fopen($abs, 'rb');
|
|
if ($fp !== false) {
|
|
logger()->info('Document download fallback: serving from absolute storage path', [
|
|
'document_id' => $document->id,
|
|
'abs' => str_replace('\\\\', '/', (string) realpath($abs)),
|
|
]);
|
|
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
// Fallback 3: serve from public path if available
|
|
$publicFull = public_path($relPath);
|
|
$real = @realpath($publicFull);
|
|
$publicRoot = @realpath(public_path());
|
|
$realN = $real ? str_replace('\\\\', '/', $real) : null;
|
|
$rootN = $publicRoot ? str_replace('\\\\', '/', $publicRoot) : null;
|
|
if ($realN && $rootN && str_starts_with($realN, $rootN) && is_file($real)) {
|
|
logger()->info('Document download fallback: serving from public path (post-readStream failure)', [
|
|
'document_id' => $document->id,
|
|
'path' => $realN,
|
|
]);
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp !== false) {
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
logger()->warning('Document download 404: all fallbacks failed after readStream failure', [
|
|
'document_id' => $document->id,
|
|
'disk' => $disk,
|
|
'relPath' => $relPath,
|
|
]);
|
|
abort(404);
|
|
}
|
|
|
|
return response()->stream(function () use ($stream) {
|
|
fpassthru($stream);
|
|
}, 200, [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => 'attachment; filename="'.addslashes($name).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* View a contract document using contract route binding.
|
|
*/
|
|
public function viewContractDocument(Contract $contract, Document $document, Request $request)
|
|
{
|
|
// Ensure the document belongs to this contract (including trashed docs)
|
|
$belongs = $document->documentable_type === Contract::class && $document->documentable_id === $contract->id;
|
|
if (! $belongs) {
|
|
abort(404);
|
|
}
|
|
|
|
// Reuse the existing logic by delegating to a small helper
|
|
return $this->streamDocumentForDisk($document, inline: true);
|
|
}
|
|
|
|
/**
|
|
* Download a contract document using contract route binding.
|
|
*/
|
|
public function downloadContractDocument(Contract $contract, Document $document, Request $request)
|
|
{
|
|
$belongs = $document->documentable_type === Contract::class && $document->documentable_id === $contract->id;
|
|
if (! $belongs) {
|
|
abort(404);
|
|
}
|
|
|
|
return $this->streamDocumentForDisk($document, inline: false);
|
|
}
|
|
|
|
/**
|
|
* Internal helper to stream a document either inline or as attachment with all Windows/public fallbacks.
|
|
*/
|
|
protected function streamDocumentForDisk(Document $document, bool $inline = true)
|
|
{
|
|
$disk = $document->disk ?: 'public';
|
|
$relPath = $document->path ?? '';
|
|
$relPath = str_replace('\\', '/', $relPath);
|
|
$relPath = ltrim($relPath, '/');
|
|
if (str_starts_with($relPath, 'public/')) {
|
|
$relPath = substr($relPath, 7);
|
|
}
|
|
|
|
// Previews for DOC/DOCX
|
|
$ext = strtolower(pathinfo($document->original_name ?: $document->file_name, PATHINFO_EXTENSION));
|
|
$previewDisk = config('files.preview_disk', 'public');
|
|
if ($inline && in_array($ext, ['doc', 'docx'])) {
|
|
if ($document->preview_path && Storage::disk($previewDisk)->exists($document->preview_path)) {
|
|
$stream = Storage::disk($previewDisk)->readStream($document->preview_path);
|
|
if ($stream !== false) {
|
|
$previewNameBase = $document->name ?: pathinfo($document->original_name ?: $document->file_name, PATHINFO_FILENAME);
|
|
|
|
return response()->stream(function () use ($stream) {
|
|
fpassthru($stream);
|
|
}, 200, [
|
|
'Content-Type' => $document->preview_mime ?: 'application/pdf',
|
|
'Content-Disposition' => 'inline; filename="'.addslashes($previewNameBase.'.pdf').'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
]);
|
|
}
|
|
}
|
|
\App\Jobs\GenerateDocumentPreview::dispatch($document->id);
|
|
|
|
return response('Preview is being generated. Please try again shortly.', 202);
|
|
}
|
|
|
|
// Try storage candidates
|
|
$candidates = [$relPath];
|
|
$raw = $document->path ? ltrim(str_replace('\\', '/', $document->path), '/') : null;
|
|
if ($raw && $raw !== $relPath) {
|
|
$candidates[] = $raw;
|
|
}
|
|
if (str_starts_with($relPath, 'storage/')) {
|
|
$candidates[] = substr($relPath, 8);
|
|
}
|
|
if ($raw && str_starts_with($raw, 'storage/')) {
|
|
$candidates[] = substr($raw, 8);
|
|
}
|
|
|
|
$found = null;
|
|
foreach ($candidates as $cand) {
|
|
if (Storage::disk($disk)->exists($cand)) {
|
|
$found = $cand;
|
|
break;
|
|
}
|
|
}
|
|
|
|
$headers = [
|
|
'Content-Type' => $document->mime_type ?: 'application/octet-stream',
|
|
'Content-Disposition' => ($inline ? 'inline' : 'attachment').'; filename="'.addslashes($document->original_name ?: $document->file_name).'"',
|
|
'Cache-Control' => 'private, max-age=0, no-cache',
|
|
'Pragma' => 'no-cache',
|
|
];
|
|
|
|
if (! $found) {
|
|
// public/ fallback
|
|
$publicFull = public_path($relPath);
|
|
$real = @realpath($publicFull);
|
|
$publicRoot = @realpath(public_path());
|
|
$realN = $real ? str_replace('\\\\', '/', $real) : null;
|
|
$rootN = $publicRoot ? str_replace('\\\\', '/', $publicRoot) : null;
|
|
if ($realN && $rootN && str_starts_with($realN, $rootN) && is_file($real)) {
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp !== false) {
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
abort(404);
|
|
}
|
|
|
|
$stream = Storage::disk($disk)->readStream($found);
|
|
if ($stream !== false) {
|
|
return response()->stream(function () use ($stream) {
|
|
fpassthru($stream);
|
|
}, 200, $headers);
|
|
}
|
|
|
|
// Fallbacks on readStream failure
|
|
try {
|
|
$bytes = Storage::disk($disk)->get($found);
|
|
if (! is_null($bytes) && $bytes !== false) {
|
|
return response($bytes, 200, $headers);
|
|
}
|
|
} catch (\Throwable $e) {
|
|
}
|
|
|
|
$abs = null;
|
|
try {
|
|
if (method_exists(Storage::disk($disk), 'path')) {
|
|
$abs = Storage::disk($disk)->path($found);
|
|
}
|
|
} catch (\Throwable $e) {
|
|
$abs = null;
|
|
}
|
|
if ($abs && is_file($abs)) {
|
|
$fp = @fopen($abs, 'rb');
|
|
if ($fp !== false) {
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
// public/ again as last try
|
|
$publicFull = public_path($found);
|
|
$real = @realpath($publicFull);
|
|
if ($real && is_file($real)) {
|
|
$fp = @fopen($real, 'rb');
|
|
if ($fp !== false) {
|
|
return response()->stream(function () use ($fp) {
|
|
fpassthru($fp);
|
|
}, 200, $headers);
|
|
}
|
|
}
|
|
|
|
abort(404);
|
|
}
|
|
|
|
/**
|
|
* Display the specified resource.
|
|
*/
|
|
public function show(ClientCase $clientCase)
|
|
{
|
|
$case = $clientCase::with([
|
|
'person' => fn ($que) => $que->with(['addresses', 'phones', 'emails', 'bankAccounts']),
|
|
])->where('active', 1)->findOrFail($clientCase->id);
|
|
|
|
$types = [
|
|
'address_types' => \App\Models\Person\AddressType::all(),
|
|
'phone_types' => \App\Models\Person\PhoneType::all(),
|
|
];
|
|
|
|
// Optional segment filter from query string
|
|
$segmentId = request()->integer('segment');
|
|
|
|
// Prepare contracts and a reference map
|
|
$contractsQuery = $case->contracts()
|
|
->with(['type', 'account', 'objects', 'segments:id,name'])
|
|
->orderByDesc('created_at');
|
|
|
|
if (! empty($segmentId)) {
|
|
// Filter to contracts that are in the provided segment and active on pivot
|
|
$contractsQuery->whereExists(function ($q) use ($segmentId) {
|
|
$q->from('contract_segment')
|
|
->whereColumn('contract_segment.contract_id', 'contracts.id')
|
|
->where('contract_segment.segment_id', $segmentId)
|
|
->where('contract_segment.active', true);
|
|
});
|
|
}
|
|
|
|
$contracts = $contractsQuery->get();
|
|
$contractRefMap = [];
|
|
foreach ($contracts as $c) {
|
|
$contractRefMap[$c->id] = $c->reference;
|
|
}
|
|
|
|
// Merge client case and contract documents into a single array and include contract reference when applicable
|
|
$contractIds = $contracts->pluck('id');
|
|
$contractDocs = Document::query()
|
|
->where('documentable_type', Contract::class)
|
|
->when($contractIds->isNotEmpty(), fn ($q) => $q->whereIn('documentable_id', $contractIds))
|
|
->orderByDesc('created_at')
|
|
->get()
|
|
->map(function ($d) use ($contractRefMap) {
|
|
$arr = method_exists($d, 'toArray') ? $d->toArray() : (array) $d;
|
|
$arr['contract_reference'] = $contractRefMap[$d->documentable_id] ?? null;
|
|
$arr['documentable_type'] = Contract::class;
|
|
$arr['contract_uuid'] = optional(Contract::withTrashed()->find($d->documentable_id))->uuid;
|
|
|
|
return $arr;
|
|
});
|
|
|
|
$caseDocs = $case->documents()->orderByDesc('created_at')->get()->map(function ($d) use ($case) {
|
|
$arr = method_exists($d, 'toArray') ? $d->toArray() : (array) $d;
|
|
$arr['documentable_type'] = ClientCase::class;
|
|
$arr['client_case_uuid'] = $case->uuid;
|
|
|
|
return $arr;
|
|
});
|
|
$mergedDocs = $caseDocs
|
|
->concat($contractDocs)
|
|
->sortByDesc('created_at')
|
|
->values();
|
|
|
|
// Resolve current segment for display when filtered
|
|
$currentSegment = null;
|
|
if (! empty($segmentId)) {
|
|
$currentSegment = \App\Models\Segment::query()->select('id', 'name')->find($segmentId);
|
|
}
|
|
|
|
return Inertia::render('Cases/Show', [
|
|
'client' => $case->client()->with('person', fn ($q) => $q->with(['addresses', 'phones', 'bankAccounts']))->firstOrFail(),
|
|
'client_case' => $case,
|
|
'contracts' => $contracts,
|
|
'activities' => tap(
|
|
(function () use ($case, $segmentId, $contractIds) {
|
|
$q = $case->activities()
|
|
->with(['action', 'decision', 'contract:id,uuid,reference', 'user:id,name'])
|
|
->orderByDesc('created_at');
|
|
if (! empty($segmentId)) {
|
|
// Only activities for filtered contracts or unlinked (contract_id null)
|
|
$q->where(function ($qq) use ($contractIds) {
|
|
$qq->whereNull('contract_id');
|
|
if ($contractIds->isNotEmpty()) {
|
|
$qq->orWhereIn('contract_id', $contractIds);
|
|
}
|
|
});
|
|
}
|
|
|
|
return $q->paginate(20, ['*'], 'activities')->withQueryString();
|
|
})(),
|
|
function ($p) {
|
|
$p->getCollection()->transform(function ($a) {
|
|
$a->setAttribute('user_name', optional($a->user)->name);
|
|
|
|
return $a;
|
|
});
|
|
}
|
|
),
|
|
'documents' => $mergedDocs,
|
|
'contract_types' => \App\Models\ContractType::whereNull('deleted_at')->get(),
|
|
'account_types' => \App\Models\AccountType::all(),
|
|
'actions' => \App\Models\Action::with('decisions')->get(),
|
|
'types' => $types,
|
|
'segments' => $case->segments()->wherePivot('active', true)->get(['segments.id', 'segments.name']),
|
|
'all_segments' => \App\Models\Segment::query()->where('active', true)->get(['id', 'name']),
|
|
'current_segment' => $currentSegment,
|
|
]);
|
|
}
|
|
|
|
/**
|
|
* Show the form for editing the specified resource.
|
|
*/
|
|
public function edit(string $id)
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Update the specified resource in storage.
|
|
*/
|
|
public function update(Request $request, string $id)
|
|
{
|
|
//
|
|
}
|
|
|
|
/**
|
|
* Remove the specified resource from storage.
|
|
*/
|
|
public function destroy(string $id)
|
|
{
|
|
//
|
|
}
|
|
}
|