You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
624 lines
24 KiB
Dart
624 lines
24 KiB
Dart
import 'package:doctor_app_flutter/config/config.dart';
|
|
import 'package:doctor_app_flutter/config/shared_pref_kay.dart';
|
|
import 'package:doctor_app_flutter/config/size_config.dart';
|
|
import 'package:doctor_app_flutter/core/enum/patient_type.dart';
|
|
import 'package:doctor_app_flutter/core/model/PatientSearchRequestModel.dart';
|
|
import 'package:doctor_app_flutter/core/viewModel/PatientSearchViewModel.dart';
|
|
import 'package:doctor_app_flutter/core/viewModel/auth_view_model.dart';
|
|
import 'package:doctor_app_flutter/core/viewModel/project_view_model.dart';
|
|
import 'package:doctor_app_flutter/icons_app/doctor_app_icons.dart';
|
|
import 'package:doctor_app_flutter/models/doctor/doctor_profile_model.dart';
|
|
import 'package:doctor_app_flutter/models/doctor/profile_req_Model.dart';
|
|
import 'package:doctor_app_flutter/models/patient/patiant_info_model.dart';
|
|
import 'package:doctor_app_flutter/models/patient/patient_arrival/get_patient_arrival_list_request_model.dart';
|
|
import 'package:doctor_app_flutter/models/patient/patient_model.dart';
|
|
import 'package:doctor_app_flutter/models/patient/topten_users_res_model.dart';
|
|
import 'package:doctor_app_flutter/routes.dart';
|
|
import 'package:doctor_app_flutter/screens/base/base_view.dart';
|
|
import 'package:doctor_app_flutter/screens/patients/profile/soap_update/shared_soap_widgets/bottom_sheet_title.dart';
|
|
import 'package:doctor_app_flutter/util/helpers.dart';
|
|
import 'package:doctor_app_flutter/util/translations_delegate_base.dart';
|
|
import 'package:doctor_app_flutter/widgets/patients/PatientCard.dart';
|
|
import 'package:doctor_app_flutter/widgets/patients/clinic_list_dropdwon.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/app_scaffold_widget.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/app_texts_widget.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/dr_app_circular_progress_Indeicator.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/loader/gif_loader_dialog_utils.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/text_fields/app_text_form_field.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:hexcolor/hexcolor.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
// ignore: must_be_immutable
|
|
class PatientsScreenNew extends StatefulWidget {
|
|
final patientSearchForm;
|
|
final selectedType;
|
|
final isAppbar;
|
|
final arrivalType;
|
|
final isView;
|
|
final PatientType selectedPatientType;
|
|
final PatientSearchRequestModel patientSearchRequestModel;
|
|
final bool isSearchWithKeyInfo;
|
|
|
|
PatientsScreenNew(
|
|
{this.patientSearchForm,
|
|
this.selectedType,
|
|
this.isAppbar = true,
|
|
this.arrivalType,
|
|
this.isView,
|
|
this.selectedPatientType,
|
|
this.patientSearchRequestModel,
|
|
this.isSearchWithKeyInfo = true});
|
|
|
|
@override
|
|
_PatientsScreenNewState createState() => _PatientsScreenNewState();
|
|
}
|
|
|
|
class _PatientsScreenNewState extends State<PatientsScreenNew> {
|
|
List<dynamic> lItems;
|
|
|
|
List parsed;
|
|
|
|
List date;
|
|
List unFilterDate;
|
|
|
|
int clinicId;
|
|
AuthViewModel authProvider;
|
|
|
|
Color sideColor = Colors.black;
|
|
List<PatiantInformtion> responseModelList;
|
|
List<PatiantInformtion> responseModelList2;
|
|
final String url = "assets/images/";
|
|
final String avatarMale = "user_male.svg"; //'working_male.svg';//'user.svg';
|
|
final String avatarFemale = 'user_female.svg';
|
|
final String assetName = 'assets/image.svg';
|
|
|
|
List<String> _locations = []; //['All', 'Today', 'Tomorrow', 'Next Week'];
|
|
|
|
int _activeLocation = 0;
|
|
bool isInpatient = false;
|
|
String patientType;
|
|
bool isSearch = false;
|
|
String patientTypeTitle;
|
|
var _isLoading = true;
|
|
var selectedFilter = 1;
|
|
bool _isError = false;
|
|
String error = "";
|
|
String arrivalType;
|
|
ProjectViewModel projectsProvider;
|
|
var isView;
|
|
final _controller = TextEditingController();
|
|
|
|
PatientModel patient;
|
|
searchData(String str) {
|
|
this.responseModelList = this.responseModelList2;
|
|
var strExist = str.length > 0 ? true : false;
|
|
if (strExist) {
|
|
List<PatiantInformtion> filterData = [];
|
|
|
|
for (var i = 0; i < responseModelList2.length; i++) {
|
|
String firstName = responseModelList[i].firstName.toUpperCase();
|
|
String lastName = responseModelList[i].lastName.toUpperCase();
|
|
String mobile = responseModelList[i].mobileNumber.toUpperCase();
|
|
String patientID = responseModelList[i].patientId.toString();
|
|
|
|
if (firstName.contains(str.toUpperCase()) ||
|
|
lastName.contains(str.toUpperCase()) ||
|
|
mobile.contains(str) ||
|
|
patientID.contains(str)) {
|
|
filterData.add(responseModelList[i]);
|
|
}
|
|
}
|
|
|
|
setState(() {
|
|
this.responseModelList = filterData;
|
|
});
|
|
} else {
|
|
setState(() {
|
|
this.responseModelList = this.responseModelList2;
|
|
});
|
|
}
|
|
}
|
|
|
|
convertDateFormat(String str) {
|
|
String timeConvert;
|
|
const start = "/Date(";
|
|
const end = "+0300)";
|
|
|
|
final startIndex = str.indexOf(start);
|
|
final endIndex = str.indexOf(end, startIndex + start.length);
|
|
|
|
var date = new DateTime.fromMillisecondsSinceEpoch(
|
|
int.parse(str.substring(startIndex + start.length, endIndex)));
|
|
String newDate = date.year.toString() +
|
|
"-" +
|
|
date.month.toString().padLeft(2, '0') +
|
|
"-" +
|
|
date.day.toString().padLeft(2, '0');
|
|
|
|
return newDate.toString();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
authProvider = Provider.of(context);
|
|
_locations = [
|
|
TranslationBase.of(context).today,
|
|
TranslationBase.of(context).tomorrow,
|
|
TranslationBase.of(context).nextWeek,
|
|
];
|
|
//TranslationBase.of(context).all,
|
|
projectsProvider = Provider.of(context);
|
|
final routeArgs = ModalRoute.of(context).settings.arguments as Map;
|
|
|
|
// patient = widget.patientSearchForm != null
|
|
// ? widget.patientSearchForm
|
|
// : routeArgs['patientSearchForm'];
|
|
//
|
|
// patientType = widget.selectedType != null
|
|
// ? widget.selectedType
|
|
// : routeArgs['selectedType'];
|
|
// arrivalType = widget.arrivalType != null
|
|
// ? widget.arrivalType
|
|
// : routeArgs['arrivalType'];
|
|
// if (routeArgs != null && routeArgs.containsKey("isSearch")) {
|
|
// isSearch = routeArgs['isSearch'];
|
|
// }
|
|
// if (routeArgs != null && routeArgs.containsKey("isSearch")) {
|
|
// isView = routeArgs['isView'];
|
|
// }
|
|
// if (routeArgs != null && routeArgs.containsKey('activeFilter')) {
|
|
// _activeLocation = routeArgs['activeFilter'];
|
|
// }
|
|
// if (routeArgs != null && routeArgs.containsKey('isInpatient')) {
|
|
// isInpatient = routeArgs['isInpatient'];
|
|
// }
|
|
|
|
// if (!projectsProvider.isArabic)
|
|
// patientTypeTitle = SERVICES_PATIANT_HEADER[int.parse(patientType)];
|
|
// else
|
|
// patientTypeTitle = SERVICES_PATIANT_HEADER_AR[int.parse(patientType)];
|
|
|
|
return BaseView<PatientSearchViewModel>(
|
|
onModelReady: (model) async {
|
|
if(widget.isSearchWithKeyInfo) {
|
|
await model.getPatientFileInformation(widget.patientSearchRequestModel);
|
|
} else {
|
|
// ignore: unrelated_type_equality_checks
|
|
if(widget.selectedPatientType == PatientType.OutPatient) {
|
|
await model.getOutPatient(widget.patientSearchRequestModel);
|
|
} else {
|
|
// TODO handel inPatient case
|
|
}
|
|
}
|
|
},
|
|
builder: (_, model, w) => AppScaffold(
|
|
appBarTitle: "Search Patient",
|
|
isShowAppBar: false,
|
|
baseViewModel: model,
|
|
body: model.patientList.isEmpty
|
|
? Column(
|
|
children: [
|
|
Column(children: <Widget>[
|
|
SizedBox(
|
|
height: 10.0,
|
|
),
|
|
if (widget.selectedPatientType ==
|
|
PatientType.OutPatient &&
|
|
!widget.isSearchWithKeyInfo)
|
|
Container(
|
|
padding: EdgeInsets.all(5),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
border: Border.all(color: Colors.grey),
|
|
borderRadius: BorderRadius.circular(10)),
|
|
child: ClinicList(
|
|
clinicId: clinicId,
|
|
onClinicChange: (newValue) {
|
|
clinicId = newValue;
|
|
changeClinic(newValue, context, model);
|
|
},
|
|
)),
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
top: MediaQuery.of(context).size.height *
|
|
0.03),
|
|
// child: _locationBar(context)
|
|
child:
|
|
(widget.selectedPatientType == PatientType.OutPatient &&
|
|
widget.isSearchWithKeyInfo)
|
|
? _locationBar(context, model)
|
|
: Container(),
|
|
)
|
|
]),
|
|
Container(
|
|
margin: EdgeInsets.only(
|
|
top: MediaQuery.of(context).size.height * 0.10),
|
|
child: Center(
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: [
|
|
SizedBox(
|
|
height: 100,
|
|
),
|
|
Image.asset('assets/images/no-data.png'),
|
|
Padding(
|
|
padding: const EdgeInsets.all(8.0),
|
|
child: AppText(TranslationBase.of(context)
|
|
.youDontHaveAnyPatient),
|
|
)
|
|
],
|
|
),
|
|
),
|
|
),
|
|
],
|
|
)
|
|
: Container(
|
|
color: Colors.grey[200],
|
|
child: ListView(
|
|
scrollDirection: Axis.vertical,
|
|
children: <Widget>[
|
|
Container(
|
|
child:model.patientList.isEmpty
|
|
? Column(
|
|
crossAxisAlignment:
|
|
CrossAxisAlignment.start,
|
|
children: <Widget>[
|
|
Container(
|
|
child: Center(
|
|
child: Padding(
|
|
padding: const EdgeInsets.fromLTRB(
|
|
0, 0, 0, 0), //250
|
|
child:
|
|
DrAppCircularProgressIndeicator(),
|
|
)),
|
|
),
|
|
],
|
|
)
|
|
: Column(
|
|
children: <Widget>[
|
|
|
|
Container(
|
|
padding: EdgeInsets.only(
|
|
left: 0, right: 5, bottom: 5, top: 5),
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
),
|
|
height: 115,
|
|
child: Container(
|
|
padding: EdgeInsets.only(
|
|
left: 10, right: 10),
|
|
margin: EdgeInsets.only(top: 60),
|
|
child: Column(
|
|
children: [
|
|
Row(
|
|
mainAxisAlignment:
|
|
MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
RichText(
|
|
text: TextSpan(
|
|
style: TextStyle(
|
|
fontSize:20,
|
|
color: Colors.black),
|
|
children: <TextSpan>[
|
|
new TextSpan(
|
|
|
|
text: "Search for 1111",
|
|
style: TextStyle(
|
|
color: Color(0xFF2B353E),
|
|
fontWeight: FontWeight.bold,
|
|
fontFamily: 'Poppins',
|
|
fontSize: 22)),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
SizedBox(height: 18.5),
|
|
Container(
|
|
width: SizeConfig.screenWidth * 0.9,
|
|
height: 75,
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.all(
|
|
Radius.circular(6.0)),
|
|
border: Border.all(
|
|
width: 1.0,
|
|
color: HexColor("#CCCCCC"),
|
|
),
|
|
color: Colors.white),
|
|
child: Column(
|
|
crossAxisAlignment:
|
|
CrossAxisAlignment.start,
|
|
children: [
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
left: 10, top: 10),
|
|
child: AppText(
|
|
TranslationBase.of(
|
|
context)
|
|
.searchPatientName,
|
|
fontSize: 13,
|
|
)),
|
|
AppTextFormField(
|
|
// focusNode: focusProject,
|
|
controller: _controller,
|
|
borderColor: Colors.white,
|
|
prefix: IconButton(
|
|
icon: Icon(
|
|
DoctorApp.filter_1,
|
|
color: Colors.black,
|
|
),
|
|
iconSize: 20,
|
|
padding:
|
|
EdgeInsets.only(
|
|
bottom: 30),
|
|
),
|
|
onChanged: (String str) {
|
|
this.searchData(str);
|
|
}),
|
|
])),
|
|
SizedBox(
|
|
height: 10.0,
|
|
),
|
|
Padding(
|
|
padding: EdgeInsets.only(
|
|
top: MediaQuery.of(context)
|
|
.size
|
|
.height *
|
|
0.03),
|
|
// child: _locationBar(context)
|
|
child: widget.selectedPatientType ==
|
|
PatientType.OutPatient && !widget.isSearchWithKeyInfo
|
|
? _locationBar(context, model)
|
|
: Container(),
|
|
),
|
|
SizedBox(
|
|
height: 10.0,
|
|
),
|
|
Container(
|
|
child: (model.patientList.isNotEmpty)
|
|
? Column(
|
|
// mainAxisAlignment: MainAxisAlignment.center,
|
|
children: model.patientList
|
|
.map((PatiantInformtion
|
|
item) {
|
|
return PatientCard(
|
|
patientInfo: item,
|
|
patientType:
|
|
patientType,
|
|
arrivalType:
|
|
arrivalType,
|
|
isInpatient:
|
|
isInpatient,
|
|
onTap: () {
|
|
Navigator.of(context)
|
|
.pushNamed(
|
|
PATIENTS_PROFILE,
|
|
arguments: {
|
|
"patient": item,
|
|
"patientType":
|
|
patientType,
|
|
"from": patient
|
|
.getFrom,
|
|
"to": patient
|
|
.getTo,
|
|
"isSearch":
|
|
isSearch,
|
|
"isInpatient":
|
|
isInpatient,
|
|
"arrivalType":
|
|
arrivalType,
|
|
"isInpatient":
|
|
isInpatient
|
|
});
|
|
},
|
|
);
|
|
}).toList(),
|
|
)
|
|
: Center(
|
|
child: Column(
|
|
crossAxisAlignment:
|
|
CrossAxisAlignment
|
|
.center,
|
|
children: [
|
|
SizedBox(
|
|
height: 100,
|
|
),
|
|
Image.asset(
|
|
'assets/images/no-data.png'),
|
|
Padding(
|
|
padding:
|
|
const EdgeInsets
|
|
.all(8.0),
|
|
child: AppText(
|
|
TranslationBase.of(
|
|
context)
|
|
.youDontHaveAnyPatient),
|
|
)
|
|
],
|
|
),
|
|
)),
|
|
],
|
|
),
|
|
)
|
|
],
|
|
),
|
|
)
|
|
),
|
|
);
|
|
}
|
|
|
|
changeClinic(clinicId, BuildContext context, model) async {
|
|
GifLoaderDialogUtils.showMyDialog(context);
|
|
Map profile = await sharedPref.getObj(DOCTOR_PROFILE);
|
|
DoctorProfileModel doctorProfile = new DoctorProfileModel.fromJson(profile);
|
|
ProfileReqModel docInfo = new ProfileReqModel(
|
|
doctorID: doctorProfile.doctorID,
|
|
clinicID: clinicId,
|
|
license: true,
|
|
projectID: doctorProfile.projectID,
|
|
tokenID: '',
|
|
languageID: 2);
|
|
|
|
authProvider
|
|
.getDocProfiles(docInfo.toJson(), allowChangeProfile: false)
|
|
.then((profileList) async {
|
|
print(profileList['DoctorProfileList'][0]);
|
|
int val2 = int.parse(patientType);
|
|
|
|
GetPatientArrivalListRequestModel getPatientArrivalListRequestModel =
|
|
GetPatientArrivalListRequestModel(
|
|
from: patient.From,
|
|
to: patient.To,
|
|
clinicID: profileList['DoctorProfileList'][0]['ClinicID'],
|
|
doctorID:
|
|
profileList['DoctorProfileList'][0]['DoctorID'].toString(),
|
|
patientMRN: patient.getPatientID,
|
|
pageIndex: 0,
|
|
pageSize: 0);
|
|
|
|
model
|
|
.getPatientList(
|
|
getPatientArrivalListRequestModel.toJson(), patientType)
|
|
.then((res) {
|
|
setState(() {
|
|
if (res != null && res['MessageStatus'] == 1) {
|
|
if (val2 == 7) {
|
|
if (res[SERVICES_PATIANT2[val2]] == null) {
|
|
_isError = true;
|
|
_isLoading = false;
|
|
this.error = error.toString();
|
|
} else {
|
|
var localList = [];
|
|
if (res["patientArrivalList"]["entityList"] == null) {
|
|
res["patientArrivalList"]["entityList"] = [];
|
|
}
|
|
res["patientArrivalList"]["entityList"].forEach((v) {
|
|
Map<String, dynamic> mergedPatient = {
|
|
...v,
|
|
...v["patientDetails"]
|
|
};
|
|
localList.add(mergedPatient);
|
|
});
|
|
lItems = localList;
|
|
}
|
|
}
|
|
parsed = lItems;
|
|
responseModelList = new ModelResponse.fromJson(parsed).list;
|
|
responseModelList.sort((a, b) {
|
|
DateTime now = DateTime.now();
|
|
DateFormat dateFormat = DateFormat("yyyy-MM-dd HH:mm");
|
|
String formattedDate =
|
|
DateFormat('yyyy-MM-dd ' + a.startTime).format(now);
|
|
DateTime dateTimeA = dateFormat.parse(formattedDate);
|
|
String formattedDateB =
|
|
DateFormat('yyyy-MM-dd ' + b.startTime).format(now);
|
|
DateTime dateTimeB = dateFormat.parse(formattedDateB);
|
|
var adate = dateTimeA; //a.startTime;
|
|
var bdate = dateTimeB;
|
|
return adate.compareTo(bdate);
|
|
});
|
|
responseModelList2 = responseModelList;
|
|
_isError = false;
|
|
} else {
|
|
_isError = true;
|
|
error = model.error ??
|
|
res['ErrorEndUserMessage'] ??
|
|
res['ErrorMessage'];
|
|
}
|
|
|
|
_isLoading = false;
|
|
});
|
|
GifLoaderDialogUtils.hideDialog(context);
|
|
}).catchError((error) {
|
|
Helpers.showErrorToast(error.toString());
|
|
GifLoaderDialogUtils.hideDialog(context);
|
|
});
|
|
}).catchError((err) {
|
|
GifLoaderDialogUtils.hideDialog(context);
|
|
Helpers.showErrorToast(err);
|
|
});
|
|
}
|
|
|
|
//TODO Replace it with time bar.
|
|
Widget _locationBar(BuildContext _context, model) {
|
|
return Container(
|
|
height: MediaQuery.of(context).size.height * 0.0619,
|
|
width: SizeConfig.screenWidth * 0.94,
|
|
decoration: BoxDecoration(
|
|
color: Color(0Xffffffff),
|
|
borderRadius: BorderRadius.circular(12.5),
|
|
// border: Border.all(
|
|
// width: 0.5,
|
|
// ),
|
|
),
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceEvenly,
|
|
mainAxisSize: MainAxisSize.max,
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: _locations.map((item) {
|
|
bool _isActive = _locations[_activeLocation] == item ? true : false;
|
|
return Column(mainAxisSize: MainAxisSize.min, children: <Widget>[
|
|
InkWell(
|
|
child: Center(
|
|
child: Container(
|
|
height: MediaQuery.of(context).size.height * 0.058,
|
|
width: SizeConfig.screenWidth * 0.2334,
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.only(
|
|
bottomRight: Radius.circular(12.5),
|
|
topRight: Radius.circular(12.5),
|
|
topLeft: Radius.circular(9.5),
|
|
bottomLeft: Radius.circular(9.5)),
|
|
color: _isActive ? HexColor("#B8382B") : Colors.white,
|
|
),
|
|
child: Center(
|
|
child: Text(
|
|
item,
|
|
style: TextStyle(
|
|
fontSize: 12,
|
|
color: _isActive
|
|
? Colors.white
|
|
: Colors.black, //Colors.black,
|
|
|
|
fontWeight: FontWeight.normal,
|
|
),
|
|
),
|
|
)),
|
|
),
|
|
onTap: () async {
|
|
setState(() {
|
|
_activeLocation = _locations.indexOf(item);
|
|
});
|
|
GifLoaderDialogUtils.showMyDialog(context);
|
|
await model.getPatientBasedOnDate(item: item,
|
|
selectedPatientType: widget.selectedPatientType,
|
|
patientSearchRequestModel: widget
|
|
.patientSearchRequestModel,
|
|
isSearchWithKeyInfo: widget.isSearchWithKeyInfo);
|
|
GifLoaderDialogUtils.hideDialog(context);
|
|
}),
|
|
_isActive
|
|
? Container(
|
|
decoration: BoxDecoration(
|
|
borderRadius: BorderRadius.only(
|
|
bottomRight: Radius.circular(10),
|
|
topRight: Radius.circular(10)),
|
|
color: Colors.white),
|
|
alignment: Alignment.center,
|
|
height: 1,
|
|
width: SizeConfig.screenWidth * 0.23,
|
|
)
|
|
: Container()
|
|
]);
|
|
}).toList(),
|
|
),
|
|
);
|
|
}
|
|
}
|