sample code setup

lib/dev/main_dev.dart

+// Import necessary Dart files for environment configuration and application initialization
+import '../src/base/environment/app_config.dart';
+import '../src/main.dart';
+
+// Main entry point of the application
+void main() {
+  // Set the application environment to 'dev' (development) before initializing the app
+  setEnvironment(Environment.dev);
+
+  // Call the main delegate to start the application
+  mainDelegate();
+}

lib/preprod/main_preprod.dart

+// Import necessary Dart files for environment configuration and application start
+import '../src/base/environment/app_config.dart';
+import '../src/main.dart';
+
+// Main entry point of the application
+void main() {
+  // Set the application environment to 'preprod' (pre-production) before initializing the app
+  setEnvironment(Environment.preprod);
+
+  // Call the main delegate to start the application
+  mainDelegate();
+}

lib/prod/main_prod.dart

+// Import statements to include necessary Dart files from other parts of the project
+import '../src/base/environment/app_config.dart';
+import '../src/main.dart';
+
+// Main entry point of the application
+void main() {
+  // Set the application environment to 'prod' (production) before initializing the app
+  setEnvironment(Environment.prod);
+
+  // Call the main delegate to start the application
+  mainDelegate();
+}

lib/src/base/app_config.dart

+// Base URLs for various services in different environments
+const _baseUrl = "baseUrl";
+const _mediaUrl = "mediaUrl";
+const _feedbackUrl = "feedbackUrl";
+
+// Enum representing different environments
+enum Environment { dev, stage, preprod, prod }
+
+// Configuration map to store environment specific constants
+Map<String, dynamic>? _config;
+
+// Function to set the environment and update the configuration
+void setEnvironment(Environment env) {
+  _config = _getConstantsForEnv(env);
+}
+
+// Helper function to retrieve constants based on the environment
+Map<String, dynamic> _getConstantsForEnv(Environment env) {
+  switch (env) {
+    case Environment.dev:
+      return devConstants;
+    case Environment.stage:
+      return stageConstants;
+    case Environment.preprod:
+      return preprodConstants;
+    case Environment.prod:
+      return prodConstants;
+    default:
+      return devConstants; // Default to dev constants if no match
+  }
+}
+
+// Getter for API base URL
+dynamic get apiBaseUrl {
+  return _config![_baseUrl];
+}
+
+// Getter for media base URL
+String get mediaBaseUrl {
+  return _config![_mediaUrl];
+}
+
+// Getter for feedback URL
+String get feedbackUrl {
+  return _config![_feedbackUrl];
+}
+
+// Constants for development environment
+Map<String, dynamic> devConstants = {
+  _baseUrl: "https://my-app-dev.mydomain.us/",
+  _mediaUrl: "https://dev-my-app.mydomain.us/",
+  _feedbackUrl:
+      "https://dev-my-app.mydomain.us/feedback-form/parent-feedback-form/"
+};
+
+// Constants for staging environment
+Map<String, dynamic> stageConstants = {
+  _baseUrl: "https://my-app-stage.mydomain.us/",
+  _mediaUrl: "https://dev-my-app.mydomain.us/",
+  // Note: Media URL seems to be from dev?
+  _feedbackUrl:
+      "https://stage-my-app.mydomain.us/feedback-form/parent-feedback-form/"
+};
+
+// Constants for pre-production environment
+Map<String, dynamic> preprodConstants = {
+  _baseUrl: "https://my-app-preprod.mydomain.us/",
+  _mediaUrl: "https://preprod-my-app.mydomain.us/",
+  _feedbackUrl:
+      "https://preprod-my-app.mydomain.us/feedback-form/parent-feedback-form/"
+};
+
+// Constants for production environment
+Map<String, dynamic> prodConstants = {
+  _baseUrl: "https://my-app.mydomain.us/",
+  _mediaUrl: "https://my-app.mydomain.us/",
+  _feedbackUrl: "https://my-app.mydomain.us/feedback-form/parent-feedback-form/"
+};

lib/src/main.dart

