719eb1403f
* оптимизация обновления при редактировании спец контингента * добавил поддержку заключительных диагнозов * изменил определение законченной операции * добавил поддержку исхода операции * добавил определение отмены для операции через назначение * работа над диапазонами календарей, подсчет статистики * добавил статусы отчетов и подкорректировал привязку спец контингента к отчету * добавил новые сервисы для будущего кеширования * частичное разделение логики подсчета пациентов
1130 lines
40 KiB
PHP
1130 lines
40 KiB
PHP
<?php
|
||
|
||
namespace App\Http\Controllers\Api;
|
||
|
||
use App\Http\Controllers\Controller;
|
||
use App\Http\Resources\Api\DepartmentPatientOperationResource;
|
||
use App\Http\Resources\Mis\FormattedPatientResource;
|
||
use App\Models\Department;
|
||
use App\Models\MedicalHistorySnapshot;
|
||
use App\Models\MetrikaGroup;
|
||
use App\Models\MetrikaResult;
|
||
use App\Models\MisLpuDoctor;
|
||
use App\Models\MisMKB;
|
||
use App\Models\MisMedicalHistory;
|
||
use App\Models\MisMigrationPatient;
|
||
use App\Models\MisStationarBranch;
|
||
use App\Models\MisSurgicalOperation;
|
||
use App\Models\ObservationPatient;
|
||
use App\Models\Report;
|
||
use App\Models\UnwantedEvent;
|
||
use App\Models\User;
|
||
use App\Services\DateRangeService;
|
||
use App\Services\MisPatientService;
|
||
use App\Services\ReportService;
|
||
use Illuminate\Http\Request;
|
||
use Illuminate\Support\Carbon;
|
||
use Illuminate\Support\Facades\Auth;
|
||
use Illuminate\Support\Facades\Cache;
|
||
use Illuminate\Support\Facades\DB;
|
||
use Illuminate\Support\Facades\Session;
|
||
use Illuminate\Support\Str;
|
||
use Inertia\Inertia;
|
||
|
||
class ReportController extends Controller
|
||
{
|
||
public function __construct(
|
||
protected MisPatientService $misPatientService,
|
||
protected ReportService $reportService,
|
||
protected DateRangeService $dateRangeService)
|
||
{ }
|
||
|
||
public function index(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
$departmentId = $request->query('departmentId', $user->department->department_id);
|
||
$department = Department::where('department_id', $departmentId)->firstOrFail();
|
||
$dateRange = $this->dateRangeService->getDateRangeFromRequest($request, $user);
|
||
$statistics = $this->reportService->getReportStatistics($department, $user, $dateRange);
|
||
$reportInfo = $this->reportService->getCurrentReportInfo($department, $user, $dateRange);
|
||
$metrikaGroup = MetrikaGroup::whereMetrikaGroupId(2)->first();
|
||
$metrikaItems = $metrikaGroup->metrikaItems;
|
||
|
||
return response()->json([
|
||
'department' => [
|
||
'department_id' => $department->department_id,
|
||
'department_name' => $department->name_full,
|
||
'beds' => $department->beds,
|
||
...$statistics,
|
||
],
|
||
'dates' => [
|
||
'startAt' => $dateRange->startTimestamp(),
|
||
'endAt' => $dateRange->endTimestamp(),
|
||
],
|
||
'report' => $reportInfo,
|
||
'metrikaItems' => $metrikaItems,
|
||
'userId' => $reportInfo['userId'],
|
||
'userName' => $reportInfo['userName'],
|
||
]);
|
||
}
|
||
|
||
private function getSurgicalPatientsFromSnapshot(string $type, array $reportIds)
|
||
{
|
||
$count = 0;
|
||
switch ($type) {
|
||
case 'emergency':
|
||
$count = $this->getMetrikaResult(10, $reportIds);
|
||
break;
|
||
case 'plan':
|
||
$count = $this->getMetrikaResult(11, $reportIds);
|
||
break;
|
||
case 'recipient':
|
||
$count = $this->getMetrikaResult(3, $reportIds);
|
||
break;
|
||
}
|
||
|
||
return $count;
|
||
}
|
||
|
||
private function getPatientsCountFromSnapshot(string $type, array $reportIds)
|
||
{
|
||
$count = 0;
|
||
switch ($type) {
|
||
case 'emergency':
|
||
$count = $this->getMetrikaResult(10, $reportIds);
|
||
break;
|
||
case 'plan':
|
||
$count = $this->getMetrikaResult(11, $reportIds);
|
||
break;
|
||
case 'recipient':
|
||
$count = $this->getMetrikaResult(3, $reportIds);
|
||
break;
|
||
case 'outcome':
|
||
$count = $this->getMetrikaResult(7, $reportIds);
|
||
break;
|
||
case 'deceased':
|
||
$count = $this->getMetrikaResult(9, $reportIds);
|
||
break;
|
||
case 'current':
|
||
$count = $this->getMetrikaResult(8, $reportIds);
|
||
break;
|
||
}
|
||
|
||
return $count;
|
||
}
|
||
|
||
private function getMetrikaResult(int $metrikaItemId, array $reportIds)
|
||
{
|
||
$reports = Report::whereIn('report_id', $reportIds)
|
||
->with('metrikaResults')
|
||
->get();
|
||
|
||
$count = 0;
|
||
foreach ($reports as $report) {
|
||
foreach ($report->metrikaResults as $metrikaResult) {
|
||
if ($metrikaResult->rf_metrika_item_id === $metrikaItemId)
|
||
$count += intval($metrikaResult->value) ?? 0;
|
||
}
|
||
}
|
||
|
||
return $count;
|
||
}
|
||
|
||
/**
|
||
* Получить ID поступивших пациентов из снапшотов
|
||
*/
|
||
private function getRecipientIdsFromSnapshots(array $reportIds)
|
||
{
|
||
$recipientIds = MedicalHistorySnapshot::whereIn('rf_report_id', $reportIds)
|
||
->where('patient_type', 'recipient')
|
||
->pluck('rf_medicalhistory_id')
|
||
->unique()
|
||
->toArray();
|
||
|
||
return $recipientIds;
|
||
}
|
||
|
||
public function store(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
$misDepartmentId = $user->department->rf_mis_department_id;
|
||
|
||
$branchId = MisStationarBranch::where('rf_DepartmentID', $misDepartmentId)
|
||
->value('StationarBranchID');
|
||
|
||
// Определяем, является ли пользователь заведующим/администратором
|
||
$isHeadOrAdmin = $user->isHeadOfDepartment() || $user->isAdmin();
|
||
|
||
$data = $request->validate([
|
||
'metrics' => 'required',
|
||
'observationPatients' => 'nullable',
|
||
'departmentId' => 'required|integer',
|
||
'unwantedEvents' => 'nullable|array',
|
||
'startAt' => 'required|integer',
|
||
'endAt' => 'required|integer',
|
||
'userId' => 'required|integer',
|
||
'reportId' => 'nullable'
|
||
]);
|
||
$metrics = $data['metrics'];
|
||
$observationPatients = $data['observationPatients'];
|
||
$unwantedEvents = $data['unwantedEvents'];
|
||
|
||
// Определяем даты в зависимости от роли
|
||
$dateRange = $this->dateRangeService->getDateRangeFromRequest($request, $user);
|
||
|
||
$metriks = [];
|
||
foreach ($metrics as $key => $value) {
|
||
$metrika = new MetrikaResult;
|
||
$metrikaId = (int)Str::replace('metrika_item_', '', $key);
|
||
$metrika->rf_metrika_item_id = $metrikaId;
|
||
$metrika->value = $value;
|
||
|
||
$metriks[] = $metrika;
|
||
}
|
||
|
||
// 1. Плановые
|
||
$planIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'plan',
|
||
$dateRange,
|
||
true,
|
||
true,
|
||
);
|
||
$planCount = $this->reportService->getPatientsCountByStatus($user, 'plan', $dateRange);
|
||
// 2. Экстренные
|
||
$emergencyIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'emergency',
|
||
$dateRange,
|
||
true,
|
||
true,
|
||
);
|
||
$emergencyCount = $this->reportService->getPatientsCountByStatus($user, 'emergency', $dateRange);
|
||
// 3. Выписанные
|
||
$dischargedIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'outcome',
|
||
$dateRange,
|
||
true,
|
||
true
|
||
);
|
||
// 4. Переведенные
|
||
$transferredIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'outcome-transferred',
|
||
$dateRange,
|
||
true,
|
||
true
|
||
);
|
||
// 5. Умершие
|
||
$deceasedIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'outcome-deceased',
|
||
$dateRange,
|
||
true,
|
||
true
|
||
);
|
||
// 6. Поступившие
|
||
$recipientIds = $this->reportService->getPatientsByStatus(
|
||
$user,
|
||
'recipient',
|
||
$dateRange,
|
||
true,
|
||
true
|
||
);
|
||
|
||
\DB::beginTransaction();
|
||
|
||
if (isset($data['reportId']) && $data['reportId']) {
|
||
$report = Report::updateOrCreate(
|
||
[
|
||
'report_id' => $data['reportId']
|
||
],
|
||
[
|
||
'rf_department_id' => $data['departmentId'],
|
||
'rf_user_id' => Auth::user()->id,
|
||
'rf_lpudoctor_id' => $data['userId'],
|
||
'created_at' => $dateRange->endSql(),
|
||
'sent_at' => $dateRange->endSql(),
|
||
'period_start' => $dateRange->startSql(),
|
||
'period_end' => $dateRange->endSql(),
|
||
]
|
||
);
|
||
} else {
|
||
$report = Report::create([
|
||
'rf_department_id' => $data['departmentId'],
|
||
'rf_user_id' => Auth::user()->id,
|
||
'rf_lpudoctor_id' => $data['userId'],
|
||
'created_at' => $dateRange->endSql(),
|
||
'sent_at' => $dateRange->endSql(),
|
||
'period_start' => $dateRange->startSql(),
|
||
'period_end' => $dateRange->endSql(),
|
||
]);
|
||
}
|
||
|
||
if (count($unwantedEvents)) {
|
||
foreach ($unwantedEvents as $unwantedEvent) {
|
||
// Если есть ID - ищем по нему
|
||
if (isset($unwantedEvent['unwanted_event_id']) && $unwantedEvent['unwanted_event_id']) {
|
||
UnwantedEvent::updateOrCreate(
|
||
['unwanted_event_id' => $unwantedEvent['unwanted_event_id']],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'comment' => $unwantedEvent['comment'] ?? '',
|
||
'title' => $unwantedEvent['title'] ?? '',
|
||
'is_visible' => $unwantedEvent['is_visible'] ?? true,
|
||
]
|
||
);
|
||
} else {
|
||
// Если нет ID - создаем новую запись
|
||
UnwantedEvent::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'comment' => $unwantedEvent['comment'] ?? '',
|
||
'title' => $unwantedEvent['title'] ?? '',
|
||
'is_visible' => $unwantedEvent['is_visible'] ?? true,
|
||
]);
|
||
}
|
||
}
|
||
} else {
|
||
$unwantedEvents = $report->unwantedEvents;
|
||
foreach ($unwantedEvents as $unwantedEvent) {
|
||
$unwantedEvent->delete();
|
||
}
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 16
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 16,
|
||
'value' => count($unwantedEvents),
|
||
]
|
||
);
|
||
|
||
foreach ($metriks as $metrika) {
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => $metrika->rf_metrika_item_id
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => $metrika->rf_metrika_item_id,
|
||
'value' => $metrika->value,
|
||
]
|
||
);
|
||
}
|
||
|
||
if (count($observationPatients)) {
|
||
foreach ($observationPatients as $observationPatient) {
|
||
ObservationPatient::updateOrCreate(
|
||
[
|
||
'rf_medicalhistory_id' => $observationPatient['id'],
|
||
'rf_department_id' => $data['departmentId']
|
||
],
|
||
[
|
||
'rf_department_id' => $data['departmentId'],
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $observationPatient['id'],
|
||
'rf_mkab_id' => null,
|
||
'comment' => $observationPatient['comment'] ?? null
|
||
]
|
||
);
|
||
}
|
||
} else {
|
||
foreach ($report->observationPatients as $observationPatient) {
|
||
$observationPatient->delete();
|
||
}
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 14
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 14,
|
||
'value' => count($observationPatients),
|
||
]
|
||
);
|
||
|
||
// Сохраняем снимок для каждого типа пациентов
|
||
// Планово
|
||
//$this->getPlanOrEmergencyPatients('plan', false, $branchId, $dateRange->startSql(), $dateRange->endSql(), false, false, true);
|
||
foreach ($planIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'plan'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 4
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 4,
|
||
'value' => $planCount,
|
||
]
|
||
);
|
||
|
||
//$this->getPlanOrEmergencyPatients('emergency', false, $branchId, $startDate, $endDate, false, false, true);
|
||
// Экстренно
|
||
foreach ($emergencyIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'emergency'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 12
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 12,
|
||
'value' => $emergencyCount,
|
||
]
|
||
);
|
||
|
||
//$this->getDischargedPatients($branchId, $startDate, $endDate, true);
|
||
foreach ($dischargedIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'discharged'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 15,
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 15,
|
||
'value' => count($dischargedIds),
|
||
]
|
||
);
|
||
|
||
//$this->getTransferredPatients($branchId, $startDate, $endDate, true);
|
||
foreach ($transferredIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'transferred'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 13,
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 13,
|
||
'value' => count($transferredIds),
|
||
]
|
||
);
|
||
|
||
//$this->getDeceasedOutcomePatients($branchId, $startDate, $endDate, false, true);
|
||
foreach ($deceasedIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'deceased'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 9,
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 9,
|
||
'value' => count($deceasedIds),
|
||
]
|
||
);
|
||
|
||
// $recipientIds = $this->getPlanOrEmergencyPatients(
|
||
// null,
|
||
// $isHeadOrAdmin,
|
||
// $branchId,
|
||
// $startDate,
|
||
// $endDate,
|
||
// false,
|
||
// true,
|
||
// true,
|
||
// today: true
|
||
// );
|
||
foreach ($recipientIds as $id) {
|
||
MedicalHistorySnapshot::create([
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_medicalhistory_id' => $id,
|
||
'patient_type' => 'recipient'
|
||
]);
|
||
}
|
||
MetrikaResult::updateOrCreate(
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 3,
|
||
],
|
||
[
|
||
'rf_report_id' => $report->report_id,
|
||
'rf_metrika_item_id' => 3,
|
||
'value' => count($recipientIds),
|
||
]
|
||
);
|
||
|
||
// 7. Находящиеся на лечении
|
||
// $currentIds = $this->getCurrentPatients($branchId, false, true);
|
||
// foreach ($currentIds as $id) {
|
||
// MedicalHistorySnapshot::create([
|
||
// 'rf_report_id' => $report->report_id,
|
||
// 'rf_medicalhistory_id' => $id,
|
||
// 'patient_type' => 'current'
|
||
// ]);
|
||
// }
|
||
|
||
\DB::commit();
|
||
|
||
return response()->json([
|
||
'message' => 'success'
|
||
]);
|
||
}
|
||
|
||
public function getPatients(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
|
||
$validated = $request->validate([
|
||
'status' => 'required|string',
|
||
'startAt' => 'nullable',
|
||
'endAt' => 'nullable',
|
||
'departmentId' => 'nullable',
|
||
'page' => 'nullable|integer|min:1',
|
||
'perPage' => 'nullable|integer|min:1|max:1000',
|
||
'search' => 'nullable|string|max:255',
|
||
]);
|
||
|
||
$dateRange = $this->dateRangeService->getDateRangeFromRequest($request, $user);
|
||
|
||
$departmentId = $request->get('departmentId', $user->department->department_id);
|
||
$department = Department::where('department_id', $departmentId)->first();
|
||
$page = (int) ($validated['page'] ?? 1);
|
||
$perPage = (int) ($validated['perPage'] ?? 20);
|
||
$search = trim((string) ($validated['search'] ?? ''));
|
||
|
||
$patients = collect($this->reportService->getPatientsByStatus(
|
||
$department,
|
||
Auth::user(),
|
||
$validated['status'],
|
||
$dateRange
|
||
));
|
||
|
||
if ($search !== '') {
|
||
$needle = mb_strtolower($search);
|
||
$patients = $patients->filter(function ($patient) use ($needle) {
|
||
$fullName = mb_strtolower(trim((string) ($patient->fullname ?? "{$patient->FAMILY} {$patient->Name} {$patient->OT}")));
|
||
$diagnosisCode = mb_strtolower((string) ($patient->mkb['ds'] ?? ''));
|
||
$diagnosisName = mb_strtolower((string) ($patient->mkb['name'] ?? ''));
|
||
|
||
return str_contains($fullName, $needle)
|
||
|| str_contains($diagnosisCode, $needle)
|
||
|| str_contains($diagnosisName, $needle);
|
||
})->values();
|
||
}
|
||
|
||
$total = $patients->count();
|
||
$items = $patients->forPage($page, $perPage)->values();
|
||
$data = FormattedPatientResource::collection($items)->resolve();
|
||
|
||
return response()->json([
|
||
'data' => $data,
|
||
'meta' => [
|
||
'total' => $total,
|
||
'page' => $page,
|
||
'perPage' => $perPage,
|
||
'lastPage' => max((int) ceil($total / max($perPage, 1)), 1),
|
||
],
|
||
]);
|
||
}
|
||
|
||
public function getPatientsCount(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
|
||
$validated = $request->validate([
|
||
'status' => 'required|string',
|
||
'startAt' => 'nullable',
|
||
'endAt' => 'nullable',
|
||
'departmentId' => 'nullable'
|
||
]);
|
||
|
||
$dateRange = $this->dateRangeService->getDateRangeFromRequest($request, $user);
|
||
|
||
$departmentId = $request->get('departmentId', $user->department->department_id);
|
||
$department = Department::where('department_id', $departmentId)->first();
|
||
|
||
$count = $this->reportService->getPatientsCountByStatus(
|
||
$department,
|
||
$user,
|
||
$validated['status'],
|
||
$dateRange,
|
||
);
|
||
|
||
return response()->json($count);
|
||
}
|
||
|
||
public function getPatientsCounts(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
|
||
$request->validate([
|
||
'startAt' => 'nullable',
|
||
'endAt' => 'nullable',
|
||
'departmentId' => 'nullable',
|
||
'force' => 'nullable|boolean',
|
||
]);
|
||
|
||
$dateRange = $this->dateRangeService->getDateRangeFromRequest($request, $user);
|
||
$departmentId = $request->get('departmentId', $user->department->department_id);
|
||
$department = Department::where('department_id', $departmentId)->firstOrFail();
|
||
|
||
$cacheKey = sprintf(
|
||
'report:patients-counts:%d:%d:%s:%s',
|
||
$user->id,
|
||
$department->department_id,
|
||
$dateRange->startSql(),
|
||
$dateRange->endSql()
|
||
);
|
||
|
||
$force = (bool) $request->boolean('force', false);
|
||
|
||
if ($force) {
|
||
$counts = $this->reportService->getPatientsCountsMap($department, $user, $dateRange);
|
||
Cache::put($cacheKey, $counts, now()->addSeconds(30));
|
||
} else {
|
||
$counts = Cache::remember($cacheKey, now()->addSeconds(30), function () use ($department, $user, $dateRange) {
|
||
return $this->reportService->getPatientsCountsMap($department, $user, $dateRange);
|
||
});
|
||
}
|
||
|
||
return response()->json([
|
||
'counts' => $counts,
|
||
]);
|
||
}
|
||
|
||
/**
|
||
* Получить пациентов (плановых или экстренных)
|
||
*/
|
||
private function getPlanOrEmergencyPatients(
|
||
?string $status,
|
||
bool $isHeadOrAdmin,
|
||
$branchId,
|
||
$startDate, $endDate,
|
||
bool $returnedCount = false,
|
||
bool $all = false,
|
||
bool $onlyIds = false,
|
||
bool $today = false
|
||
) {
|
||
// Определяем, является ли статус outcome
|
||
$isOutcomeStatus = in_array($status, ['outcome-transferred', 'outcome-discharged', 'outcome-deceased']);
|
||
|
||
if ($isOutcomeStatus) {
|
||
$visitResultIds = match ($status) {
|
||
'outcome-transferred' => [4, 14],
|
||
'outcome-discharged' => [1, 11, 2, 12, 7, 18, 48],
|
||
'outcome-deceased' => [5, 6, 15, 16],
|
||
default => [],
|
||
};
|
||
|
||
$historyQuery = $this->buildOutcomeMedicalHistoryQuery(
|
||
$branchId,
|
||
$startDate,
|
||
$endDate,
|
||
$visitResultIds
|
||
);
|
||
|
||
if ($onlyIds) {
|
||
return $historyQuery->pluck('MedicalHistoryID')->values();
|
||
}
|
||
|
||
if ($returnedCount) {
|
||
return $historyQuery->count();
|
||
}
|
||
|
||
return $historyQuery
|
||
->with(['surgicalOperations' => function ($query) use ($startDate, $endDate) {
|
||
$query->where('Date', '>=', $startDate)
|
||
->where('Date', '<=', $endDate);
|
||
}])
|
||
->orderBy('DateRecipient', 'DESC')
|
||
->get();
|
||
} else {
|
||
// Разная логика для заведующего и врача
|
||
if ($isHeadOrAdmin) {
|
||
// Заведующий: используем whereInDepartment
|
||
$query = MisMigrationPatient::whereInDepartment($branchId)
|
||
// ->whereBetween('DateIngoing', [$startDate, $endDate]);
|
||
->where('DateIngoing', '>=', $startDate)
|
||
->where('DateIngoing', '<=', $endDate);
|
||
} else {
|
||
// Врач: используем currentlyInTreatment + фильтр по дате
|
||
$query = MisMigrationPatient::currentlyInTreatment($branchId)
|
||
->when($today, function ($query) use ($startDate, $endDate) {
|
||
// return $query->whereBetween('DateIngoing', [$startDate, $endDate]);
|
||
return $query->where('DateIngoing', '>=', $startDate)
|
||
->where('DateIngoing', '<=', $endDate);
|
||
});
|
||
}
|
||
}
|
||
|
||
$medicalHistoryIds = $query->pluck('rf_MedicalHistoryID')->toArray();
|
||
|
||
if (empty($medicalHistoryIds)) {
|
||
if ($returnedCount) return 0;
|
||
return collect();
|
||
}
|
||
|
||
// Получаем истории
|
||
$query = MisMedicalHistory::whereIn('MedicalHistoryID', $medicalHistoryIds)
|
||
->with(['surgicalOperations' => function ($query) use ($startDate, $endDate) {
|
||
// $query->whereBetween('Date', [$startDate, $endDate]);
|
||
$query->where('Date', '>=', $startDate)
|
||
->where('Date', '<=', $endDate);
|
||
}])
|
||
->orderBy('DateRecipient', 'DESC');
|
||
|
||
// Выбираем план или экстренность
|
||
if (!$all && !$isOutcomeStatus) {
|
||
if ($status === 'plan') {
|
||
$query->plan();
|
||
} else if ($status === 'emergency') {
|
||
$query->emergency();
|
||
}
|
||
}
|
||
|
||
// Для врача добавляем условие "в отделении"
|
||
if (!$isHeadOrAdmin && !$isOutcomeStatus) {
|
||
$query->currentlyHospitalized();
|
||
}
|
||
|
||
if ($onlyIds) {
|
||
return $query->select('MedicalHistoryID')
|
||
->pluck('MedicalHistoryID')->values();
|
||
} else {
|
||
if ($returnedCount) return $query->count();
|
||
else return $query->get();
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Получить всех выбывших пациентов
|
||
*/
|
||
private function getAllOutcomePatients($branchId, $startDate, $endDate, bool $returnedCount = false)
|
||
{
|
||
$query = $this->buildOutcomeMedicalHistoryQuery($branchId, $startDate, $endDate);
|
||
|
||
if ($returnedCount) {
|
||
return $query->count();
|
||
}
|
||
|
||
return $query
|
||
->with(['surgicalOperations'])
|
||
->orderBy('DateRecipient', 'DESC')
|
||
->get();
|
||
}
|
||
|
||
/**
|
||
* Получить понятное название типа выбытия
|
||
*/
|
||
private function getOutcomeTypeName($visitResultId): string
|
||
{
|
||
return match($visitResultId) {
|
||
1, 7, 8, 9, 10, 11, 48, 49, 124 => 'Выписка',
|
||
2, 3, 4, 12, 13, 14 => 'Перевод',
|
||
5, 6, 15, 16 => 'Умер',
|
||
// Добавьте другие коды по мере необходимости
|
||
default => 'Другое (' . $visitResultId . ')'
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Получить умерших пациентов (исход)
|
||
*/
|
||
private function getDeceasedOutcomePatients($branchId, $startDate, $endDate, bool $returnedCount = false, bool $onlyIds = false)
|
||
{
|
||
$query = $this->buildOutcomeMedicalHistoryQuery(
|
||
$branchId,
|
||
$startDate,
|
||
$endDate,
|
||
[5, 6, 15, 16]
|
||
);
|
||
|
||
if ($onlyIds) {
|
||
return $query->pluck('MedicalHistoryID')->values();
|
||
}
|
||
|
||
if ($returnedCount) return $query->count();
|
||
else return $query
|
||
->with(['surgicalOperations'])
|
||
->orderBy('DateRecipient', 'DESC')
|
||
->get();
|
||
}
|
||
|
||
private function buildOutcomeMedicalHistoryQuery(
|
||
int $branchId,
|
||
string $startDate,
|
||
string $endDate,
|
||
?array $visitResultIds = null
|
||
)
|
||
{
|
||
$startDateOnly = Carbon::parse($startDate)->toDateString();
|
||
$endDateOnly = Carbon::parse($endDate)->toDateString();
|
||
|
||
return MisMedicalHistory::query()
|
||
->where('MedicalHistoryID', '<>', 0)
|
||
->whereDate('DateExtract', '>', $startDateOnly)
|
||
->whereDate('DateExtract', '<=', $endDateOnly)
|
||
->whereHas('migrations', function ($migrationQuery) use ($branchId, $visitResultIds) {
|
||
$migrationQuery->where('rf_StationarBranchID', $branchId);
|
||
|
||
if ($visitResultIds !== null && !empty($visitResultIds)) {
|
||
$migrationQuery->whereIn('rf_kl_VisitResultID', $visitResultIds);
|
||
}
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Получить пациентов с операциями
|
||
*/
|
||
private function getSurgicalPatients(string $status, bool $isHeadOrAdmin, $branchId, $startDate, $endDate, bool $returnedCount = false)
|
||
{
|
||
$query = MisSurgicalOperation::where('rf_StationarBranchID', $branchId)
|
||
->completed()
|
||
// ->whereBetween('Date', [$startDate, $endDate])
|
||
->where('Date', '>=', $startDate)
|
||
->where('Date', '<=', $endDate)
|
||
->orderBy('Date', 'DESC');
|
||
|
||
if ($status === 'plan') {
|
||
$query->where('rf_TypeSurgOperationInTimeID', 6);
|
||
} else {
|
||
$query->whereIn('rf_TypeSurgOperationInTimeID', [4, 5]);
|
||
}
|
||
|
||
|
||
if ($returnedCount) return $query->count();
|
||
else return $query->get();
|
||
}
|
||
|
||
/**
|
||
* Находятся на лечении
|
||
*/
|
||
private function getCurrentPatients($branchId, bool $returnedCount = false, bool $onlyIds = false)
|
||
{
|
||
// $currentCount = MisMedicalHistory::whereIn('MedicalHistoryID', $medicalHistoryIds)
|
||
// ->currentlyHospitalized()
|
||
// ->orderBy('DateRecipient', 'DESC')
|
||
// ->count();
|
||
$medicalHistoryIds = MisMigrationPatient::currentlyInTreatment($branchId)
|
||
->pluck('rf_MedicalHistoryID')
|
||
->unique()
|
||
->toArray();
|
||
|
||
if (empty($medicalHistoryIds)) {
|
||
if ($returnedCount) return 0;
|
||
return collect();
|
||
}
|
||
|
||
if ($onlyIds) return $medicalHistoryIds;
|
||
|
||
$patients = MisMedicalHistory::whereIn('MedicalHistoryID', $medicalHistoryIds)
|
||
->currentlyHospitalized()
|
||
->with(['surgicalOperations'])
|
||
->orderBy('DateRecipient', 'DESC');
|
||
|
||
if ($returnedCount) return $patients->count();
|
||
else return $patients->get();
|
||
}
|
||
|
||
public function removeObservation(
|
||
Request $request,
|
||
) {
|
||
$data = $request->validate([
|
||
'id' => 'required|string'
|
||
]);
|
||
|
||
$this->reportService->removeObservationPatient($data['id']);
|
||
|
||
return response()->json()->setStatusCode(200);
|
||
}
|
||
|
||
public function createManualPatient(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
$data = $request->validate([
|
||
'departmentId' => 'required|integer',
|
||
'report_id' => 'nullable|integer',
|
||
'startAt' => 'required_without:report_id',
|
||
'endAt' => 'required_without:report_id',
|
||
'user_id' => 'nullable|integer',
|
||
'full_name' => 'required|string|max:255',
|
||
'birth_date' => 'required|date',
|
||
'patient_kind' => 'required|in:plan,emergency',
|
||
'diagnosis_code' => 'nullable|string|max:255',
|
||
'diagnosis_name' => 'nullable|string|max:1000',
|
||
'admitted_at' => 'nullable|date',
|
||
]);
|
||
|
||
$department = Department::where('department_id', $data['departmentId'])->firstOrFail();
|
||
$patient = $this->reportService->createManualPatient($department, $user, $data);
|
||
|
||
return response()->json([
|
||
'patient' => $patient,
|
||
'report_id' => $patient->rf_report_id,
|
||
], 201);
|
||
}
|
||
|
||
public function setManualPatientOutcome(Request $request, int $departmentPatientId)
|
||
{
|
||
$user = Auth::user();
|
||
$data = $request->validate([
|
||
'outcome_type' => 'required|in:discharged,transferred,deceased',
|
||
'outcome_at' => 'nullable|date',
|
||
]);
|
||
|
||
return response()->json(
|
||
$this->reportService->setManualPatientOutcome($user, $departmentPatientId, $data)
|
||
);
|
||
}
|
||
|
||
public function updateManualPatient(Request $request, int $departmentPatientId)
|
||
{
|
||
$user = Auth::user();
|
||
|
||
$data = $request->validate([
|
||
'full_name' => 'required|string|max:255',
|
||
'birth_date' => 'required|date',
|
||
'patient_kind' => 'required|in:plan,emergency',
|
||
'manual_status' => 'nullable|in:current,discharged,deceased',
|
||
'outcome_at' => 'nullable|date',
|
||
'diagnosis_code' => 'nullable|string|max:255',
|
||
'diagnosis_name' => 'nullable|string|max:1000',
|
||
'admitted_at' => 'nullable|date',
|
||
'startAt' => 'nullable',
|
||
'endAt' => 'nullable',
|
||
]);
|
||
|
||
return response()->json(
|
||
$this->reportService->updateManualPatient(
|
||
$user,
|
||
$departmentPatientId,
|
||
$data
|
||
)
|
||
);
|
||
}
|
||
|
||
public function linkManualPatient(Request $request, int $departmentPatientId)
|
||
{
|
||
$data = $request->validate([
|
||
'medical_history_id' => 'required|integer',
|
||
]);
|
||
|
||
return response()->json(
|
||
$this->reportService->linkManualPatientToMis($departmentPatientId, $data['medical_history_id'])
|
||
);
|
||
}
|
||
|
||
public function getManualPatientOperations(int $departmentPatientId)
|
||
{
|
||
$user = Auth::user();
|
||
$operations = $this->reportService->getManualPatientOperations($user, $departmentPatientId);
|
||
|
||
return response()->json(
|
||
DepartmentPatientOperationResource::collection($operations)
|
||
);
|
||
}
|
||
|
||
public function createManualPatientOperation(Request $request, int $departmentPatientId)
|
||
{
|
||
$user = Auth::user();
|
||
$data = $request->validate([
|
||
'service_id' => 'required|integer',
|
||
'urgency' => 'required|in:plan,emergency',
|
||
'started_at' => 'required|date',
|
||
'ended_at' => 'required|date|after_or_equal:started_at',
|
||
]);
|
||
|
||
$operation = $this->reportService->createManualPatientOperation($user, $departmentPatientId, $data);
|
||
|
||
return response()->json(new DepartmentPatientOperationResource($operation), 201);
|
||
}
|
||
|
||
public function updateManualPatientOperation(Request $request, int $departmentPatientId, int $operationId)
|
||
{
|
||
$user = Auth::user();
|
||
$data = $request->validate([
|
||
'service_id' => 'required|integer',
|
||
'urgency' => 'required|in:plan,emergency',
|
||
'started_at' => 'required|date',
|
||
'ended_at' => 'required|date|after_or_equal:started_at',
|
||
]);
|
||
|
||
$operation = $this->reportService->updateManualPatientOperation($user, $departmentPatientId, $operationId, $data);
|
||
|
||
return response()->json(new DepartmentPatientOperationResource($operation));
|
||
}
|
||
|
||
public function deleteManualPatientOperation(int $departmentPatientId, int $operationId)
|
||
{
|
||
$user = Auth::user();
|
||
$this->reportService->deleteManualPatientOperation($user, $departmentPatientId, $operationId);
|
||
|
||
return response()->json()->setStatusCode(204);
|
||
}
|
||
|
||
public function searchMisPatients(Request $request)
|
||
{
|
||
$data = $request->validate([
|
||
'departmentId' => 'required|integer',
|
||
'query' => 'required|string|min:2',
|
||
]);
|
||
|
||
$department = Department::where('department_id', $data['departmentId'])->firstOrFail();
|
||
$patients = $this->reportService->searchMisPatientsForDepartment($department, $data['query']);
|
||
|
||
return response()->json(FormattedPatientResource::collection($patients));
|
||
}
|
||
|
||
public function searchMkb(Request $request)
|
||
{
|
||
$data = $request->validate([
|
||
'query' => 'required|string|min:1|max:255',
|
||
]);
|
||
|
||
$query = trim($data['query']);
|
||
$needle = mb_strtolower($query, 'UTF-8');
|
||
$like = "%{$needle}%";
|
||
|
||
$items = MisMKB::query()
|
||
->select(['MKBID', 'DS', 'NAME'])
|
||
->where(function ($builder) use ($like) {
|
||
$builder->whereRaw('LOWER("DS") LIKE ?', [$like])
|
||
->orWhereRaw('LOWER("NAME") LIKE ?', [$like]);
|
||
})
|
||
->orderBy('DS')
|
||
->limit(30)
|
||
->get()
|
||
->map(fn (MisMKB $item) => [
|
||
'id' => $item->MKBID,
|
||
'code' => $item->DS,
|
||
'name' => $item->NAME,
|
||
'label' => trim(($item->DS ? "{$item->DS} " : '') . ($item->NAME ?? '')),
|
||
])
|
||
->values();
|
||
|
||
return response()->json($items);
|
||
}
|
||
|
||
public function searchMedicalServices(Request $request)
|
||
{
|
||
$data = $request->validate([
|
||
'query' => 'required|string|min:2|max:255',
|
||
]);
|
||
|
||
$query = trim($data['query']);
|
||
|
||
$items = \App\Models\MisServiceMedical::query()
|
||
->select(['ServiceMedicalID', 'ServiceMedicalCode', 'ServiceMedicalName'])
|
||
->where(function ($builder) use ($query) {
|
||
$builder->where('ServiceMedicalCode', 'like', "%{$query}%")
|
||
->orWhere('ServiceMedicalName', 'like', "%{$query}%");
|
||
})
|
||
->orderBy('ServiceMedicalCode')
|
||
->limit(30)
|
||
->get()
|
||
->map(fn (\App\Models\MisServiceMedical $item) => [
|
||
'id' => $item->ServiceMedicalID,
|
||
'code' => $item->ServiceMedicalCode,
|
||
'name' => $item->ServiceMedicalName,
|
||
'label' => trim(($item->ServiceMedicalCode ? "{$item->ServiceMedicalCode} " : '') . ($item->ServiceMedicalName ?? '')),
|
||
])
|
||
->values();
|
||
|
||
return response()->json($items);
|
||
}
|
||
|
||
|
||
|
||
// api/report/unwanted-event
|
||
public function removeUnwantedEvent(UnwantedEvent $unwantedEvent, Request $request)
|
||
{
|
||
$unwantedEvent->delete();
|
||
|
||
return response()->json()->setStatusCode(200);
|
||
}
|
||
|
||
public function getDepartmentUsers(Request $request)
|
||
{
|
||
$user = Auth::user();
|
||
|
||
$departmentId = $user->department->rf_mis_department_id;
|
||
|
||
$users = MisLpuDoctor::select(['LPUDoctorID', 'FAM_V', 'IM_V', 'OT_V'])
|
||
->whereHas('prvds', function ($query) use ($departmentId) {
|
||
$query->where('rf_DepartmentID', $departmentId)
|
||
->whereDate('D_END', '2222-01-01 00:00:00.000000');
|
||
})
|
||
->active()
|
||
->whereNotIn('LPUDoctorID', [0, 1])
|
||
->orderBy('FAM_V')
|
||
->get();
|
||
|
||
return response()->json([
|
||
...$users
|
||
])->setStatusCode(200);
|
||
}
|
||
|
||
/**
|
||
* Получить все отчеты в промежутке дат (для агрегации данных)
|
||
*/
|
||
private function getReportsForDateRange($departmentId, $startDate, $endDate)
|
||
{
|
||
if (Carbon::parse($startDate)->diffInDays(Carbon::parse($endDate)) > 1.0)
|
||
return Report::where('rf_department_id', $departmentId)
|
||
->withinPeriod($startDate, $endDate)
|
||
->orderBy('period_end', 'ASC')
|
||
->get();
|
||
else
|
||
return Report::where('rf_department_id', $departmentId)
|
||
->exactPeriod($startDate, $endDate)
|
||
->orderBy('period_end', 'ASC')
|
||
->get();
|
||
}
|
||
|
||
public function checkReport(Request $request)
|
||
{
|
||
$request->validate([
|
||
'department_id' => 'required|integer|exists:departments,department_id'
|
||
]);
|
||
|
||
$report = Report::where('rf_department_id', $request->department_id)
|
||
->exactPeriod(now('Asia/Yakutsk')->subDay()->setTime(7, 0)->format('Y-m-d H:i:s'), now('Asia/Yakutsk')->setTime(7, 0)->format('Y-m-d H:i:s'))
|
||
->first();
|
||
|
||
return response()->json([
|
||
'report_id' => $report?->report_id,
|
||
'exists' => (bool) $report
|
||
]);
|
||
}
|
||
}
|