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.
4443 lines
125 KiB
4443 lines
125 KiB
import 'dart:io';
|
|
import 'dart:typed_data';
|
|
import 'package:bookatanker/common/preloader.dart';
|
|
import 'package:flutter/material.dart';
|
|
import 'dart:convert';
|
|
import 'package:flutter/services.dart';
|
|
import 'package:google_fonts/google_fonts.dart';
|
|
import 'package:http/http.dart' as http;
|
|
import 'package:fluttertoast/fluttertoast.dart';
|
|
import 'package:shared_preferences/shared_preferences.dart';
|
|
import 'package:intl/intl.dart';
|
|
import 'dart:async';
|
|
import 'package:geolocator/geolocator.dart';
|
|
import 'package:dio/dio.dart';
|
|
|
|
//const Color primaryColor = Color(0XFF0D4E84);
|
|
//const Color primaryColor = Color(0XFF075A7C);
|
|
const Color primaryColor = Color(0XFF1D7AFC);
|
|
const Color tankLocationColor = Color(0XFFF3E998);
|
|
const Color typeOfWaterColor = Color(0XFFCE93D8);
|
|
const Color newTextColor = Color(0XFF424242);
|
|
const Color secondaryColor = Color(0XFFBFE0ED);
|
|
const Color greyColor = Color(0XFF7E7F80);
|
|
const Color textFieldStartColor = Colors.grey;
|
|
const Color screenBackgroundColor = Color(0XFFBFE0ED);
|
|
const Color screenBackgroundColord = Colors.black12;
|
|
const Color dashboardbackground = Color(0XFFF5F5F5);
|
|
|
|
Color AppBarGradient_1 = Color(0XFF4D317D);
|
|
|
|
|
|
String capitalizeFirstLetter(String text) {
|
|
if (text.isEmpty) return text;
|
|
return text[0].toUpperCase() + text.substring(1).toLowerCase();
|
|
}
|
|
|
|
TextStyle PreloaderText() {
|
|
return TextStyle(color:primaryColor);
|
|
}
|
|
|
|
TextStyle labelTextStyle() {
|
|
return TextStyle(color: primaryColor, fontSize: 12,fontWeight: FontWeight.bold);
|
|
}
|
|
|
|
TextStyle newTextStyle() {
|
|
return TextStyle(color:newTextColor,fontWeight: FontWeight.bold );
|
|
}
|
|
|
|
TextStyle labelTextStyleRed() {
|
|
return TextStyle(color: Colors.red, fontSize: 12,fontWeight: FontWeight.bold);
|
|
}
|
|
|
|
TextStyle labelTextStyleMotorRunning() {
|
|
return TextStyle(color: primaryColor, fontSize: 16);
|
|
}
|
|
TextStyle labelTextStylewithBold() {
|
|
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 iconBelowTextStyle() {
|
|
return TextStyle(fontSize: 10, color: primaryColor);
|
|
}
|
|
|
|
TextStyle valuesTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.black,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleConsumption() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.red,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleCapacity() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
color: Colors.red,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleRed() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.red,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleBig() {
|
|
return TextStyle(
|
|
fontSize: 15,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle valuesTextStyleBigImportant() {
|
|
return TextStyle(
|
|
fontSize: 15,
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.red
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleImportant() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.red
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleImportantMotorRunning() {
|
|
return TextStyle(
|
|
fontSize: 16,
|
|
fontWeight: FontWeight.bold,
|
|
color: Colors.red
|
|
);
|
|
}
|
|
|
|
TextStyle valuesTextStyleForDisplayLastUpdatedTime() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
color: primaryColor
|
|
);
|
|
}
|
|
|
|
|
|
TextStyle valuesTextStyleForOrders() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
fontWeight: FontWeight.bold,
|
|
color: primaryColor
|
|
);
|
|
}
|
|
TextStyle lablesTextStyleForOrders() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
);
|
|
}
|
|
|
|
TextStyle tabTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
);
|
|
}
|
|
TextStyle valuesTextStyleWithoutTextSize() {
|
|
return TextStyle(
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
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: primaryColor,
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle labelTextStyleBold() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
color: primaryColor,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle labelTextStyleButton() {
|
|
return TextStyle(
|
|
fontSize: 12,
|
|
color: Colors.white,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle labelTextStyleCapacity() {
|
|
return TextStyle(
|
|
fontSize: 14,
|
|
color: primaryColor,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
TextStyle radioItemsTextStyle() {
|
|
return TextStyle(color: primaryColor,fontSize: 11,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 wrapTextStyleStartMotor() {
|
|
return TextStyle(
|
|
color: Colors.black,
|
|
fontSize: 15,
|
|
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(
|
|
color: primaryColor,
|
|
fontSize: 12,
|
|
fontWeight: FontWeight.bold,
|
|
);
|
|
}
|
|
|
|
|
|
TextStyle elevatedButtonTextStyle() {
|
|
return TextStyle(
|
|
fontSize: 16,
|
|
);
|
|
}
|
|
TextStyle underLineTextStyle() {
|
|
return TextStyle(
|
|
color: primaryColor,
|
|
decoration: TextDecoration.underline,
|
|
|
|
);
|
|
}
|
|
|
|
TextStyle fontTextStyle(double fontSize,Color fontColor,FontWeight weight) {
|
|
return GoogleFonts.inter(
|
|
textStyle: TextStyle(
|
|
fontSize: fontSize,
|
|
fontWeight: weight,
|
|
color:fontColor,
|
|
),
|
|
);
|
|
}
|
|
|
|
TextStyle fontTextStylewithUnderline(double fontSize,Color fontColor,FontWeight weight, Color underlineColor) {
|
|
return GoogleFonts.inter(
|
|
textStyle: TextStyle(
|
|
fontSize: fontSize,
|
|
fontWeight: weight,
|
|
color:fontColor,
|
|
decoration: TextDecoration.underline,
|
|
decorationColor: underlineColor,
|
|
decorationThickness: 1,
|
|
),
|
|
);
|
|
}
|
|
TextStyle italicFontTextStyle(double fontSize, Color fontColor, FontWeight weight) {
|
|
return GoogleFonts.roboto(
|
|
textStyle: TextStyle(
|
|
fontSize: fontSize,
|
|
fontWeight: weight,
|
|
color: fontColor,
|
|
fontStyle: FontStyle.italic,
|
|
),
|
|
);
|
|
}
|
|
TextStyle fontTextStyleHeight(double fontSize,Color fontColor,FontWeight weight,double height) {
|
|
return GoogleFonts.inter(
|
|
textStyle: TextStyle(
|
|
fontSize: fontSize,
|
|
fontWeight: weight,
|
|
color:fontColor,
|
|
height: height
|
|
),
|
|
);
|
|
}
|
|
TextStyle fontTextStyleUnderline(double fontSize,Color fontColor,FontWeight weight) {
|
|
return GoogleFonts.inter(
|
|
textStyle: TextStyle(
|
|
fontSize: fontSize,
|
|
fontWeight: weight,
|
|
color:fontColor,
|
|
decoration: TextDecoration.underline,
|
|
),
|
|
);
|
|
}
|
|
|
|
|
|
InputDecoration textFormFieldDecoration(IconData icon,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
/*prefixIcon: Icon(
|
|
icon,
|
|
color: Colors.white,
|
|
),*/
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle:fontTextStyle(14,Color(0XFF7E7F80),FontWeight.w400),
|
|
/* TextStyle(color: greyColor, fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),*/
|
|
);
|
|
}
|
|
|
|
InputDecoration searchTextFormFieldDecoration(var path,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: true,
|
|
fillColor: Color(0XFFE8F2FF),
|
|
prefixIcon:Padding(
|
|
padding: EdgeInsets.all(15.0), // Adjust the padding around the image
|
|
child: Image.asset(
|
|
path, // Path to your image
|
|
width: 24, // Set the width
|
|
height: 24, // Set the height
|
|
color: Color(0XFF7E7F80), // Optional: Set color filter if needed
|
|
fit: BoxFit.contain, // Ensure the image is contained within the available space
|
|
),
|
|
),
|
|
hintText: text,
|
|
hintStyle: fontTextStyle(12, Color(0XFF646566), FontWeight.w400),
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(30.0),
|
|
borderSide: BorderSide(
|
|
color: Color(0XFFE8F2FF),
|
|
width: 1,
|
|
)),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(30.0),
|
|
borderSide: BorderSide(
|
|
color: Color(0XFFE8F2FF),
|
|
width: 2,
|
|
),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(30.0),
|
|
borderSide: BorderSide(color: Color(0XFFE8F2FF)),
|
|
),
|
|
);
|
|
}
|
|
|
|
|
|
String capitalizeFirst(String text) {
|
|
if (text.isEmpty) return text;
|
|
return text[0].toUpperCase() + text.substring(1);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationHintText(IconData icon,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
/*prefixIcon: Icon(
|
|
icon,
|
|
color: Colors.white,
|
|
),*/
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
hintText: text,
|
|
hintStyle:fontTextStyle(14,Color(0XFF7E7F80),FontWeight.w400),
|
|
/* TextStyle(color: greyColor, fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),*/
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationWithoutLabelText(){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495),
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495),width: 1,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495)),
|
|
),
|
|
|
|
);
|
|
}
|
|
|
|
InputDecoration DisableTextFormFieldDecoration(){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495),
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495),width: 1,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF939495)),
|
|
),
|
|
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationWithoutLabelTextWithEnableBorder(){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelStyle:fontTextStyle(14,Color(0XFF7E7F80),FontWeight.w400),
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationWithoutLabelTextWithErrorText(msg){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
errorText: msg,
|
|
errorStyle:fontTextStyle(14,Color(0XFFE2483D),FontWeight.w400),
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationForSuffixText(IconData icon,var text,var suffixText){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelText: text,
|
|
suffix: Text('mins'),
|
|
labelStyle:fontTextStyle(14,Color(0XFF7E7F80),FontWeight.w400),
|
|
/* TextStyle(color: greyColor, fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),*/
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationForDateRange(var path,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
suffixIcon:IconButton(
|
|
icon: Image.asset(
|
|
path, // Path to your image asset
|
|
width: 24, // Set the width
|
|
height: 24, // Set the height
|
|
color: Color(0XFF7E7F80),
|
|
fit: BoxFit.contain, // Ensure the image is contained within the given space
|
|
),
|
|
onPressed: () {
|
|
// Define the action for the icon if necessary
|
|
print('Suffix icon pressed');
|
|
},
|
|
),
|
|
|
|
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: Color(0XFF1D7AFC),width: 2,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle:fontTextStyle(14,Color(0XFF939495),FontWeight.w400),
|
|
/* TextStyle(color: greyColor, fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),*/
|
|
);
|
|
}
|
|
|
|
InputDecoration textFormFieldDecorationForSuffix(var path,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
suffixIcon: Padding(
|
|
padding: EdgeInsets.all(12.0), // Adjust the padding around the image
|
|
child: Image.asset(
|
|
path, // Path to your image
|
|
width: 8, // Set the width
|
|
height: 8, // Set the height
|
|
color: Color(0XFF7E7F80), // Optional: Set color filter if needed
|
|
fit: BoxFit.contain, // Ensure the image is contained within the available space
|
|
),
|
|
),
|
|
|
|
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,width: 1,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
);
|
|
}
|
|
|
|
InputDecoration decorationForDropdown(var path,var text){
|
|
return InputDecoration(
|
|
counterText: '',
|
|
filled: false,
|
|
fillColor: Colors.white,
|
|
prefixIcon:Padding(
|
|
padding: EdgeInsets.all(15.0), // Adjust the padding around the image
|
|
child: Image.asset(
|
|
path, // Path to your image
|
|
width: 24, // Set the width
|
|
height: 24, // Set the height
|
|
color: Color(0XFF7E7F80), // Optional: Set color filter if needed
|
|
fit: BoxFit.contain, // Ensure the image is contained within the available space
|
|
),
|
|
),
|
|
|
|
/*IconButton(
|
|
icon: Image.asset(
|
|
path, // Path to your image asset
|
|
width: 20, // Set the width
|
|
height: 20, // Set the height
|
|
color: Color(0XFF515253),
|
|
fit: BoxFit.contain, // Ensure the image is contained within the given space
|
|
),
|
|
onPressed: () {
|
|
// Define the action for the icon if necessary
|
|
print('Suffix icon pressed');
|
|
},
|
|
),*/
|
|
|
|
|
|
border: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,
|
|
width: 1, )),
|
|
focusedBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor,width: 1,),
|
|
),
|
|
|
|
enabledBorder: OutlineInputBorder(
|
|
borderRadius: BorderRadius.circular(15.0),
|
|
borderSide: BorderSide(color: greyColor),
|
|
),
|
|
labelText: text,
|
|
labelStyle:fontTextStyle(14,Color(0XFF939495),FontWeight.w400),
|
|
/* TextStyle(color: greyColor, fontWeight: FontWeight.bold //<-- SEE HERE
|
|
),*/
|
|
);
|
|
}
|
|
|
|
Widget valuesText(var text){
|
|
return Container(
|
|
child: Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: valuesTextStyle(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget valuesTextConsumption(var text){
|
|
return Container(
|
|
child: Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: valuesTextStyleConsumption(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget valuesTextMotorStatus(var text){
|
|
Color textColor=Colors.black;
|
|
if(text.toString().toLowerCase()=='off'){
|
|
textColor=Colors.red;
|
|
}
|
|
else{
|
|
textColor=Colors.green;
|
|
}
|
|
|
|
return Container(
|
|
child: Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: TextStyle(
|
|
fontSize: 12,
|
|
color:textColor,
|
|
fontWeight: FontWeight.bold,
|
|
),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
),
|
|
);
|
|
}
|
|
|
|
Widget valuesTextCapacity(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: valuesTextStyleCapacity(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget valuesTextLowTextScaleFactor(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: valuesTextStyle(),
|
|
textScaleFactor: 0.9,
|
|
);
|
|
}
|
|
|
|
Widget labelsTextLowTextScaleFactor(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: labelTextStyleBold(),
|
|
textScaleFactor: 0.9,
|
|
);
|
|
}
|
|
|
|
Widget valuesTextNewBig(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: valuesTextStyleBig(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget labelsText(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: labelTextStyle(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget labelsTextFont(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: fontTextStyle(16,Color(0XFF1D7AFC),FontWeight.w600),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget labelsTextBold(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: labelTextStyleBold(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget labelsTextButton(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: labelTextStyleButton(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
Widget labelsTextCapacity(var text){
|
|
return Text(
|
|
text,
|
|
overflow: TextOverflow.ellipsis,
|
|
style: labelTextStyleCapacity(),
|
|
textScaleFactor: AppSettings.textScaleFactor,
|
|
);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
InputDecoration textFormFieldDecorationForBoxId(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: primaryColor, fontWeight: FontWeight.bold //<-- 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 userName = '';
|
|
static String loginType = '';
|
|
static String accessType = '';
|
|
static String buildingName = '';
|
|
static String userAddress = '';
|
|
static String email = '';
|
|
static String phoneNumber = '';
|
|
static String accessToken = '';
|
|
static String customerId = '';
|
|
static double userLatitude = 0;
|
|
static double userLongitude = 0;
|
|
static String customerIdsign = '';
|
|
static String profileImage = '';
|
|
static List<String> storedPreferenceValidKeys = ['phone', '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 double textScaleFactor = 1.1;
|
|
static String serverToken =
|
|
'AAAAA66BLaA:APA91bHcmbyiNN8hCL-t-M9oH-u7ZMOl74fcImMM2DQZLgdyY98Wu9XxME-CTPcjpjU6Yy48ouxISrOMb9lpa3PJofh8qciUKMNxV2al-bDvGvPP_VVaH0mrTHzR56hdkGy1Zl-0frDO';
|
|
static String profilePictureUrl = '';
|
|
|
|
|
|
//api urls
|
|
//static String host = 'http://34.100.133.20:5000/api/';
|
|
//static String host = 'http://35.207.198.4:3000/api/';
|
|
|
|
//public host
|
|
static String host = 'http://armintaaqua.com:3000/api/';
|
|
|
|
// local host
|
|
//static String host = 'http://10.10.1.127:5000/api/';
|
|
static String addTanksUrl = host + 'addTanks';
|
|
static String addTankerUrl = host + 'addTankers';
|
|
static String addBoreUrl = host + 'addBores';
|
|
static String addGovtPipelinesUrl = host + 'addGovtPIpeline';
|
|
static String loginUrl = host + 'login';
|
|
static String signUpUrl = host + 'users';
|
|
static String verifyPhnUrl = host + 'phone';
|
|
static String getTanksDataUrl = host + 'getTanks';
|
|
static String getParticularTankConnectionsDataUrl = host + 'getConnectionsInfoOfParticularTank';
|
|
static String getIotDataUrl = host + 'APIRead';
|
|
static String capacityCaluculateUrl = host + 'calculateCapacity';
|
|
static String getBoresDataUrl = host + 'getBores';
|
|
static String UpdateBoresUrl = host + 'updateBores';
|
|
static String UpdateTankerUrl = host + 'updateTankers';
|
|
static String connectRequestUrl = host + 'users/friend-request';
|
|
static String disconnectRequestUrl = host + 'friend-request/reject';
|
|
static String cancelOrderUrl = host + 'deleteBookingInfo';
|
|
static String UpdateGovtPipelinesUrl = host + 'updatePipeline';
|
|
static String bookATankerUrl = host + 'bookingData';
|
|
static String updateProfileUrl = host + 'update/currentUser';
|
|
static String profilePicUrl = host + 'users/profile-picture';
|
|
static String uploadPicUrl = host + 'uploads-user';
|
|
static String getBookingTankerDetails = host + 'getTankersBookingdetails';
|
|
static String getPendingOrdersForConfirmationUrl =
|
|
host + 'pendingconformation';
|
|
static String getOrdersYetDeliveryUrl = host + 'accepted';
|
|
static String getCancelledOrdersUrl = host + 'rejected';
|
|
static String getDeliveredOrdersUrl = host + 'delivered';
|
|
static String getAllOrdersUrl = host + 'orders';
|
|
static String getCustomerPlansUrl = host + 'getuserRequestbookingsforplansforcustomer';
|
|
static String getTankersDataUrl = host + 'getallTankers';
|
|
static String getSupplierAllTankersDataUrl = host + 'getTankers';
|
|
static String getCartItemsUrl = host + 'cart';
|
|
static String getAllSuppliersDataUrl = host + 'getSupplierswithoutbooking';
|
|
static String getConnectedSuppliersDataUrl = host + 'connectedSuppliers';
|
|
static String getPendingSuppliersDataUrl = host + 'pendingSuppliers';
|
|
static String getDisconnectedSuppliersDataUrl = host + 'rejectSuppliers';
|
|
static String getGovtPipelinesDataUrl = host + 'getPipelines';
|
|
static String deleteTankUrl = host + 'deleteTank';
|
|
static String deleteBoreUrl = host + 'deleteBore';
|
|
static String deleteGovtPipelineUrl = host + 'deletePipeline';
|
|
static String deleteTankerUrl = host + 'deleteTanker';
|
|
static String updateTankUrl = host + 'updateTanks';
|
|
static String createConnectionsUrl = host + 'createConnections';
|
|
static String UpdateConnectionsUrl = host + 'updateConnections';
|
|
static String deleteTankConnectionsUrl = host + 'deleteTankConnections';
|
|
static String getTankLevelsDataUrl = host + 'getTanklevels';
|
|
static String getinitialwaterlevel = host + 'updateTanklevels';
|
|
static String getConsumptionDataUrl = host + 'consumption';
|
|
static String getConsumptionDataDateWiseOfAllTanksUrl = host + 'consumptiondatewiseofalltanks';
|
|
static String resetTokenUrl = host + 'reset_token';
|
|
static String startAndStopUrl = host + 'motorAction';
|
|
static String getUserAccountsUrl = host + 'userAccounts';
|
|
static String getUserSupplierAccountsUrl = host + 'UserSupplierAccounts';
|
|
static String forgotPasswordUrl = host + 'forgotpassword';
|
|
static String forgotChangePasswordUrl = host + 'forgot-change-password';
|
|
static String ChangePasswordUrl = host + 'changePassword';
|
|
static String resetPasswordUrl = host + 'resetpassword';
|
|
static String acceptBookingRequestsUrl = host + 'ordernow';
|
|
static String readMotorStatusUrl = host + 'motor/readMotorIotStatus';
|
|
static String changeMotorStatusUrl = host + 'motor/changeMotorStatus';
|
|
static String updateTankMinMaxPercentageUrl = host + 'update_auto_percentage';
|
|
static String updateMotorModeUrl = host + 'update_auto_mode';
|
|
static String getBlocksDataUrl = host + 'getBlockData';
|
|
static String getConsumptionDataForParticulartankUrl = host + 'consumptionofparticulartank';
|
|
static String addStaffUrl = host + 'createstaff';
|
|
static String viewStaffDataUrl = host + 'currentUser';
|
|
static String deleteStaffUrl = host + 'deletestaff';
|
|
static String updateStaffUrl = host + 'editstaff';
|
|
static String getMotorHistoryDataUrl = host + 'getTankmotordata';
|
|
static String updateTankStatusUrl = host + 'updatetankstatus';
|
|
static String getMinMaxLevelsOfAllTanksUrl = host + 'getCustomerAutoPercentages';
|
|
static String getPumpsAndUsersDataUrl = host + 'getPumpsAndUsers';
|
|
static String blockStaffUrl = host + 'blockstaff';
|
|
static String pauseNotificationUrl = host + 'sendNotificationDailyPreference';
|
|
static String timeBasedNotificationUrl = host + 'sendNotificationDaily';
|
|
static String lowLevelNotificationUrl = host + 'sendNotificationLowWaterLevel';
|
|
static String criticalLowLevelNotificationUrl = host + 'sendNotificationCriticallyWaterLevel';
|
|
static String automaticNotificationUrl = host + 'sendNotificationAutomaticStartAndStop';
|
|
static String manualNotificationUrl = host + 'sendNotificationManualStartAndStop';
|
|
static String removeFavouritesUrl = host + 'deletefavoratesupplier';
|
|
static String addFavouriteUrl = host + 'addingfavoratesupplier';
|
|
static String getAllFavouritesDataUrl = host + 'favorites';
|
|
static String getSuppliersForBookingUrl = host + 'suppliersforbooking';
|
|
static String requestOrderUrl = host + 'requestedbookings';
|
|
static String requestPlanUrl = host + 'requestedplanbookings';
|
|
static String getAcceptedOrdersDataFromSupplierUrl = host + 'getuserRequestbookings';
|
|
static String getAcceptedPlansFromSupplierUrl = host + 'getuserRequestbookingsforplansforcustomer';
|
|
static String getSuppliersForPlanUrl = host + 'plan/suppliers';
|
|
static String acceptOrderRequestsUrl = host + 'request-advance-amount';
|
|
static String acceptPlanRequestsUrl = host + 'customer/recurring/respond';
|
|
static String getAcceptedOrdersUrl = host + 'getAllTankersBookingdetailsofuser';
|
|
static String acceptPlanRequestsWithPaymentUrl = host + 'user/recurring/payment';
|
|
static String updateTankNamehileDeliveryUrl = host + 'update-tank-name-while-delivery';
|
|
static String updateBookingDetailsByIdUrl = host + 'get_tanker_booking';
|
|
static String rescheduleOrderUrl = host + 'tanker/reSchedule';
|
|
static String cancelPlanOrderUrl = host + 'cancelOrder';
|
|
static String getAdvanceTransactionsByCustomerUrl = host + 'advance/transactions/customer';
|
|
static String payAdvanceUrl = host + 'advance/pay';
|
|
static String getAdvanceTransactionsBySupplierAndCustomerUrl = host + 'advance/transactions';
|
|
static String addAdvanceTopUpUrl = host + 'advance/transactions';
|
|
static String verifyRazorpayPaymentUrl = host + 'advance/transactions';
|
|
static String createRazorpayOrderUrl = host + 'advance/transactions';
|
|
static String cancelTankerBookingUrl = host + 'update-tank-cancel-status';
|
|
static String getSupplierBookingsUrl = host + 'getuserRequestbookingsforplansforcustomer';
|
|
static String recurringDateActionUrl = host + 'recurring-booking/date-action';
|
|
|
|
static File? updatedImage;
|
|
static String image = '';
|
|
static var api = {
|
|
'signIn': host + '/login',
|
|
};
|
|
|
|
/*Formatter*/
|
|
static String formNum(String s) {
|
|
var comma = NumberFormat('#,##,###', 'en_IN');
|
|
return comma.format(
|
|
int.parse(s),
|
|
);
|
|
}
|
|
|
|
static String formDouble(dynamic s) {
|
|
var comma = NumberFormat('#,##,###.##', 'en_IN');
|
|
|
|
if (s == null) return "0.00";
|
|
|
|
String str = s.toString().trim();
|
|
if (str.isEmpty) return "0.00";
|
|
|
|
try {
|
|
return comma.format(double.parse(str));
|
|
} catch (e) {
|
|
return "0.00"; // fallback if it's not a valid number
|
|
}
|
|
}
|
|
static String moneyConvertion(String value) {
|
|
var comma = NumberFormat('#,##,###.00', 'en_IN');
|
|
return comma.format(
|
|
double.parse(value),
|
|
);
|
|
}
|
|
/* 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;
|
|
}
|
|
|
|
static Future<Map<String, String>> buildRequestHeaders1() async {
|
|
Map<String, String> _headers = new Map<String, String>();
|
|
_headers[HttpHeaders.contentTypeHeader] = 'application/json';
|
|
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);
|
|
}
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|
|
|
|
static clearSharedPreferences() 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> 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);
|
|
print(_response['simplydata']['error']);
|
|
|
|
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> 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);
|
|
customerIdsign = _response['armintatankdata']['customerId'];
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static Future<bool> verifyPhn(payload) async {
|
|
var response = await http.post(Uri.parse(verifyPhnUrl),
|
|
body: json.encode(payload),
|
|
headers: {'Content-type': 'application/json'});
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
if (_response['armintatankdata']['error'] == false) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> updateProfile(payload) async {
|
|
var uri = Uri.parse(updateProfileUrl + '/' + customerId);
|
|
try {
|
|
var response = await http.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
var _response = json.decode(response.body);
|
|
|
|
userName = _response['username'];
|
|
phoneNumber = _response['phone'];
|
|
email = _response['emails'][0]['email'];
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> updateProfilePicture(payload) async {
|
|
var uri = Uri.parse(profilePicUrl + '/' + 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) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> uploadrofileImageHTTPNew(file) async {
|
|
var request = http.MultipartRequest(
|
|
'POST', Uri.parse(uploadPicUrl + '/' + customerId));
|
|
request.files.add(
|
|
await http.MultipartFile.fromPath('file', file.path)
|
|
);
|
|
var res = await request.send();
|
|
var response = await http.Response.fromStream(res);
|
|
return response.body;
|
|
}
|
|
|
|
static Future<bool> addTanks(payload) async {
|
|
var uri = Uri.parse(addTanksUrl + '/' + 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) {
|
|
// display error toast
|
|
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<bool> addStaff(payload) async {
|
|
var uri = Uri.parse(addStaffUrl + '/' + 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) {
|
|
// display error toast
|
|
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> viewStaff(payload) async {
|
|
var uri = Uri.parse(viewStaffDataUrl);
|
|
//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, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> updateStaff(phone,payload) async {
|
|
var uri = Uri.parse(updateStaffUrl + '/' + customerId+ '/' + phone);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri, body: json.encode(payload), 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> blockStaff(phone) async {
|
|
var uri = Uri.parse(blockStaffUrl + '/' + customerId+ '/' + phone);
|
|
|
|
try {
|
|
var response = await http.patch(uri,headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteStaff(phone) async {
|
|
var uri = Uri.parse(deleteStaffUrl + '/' + customerId+ '/' + phone);
|
|
|
|
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> getTanks() async {
|
|
var uri = Uri.parse(getTanksDataUrl);
|
|
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> getParticularTankConnections(payload) async {
|
|
var uri = Uri.parse(getParticularTankConnectionsDataUrl+'/'+customerId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
var response = await http.put(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.put(uri, body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getIotDataNew() async {
|
|
var uri = Uri.parse(getIotDataUrl);
|
|
uri = uri.replace(query: 'hardwareId=56789');
|
|
|
|
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> getTankLevels() async {
|
|
var uri = Uri.parse(getTankLevelsDataUrl + '/' + 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> pauseNotificationsData(payload) async {
|
|
var uri = Uri.parse(pauseNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> timeBasedNotificationsData(payload) async {
|
|
var uri = Uri.parse(timeBasedNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> lowLevelNotificationsData(payload) async {
|
|
var uri = Uri.parse(lowLevelNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
static Future<bool> criticalLowLevelNotificationsData(payload) async {
|
|
var uri = Uri.parse(criticalLowLevelNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> automaticNotificationsData(payload) async {
|
|
var uri = Uri.parse(automaticNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
static Future<bool> manualNotificationsData(payload) async {
|
|
var uri = Uri.parse(manualNotificationUrl);
|
|
|
|
try {
|
|
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); // You can inspect this response further for success
|
|
return true;
|
|
} catch (e) {
|
|
print("Error decoding response: $e");
|
|
return false;
|
|
}
|
|
} else {
|
|
print("Request failed with status: ${response.statusCode}");
|
|
print("Response body: ${response.body}");
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print("Error during request: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
|
|
static Future<String> capacityCaluculate(payload) async {
|
|
var uri = Uri.parse(capacityCaluculateUrl);
|
|
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> deleteTank(tankName, payload) async {
|
|
var uri = Uri.parse(deleteTankUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'tankName=$tankName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> updateTank(tankName, payload) async {
|
|
var uri = Uri.parse(updateTankUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'tankName=$tankName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> updateTankMinMaxPercentage(payload) async {
|
|
var uri = Uri.parse(updateTankMinMaxPercentageUrl + '/' + customerId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> updateTankStatus(payload) async {
|
|
var uri = Uri.parse(updateTankStatusUrl + '/' + customerId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> updateMotorMode(payload) async {
|
|
var uri = Uri.parse(updateMotorModeUrl + '/' + customerId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> addTankers(payload) async {
|
|
var uri = Uri.parse(addTankerUrl + '/' + 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) {
|
|
// display error toast
|
|
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> getTankers() async {
|
|
var uri = Uri.parse(getTankersDataUrl);
|
|
//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> getAllTankers(var supplierId) async {
|
|
var uri = Uri.parse(getSupplierAllTankersDataUrl);
|
|
uri = uri.replace(query: 'supplierId=$supplierId');
|
|
|
|
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> getCartItems() async {
|
|
var uri = Uri.parse(getCartItemsUrl+ '/' + 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> getAllSuppliers() async {
|
|
var uri = Uri.parse(getAllSuppliersDataUrl+'/'+customerId);
|
|
//uri = uri.replace(query: 'customerId=$customerId');
|
|
|
|
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> getConnetcedSuppliers() async {
|
|
var uri = Uri.parse(getConnectedSuppliersDataUrl + '/' + 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<String> getPendingSuppliers() async {
|
|
var uri = Uri.parse(getPendingSuppliersDataUrl + '/' + 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<String> getDisconnectedSuppliers() async {
|
|
var uri = Uri.parse(getDisconnectedSuppliersDataUrl + '/' + 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> updateTanker(tankerName, payload) async {
|
|
var uri = Uri.parse(UpdateTankerUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'tankerName=$tankerName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> deleteTanker(tankerName) async {
|
|
var uri = Uri.parse(deleteTankerUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'tankerName=$tankerName');
|
|
|
|
try {
|
|
var response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> getUpdateTankLevelsInitial() async {
|
|
var uri = Uri.parse(getinitialwaterlevel + "/" + customerId);
|
|
var response = await http.put(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.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> addBores(payload) async {
|
|
var uri = Uri.parse(addBoreUrl + '/' + 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) {
|
|
// display error toast
|
|
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> getBores() async {
|
|
var uri = Uri.parse(getBoresDataUrl);
|
|
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> updateBore(boreName, payload) async {
|
|
var uri = Uri.parse(UpdateBoresUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'boreName=$boreName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> deleteBore(boreName) async {
|
|
var uri = Uri.parse(deleteBoreUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'boreName=$boreName');
|
|
|
|
try {
|
|
var response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> addGovtPipelines(payload) async {
|
|
var uri = Uri.parse(addGovtPipelinesUrl + '/' + 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) {
|
|
// display error toast
|
|
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> getGovtPipelines() async {
|
|
var uri = Uri.parse(getGovtPipelinesDataUrl);
|
|
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> updateGovtPipeline(pipelineName, payload) async {
|
|
var uri = Uri.parse(UpdateGovtPipelinesUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'Name=$pipelineName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> deleteGovtPipeline(pipelineName) async {
|
|
var uri = Uri.parse(deleteGovtPipelineUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'Name=$pipelineName');
|
|
|
|
try {
|
|
var response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> createConnections(payload) async {
|
|
var uri = Uri.parse(createConnectionsUrl + '/' + 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<bool> updateConnections(payload) async {
|
|
var uri = Uri.parse(UpdateConnectionsUrl + '/' + customerId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> deleteTankConnection(tankName) async {
|
|
var uri = Uri.parse(deleteTankConnectionsUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'tankName=$tankName');
|
|
|
|
try {
|
|
var response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> bookATanker(payload) async {
|
|
var uri = Uri.parse(bookATankerUrl + '/' + 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 response.body;
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
} 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> getBookedTankerDetails(tankerName) async {
|
|
var uri = Uri.parse(getBookingTankerDetails + '/' + customerId);
|
|
uri = uri.replace(query: 'tankerName=$tankerName');
|
|
|
|
var response = await http.get(uri, headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
var _response = json.decode(response.body);
|
|
//print(_response);
|
|
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> getPendingOrdersForConfirmation() async {
|
|
var uri = Uri.parse(getPendingOrdersForConfirmationUrl + '/' + 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> getOrdersYetDelivery() async {
|
|
var uri = Uri.parse(getOrdersYetDeliveryUrl + '/' + 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> getDeliveredOrders() async {
|
|
var uri = Uri.parse(getDeliveredOrdersUrl + '/' + 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> getCancelledOrders() async {
|
|
var uri = Uri.parse(getCancelledOrdersUrl + '/' + 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> getAllOrders() async {
|
|
var uri = Uri.parse(getAllOrdersUrl);
|
|
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> getCustomerPlans() async {
|
|
var uri = Uri.parse(getCustomerPlansUrl+'/'+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> getAcceptedOrdersDataFromSupplier() async {
|
|
var uri = Uri.parse(getAcceptedOrdersDataFromSupplierUrl+'/'+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> getAcceptedPlansFromSupplier() async {
|
|
var uri = Uri.parse(getAcceptedPlansFromSupplierUrl+'/'+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> getConsumptionData(payload) async {
|
|
var uri = Uri.parse(getConsumptionDataUrl + '/' + customerId);
|
|
|
|
var response = await http.put(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.put(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getMotorHistoryData(payload) async {
|
|
var uri = Uri.parse(getMotorHistoryDataUrl + '/' + customerId);
|
|
|
|
var response = await http.put(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.put(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getConsumptionDataDateWiseOfAllTanks(payload) async {
|
|
var uri = Uri.parse(getConsumptionDataDateWiseOfAllTanksUrl + '/' + customerId);
|
|
|
|
var response = await http.put(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.put(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getConsumptionDataForParticularTank(payload) async {
|
|
var uri = Uri.parse(getConsumptionDataForParticulartankUrl + '/' + customerId);
|
|
|
|
var response = await http.put(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.put(uri,body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getBlocks() async {
|
|
var uri = Uri.parse(getBlocksDataUrl + '/' + 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> getPumpsAndUsers() async {
|
|
var uri = Uri.parse(getPumpsAndUsersDataUrl + '/' + 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> resetToken() async {
|
|
var uri = Uri.parse(resetTokenUrl + '/' + customerId);
|
|
|
|
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<bool> startAndStop(payload) async {
|
|
var uri = Uri.parse(startAndStopUrl + '/' + customerId);
|
|
//uri = uri.replace(query: 'Name=$pipelineName');
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> startAndStopResponse(payload) async {
|
|
var uri = Uri.parse(startAndStopUrl + '/' + customerId);
|
|
//uri = uri.replace(query: 'Name=$pipelineName');
|
|
|
|
try {
|
|
var response = await http.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
return response.body;
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
} 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 response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> connectRequest(payload) async {
|
|
var uri = Uri.parse(connectRequestUrl);
|
|
try {
|
|
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;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> disconnectRequest(payload) async {
|
|
var uri = Uri.parse(disconnectRequestUrl);
|
|
try {
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), 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> cancelOrder(var bookingId) async {
|
|
var uri = Uri.parse(cancelOrderUrl + '/' + bookingId);
|
|
try {
|
|
var response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response =
|
|
await http.put(uri, headers: await buildPutRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> cancelOrderNew(var bookingId, payload) async {
|
|
var response = await http.post(
|
|
Uri.parse(acceptBookingRequestsUrl + '/' + bookingId),
|
|
body: json.encode(payload),
|
|
headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
} else if (response.statusCode == 401) {
|
|
bool status = await AppSettings.resetToken();
|
|
if (status) {
|
|
response = await http.post(
|
|
Uri.parse(acceptBookingRequestsUrl + '/' + bookingId),
|
|
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> getUserAccounts() async {
|
|
var uri = Uri.parse(getUserAccountsUrl + '/' + 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> getUserSupplierAccounts(var payload) async {
|
|
var uri = Uri.parse(getUserSupplierAccountsUrl + '/' + customerId);
|
|
var response = await http.put(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.put(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
} else {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<bool> forgotPassword(payload) async {
|
|
var uri = Uri.parse(forgotPasswordUrl);
|
|
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) {
|
|
// display error toast
|
|
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<bool> forgotChangePassword(payload) async {
|
|
var uri = Uri.parse(forgotChangePasswordUrl);
|
|
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['simplydata']['error']);
|
|
|
|
if (_response['simplydata']['error'] == false) {
|
|
await saveAvailableReportAndLocationsInMemory(_response);
|
|
//await saveProfilePic(_response);
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
/* try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
// display error toast
|
|
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<bool> ChangePassword(payload) async {
|
|
var uri = Uri.parse(ChangePasswordUrl);
|
|
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['armintatankdata']['error']);
|
|
|
|
if (_response['armintatankdata']['error'] == false) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
// display error toast
|
|
return false;
|
|
}
|
|
/* try {
|
|
var _response = json.decode(response.body);
|
|
print(_response);
|
|
return true;
|
|
} catch (e) {
|
|
// display error toast
|
|
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<bool> resetPassword(payload) async {
|
|
var uri = Uri.parse(resetPasswordUrl);
|
|
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) {
|
|
// display error toast
|
|
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<void> sendNotification(var body, var titile) async {
|
|
final postUrl = 'https://fcm.googleapis.com/fcm/send';
|
|
var token = fcmId;
|
|
print('token : $token');
|
|
|
|
final data = {
|
|
"notification": {"body": body, "title": titile},
|
|
"priority": "high",
|
|
"data": {
|
|
"click_action": "FLUTTER_NOTIFICATION_CLICK",
|
|
"id": "1",
|
|
"status": "done"
|
|
},
|
|
"to": "$token"
|
|
};
|
|
|
|
final headers = {
|
|
'content-type': 'application/json',
|
|
'Authorization': 'key=$serverToken',
|
|
};
|
|
|
|
BaseOptions options = BaseOptions(
|
|
headers: headers,
|
|
);
|
|
|
|
try {
|
|
final response = await Dio(options).post(postUrl, data: data);
|
|
|
|
if (response.statusCode == 200) {
|
|
longSuccessToast('Request notification sent to supplier');
|
|
} else {
|
|
print('notification sending failed');
|
|
// on failure do sth
|
|
}
|
|
} catch (e) {
|
|
print('exception $e');
|
|
}
|
|
}
|
|
|
|
static Future<void> sendNotificationFromApp(var body, var titile) async {
|
|
http.post(
|
|
Uri.parse('https://fcm.googleapis.com/fcm/send'),
|
|
headers: <String, String>{
|
|
'Content-Type': 'application/json',
|
|
'Authorization': 'key=$serverToken',
|
|
},
|
|
body: jsonEncode(
|
|
<String, dynamic>{
|
|
'notification': <String, dynamic>{
|
|
'title': titile,
|
|
'body': body,
|
|
},
|
|
'priority': 'high',
|
|
'data': <String, dynamic>{
|
|
'click_action': 'FLUTTER_NOTIFICATION_CLICK',
|
|
'id': '1',
|
|
'status': 'done'
|
|
},
|
|
'to': fcmId,
|
|
},
|
|
),
|
|
);
|
|
}
|
|
|
|
static Future<String> readMotorStatus() async {
|
|
var uri = Uri.parse(readMotorStatusUrl);
|
|
uri = uri.replace(query: 'motor_id=12345');
|
|
try {
|
|
var response = await http.get(uri, headers: await buildRequestHeaders1());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> changeMotorStatus(payload) async {
|
|
var uri = Uri.parse(changeMotorStatusUrl);
|
|
try {
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders1());
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return '';
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return '';
|
|
}
|
|
}
|
|
|
|
static Future<String> getMinMaxLevelsOfAllTanks() async {
|
|
var uri = Uri.parse(getMinMaxLevelsOfAllTanksUrl+ '/' + 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> removeFavourites(supplierId) async {
|
|
var uri = Uri.parse(removeFavouritesUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'supplierId=$supplierId');
|
|
try {
|
|
var response = await http.delete(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
var _response = json.decode(response.body);
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<bool> addFavourites(supplierId) async {
|
|
var uri = Uri.parse(addFavouriteUrl + '/' + customerId);
|
|
uri = uri.replace(query: 'supplierId=$supplierId');
|
|
try {
|
|
var response = await http.put(uri, headers: await buildPutRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
var _response = json.decode(response.body);
|
|
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> getAllFavourites() async {
|
|
var uri = Uri.parse(getAllFavouritesDataUrl + '/' + 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<String> getSuppliersForBooking(payload) async {
|
|
var uri = Uri.parse(getSuppliersForBookingUrl + '/' + customerId);
|
|
//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> requestOrder(payload) async {
|
|
var uri = Uri.parse(requestOrderUrl);
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
return true;
|
|
|
|
} catch (e) {
|
|
// display error toast
|
|
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<bool> requestPlan(payload) async {
|
|
var uri = Uri.parse(requestPlanUrl);
|
|
var response = await http.post(uri,
|
|
body: json.encode(payload), headers: await buildRequestHeaders());
|
|
|
|
if (response.statusCode == 200) {
|
|
try {
|
|
var _response = json.decode(response.body);
|
|
return true;
|
|
|
|
} catch (e) {
|
|
// display error toast
|
|
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> getSuppliersForPlan(payload) async {
|
|
var uri = Uri.parse(getSuppliersForPlanUrl + '/' + customerId);
|
|
//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> acceptOrderRequests(payload,dbId) async {
|
|
|
|
var uri = Uri.parse(acceptOrderRequestsUrl+'/'+dbId+'/supplier/advance');
|
|
|
|
var response = await http.put(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.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<bool> acceptPlanRequestsWithPayment(payload,dbId) async {
|
|
|
|
var uri = Uri.parse(acceptPlanRequestsWithPaymentUrl+'/'+dbId);
|
|
|
|
var response = await http.put(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.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<Map<String, dynamic>> acceptPlanRequests(payload, dbId) async {
|
|
var uri = Uri.parse(acceptPlanRequestsUrl + '/' + dbId);
|
|
|
|
var response = await http.post(
|
|
uri,
|
|
body: json.encode(payload),
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return jsonDecode(response.body);
|
|
}
|
|
|
|
// If unauthorized, refresh token
|
|
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 jsonDecode(response.body);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Default fallback
|
|
return {"status_code": 0};
|
|
}
|
|
|
|
static Future<String> getAcceptedOrders() async {
|
|
var uri = Uri.parse(getAcceptedOrdersUrl+'/'+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<String> updateTankNameWhileDelivery(dbId,payload) async {
|
|
var uri = Uri.parse(updateTankNamehileDeliveryUrl + '/' + dbId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri, body: json.encode(payload), headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return "";
|
|
}
|
|
} else {
|
|
return "";
|
|
}
|
|
} else {
|
|
return "";
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static Future<String> updateBookingDetailsById(dbId) async {
|
|
var uri = Uri.parse(updateBookingDetailsByIdUrl + '/' + dbId);
|
|
|
|
try {
|
|
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 "";
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static Future<String> rescheduleOrder(dbId,payload) async {
|
|
var uri = Uri.parse(rescheduleOrderUrl + '/' + customerId+ '/' + dbId);
|
|
|
|
try {
|
|
var response = await http.put(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.put(uri,body: json.encode(payload),headers: await buildRequestHeaders());
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
return "";
|
|
}
|
|
} else {
|
|
return "";
|
|
}
|
|
} else {
|
|
return "";
|
|
}
|
|
} catch (e) {
|
|
print(e);
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static Future<String> cancelPlanOrder(String dbId) async {
|
|
final uri = Uri.parse('$cancelPlanOrderUrl/$customerId/$dbId');
|
|
|
|
try {
|
|
print("CANCEL PLAN URL => $uri");
|
|
|
|
var response = await http.patch(
|
|
uri,
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
}
|
|
|
|
print("CANCEL ERROR ${response.statusCode} => ${response.body}");
|
|
return "";
|
|
|
|
} catch (e) {
|
|
print("CANCEL EXCEPTION => $e");
|
|
return "";
|
|
}
|
|
}
|
|
|
|
static Future<String> getAdvanceTransactionsByCustomer() async {
|
|
var uri = Uri.parse(getAdvanceTransactionsByCustomerUrl + '/' + 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> payAdvance({
|
|
required String transactionId,
|
|
required Map<String, dynamic> payload,
|
|
}) async {
|
|
var uri = Uri.parse(payAdvanceUrl + '/' + transactionId);
|
|
|
|
var response = await http.put(
|
|
uri,
|
|
body: json.encode(payload),
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
}
|
|
|
|
// 🔁 Retry on token expiry
|
|
if (response.statusCode == 401) {
|
|
final refreshed = await resetToken();
|
|
if (refreshed) {
|
|
response = await http.put(
|
|
uri,
|
|
body: json.encode(payload),
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
return response.statusCode == 200;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static Future<String> getAdvanceTransactionsBySupplierAndCustomer(
|
|
String supplierId,
|
|
String customerId,
|
|
) async {
|
|
var uri = Uri.parse("$getAdvanceTransactionsBySupplierAndCustomerUrl/$supplierId/$customerId");
|
|
|
|
|
|
final response = await http.get(
|
|
uri,
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
throw Exception("Failed to fetch transactions");
|
|
}
|
|
}
|
|
|
|
static Future<String> addAdvanceTopUp(
|
|
String supplierId,
|
|
String customerId,
|
|
double amount,
|
|
String paymentType, {
|
|
String gatewayTxnId = "",
|
|
}) async {
|
|
var uri = Uri.parse(addAdvanceTopUpUrl);
|
|
|
|
final response = await http.post(
|
|
uri,
|
|
headers: await buildRequestHeaders(),
|
|
body: jsonEncode({
|
|
"supplierId": supplierId,
|
|
"customerId": customerId,
|
|
"advance_amount": amount,
|
|
"payment_type": paymentType,
|
|
"gateway_txn_id": gatewayTxnId,
|
|
}),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
throw Exception("Failed to top up credit");
|
|
}
|
|
}
|
|
|
|
static Future<String> createRazorpayOrder({
|
|
required double amount,
|
|
required String supplierId,
|
|
required String customerId,
|
|
}) async {
|
|
var uri = Uri.parse(createRazorpayOrderUrl);
|
|
|
|
final response = await http.post(
|
|
uri,
|
|
headers: await buildRequestHeaders(),
|
|
body: jsonEncode({
|
|
"amount": amount,
|
|
"supplierId": supplierId,
|
|
"customerId": customerId,
|
|
}),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body; // must return: { "order_id": "...", "key_id": "rzp_test..." }
|
|
} else {
|
|
throw Exception("Failed to create Razorpay order");
|
|
}
|
|
}
|
|
|
|
static Future<String> verifyRazorpayPayment({
|
|
required String razorpayPaymentId,
|
|
required String razorpayOrderId,
|
|
required String razorpaySignature,
|
|
}) async {
|
|
var uri = Uri.parse(verifyRazorpayPaymentUrl);
|
|
|
|
final response = await http.post(
|
|
uri,
|
|
headers: await buildRequestHeaders(),
|
|
body: jsonEncode({
|
|
"razorpay_payment_id": razorpayPaymentId,
|
|
"razorpay_order_id": razorpayOrderId,
|
|
"razorpay_signature": razorpaySignature,
|
|
}),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
throw Exception("Failed to verify Razorpay payment");
|
|
}
|
|
}
|
|
|
|
static Future<bool> cancelTankerBooking(
|
|
String bookingId,
|
|
String status,
|
|
String reason,
|
|
) async {
|
|
try {
|
|
var uri = Uri.parse("$cancelTankerBookingUrl/$bookingId");
|
|
|
|
var payload = json.encode({
|
|
"status": status, // "cancelled"
|
|
"reason": reason,
|
|
});
|
|
|
|
var response = await http.put(
|
|
uri,
|
|
body: payload,
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return true;
|
|
}
|
|
|
|
// 🔁 Token expired → retry
|
|
if (response.statusCode == 401) {
|
|
bool refreshed = await resetToken();
|
|
if (!refreshed) return false;
|
|
|
|
response = await http.put(
|
|
uri,
|
|
body: payload,
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
return response.statusCode == 200;
|
|
}
|
|
|
|
return false;
|
|
} catch (e) {
|
|
debugPrint("❌ cancelTankerBooking error: $e");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
static Future<String> getSupplierBookings() async {
|
|
var uri = Uri.parse("$getSupplierBookingsUrl/${AppSettings.customerId}");
|
|
|
|
|
|
final response = await http.get(
|
|
uri,
|
|
headers: await buildRequestHeaders(),
|
|
);
|
|
|
|
if (response.statusCode == 200) {
|
|
return response.body;
|
|
} else {
|
|
throw Exception("Failed to fetch transactions");
|
|
}
|
|
}
|
|
|
|
static Future<void> recurringDateAction(
|
|
String bookingId,
|
|
Map<String, dynamic> payload,
|
|
) async {
|
|
|
|
final url = Uri.parse("$recurringDateActionUrl/${bookingId}");
|
|
|
|
|
|
final response = await http.post(
|
|
url,
|
|
headers: await buildRequestHeaders(),
|
|
body: jsonEncode(payload),
|
|
);
|
|
|
|
if (response.statusCode != 200) {
|
|
throw Exception(
|
|
"Recurring date action failed: ${response.body}",
|
|
);
|
|
}
|
|
}
|
|
|
|
|
|
/*Apis ends here*/
|
|
|
|
//save data local
|
|
static Future<void> saveAvailableReportAndLocationsInMemory(
|
|
dynamic input) async {
|
|
// save login name information
|
|
await saveData('username', input['simplydata']['username'], 'STRING');
|
|
await saveData('logintype', input['simplydata']['loginType'], 'STRING');
|
|
await saveData('all_motor_access', input['simplydata']['all_motor_access'], 'STRING');
|
|
await saveData('buildingname', input['simplydata']['buildingName'], '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('customerId', input['simplydata']['customerId'], 'STRING');
|
|
await saveData('profile', input['simplydata']['picture'], 'STRING');
|
|
await saveData('user_address', input['simplydata']['address1'], 'STRING');
|
|
if(input['simplydata']['latitude']==0){
|
|
input['simplydata']['latitude']=0.0;
|
|
}
|
|
if(input['simplydata']['longitude']==0){
|
|
input['simplydata']['longitude']=0.0;
|
|
}
|
|
await saveData('latitude', input['simplydata']['latitude'], 'DOUBLE');
|
|
await saveData('longitude', input['simplydata']['longitude'], 'DOUBLE');
|
|
await saveData('fcmId', input['simplydata']['fcmId'], 'STRING');
|
|
|
|
//latitude,longitude
|
|
await loadDataFromMemory();
|
|
}
|
|
|
|
static Future<void> saveProfile(dynamic image) async {
|
|
// save login name information
|
|
await saveData('profile', image.toString(), 'STRING');
|
|
//await loadDataFromMemory();
|
|
}
|
|
|
|
static Uint8List convertBase64Image(String base64String) {
|
|
return Base64Decoder().convert(base64String.split(',').last);
|
|
}
|
|
|
|
static Future<void> loadDataFromMemory() async {
|
|
userName = await getData('username', 'STRING');
|
|
loginType = await getData('logintype', 'STRING');
|
|
accessType = await getData('all_motor_access', 'STRING');
|
|
buildingName = await getData('buildingname', 'STRING');
|
|
accessToken = await getData('access_token', 'STRING');
|
|
email = await getData('email', 'STRING');
|
|
userAddress = await getData('user_address', 'STRING');
|
|
phoneNumber = await getData('phone', 'STRING');
|
|
customerId = await getData('customerId', 'STRING');
|
|
userLatitude = await getData('latitude', 'DOUBLE');
|
|
userLongitude = await getData('longitude', 'DOUBLE');
|
|
profilePictureUrl = await getData('profile', 'STRING');
|
|
fcmId = await getData('fcmId', 'STRING');
|
|
//profileImage=await getData('profile', 'STRING');
|
|
getProfile();
|
|
}
|
|
|
|
static String getStringFromBytes(var data) {
|
|
final buffer = data.buffer;
|
|
var list = buffer.asUint8List(data.offsetInBytes, data.lengthInBytes);
|
|
var bufferdata = utf8.decode(list);
|
|
String bs4str = base64.encode(list);
|
|
Uint8List decodedbytes = base64.decode(bs4str);
|
|
//OR
|
|
// String bs4str1 = base64Encode(imgbytes);
|
|
String s = new String.fromCharCodes(list);
|
|
var outputAsUint8List = new Uint8List.fromList(s.codeUnits);
|
|
return bufferdata;
|
|
}
|
|
|
|
static Uint8List image1(dynamicList) {
|
|
List<int> intList =
|
|
dynamicList.cast<int>().toList(); //This is the magical line.
|
|
Uint8List data = Uint8List.fromList(intList);
|
|
return data;
|
|
}
|
|
|
|
static Future<void> getProfile() async {
|
|
final image1 = await getData('profile', 'STRING');
|
|
|
|
//Io.File.fromUri(imageFile.uri)
|
|
|
|
var x = image1;
|
|
|
|
if (image1 == null) return;
|
|
|
|
if (image1 == '') {
|
|
updatedImage = null;
|
|
} else if (image1 == 'null') {
|
|
updatedImage = null;
|
|
} else {
|
|
final imageTemp = File(image1);
|
|
updatedImage = imageTemp;
|
|
}
|
|
|
|
print(updatedImage);
|
|
}
|
|
|
|
//assign saved values to variables
|
|
static Future<void> saveProfilePic(dynamic input) async {
|
|
SharedPreferences prefs = await SharedPreferences.getInstance();
|
|
|
|
// your custom int list
|
|
List<dynamic> mList = input['simplydata']['picture']['data'];
|
|
|
|
print(mList.length);
|
|
//input['simplydata']['picture']['data'];[0,1,2,3]
|
|
|
|
// convert your custom list to string list
|
|
List<String> stringsList = mList.map((i) => i.toString()).toList();
|
|
|
|
// store your string list in shared prefs
|
|
prefs.setStringList("stringList", stringsList);
|
|
|
|
// String bar = utf8.decode(bytes);
|
|
|
|
//String convertedValue = utf8.decode(mList);
|
|
}
|
|
|
|
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: Colors.white,
|
|
elevation: 0,
|
|
scrolledUnderElevation: 0,
|
|
titleSpacing: 0,
|
|
title: Text(title,style: fontTextStyle(14,Color(0XFF2A2A2A),FontWeight.w500),),
|
|
iconTheme: IconThemeData(color: Color(0XFF2A2A2A)),
|
|
actions: [
|
|
Row(
|
|
children: [
|
|
Padding(padding: EdgeInsets.fromLTRB(10,10,0,10),
|
|
child: IconButton(
|
|
icon: Image(
|
|
image: AssetImage('images/customercare_appbar.png')
|
|
|
|
),
|
|
onPressed: (){
|
|
|
|
},
|
|
),
|
|
),
|
|
|
|
Padding(padding: EdgeInsets.fromLTRB(0,10,10,10),
|
|
child: IconButton(
|
|
icon: Image.asset(
|
|
'images/notification_appbar.png', // Example URL image
|
|
),
|
|
onPressed: (){
|
|
|
|
},
|
|
),
|
|
)
|
|
],
|
|
)
|
|
],
|
|
);
|
|
}
|
|
|
|
static SupplierAppBar(String title,context) {
|
|
title = title ?? '';
|
|
return AppBar(
|
|
backgroundColor: Colors.white,
|
|
elevation: 0,
|
|
scrolledUnderElevation: 0,
|
|
titleSpacing: 0,
|
|
title: Text(
|
|
title,
|
|
style: fontTextStyle(14, Color(0XFF2A2A2A), FontWeight.w500),
|
|
),
|
|
iconTheme: IconThemeData(color: Color(0XFF2A2A2A)),
|
|
actions: [
|
|
Row(
|
|
children: [
|
|
Padding(
|
|
padding: EdgeInsets.fromLTRB(10, 10, 0, 10),
|
|
child: IconButton(
|
|
icon: Image(
|
|
image:
|
|
AssetImage('images/calender_supplier_landing.png')),
|
|
onPressed: () {},
|
|
),
|
|
),
|
|
Padding(
|
|
padding: EdgeInsets.fromLTRB(0, 10, 10, 10),
|
|
child: IconButton(
|
|
icon: Image.asset(
|
|
'images/notification_appbar.png', // Example URL image
|
|
),
|
|
onPressed: () {},
|
|
),
|
|
)
|
|
],
|
|
)
|
|
],
|
|
leading: GestureDetector(
|
|
onTap: () {
|
|
Navigator.pop(context);
|
|
},
|
|
child: Padding(
|
|
padding:
|
|
const EdgeInsets.fromLTRB(8, 8, 8, 8), // Add padding if needed
|
|
child: Image.asset(
|
|
'images/backbutton_appbar.png', // Replace with your image path
|
|
fit: BoxFit.contain,
|
|
color: Color(0XFF2A2A2A),
|
|
height: 24,
|
|
width: 24,
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
|
|
static appBarWithoutActions(String title) {
|
|
title = title ?? '';
|
|
return AppBar(
|
|
backgroundColor: Colors.white,
|
|
elevation: 0,
|
|
scrolledUnderElevation: 0,
|
|
titleSpacing: 0,
|
|
title: Text(
|
|
title,
|
|
style: fontTextStyle(14, Color(0XFF2A2A2A), FontWeight.w500),
|
|
),
|
|
iconTheme: IconThemeData(color: Color(0XFF2A2A2A)),
|
|
);
|
|
}
|
|
|
|
static supplierAppBarWithoutActions(String title,context) {
|
|
title = title ?? '';
|
|
return AppBar(
|
|
backgroundColor: Colors.white,
|
|
elevation: 0,
|
|
scrolledUnderElevation: 0,
|
|
titleSpacing: 0,
|
|
title: Text(
|
|
title,
|
|
style: fontTextStyle(14, Color(0XFF101214), FontWeight.w500),
|
|
),
|
|
iconTheme: IconThemeData(color: Color(0XFF2A2A2A)),
|
|
leading: GestureDetector(
|
|
onTap: () {
|
|
Navigator.pop(context);
|
|
},
|
|
child: Padding(
|
|
padding: const EdgeInsets.fromLTRB(
|
|
8, 8, 8, 8), // Add padding if needed
|
|
child: Image.asset(
|
|
'images/backbutton_appbar.png',
|
|
height: 24,
|
|
width: 24,// Replace with your image path
|
|
fit: BoxFit.contain, // Adjust the fit
|
|
),
|
|
),
|
|
),
|
|
);
|
|
}
|
|
|
|
static supplierAppBarWithActionsText(String title,context) {
|
|
title = title ?? '';
|
|
return AppBar(
|
|
backgroundColor: Colors.white,
|
|
elevation: 0,
|
|
scrolledUnderElevation: 0,
|
|
titleSpacing: 0,
|
|
title: Text(
|
|
title,
|
|
style: fontTextStyle(14, Color(0XFF101214), FontWeight.w500),
|
|
),
|
|
iconTheme: IconThemeData(color: Color(0XFF2A2A2A)),
|
|
leading: GestureDetector(
|
|
onTap: () {
|
|
Navigator.pop(context);
|
|
},
|
|
child: Padding(
|
|
padding: const EdgeInsets.fromLTRB(
|
|
8, 8, 8, 8), // Add padding if needed
|
|
child: Image.asset(
|
|
'images/backbutton_appbar.png',
|
|
height: 24,
|
|
width: 24,// Replace with your image path
|
|
fit: BoxFit.contain, // Adjust the fit
|
|
),
|
|
),
|
|
),
|
|
actions: [
|
|
Padding(padding: EdgeInsets.all(8),
|
|
child: TextButton(
|
|
onPressed: () async {
|
|
},
|
|
child: Text('HELP',
|
|
style: fontTextStyle(14,Color(0XFF1D7AFC),FontWeight.w600),),
|
|
),)
|
|
],
|
|
);
|
|
}
|
|
|
|
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 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);
|
|
}
|
|
|
|
/*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();
|
|
|
|
/*setState(() {
|
|
//refresh UI on update
|
|
});*/
|
|
});
|
|
}
|
|
}
|