+import 'package:firebase_core/firebase_core.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:flutter_screenutil/flutter_screenutil.dart';
+import 'package:provider/provider.dart';
+import 'package:schoolerp/src/appearance/theme.dart';
+import 'package:schoolerp/src/ui/activity/activityanalysis/bloc/activity_analysis_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitycurriculum/bloc/activity_curriculum_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitydetails/bloc/activity_details_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitygradecriteria/bloc/activity_grade_criteria_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitylist/bloc/activity_list_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitylo/bloc/activity_lo_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activitypendingskills/bloc/activity_pending_skills_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activityresources/bloc/activity_resources_bloc.dart';
+import 'package:schoolerp/src/ui/activity/activityselection/bloc/activity_selection_bloc.dart';
+import 'package:schoolerp/src/ui/attendance/bloc/attendance_bloc.dart';
+import 'package:schoolerp/src/ui/auth/forgot_password/bloc/forgot_password_bloc.dart';
+import 'package:schoolerp/src/ui/auth/login/bloc/login_bloc.dart';
+import 'package:schoolerp/src/ui/calendar/bloc/calendar_bloc.dart';
+import 'package:schoolerp/src/ui/circulardetails/bloc/circular_details_bloc.dart';
+import 'package:schoolerp/src/ui/circularlist/bloc/circular_list_bloc.dart';
+import 'package:schoolerp/src/ui/events/bloc/events_bloc.dart';
+import 'package:schoolerp/src/ui/events/bloc/events_detail_bloc.dart';
+import 'package:schoolerp/src/ui/exam/examdetails/bloc/exam_details_bloc.dart';
+import 'package:schoolerp/src/ui/exam/examlesson/bloc/exam_lesson_bloc.dart';
+import 'package:schoolerp/src/ui/exam/examlist/bloc/exam_list_bloc.dart';
+import 'package:schoolerp/src/ui/exam/examlo/bloc/exam_lo_bloc.dart';
+import 'package:schoolerp/src/ui/exam/examtab/bloc/exam_tab_bloc.dart';
+import 'package:schoolerp/src/ui/exam/instruction/bloc/instruction_bloc.dart';
+import 'package:schoolerp/src/ui/exam/revisiondetails/bloc/revision_details_bloc.dart';
+import 'package:schoolerp/src/ui/exam/syllabus/bloc/syllabus_bloc.dart';
+import 'package:schoolerp/src/ui/feedetails/bloc/fee_detail_bloc.dart';
+import 'package:schoolerp/src/ui/fees/bloc/fees_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/appointments/appointmentdetails/bloc/appointment_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/appointments/appointmentfeedback/bloc/appointment_feedback_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/appointments/appointmentlist/bloc/appointment_list_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/appointments/bookappointment/bloc/book_appointment_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/certificates/applycertificate/bloc/apply_certificate_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/certificates/certificatedetails/bloc/certificate_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/certificates/certificatelist/bloc/certificate_list_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/gatepass/addnewpass/bloc/add_new_pass_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/gatepass/pickupdetails/bloc/pickup_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/gatepass/studentpickup/bloc/student_pickup_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/infirmary/infirmarydetails/bloc/infirmary_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/infirmary/infirmarylist/bloc/infirmary_list_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/lostandfound/additem/bloc/add_lost_item_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/lostandfound/lostandfoundlist/bloc/lost_and_found_list_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/lostandfound/lostitemdetails/bloc/lost_item_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/ptm/ptmdetails/bloc/ptm_details_bloc.dart';
+import 'package:schoolerp/src/ui/helpdesk/ptm/ptmlist/bloc/ptm_list_bloc.dart';
+import 'package:schoolerp/src/ui/instalmentdetails/bloc/instalment_detail_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/editgrade/bloc/edit_grade_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/lessondetails/bloc/lesson_details_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/lolist/bloc/lo_list_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/loscreen/bloc/lo_screen_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/resourcesdetails/bloc/resource_details_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/bloc/subject_details_bloc.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/subjectlist/bloc/subject_list_bloc.dart';
+import 'package:schoolerp/src/ui/notifications/bloc/notification_list_bloc.dart';
+import 'package:schoolerp/src/ui/parentdashboard/dashboard/bloc/parent_dashboard_bloc.dart';
+import 'package:schoolerp/src/ui/profile/bloc/profile_bloc.dart';
+import 'package:schoolerp/src/ui/resetpassword/bloc/reset_password_bloc.dart';
+import 'package:schoolerp/src/ui/studentdashboard/bloc/student_dashboard_bloc.dart';
+
+import 'base/dependencyinjection/locator.dart';
+import 'base/utils/constants/navigation_route_constants.dart';
+import 'base/utils/navigation.dart';
+import 'base/utils/preference_utils.dart';
+import 'ui/academicdetails/academiclist/bloc/academic_list_bloc.dart';
+import 'ui/academicdetails/academiclo/bloc/academic_lo_bloc.dart';
+import 'ui/academicdetails/lessonlist/bloc/lesson_list_bloc.dart';
+import 'ui/academicdetails/questions/bloc/questions_list_bloc.dart';
+import 'ui/academicdetails/topic/bloc/topic_list_bloc.dart';
+import 'ui/discipline/bloc/discipline_bloc.dart';
+import 'ui/doubt_class/classdetails/bloc/class_details_bloc.dart';
+import 'ui/doubt_class/classlist/bloc/class_list_bloc.dart';
+import 'ui/events/bloc/events_lo_bloc.dart';
+import 'ui/helpdesk/helpdeskdashboard/bloc/helpdesk_bloc.dart';
+import 'ui/timetable/bloc/timetable_bloc.dart';
+import 'ui/transport/addconcern/bloc/add_concern_bloc.dart';
+import 'ui/transport/transportfeedetail/bloc/transport_fee_detail_bloc.dart';
+import 'ui/transport/transporttabs/bloc/transport_bloc.dart';
+
+GlobalKey<NavigatorState> navigatorKey = GlobalKey<NavigatorState>();
+
+// Entry function that initializes Firebase, sets up dependency injection, and runs the app.
+void mainDelegate() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await Firebase.initializeApp(); // Initialize Firebase.
+  await init(); // Placeholder for any additional initializations.
+  setupLocator(); // Set up service locator for dependency injection.
+  runApp(MyApp()); // Run the app.
+}
+
+// Root widget of the application.
+class MyApp extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    // Set preferred orientations to portrait modes only.
+    SystemChrome.setPreferredOrientations([
+      DeviceOrientation.portraitUp,
+      DeviceOrientation.portraitDown,
+    ]);
+
+    // Set the status bar color and icon brightness.
+    SystemChrome.setSystemUIOverlayStyle(SystemUiOverlayStyle(
+      statusBarColor: Colors.transparent, // Transparent status bar
+      statusBarBrightness:
+          Brightness.dark, // Dark theme for status bar contents
+      statusBarIconBrightness: Brightness.dark, // Dark icons on status bar
+    ));
+
+    // Initialize ScreenUtil
+    return ScreenUtilInit(
+      designSize: const Size(414, 736), // Design size for UI scaling
+      minTextAdapt: true, // Minimum text adaptation
+      splitScreenMode: true, // Adapt for split screen mode
+      builder: (_, child) => MultiProvider(
+        providers: allProviders, // List of all BlocProviders
+        child: MaterialApp(
+          navigatorKey: navigatorKey,
+          debugShowCheckedModeBanner: false,
+          title: 'SchoolERP',
+          theme: AppTheme.lightTheme,
+          // Custom light theme
+          initialRoute: NavigationRouteConstants.routeLaunch,
+          // Initial route
+          onGenerateRoute: locator<NavigationUtils>().generateRoute,
+          // Route generation using a locator
+          home: child,
+        ),
+      ),
+    );
+  }
+
+  List<BlocProvider> allProviders = [
+    BlocProvider<LoginBloc>(create: (BuildContext context) => LoginBloc()),
+    BlocProvider<ForgotPasswordBloc>(
+        create: (BuildContext context) => ForgotPasswordBloc()),
+    BlocProvider<ParentDashboardBloc>(
+        create: (BuildContext context) => ParentDashboardBloc()),
+    BlocProvider<StudentDashboardBloc>(
+        create: (BuildContext context) => StudentDashboardBloc()),
+    BlocProvider<AttendanceBloc>(
+        create: (BuildContext context) => AttendanceBloc()),
+    BlocProvider<FeesBloc>(create: (BuildContext context) => FeesBloc()),
+    BlocProvider<InstalmentDetailBloc>(
+        create: (BuildContext context) => InstalmentDetailBloc()),
+    BlocProvider<FeeDetailBloc>(
+        create: (BuildContext context) => FeeDetailBloc()),
+    BlocProvider<CalendarBloc>(
+        create: (BuildContext context) => CalendarBloc()),
+    BlocProvider<CircularListBloc>(
+        create: (BuildContext context) => CircularListBloc()),
+    BlocProvider<CircularDetailsBloc>(
+        create: (BuildContext context) => CircularDetailsBloc()),
+    BlocProvider<ResetPasswordBloc>(
+        create: (BuildContext context) => ResetPasswordBloc()),
+    BlocProvider<ProfileBloc>(create: (BuildContext context) => ProfileBloc()),
+    BlocProvider<LOScreenBloc>(
+        create: (BuildContext context) => LOScreenBloc()),
+    BlocProvider<LOListBloc>(create: (BuildContext context) => LOListBloc()),
+    BlocProvider<LessonDetailsBloc>(
+        create: (BuildContext context) => LessonDetailsBloc()),
+    BlocProvider<SubjectDetailsBloc>(
+        create: (BuildContext context) => SubjectDetailsBloc()),
+    BlocProvider<ResourceDetailsBloc>(
+        create: (BuildContext context) => ResourceDetailsBloc()),
+    BlocProvider<EditGradeBloc>(
+        create: (BuildContext context) => EditGradeBloc()),
+    BlocProvider<SubjectListBloc>(
+        create: (BuildContext context) => SubjectListBloc()),
+    BlocProvider<ExamDetailsBloc>(
+        create: (BuildContext context) => ExamDetailsBloc()),
+    BlocProvider<ExamLessonBloc>(
+        create: (BuildContext context) => ExamLessonBloc()),
+    BlocProvider<ExamListBloc>(
+        create: (BuildContext context) => ExamListBloc()),
+    BlocProvider<ExamLoBloc>(create: (BuildContext context) => ExamLoBloc()),
+    BlocProvider<ExamTabBloc>(create: (BuildContext context) => ExamTabBloc()),
+    BlocProvider<InstructionBloc>(
+        create: (BuildContext context) => InstructionBloc()),
+    BlocProvider<RevisionDetailsBloc>(
+        create: (BuildContext context) => RevisionDetailsBloc()),
+    BlocProvider<SyllabusBloc>(
+        create: (BuildContext context) => SyllabusBloc()),
+    BlocProvider<TimeTableBloc>(
+        create: (BuildContext context) => TimeTableBloc()),
+    BlocProvider<DisciplineBloc>(
+        create: (BuildContext context) => DisciplineBloc()),
+    BlocProvider<HelpdeskBloc>(
+        create: (BuildContext context) => HelpdeskBloc()),
+    BlocProvider<StudentPickupBloc>(
+        create: (BuildContext context) => StudentPickupBloc()),
+    BlocProvider<AddNewPassBloc>(
+        create: (BuildContext context) => AddNewPassBloc()),
+    BlocProvider<PickupDetailsBloc>(
+        create: (BuildContext context) => PickupDetailsBloc()),
+    BlocProvider<AppointmentListBloc>(
+        create: (BuildContext context) => AppointmentListBloc()),
+    BlocProvider<BookAppointmentBloc>(
+        create: (BuildContext context) => BookAppointmentBloc()),
+    BlocProvider<AppointmentDetailsBloc>(
+        create: (BuildContext context) => AppointmentDetailsBloc()),
+    BlocProvider<AppointmentFeedbackBloc>(
+        create: (BuildContext context) => AppointmentFeedbackBloc()),
+    BlocProvider<ApplyCertificateBloc>(
+        create: (BuildContext context) => ApplyCertificateBloc()),
+    BlocProvider<CertificateDetailsBloc>(
+        create: (BuildContext context) => CertificateDetailsBloc()),
+    BlocProvider<CertificateListBloc>(
+        create: (BuildContext context) => CertificateListBloc()),
+    BlocProvider<InfirmaryListBloc>(
+        create: (BuildContext context) => InfirmaryListBloc()),
+    BlocProvider<InfirmaryDetailsBloc>(
+        create: (BuildContext context) => InfirmaryDetailsBloc()),
+    BlocProvider<PTMListBloc>(create: (BuildContext context) => PTMListBloc()),
+    BlocProvider<PTMDetailsBloc>(
+        create: (BuildContext context) => PTMDetailsBloc()),
+    BlocProvider<LostAndFoundListBloc>(
+        create: (BuildContext context) => LostAndFoundListBloc()),
+    BlocProvider<AddLostItemBloc>(
+        create: (BuildContext context) => AddLostItemBloc()),
+    BlocProvider<LostItemDetailsBloc>(
+        create: (BuildContext context) => LostItemDetailsBloc()),
+    BlocProvider<ActivityAnalysisBloc>(
+        create: (BuildContext context) => ActivityAnalysisBloc()),
+    BlocProvider<ActivityCurriculumBloc>(
+        create: (BuildContext context) => ActivityCurriculumBloc()),
+    BlocProvider<ActivityDetailsBloc>(
+        create: (BuildContext context) => ActivityDetailsBloc()),
+    BlocProvider<ActivityListBloc>(
+        create: (BuildContext context) => ActivityListBloc()),
+    BlocProvider<ActivityLOBloc>(
+        create: (BuildContext context) => ActivityLOBloc()),
+    BlocProvider<ActivityResourcesBloc>(
+        create: (BuildContext context) => ActivityResourcesBloc()),
+    BlocProvider<ActivitySelectionBloc>(
+        create: (BuildContext context) => ActivitySelectionBloc()),
+    BlocProvider<ActivityGradeCriteriaBloc>(
+        create: (BuildContext context) => ActivityGradeCriteriaBloc()),
+    BlocProvider<ActivityPendingSkillsBloc>(
+        create: (BuildContext context) => ActivityPendingSkillsBloc()),
+    BlocProvider<NotificationListBloc>(
+        create: (BuildContext context) => NotificationListBloc()),
+    BlocProvider<EventsBloc>(create: (BuildContext context) => EventsBloc()),
+    BlocProvider<EventsDetailBloc>(
+        create: (BuildContext context) => EventsDetailBloc()),
+    BlocProvider<EventsLOBloc>(
+        create: (BuildContext context) => EventsLOBloc()),
+    BlocProvider<TransportBloc>(
+        create: (BuildContext context) => TransportBloc()),
+    BlocProvider<AddConcernBloc>(
+        create: (BuildContext context) => AddConcernBloc()),
+    BlocProvider<TransportFeeDetailBloc>(
+        create: (BuildContext context) => TransportFeeDetailBloc()),
+    BlocProvider<AcademicListBloc>(
+        create: (BuildContext context) => AcademicListBloc()),
+    BlocProvider<LessonListBloc>(
+        create: (BuildContext context) => LessonListBloc()),
+    BlocProvider<AcademicLOBloc>(
+        create: (BuildContext context) => AcademicLOBloc()),
+    BlocProvider<TopicListBloc>(
+        create: (BuildContext context) => TopicListBloc()),
+    BlocProvider<QuestionsListBloc>(
+        create: (BuildContext context) => QuestionsListBloc()),
+    BlocProvider<ClassListBloc>(
+        create: (BuildContext context) => ClassListBloc()),
+    BlocProvider<ClassDetailsBloc>(
+        create: (BuildContext context) => ClassDetailsBloc()),
+  ];
+}

