car_provider_app/lib/views/settings/schedule/add_schedules_page.dart

import 'package:car_provider_app/view_models/schedule_view_model.dart';
import 'package:car_provider_app/views/settings/schedule/widgets/chips_picker_item.dart';
import 'package:car_provider_app/views/settings/schedule/widgets/select_days_sheet.dart';
import 'package:car_provider_app/views/settings/schedule/widgets/select_services_sheet.dart';
import 'package:flutter/material.dart';
import 'package:mc_common_app/extensions/int_extensions.dart';
import 'package:mc_common_app/extensions/string_extensions.dart';
import 'package:mc_common_app/models/appointments_models/schedule_model.dart';
import 'package:mc_common_app/models/general_models/m_response.dart';
import 'package:mc_common_app/theme/colors.dart';
import 'package:mc_common_app/utils/date_helper.dart';
import 'package:mc_common_app/utils/utils.dart';
import 'package:mc_common_app/widgets/button/show_fill_button.dart';
import 'package:mc_common_app/widgets/common_widgets/app_bar.dart';
import 'package:mc_common_app/widgets/txt_field.dart';
import 'package:provider/provider.dart';
import 'package:mc_common_app/widgets/bottom_sheet.dart';

class AddSchedulesPage extends StatelessWidget {
  late ScheduleVM mModel;
  String name = "", startDate = "", endDate = "", startTime = "", endTime = "", slotsTime = "", appointmentPerSlot = "", servicesGroupID = "";
  late ScheduleData scheduleData;

  AddSchedulesPage({Key? key}) : super(key: key);

  setEditData() {
    name = scheduleData.scheduleName ?? "";
    startDate = DateHelper.formatAsYearMonthDay(scheduleData.fromDate ?? DateTime.now());
    endDate = DateHelper.formatAsYearMonthDay(scheduleData.toDate ?? DateTime.now());
    startTime = scheduleData.startTime ?? "";
    endTime = scheduleData.endTime ?? "";
    slotsTime = scheduleData.slotDurationMinute.toString();
    appointmentPerSlot = scheduleData.perSlotAppointment.toString();

    // mModel.selectedServicesItems.clear();
    scheduleData.scheduleServices?.forEach((element) {
      mModel.selectedServicesItems.add(PickerItem(id: element.providerServiceId ?? 0, title: element.providerServiceName ?? ""));
    });
    mModel.selectedDaysItems.clear();
    scheduleData.weeklyOffDays?.forEach((element) {
      for (var daysElement in initDaysList) {
        if (element.dayNumber == daysElement.id) {
          daysElement.isSelected = true;
          mModel.selectedDaysItems.add(daysElement);
        }
      }
    });
  }

