void

lib/application/void/void_form/void_form_bloc.dart

@@ -0,0 +1,120 @@
+import 'package:bloc/bloc.dart';
+import 'package:dartz/dartz.dart' hide Order;
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:injectable/injectable.dart' hide Order;
+
+import '../../../common/types/void_type.dart';
+import '../../../domain/order/order.dart';
+
+part 'void_form_event.dart';
+part 'void_form_state.dart';
+part 'void_form_bloc.freezed.dart';
+
+@injectable
+class VoidFormBloc extends Bloc<VoidFormEvent, VoidFormState> {
+  final IOrderRepository _repository;
+  VoidFormBloc(this._repository) : super(VoidFormState.initial()) {
+    on<VoidFormEvent>(_onVoidFormEvent);
+  }
+
+  Future<void> _onVoidFormEvent(
+    VoidFormEvent event,
+    Emitter<VoidFormState> emit,
+  ) {
+    return event.map(
+      setOrder: (e) async {
+        List<OrderItem> pendingItems = e.order.orderItems
+            .where((item) => item.status == 'pending')
+            .toList();
+
+        emit(state.copyWith(order: e.order, pendingItems: pendingItems));
+      },
+      voidTypeChanged: (e) async {
+        emit(state.copyWith(voidType: e.voidType));
+      },
+      voidReasonChanged: (e) async {
+        emit(state.copyWith(voidReason: e.voidReason));
+      },
+      itemQuantityChanged: (e) async {
+        final newQuantities = Map<String, int>.from(
+          state.selectedItemQuantities,
+        );
+
+        if (e.quantity > 0) {
+          newQuantities[e.itemId] = e.quantity;
+        } else {
+          newQuantities.remove(e.itemId);
+        }
+
+        // Recalculate total price
+        int newTotal = 0;
+        for (var entry in newQuantities.entries) {
+          final item = state.pendingItems.firstWhere(
+            (item) => item.id == entry.key,
+          );
+          newTotal += item.unitPrice.toInt() * entry.value;
+        }
+
+        emit(
+          state.copyWith(
+            selectedItemQuantities: newQuantities,
+            totalPriceVoid: newTotal,
+          ),
+        );
+      },
+      clearSelectedItem: (e) async {
+        emit(state.copyWith(selectedItemQuantities: {}, totalPriceVoid: 0));
+      },
+      submitted: (e) async {
+        Either<OrderFailure, Unit> failureOrVoid;
+        List<OrderItem> voidItems = [];
+
+        if (state.voidType.isItem) {
+          state.selectedItemQuantities.forEach((itemId, voidQty) {
+            final originalItem = state.order.orderItems.firstWhere(
+              (item) => item.id == itemId,
+            );
+
+            voidItems.add(
+              OrderItem(
+                id: originalItem.id,
+                orderId: originalItem.orderId,
+                productId: originalItem.productId,
+                productName: originalItem.productName,
+                productVariantId: originalItem.productVariantId,
+                productVariantName: originalItem.productVariantName,
+                quantity: voidQty,
+                unitPrice: originalItem.unitPrice,
+                totalPrice: (originalItem.unitPrice) * voidQty,
+                modifiers: originalItem.modifiers,
+                notes: originalItem.notes,
+                status: originalItem.status,
+                createdAt: originalItem.createdAt,
+                updatedAt: originalItem.updatedAt,
+                printerType: originalItem.printerType,
+                paidQuantity: originalItem.paidQuantity,
+              ),
+            );
+          });
+        }
+
+        emit(state.copyWith(isSubmitting: true, failureOrVoid: none()));
+
+        failureOrVoid = await _repository.voidOrder(
+          orderId: state.order.id,
+          reason: state.voidReason ?? '',
+          orderItems: voidItems,
+          type: state.voidType.toStringType(),
+        );
+
+        emit(
+          state.copyWith(
+            isSubmitting: false,
+            failureOrVoid: optionOf(failureOrVoid),
+            voidItems: state.voidType.isItem ? voidItems : state.pendingItems,
+          ),
+        );
+      },
+    );
+  }
+}

lib/application/void/void_form/void_form_event.dart

@@ -0,0 +1,16 @@
+part of 'void_form_bloc.dart';
+
+@freezed
+class VoidFormEvent with _$VoidFormEvent {
+  const factory VoidFormEvent.setOrder(Order order) = _SetOrder;
+  const factory VoidFormEvent.voidTypeChanged(VoidType voidType) =
+      _VoidTypeChanged;
+  const factory VoidFormEvent.voidReasonChanged(String voidReason) =
+      _VoidReasonChanged;
+  const factory VoidFormEvent.itemQuantityChanged({
+    required String itemId,
+    required int quantity,
+  }) = _ItemQuantityChanged;
+  const factory VoidFormEvent.clearSelectedItem() = _ClearSelectedItem;
+  const factory VoidFormEvent.submitted() = _Submitted;
+}

lib/application/void/void_form/void_form_state.dart

@@ -0,0 +1,26 @@
+part of 'void_form_bloc.dart';
+
+@freezed
+class VoidFormState with _$VoidFormState {
+  factory VoidFormState({
+    required Order order,
+    required List<OrderItem> pendingItems,
+    required List<OrderItem> voidItems,
+    required VoidType voidType,
+    required Map<String, int> selectedItemQuantities,
+    String? voidReason,
+    required int totalPriceVoid,
+    required Option<Either<OrderFailure, Unit>> failureOrVoid,
+    @Default(false) bool isSubmitting,
+  }) = _VoidFormState;
+
+  factory VoidFormState.initial() => VoidFormState(
+    order: Order.empty(),
+    voidType: VoidType.all,
+    selectedItemQuantities: {},
+    pendingItems: [],
+    totalPriceVoid: 0,
+    failureOrVoid: none(),
+    voidItems: [],
+  );
+}