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.
507 lines
18 KiB
Dart
507 lines
18 KiB
Dart
import 'package:doctor_app_flutter/config/size_config.dart';
|
|
import 'package:doctor_app_flutter/core/enum/master_lookup_key.dart';
|
|
import 'package:doctor_app_flutter/core/viewModel/SOAP_view_model.dart';
|
|
import 'package:doctor_app_flutter/core/viewModel/project_view_model.dart';
|
|
import 'package:doctor_app_flutter/models/SOAP/master_key_model.dart';
|
|
import 'package:doctor_app_flutter/models/SOAP/my_selected_examination.dart';
|
|
import 'package:doctor_app_flutter/screens/base/base_view.dart';
|
|
import 'package:doctor_app_flutter/util/translations_delegate_base.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/app-textfield-custom.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/borderedButton.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/divider_with_spaces_around.dart';
|
|
import 'package:doctor_app_flutter/widgets/shared/expandable-widget-header-body.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'package:hexcolor/hexcolor.dart';
|
|
import 'package:provider/provider.dart';
|
|
|
|
// Author Mosa Abuzaid
|
|
|
|
class AddExaminationPage extends StatefulWidget {
|
|
final List<MySelectedExamination> mySelectedExamination;
|
|
final Function addSelectedExamination;
|
|
final Function(MasterKeyModel) removeExamination;
|
|
|
|
AddExaminationPage(
|
|
{this.mySelectedExamination,
|
|
this.addSelectedExamination,
|
|
this.removeExamination});
|
|
|
|
@override
|
|
_AddExaminationPageState createState() => _AddExaminationPageState();
|
|
}
|
|
|
|
class _AddExaminationPageState extends State<AddExaminationPage> {
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return BaseView<SOAPViewModel>(
|
|
onModelReady: (model) async {
|
|
if (model.physicalExaminationList.length == 0) {
|
|
await model.getMasterLookup(MasterKeysService.PhysicalExamination);
|
|
}
|
|
},
|
|
builder: (_, model, w) => AppScaffold(
|
|
baseViewModel: model,
|
|
isShowAppBar: false,
|
|
backgroundColor: Color.fromRGBO(248, 248, 248, 1),
|
|
body: Column(
|
|
mainAxisAlignment: MainAxisAlignment.start,
|
|
children: [
|
|
Container(
|
|
padding:
|
|
EdgeInsets.only(left: 16, top: 70, right: 16, bottom: 16),
|
|
color: Colors.white,
|
|
child: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
crossAxisAlignment: CrossAxisAlignment.center,
|
|
children: [
|
|
Expanded(
|
|
child: AppText(
|
|
"${TranslationBase.of(context).addExamination}",
|
|
fontSize: SizeConfig.textMultiplier * 3.3,
|
|
color: Colors.black,
|
|
fontWeight: FontWeight.w700,
|
|
),
|
|
),
|
|
InkWell(
|
|
onTap: () {
|
|
Navigator.of(context).pop();
|
|
},
|
|
child: Icon(
|
|
Icons.clear,
|
|
size: 40,
|
|
),
|
|
)
|
|
],
|
|
),
|
|
),
|
|
Expanded(
|
|
child: SingleChildScrollView(
|
|
child: Column(
|
|
children: [
|
|
Container(
|
|
margin: EdgeInsets.all(16.0),
|
|
padding: EdgeInsets.all(0.0),
|
|
decoration: BoxDecoration(
|
|
shape: BoxShape.rectangle,
|
|
color: Colors.white,
|
|
borderRadius: BorderRadius.circular(12),
|
|
border: Border.fromBorderSide(BorderSide(
|
|
color: Colors.grey.shade400,
|
|
width: 0.4,
|
|
)),
|
|
),
|
|
child: Column(
|
|
children: [
|
|
ExaminationsListSearchWidget(
|
|
masterList: model.physicalExaminationList,
|
|
isServiceSelected: (master) =>
|
|
isServiceSelected(master),
|
|
removeHistory: (history) {
|
|
setState(() {
|
|
widget.removeExamination(history);
|
|
});
|
|
},
|
|
addHistory: (selectedExamination) {
|
|
setState(() {
|
|
widget.mySelectedExamination
|
|
.add(selectedExamination);
|
|
});
|
|
},
|
|
),
|
|
],
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
),
|
|
Container(
|
|
padding: EdgeInsets.all(16),
|
|
color: Colors.white,
|
|
child: BorderedButton(
|
|
"${TranslationBase.of(context).addExamination}",
|
|
backgroundColor: HexColor("#359846"),
|
|
textColor: Colors.white,
|
|
vPadding: 12,
|
|
radius: 12,
|
|
fontWeight: FontWeight.w600,
|
|
fontSize: SizeConfig.textMultiplier * 2.5,
|
|
fontFamily: 'Poppins',
|
|
handler: () {
|
|
widget.addSelectedExamination();
|
|
},
|
|
),
|
|
)
|
|
],
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
isServiceSelected(MasterKeyModel masterKey) {
|
|
Iterable<MySelectedExamination> exam = widget.mySelectedExamination.where(
|
|
(element) =>
|
|
masterKey.id == element.selectedExamination.id &&
|
|
masterKey.typeId == element.selectedExamination.typeId);
|
|
if (exam.length > 0) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
class ExaminationsListSearchWidget extends StatefulWidget {
|
|
final Function(MasterKeyModel) removeHistory;
|
|
final Function(MySelectedExamination) addHistory;
|
|
final bool Function(MasterKeyModel) isServiceSelected;
|
|
final List<MasterKeyModel> masterList;
|
|
|
|
ExaminationsListSearchWidget(
|
|
{this.removeHistory,
|
|
this.addHistory,
|
|
this.isServiceSelected,
|
|
this.masterList});
|
|
|
|
@override
|
|
_ExaminationsListSearchWidgetState createState() =>
|
|
_ExaminationsListSearchWidgetState();
|
|
}
|
|
|
|
class _ExaminationsListSearchWidgetState
|
|
extends State<ExaminationsListSearchWidget> {
|
|
int expandedIndex = -1;
|
|
List<MasterKeyModel> items = List();
|
|
TextEditingController filteredSearchController = TextEditingController();
|
|
|
|
@override
|
|
void initState() {
|
|
items.addAll(widget.masterList);
|
|
super.initState();
|
|
}
|
|
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
return Column(
|
|
children: [
|
|
AppTextFieldCustom(
|
|
height: MediaQuery.of(context).size.height * 0.080,
|
|
hintText: TranslationBase.of(context).searchExamination,
|
|
isDropDown: true,
|
|
hasBorder: false,
|
|
controller: filteredSearchController,
|
|
onChanged: (value) {
|
|
filterSearchResults(value);
|
|
},
|
|
suffixIcon: Icon(
|
|
Icons.search,
|
|
color: Colors.black,
|
|
),
|
|
),
|
|
DividerWithSpacesAround(
|
|
height: 2,
|
|
),
|
|
...items.mapIndexed((index, item) {
|
|
return AddExaminationWidget(
|
|
item: item,
|
|
addHistory: widget.addHistory,
|
|
removeHistory: widget.removeHistory,
|
|
isServiceSelected: widget.isServiceSelected,
|
|
isExpand: index == expandedIndex,
|
|
expandClick: () {
|
|
setState(() {
|
|
if (expandedIndex == index) {
|
|
expandedIndex = -1;
|
|
} else {
|
|
expandedIndex = index;
|
|
}
|
|
});
|
|
},
|
|
);
|
|
}).toList(),
|
|
],
|
|
);
|
|
}
|
|
|
|
void filterSearchResults(String query) {
|
|
List<MasterKeyModel> dummySearchList = List();
|
|
dummySearchList.addAll(widget.masterList);
|
|
if (query.isNotEmpty) {
|
|
List<MasterKeyModel> dummyListData = List();
|
|
dummySearchList.forEach((item) {
|
|
if (item.nameAr.toLowerCase().contains(query.toLowerCase()) ||
|
|
item.nameEn.toLowerCase().contains(query.toLowerCase())) {
|
|
dummyListData.add(item);
|
|
}
|
|
});
|
|
setState(() {
|
|
items.clear();
|
|
items.addAll(dummyListData);
|
|
});
|
|
return;
|
|
} else {
|
|
setState(() {
|
|
items.clear();
|
|
items.addAll(widget.masterList);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
class AddExaminationWidget extends StatefulWidget {
|
|
MasterKeyModel item;
|
|
final Function(MasterKeyModel) removeHistory;
|
|
final Function(MySelectedExamination) addHistory;
|
|
final bool Function(MasterKeyModel) isServiceSelected;
|
|
bool isExpand;
|
|
final Function expandClick;
|
|
|
|
AddExaminationWidget({
|
|
this.item,
|
|
this.removeHistory,
|
|
this.addHistory,
|
|
this.isServiceSelected,
|
|
this.isExpand,
|
|
this.expandClick,
|
|
});
|
|
|
|
@override
|
|
_AddExaminationWidgetState createState() => _AddExaminationWidgetState();
|
|
}
|
|
|
|
class _AddExaminationWidgetState extends State<AddExaminationWidget> {
|
|
int status = 3;
|
|
TextEditingController remarksController = TextEditingController();
|
|
MySelectedExamination examination = MySelectedExamination();
|
|
|
|
@override
|
|
void initState() {
|
|
|
|
examination.selectedExamination = widget.item;
|
|
super.initState();
|
|
}
|
|
@override
|
|
Widget build(BuildContext context) {
|
|
ProjectViewModel projectViewModel = Provider.of(context);
|
|
|
|
return Container(
|
|
child: HeaderBodyExpandableNotifier(
|
|
headerWidget: Row(
|
|
mainAxisAlignment: MainAxisAlignment.spaceBetween,
|
|
children: [
|
|
Expanded(
|
|
child: CheckboxListTile(
|
|
title: AppText(
|
|
projectViewModel.isArabic
|
|
? widget.item.nameAr != null && widget.item.nameAr != ""
|
|
? widget.item.nameAr
|
|
: widget.item.nameEn
|
|
: widget.item.nameEn,
|
|
fontWeight: FontWeight.normal,
|
|
fontFamily: 'Poppins',
|
|
fontSize: SizeConfig.textMultiplier * 2.0,
|
|
),
|
|
value: widget.isServiceSelected(widget.item),
|
|
activeColor: HexColor("#D02127"),
|
|
onChanged: (newValue) {
|
|
setState(() {
|
|
if (widget.isServiceSelected(widget.item)) {
|
|
widget.removeHistory(widget.item);
|
|
widget.expandClick();
|
|
} else {
|
|
examination.isNormal = status == 1;
|
|
examination.isAbnormal = status == 2;
|
|
examination.notExamined = status == 3;
|
|
examination.remark = remarksController.text;
|
|
widget.addHistory(examination);
|
|
widget.expandClick();
|
|
}
|
|
});
|
|
},
|
|
controlAffinity: ListTileControlAffinity.leading,
|
|
contentPadding: EdgeInsets.all(0),
|
|
),
|
|
),
|
|
Container(
|
|
margin: EdgeInsets.symmetric(horizontal: 8),
|
|
child: InkWell(
|
|
onTap: widget.expandClick,
|
|
child: Icon(widget.isExpand
|
|
? Icons.keyboard_arrow_up
|
|
: Icons.keyboard_arrow_down)),
|
|
),
|
|
],
|
|
),
|
|
bodyWidget: Container(
|
|
padding: EdgeInsets.symmetric(horizontal: 12),
|
|
child: Column(
|
|
crossAxisAlignment: CrossAxisAlignment.start,
|
|
children: [
|
|
Container(
|
|
margin: EdgeInsets.only(bottom: 8),
|
|
child: AppText(
|
|
TranslationBase.of(context).status,
|
|
fontWeight: FontWeight.bold,
|
|
fontFamily: 'Poppins',
|
|
fontSize: SizeConfig.textMultiplier * 1.6,
|
|
),
|
|
),
|
|
Row(
|
|
children: [
|
|
Expanded(
|
|
child: Row(
|
|
children: [
|
|
InkWell(
|
|
onTap: () {
|
|
setState(() {
|
|
status = 1;
|
|
});
|
|
examination.isNormal = true;
|
|
examination.isAbnormal = false;
|
|
examination.notExamined = false;
|
|
},
|
|
child: Container(
|
|
padding: EdgeInsets.all(2.0),
|
|
margin: EdgeInsets.symmetric(horizontal: 6),
|
|
width: 20,
|
|
height: 20,
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
shape: BoxShape.circle,
|
|
border: Border.all(color: Colors.grey, width: 1),
|
|
),
|
|
child: Container(
|
|
decoration: BoxDecoration(
|
|
color: status == 1
|
|
? HexColor("#D02127")
|
|
: Colors.white,
|
|
shape: BoxShape.circle,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
AppText(
|
|
TranslationBase.of(context).normal,
|
|
fontWeight: FontWeight.normal,
|
|
fontFamily: 'Poppins',
|
|
fontSize: SizeConfig.textMultiplier * 1.6,
|
|
),
|
|
],
|
|
)),
|
|
Expanded(
|
|
child: Row(
|
|
children: [
|
|
InkWell(
|
|
onTap: () {
|
|
setState(() {
|
|
status = 2;
|
|
});
|
|
examination.isNormal = false;
|
|
examination.isAbnormal = true;
|
|
examination.notExamined = false;
|
|
},
|
|
child: Container(
|
|
padding: EdgeInsets.all(2.0),
|
|
margin: EdgeInsets.symmetric(horizontal: 6),
|
|
width: 20,
|
|
height: 20,
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
shape: BoxShape.circle,
|
|
border: Border.all(color: Colors.grey, width: 1),
|
|
),
|
|
child: Container(
|
|
decoration: BoxDecoration(
|
|
color: status == 2
|
|
? HexColor("#D02127")
|
|
: Colors.white,
|
|
shape: BoxShape.circle,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
AppText(
|
|
TranslationBase.of(context).abnormal,
|
|
fontWeight: FontWeight.normal,
|
|
fontFamily: 'Poppins',
|
|
fontSize: SizeConfig.textMultiplier * 1.6,
|
|
),
|
|
],
|
|
)),
|
|
Expanded(
|
|
child: Row(
|
|
children: [
|
|
InkWell(
|
|
onTap: () {
|
|
setState(() {
|
|
status = 3;
|
|
});
|
|
examination.isNormal = false;
|
|
examination.isAbnormal = false;
|
|
examination.notExamined = true;
|
|
},
|
|
child: Container(
|
|
padding: EdgeInsets.all(2.0),
|
|
margin: EdgeInsets.symmetric(horizontal: 6),
|
|
width: 20,
|
|
height: 20,
|
|
decoration: BoxDecoration(
|
|
color: Colors.white,
|
|
shape: BoxShape.circle,
|
|
border: Border.all(color: Colors.grey, width: 1),
|
|
),
|
|
child: Container(
|
|
decoration: BoxDecoration(
|
|
color: status == 3
|
|
? HexColor("#D02127")
|
|
: Colors.white,
|
|
shape: BoxShape.circle,
|
|
),
|
|
),
|
|
),
|
|
),
|
|
Expanded(
|
|
child: AppText(
|
|
TranslationBase.of(context).notExamined,
|
|
fontWeight: FontWeight.normal,
|
|
fontFamily: 'Poppins',
|
|
fontSize: SizeConfig.textMultiplier * 1.6,
|
|
),
|
|
),
|
|
],
|
|
)),
|
|
],
|
|
),
|
|
Container(
|
|
margin: EdgeInsets.only(top: 8),
|
|
child: AppTextFieldCustom(
|
|
hintText: TranslationBase.of(context).remarks,
|
|
controller: remarksController,
|
|
minLines: 2,
|
|
maxLines: 4,
|
|
inputType: TextInputType.multiline,
|
|
onChanged: (value){
|
|
examination.remark = value;
|
|
},
|
|
),
|
|
),
|
|
],
|
|
),
|
|
),
|
|
isExpand: widget.isExpand,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
|
|
extension FicListExtension<T> on List<T> {
|
|
/// Maps each element of the list.
|
|
/// The [map] function gets both the original [item] and its [index].
|
|
Iterable<E> mapIndexed<E>(E Function(int index, T item) map) sync* {
|
|
for (var index = 0; index < length; index++) {
|
|
yield map(index, this[index]);
|
|
}
|
|
}
|
|
}
|