  @override
  Widget build(BuildContext context) {
    mModel = context.read<ScheduleVM>();
    scheduleData = ModalRoute.of(context)!.settings.arguments as ScheduleData;
    mModel.getAllServices(scheduleData.branchId, scheduleData);
    mModel.selectedServicesItems = [];
    mModel.selectedDaysItems = [];
    if (scheduleData.id != null) {
      setEditData();
    }
    return Scaffold(
      appBar: const CustomAppBar(
        title: "Create Schedules",
      ),
      body: SizedBox(
        width: double.infinity,
        child: Consumer<ScheduleVM>(
          builder: (_, ScheduleVM model, child) {
            return Column(
              children: [
                Expanded(
                  child: SingleChildScrollView(
                    padding: const EdgeInsets.all(20),
                    child: Column(
                      children: [
                        TxtField(
                          hint: "Name of Schedule",
                          value: name,
                          onChanged: (v) {
                            name = v;
                          },
                        ),
                        8.height,
                        ChipsPickerItem(
                          hint: 'Select Services',
                          itemsList: [...model.selectedServicesItems],
                          onClick: () {
                            showMyBottomSheet(
                              context,
                              child: SelectServicesSheet(
                                onSelectServices: () {
                                  model.filterSelectedServices();
                                  FocusManager.instance.primaryFocus?.unfocus();
                                },
                              ),
                            );
                          },
                        ),
                        8.height,
                        TxtField(
                          hint: "Starting Date",
                          value: startDate,
                          postfixWidget: const Icon(
                            Icons.calendar_month,
                            size: 16,
                          ),
                          isNeedClickAll: true,
                          onTap: () async {
                            startDate = await Utils.pickDateFromDatePicker(
                              context,
                              firstDate: DateTime.now(),
                            );
                            FocusManager.instance.primaryFocus?.unfocus();
                            model.refresh();
                          },
                        ),
                        8.height,
                        TxtField(
                          hint: "End Date",
                          postfixWidget: const Icon(
                            Icons.calendar_month,
                            size: 16,
                          ),
                          value: endDate,
                          isNeedClickAll: true,
                          onTap: () async {
                            endDate = await Utils.pickDateFromDatePicker(
                              context,
                              firstDate: DateTime.now(),
                            );
                            FocusManager.instance.primaryFocus?.unfocus();
                            model.refresh();
                          },
                        ),
                        8.height,
                        ChipsPickerItem(
                          hint: 'Days',
                          itemsList: [...model.selectedDaysItems],
                          onClick: () {
                            showMyBottomSheet(
                              context,
                              child: SelectDaysSheet(
                                onSelected: (List<PickerItem> picked) {
                                  model.filterDays(picked);
                                  FocusManager.instance.primaryFocus?.unfocus();
                                },
                              ),
                            );
                          },
                        ),
                        8.height,
                        Row(
                          children: [
                            Expanded(
                              child: TxtField(
                                hint: "Shift Start Time",
                                postfixWidget: const Icon(
                                  Icons.access_time_filled_outlined,
                                  size: 16,
                                ),
                                value: startTime,
                                isNeedClickAll: true,
                                onTap: () async {
                                  startTime = await Utils.pickTime(context);
                                  FocusManager.instance.primaryFocus?.unfocus();
                                  model.refresh();
                                },
                              ),
                            ),
                            8.width,
                            Expanded(
                              child: TxtField(
                                hint: "Shift End Time",
                                postfixWidget: const Icon(
                                  Icons.access_time_filled_outlined,
                                  size: 16,
                                ),
                                value: endTime,
                                isNeedClickAll: true,
                                onTap: () async {
                                  TimeOfDay _startTime = TimeOfDay.now();
                                  if (startTime.isNotEmpty) _startTime = TimeOfDay(hour: int.parse(startTime.split(":")[0]), minute: int.parse(startTime.split(":")[1]));
                                  endTime = await Utils.pickTime(
                                    context,
                                    initialTime: _startTime,
                                  );
                                  FocusManager.instance.primaryFocus?.unfocus();
                                  model.refresh();
                                },
                              ),
                            ),
                          ],
                        ),
                        8.height,
                        TxtField(
                          hint: "Slots Time",
                          postfixWidget: Row(
                            mainAxisSize: MainAxisSize.min,
                            crossAxisAlignment: CrossAxisAlignment.center,
                            mainAxisAlignment: MainAxisAlignment.center,
                            children: [
                              "Min".toText(color: MyColors.lightTextColor),
                            ],
                          ),
                          keyboardType: TextInputType.number,
                          value: slotsTime,
                          onChanged: (v) {
                            slotsTime = v;
                          },
                        ),
                        8.height,
                        TxtField(
                          hint: "Appointment Per Slot",
                          value: appointmentPerSlot,
                          keyboardType: TextInputType.number,
                          onChanged: (v) {
                            appointmentPerSlot = v;
                          },
                        ),
                      ],
                    ),
                  ),
                ),
                ShowFillButton(
                  title: "Create",
                  maxWidth: double.infinity,
                  margin: const EdgeInsets.all(20),
                  onPressed: () {
                    if (validation(model)) {
                      if (scheduleData.id != null) {
                        updateSchedule(context, model);
                      } else {
                        createSchedule(context, model);
                      }
                    }
                  },
                ),
              ],
            );
          },
        ),
      ),
    );
  }