lib/src/network/error_model.dart

+import 'package:schoolerp/src/base/utils/constants/api_params.dart';
+
+/// Model class to handle API error responses.
+class ErrorModel {
+  // Optional fields to store error message and status code
+  String? error;
+  int? status;
+
+  /// Constructor for creating an error model with optional error message and status code.
+  ErrorModel({this.error, this.status});
+
+  /// Factory constructor to create an `ErrorModel` instance from JSON.
+  ErrorModel.fromJson(Map<String, dynamic> json) {
+    error = json[
+        ApiParams.paramError]; // Retrieve error message from JSON using key
+    status =
+        json[ApiParams.paramStatus]; // Retrieve status code from JSON using key
+  }
+
+  /// Method to convert `ErrorModel` instance to JSON format.
+  Map<String, dynamic> toJson() {
+    final data = <String, dynamic>{}; // Initialize an empty map
+    data[ApiParams.paramError] = error; // Insert error message into map
+    data[ApiParams.paramStatus] = status; // Insert status code into map
+    return data; // Return the map containing the model data
+  }
+}

lib/src/network/http_transport.dart

+import 'dart:async';
+import 'dart:developer';
+
+import 'package:connectivity_plus/connectivity_plus.dart';
+import 'package:dio/dio.dart' as dioApi;
+import 'package:flutter/foundation.dart';
+import 'package:flutter/material.dart';
+import 'package:schoolerp/src/base/utils/constants/app_constants.dart';
+import 'package:schoolerp/src/base/utils/constants/navigation_route_constants.dart';
+import 'package:schoolerp/src/network/req_refresh_token.dart';
+import 'package:schoolerp/src/network/res_refresh_token.dart';
+
+import '../base/data/student_list_data.dart';
+import '../base/environment/app_config.dart';
+import '../base/utils/constants.dart';
+import '../base/utils/constants/api_constants.dart';
+import '../base/utils/constants/api_params.dart';
+import '../base/utils/constants/preference_key_constants.dart';
+import '../base/utils/preference_utils.dart';
+import '../main.dart';
+import 'i_transport.dart';
+import 'network_command.dart';
+import 'res_base_model.dart';
+
+class HTTPTransport extends ITransport {
+  // Create Dio instance with interceptors
+  static final _createDio = createDio();
+  static var _dio = addInterceptors(_createDio);
+
+  // HTTP status codes
+  static const httpStatusCodeSuccess200 = 200;
+  static const httpStatusCodeSuccess201 = 201;
+  static const httpStatusCodeSuccess202 = 202;
+  static const httpStatusCodeAlreadyExist409 = 409;
+  static const httpStatusCodePreConditionRequired = 428;
+
+  // Dio BaseOptions configuration
+  static dioApi.BaseOptions options = dioApi.BaseOptions(
+    baseUrl: apiBaseUrl,
+    responseType: dioApi.ResponseType.json,
+    contentType: ApiConstants.applicationJsonType,
+    connectTimeout: Duration(minutes: 120 * 1000),
+    receiveTimeout: Duration(minutes: 120 * 1000),
+    headers: {
+      ApiConstants.authorization:
+          'Bearer ${getString(PreferenceKeyConstants.prefKeyToken)}',
+      ApiConstants.headerVersion: ApiConstants.version,
+      if (Constants.isParentApp &&
+          StudentListData().getSelectedStudent().schoolId != null)
+        ApiConstants.schoolId:
+            StudentListData().getSelectedStudent().schoolId.toString()
+      else
+        ApiConstants.schoolId: getString(PreferenceKeyConstants.prefSchoolId)
+    },
+  );
+
+  // Create Dio instance
+  static dioApi.Dio createDio() {
+    return dioApi.Dio(options);
+  }
+
+  // Add interceptors to Dio instance
+  static dioApi.Dio addInterceptors(dioApi.Dio dio) {
+    return dio
+      ..interceptors.add(
+        dioApi.InterceptorsWrapper(
+          onRequest: (options, handler) {
+            // Add headers
+            options.headers.addAll({
+              ApiConstants.authorization:
+                  'Bearer ${getString(PreferenceKeyConstants.prefKeyToken)}',
+              ApiConstants.headerVersion: ApiConstants.version,
+              if (Constants.isParentApp &&
+                  StudentListData().getSelectedStudent().schoolId != null)
+                ApiConstants.schoolId:
+                    StudentListData().getSelectedStudent().schoolId.toString()
+              else
+                ApiConstants.schoolId:
+                    getString(PreferenceKeyConstants.prefSchoolId),
+            });
+
+            // Log request details in debug mode
+            if (kDebugMode) {
+              log("${options.headers.toString()}", name: "Headers");
+              log("${options.baseUrl.toString() + options.path}",
+                  name: "BaseURL");
+              log("${options.queryParameters.toString()}", name: "QueryParam");
+              log("${options.data.toString()}", name: "Data");
+            }
+            return handler.next(options);
+          },
+          onResponse: (e, handler) {
+            // Log response details in debug mode
+            if (kDebugMode) {
+              log("${e.statusCode.toString()}", name: "Code");
+              log("${e.toString()}", name: "Response");
+            }
+            return handler.next(e);
+          },
+          onError: (e, handler) {
+            // Log error details in debug mode
+            if (kDebugMode) {
+              log("${e.error.toString()}", name: "Error");
+              log("${e.response.toString()}", name: "Error Data");
+            }
+            return handler.next(e);
+          },
+        ),
+      );
+  }
+
+  // Helper function to check internet connectivity
+  Future<bool> checkInternet() async {
+    var connectivityResult = await (Connectivity().checkConnectivity());
+    return connectivityResult == ConnectivityResult.mobile ||
+        connectivityResult == ConnectivityResult.wifi;
+  }
+
+  // GET request
+  Future<dioApi.Response> get(String endUrl,
+      {Map<String, dynamic>? params,
+      dioApi.Options? options,
+      bool isCompanyCheck = false}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+
+      return await _dio.get(
+        endUrl,
+        queryParameters: params,
+        options: options,
+      );
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // POST request
+  Future<dioApi.Response> post(String endUrl,
+      {Map<String, dynamic>? data,
+      Map<String, dynamic>? params,
+      dioApi.Options? options,
+      bool isCompanyCheck = false}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+
+      return await _dio.post(
+        endUrl,
+        data: data,
+        queryParameters: params,
+      );
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // PUT request
+  Future<dioApi.Response> put(String endUrl,
+      {Map<String, dynamic>? data,
+      Map<String, dynamic>? params,
+      dioApi.Options? options,
+      bool isCompanyCheck = false}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+
+      return params != null || data != null
+          ? await _dio.put(endUrl, data: data, queryParameters: params)
+          : await _dio.put(endUrl);
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // POST request for lists
+  Future<dioApi.Response> postList(String endUrl,
+      {dynamic data,
+      Map<String, dynamic>? params,
+      dioApi.Options? options,
+      bool isCompanyCheck = false}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+
+      return await _dio.post(
+        endUrl,
+        data: data,
+        queryParameters: params,
+        options: options,
+      );
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // DELETE request
+  Future<dioApi.Response> delete(String endUrl,
+      {Map<String, dynamic>? data,
+      Map<String, dynamic>? params,
+      dioApi.Options? options,
+      bool isCompanyCheck = false}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+
+      return await _dio.delete(
+        endUrl,
+        data: data,
+        queryParameters: params,
+        options: options,
+      );
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // Multipart POST request
+  Future<dioApi.Response> multipartPost(String endUrl,
+      {dioApi.FormData? data,
+      bool isCompanyCheck = false,
+      dioApi.Options? options}) async {
+    try {
+      if (!(await checkInternet())) {
+        return Future.error(
+          ResBaseModel(
+            message: ApiConstants.noInternet,
+          ),
+        );
+      }
+      return await _dio.post(
+        endUrl,
+        data: data,
+        options: options,
+      );
+    } on dioApi.DioException catch (e) {
+      return handleError(e);
+    }
+  }
+
+  // Handle Dio errors
+  Future<dioApi.Response> handleError(dioApi.DioException e) {
+    if (e.type == dioApi.DioExceptionType.connectionTimeout) {
+      return Future.error(ResBaseModel(message: ApiConstants.poorInternet));
+    } else {
+      return Future.value(e.response);
+    }
+  }
+
+  @override
+  Future<T> execute<T, C extends NetworkCommand>(C command) {
+    return _request(command).then((response) async {
+      logResponse(response);
+
+      if (response.headers.value(AppConstants.razorKey) != null) {
+        StudentListData studentData = StudentListData();
+        studentData.setRazorKey(response.headers.value(AppConstants.razorKey));
+      }
+
+      if (response.statusCode != 401) {
+        return response.data;
+      } else {
+        await _callRefreshTokenAPI();
+        return _request(command).then((value) => value.data).catchError((e) {
+          return (e as ResBaseModel).toJson();
+        });
+      }
+    }).catchError((e) {
+      log('###### NETWORK ERROR: $e');
+      return (e as ResBaseModel).toJson();
+    }).then((value) => value);
+  }
+
+  // Log response details
+  void logResponse(dioApi.Response response) {
+    log("### RESPONSE: ${response.statusCode} >>> ${response.data.toString()}");
+    log("### Headers: ${response.headers.value('razor-key')}");
+  }
+
+  // Make network request based on command method
+  Future<dioApi.Response> _request(NetworkCommand command) async {
+    log("##### METHOD: ${command.method}");
+    log("####### BODY: ${command.body}");
+
+    switch (command.method) {
+      case APIMethod.get:
+        return await get(command.path!, params: command.body);
+
+      case APIMethod.post:
+        return await post(command.path!, data: command.body);
+
+      case APIMethod.put:
+        return await put(command.path!, data: command.body);
+
+      case APIMethod.delete:
+        return await delete(command.path!, data: command.body);
+
+      case APIMethod.multipart:
+        return await multipartPost(command.path!, data: command.body);
+
+      default:
+        // this will never call as API method are always defined
+        return Future.value();
+    }
+  }
+
+  // Check if status code indicates success
+  static bool isSuccess(int statusCode) {
+    return (statusCode == httpStatusCodeSuccess200 ||
+            statusCode == httpStatusCodeSuccess201 ||
+            statusCode == httpStatusCodeSuccess202)
+        ? true
+        : false;
+  }
+
+  // Call refresh token API
+  Future<void> _callRefreshTokenAPI() async {
+    var command = ReqRefreshToken(
+        refreshToken: getString(PreferenceKeyConstants.prefKeyRefreshToken));
+    dioApi.Response provider =
+        await post(command.path!, data: command.toJson());
+    if (HTTPTransport.isSuccess(provider.data[ApiParams.paramCode] ?? 500)) {
+      ResRefreshToken data = ResRefreshToken.fromJson(provider.data);
+      setString(PreferenceKeyConstants.prefKeyToken, data.data!.token!);
+      setString(
+          PreferenceKeyConstants.prefKeyRefreshToken, data.data!.refreshToken!);
+      _dio = addInterceptors(_createDio);
+    } else {
+      // logout user here
+      navigatorKey.currentState?.pushNamedAndRemoveUntil(
+        NavigationRouteConstants.routeSignIn,
+        (Route<dynamic> route) => false,
+      );
+    }
+  }
+}

lib/src/network/i_transport.dart

+import 'network_command.dart';
+
+/// Abstract class [ITransport] defines the interface for transport layers used in network communication.
+///
+/// This interface ensures that all transport classes that implement it must provide an implementation
+/// for the [execute] method. This method should take a command of type [NetworkCommand] and return a
+/// future containing the result of the command's execution.
+abstract class ITransport {
+  /// Executes a [NetworkCommand] and returns a [Future] containing the result.
+  ///
+  /// The method uses generic types [T] for the expected result type and [C] for the specific
+  /// type of [NetworkCommand] to be executed. This allows for strong type checking and flexibility
+  /// in handling different types of commands.
+  Future<T> execute<T, C extends NetworkCommand>(C command);
+}

lib/src/network/network_command.dart

+/// Abstract class [NetworkCommand] to define the structure and functionality of network commands.
+abstract class NetworkCommand<T> {
+  // API endpoint for the network command
+  String? path;
+
+  // HTTP method to be used for the network request
+  APIMethod? method;
+
+  // Data body to be sent with the request; can be a map, list, or any other dynamic object
+  dynamic body;
+
+  /// Abstract method [parse] to convert a JSON response into a specific type [T], based on the HTTP status.
+  ///
+  /// Parameters:
+  /// - [httpsStatus] HTTP status code returned by the server.
+  /// - [json] JSON data received from the server as a map.
+  T parse(int httpsStatus, Map<String, dynamic> json);
+}
+
+/// Enum [APIMethod] to define supported HTTP methods.
+enum APIMethod {
+  get,
+  post,
+  put,
+  patch,
+  delete,
+  multipart,
+}

lib/src/network/req_refresh_token.dart

+import 'network_command.dart';
+
+/// A network command to request a new refresh token.
+///
+/// This class extends [NetworkCommand] and is specifically used for making network requests
+/// to regenerate a token when the current token has expired.
+class ReqRefreshToken extends NetworkCommand {
+  /// Refresh token string that will be included in the request.
+  String? refreshToken;
+
+  /// Constructor for creating a new [ReqRefreshToken] instance.
+  ReqRefreshToken({this.refreshToken});
+
+  /// Factory constructor to create a [ReqRefreshToken] from a JSON map.
+  ReqRefreshToken.fromJson(Map<String, dynamic> json) {
+    refreshToken = json['refresh_token'];
+  }
+
+  /// Method to convert [ReqRefreshToken] instance into a JSON map.
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['refresh_token'] = this.refreshToken;
+    return data;
+  }
+
+  /// Overridden [path] getter to provide the API endpoint path for token regeneration.
+  @override
+  String get path => "api/authentication-service/user/regenerate-token";
+
+  /// Overridden [parse] method to parse the JSON response into an instance of [ReqRefreshToken].
+  ///
+  /// This implementation simply creates a new instance using the JSON data provided in the request,
+  /// which might not be practical for real use-cases where the response needs to be parsed from the server's response.
+  @override
+  ReqRefreshToken parse(int httpsStatus, Map<String, dynamic> json) {
+    return ReqRefreshToken.fromJson(json);
+  }
+}

lib/src/network/res_base_model.dart

+import '../base/utils/constants/api_params.dart';
+import 'network_command.dart';
+
+/// Class representing a base model for network responses.
+///
+/// This class extends [NetworkCommand] and encapsulates common attributes found in most API responses,
+/// such as status code and message. It also supports nested data parsing through [BaseModelData].
+class ResBaseModel extends NetworkCommand {
+  int? statusCode;
+  String? message;
+  BaseModelData? data;
+
+  /// Constructor for creating a new [ResBaseModel] instance.
+  ResBaseModel({this.statusCode, this.message, this.data});
+
+  /// Factory constructor to create a [ResBaseModel] from a JSON map.
+  ResBaseModel.fromJson(Map<String, dynamic> json) {
+    statusCode = json[ApiParams.paramCode];
+    message = json[ApiParams.paramMessage];
+    data = json[ApiParams.paramData] != null
+        ? BaseModelData.fromJson(json[ApiParams.paramData])
+        : null;
+  }
+
+  /// Method to convert [ResBaseModel] instance into a JSON map.
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data[ApiParams.paramCode] = this.statusCode;
+    data[ApiParams.paramMessage] = this.message;
+    if (this.data != null) {
+      data[ApiParams.paramData] = this.data!.toJson();
+    }
+    return data;
+  }
+
+  /// Overridden [parse] method to parse the JSON response into an instance of [ResBaseModel].
+  ///
+  /// Assumes [json] is the server response and uses it to parse the data accordingly.
+  @override
+  parse(int httpsStatus, Map<String, dynamic> json) {
+    return ResBaseModel.fromJson(json);
+  }
+}
+
+/// Class representing additional data typically found in API responses.
+class BaseModelData {
+  int? remainingCount;
+
+  /// Constructor for creating a new [BaseModelData] instance.
+  BaseModelData({this.remainingCount});
+
+  /// Factory constructor to create a [BaseModelData] from a JSON map.
+  BaseModelData.fromJson(Map<String, dynamic> json) {
+    remainingCount = json['remaining_count'];
+  }
+
+  /// Method to convert [BaseModelData] instance into a JSON map.
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['remaining_count'] = this.remainingCount;
+    return data;
+  }
+}

lib/src/network/res_refresh_token.dart

+class ResRefreshToken {
+  int? statusCode;
+  String? message;
+  Data? data;
+
+  // Constructor with named parameters
+  ResRefreshToken({this.statusCode, this.message, this.data});
+
+  // Named constructor to create an instance from a JSON object
+  ResRefreshToken.fromJson(Map<String, dynamic> json) {
+    statusCode = json['statusCode'];
+    message = json['message'];
+    data = json['data'] != null ? Data.fromJson(json['data']) : null;
+  }
+
+  // Method to convert the instance to a JSON object
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> jsonData = {};
+    jsonData['statusCode'] = statusCode;
+    jsonData['message'] = message;
+    if (data != null) {
+      jsonData['data'] = data!.toJson();
+    }
+    return jsonData;
+  }
+}
+
+class Data {
+  String? token;
+  String? refreshToken;
+
+  // Constructor with named parameters
+  Data({this.token, this.refreshToken});
+
+  // Named constructor to create an instance from a JSON object
+  Data.fromJson(Map<String, dynamic> json) {
+    token = json['token'];
+    refreshToken = json['refreshToken'];
+  }
+
+  // Method to convert the instance to a JSON object
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> jsonData = {};
+    jsonData['token'] = token;
+    jsonData['refreshToken'] = refreshToken;
+    return jsonData;
+  }
+}
+
+// Utility function to create ResRefreshToken from JSON
+ResRefreshToken parseResRefreshToken(Map<String, dynamic> json) {
+  return ResRefreshToken.fromJson(json);
+}
+
+// Utility function to create Data from JSON
+Data parseData(Map<String, dynamic> json) {
+  return Data.fromJson(json);
+}

