signalytic/streamline-emr
1
0
Fork 0
mirror of https://gitlab.com/signalytic/client-external/streamline/streamline-emr.git synced 2026-09-12 03:01:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

resolved conflicts

Browse Source
This commit is contained in:
admin
2025-03-31 03:46:05 +03:00
parent b0a69145d7 c7fdd2968a
commit 2dc2287379
6454 changed files with 1520539 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docker/statistics/Modules/PatientDiscounts/Http/Controllers/DiscountController.php
Executable
+588
View File
@@ -0,0 +1,588 @@
<?php
namespace Modules\PatientDiscounts\Http\Controllers;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Streamline\Models\DependantsConsumption;
use Streamline\Models\HospitalInformation;
use Streamline\Models\OrderedInvestigation;
use Streamline\Models\OrderedProcedure;
use Streamline\Models\OrderedService;
use Streamline\Models\OrderedSundry;
use Streamline\Models\Patient;
use Streamline\Models\PatientCategory;
use Streamline\Models\PatientCategoryInvoice;
use Streamline\Models\PatientDiscount;
use Streamline\Models\ChartOfAccount;
use Illuminate\Support\Facades\Validator;
use Streamline\Models\CategoryPatientDependant;
use Carbon\Carbon;
use Streamline\Models\TrackInvoice;
use Streamline\Models\Treatment;
class DiscountController extends Controller {
public function __construct() {
$this->middleware('auth');
$this->middleware('permission:discount-list', ['only' => ['index']]);
$this->middleware('permission:discount-create', ['only' => ['create', 'store']]);
$this->middleware('permission:discount-edit', ['only' => ['edit', 'update']]);
}
/**
* Display a listing of the resource.
*
*/
public function index(){
$discounts = PatientDiscount::orderBy('patient_category', 'asc')
->paginate(50);
$categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id")->toArray();
return view('patient_discounts::discounts.index',compact('discounts','categories'));
}
/**
* Show the form for creating a new resource.
*
*/
public function create(){
// make sure that patient discounts are not repeated
$exiting_discount = PatientDiscount::all()->pluck('patient_category')->toArray();
$categories = PatientCategory::whereNotIn('id',$exiting_discount)->pluck("name", "id")->toArray();
$categories = ['' => '- select -'] + $categories;
$expense_accounts = ChartOfAccount::where('type', 2)->pluck('name', 'id')->prepend('-select-', '')->toArray();
return view('patient_discounts::discounts.create',compact('categories', 'expense_accounts'));
}
/**
* Store a newly created resource in storage.
*
*/
public function store(Request $request){
request()->validate([
'patient_category' => 'required',
'pay_later' => 'required'
]);
$patient_category_discount = new PatientDiscount;
$patient_category_discount->patient_category = $request->patient_category;
$patient_category_discount->discount = $request->discount;
$patient_category_discount->pay_later = $request->pay_later;
if ($request->is_pay_later_threshold_discount == "1") {
$patient_category_discount->threshold_type = $request->threshold_type;
$patient_category_discount->threshold_amount = $request->threshold_amount;
}
$patient_category_discount->co_payment = $request->co_payment;
$patient_category_discount->co_payment_share = $request->co_payment_share;
$patient_category_discount->tracking_expense_account = $request->tracking_expense_account;
$patient_category_discount->created_by = Auth::id();
if ($patient_category_discount->save()) {
flash('new patient discount saved')->success();
return redirect('/discounts/');
}
}
/**
* Display the specified resource.
*
* @param int $id
* @return \Illuminate\Http\Response
*/
public function show($id)
{
//
}
/**
* Show the form for editing the specified resource.
*
* @param int $id
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
*/
public function edit($id){
$discount = PatientDiscount::find($id);
$categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id")->toArray();
$expense_accounts = ChartOfAccount::where('type', 2)->pluck('name', 'id')->prepend('-select-', '')->toArray();
return view('patient_discounts::discounts.edit',compact('discount','categories', 'id', 'expense_accounts'));
}
/**
* Update the specified resource in storage.
*
* @param \Illuminate\Http\Request $request
* @param int $id
*/
public function update(Request $request) {
$validator = Validator::make($request->all(), [
'discount' => 'required',
'pay_later' => 'required'
]);
if ($validator->fails()) {
$string = "";
foreach ($validator->errors()->getMessages() as $item) {
$string .= "{$item[0]}<br>";
}
flash($string)->error();
return back()->withErrors($validator)->withInput();
} else {
$patient_category_discount = PatientDiscount::find($request->id);
$patient_category_discount->discount = $request->discount;
$patient_category_discount->pay_later = $request->pay_later;
$patient_category_discount->updated_by = $request->discount;
if ($patient_category_discount->pay_later == 0) {
$request->is_pay_later_threshold_discount = 0;
$request->co_payment = 0;
}
if ($request->is_pay_later_threshold_discount == 1) {
$patient_category_discount->threshold_type = $request->threshold_type;
$patient_category_discount->threshold_amount = $request->threshold_amount;
} else {
$patient_category_discount->threshold_type = NULL;
$patient_category_discount->threshold_amount = NULL;
}
if ($request->track_discounts == 1 || $request->is_pay_later_threshold_discount == 1) {
$patient_category_discount->tracking_expense_account = $request->tracking_expense_account;
} else {
$patient_category_discount->tracking_expense_account = NULL;
}
$patient_category_discount->co_payment = $request->co_payment;
if ($request->co_payment == 1) {
$patient_category_discount->co_payment_share = $request->co_payment_share;
} else {
$patient_category_discount->co_payment_share = 0;
}
if ($patient_category_discount->update()) {
flash('Patient discount has been updated')->success();
} else {
flash("An error occurred!")->error();
}
return redirect('/discounts/');
}
}
/**
* Remove the specified resource from storage.
*
* @param int $id
*/
public function destroy($id) {
if (PatientDiscount::destroy($id)) {
flash("Patient discount has been deleted.")->success();
return redirect('/discounts/');
} else {
flash("Patient discount failed to deleted.")->error();
return redirect('/discounts/');
}
}
/**
* Display a listing of the inactive resource(s).
*
*/
public function inactive() {
$discounts = PatientDiscount::onlyTrashed()
->orderBy('patient_category', 'asc')
->paginate(50);
$categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id")->toArray();
if (count($discounts) < 1) {
flash()->error("There is no inactive discount");
return redirect('/discounts/');
} else {
return view('patient_discounts::discounts.inactive', compact('discounts', 'categories'));
}
}
/**
* Activate the specified resource in storage.
*
* @param int $id
*/
public function activate($id) {
$discount = PatientDiscount::withTrashed()->find($id);
if($discount->restore()){
flash("Patient discount has been activated.")->success();
return redirect('/discounts/inactive');
} else {
flash("Patient discount failed to activate.")->error();
return redirect('/discounts/inactive');
}
}
public function edit_insured_drugs($patient_category_id) {
$drugs = DB::table('drugs')->whereNull('deleted_at')->get(['id', 'name', 'patient_category_coverage']);
return view('patient_discounts::discounts.edit_insured_drugs', compact('drugs', 'patient_category_id'));
}
public function store_edited_insured_drugs(Request $request) {
$is_covered = $request->is_covered;
$current_covered = is_null($request->current_covered) ? [] : $request->current_covered;
$removed_coverage = array_diff($current_covered, $is_covered);
foreach ($is_covered as $value) {
$current_coverages = get_name($value, 'id', 'patient_category_coverage', 'drugs');
if ($current_coverages != 'N/A') {
if (is_null($current_coverages) || $current_coverages == "") {
$current_coverages_array = [];
} else {
$current_coverages_array = explode(",", $current_coverages);
// check if the id is already in the array and just chill
if (in_array($request->patient_category_id, $current_coverages_array)) {
continue;
}
}
$current_coverages_array[] = $request->patient_category_id;
DB::table('drugs')->where('id', $value)->update(['patient_category_coverage' => implode(",", $current_coverages_array)]);
}
}
foreach ($removed_coverage as $value) {
$current_coverages = get_name($value, 'id', 'patient_category_coverage', 'drugs');
if ($current_coverages != 'N/A') {
$current_coverages_array = explode(",", $current_coverages);
if (in_array($request->patient_category_id, $current_coverages_array)) {
unset($current_coverages_array[array_search($request->patient_category_id, $current_coverages_array)]);
}
DB::table('drugs')->where('id', $value)->update(['patient_category_coverage' => implode(",", $current_coverages_array)]);
}
}
flash("Drug coverages have been updated")->success();
return redirect('/discounts/edit_insured_drugs/' . $request->patient_category_id);
}
public function add_category_patient_dependants(Request $request)
{
$discount_id = $request->discount_id;
$patient_discount = PatientDiscount::find($discount_id);
$patient_category_patients = Patient::where('category_id', $patient_discount->patient_category)->orderBy('first_name', 'asc')->get();
/*
$patient_category_patients = DB::table("patients")->select('*')->where('category_id', $patient_discount->patient_category)->whereRaw('!FIND_IN_SET(id,'.function($query) {
$query->select('dependant_patient_ids')->from('category_patient_dependants');
}.')')->get();
*/
return view('patient_discounts::discounts.patient_category_patients', compact('patient_discount','patient_category_patients'));
}
/*
* Display blade to enable adding dependants to a main category patient
*/
public function add_dependants_to_category_patient(Request $request)
{
$patient_id = $request->patient_id;
$patient_category_id = $request->patient_category;
$patient_discount_id = $request->patient_discount_id;
$patient = Patient::find($patient_id);
$patients_array = [];//Patient::all(['id', 'first_name', 'last_name'])->where('category_id', 1)->pluck("full_name", "id")->toArray();
return view('patient_discounts::discounts.add_dependants_to_category_patient', compact('patient_id','patient_discount_id','patient_category_id','patient','patients_array'));
}
/*
* Store the added dependants
*/
public function store_dependants_to_category_patient(Request $request)
{
//check to make sure that the dependants are not attached to another dependant or even are the main patients
$all_main_patients_array = CategoryPatientDependant::pluck('main_patient_id')->toArray();
$patient_dependants_array = is_null($request->dependants) ? [] : $request->dependants;
for ($i=0; $i < count($patient_dependants_array) ; $i++) {
if (in_array($patient_dependants_array[$i],$all_main_patients_array)) {
flash('Patient <b>'.get_full_name($patient_dependants_array[$i], "id", "first_name", "last_name", "patients").'</b> is already a main patient and so can not be another person\'s dependant ')->error();
return redirect('discounts');
}
$all_dependants = CategoryPatientDependant::whereRaw('FIND_IN_SET(' . $patient_dependants_array[$i] . ',dependant_patient_ids)')->get();
if (count($all_dependants)) {
$patient_is_a_dependant_of = patient_is_a_dependant_of($patient_dependants_array[$i]);
if (!is_null($patient_is_a_dependant_of) && ($patient_is_a_dependant_of != $request->patient_id)) {
flash('Patient <b>'.get_full_name($patient_dependants_array[$i], "id", "first_name", "last_name", "patients").'</b> is already a dependant of someone else')->error();
return redirect('discounts');
}
}
//make sure that they are not configured to the same category
$main_patient_category = get_name($request->patient_id, "id", "category_id", "patients");
$dependant_patient_category = get_name($patient_dependants_array[$i], "id", "category_id", "patients");
if ($main_patient_category == $dependant_patient_category) {
flash('Patient <b>'.get_full_name($patient_dependants_array[$i], "id", "first_name", "last_name", "patients").'</b> belongs to the same patient category. Both the dependant and dependee can not belong to the same category')->error();
return redirect('discounts');
}
}
$patient = Patient::find($request->patient_id);
$patient_category_id = $request->patient_category_id;
$start_date = is_null($request->start_date) ? null : Carbon::createFromFormat('d/m/Y', $request->start_date)->toDateString();
$patient_category_depedants_record = CategoryPatientDependant::where('main_patient_id', $request->patient_id)->get();
if (count($patient_category_depedants_record) > 0) {
$patient_category_depedants = $patient_category_depedants_record->first();
$patient_category_depedants->main_patient_id = $request->patient_id;
$patient_category_depedants->dependant_patient_ids = implode(",", $patient_dependants_array);
$patient_category_depedants->patient_category_id = $patient_category_id;
$patient_category_depedants->start_date = $start_date;
$duration = 0;
$duration = get_name($patient_category_id, "patient_category", "threshold_type", "patient_discounts");
if ($duration == 2) {
$duration = 12; //12 months
}
if ($duration == 1) {
$duration = 1; //1 month
}
$patient_category_depedants->duration = $duration;
$patient_category_depedants->update();
} else {
$patient_category_depedants = new CategoryPatientDependant;
$patient_category_depedants->main_patient_id = $request->patient_id;
$patient_category_depedants->dependant_patient_ids = implode(",", $patient_dependants_array);
$patient_category_depedants->patient_category_id = $patient_category_id;
$patient_category_depedants->start_date = $start_date;
$duration = 0;
$duration = get_name($patient_category_id, "patient_category", "threshold_type", "patient_discounts");
if ($duration == 2) {
$duration = 12; //12 months
}
if ($duration == 1) {
$duration = 1; //1 month
}
$patient_category_depedants->duration = $duration;
$patient_category_depedants->save();
}
flash('new dependants have been saved')->success();
return redirect('discounts');
}
public function view_patient_dependant_details(Request $request)
{
$patient_category_depedant = CategoryPatientDependant::first();
return view('patient_discounts::discounts.view_patient_dependant_details', compact('patient_category_depedant'));
}
/* View all dependants to a category patient */
public function view_dependants_to_category_patient($id)
{
$patient_category_depedants_record = CategoryPatientDependant::where('main_patient_id', $id)->get();
$patient = Patient::find($id);
$dependants_record = null;
if (count($patient_category_depedants_record) > 0) {
$dependants_record = $patient_category_depedants_record->first();
return view('patient_discounts::discounts.view_dependants_to_category_patient', compact('patient','dependants_record'));
}
return view('patient_discounts::discounts.view_dependants_to_category_patient', compact('patient','dependants_record'));
}
public function search_dependant_name(Request $request)
{
$data = [];
if ($request->has('q')) {
$search = $request->q;
$data = DB::table('patients')
->where('category_id', 1)
->where('first_name', 'LIKE', "%$search%")
->orWhere('last_name', 'LIKE', "%$search%")
->orWhere('number', 'LIKE', "%$search%")
->get(["id", "first_name", "last_name", "number", "phone"]);
}
return response()->json($data);
}
public function generate_dependants_payment_invoice(Request $request)
{
$main_patient_id = $request->main_patient_id;
$dependants_array = [];
$dependants = CategoryPatientDependant::where('main_patient_id', $main_patient_id)->get();
$consumptions = DependantsConsumption::where('main_patient_id', $main_patient_id)->get();
$patient_category_id = 0;
foreach ($dependants as $record) {
$dependants_array = explode(",", $record->dependant_patient_ids);
$patient_category_id = $record->patient_category_id;
}
$dependants_array[] = $main_patient_id; //add the main patient in array
$start_of_year = Carbon::now()->startOfYear();
$start = $start_of_year->toDateTimeString();
$end = Carbon::now()->toDateString();
$patient_category_name = get_name($patient_category_id, "id", "name", "patient_categories");
$invoice_number = generateInvoiceNumberFromDB($patient_category_name);
$invoice_start = Carbon::parse($start)->format('d-m-Y');
$invoice_date = $invoice_start."/".$end; //according to how Benjamin organized it
$invoice_with_payment_amount_paid = $invoice_with_payment_balance = 0;
$update = PatientCategoryInvoice::where('invoice_generated', 0)
->where('patient_category', $patient_category_id)
->whereIn('patient_id', $dependants_array)
->update(
[
'invoice_generated' => 1,
'invoice_date' => $invoice_date,
'invoice_number' => $invoice_number,
'is_invoice_for_individual' => $main_patient_id
]
);
$track_invoice = new TrackInvoice;
$track_invoice->reason = $patient_category_id;
$track_invoice->created_by = Auth::id();
if (!is_null($update) && $track_invoice->save()) {
$hospital_information = HospitalInformation::first();
$users_name = get_full_name(Auth::id(), 'id', 'first_name', 'last_name', 'users');
$start_date = Carbon::parse($start)->startOfDay()->toDateTimeString();
$end_date = Carbon::parse($end)->endOfDay()->toDateTimeString();
//update the dependant consumption table with the generated invoices number
$consumption = DependantsConsumption::where('main_patient_id', $main_patient_id)->whereNull('invoice_number')
->where('unpaid_balance', '>', 0)
->whereBetween('created_at', [$start_date, $end_date])
->update(['invoice_number' => $invoice_number]);
$last_invoice = DB::table('patient_category_invoices')->select('invoice_number')->distinct()->orderBy('invoice_number', 'desc')->first();
$last_invoice_number = $invoice_number;
$invoices = DB::table('patient_category_invoices')
->whereNotIn('patient_id', findTestOrDemoPatients())
->whereBetween('created_at', [$start_date, $end_date])
->where('patient_category', $patient_category_id)
->where('invoice_generated', 1)
->where('status', 0)
->where('invoice_number', $last_invoice_number)
->groupBy('episode_id')->selectRaw('*, sum(patient_amount) as sum')
->get()
->toArray();
$request->merge(['invoice_number' => $invoice_number]);
$request->merge(['patient_category' => $patient_category_id]);
$request->merge(['start_date' => $start_date]);
$request->merge(['end_date' => $end_date]);
return view('invoices::invoices.generate_invoice.patient_invoice', compact(
'invoices',
'request',
'users_name',
'hospital_information',
'invoice_with_payment_amount_paid',
'invoice_with_payment_balance'
));
} else {
return back()->withInput();
}
}
/* receive payment for a patient and his dependants */
public function receive_dependants_payment(Request $request)
{
//load the page that loads invoice payment with the requests as below
/*
"patient_category" => "15"
"created_by" => "17"
"created_at" => "2021-02-01 10:35:49"
"status" => "new"
"total" => "3150600"
"invoice_date" => "01-02-2021/2021-02-27"
"invoice_number" => "0865"
*/
}
public function clean_dependants_that_are_main_patients()
{
//1. loop through category_patient_dependants table
//2. explode dependants and check if any is main patient
//3. if main patient record exists, delete main patient record, soft delete consumption and make records unpaid
//4. soft delete episode record from patient_category_invoices and make ordered record not paid
$patient_category_dependants = CategoryPatientDependant::all();
if (count($patient_category_dependants) > 0) {
foreach ($patient_category_dependants as $category_record) {
$dependants_array = explode(",", $category_record->dependant_patient_ids);
for ($i=0; $i < count($dependants_array) ; $i++) {
$checking_for_main_patients = CategoryPatientDependant::where('main_patient_id',$dependants_array[$i])->get();
if (count($checking_for_main_patients) > 0) {
foreach ($checking_for_main_patients as $main_record) {
$main_record->delete();
$consumptions_records = DependantsConsumption::where('main_patient_id', $main_record->main_patient_id)->get();
if (count($consumptions_records) > 0) {
foreach ($consumptions_records as $consumption) {
$consumption->delete();
//treatments
$treatments = Treatment::where('episode_id', $consumption->episode_id)->get();
if (count($treatments) > 0) {
foreach ($treatments as $treatment) {
$treatment->update(['payment_status' => 0]);
}
}
//investigations
$investigations = OrderedInvestigation::where('episode_id', $consumption->episode_id)->get();
if (count($investigations) > 0) {
foreach ($investigations as $ordered_investigation) {
$ordered_investigation->update(['payment_status' => 0]);
}
}
//procedures
$procedures = OrderedProcedure::where('episode_id', $consumption->episode_id)->get();
if (count($procedures) > 0) {
foreach ($procedures as $ordered_procedure) {
$ordered_procedure->update(['payment_status' => 0]);
}
}
//services
$services = OrderedService::where('episode_id', $consumption->episode_id)->get();
if (count($services) > 0) {
foreach ($services as $ordered_service) {
$ordered_service->update(['payment_status' => 0]);
}
}
//sundrys
$sundrys = OrderedSundry::where('episode_id', $consumption->episode_id)->get();
if (count($sundrys) > 0) {
foreach ($sundrys as $ordered_sundry) {
$ordered_sundry->update(['payment_status' => 0]);
}
}
//patient category invoice
$patient_category_invoice = PatientCategoryInvoice::where('episode_id',$consumption->episode_id)->delete();
}
}
}
}
}
}
}
}
}