mirror of
https://gitlab.com/signalytic/client-external/streamline/streamline-emr.git
synced 2026-09-11 18:51:31 +00:00
563 lines
25 KiB
PHP
Executable File
563 lines
25 KiB
PHP
Executable File
<?php
|
|
|
|
namespace Modules\ClinicalData\Http\Controllers;
|
|
|
|
use Illuminate\Database\Eloquent\Model;
|
|
use Illuminate\Http\Request;
|
|
use Streamline\Http\Controllers\StreamlineSetupManager;
|
|
use Streamline\Models\Alert;
|
|
use Streamline\Models\Allergy;
|
|
use Streamline\Models\ChartOfAccount;
|
|
use Streamline\Models\InsuranceClaim;
|
|
use Streamline\Models\PatientDocument;
|
|
use Streamline\Models\PriceListCategories;
|
|
use Streamline\Models\Procedure;
|
|
use Streamline\Models\Patient;
|
|
use Streamline\Models\PatientEpisode;
|
|
use Streamline\Models\OrderedProcedure;
|
|
use Streamline\Models\ProcedureCategory;
|
|
use Streamline\Models\Consultation;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Validator;
|
|
use Illuminate\Support\Facades\Auth;
|
|
use Illuminate\Database\QueryException;
|
|
use Illuminate\Support\Facades\Artisan;
|
|
use Streamline\Models\HmisCategory;
|
|
use Streamline\Services\StreamlineSetupServiceInterface;
|
|
class ProcedureController extends Controller {
|
|
protected StreamlineSetupServiceInterface $setupService;
|
|
public function __construct(StreamlineSetupServiceInterface $setupService) {
|
|
$this->middleware('auth');
|
|
$this->middleware('permission:procedure-list', ['only' => ['index']]);
|
|
$this->middleware('permission:procedure-create', ['only' => ['create', 'store']]);
|
|
$this->middleware('permission:procedure-edit', ['only' => ['edit', 'update']]);
|
|
$this->middleware('permission:procedure-delete', ['only' => ['destroy', 'inactive', 'activate']]);
|
|
$this->setupService = $setupService;
|
|
}
|
|
|
|
/**
|
|
* Display a listing of the resource.
|
|
*
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function index() {
|
|
$procedures = Procedure::where('available', 1)->orderBy('name', 'asc')->get();
|
|
$chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')->pluck('name', 'id');
|
|
|
|
$ordered_procedures_array = [];
|
|
$ordered_procedures = OrderedProcedure::distinct('procedure_id')->get(['procedure_id']);
|
|
foreach ($ordered_procedures as $ordered_procedure) {
|
|
$actual = explode(',', $ordered_procedure->procedure_id);
|
|
foreach ($actual as $value) $ordered_procedures_array[] = $value;
|
|
}
|
|
$ordered_procedures_ids = array_unique($ordered_procedures_array);
|
|
|
|
$categories = ProcedureCategory::orderBy('name', 'asc')->pluck('name', 'id');
|
|
$hmis_categories = DB::table('hmis_categories')->orderBy('title', 'asc')->pluck('title', 'id')->toArray();
|
|
|
|
return view('clinical_data::procedures.index', compact('procedures', 'chart_of_accounts', 'categories', 'hmis_categories', 'ordered_procedures_ids'));
|
|
}
|
|
|
|
/**
|
|
* Show the form for creating a new resource.
|
|
*
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function create() {
|
|
$procedure_categories = ProcedureCategory::pluck('name', 'id')
|
|
->toArray();
|
|
|
|
$procedure_categories = ['' => '- select -'] + $procedure_categories;
|
|
|
|
$chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')
|
|
->pluck('name', 'id')
|
|
->toArray();
|
|
|
|
$chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;
|
|
|
|
$procedures = StreamlineSetupManager::get_procedures_array();
|
|
|
|
$hmis_categories = HmisCategory::all('title', 'id','number','type', 'section_number')->toArray();
|
|
|
|
return view('clinical_data::procedures.create', compact('procedure_categories', 'chart_of_accounts','procedures', 'hmis_categories'));
|
|
}
|
|
|
|
/**
|
|
* Store a newly created resource in storage.
|
|
*
|
|
* @param \Illuminate\Http\Request $request
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function store(Request $request) {
|
|
if (session()->has('streamline_setup')){
|
|
//skip validation
|
|
} else {
|
|
request()->validate([
|
|
'name' => 'required',
|
|
'non_insured_price' => 'required',
|
|
'account_id' => 'required',
|
|
'category' => 'required',
|
|
'procedure_type' => 'required',
|
|
'hmis_category_inpatient'=>'nullable|required_if:procedure_type,1|required_with:hmis_category_inpatient_options',
|
|
'hmis_category_inpatient_options'=>'nullable|required_with:hmis_category_inpatient',
|
|
'hysterectomy_type'=>'nullable|required_if:hmis_category_inpatient_options,5'
|
|
]);
|
|
}
|
|
if (session()->has('streamline_setup')&& isset($request->skip)){
|
|
//update the streamline setup table with the new finished step
|
|
$this->setupService->saveStep("procedures registration", 1);
|
|
return redirect("sundries/create");
|
|
}
|
|
|
|
// get all current price lists
|
|
$price_list = PriceListCategories::withTrashed()->select('id')->get();
|
|
$price_list_category = [];
|
|
$price_list_price = [];
|
|
|
|
foreach ($price_list as $record){
|
|
array_push($price_list_category, $record->id);
|
|
array_push($price_list_price, $request->non_insured_price);
|
|
}
|
|
|
|
$logged_in_user_id = Auth()->user()->id;
|
|
$procedure = new Procedure;
|
|
|
|
$procedure->name = $request->name;
|
|
$procedure->code = $request->code;
|
|
$procedure->reference_link = !empty($request->reference_link)? implode(',',$request->reference_link):null;
|
|
$procedure->reference_text = !empty($request->reference_text)? implode(',',$request->reference_text):null;
|
|
$procedure->non_insured_price = $request->non_insured_price;
|
|
$procedure->insured_price = 0;
|
|
$procedure->available = $request->available;
|
|
|
|
if (isset($request->price_list_category_id) && isset($request->price_list_price)) {
|
|
$procedure->price_list_category = !is_null($request->price_list_category_id) ? implode(",", $request->price_list_category_id) : null;
|
|
$procedure->price_list_price = !is_null($request->price_list_price) ? implode(",", $request->price_list_price) : null;
|
|
} else {
|
|
$procedure->price_list_category = implode(",", $price_list_category);
|
|
$procedure->price_list_price = implode(",", $price_list_price);
|
|
}
|
|
|
|
$procedure->account_id = $request->account_id;
|
|
$procedure->category_id = $request->category;
|
|
$procedure->hmis_number = $request->hmis_number;
|
|
/*== hmis stuff =====*/
|
|
$procedure->hmis_no_outpatient = (!empty($request->hmis_no_outpatient[0]))? implode(",", $request->hmis_no_outpatient) : null;
|
|
$procedure->hmis_category = is_array($request->hmis_category) ? implode(",", $request->hmis_category) : "";
|
|
$procedure->hmis_no_inpatient = ($request->hmis_category_inpatient_options != '5')? $request->hmis_category_inpatient_options:$request->hysterectomy_type;
|
|
$procedure->hmis_category_inpatient = $request->hmis_category_inpatient;
|
|
$procedure->hmis_inpatient_type = $request->procedure_type;
|
|
/*===================*/
|
|
$procedure->created_by = $logged_in_user_id;
|
|
$procedure->updated_by = $logged_in_user_id;
|
|
|
|
try {
|
|
if ($procedure->name != "" && !is_null($procedure->name)) {
|
|
$procedure->save();
|
|
}
|
|
|
|
flash($request->name . " Procedure has been saved")->success();
|
|
|
|
if (session()->has('streamline_setup')) {
|
|
if (isset($request->selected_procedures)) {
|
|
$selected_procedures_array = $request->selected_procedures;
|
|
if (!empty($selected_procedures_array)) {
|
|
|
|
for ($i=0; $i < count($selected_procedures_array) ; $i++) {
|
|
/* try this magic to get details for the selected service */
|
|
$procedures_array = StreamlineSetupManager::get_procedures_array();
|
|
$key = array_search($selected_procedures_array[$i], array_column($procedures_array, 'Procedure_Name'));
|
|
$procedure_details = $procedures_array[$key];
|
|
/* end of magic trial */
|
|
|
|
$default_procedure = new Procedure;
|
|
$default_procedure->name = $procedure_details['Procedure_Name'];
|
|
$default_procedure->insured_price = 0;
|
|
$default_procedure->non_insured_price = 0;
|
|
$default_procedure->category_id = $procedure_details['Category'];
|
|
$default_procedure->account_id = $procedure_details['Account_Id'];
|
|
$default_procedure->save();
|
|
}
|
|
}
|
|
}
|
|
//update the streamline setup table with the new finished step
|
|
$this->setupService->saveStep("procedures registration", 1);
|
|
// $streamline_setup = new \Streamline\Models\StreamlineSetupStep;
|
|
// $streamline_setup->step = "procedures registration";
|
|
// $streamline_setup->completion_status = 1;
|
|
// $streamline_setup->save();
|
|
return redirect("sundries/create");
|
|
}
|
|
return redirect("/procedures/");
|
|
} catch (QueryException $e) {
|
|
flash("An error occurred")->error();
|
|
return back()->withInput();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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\Http\Response
|
|
*/
|
|
public function edit($id) {
|
|
$procedure = Procedure::where(['id' => $id])->first();
|
|
|
|
$procedure_categories = ProcedureCategory::pluck('name', 'id')
|
|
->toArray();
|
|
$procedure_categories = ['' => '- select -'] + $procedure_categories;
|
|
|
|
$chart_of_accounts = ChartOfAccount::orderBy('name', 'asc')
|
|
->pluck('name', 'id')
|
|
->toArray();
|
|
|
|
$chart_of_accounts = ['' => '- select -'] + $chart_of_accounts;
|
|
|
|
// $hmis_categories = DB::table('hmis_categories')->orderBy('title', 'asc')->pluck('title', 'id')->toArray();
|
|
|
|
// $hmis_categories = ['' => '- select -'] + $hmis_categories;
|
|
$hmis_categories_options = [];
|
|
$hmis_categories = HmisCategory::all('title', 'id','number','type', 'section_number')->toArray();
|
|
$categories_options = DB::table('hmis_category_options')->where('hmis_category_id', $procedure->hmis_category_inpatient)->get();
|
|
foreach ($categories_options as $options) $hmis_categories_options[] =['id'=>$options->id, 'name'=>$options->name, 'number'=>$options->number];
|
|
if (!$procedure) {
|
|
flash()->error("There is no such procedure");
|
|
return redirect('/procedures/');
|
|
} else {
|
|
return view('clinical_data::procedures.edit', compact('procedure', 'procedure_categories', 'chart_of_accounts', 'hmis_categories','hmis_categories_options'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update the specified resource in storage.
|
|
*
|
|
* @param \Illuminate\Http\Request $request
|
|
* @param int $id
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function update(Request $request, $id) {
|
|
request()->validate([
|
|
'name' => 'required',
|
|
'non_insured_price' => 'required',
|
|
'account_id' => 'required',
|
|
'category' => 'required',
|
|
'procedure_type' => 'required',
|
|
'hmis_category_inpatient'=>'nullable|required_if:procedure_type,1|required_with:hmis_category_inpatient_options',
|
|
'hmis_category_inpatient_options'=>'nullable|required_with:hmis_category_inpatient',
|
|
'hysterectomy_type'=>'nullable|required_if:hmis_category_inpatient_options,5'
|
|
]);
|
|
|
|
$logged_in_user_id = Auth()->user()->id;
|
|
|
|
$procedure = Procedure::find($id);
|
|
|
|
$procedure->name = $request->name;
|
|
$procedure->code = $request->code;
|
|
$procedure->non_insured_price = $request->non_insured_price;
|
|
$procedure->available = $request->available;
|
|
$procedure->reference_link = !empty($request->reference_link)? implode(',',$request->reference_link):null;
|
|
$procedure->reference_text = !empty($request->reference_text)? implode(',',$request->reference_text):null;
|
|
$procedure->insured_price = 0;
|
|
$procedure->insurance = 0;
|
|
$procedure->price_list_category = !is_null($request->price_list_category_id) ? implode(",", $request->price_list_category_id) : null;
|
|
$procedure->price_list_price = !is_null($request->price_list_price) ? implode(",", $request->price_list_price) : null;
|
|
$procedure->account_id = $request->account_id;
|
|
$procedure->category_id = $request->category;
|
|
$procedure->hmis_number = $request->hmis_number;
|
|
/*== hmis stuff =====*/
|
|
$procedure->hmis_no_outpatient = (!empty($request->hmis_no_outpatient[0]))? implode(",", $request->hmis_no_outpatient):null;
|
|
// $procedure->hmis_category = implode(",", $request->hmis_category);
|
|
/*== Hmis 108 stuff =====*/
|
|
$procedure->hmis_no_inpatient = ($request->hmis_category_inpatient_options != '5')? $request->hmis_category_inpatient_options:$request->hysterectomy_type;
|
|
$procedure->hmis_category_inpatient = $request->hmis_category_inpatient;
|
|
$procedure->hmis_inpatient_type = $request->procedure_type;
|
|
/*===================*/
|
|
$procedure->updated_by = $logged_in_user_id;
|
|
|
|
try {
|
|
$procedure->save();
|
|
flash($request->name . " Procedure has been updated")->success();
|
|
return redirect("/procedures/");
|
|
} catch (QueryException $e) {
|
|
flash("An error occurred")->error();
|
|
return back()->withInput();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the specified resource from storage.
|
|
*
|
|
* @param int $id
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function destroy($id) {
|
|
$procedure = Procedure::find($id);
|
|
|
|
if ($procedure->delete()):
|
|
flash("Procedure has been deleted.")->success();
|
|
return redirect('/procedures/');
|
|
endif;
|
|
}
|
|
|
|
/**
|
|
* Display a listing of the inactive resource(s).
|
|
*
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function inactive() {
|
|
$procedures = Procedure::onlyTrashed()
|
|
->orderBy('name', 'asc')
|
|
->get();
|
|
|
|
$chart_of_accounts = DB::table('chart_of_accounts')
|
|
->orderBy('name', 'asc')
|
|
->pluck('name', 'id');
|
|
|
|
$categories = DB::table('procedure_categories')
|
|
->orderBy('name', 'asc')
|
|
->pluck('name', 'id');
|
|
|
|
if (count($procedures) < 1) {
|
|
flash()->error("There is no inactive procedure");
|
|
return redirect('/procedures/');
|
|
} else {
|
|
return view('clinical_data::procedures.inactive', compact('procedures', 'chart_of_accounts', 'categories'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activate the specified resource in storage.
|
|
*
|
|
* @param int $id
|
|
* @return \Illuminate\Http\Response
|
|
*/
|
|
public function activate($id) {
|
|
$procedure = Procedure::withTrashed()->find($id);
|
|
|
|
if ($procedure->restore()):
|
|
flash("Procedure has been activated.")->success();
|
|
return redirect('/procedures/inactive');
|
|
endif;
|
|
}
|
|
|
|
/**
|
|
* Order procedures for the patient
|
|
*
|
|
* @return \Illuminate\Contracts\View\Factory|\Illuminate\View\View
|
|
*/
|
|
public function order_procedures(){
|
|
$patient_id = session()->get('patient_id');
|
|
$episode_id = session()->get('episode_id');
|
|
$patient = Patient::where('id', $patient_id)->first();
|
|
$categories = DB::table('patient_categories')->where('available', 1)->pluck("name", "id");
|
|
$procedures = Procedure::where('available', 1)->orderBy('name')->pluck('name', 'id');
|
|
|
|
$ordered_procedures = DB::table('ordered_procedures')->whereNull('deleted_at')
|
|
->where(['patient_id'=>$patient_id, 'episode_id'=>$episode_id, 'payment_status'=>0])
|
|
->first();
|
|
|
|
$users_collection = DB::table('users')->orderBy("first_name","asc")->select("id")->get()->toArray();
|
|
$users_array = [];
|
|
foreach ($users_collection as $value){
|
|
$user = \Streamline\Models\User::find($value->id);
|
|
if (!is_null($user)) {
|
|
$users_array[$value->id] = get_full_name($value->id, 'id', 'first_name', 'last_name', 'users');
|
|
}
|
|
}
|
|
$users_array = ['' => '- select -'] + $users_array;
|
|
|
|
$employees = DB::table('users')->whereNull('deleted_at')->orderBy('first_name', 'asc')->get();
|
|
|
|
return view('clinical_data::procedures.order_procedures',compact('patient_id','episode_id','patient','categories','employees','procedures','ordered_procedures', 'users_array'));
|
|
}
|
|
|
|
/**
|
|
* Store ordered procedures for a patient episode
|
|
*
|
|
* @param Request $request
|
|
* @return \Illuminate\Http\RedirectResponse|\Illuminate\Routing\Redirector
|
|
*/
|
|
public function store_ordered_procedures(Request $request){
|
|
if(is_null($request->procedure_id)){
|
|
flash("No procedure has been selected")->error();
|
|
return back()->withInput();
|
|
} else {
|
|
$patient_id = session()->get('patient_id');
|
|
$episode_id = session()->get('episode_id');
|
|
|
|
$procedure_ids_array = $request->procedure_id;
|
|
$procedure_cost_array = $request->item_cost;
|
|
$procedure_performed = [];
|
|
$procedure_performed_id = [];
|
|
|
|
//loop through performed procedures and update the performed column
|
|
$performed_procedures_array = $request->performed_procedures;
|
|
$performed_by_array = $request->procedure_performed_by;
|
|
$procedure_performed_by_amount = $request->procedure_performed_by_amount;
|
|
$procedure_performed_date = $request->procedure_performed_date;
|
|
|
|
// filter to check if all entries have been filled for performed by and discard otherwise
|
|
for ($i = 0; $i < count($procedure_ids_array); $i++) {
|
|
if ($performed_procedures_array[$i] == 1 && ($performed_by_array[$i] != "" || $performed_by_array[$i] != null) &&
|
|
($procedure_performed_by_amount[$i] != "" || $procedure_performed_by_amount[$i] != null) &&
|
|
($procedure_performed_date[$i] != "" || $procedure_performed_date[$i] != null)) {
|
|
$procedure_performed_id[] = record_staff_that_has_performed_the_service_with_price($patient_id, $episode_id, 1, $procedure_ids_array[$i], 0,
|
|
$performed_by_array[$i], $procedure_performed_by_amount[$i], $procedure_performed_date[$i]);
|
|
$procedure_performed[] = 1;
|
|
} else {
|
|
$procedure_performed[] = 0;
|
|
$procedure_performed_id[] = 0;
|
|
}
|
|
}
|
|
|
|
if (isset($request->order_id) && get_name($request->order_id, 'id', 'payment_status', 'ordered_procedures') == 0) {
|
|
$procedure_order = OrderedProcedure::find($request->order_id);
|
|
|
|
// delete the previous preformed_by_ids
|
|
try {
|
|
DB::table('staff_performed_services')->whereIn('id', explode(",", $procedure_order->performed_id))->delete();
|
|
} catch (\Exception $e) {}
|
|
} else {
|
|
$procedure_order = new OrderedProcedure;
|
|
$procedure_order->patient_id = $patient_id;
|
|
$procedure_order->episode_id = $episode_id;
|
|
$procedure_order->payment_status = 0; //0 by default to mean not paid
|
|
$procedure_order->created_by = auth()->user()->id;
|
|
}
|
|
|
|
$procedure_order->procedure_id = implode(",", $procedure_ids_array);
|
|
$procedure_order->procedure_amount = implode(",", $procedure_cost_array);
|
|
$procedure_order->performed = implode(",", $procedure_performed);
|
|
$procedure_order->performed_id = implode(",", $procedure_performed_id);
|
|
$procedure_order->eye = implode(",", $request->eye);
|
|
$procedure_order->updated_by = auth()->user()->id;
|
|
$procedure_order->save();
|
|
|
|
// create an insurance claim for the ordered items
|
|
if ($request->patient_insurance_status == 1) {
|
|
generate_insurance_claim($procedure_order->id, 2);
|
|
}
|
|
|
|
flash("Procedures have been saved")->success();
|
|
|
|
// redirect to consultation or patient_episode page depending on where the user is from
|
|
if (session()->has('redirect_to_consultation')) {
|
|
$url = session()->get('redirect_to_consultation');
|
|
session()->forget('redirect_to_consultation');
|
|
return redirect($url);
|
|
} elseif (session()->has('anc_visit_redirect')) {
|
|
$url = session()->get('anc_visit_redirect');
|
|
session()->forget('anc_visit_redirect');
|
|
return redirect($url);
|
|
} else {
|
|
if(session()->has('previous_action') && session()->get('previous_action') == 'anc_consultation_page') {
|
|
return redirect("ante_natal_clinic/route");
|
|
session()->forget('previous_action');
|
|
}
|
|
else return redirect("/patient_episodes");
|
|
}
|
|
}
|
|
}
|
|
|
|
public function fetch_procedure_performance_fee(Request $request) {
|
|
$patient_id = $request->patient_id;
|
|
$patient_category_id = get_name($patient_id, 'id', 'category_id', 'patients');
|
|
$performed_by = $request->performed_by;
|
|
$item_id = $request->item_id;
|
|
|
|
$price_list_category_details = \Streamline\Models\PriceListCategories::where(['patient_category_id' => $patient_category_id])->first();
|
|
|
|
if ($price_list_category_details) {
|
|
$price_list_category_id = $price_list_category_details->id;
|
|
|
|
$fees_array = get_item_price_and_performance_fee_based_on_price_list_category($performed_by, $item_id, 1, $price_list_category_id);
|
|
|
|
return ($fees_array[1] == 0) ? $fees_array[0] : $fees_array[1];
|
|
} else {
|
|
//do this for cases where the there are no price lists for the patient's patient_category
|
|
$fees_array = get_item_price_and_performance_fee_array_without_price_list($item_id, $performed_by, 1);
|
|
|
|
return ($fees_array[1] == 0) ? $fees_array[0] : $fees_array[1];
|
|
}
|
|
}
|
|
|
|
public function cancel_ordered_procedures($order_id) {
|
|
$ordered_procedure = OrderedProcedure::find($order_id);
|
|
|
|
try {
|
|
$ordered_procedure->delete();
|
|
|
|
// check if there are any insurance claims available
|
|
$claim = InsuranceClaim::where('order_id', $order_id)->where('item_type', 2)->first();
|
|
|
|
if ($claim) {
|
|
$claim->delete();
|
|
}
|
|
|
|
return 1;
|
|
} catch (\Exception $exception) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
public function get_procedure_details(Request $request) {
|
|
$patient_id = $request->patient_id;
|
|
$patient_insurance_status = $request->patient_insurance_status ?? 0;
|
|
$is_inpatient = $request->is_inpatient == 1;
|
|
$ward_id = $request->ward_id ?? 0;
|
|
|
|
$procedure = DB::table('procedures')->find($request->procedure_id);
|
|
|
|
if(is_numeric($patient_insurance_status) && $patient_insurance_status == 1 && $patient_id != 0 && is_numeric($patient_id)) {
|
|
$selling_price = get_item_insurance_co_payment($patient_id, $procedure->id, 2, $is_inpatient, $ward_id);
|
|
} else {
|
|
// check if the patient category is attached to a price list
|
|
$price_list_id = is_patient_category_attached_to_price_list($patient_id);
|
|
if ($price_list_id) {
|
|
$selling_price = get_price_list_category_price($price_list_id, 4, $procedure->id);
|
|
} else {
|
|
$selling_price = $procedure->non_insured_price;
|
|
}
|
|
}
|
|
|
|
if (is_chi_enabled() && is_patient_item_covered($patient_id, $procedure->id, 2)) {
|
|
$covered_by_chi = ' <br><span style="color: darkgreen"><b>Covered by CHI</b></span>';
|
|
} else {
|
|
$covered_by_chi = "";
|
|
}
|
|
|
|
return json_encode([
|
|
"selling_price" => $selling_price,
|
|
"covered_by_chi" => $covered_by_chi,
|
|
]);
|
|
}
|
|
public function get_hmis_categories_options(Request $request) {
|
|
$options = DB::table('hmis_category_options')->where('hmis_category_id', $request->hmis_category)->orderBy('name', 'asc')->get();
|
|
$data ='<option value="" selected disabled>- Select HMIS category Option -</option>';
|
|
foreach($options as $option){
|
|
$data .= '<option value="'.$option->id.'">'.$option->name.'</option>';
|
|
}
|
|
return $data;
|
|
}
|
|
|
|
public function get_dependent_hmis_category_options(Request $request) {
|
|
$options = DB::table('hmis_category_options')->where('parent_option', $request->parent_category)->orderBy('name', 'asc')->get();
|
|
$data ='<option value="" selected disabled>- Select Dependent Option -</option>';
|
|
foreach($options as $option){
|
|
$data .= '<option value="'.$option->id.'">'.$option->name.'</option>';
|
|
}
|
|
return $data;
|
|
}
|
|
}
|