lib/src/ui/subjectdetails/bloc/subject_details_bloc.dart

+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:get_it/get_it.dart';
+import 'package:schoolerp/src/base/utils/constants/api_params.dart';
+import 'package:schoolerp/src/base/utils/reusablemethods/reusable_methods.dart';
+import 'package:schoolerp/src/network/http_transport.dart';
+import 'package:schoolerp/src/network/res_base_model.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/bloc/subject_details_state.dart';
+
+import '../network/i_subject_details_network.dart';
+import '../network/res_subject_details.dart';
+import '../network/res_submit_lo_grade.dart';
+import 'subject_details_event.dart';
+
+// Bloc for managing subject details state
+class SubjectDetailsBloc
+    extends Bloc<SubjectDetailsEvent, SubjectDetailsState> {
+  final ISubjectDetailsNetwork _network = GetIt.I<ISubjectDetailsNetwork>();
+
+  SubjectDetailsBloc() : super(const SubjectDetailsState()) {
+    on<SubjectDetailsEvent>((event, emit) async {
+      if (event is SubjectDetailsSubmitted) {
+        emit(SubjectDetailsLoading());
+      } else if (event is SubjectDetailsCallAPIEvent) {
+        await _handleSubjectDetailsCallAPIEvent(event, emit);
+      } else if (event is GradeSubmitEvent) {
+        await _handleGradeSubmitEvent(event, emit);
+      }
+    });
+  }
+
+  // Handles the API call for subject details
+  Future<void> _handleSubjectDetailsCallAPIEvent(
+      SubjectDetailsCallAPIEvent event,
+      Emitter<SubjectDetailsState> emit) async {
+    try {
+      final provider = await _network.provider(event.reqSubjectDetails!);
+      printMyLog("DATA::provider ::  $provider");
+      if (HTTPTransport.isSuccess(provider[ApiParams.paramCode] ?? 500)) {
+        emit(SubjectDetailsSuccess(
+            provider: ResSubjectDetails.fromJson(provider)));
+      } else {
+        emit(SubjectDetailsFailure(provider: ResBaseModel.fromJson(provider)));
+      }
+    } catch (e) {
+      printMyLog("DATA:: $e");
+      emit(
+        SubjectDetailsFailure(
+          provider: ResBaseModel(
+            message: e.toString(),
+          ),
+        ),
+      );
+    }
+  }
+
+  // Handles the grade submission event
+  Future<void> _handleGradeSubmitEvent(
+      GradeSubmitEvent event, Emitter<SubjectDetailsState> emit) async {
+    try {
+      final provider =
+          await _network.providerSubmitGrade(event.reqSubmitLoGrade!);
+      printMyLog("DATA::provider ::  $provider");
+      if (HTTPTransport.isSuccess(provider[ApiParams.paramCode] ?? 500)) {
+        emit(GradeSubmitSuccess(provider: ResSubmitLoGrade.fromJson(provider)));
+      } else {
+        emit(SubjectDetailsFailure(provider: ResBaseModel.fromJson(provider)));
+      }
+    } catch (e) {
+      printMyLog("DATA:: $e");
+      emit(
+        SubjectDetailsFailure(
+          provider: ResBaseModel(
+            message: e.toString(),
+          ),
+        ),
+      );
+    }
+  }
+}