  bool validation(ScheduleVM model) {
    bool valid = true;
    if (name.length < 3) {
      Utils.showToast("Please enter valid schedule Name");
      valid = false;
    } else if (model.selectedServicesItems.isEmpty) {
      Utils.showToast("Please select Services");
      valid = false;
    } else if (startDate.isEmpty) {
      Utils.showToast("Please select start date");
      valid = false;
    } else if (endDate.isEmpty) {
      Utils.showToast("Please select end date");
      valid = false;
    } else if (model.selectedDaysItems.isEmpty) {
      Utils.showToast("Please off Days");
      valid = false;
    } else if (startTime.isEmpty) {
      Utils.showToast("Please select start time");
      valid = false;
    } else if (endTime.isEmpty) {
      Utils.showToast("Please select end time");
      valid = false;
    } else if (slotsTime.isEmpty) {
      Utils.showToast("Please select slot time");
      valid = false;
    } else if (appointmentPerSlot.isEmpty) {
      Utils.showToast("Please select appointment per slot");
      valid = false;
    }
    return valid;
  }

  createSchedule(BuildContext context, ScheduleVM model) async {
    List<int> days = [];
    for (var element in model.selectedDaysItems) {
      days.add(element.id);
    }

    var map = {
      "scheduleName": name,
      "serviceProviderBranchID": scheduleData.branchId,
      "fromDate": startDate,
      "toDate": endDate,
      "startTime": startTime,
      "endTime": endDate,
      "slotDurationMinute": slotsTime,
      "perSlotAppointment": appointmentPerSlot,
      "deliveryServiceType": 1,
      "weeklyOffDays": days
    };

    Utils.showLoading(context);
    MResponse scheduleResponse = await model.createSchedule(map);
    if (scheduleResponse.messageStatus == 1) {
      List<int> services = [];
      for (var element in model.selectedServicesItems) {
        services.add(element.id);
      }
      var map1 = {
        // "id": 0,
        "branchAppointmentScheduleID": scheduleResponse.data,
        "serviceProviderServiceID": services,
        "serviceGroupDescription": "string"
      };

      MResponse servicesResponse = await model.addServicesInSchedule(map1);
      Utils.hideLoading(context);
      if (servicesResponse.messageStatus == 1) {
        Utils.showToast("Successfully schedule created");
      } else {
        Utils.showToast("Something went wrong while adding services in schedule");
      }
    } else {
      Utils.hideLoading(context);
      Utils.showToast("Something went wrong");
    }
  }

  updateSchedule(BuildContext context, ScheduleVM model) async {
    List<int> days = [];
    for (var element in model.selectedDaysItems) {
      days.add(element.id);
    }

    var map = {
      "id": scheduleData.id,
      "scheduleName": name,
      "serviceProviderBranchID": scheduleData.branchId,
      "fromDate": startDate,
      "toDate": endDate,
      "startTime": startTime,
      "endTime": endDate,
      "slotDurationMinute": slotsTime,
      "perSlotAppointment": appointmentPerSlot,
      "deliveryServiceType": 1,
      "weeklyOffDays": days
    };

    Utils.showLoading(context);
    MResponse scheduleResponse = await model.updateSchedule(map);
    if (scheduleResponse.messageStatus == 1) {
      List<int> services = [];
      for (var element in model.selectedServicesItems) {
        services.add(element.id);
      }
      var map1 = {
        // "id": scheduleData,
        "branchAppointmentScheduleID": scheduleData.id,
        "serviceProviderServiceID": services,
        "serviceGroupDescription": "string",
      };

      MResponse servicesResponse = await model.updateServicesInSchedule(map1);
      Utils.hideLoading(context);
      if (servicesResponse.messageStatus == 1) {
        Utils.showToast("Successfully schedule updated");
      } else {
        Utils.showToast("Something went wrong while adding services in schedule");
      }
    } else {
      Utils.hideLoading(context);
      Utils.showToast("Something went wrong");
    }
  }
}