fist commit ftc staff app clone

lib/web_services/api_services.dart

@@ -0,0 +1,40 @@
+import 'package:ftc_mobile_app/ftc_mobile_app.dart';
+import 'package:ftc_mobile_app/models/training/TrainingResponseData.dart';
+import 'package:ftc_mobile_app/utilities/enums/api_method.dart';
+
+class ApiService {
+  static final ApiService _instance = ApiService._private();
+
+  ApiService._private();
+
+  factory ApiService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+
+  Future<dynamic> allTrainingsList() async {
+    Map<String, dynamic> requestBody = {
+      "sortorder": -1,
+      "offset": 0,
+      "limit": 50,
+      "query": {
+        "critarion": {
+          "user": "658adee559e19fef22ce1a17"
+        }
+      }
+    };
+
+    ResponseModel responseModel = await _httpClient.safeApiCall(
+      method: ApiMethod.post,
+      url: WebUrls.allTrainings,
+      body: requestBody,
+    );
+
+    if ((responseModel.statusCode ~/ 100) == 2) {
+      return TrainingResponseData.fromJson(responseModel.data);
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+}

lib/web_services/auth_services.dart

@@ -0,0 +1,130 @@
+import '../ftc_mobile_app.dart';
+
+class AuthService {
+  static final AuthService _instance = AuthService._constructor();
+
+  AuthService._constructor();
+
+  factory AuthService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+
+  // final LocalStorageManager _sessionManagement = LocalStorageManager();
+
+  Future<dynamic> loginUser(
+      {required String email,
+      required String password,
+      bool isRememberMe = false}) async {
+    Map<String, dynamic> requestBody = {
+      "email": email,
+      "password": password,
+      "fcm_tokens": {
+        "token":
+            "fY6_DGfGQ06OW4BUVEsEwG:APA91bGUFza2uhaaR0miN2jtY0ut7RuA5ObleZvqv2X8KLOBgksmDmgc9sHDdea-DBvHmz1aUwX1uhkysk92x50WQCLHPDD1VwGX5ybKhUwVdq4aBfI24vhXqMB-FksWXEZwzDAi9BA_",
+        // "token": "${await FirebaseMessaging.instance.getToken()}",
+        "deviceType": "android"
+      }
+    };
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.signInUrl,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return true;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  //verify Otp  and if success storing token and user data
+  Future<dynamic> verifyOtp({required String verificationCode}) async {
+    Map<String, dynamic> requestBody = {
+      "email": LocalStorageManager.getSessionToken(
+          tokenKey: LocalStorageKeys.kSaveEmailKey),
+      "verification_code": verificationCode,
+    };
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.verifyCodeUrl,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+    );
+    if (responseModel.statusCode >= 200 &&
+        responseModel.statusCode <= 230 &&
+        responseModel.statusDescription == "Code verified successfully") {
+
+      final data = UserModel.fromJson(responseModel.data ?? {});
+
+      LocalStorageManager.setLoginToken(responseModel.userToken);
+      LocalStorageManager.setUserId(data.id);
+      // await LocalStorageManager.saveSession(
+      //   tokenKey: LocalStorageKeys.kUserModelKey,
+      //   tokenValue:
+      //       json.encode(UserModel.fromJson(responseModel.data ?? "").toJson()),
+      // );
+      // FrequentFunctions.userModel.value =
+      //     UserModel.fromJson(responseModel.data ?? "");
+      return true;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> passwordLessLogin(
+      {required String email, bool isRememberMe = false}) async {
+    Map<String, dynamic> requestBody = {
+      "email": email,
+      "expiryTime": "3m",
+      "fcm_tokens": {
+        "token":
+            "fY6_DGfGQ06OW4BUVEsEwG:APA91bGUFza2uhaaR0miN2jtY0ut7RuA5ObleZvqv2X8KLOBgksmDmgc9sHDdea-DBvHmz1aUwX1uhkysk92x50WQCLHPDD1VwGX5ybKhUwVdq4aBfI24vhXqMB-FksWXEZwzDAi9BA_",
+        "deviceType": "android"
+      }
+    };
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.passwordLessSignInUrl,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return true;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> forgetPassword({required String email}) async {
+    Map<String, dynamic> requestBody = {
+      "email": email,
+      // "fcm_tokens": {
+      //   "token":
+      //       "fY6_DGfGQ06OW4BUVEsEwG:APA91bGUFza2uhaaR0miN2jtY0ut7RuA5ObleZvqv2X8KLOBgksmDmgc9sHDdea-DBvHmz1aUwX1uhkysk92x50WQCLHPDD1VwGX5ybKhUwVdq4aBfI24vhXqMB-FksWXEZwzDAi9BA_",
+      //   "deviceType": "android"
+      // }
+    };
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.forgetPasswordUrl,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return true;
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+}

lib/web_services/chat_services.dart

@@ -0,0 +1,328 @@
+import 'dart:io';
+
+import 'package:dio/dio.dart';
+import 'package:ftc_mobile_app/ftc_mobile_app.dart';
+import 'package:ftc_mobile_app/models/chat/ChatModel.dart';
+import 'package:ftc_mobile_app/models/chat/add_group_message_model.dart';
+import 'package:ftc_mobile_app/models/chat/all_group_messages_model.dart';
+import 'package:ftc_mobile_app/models/chat/all_single_chat_message_model.dart';
+import 'package:ftc_mobile_app/models/chat/combined_last_messages_model_class.dart';
+import '../models/chat/single_chat.dart';
+
+enum MessageType { file, message }
+
+class ChatService {
+  static final ChatService _instance = ChatService._private();
+
+  ChatService._private();
+
+  factory ChatService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+
+  Future<dynamic> _uploadFile({
+    required String filePath,
+  }) async {
+    final formData = FormData();
+    formData.files.add(MapEntry(
+      "attachment",
+      MultipartFile.fromFileSync(filePath),
+    ));
+
+    ResponseModel responseModel = await _httpClient.safeFormDataRequest(
+      url: WebUrls.uploadMessageAttachmentsURL,
+      body: formData,
+    );
+
+    print("responseModel is : ${responseModel.toJson()}");
+
+    if ((responseModel.statusCode ~/ 100) == 2) {
+      //Success response
+      return responseModel.data; // returning file path from response
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+
+    // final files = <String, String>{"attachment": filePath};
+    // ResponseModel responseModel = await _httpClient.postMultipartRequest(
+    //   files: files,
+    //   url: WebUrls.uploadMessageAttachmentsURL,
+    // );
+    //
+    // if (responseModel.statusCode ~/ 100 == 2) {
+    //   print("got data as: ${responseModel.data}");
+    //   return responseModel.data;
+    // } else {
+    //   return {
+    //     "message": responseModel.statusDescription,
+    //   };
+    // }
+  }
+
+  Future<dynamic> addSingleMessage({
+    required String message,
+    required MessageType messageType,
+    File? file,
+    required String senderId,
+    required String receiverId,
+  }) async {
+    Map<String, dynamic> requestBody = {
+      "from": senderId,
+      "to": receiverId,
+      "message": message,
+      "messageType": messageType.name,
+    };
+
+    if (messageType == MessageType.file) {
+      if (file == null) {
+        return {
+          "message": "Please select file to upload",
+        };
+      }
+
+      final resp = await _uploadFile(filePath: file.path);
+      print("upload resp: $resp");
+      if (resp is String) {
+        requestBody['message'] = resp; //overriding message in case of file send
+        requestBody['filePath'] = resp;
+      } else {
+        return {
+          "message": "Failed to send file",
+        };
+      }
+    }
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.addSingleMessageChatURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 &&
+        responseModel.statusCode <= 230 &&
+        responseModel.statusDescription
+            .toLowerCase()
+            .contains("message added")) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        SingleChatModelClass singleChatModelClass =
+            SingleChatModelClass.fromJson(responseModel.data[0]);
+        return singleChatModelClass;
+      } else {
+        SingleChatModelClass singleChatModelClass =
+            SingleChatModelClass.fromJson(responseModel.data);
+        return singleChatModelClass;
+      }
+      // return true;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> addGroupMessageService(
+      {required String message,
+      required MessageType messageType,
+      File? file,
+      required String groupId,
+      required String userId}) async {
+    Map<String, dynamic> requestBody = {
+      "groupId": groupId,
+      "userId": userId,
+      "message": message,
+      "messageType": messageType.name,
+    };
+
+    if (messageType == MessageType.file) {
+      if (file == null) {
+        return {
+          "message": "Please select file to upload",
+        };
+      }
+
+      final resp = await _uploadFile(filePath: file.path);
+      print("upload resp: $resp");
+      if (resp is String) {
+        requestBody['message'] = resp; //overriding message in case of file send
+        requestBody['filePath'] = resp;
+      } else {
+        return {
+          "message": "Failed to send file",
+        };
+      }
+    }
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.addGroupMessageServiceURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        AddDeleteUpdateGroupMessageModel addGroupMessage =
+            AddDeleteUpdateGroupMessageModel.fromJson(responseModel.data[0]);
+        return addGroupMessage;
+      } else {
+        AddDeleteUpdateGroupMessageModel addGroupMessage =
+            AddDeleteUpdateGroupMessageModel.fromJson(responseModel.data);
+        return addGroupMessage;
+      }
+      // return true;
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+
+  Future<dynamic> combinedLastMessage({required String userId}) async {
+    Map<String, dynamic> requestBody = {
+      "userId": userId,
+    };
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.combinedLastMessageURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 &&
+        responseModel.statusCode <= 230 &&
+        responseModel.statusDescription
+            .toLowerCase()
+            .contains("group messages")) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        CombinedMessageModel combinedMessageModel =
+            CombinedMessageModel.fromJson(responseModel.data[0]);
+        return combinedMessageModel;
+      } else {
+        CombinedMessageModel combinedMessageModel =
+            CombinedMessageModel.fromJson(responseModel.data);
+        return combinedMessageModel;
+      }
+      // return true;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> allGroupMessages({
+    required int sortOrder,
+    required int offset,
+    required int limit,
+    required String groupId,
+    required bool isDeleted,
+  }) async {
+    Map<String, dynamic> requestBody = {
+      "sortProperty": "createdAt",
+      "sortOrder": sortOrder,
+      "offset": offset,
+      "limit": limit,
+      "query": {
+        "critarion": {"groupId": groupId, "isDeleted": false}
+      }
+    };
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.allGroupMessagesURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        List<AllGroupMessages> listOfMessages = [];
+        for (final item in responseModel.data) {
+          listOfMessages.add(AllGroupMessages.fromJson(item));
+        }
+        return listOfMessages;
+      } else {
+        return <AllGroupMessages>[];
+      }
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+
+  Future<dynamic> allSingleChatMessages({required String userId}) async {
+    Map<String, dynamic> requestBody = {
+      "userId": userId,
+    };
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.allSingleChatMessagesURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 &&
+        responseModel.statusCode <= 230 &&
+        responseModel.statusDescription
+            .toLowerCase()
+            .contains("all messages load")) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        List<AllSingleChatMessages> listOfMessages = [];
+        for (var item in responseModel.data) {
+          listOfMessages.add(AllSingleChatMessages.fromJson(item));
+        }
+        return listOfMessages;
+      } else {
+        AllSingleChatMessages allSingleChatMessages =
+            AllSingleChatMessages.fromJson(responseModel.data);
+        return allSingleChatMessages;
+      }
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> allSingleUsersChatMessagesServerAdmin({
+    required String to,
+    required String from,
+  }) async {
+    Map<String, dynamic> requestBody = {
+      "to": to,
+      "from": from,
+    };
+
+    ResponseModel responseModel = await _httpClient.customRequest(
+      "POST",
+      url: WebUrls.allSingleChatMessagesServiceAdminURL,
+      requestBody: requestBody,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      if (responseModel.data is List && responseModel.data.length > 0) {
+        List<ChatModel> listOfMessages = [];
+        for (final item in responseModel.data) {
+          listOfMessages.add(ChatModel.fromJson(item));
+        }
+        return listOfMessages;
+      } else {
+        // AllSingleUsersChats allSingleUsersChats =
+        //     AllSingleUsersChats.fromJson(responseModel.data);
+        return <ChatModel>[];
+      }
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+}

lib/web_services/export_web_services.dart

@@ -0,0 +1,7 @@
+export 'auth_services.dart';
+export 'client_services.dart';
+export 'message_services.dart';
+export 'notification_services.dart';
+export 'rota_services.dart';
+export 'http_request_client.dart';
+export 'web_url.dart';

lib/web_services/http_request_client.dart

@@ -0,0 +1,774 @@
+import 'dart:async';
+import 'dart:convert';
+import 'dart:developer';
+import 'dart:io';
+import 'dart:typed_data';
+import 'package:dio/dio.dart';
+import 'package:flutter/foundation.dart';
+import 'package:ftc_mobile_app/utilities/enums/api_method.dart';
+import 'package:http/http.dart' as http;
+import 'package:ftc_mobile_app/ftc_mobile_app.dart';
+import 'package:http_parser/src/media_type.dart';
+
+import '../dialogs/app_dialogs.dart';
+import 'logging_interceptor.dart';
+
+class HttpRequestClient {
+  HttpRequestClient._();
+
+  static final HttpRequestClient _instance = HttpRequestClient._();
+
+  factory HttpRequestClient() {
+    return _instance;
+  }
+
+  static const int _kSecondsTimeout = 60;
+  static const String _kTimeOutMessage = "Unable to process request";
+  static const String _kInternetIssue =
+      "Your internet connection is not stable";
+  static const String _kOtherException = "Unable to process request";
+
+  Map<String, dynamic> errorResponse(String message) {
+    return Map.of({"success": false, "message": message});
+  }
+
+  Map<String, dynamic> _dioErrorHandler(DioException e) {
+    if (e.type == DioExceptionType.connectionError) {
+      return errorResponse(_kInternetIssue);
+    }
+
+    // The request was made and the server responded with a status code
+    // that falls out of the range of 2xx and is also not 304.
+    if (e.response != null) {
+      debugPrint('Dio error!');
+      debugPrint('STATUS: ${e.response?.statusCode}');
+      debugPrint('DATA: ${e.response?.data}');
+      debugPrint('HEADERS: ${e.response?.headers}');
+
+      if (e.response!.statusCode == HttpStatus.unauthorized ||
+          e.response!.statusCode == HttpStatus.forbidden) {
+        AppDialog.showUnauthorizedAlert();
+        return errorResponse('');
+      }
+
+      if (e.response!.data != null &&
+          e.response!.data is Map &&
+          (e.response!.data as Map).containsKey('message')) {
+        return errorResponse(e.response!.data['message'].toString());
+      }
+
+      // if (e.response!.statusCode == 401) {
+      //   return decoder(errorResponse(e.response!.data.toString()));
+      // }
+    } else {
+      // Error due to setting up or sending the request
+      debugPrint('Error sending request!');
+      debugPrint(e.message);
+    }
+
+    debugPrint('Dio ERROR  ${e.error}\n');
+
+    return errorResponse(_kOtherException);
+  }
+
+  Map<String, dynamic> exceptionHandler(e) {
+    debugPrint("Web Error: $e");
+    debugPrint("e Type: ${e.runtimeType.toString()}");
+    if (e is SocketException) {
+      return errorResponse(_kInternetIssue);
+    } else if (e is TimeoutException) {
+      return errorResponse(_kInternetIssue);
+    } else if (e is FormatException) {
+      return errorResponse(_kOtherException);
+    } else {
+      return errorResponse(_kOtherException);
+    }
+  }
+
+  //----------------------------------------------------------------
+  Future<ResponseModel> getRequestWithOutHeader({required String url}) async {
+    try {
+      http.Response response = await http
+          .get(
+            Uri.parse(url),
+          )
+          .timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      ResponseModel responseModel = ResponseModel();
+      if (response.body.isNotEmpty && response.body.length > 4) {
+        responseModel.statusCode = response.statusCode;
+        responseModel.statusDescription = "Success";
+        responseModel.data = response.body;
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> getRequestWithRequestBody({
+    required String url,
+    dynamic requestBody,
+    Map<String, String>? requestHeader,
+  }) async {
+    try {
+      Map<String, String> header = {};
+      if (requestHeader == null) {
+        header = await getRequestHeader();
+      }
+      final uri = Uri.parse(url);
+      final uriWithBody = uri.replace(
+        queryParameters: requestBody,
+      );
+      http.Response response = await http
+          .get(
+            uriWithBody,
+            headers: requestHeader ?? header,
+          )
+          .timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      ResponseModel responseModel = ResponseModel();
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(response.body),
+          statusCode: response.statusCode,
+        );
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(response.body),
+          statusCode: response.statusCode,
+        );
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> postRequest({
+    required String url,
+    dynamic requestBody,
+    bool doJsonEncodeRequestBody = false,
+    bool isTokenRequired = false,
+    dynamic requestHeader,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      Map<String, String> header = {};
+      if (isTokenRequired) {
+        header = await getRequestHeader(isBearer: true);
+      }
+      http.Response response = await http
+          .post(
+            Uri.parse(url),
+            body:
+                doJsonEncodeRequestBody ? jsonEncode(requestBody) : requestBody,
+            headers: isTokenRequired ? header : requestHeader,
+          )
+          .timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(response.body),
+          statusCode: response.statusCode,
+        );
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(response.body),
+          statusCode: response.statusCode,
+        );
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> uploadImageRequest({
+    required String url,
+    required String filePath,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      Map<String, String> header = {};
+      header = await getRequestHeader(isBearer: true);
+      http.MultipartRequest request = http.MultipartRequest(
+        "POST",
+        Uri.parse(url),
+      );
+      request.files.add(
+        await http.MultipartFile.fromPath(
+          "photo",
+          filePath,
+        ),
+      );
+      request.headers.addAll(header);
+      http.StreamedResponse response = await request.send().timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> patchRequest({
+    required String url,
+    dynamic requestBody,
+    bool isBearerHeaderRequired = false,
+    bool isContentType = true,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      Map<String, String> header = {};
+      if (isBearerHeaderRequired) {
+        header = await getRequestHeader(
+          isBearer: true,
+          isContentType: isContentType,
+        );
+      }
+      http.Request request = http.Request(
+        'PATCH',
+        Uri.parse(url),
+      );
+      request.body = jsonEncode(requestBody);
+      request.headers.addAll(header);
+      http.StreamedResponse response = await request.send().timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> deleteRequest({
+    required String url,
+    bool isBearerHeaderRequired = false,
+    dynamic requestBody,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      Map<String, String> header = {};
+      if (isBearerHeaderRequired) {
+        header = await getRequestHeader(isBearer: true);
+      }
+      http.Request request = http.Request(
+        'DELETE',
+        Uri.parse(url),
+      );
+      request.headers.addAll(header);
+      if (requestBody != null) {
+        request.body = jsonEncode(requestBody);
+      }
+      http.StreamedResponse response = await request.send().timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> customRequest(
+    String requestType, {
+    required String url,
+    bool isBearerHeaderRequired = false,
+    bool isBearer = true,
+    dynamic requestBody,
+    dynamic requestHeader,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      Map<String, String> header = {};
+      if (isBearerHeaderRequired) {
+        header = await getRequestHeader(isBearer: isBearer);
+      }
+      http.Request request = http.Request(
+        requestType,
+        Uri.parse(url),
+      );
+      request.headers.addAll(isBearerHeaderRequired ? header : requestHeader);
+      request.body = json.encode(requestBody);
+      log('--------------request.url----------------------------($requestType) ${request.url.origin}${request.url.path}');
+      log('--------------request.headers----------------------------${request.headers}');
+      log('--------------request.body----------------------------${request.body}');
+      http.StreamedResponse response = await request.send().timeout(
+            const Duration(
+              seconds: _kSecondsTimeout,
+            ),
+          );
+      if ((response.statusCode >= 200 && response.statusCode <= 230)) {
+        responseModel = ResponseModel.fromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+        log("Api Response($url):\n${jsonEncode(responseModel.toJson())}");
+      } else {
+        responseModel = ResponseModel.errorFromJson(
+          jsonDecode(await response.stream.bytesToString()),
+          statusCode: response.statusCode,
+        );
+        print("FUTURE Expection");
+        print(responseModel);
+      }
+      // log('----------------response model is---------------${responseModel.toString()}');
+      return responseModel;
+    } on TimeoutException catch (e) {
+      print("TimeOut Expection");
+      print(e);
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      print("SOCKET Expection");
+      print(e);
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      print("FUTURE Expection");
+      print(e);
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<ResponseModel> uploadVideoRequest({
+    required String uploadUrl,
+    required Uint8List chunkStream,
+  }) async {
+    try {
+      ResponseModel responseModel = ResponseModel();
+      http.StreamedRequest request = http.StreamedRequest(
+        "PUT",
+        Uri.parse(uploadUrl),
+      );
+      request.headers.addAll({
+        'Content-Length': "${chunkStream.length}",
+        'Content-Type': 'video/mp4',
+        'content-type': 'application/octet-stream'
+      });
+      request.sink.add(chunkStream);
+      request.sink.close();
+      http.StreamedResponse response = await request.send();
+      responseModel.statusCode = response.statusCode;
+      responseModel.statusDescription = response.reasonPhrase ?? '';
+      responseModel.header = response.headers;
+      return responseModel;
+    } on TimeoutException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 408,
+          statusDescription: _kTimeOutMessage,
+          data: e.toString(),
+        ),
+      );
+    } on SocketException catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 400,
+          statusDescription: _kInternetIssue,
+          data: e.toString(),
+        ),
+      );
+    } catch (e) {
+      return Future.value(
+        ResponseModel.named(
+          statusCode: 500,
+          statusDescription: _kOtherException,
+          data: e.toString(),
+        ),
+      );
+    }
+  }
+
+  Future<Map<String, String>> getRequestHeader({
+    bool isBearer = true,
+    bool isContentType = true,
+  }) async {
+    // String token = SessionManagement().getSessionToken(
+    //   tokenKey: SessionKeys.kUserTokenKey,
+    // );
+    //todo remove this in end
+    String token =
+        'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJhIjp0cnVlLCJuIjoiSmFtc2hhaWQgU2FiaXIiLCJlIjoiamFtc2hhaWRzYWJpcjQxMTk4MEBnbWFpbC5jb20iLCJkIjoiNjQ2NTEyN2E3MmJjNzEzY2E4NDYwY2IzIiwicCI6Ii91cGxvYWRzL2RwL2RlZmF1bHQucG5nIiwiciI6Il9hIiwiaWF0IjoxNjkzMjIzNTIzfQ.EtpS_o0kEhdlNzCyFdFNNQzHd0IipTw8BEuUBVgfYok';
+    Map<String, String> header = {
+      'Authorization': isBearer ? 'Bearer $token' : token,
+      if (isContentType) 'Content-Type': 'application/json'
+    };
+    return header;
+  }
+
+  Future<dynamic> safeApiCall({
+    required ApiMethod method,
+    required String url,
+    Map<String, String>? headers,
+    Map? body,
+    Map<String, String>? param,
+  }) async {
+    try {
+      // final hasInternet = await FrequentFunctions.hasInternetConnection;
+      // debugPrint("hasInternet: $hasInternet");
+      //
+      // if (!hasInternet) {
+      //   return decoder(errorResponse(errorMsgNoInternet));
+      // }
+
+      Map<String, String> customHeader = await getRequestHeader();
+      if(headers != null) customHeader.addAll(headers!);
+
+      final dio = Dio()
+        ..interceptors.add(Logging())
+        ..options.headers.addAll(customHeader);
+
+      if (headers != null) {
+        dio.options.headers.addAll(headers);
+      }
+
+      Response response;
+      switch (method) {
+        case ApiMethod.get:
+          response = await dio.get(url, queryParameters: param);
+          break;
+        case ApiMethod.post:
+          response = await dio.post(
+            url,
+            data: (body == null) ? null : json.encode(body),
+            queryParameters: param,
+          );
+          break;
+        case ApiMethod.put:
+          response = await dio.put(
+            url,
+            data: (body == null) ? null : json.encode(body),
+            queryParameters: param,
+          );
+          break;
+        case ApiMethod.patch:
+          response = await dio.patch(
+            url,
+            data: (body == null) ? null : json.encode(body),
+            queryParameters: param,
+          );
+          break;
+        case ApiMethod.delete:
+          response = await dio.delete(
+            url,
+            data: (body == null) ? null : json.encode(body),
+            queryParameters: param,
+          );
+          break;
+      }
+
+      return ResponseModel.fromJson(jsonDecode(response.toString()))
+        ..statusCode = response.statusCode ?? 0;
+
+    } on DioException catch (e) {
+      return ResponseModel.named(
+        statusCode: e.response?.statusCode ?? 0,
+        statusDescription: _dioErrorHandler(e)['message'],
+      );
+    } catch (e) {
+      debugPrint("Web Error: $e");
+
+      return ResponseModel.named(
+        statusCode: 0,
+        statusDescription: exceptionHandler(e)['message'],
+      );
+    }
+  }
+
+  Future<ResponseModel> safeFormDataRequest({
+    required String url,
+    required FormData body,
+  }) async {
+    try {
+      Map<String, String> customHeader = await getRequestHeader();
+
+      final dio = Dio()
+        ..interceptors.add(Logging())
+        ..options.headers.addAll(customHeader);
+
+      final response = await dio.post(
+        url,
+        data: body,
+        onSendProgress: (int sent, int total) {
+          debugPrint('$sent $total');
+        },
+      );
+
+      return ResponseModel.fromJson(jsonDecode(response.toString()))
+        ..statusCode = response.statusCode ?? 0;
+    } on DioException catch (e) {
+      return ResponseModel.named(
+        statusCode: e.response?.statusCode ?? 0,
+        statusDescription: _dioErrorHandler(e)['message'],
+      );
+    } catch (e) {
+      debugPrint("Web Error: $e");
+
+      return ResponseModel.named(
+        statusCode: 0,
+        statusDescription: exceptionHandler(e)['message'],
+      );
+    }
+  }
+
+  Future<ResponseModel> postMultipartRequest(
+      {required String url,
+      Map<String, String> fields = const {},
+      Map<String, String> files = const {}}) async {
+    try {
+      Map<String, String> customHeader = await getRequestHeader();
+      // customHeader['Connection'] = 'keep-alive';
+      // customHeader['Accept'] = 'application/json';
+      // customHeader['Content-Type'] = 'multipart/form-data';
+      http.MultipartRequest request =
+          http.MultipartRequest('POST', Uri.parse(url));
+
+      request.headers.addAll(customHeader);
+      request.fields.addAll(fields);
+
+      for (MapEntry<String, String> file in files.entries) {
+        String type = file.value.substring(file.value.lastIndexOf('.') + 1);
+        String name = file.value.substring(file.value.lastIndexOf('/') + 1);
+
+        request.files.add(await http.MultipartFile.fromPath(
+          file.key,
+          file.value,
+          filename: name,
+          contentType: MediaType('image', type),
+        ));
+      }
+
+      http.StreamedResponse streamedResponse = await request.send();
+      http.Response httpResponse =
+          await http.Response.fromStream(streamedResponse);
+      log('────────────────────url> $url');
+      log('────────────────────files> $files');
+      log('────────────────────fields> $fields');
+      log('────────────────────Response.body> ${httpResponse.body}');
+      ResponseModel response =
+          ResponseModel.fromJson(jsonDecode(httpResponse.body));
+      return Future.value(response);
+    } on HttpException catch (e) {
+      return Future.value(ResponseModel.named(
+          statusCode: 405, statusDescription: e.message, data: e.toString()));
+    } on TimeoutException {
+      return Future.value(ResponseModel.named(
+          statusCode: 408,
+          statusDescription: "Request TimeOut",
+          data: "Request TimeOut"));
+    } on SocketException {
+      return Future.value(ResponseModel.named(
+          statusCode: 400,
+          statusDescription: "Bad Request",
+          data: "Bad Request"));
+    } catch (e) {
+      return Future.value(ResponseModel.named(
+          statusCode: 500,
+          statusDescription: "Service Error",
+          data: "Service Error"));
+    }
+  }
+}

lib/web_services/logging_interceptor.dart

@@ -0,0 +1,103 @@
+import 'dart:convert';
+import 'dart:developer';
+import 'package:dio/dio.dart';
+import 'package:flutter/foundation.dart';
+
+class Logging extends Interceptor {
+  // String get _token => LocalStorage.token ?? emptyString;
+
+  // String get _userId => GetStorage().read(keyUserId) ?? emptyString;
+
+  // Map<String, String> get headers => {HttpHeaders.authorizationHeader: _token};
+
+  @override
+  void onRequest(RequestOptions options, RequestInterceptorHandler handler) {
+    // if (_token.isNotEmpty) {
+    //   options.headers.addAll({HttpHeaders.authorizationHeader: _token});
+    // }
+
+    if (kDebugMode) {
+      // Logger.print(options);
+      _CurlLogger.print(options);
+    }
+
+    return super.onRequest(options, handler);
+  }
+
+  @override
+  void onResponse(Response response, ResponseInterceptorHandler handler) {
+    if (kDebugMode) {
+      log('RESPONSE(${response.statusCode}) => ${response.requestOptions.baseUrl + response.requestOptions.path}'
+          '\n'
+          "api response: ${jsonEncode(response.data)}");
+    }
+    return super.onResponse(response, handler);
+  }
+
+  @override
+  void onError(DioException err, ErrorInterceptorHandler handler) {
+    if (kDebugMode) {
+      debugPrint(
+        'ERROR(${err.response?.statusCode}) => ${err.requestOptions.baseUrl + err.requestOptions.path}',
+      );
+    }
+    return super.onError(err, handler);
+  }
+}
+
+abstract class _SimpleLogger {
+  static print(RequestOptions options) {
+    debugPrint('REQUEST(${options.method}) => ${options.uri.toString()}');
+    debugPrint('Headers: ${options.headers}');
+    if (options.queryParameters.isNotEmpty) {
+      log("queryParameters: ${options.queryParameters}");
+    }
+
+    if (options.data != null) {
+      if (options.data is FormData) {
+        debugPrint("data: ");
+        for (var value in (options.data as FormData).fields) {
+          log(value.toString());
+        }
+
+        debugPrint("files: ");
+        for (var value in (options.data as FormData).files) {
+          log("${value.key}: ${value.value.filename}");
+        }
+      } else {
+        log("data: ${options.data}");
+      }
+    }
+  }
+}
+
+abstract class _CurlLogger {
+  static print(RequestOptions options) {
+    String curl = 'curl';
+    curl += " --location '${options.uri}'";
+    if (options.data != null) {
+      // Add the data
+
+      if (options.data is FormData) {
+        for (MapEntry entry in (options.data as FormData).fields) {
+          curl += " --form '${entry.key}=\"${entry.value}\"'";
+        }
+
+        for (MapEntry<String, MultipartFile> entry
+        in (options.data as FormData).files) {
+          curl += " --form '${entry.key}=@\"${entry.value.filename}\"'";
+        }
+      } else {
+        curl += ' --data \'${options.data}\'';
+      }
+    }
+
+    if (options.headers.isNotEmpty) {
+      // Add the headers
+      options.headers.forEach((key, value) {
+        curl += ' --header \'$key: $value\'';
+      });
+    }
+    log(curl);
+  }
+}

lib/web_services/message_services.dart

@@ -0,0 +1,14 @@
+import 'http_request_client.dart';
+
+class MessageService {
+  static final MessageService _instance = MessageService._private();
+
+  MessageService._private();
+
+  factory MessageService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+// final SessionManagement _sessionManagement = SessionManagement();
+}

lib/web_services/notification_services.dart

@@ -0,0 +1,45 @@
+import 'http_request_client.dart';
+import 'web_url.dart';
+
+class NotificationService {
+  static final NotificationService _instance = NotificationService._private();
+
+  NotificationService._private();
+
+  factory NotificationService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+
+// final SessionManagement _sessionManagement = SessionManagement();
+
+  Future<dynamic> getNotifications() async {
+    final responseModel = await _httpClient.customRequest(
+      "GET",
+      url: WebUrls.getNotifications,
+      requestHeader: {'Content-Type': 'application/json'},
+      isBearerHeaderRequired: true,
+      isBearer: true,
+    );
+
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      // if (responseModel.data is List &&
+      //     (responseModel.data as List).isNotNullOrEmpty()) {
+      //   return GetRiskAssessmentResponse(
+      //       success: true,
+      //       data: (responseModel.data as List)
+      //           .map((e) => RiskAssessmentData.fromJson(e))
+      //           .toList());
+      // }
+      //
+      // return GetRiskAssessmentResponse(success: true, data: []);
+
+      return [];
+    } else {
+      return responseModel.statusDescription;
+      // return GetRiskAssessmentResponse(
+      //     success: false, message: responseModel.statusDescription);
+    }
+  }
+}

lib/web_services/rota_services.dart

@@ -0,0 +1,178 @@
+import 'dart:convert';
+
+import 'package:ftc_mobile_app/ftc_mobile_app.dart';
+
+import '../models/requests/HolidayRequestData.dart';
+import '../models/rota/LiveRoasterResponseData.dart';
+import '../models/staffWorkload/StaffWorkloadResponse.dart';
+
+class RotaService {
+  static final RotaService _instance = RotaService._private();
+
+  RotaService._private();
+
+  factory RotaService() {
+    return _instance;
+  }
+
+  final HttpRequestClient _httpClient = HttpRequestClient();
+
+  Future<dynamic> getMyShifts(
+      {required int startDateMills, required int endDateMills}) async {
+    // final userJson = LocalStorageManager.getSessionToken(
+    //   tokenKey: LocalStorageKeys.kUserModelKey,
+    // );
+    // final userModel = UserModel.fromJson(jsonDecode(userJson));
+
+    Map<String, dynamic> requestBody = {
+      "startDate": startDateMills,
+      "endDate": endDateMills,
+      "staffUserId": LocalStorageManager.userId,
+      // "startDate": 1720983600000,
+      // "endDate": 1721502000000,
+      // "staffUserId": "659653a31faf0d9fa4e15d5d",
+    };
+    ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.myShifts,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return LiveRoasterResponseData.fromJson({'data': responseModel.data});
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> getAvailableShifts() async {
+    Map<String, dynamic> requestBody = {
+      "startDate": DateTime.now().millisecondsSinceEpoch
+    };
+    ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.unassignedShifts,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return LiveRoasterResponseData.fromJson({'data': responseModel.data});
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> claimShift({
+    required String rosterId,
+    required String locationId,
+    required String dayId,
+  }) async {
+    // final userJson = LocalStorageManager.getSessionToken(
+    //   tokenKey: LocalStorageKeys.kUserModelKey,
+    // );
+    // final userModel = UserModel.fromJson(jsonDecode(userJson));
+    Map<String, dynamic> requestBody = {
+      "rosterId": rosterId,
+      "locationId": locationId,
+      "staffUserId": LocalStorageManager.userId,
+      "dayId": dayId,
+    };
+    ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.assignStaffToShift,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      print("responseModel.data type: ${responseModel.data.runtimeType}");
+      return LiveRoasterResponseData.fromJson({'data': responseModel.data});
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> serviceUserShifts(
+      {required String serviceUserId,
+      required int month,
+      required int year}) async {
+    Map<String, dynamic> requestBody = {
+      "serviceUser": serviceUserId,
+      "month": month, //Dec
+      "year": year,
+    };
+    ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.rotaServiceUserShiftsListUrl,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return (responseModel.data['filteredShifts'] is List) &&
+              responseModel.data['filteredShifts'].isNotEmpty
+          ? MonthWiseRecord.fromJson(responseModel.data['filteredShifts'][0])
+          : false;
+    } else {
+      return {
+        "message": responseModel.statusDescription,
+      };
+    }
+  }
+
+  Future<dynamic> getStaffWorkload() async {
+    // final userJson = LocalStorageManager.getSessionToken(
+    //   tokenKey: LocalStorageKeys.kUserModelKey,
+    // );
+    // print("userJson: $userJson");
+    // final userModel = UserModel.fromJson(jsonDecode(userJson));
+
+    Map<String, dynamic> requestBody = {
+      "sortproperty": "createdAt",
+      "sortorder": -1,
+      "offset": 0,
+      "limit": 1,
+      "query": {
+        "critarion": {"staffMember": LocalStorageManager.userId},
+        "staffMemberfields": "staffMemberName",
+        "usersFields": "profile_picture_url name",
+        "addedby": "_id email name",
+        "lastModifiedBy": "_id email name"
+      }
+    };
+    ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.getStaffWorkload,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return StaffWorkloadResponse.fromJson({'data': responseModel.data})
+        ..status = "Success"
+        ..message = responseModel.statusDescription;
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+
+  Future<dynamic> requestHoliday({required HolidayRequestData request}) async {
+    Map<String, dynamic> requestBody =
+        (request..staffRequester = LocalStorageManager.userId).toJson();
+
+    final ResponseModel responseModel = await _httpClient.customRequest('POST',
+        requestBody: requestBody,
+        url: WebUrls.requestHoliday,
+        requestHeader: {'Content-Type': 'application/json'},
+        isBearer: true,
+        isBearerHeaderRequired: true);
+    if (responseModel.statusCode >= 200 && responseModel.statusCode <= 230) {
+      return responseModel;
+    } else {
+      return responseModel.statusDescription;
+    }
+  }
+}

lib/web_services/web_url.dart

@@ -0,0 +1,105 @@
+class WebUrls extends _BaseUrl {
+  WebUrls._();
+
+  static String baseUrl = _BaseUrl.baseUrl; //Test
+  // static String baseUrl = _BaseUrl.liveBaseUrl; //Live
+
+  static String socketUrl = 'http://16.171.242.62:3000';
+
+  static String signInUrl = "$baseUrl/users/signin";
+  static String passwordLessSignInUrl = "$baseUrl/users/passwordLessLogin";
+  static String forgetPasswordUrl = "$baseUrl/users/forgot-password";
+  static String verifyCodeUrl = "$baseUrl/users/verify-code";
+  static String verifyTokenUrl = "$baseUrl/users/verifyToken";
+  static String rotaServiceUserShiftsListUrl =
+      "$baseUrl/serviceUserShifts/getSrUsShiftsRequiredsListForAMonth";
+  static String userProfileUrl =
+      "$baseUrl/staffMembers/getStaffMembersWithFullDetails";
+  static String addConsentUrl =
+      "$baseUrl/consentTemplateRoute/addConsentTemplate";
+  static String getConsentListUrl =
+      "$baseUrl/consentTemplateRoute/getconsentTemplate";
+  static String deleteConsentUrl =
+      "$baseUrl/consentTemplateRoute/removeConsentTemplate";
+  static String updateConsentUrl =
+      "$baseUrl/consentTemplateRoute/updateConsentTemplate";
+
+  // static String getServiceUsersListUrl =
+  //     "${baseUrl}/serviceUsers/getServiceUsersWithFullDetails";
+  static String getServiceUsersListUrl = "$baseUrl/users/listAllServiceUsers";
+  static String getBodyPointsCategoryListURL =
+      "$baseUrl/consentTemplateRoute/getHealthCategories";
+  static String addHealthIssuesURL =
+      "$baseUrl/consentTemplateRoute/addHealthIssues";
+  static String getHealthIssuesListURL =
+      "$baseUrl/consentTemplateRoute/getHealthIssues";
+  static String updateHealthIssueURL =
+      "$baseUrl/consentTemplateRoute/updateHealthIssues";
+  static String getHealthIssueChildCategoryListURL =
+      "$baseUrl/consentTemplateRoute/getChildHealthCategories";
+  static String addRecentIncidentServiceURL = "$baseUrl/incident/addIncident";
+  static String getRecentIncidentsListServiceURL =
+      "$baseUrl/incident/getIncidentWithFullDetails";
+  static String updateRecentIncidentServiceURL =
+      "$baseUrl/incident/updateIncident";
+  static String deleteRecentIncidentUrl = "$baseUrl/incident/removeIncident";
+  static String addPbsPlanServiceURL = "$baseUrl/pbsplans/addPbsplan";
+  static String updatePbsPlanServiceURL = "$baseUrl/pbsplans/updatePbsplan";
+  static String getPbsPlanServiceURL = "$baseUrl/pbsplans/getPbsPlanList";
+  static String deletePbsPlanServiceURL = "$baseUrl/pbsplans/deletePbsPlanList";
+  static String getDocumentsListServiceURL = "$baseUrl/document/documentList";
+  static String addDocumentServiceURL = "$baseUrl/document/addDocument";
+  static String updateDocumentServiceURL = "$baseUrl/document/updateDocument";
+  static String deleteDocServiceURL = "$baseUrl/document/removeDocument";
+  static String uploadDocServiceURL = "$baseUrl/uploads/uploadReferenceDoc";
+  static String addSingleMessageChatURL = "$baseUrl/messages/addMessage";
+  static String uploadMessageAttachmentsURL =
+      "$baseUrl/messages/uploadMessageAttachments";
+  static String addGroupMessageServiceURL = "$baseUrl/messages/addGroupMessage";
+  static String deleteGroupMessageServiceURL =
+      "$baseUrl/messages/deleteGroupMessage";
+  static String updateGroupMessageServiceURL =
+      "$baseUrl/messages/updateGroupMessage";
+  static String combinedLastMessageURL =
+      "$baseUrl/messages/combinedLastMessages";
+  static String allGroupMessagesURL = "$baseUrl/messages/messageByGroupId";
+  static String allSingleChatMessagesURL = "$baseUrl/messages/getAllMessage";
+  static String allSingleChatMessagesServiceAdminURL =
+      "$baseUrl/messages/getMessage";
+  static String updateSingleChatMessageURL = "$baseUrl/messages/updateMessage";
+  static String deleteSingleChatMessageURL = "$baseUrl/messages/deleteMessage";
+
+  static String deleteChatURL = "$baseUrl/messages/deleteChat";
+
+  static String createCarePlanURL = "$baseUrl/carePlans/createCarePlan";
+  static String getCarePlansListURL = "$baseUrl/carePlans/getCarePlansList";
+  static String getStaffWorkload =
+      "$baseUrl/staffWorkLoads/getStaffWorkLoadsWithFullDetails";
+  static String requestHoliday =
+      "$baseUrl/staffHolidayRequests/createStaffHolidayRequest";
+  static String myShifts = "$baseUrl/liveRoster/checkExistShiftByStaffId";
+  static String unassignedShifts = "$baseUrl/liveRoster/unassignedShifts";
+  static String assignStaffToShift = "$baseUrl/liveRoster/assignStaffToShift";
+
+  static String getAppointmentsByDate =
+      "$baseUrl/appointment/getAppointmentsByDate";
+
+  static String getRiskAssesments = "$baseUrl/riskassesments/getRiskAssesments";
+
+  static String getNotifications = "$baseUrl/notifications/getNotifications";
+
+  static String getMemoryList = "$baseUrl/carePlans/getMemoryList";
+  static String uploadMemoryBoxFile = "$baseUrl/carePlans/uploadMemoryBoxFile";
+  static String addMemoryBox = "$baseUrl/carePlans/addMemoryBox";
+  static String updateMemoryBox = "$baseUrl/carePlans/updateMemoryBox";
+  static String createRiskAssesments =
+      "$baseUrl/riskassesments/createRiskAssesments";
+  static String listAllUsers = "$baseUrl/users/listAllUsers";
+  static String allTrainings =
+      "$baseUrl/proposedTrainings/getProposedTrainingsByStaff";
+}
+
+abstract class _BaseUrl {
+  static const baseUrl = "http://16.171.242.62:3000";
+  static const liveBaseUrl = "https://ftcaresoftware.co.uk/ft_care_server";
+}