lib/src/ui/subjectdetails/bloc/subject_details_event.dart

+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/network/req_submit_lo_grade.dart';
+
+import '../network/req_subject_details.dart';
+
+// Abstract base class for all SubjectDetails events
+abstract class SubjectDetailsEvent {}
+
+// Event indicating that subject details have been submitted
+class SubjectDetailsSubmitted extends SubjectDetailsEvent {
+  SubjectDetailsSubmitted();
+}
+
+// Event to trigger an API call for subject details
+class SubjectDetailsCallAPIEvent extends SubjectDetailsEvent {
+  final ReqSubjectDetails? reqSubjectDetails;
+
+  SubjectDetailsCallAPIEvent({this.reqSubjectDetails});
+}
+
+// Event to trigger an API call for submitting grades
+class GradeSubmitEvent extends SubjectDetailsEvent {
+  final ReqSubmitLoGrade? reqSubmitLoGrade;
+
+  GradeSubmitEvent({this.reqSubmitLoGrade});
+}

lib/src/ui/subjectdetails/bloc/subject_details_state.dart

+import 'package:equatable/equatable.dart';
+import 'package:schoolerp/src/network/res_base_model.dart';
+
+import '../network/res_subject_details.dart';
+import '../network/res_submit_lo_grade.dart';
+
+// Base class for all states related to Subject Details
+class SubjectDetailsState extends Equatable {
+  const SubjectDetailsState();
+
+  @override
+  List<Object?> get props => [];
+}
+
+// Initial state for Subject Details
+class SubjectDetailsInitialize extends SubjectDetailsState {}
+
+// Loading state for Subject Details
+class SubjectDetailsLoading extends SubjectDetailsState {}
+
+// Failure state for Subject Details with error information
+class SubjectDetailsFailure extends SubjectDetailsState {
+  final ResBaseModel? provider;
+
+  const SubjectDetailsFailure({this.provider});
+
+  @override
+  List<Object?> get props => [provider];
+}
+
+// Success state for Subject Details with response data
+class SubjectDetailsSuccess extends SubjectDetailsState {
+  final ResSubjectDetails? provider;
+
+  const SubjectDetailsSuccess({this.provider});
+
+  // Creates a copy of the current state with new data if provided
+  SubjectDetailsSuccess copyWith({ResSubjectDetails? provider}) {
+    return SubjectDetailsSuccess(provider: provider ?? this.provider);
+  }
+
+  @override
+  List<Object?> get props => [provider];
+
+  @override
+  String toString() => 'SubjectDetailsSuccess { provider: $provider }';
+}
+
+// Success state for grade submission with response data
+class GradeSubmitSuccess extends SubjectDetailsState {
+  final ResSubmitLoGrade? provider;
+
+  const GradeSubmitSuccess({this.provider});
+
+  // Creates a copy of the current state with new data if provided
+  GradeSubmitSuccess copyWith({ResSubmitLoGrade? provider}) {
+    return GradeSubmitSuccess(provider: provider ?? this.provider);
+  }
+
+  @override
+  List<Object?> get props => [provider];
+
+  @override
+  String toString() => 'GradeSubmitSuccess { provider: $provider }';
+}

