You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1710 lines
55 KiB
1710 lines
55 KiB
import 'dart:io';
|
|
import 'package:flutter/material.dart';
|
|
import 'dart:convert';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:doctor/common/preloader.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'dart:async';
|
|
import 'package:geolocator/geolocator.dart';
|
|
import 'package:fluttertoast/fluttertoast.dart';
|
|
import 'package:http/http.dart' as http;
|
|
|
|
//const Color primaryColor = Color(0XFF1786A3);
|
|
const Color primaryColor = Color(0XFF99405B);
|
|
const Color secondaryColor = Color(0XFFD9D9D9);
|
|
const Color buttonColors = Color(0XFF1786A3);
|
|
const Color greyColor = Color(0XFF8F8E8E);
|
|
const Color textFieldStartColor = Colors.grey;
|
|
const Color screenBackgroundColor = Color(0XFFEAF6FF);
|
|
const Color screenBackgroundColord = Colors.black12;
|
|
const Color dashboardbackground = Color(0XFFF5F5F5);
|
|
|
|
//Color AppBarGradient_1 = Color(0XFF1258F6);
|
|
Color AppBarGradient_1 = Color(0XFF99405B);
|
|
|
|
TextStyle PreloaderText() {
|
|
return TextStyle(color: Color(0XFF99405B));
|
|
}
|
|
|
|
TextStyle labelTextStyle() {
|
|
return TextStyle(color: primaryColor, fontSize: 12);
|
|
}
|
|
|
|
TextStyle labelTextStyleOrderMedicine() {
|
|
return TextStyle(color: primaryColor, fontSize: 12,fontWeight: FontWeight.bold);
|
|
}
|
|
|
|
TextStyle haveMotorTextStyle() {
|
|
return TextStyle(
|
|
color: Colors.red, fontSize: 12, fontWeight: FontWeight.bold);
|
|
}
|
|
|
|
TextStyle textButtonStyle() {
|
|
return TextStyle(color: primaryColor, fontSize: 15);
|
|
}
|
|
|
|
TextStyle textButtonStyleReports() {
|
|
return TextStyle(color: Colors.white, fontSize: 12);
|
|
}
|
|
|
|
TextStyle iconBelowTextStyle() {
|
|
return TextStyle(fontSize: 10, color: primaryColor);
|
|
}
|
|
|
|
TextStyle valuesTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle recordDetailsHeading() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle problemTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.red
|
|
);
|
|
}
|
|
|
|
TextStyle headingsTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
color: primaryColor
|
|
);
|
|
}
|
|
|
|
TextStyle startAndStopHeading() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.bold,
|
|
color: primaryColor,
|
|
);
|
|
}
|
|
|
|
Text capacitySuffixText() {
|
|
return Text('in Ltrs.');
|
|
}
|
|
|
|
Text dimensionSuffixText() {
|
|
return Text('in fts');
|
|
}
|
|
|
|
TextStyle dashboardTextStyle() {
|
|
return TextStyle(
|
|
color: Colors.white,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle labelTextStyleBold() {
|
|
return TextStyle(
|
|
color: primaryColor,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle serverIssueTextStyle() {
|
|
return TextStyle(color: Colors.red, fontSize: 15);
|
|
}
|
|
|
|
TextStyle bottomSheetValuesTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
overflow: TextOverflow.ellipsis,
|
|
);
|
|
}
|
|
|
|
TextStyle wrapTextStyle() {
|
|
return TextStyle(
|
|
color: primaryColor,
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
overflow: TextOverflow.ellipsis,
|
|
);
|
|
}
|
|
|
|
TextStyle wrapTextStyleBlack() {
|
|
return TextStyle(
|
|
color: Colors.black,
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
overflow: TextOverflow.ellipsis,
|
|
);
|
|
}
|
|
|
|
TextStyle withoutWrapTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle bmiTextStyle() {
|
|
return TextStyle(
|
|
color: primaryColor,
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle drawerListItemsTextStyle() {
|
|
return TextStyle(color: Colors.white);
|
|
}
|
|
|
|
TextStyle drawerHeaderTextStyle() {
|
|
return TextStyle(color: Colors.white, fontSize: 15);
|
|
}
|
|
|
|
TextStyle drawerHeaderTextStyleNew() {
|
|
return TextStyle(color: Colors.black, fontSize: 15);
|
|
}
|
|
|
|
TextStyle textFormFieldFilledTextStyle() {
|
|
return TextStyle(color: secondaryColor);
|
|
}
|
|
|
|
|
|
InputDecoration textFormFieldDecoration(IconData icon, var text) {
|
|
return InputDecoration(
|
|
filled: true,
|
|
fillColor: primaryColor,
|
|
prefixIcon: Icon(
|
|
icon,
|
|
color: secondaryColor,
|
|
),
|
|
border: OutlineInputBorder(borderSide: BorderSide(color: secondaryColor)),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: secondaryColor),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: secondaryColor),
|
|
),
|
|
labelText: text,
|
|
/*labelStyle: TextStyle(
|
|
color: myFocusNode.hasFocus ? Colors.blue : Colors.black
|
|
)*/
|
|
labelStyle: TextStyle(
|
|
color: secondaryColor,fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationGrey(IconData icon, var text) {
|
|
return InputDecoration(
|
|
prefixIcon: Icon(
|
|
icon,
|
|
color: greyColor,
|
|
),
|
|
border: OutlineInputBorder(
|
|
borderSide: BorderSide(color: greyColor)),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle: TextStyle(
|
|
color: greyColor, //<-- SEE HERE
|
|
),
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationInsideApp(IconData icon, var text) {
|
|
return InputDecoration(
|
|
prefixIcon: Icon(
|
|
icon,
|
|
color: primaryColor,
|
|
),
|
|
border: OutlineInputBorder(
|
|
borderSide: BorderSide(color: primaryColor)),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: primaryColor),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: primaryColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle: TextStyle(
|
|
color: primaryColor, //<-- SEE HERE
|
|
),
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationBMI(IconData icon, var text) {
|
|
return InputDecoration(
|
|
//filled: true,
|
|
//fillColor: Colors.white,
|
|
prefixIcon: Icon(
|
|
icon,
|
|
color: primaryColor,
|
|
),
|
|
border: OutlineInputBorder(borderSide: BorderSide(color: primaryColor)),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: primaryColor),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderSide: BorderSide(color: primaryColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle: TextStyle(
|
|
color: Colors.grey, //<-- SEE HERE
|
|
),
|
|
);
|
|
}
|
|
|
|
final GlobalKey<State> preloaderWindowKey = new GlobalKey<State>();
|
|
Future<void> preloaderWindow(BuildContext context) async {
|
|
try {
|
|
Dialogs.showLoadingDialog(context, preloaderWindowKey);
|
|
} catch (error) {}
|
|
}
|
|
|
|
class AppSettings {
|
|
static SharedPreferences sharedPreferences =
|
|
SharedPreferences.getInstance() as SharedPreferences;
|
|
static String doctorName = '';
|
|
static String specialization = '';
|
|
static String qualification = '';
|
|
static List placeOfPractices = [];
|
|
static String placeOfPractice1 = '';
|
|
static String placeOfPractice2 = '';
|
|
static String placeOfPractice3 = '';
|
|
static String placeOfPracticeAddress1 = '';
|
|
static String placeOfPracticeAddress2 = '';
|
|
static String placeOfPracticeAddress3 = '';
|
|
static String doctorAddress = '';
|
|
static String email = '';
|
|
static String age = '';
|
|
static String gender = '';
|
|
static String phoneNumber = '';
|
|
static String accessToken = '';
|
|
static String doctorId = '';
|
|
static double doctorLatitude = 0;
|
|
static double doctorLongitude = 0;
|
|
static String customerIdsign = '';
|
|
static String profileImage = '';
|
|
static List<String> storedPreferenceValidKeys = ['doctorname', 'access_token'];
|
|
static String preloadText = 'Please wait';
|
|
static String latitude = '';
|
|
static String longitude = '';
|
|
static bool servicestatus = false;
|
|
static bool haspermission = false;
|
|
static late LocationPermission permission;
|
|
static late Position position;
|
|
static String long = "", lat = "";
|
|
late StreamSubscription<Position> positionStream;
|
|
static String fcmId = '';
|
|
static String serverToken =
|
|
'AAAAA66BLaA:APA91bHcmbyiNN8hCL-t-M9oH-u7ZMOl74fcImMM2DQZLgdyY98Wu9XxME-CTPcjpjU6Yy48ouxISrOMb9lpa3PJofh8qciUKMNxV2al-bDvGvPP_VVaH0mrTHzR56hdkGy1Zl-0frDO';
|
|
|
|
static String qrCode = '';
|
|
static String originalQrCode = '';
|
|
|
|
|
|
//api urls
|
|
//static String host = 'http://35.200.129.165:4000/api/';
|
|
static String host = 'http://cloudh.in:4000/api/';
|
|
static String loginUrl = host + 'doctorlogin';
|
|
static String signUpUrl = host + 'addDoctor';
|
|
static String sendSmsUrl = host + 'sendSms';
|
|
static String phoneVerificationUrl = host + 'doctorphone';
|
|
static String uploadPicUrl = host + 'uploadsDoctorProfilePicture';
|
|
static String updateProfileUrl = host + 'updateDoctor';
|
|
static String resetTokenUrl = host + 'reset_token';
|
|
static String generateQRCodeUrl = host + 'generate-qrcode-doctor';
|
|
static String getAllConectedPatientsDataUrl = host + 'customerDetails';
|
|
static String getRecordsDataUrl = host + 'getAllRecords';
|
|
static String deleteRecordUrl = host + 'deleteRecord';
|
|
static String getDynamicCodeUrl = host + 'records';
|
|
static String dynamicCodeVerificationUrl = host + 'verifyDynamicCode';
|
|
static String getPatientInformationBasedOnMobileNumberUrl = host + 'getInfoCustomerDataPhone';
|
|
static String getBmiHistoryUrl = host + 'usersbmi';
|
|
static String getBpHistoryUrl = host + 'usersbp';
|
|
static String getSugarHistoryUrl = host + 'userssugar';
|
|
static String bmiCaluculateUrl = host + 'insertBMI';
|
|
static String bpCaluculateUrl = host + 'insertBP';
|
|
static String sugarCaluculateUrl = host + 'insertSugar';
|
|
static String deleteBMIDetailsUrl = host + 'deleteBMI';
|
|
static String deleteBPDetailsUrl = host + 'deleteBP';
|
|
static String deleteSugarDetailsUrl = host + 'deleteSugar';
|
|
static String findingsUploadPicUrl = host + 'uploads-findings-prescription';
|
|
static String addFindingsUrl = host + 'update-uploads-findingsPictureId-prescription';
|
|
static String addReportsUrl = host + 'update-uploads-reportsPictureId-prescription';
|
|
static String addPrescriptionsUrl = host + 'update-uploads-prescriptionPictureId-prescription';
|
|
static String updateFindingsUploadPicUrl = host + 'update-uploads-findings-prescription';
|
|
static String updateReportsUploadPicUrl = host + 'update-uploads-reports-prescription';
|
|
static String reportsUploadPicUrl = host + 'uploads-reports-prescription';
|
|
static String prescriptionUploadPicUrl = host + 'uploads-prescription-prescription';
|
|
static String updatePrescriptionPicUrl = host + 'update-uploads-prescription-prescription';
|
|
static String deleteRecordsUrl = host + 'delete-url';
|
|
static String updateRecordsUrl = host + 'records';
|
|
static String deleteFindingsUrl = host + 'delete-uploads-findings';
|
|
static String deletePrescriptionsUrl = host + 'delete-prescription';
|
|
static String deleteReportsUrl = host + 'delete-report';
|
|
static String getAllConnectedDoctorsDataUrl = host + 'connected-doctors';
|
|
static String addRecordsUrl = host + 'add-record';
|
|
static String addPrescriptionUrl = host + 'add-prescription-details';
|
|
static String getAllReportProblemDetalisUrl = host + 'userreport';
|
|
|
|
|
|
static File? updatedImage;
|
|
static String image = '';
|
|
static String profilePictureUrl = '';
|
|
|
|
/*Formatter*/
|
|
static String formNum(String s) {
|
|
var comma = NumberFormat('#,##,###', 'en_IN');
|
|
return comma.format(
|
|
int.parse(s),
|
|
);
|
|
}
|
|
|
|
static String formDouble(String s) {
|
|
var comma = NumberFormat('#,##,###.##', 'en_IN');
|
|
return comma.format(
|
|
double.parse(s),
|
|
);
|
|
}
|
|
|
|
/* Preloader */
|
|
static GlobalKey<State> preLoaderKey = new GlobalKey<State>();
|
|
|
|
static Future<void> preLoaderDialog(BuildContext context) async {
|
|
try {
|
|
preLoaderKey = new GlobalKey<State>();
|
|
Dialogs.showLoadingDialog(context, preLoaderKey);
|
|
} catch (error) {}
|
|
}
|
|
|
|
////request headers with content type
|
|
static Future<Map<String, String>> buildRequestHeaders() async {
|
|
Map<String, String> _headers = new Map<String, String>();
|
|
_headers[HttpHeaders.contentTypeHeader] = 'application/json';
|
|
_headers['Authorization'] = accessToken;
|
|
return _headers;
|
|
}
|
|
|
|
//request headers without content type
|
|
static Future<Map<String, String>> buildPutRequestHeaders() async {
|
|
Map<String, String> _headers = new Map<String, String>();
|
|
_headers['Authorization'] = accessToken;
|
|
return _headers;
|
|
}
|
|
|
|
static Future<Map<String, String>> buildPutRequestHeadersForResetToken() async {
|
|
Map<String, String> _headers = new Map<String, String>();
|
|
return _headers;
|
|
}
|
|
|
|
// Shared preferences save,get and clear data
|
|
static saveData(String _key, _value, type) async {
|
|
sharedPreferences = await SharedPreferences.getInstance();
|
|
|
|
if (type == 'STRING') {
|
|
await sharedPreferences.setString(_key, _value.toString());
|
|
} else if (type == 'INTEGER') {
|
|
await sharedPreferences.setInt(_key, _value);
|
|
} else if (type == 'BOOL') {
|
|
await sharedPreferences.setBool(_key, _value);
|
|
} else if (type == 'DOUBLE') {
|
|
await sharedPreferences.setDouble(_key, _value);
|
|
}
|
|
else if (type == 'LIST') {
|
|
await sharedPreferences.setStringList(_key, _value);
|
|
}
|
|
}
|
|
|
|
static getData(String _key, type) async {
|
|
sharedPreferences = await SharedPreferences.getInstance();
|
|
if (type == 'STRING') {
|
|
return sharedPreferences.getString(_key) ?? '';
|
|
} else if (type == 'INTEGER') {
|
|
return sharedPreferences.getInt(_key) ?? -1;
|
|
} else if (type == 'BOOL') {
|
|
return sharedPreferences.getBool(_key) ?? -1;
|
|
} else if (type == 'DOUBLE') {
|
|
return sharedPreferences.getDouble(_key) ?? -1;
|
|
}
|
|
else if (type == 'LIST') {
|
|
return sharedPreferences.getStringList(_key) ?? -1;
|
|
}
|
|
}
|
|
|
|
static clearSharedPrefeences() async {
|
|
sharedPreferences = await SharedPreferences.getInstance();
|
|
await sharedPreferences.clear();
|
|
}
|
|
|
|
/*Sign in check*/
|
|
static Future<bool> isSigIn() async {
|
|
bool isSignInCheck = true;
|
|
for (var eachKey in storedPreferenceValidKeys) {
|
|
if (await getData(eachKey, 'STRING') == '') {
|
|
isSignInCheck = false;
|
|
}
|
|
}
|
|
return isSignInCheck;
|
|
}
|
|
|
|
static Future<bool> internetConnectivity() async {
|
|
try {
|
|
final result = await InternetAddress.lookup('google.com');
|
|
if (result.isNotEmpty && result[0].rawAddress.isNotEmpty) {
|
|
return true;
|
|
}
|
|
} on SocketException catch (_) {
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/*Apis Starts here*/
|
|
|
|
static Future<bool> signUp(payload) async {
|
|
var response = await http.post(Uri.parse(signUpUrl),
|
|
body: json.encode(payload),
|
|
headers: {'Content-type': 'application/json'});
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> sendSms(payload) async {
|
|
var response = await http.post(Uri.parse(sendSmsUrl),
|
|
body: json.encode(payload),
|
|
headers: {'Content-type': 'application/json'});
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> phoneVerification(payload) async {
|
|
var response = await http.post(Uri.parse(phoneVerificationUrl),
|
|
body: json.encode(payload),
|
|
headers: {'Content-type': 'application/json'});
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> login(payload) async {
|
|
var response = await http.post(Uri.parse(loginUrl),
|
|
body: json.encode(payload),
|
|
headers: {'Content-type': 'application/json'});
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
|
|
if (_response['simplydata']['error'] == false) {
|
|
await saveAvailableReportAndLocationsInMemory(_response);
|
|
//await saveProfilePic(_response);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> resetToken() async {
|
|
var uri = Uri.parse(resetTokenUrl + '/' + doctorId);
|
|
|
|
try {
|
|
// var response = await http.get(uri, headers: await buildPutRequestHeaders());
|
|
var response = await http.get(uri,
|
|
headers: await buildPutRequestHeadersForResetToken());
|
|
if (response.statusCode == 200) {
|
|
print(response.body);
|
|
var res = jsonDecode(response.body);
|
|
print(res);
|
|
|
|
accessToken = res['access_token'];
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> uploadImageHTTPNew(file) async {
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(uploadPicUrl + '/' + doctorId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<bool> updateProfile(payload) async {
|
|
var uri = Uri.parse(updateProfileUrl + '/' + doctorId);
|
|
try {
|
|
var response = await http.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
var _response = json.decode(response.body);
|
|
|
|
doctorName = _response['armintahealthdata']['doctorName'];
|
|
phoneNumber = _response['armintahealthdata']['phone'];
|
|
email = _response['armintahealthdata']['emails'][0]['email'];
|
|
age = _response['armintahealthdata']['age'].toString();
|
|
gender=_response['armintahealthdata']['gender'].toString();
|
|
specialization=_response['armintahealthdata']['specialization'].toString();
|
|
qualification=_response['armintahealthdata']['qualification'].toString();
|
|
if(_response['armintahealthdata']['placeOfPractice'].length>0){
|
|
placeOfPractice1=_response['armintahealthdata']['placeOfPractice'][0]['hospitalName']??'';
|
|
placeOfPracticeAddress1=_response['armintahealthdata']['placeOfPractice'][0]['address']??'';
|
|
}
|
|
|
|
|
|
await saveData('phone', _response['armintahealthdata']['phone'], 'STRING');
|
|
await saveData('email', _response['armintahealthdata']['emails'][0]['email'], 'STRING');
|
|
await saveData('doctorname', _response['armintahealthdata']['doctorName'], 'STRING');
|
|
await saveData('age', _response['armintahealthdata']['age'].toString(), 'STRING');
|
|
await saveData('specialization', _response['armintahealthdata']['specialization'], 'STRING');
|
|
await saveData('qualification', _response['armintahealthdata']['qualification'], 'STRING');
|
|
await saveData('gender', _response['armintahealthdata']['gender'], 'STRING');
|
|
if(_response['armintahealthdata']['placeOfPractice'].length>0){
|
|
await saveData('placeOfPractice1',_response['armintahealthdata']['placeOfPractice'][0]['hospitalName']??'', 'STRING');
|
|
await saveData('placeOfPracticeAddress1', _response['armintahealthdata']['placeOfPractice'][0]['address']??'', 'STRING');
|
|
}
|
|
|
|
await loadDataFromMemory();
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> generateQRCode() async {
|
|
var uri = Uri.parse(generateQRCodeUrl + '/' + doctorId);
|
|
|
|
var response = await http.post(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getAllConectedPatients() async {
|
|
var uri = Uri.parse(getAllConectedPatientsDataUrl + '/' + doctorId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getAllRecords(customerId) async {
|
|
var uri = Uri.parse(getRecordsDataUrl + '/' + customerId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteRecord(recordId) async {
|
|
var uri = Uri.parse(deleteRecordUrl + '/' + recordId);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static Future<String> getDynamicCode(payload) async {
|
|
var uri = Uri.parse(getDynamicCodeUrl );
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.post(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> dynamicCodeVerification(payload) async {
|
|
var uri = Uri.parse(dynamicCodeVerificationUrl + '/'+doctorId);
|
|
var response = await http.post(uri, body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
}
|
|
else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri, body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> getPatientInformationBasedOnMobileNumber(phoneNumber) async {
|
|
var uri = Uri.parse(getPatientInformationBasedOnMobileNumberUrl + '/' + phoneNumber);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getBmiHistory(var customerId) async {
|
|
var uri = Uri.parse(getBmiHistoryUrl + '/' + customerId);
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getBPHistory(var customerId) async {
|
|
var uri = Uri.parse(getBpHistoryUrl + '/' + customerId);
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getSugarHistory(var customerId) async {
|
|
var uri = Uri.parse(getSugarHistoryUrl + '/' + customerId);
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> calculateBmi(payload,customerId) async {
|
|
var uri = Uri.parse(bmiCaluculateUrl + '/' + customerId);
|
|
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> calculateBP(payload,customerId) async {
|
|
var uri = Uri.parse(bpCaluculateUrl + '/' + customerId);
|
|
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> calculateSugar(payload,customerId) async {
|
|
var uri = Uri.parse(sugarCaluculateUrl + '/' + customerId);
|
|
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteBMIDetails(bmiId,customerId) async {
|
|
var uri = Uri.parse(deleteBMIDetailsUrl + '/' + customerId+'/'+ bmiId);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteBPDetails(bmiId,customerId) async {
|
|
var uri = Uri.parse(deleteBPDetailsUrl + '/' + customerId+'/'+ bmiId);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteSugarDetails(bmiId,customerId) async {
|
|
var uri = Uri.parse(deleteSugarDetailsUrl + '/' + customerId+'/'+ bmiId);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/*upload and update findings*/
|
|
|
|
static Future<String> uploadFindingsGallery(file,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(findingsUploadPicUrl + '/' + customerId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> uploadFindingsCamera(file,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(findingsUploadPicUrl + '/' + customerId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addFindingsGallery(file,pictureId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'PUT', Uri.parse(addFindingsUrl + '/' + customerId+"/"+pictureId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addFindingsCamera(file,pictureId,customerId) async {
|
|
var request = http.MultipartRequest('PUT', Uri.parse(addFindingsUrl + '/' + customerId+"/"+pictureId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updateFindingsGallery(file,var recordId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(updateFindingsUploadPicUrl + '/' + customerId+'/'+recordId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updateFindingsCamera(file,var recordId,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(updateFindingsUploadPicUrl + '/' + customerId+'/'+recordId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
/*End*/
|
|
|
|
|
|
/*upload and update Reports*/
|
|
|
|
static Future<String> uploadReportsGallery(file,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(reportsUploadPicUrl + '/' + customerId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> uploadReportsCamera(file,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(reportsUploadPicUrl + '/' + customerId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addReportsGallery(file,pictureId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'PUT', Uri.parse(addReportsUrl + '/' + customerId+"/"+pictureId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addReportsCamera(file,pictureId,customerId) async {
|
|
var request = http.MultipartRequest('PUT', Uri.parse(addReportsUrl + '/' + customerId+"/"+pictureId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updateReportsGallery(file,var recordId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(updateReportsUploadPicUrl + '/' + customerId+'/'+recordId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updateReportsCamera(file,var recordId,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(updateReportsUploadPicUrl + '/' + customerId+'/'+recordId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
/*End*/
|
|
|
|
|
|
/*upload and update Prescriptions*/
|
|
|
|
static Future<String> uploadPrescriptionsGallery(file,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(prescriptionUploadPicUrl + '/' + customerId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> uploadPrescriptionsCamera(file,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(prescriptionUploadPicUrl + '/' + customerId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addPrescriptionsGallery(file,pictureId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'PUT', Uri.parse(addPrescriptionsUrl + '/' + customerId+"/"+pictureId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> addPrescriptionsCamera(file,pictureId,customerId) async {
|
|
var request = http.MultipartRequest('PUT', Uri.parse(addPrescriptionsUrl + '/' + customerId+"/"+pictureId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updatePrescriptionsGallery(file,var recordId,customerId) async {
|
|
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(updatePrescriptionPicUrl + '/' + customerId+'/'+recordId));
|
|
if (file.length > 0) {
|
|
for (var i = 0; i < file.length; i++) {
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file[i].path));
|
|
}}
|
|
// request.files.add(await http.MultipartFile.fromPath('picture', images.toString().replaceAll('[', '').replaceAll(']','')));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<String> updatePrescriptionsCamera(file,var recordId,customerId) async {
|
|
var request = http.MultipartRequest('POST', Uri.parse(updatePrescriptionPicUrl + '/' + customerId+'/'+recordId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
/*End*/
|
|
|
|
static Future<String> deleteRecordsNew(payload, recordId,customerId) async {
|
|
var uri = Uri.parse(deleteRecordsUrl + '/' + customerId+'/'+recordId);
|
|
|
|
try {
|
|
var response = await http.post(uri, body: json.encode(payload),headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> updateRecord(payload,recordId) async {
|
|
var uri = Uri.parse(updateRecordsUrl + '/' + recordId);
|
|
var response = await http.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> deleteFindings(fileName,findingsId,customerId) async {
|
|
var uri = Uri.parse(deleteFindingsUrl + '/' + customerId+'/'+findingsId+'/'+fileName);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> deletePrescriptions(fileName,prescriptionId,customerId) async {
|
|
var uri = Uri.parse(deletePrescriptionsUrl + '/' + customerId+'/'+prescriptionId+'/'+fileName);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> deleteReports(fileName,reportsId,customerId) async {
|
|
var uri = Uri.parse(deleteReportsUrl + '/' + customerId+'/'+reportsId+'/'+fileName);
|
|
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.delete(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getAllConnectedDoctors(customerId) async {
|
|
var uri = Uri.parse(getAllConnectedDoctorsDataUrl + '/' + customerId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> addRecords(payload,customerId) async {
|
|
var uri = Uri.parse(addRecordsUrl + '/' + customerId);
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> uploadImageHTTPForPrescriptions(file,customerId) async {
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(prescriptionUploadPicUrl + '/' + customerId));
|
|
request.files.add(await http.MultipartFile.fromPath('picture', file.path));
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<bool> addPrescription(payload,customerId) async {
|
|
var uri = Uri.parse(addPrescriptionUrl + '/' + customerId);
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> getAllReportProblemDetalis(customerId) async {
|
|
var uri = Uri.parse(getAllReportProblemDetalisUrl+'/'+customerId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*Apis ends here*/
|
|
|
|
//save data local
|
|
static Future<void> saveAvailableReportAndLocationsInMemory(dynamic input) async {
|
|
// save login name information
|
|
await saveData('doctorname', input['simplydata']['doctorName'], 'STRING');
|
|
await saveData('access_token', input['simplydata']['access_token'], 'STRING');
|
|
await saveData('phone', input['simplydata']['phone'], 'STRING');
|
|
await saveData('email', input['simplydata']['email'][0]['email'], 'STRING');
|
|
await saveData('doctorId', input['simplydata']['doctorId'], 'STRING');
|
|
await saveData('profile', input['simplydata']['picture'], 'STRING');
|
|
await saveData('user_address', input['simplydata']['address1'], 'STRING');
|
|
await saveData('latitude', input['simplydata']['latitude'], 'DOUBLE');
|
|
await saveData('longitude', input['simplydata']['longitude'], 'DOUBLE');
|
|
await saveData('fcmId', input['simplydata']['fcmId'], 'STRING');
|
|
await saveData('age', input['simplydata']['age'], 'STRING');
|
|
await saveData('gender', input['simplydata']['gender'], 'STRING');
|
|
await saveData('qrCode', input['simplydata']['qrCode'], 'STRING');
|
|
await saveData('specialization', input['simplydata']['specialization'], 'STRING');
|
|
await saveData('qualification', input['simplydata']['qualification'], 'STRING');
|
|
if(input['simplydata']['placeOfPractice'].length>0){
|
|
await saveData('placeOfPractice1', input['simplydata']['placeOfPractice'][0]['hospitalName']??'', 'STRING');
|
|
await saveData('placeOfPractice2', input['simplydata']['placeOfPractice'][1]['hospitalName']??'', 'STRING');
|
|
await saveData('placeOfPractice3', input['simplydata']['placeOfPractice'][2]['hospitalName']??'', 'STRING');
|
|
await saveData('placeOfPracticeAddress1', input['simplydata']['placeOfPractice'][0]['address']??'', 'STRING');
|
|
await saveData('placeOfPracticeAddress2', input['simplydata']['placeOfPractice'][1]['address']??'', 'STRING');
|
|
await saveData('placeOfPracticeAddress3', input['simplydata']['placeOfPractice'][2]['address']??'', 'STRING');
|
|
}
|
|
|
|
//await saveData('age', input['simplydata']['age'], 'STRING');
|
|
//latitude,longitude
|
|
await loadDataFromMemory();
|
|
}
|
|
|
|
static Future<void> loadDataFromMemory() async {
|
|
doctorName = await getData('doctorname', 'STRING');
|
|
accessToken = await getData('access_token', 'STRING');
|
|
email = await getData('email', 'STRING');
|
|
doctorAddress = await getData('user_address', 'STRING');
|
|
phoneNumber = await getData('phone', 'STRING');
|
|
doctorId = await getData('doctorId', 'STRING');
|
|
doctorLatitude = await getData('latitude', 'DOUBLE');
|
|
doctorLongitude = await getData('longitude', 'DOUBLE');
|
|
profilePictureUrl = await getData('profile', 'STRING');
|
|
specialization= await getData('specialization', 'STRING');
|
|
qualification= await getData('qualification', 'STRING');
|
|
fcmId = await getData('fcmId', 'STRING');
|
|
age = await getData('age', 'STRING');
|
|
gender = await getData('gender', 'STRING');
|
|
originalQrCode = await getData('qrCode', 'STRING');
|
|
String dataUri = originalQrCode;
|
|
|
|
// Split the data URI at the comma to extract the Base64 part
|
|
List<String> parts = dataUri.split(",");
|
|
String? base64String = parts.length == 2 ? parts[1] : null;
|
|
|
|
if (base64String != null) {
|
|
qrCode=base64String;
|
|
} else {
|
|
print("Invalid data URI");
|
|
}
|
|
placeOfPractice1= await getData('placeOfPractice1', 'STRING');
|
|
placeOfPractice2= await getData('placeOfPractice2', 'STRING');
|
|
placeOfPractice3= await getData('placeOfPractice3', 'STRING');
|
|
placeOfPracticeAddress1= await getData('placeOfPracticeAddress1', 'STRING');
|
|
placeOfPracticeAddress2= await getData('placeOfPracticeAddress2', 'STRING');
|
|
placeOfPracticeAddress3= await getData('placeOfPracticeAddress3', 'STRING');
|
|
}
|
|
|
|
|
|
static void longSuccessToast(String message) {
|
|
Fluttertoast.showToast(
|
|
msg: message,
|
|
toastLength: Toast.LENGTH_SHORT,
|
|
gravity: ToastGravity.BOTTOM,
|
|
timeInSecForIosWeb: 1,
|
|
backgroundColor: Colors.green,
|
|
textColor: Colors.white,
|
|
fontSize: 16.0);
|
|
}
|
|
|
|
static void longSuccessToast1(String message) {
|
|
Fluttertoast.showToast(
|
|
msg: message,
|
|
toastLength: Toast.LENGTH_LONG,
|
|
gravity: ToastGravity.CENTER,
|
|
timeInSecForIosWeb: 1,
|
|
backgroundColor: Colors.green,
|
|
textColor: Colors.white,
|
|
fontSize: 16.0);
|
|
}
|
|
|
|
static void longFailedToast(String message) {
|
|
Fluttertoast.showToast(
|
|
msg: message,
|
|
toastLength: Toast.LENGTH_LONG,
|
|
gravity: ToastGravity.BOTTOM,
|
|
timeInSecForIosWeb: 1,
|
|
backgroundColor: Colors.red,
|
|
textColor: Colors.white,
|
|
fontSize: 16.0);
|
|
}
|
|
|
|
static Widget noDataUI(String _tabName) {
|
|
_tabName = _tabName ?? '';
|
|
return Container(
|
|
child: Column(
|
|
mainAxisAlignment: MainAxisAlignment.center,
|
|
children: <Widget>[
|
|
Image(
|
|
image: AssetImage('images/no_data.png'),
|
|
width: 200,
|
|
),
|
|
SizedBox(
|
|
height: 8,
|
|
),
|
|
Text(
|
|
'There is no data to show you right now.',
|
|
style: TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.grey[600],
|
|
fontFamily: 'Swis2',
|
|
),
|
|
),
|
|
SizedBox(
|
|
height: 5,
|
|
),
|
|
Text(
|
|
_tabName,
|
|
style: TextStyle(fontSize: 15, fontFamily: 'Swis1'),
|
|
),
|
|
],
|
|
),
|
|
);
|
|
}
|
|
|
|
static appBar(String title) {
|
|
title = title ?? '';
|
|
return AppBar(
|
|
backgroundColor: primaryColor,
|
|
title: Text(title),
|
|
);
|
|
}
|
|
|
|
/*location*/
|
|
static checkGps() async {
|
|
servicestatus = await Geolocator.isLocationServiceEnabled();
|
|
if (servicestatus) {
|
|
permission = await Geolocator.checkPermission();
|
|
|
|
if (permission == LocationPermission.denied) {
|
|
permission = await Geolocator.requestPermission();
|
|
if (permission == LocationPermission.denied) {
|
|
print('Location permissions are denied');
|
|
} else if (permission == LocationPermission.deniedForever) {
|
|
print("'Location permissions are permanently denied");
|
|
} else {
|
|
haspermission = true;
|
|
}
|
|
} else {
|
|
haspermission = true;
|
|
}
|
|
|
|
if (haspermission) {
|
|
/*setState(() {
|
|
//refresh the UI
|
|
});*/
|
|
|
|
await getLocation();
|
|
}
|
|
} else {
|
|
print("GPS Service is not enabled, turn on GPS location");
|
|
}
|
|
}
|
|
|
|
static getLocation() async {
|
|
position = await Geolocator.getCurrentPosition(
|
|
desiredAccuracy: LocationAccuracy.high);
|
|
/*print(position.longitude); //Output: 80.24599079
|
|
print(position.latitude);*/ //Output: 29.6593457
|
|
|
|
long = await position.longitude.toString();
|
|
lat = await position.latitude.toString();
|
|
|
|
/*setState(() {
|
|
//refresh UI
|
|
});*/
|
|
|
|
LocationSettings locationSettings = LocationSettings(
|
|
accuracy: LocationAccuracy.high, //accuracy of the location data
|
|
distanceFilter: 100, //minimum distance (measured in meters) a
|
|
//device must move horizontally before an update event is generated;
|
|
);
|
|
|
|
StreamSubscription<Position> positionStream =
|
|
Geolocator.getPositionStream(locationSettings: locationSettings)
|
|
.listen((Position position) {
|
|
print(position.longitude); //Output: 80.24599079
|
|
print(position.latitude); //Output: 29.6593457
|
|
|
|
long = position.longitude.toString();
|
|
lat = position.latitude.toString();
|
|
|
|
});
|
|
}
|
|
}
|