lib/src/ui/subjectdetails/network/i_subject_details_network.dart

+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/network/req_subject_details.dart';
+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/network/req_submit_lo_grade.dart';
+
+// Interface for network operations related to subject details
+abstract class ISubjectDetailsNetwork {
+  // Method to fetch subject details from the server
+  Future<Map<String, dynamic>> provider(ReqSubjectDetails reqSubjectDetails);
+
+  // Method to submit grade to the server
+  Future<Map<String, dynamic>> providerSubmitGrade(
+      ReqSubmitLoGrade reqSubmitLoGrade);
+}

lib/src/ui/subjectdetails/network/req_subject_details.dart

+import '../../../../network/network_command.dart';
+
+class ReqSubjectDetails extends NetworkCommand {
+  String? subjectId;
+  String? mediumId;
+  String? standardId;
+  String? loType;
+  String? publishDate;
+  String? page;
+  String? studentId;
+
+  ReqSubjectDetails({
+    this.subjectId,
+    this.mediumId,
+    this.standardId,
+    this.loType,
+    this.publishDate,
+    this.page,
+    this.studentId,
+  });
+
+  ReqSubjectDetails.fromJson(Map<String, dynamic> json) {
+    subjectId = json['subject_id'];
+    mediumId = json['medium_id'];
+    standardId = json['standard_id'];
+    loType = json['loType'];
+    publishDate = json['publish_date'];
+    page = json['page'];
+    studentId = json['student_id'];
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['subject_id'] = subjectId;
+    data['medium_id'] = mediumId;
+    data['standard_id'] = standardId;
+    data['loType'] = loType;
+    data['page'] = page;
+    if (publishDate != null) {
+      data['publish_date'] = publishDate;
+    }
+    data['student_id'] = studentId;
+    return data;
+  }
+
+  @override
+  dynamic get body => toJson();
+
+  @override
+  get method => APIMethod.get;
+
+  @override
+  // Deserialize JSON response into a ReqSubjectDetails object
+  dynamic parse(int httpsStatus, Map<String, dynamic> json) =>
+      ReqSubjectDetails.fromJson(json);
+
+  @override
+  String get path =>
+      'api/subject-planning-service/StudentParent/list/LoDetails';
+}

lib/src/ui/subjectdetails/network/req_submit_lo_grade.dart

+import '../../../../network/network_command.dart';
+
+class ReqSubmitLoGrade extends NetworkCommand {
+  int? loId;
+  int? loGrade;
+  String? loRemark;
+
+  ReqSubmitLoGrade({this.loId, this.loGrade, this.loRemark});
+
+  ReqSubmitLoGrade.fromJson(Map<String, dynamic> json) {
+    loId = json['lo_id'];
+    loGrade = json['lo_grade'];
+    loRemark = json['lo_remark'];
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['lo_id'] = loId;
+    data['lo_grade'] = loGrade;
+    data['lo_remark'] = loRemark;
+    return data;
+  }
+
+  @override
+  dynamic get body => toJson();
+
+  @override
+  get method => APIMethod.put;
+
+  @override
+  // Deserialize JSON response into a ReqSubmitLoGrade object
+  dynamic parse(int httpsStatus, Map<String, dynamic> json) =>
+      ReqSubmitLoGrade.fromJson(json);
+
+  @override
+  String get path => 'api/subject-planning-service/StudentParent/submitLo';
+}

lib/src/ui/subjectdetails/network/res_subject_details.dart

+import '../../../../base/utils/date_utils.dart';
+
+class ResSubjectDetails {
+  int? statusCode;
+  String? message;
+  Data? data;
+
+  ResSubjectDetails({this.statusCode, this.message, this.data});
+
+  ResSubjectDetails.fromJson(Map<String, dynamic> json) {
+    statusCode = json['statusCode'];
+    message = json['message'];
+    data = json['data'] != null ? Data.fromJson(json['data']) : null;
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['statusCode'] = statusCode;
+    data['message'] = message;
+    if (this.data != null) {
+      data['data'] = this.data!.toJson();
+    }
+    return data;
+  }
+}
+
+class Data {
+  List<SubjectListLOResult>? result;
+  int? totalCount;
+  int? page;
+  int? limit;
+
+  Data({this.result, this.totalCount, this.page, this.limit});
+
+  Data.fromJson(Map<String, dynamic> json) {
+    if (json['result'] != null) {
+      result = <SubjectListLOResult>[];
+      json['result'].forEach((v) {
+        result!.add(SubjectListLOResult.fromJson(v));
+      });
+    }
+    totalCount = json['totalCount'];
+    page = json['page'];
+    limit = json['limit'];
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    if (result != null) {
+      data['result'] = result!.map((v) => v.toJson()).toList();
+    }
+    data['totalCount'] = totalCount;
+    data['page'] = page;
+    data['limit'] = limit;
+    return data;
+  }
+}
+
+class SubjectListLOResult {
+  DateTime? publishDate;
+  List<Lesson>? lessonData;
+
+  SubjectListLOResult({this.publishDate, this.lessonData});
+
+  SubjectListLOResult.fromJson(Map<String, dynamic> json) {
+    publishDate = json['publish_date'] != null
+        ? stringToDate(json['publish_date'],
+            dateFormat: DateConstants.apiDateFormat)
+        : null;
+    if (json['lesson_data'] != null) {
+      lessonData = <Lesson>[];
+      json['lesson_data'].forEach((v) {
+        lessonData!.add(Lesson.fromJson(v));
+      });
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['publish_date'] = publishDate?.toIso8601String();
+    if (lessonData != null) {
+      data['lesson_data'] = lessonData!.map((v) => v.toJson()).toList();
+    }
+    return data;
+  }
+}
+
+class Lesson {
+  List<LoDataLesson>? loData;
+  int? lessonId;
+  String? lessonName;
+  DateTime? publishDate;
+
+  Lesson({this.loData, this.lessonId, this.lessonName, this.publishDate});
+
+  Lesson.fromJson(Map<String, dynamic> json) {
+    if (json['lo_data'] != null) {
+      loData = <LoDataLesson>[];
+      json['lo_data'].forEach((v) {
+        loData!.add(LoDataLesson.fromJson(v));
+      });
+    }
+    lessonId = json['lesson_id'];
+    lessonName = json['lesson_name'];
+    publishDate = json['publish_date'] != null
+        ? stringToDate(json['publish_date'],
+            dateFormat: DateConstants.apiDateFormat)
+        : null;
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    if (loData != null) {
+      data['lo_data'] = loData!.map((v) => v.toJson()).toList();
+    }
+    data['lesson_id'] = lessonId;
+    data['lesson_name'] = lessonName;
+    data['publish_date'] = publishDate?.toIso8601String();
+    return data;
+  }
+}
+
+class LoDataLesson {
+  int? id;
+  int? topicId;
+  bool? isActive;
+  int? lessonId;
+  String? loDetail;
+  String? loStatus;
+  int? mediumId;
+  int? schoolId;
+  String? createdAt;
+  int? createdBy;
+  String? deletedAt;
+  int? subjectId;
+  String? topicName;
+  String? updatedAt;
+  int? updatedBy;
+  String? instruction;
+  int? loLevelId;
+  int? standardId;
+  String? publishDate;
+  int? subTopicId;
+  String? loDescription;
+  String? subTopicName;
+  String? subjectName;
+  String? loLevelName;
+  int? loLevelSequence;
+  List<GradeList>? gradeList;
+  String? gradeName;
+  GradeList? selectedGrade;
+
+  LoDataLesson({
+    this.id,
+    this.topicId,
+    this.isActive,
+    this.lessonId,
+    this.loDetail,
+    this.loStatus,
+    this.mediumId,
+    this.schoolId,
+    this.createdAt,
+    this.createdBy,
+    this.deletedAt,
+    this.subjectId,
+    this.topicName,
+    this.updatedAt,
+    this.updatedBy,
+    this.instruction,
+    this.loLevelId,
+    this.standardId,
+    this.publishDate,
+    this.subTopicId,
+    this.loDescription,
+    this.subTopicName,
+    this.subjectName,
+    this.loLevelName,
+    this.loLevelSequence,
+    this.gradeList,
+    this.gradeName,
+  });
+
+  LoDataLesson.fromJson(Map<String, dynamic> json) {
+    id = json['id'];
+    topicId = json['topic_id'];
+    isActive = json['is_active'];
+    lessonId = json['lesson_id'];
+    loDetail = json['lo_detail'];
+    loStatus = json['lo_status'];
+    mediumId = json['medium_id'];
+    schoolId = json['school_id'];
+    createdAt = json['created_at'];
+    createdBy = json['created_by'];
+    deletedAt = json['deleted_at'];
+    subjectId = json['subject_id'];
+    topicName = json['topic_name'];
+    updatedAt = json['updated_at'];
+    updatedBy = json['updated_by'];
+    instruction = json['instruction'];
+    loLevelId = json['lo_level_id'];
+    standardId = json['standard_id'];
+    publishDate = json['publish_date'];
+    subTopicId = json['sub_topic_id'];
+    loDescription = json['lo_description'];
+    subTopicName = json['sub_topic_name'];
+    subjectName = json['subject_name'];
+    loLevelName = json['lo_level_name'];
+    loLevelSequence = json['lo_level_sequence'];
+    gradeName = json['grade_name'];
+    if (json['grade_list'] != null) {
+      gradeList = <GradeList>[];
+      json['grade_list'].forEach((v) {
+        gradeList!.add(GradeList.fromJson(v));
+      });
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['id'] = id;
+    data['topic_id'] = topicId;
+    data['is_active'] = isActive;
+    data['lesson_id'] = lessonId;
+    data['lo_detail'] = loDetail;
+    data['lo_status'] = loStatus;
+    data['medium_id'] = mediumId;
+    data['school_id'] = schoolId;
+    data['created_at'] = createdAt;
+    data['created_by'] = createdBy;
+    data['deleted_at'] = deletedAt;
+    data['subject_id'] = subjectId;
+    data['topic_name'] = topicName;
+    data['updated_at'] = updatedAt;
+    data['updated_by'] = updatedBy;
+    data['instruction'] = instruction;
+    data['lo_level_id'] = loLevelId;
+    data['standard_id'] = standardId;
+    data['publish_date'] = publishDate;
+    data['sub_topic_id'] = subTopicId;
+    data['lo_description'] = loDescription;
+    data['sub_topic_name'] = subTopicName;
+    data['subject_name'] = subjectName;
+    data['lo_level_name'] = loLevelName;
+    data['lo_level_sequence'] = loLevelSequence;
+    data['grade_name'] = gradeName;
+    if (gradeList != null) {
+      data['grade_list'] = gradeList!.map((v) => v.toJson()).toList();
+    }
+    return data;
+  }
+}
+
+class GradeList {
+  int? id;
+  int? schoolId;
+  int? academicYearId;
+  bool? isActive;
+  String? deletedAt;
+  int? createdBy;
+  int? updatedBy;
+  String? createdAt;
+  String? updatedAt;
+  String? gradeName;
+  int? preference;
+
+  GradeList({
+    this.id,
+    this.schoolId,
+    this.academicYearId,
+    this.isActive,
+    this.deletedAt,
+    this.createdBy,
+    this.updatedBy,
+    this.createdAt,
+    this.updatedAt,
+    this.gradeName,
+    this.preference,
+  });
+
+  GradeList.fromJson(Map<String, dynamic> json) {
+    id = json['id'];
+    schoolId = json['school_id'];
+    academicYearId = json['academic_year_id'];
+    isActive = json['is_active'];
+    deletedAt = json['deleted_at'];
+    createdBy = json['created_by'];
+    updatedBy = json['updated_by'];
+    createdAt = json['created_at'];
+    updatedAt = json['updated_at'];
+    gradeName = json['grade_name'];
+    preference = json['preference'];
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['id'] = id;
+    data['school_id'] = schoolId;
+    data['academic_year_id'] = academicYearId;
+    data['is_active'] = isActive;
+    data['deleted_at'] = deletedAt;
+    data['created_by'] = createdBy;
+    data['updated_by'] = updatedBy;
+    data['created_at'] = createdAt;
+    data['updated_at'] = updatedAt;
+    data['grade_name'] = gradeName;
+    data['preference'] = preference;
+    return data;
+  }
+}

lib/src/ui/subjectdetails/network/res_submit_lo_grade.dart

+import 'package:schoolerp/src/ui/learning_outcomes/subjectdetails/network/res_subject_details.dart';
+
+class ResSubmitLoGrade {
+  int? statusCode;
+  String? message;
+  Data? data;
+
+  ResSubmitLoGrade({this.statusCode, this.message, this.data});
+
+  ResSubmitLoGrade.fromJson(Map<String, dynamic> json) {
+    statusCode = json['statusCode'];
+    message = json['message'];
+    data = json['data'] != null ? Data.fromJson(json['data']) : null;
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    data['statusCode'] = statusCode;
+    data['message'] = message;
+    if (this.data != null) {
+      data['data'] = this.data!.toJson();
+    }
+    return data;
+  }
+}
+
+class Data {
+  List<GradeList>? result;
+
+  Data({this.result});
+
+  Data.fromJson(Map<String, dynamic> json) {
+    if (json['result'] != null) {
+      result = <GradeList>[];
+      json['result'].forEach((v) {
+        result!.add(GradeList.fromJson(v));
+      });
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = {};
+    if (result != null) {
+      data['result'] = result!.map((v) => v.toJson()).toList();
+    }
+    return data;
+  }
+}