Index: src/main/java/finki/db/tasty_tabs/entity/exceptions/FrontStaffNotFoundException.java =================================================================== --- src/main/java/finki/db/tasty_tabs/entity/exceptions/FrontStaffNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/entity/exceptions/FrontStaffNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,8 @@ +package finki.db.tasty_tabs.entity.exceptions; + +public class FrontStaffNotFoundException extends DomainException { + + public FrontStaffNotFoundException(Long id) { + super(String.format("FrontStaff with id %d doesnt exist",id)); + } +} Index: src/main/java/finki/db/tasty_tabs/entity/exceptions/InvalidOrderTypeException.java =================================================================== --- src/main/java/finki/db/tasty_tabs/entity/exceptions/InvalidOrderTypeException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/entity/exceptions/InvalidOrderTypeException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,8 @@ +package finki.db.tasty_tabs.entity.exceptions; + +public class InvalidOrderTypeException extends DomainException { + + public InvalidOrderTypeException(String message) { + super(message); + } +} Index: src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderItemNotFoundException.java =================================================================== --- src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderItemNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderItemNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,8 @@ +package finki.db.tasty_tabs.entity.exceptions; + +public class OrderItemNotFoundException extends DomainException { + + public OrderItemNotFoundException() { + super(String.format("OrderItem doesnt exist")); + } +} Index: src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderNotFoundException.java =================================================================== --- src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/entity/exceptions/OrderNotFoundException.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,8 @@ +package finki.db.tasty_tabs.entity.exceptions; + +public class OrderNotFoundException extends DomainException { + + public OrderNotFoundException(Long id) { + super(String.format("Order with id %d doesnt exist",id)); + } +} Index: src/main/java/finki/db/tasty_tabs/repository/OnlineOrderRepository.java =================================================================== --- src/main/java/finki/db/tasty_tabs/repository/OnlineOrderRepository.java (revision e9ac9e121a623e658d58b18bd77bf4aa27ae162e) +++ src/main/java/finki/db/tasty_tabs/repository/OnlineOrderRepository.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -1,6 +1,15 @@ package finki.db.tasty_tabs.repository; +import finki.db.tasty_tabs.entity.Customer; import finki.db.tasty_tabs.entity.OnlineOrder; +import finki.db.tasty_tabs.entity.Order; import org.springframework.data.jpa.repository.JpaRepository; -public interface OnlineOrderRepository extends JpaRepository {} +import java.util.List; + +public interface OnlineOrderRepository extends JpaRepository { + + List findAllByCustomer_Id(Long id); + List findAllByStatus(String status); + +} Index: src/main/java/finki/db/tasty_tabs/repository/OrderItemRepository.java =================================================================== --- src/main/java/finki/db/tasty_tabs/repository/OrderItemRepository.java (revision e9ac9e121a623e658d58b18bd77bf4aa27ae162e) +++ src/main/java/finki/db/tasty_tabs/repository/OrderItemRepository.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -1,6 +1,13 @@ package finki.db.tasty_tabs.repository; +import finki.db.tasty_tabs.entity.Order; import finki.db.tasty_tabs.entity.OrderItem; +import finki.db.tasty_tabs.entity.Product; import org.springframework.data.jpa.repository.JpaRepository; -public interface OrderItemRepository extends JpaRepository {} +import java.util.Optional; + +public interface OrderItemRepository extends JpaRepository { + Optional findByOrderAndProduct(Order order, Product product); + +} Index: src/main/java/finki/db/tasty_tabs/repository/OrderRepository.java =================================================================== --- src/main/java/finki/db/tasty_tabs/repository/OrderRepository.java (revision e9ac9e121a623e658d58b18bd77bf4aa27ae162e) +++ src/main/java/finki/db/tasty_tabs/repository/OrderRepository.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -4,3 +4,6 @@ import org.springframework.data.jpa.repository.JpaRepository; -public interface OrderRepository extends JpaRepository {} +import java.util.List; + +public interface OrderRepository extends JpaRepository { +} Index: src/main/java/finki/db/tasty_tabs/repository/TabOrderRepository.java =================================================================== --- src/main/java/finki/db/tasty_tabs/repository/TabOrderRepository.java (revision e9ac9e121a623e658d58b18bd77bf4aa27ae162e) +++ src/main/java/finki/db/tasty_tabs/repository/TabOrderRepository.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -1,6 +1,15 @@ package finki.db.tasty_tabs.repository; +import finki.db.tasty_tabs.entity.OnlineOrder; import finki.db.tasty_tabs.entity.TabOrder; import org.springframework.data.jpa.repository.JpaRepository; -public interface TabOrderRepository extends JpaRepository {} +import java.time.LocalDateTime; +import java.util.List; + +public interface TabOrderRepository extends JpaRepository { + List findByRestaurantTable_TableNumberAndTimestampBetween(Integer tableNumber, LocalDateTime startOfDay, LocalDateTime endOfDay); + List findAllByFrontStaffId(Long frontStaffId); + List findAllByStatus(String status); + +} Index: src/main/java/finki/db/tasty_tabs/service/OrderService.java =================================================================== --- src/main/java/finki/db/tasty_tabs/service/OrderService.java (revision e9ac9e121a623e658d58b18bd77bf4aa27ae162e) +++ src/main/java/finki/db/tasty_tabs/service/OrderService.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -1,16 +1,46 @@ package finki.db.tasty_tabs.service; -import finki.db.tasty_tabs.entity.OnlineOrder; -import finki.db.tasty_tabs.entity.OrderItem; -import finki.db.tasty_tabs.entity.TabOrder; -import finki.db.tasty_tabs.web.dto.CreateOnlineOrderRequest; -import finki.db.tasty_tabs.web.dto.CreateTabOrderRequest; -import finki.db.tasty_tabs.web.dto.OrderItemRequest; -import finki.db.tasty_tabs.web.dto.TransferTabRequest; +import finki.db.tasty_tabs.entity.*; +import finki.db.tasty_tabs.web.dto.CreateOrderDto; +import finki.db.tasty_tabs.web.dto.CreateOrderItemDto; + +import java.time.LocalDate; +import java.util.List; public interface OrderService { - TabOrder createTabOrder(CreateTabOrderRequest request); - OnlineOrder createOnlineOrder(CreateOnlineOrderRequest request); - OrderItem addItemToOrder(Long orderId, OrderItemRequest itemRequest); - TabOrder transferTab(Long orderId, TransferTabRequest request); + List findAll(); + Order findById(Long id); + + Order updateOrder(Long id, CreateOrderDto dto); + void deleteOrder(Long id); + + double calculateTotalPrice(Long orderId); + void updateOrderStatus(Long orderId, String newStatus); + + // Methods for Order Items + OrderItem addItemToOrder(Long orderId, CreateOrderItemDto itemDto); + void decreaseOrderItemQuantity(Long orderItemId); + OrderItem updateOrderItem(Long orderItemId, CreateOrderItemDto itemDto); + void deleteOrderItem(Long orderItemId); + OrderItem processOrderItem(Long orderItemId); + + // Specific OnlineOrder methods + OnlineOrder createOnlineOrder(CreateOrderDto dto, String userEmail); + OnlineOrder findOnlineOrderById(Long id); + List findAllOnlineOrders(); + List findOnlineOrdersByCustomer(Long customerId); + + // Specific TabOrder methods + TabOrder createTabOrder(CreateOrderDto dto, String userEmail); + TabOrder findTabOrderById(Long id); + List findAllTabOrders(); + List findTabOrdersByTableAndDate(Integer tableNumber, LocalDate date); + List findTabOrdersByStaff(Long frontStaffId); + TabOrder assignOrderToStaff(Long orderId, Long frontStaffId); + + List findOpenOrders(); + List findClosedOrders(); + + // General methods for all order types + Order cancelOrder(Long orderId); } Index: src/main/java/finki/db/tasty_tabs/service/impl/OrderServiceImpl.java =================================================================== --- src/main/java/finki/db/tasty_tabs/service/impl/OrderServiceImpl.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/service/impl/OrderServiceImpl.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,302 @@ +package finki.db.tasty_tabs.service.impl; + +import finki.db.tasty_tabs.entity.*; +import finki.db.tasty_tabs.entity.exceptions.*; +import finki.db.tasty_tabs.repository.*; +import finki.db.tasty_tabs.service.OrderService; +import finki.db.tasty_tabs.web.dto.CreateOrderDto; +import finki.db.tasty_tabs.web.dto.CreateOrderItemDto; +import jakarta.transaction.Transactional; +import lombok.RequiredArgsConstructor; +import org.springframework.security.core.userdetails.UsernameNotFoundException; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.util.List; +import java.util.stream.Collectors; + +@Service +@RequiredArgsConstructor +public class OrderServiceImpl implements OrderService { + + private final OrderRepository orderRepository; + private final OrderItemRepository orderItemRepository; + private final ProductRepository productRepository; + private final RestaurantTableRepository tableRepository; + private final UserRepository userRepository; + private final TabOrderRepository tabOrderRepository; + private final OnlineOrderRepository onlineOrderRepository; + private final FrontStaffRepository frontStaffRepository; + private final CustomerRepository customerRepository; + + @Override + public List findAll() { + return orderRepository.findAll(); + } + + @Override + public Order findById(Long id) { + return orderRepository.findById(id).orElseThrow(() -> new OrderNotFoundException(id)); + } + + @Override + public Order updateOrder(Long id, CreateOrderDto dto) { + Order existingOrder = findById(id); + + existingOrder.setStatus(dto.status()); + + existingOrder.getOrderItems().clear(); + List newOrderItems = dto.orderItems().stream().map(itemDto -> { + OrderItem item = new OrderItem(); + item.setOrder(existingOrder); + item.setQuantity(itemDto.quantity()); + item.setPrice(itemDto.price()); + item.setIsProcessed(itemDto.isProcessed()); + item.setTimestamp(LocalDateTime.now()); + Product product = productRepository.findById(itemDto.productId()) + .orElseThrow(() -> new ProductNotFoundException(itemDto.productId())); + item.setProduct(product); + return item; + }).collect(Collectors.toList()); + + existingOrder.setOrderItems(newOrderItems); + + return orderRepository.save(existingOrder); + } + + @Override + public void deleteOrder(Long id) { + orderRepository.deleteById(id); + } + + @Override + public double calculateTotalPrice(Long orderId) { + Order order = findById(orderId); + return order.getOrderItems().stream() + .mapToDouble(item -> item.getQuantity() * item.getPrice()) + .sum(); + } + + @Override + public void updateOrderStatus(Long orderId, String newStatus) { + Order order = findById(orderId); + order.setStatus(newStatus); + orderRepository.save(order); + } + + // Methods for Order Items + @Override + @Transactional + public OrderItem addItemToOrder(Long orderId, CreateOrderItemDto itemDto) { + Order order = findById(orderId); + OrderItem orderItem = new OrderItem(); + orderItem.setOrder(order); + orderItem.setQuantity(itemDto.quantity()); + orderItem.setPrice(itemDto.price()); + orderItem.setIsProcessed(itemDto.isProcessed()); + orderItem.setTimestamp(LocalDateTime.now()); + Product product = productRepository.findById(itemDto.productId()) + .orElseThrow(() -> new ProductNotFoundException(itemDto.productId())); + orderItem.setProduct(product); + return orderItemRepository.save(orderItem); + } + + @Override + @Transactional + public void decreaseOrderItemQuantity(Long orderItemId) { + OrderItem orderItem = orderItemRepository.findById(orderItemId) + .orElseThrow(OrderItemNotFoundException::new); + if (orderItem.getQuantity() > 1) { + orderItem.setQuantity(orderItem.getQuantity() - 1); + orderItemRepository.save(orderItem); + } else { + orderItemRepository.delete(orderItem); + } + } + + @Override + @Transactional + public OrderItem updateOrderItem(Long orderItemId, CreateOrderItemDto itemDto) { + OrderItem orderItem = orderItemRepository.findById(orderItemId) + .orElseThrow(OrderItemNotFoundException::new); + orderItem.setQuantity(itemDto.quantity()); + orderItem.setPrice(itemDto.price()); + orderItem.setIsProcessed(itemDto.isProcessed()); + Product product = productRepository.findById(itemDto.productId()) + .orElseThrow(() -> new ProductNotFoundException(itemDto.productId())); + orderItem.setProduct(product); + return orderItemRepository.save(orderItem); + } + + @Override + @Transactional + public void deleteOrderItem(Long orderItemId) { + orderItemRepository.deleteById(orderItemId); + } + + @Override + @Transactional + public OrderItem processOrderItem(Long orderItemId) { + OrderItem orderItem = orderItemRepository.findById(orderItemId) + .orElseThrow(OrderItemNotFoundException::new); + orderItem.setIsProcessed(true); + return orderItemRepository.save(orderItem); + } + + // Specific OnlineOrder methods + @Override + @Transactional + public OnlineOrder createOnlineOrder(CreateOrderDto dto, String userEmail) { + User user = userRepository.findByEmail(userEmail) + .orElseThrow(() -> new UsernameNotFoundException("User with email " + userEmail + " not found.")); + if (!(user instanceof Customer)) { + throw new SecurityException("User is not authorized to create online orders."); + } + OnlineOrder onlineOrder = new OnlineOrder(); + onlineOrder.setCustomer((Customer) user); + onlineOrder.setDeliveryAddress(dto.deliveryAddress()); + onlineOrder.setTimestamp(LocalDateTime.now()); + onlineOrder.setStatus(dto.status()); + if (dto.orderItems() != null && !dto.orderItems().isEmpty()) { + List orderItems = dto.orderItems().stream().map(itemDto -> { + OrderItem item = new OrderItem(); + item.setOrder(onlineOrder); + item.setQuantity(itemDto.quantity()); + item.setPrice(itemDto.price()); + item.setIsProcessed(itemDto.isProcessed()); + item.setTimestamp(LocalDateTime.now()); + Product product = productRepository.findById(itemDto.productId()) + .orElseThrow(() -> new ProductNotFoundException(itemDto.productId())); + item.setProduct(product); + return item; + }).collect(Collectors.toList()); + onlineOrder.setOrderItems(orderItems); + } + return onlineOrderRepository.save(onlineOrder); + } + + @Override + public OnlineOrder findOnlineOrderById(Long id) { + return onlineOrderRepository.findById(id).orElseThrow(() -> new OrderNotFoundException(id)); + } + + @Override + public List findAllOnlineOrders() { + return onlineOrderRepository.findAll(); + } + + @Override + public List findOnlineOrdersByCustomer(Long customerId) { + return onlineOrderRepository.findAllByCustomer_Id(customerId); + } + + // Specific TabOrder methods + @Override + @Transactional + public TabOrder createTabOrder(CreateOrderDto dto, String userEmail) { + User user = userRepository.findByEmail(userEmail) + .orElseThrow(() -> new UsernameNotFoundException("User with email " + userEmail + " not found.")); + if (!(user instanceof FrontStaff)) { + throw new SecurityException("User is not authorized to create tab orders."); + } + TabOrder tabOrder = new TabOrder(); + RestaurantTable table = tableRepository.findById(dto.tableNumber()) + .orElseThrow(() -> new TableNotFoundException(dto.tableNumber())); + tabOrder.setRestaurantTable(table); + tabOrder.setFrontStaff((FrontStaff) user); + tabOrder.setTimestamp(LocalDateTime.now()); + tabOrder.setStatus(dto.status()); + if (dto.orderItems() != null && !dto.orderItems().isEmpty()) { + List orderItems = dto.orderItems().stream().map(itemDto -> { + OrderItem item = new OrderItem(); + item.setOrder(tabOrder); + item.setQuantity(itemDto.quantity()); + item.setPrice(itemDto.price()); + item.setIsProcessed(itemDto.isProcessed()); + item.setTimestamp(LocalDateTime.now()); + Product product = productRepository.findById(itemDto.productId()) + .orElseThrow(() -> new ProductNotFoundException(itemDto.productId())); + item.setProduct(product); + return item; + }).collect(Collectors.toList()); + tabOrder.setOrderItems(orderItems); + } + return tabOrderRepository.save(tabOrder); + } + + @Override + public TabOrder findTabOrderById(Long id) { + return tabOrderRepository.findById(id).orElseThrow(() -> new OrderNotFoundException(id)); + } + + @Override + public List findAllTabOrders() { + return tabOrderRepository.findAll(); + } + + @Override + public List findTabOrdersByTableAndDate(Integer tableNumber, LocalDate date) { + LocalDateTime startOfDay = date.atStartOfDay(); + LocalDateTime endOfDay = date.atTime(23, 59, 59); + return tabOrderRepository.findByRestaurantTable_TableNumberAndTimestampBetween(tableNumber, startOfDay, endOfDay); + } + + @Override + public List findTabOrdersByStaff(Long frontStaffId) { + return tabOrderRepository.findAllByFrontStaffId(frontStaffId); + } + + @Override + @Transactional + public TabOrder assignOrderToStaff(Long orderId, Long frontStaffId) { + TabOrder tabOrder = tabOrderRepository.findById(orderId) + .orElseThrow(() -> new OrderNotFoundException(orderId)); + FrontStaff frontStaff = frontStaffRepository.findById(frontStaffId) + .orElseThrow(() -> new FrontStaffNotFoundException(frontStaffId)); + tabOrder.setFrontStaff(frontStaff); + return tabOrderRepository.save(tabOrder); + } + + // General methods for all order types + @Override + @Transactional + public Order cancelOrder(Long orderId) { + Order order = findById(orderId); + order.setStatus("CANCELED"); + return orderRepository.save(order); + } + + @Override + public List findOpenOrders() { + + // Query the OnlineOrderRepository for open orders + List onlineOrders = onlineOrderRepository.findAllByStatus("OPEN"); + + // Query the TabOrderRepository for open orders + List tabOrders = tabOrderRepository.findAllByStatus("OPEN"); + + // Combine the lists into a single List + List combinedOrders = new java.util.ArrayList<>(); + combinedOrders.addAll(onlineOrders); + combinedOrders.addAll(tabOrders); + + return combinedOrders; + } + + @Override + public List findClosedOrders() { + + // Query the OnlineOrderRepository for open orders + List onlineOrders = onlineOrderRepository.findAllByStatus("CLOSED"); + + // Query the TabOrderRepository for open orders + List tabOrders = tabOrderRepository.findAllByStatus("CLOSED"); + + // Combine the lists into a single List + List combinedOrders = new java.util.ArrayList<>(); + combinedOrders.addAll(onlineOrders); + combinedOrders.addAll(tabOrders); + + return combinedOrders; } +} Index: src/main/java/finki/db/tasty_tabs/web/controllers/OrderController.java =================================================================== --- src/main/java/finki/db/tasty_tabs/web/controllers/OrderController.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/web/controllers/OrderController.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,189 @@ +package finki.db.tasty_tabs.web.controllers; +import finki.db.tasty_tabs.entity.Order; +import finki.db.tasty_tabs.service.OrderService; +import finki.db.tasty_tabs.web.dto.CreateOrderDto; +import finki.db.tasty_tabs.web.dto.CreateOrderItemDto; +import finki.db.tasty_tabs.web.dto.OrderDto; +import finki.db.tasty_tabs.web.dto.OrderItemDto; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.tags.Tag; +import lombok.RequiredArgsConstructor; +import org.springframework.format.annotation.DateTimeFormat; +import org.springframework.http.ResponseEntity; +import org.springframework.security.core.Authentication; +import org.springframework.web.bind.annotation.*; + +import java.time.LocalDate; +import java.util.List; +import java.util.stream.Collectors; + +@RestController +@RequestMapping("/api/orders") +@Tag(name = "Order API", description = "Endpoints for managing orders") +@RequiredArgsConstructor +public class OrderController { + + private final OrderService orderService; + + @Operation(summary = "Get all orders (both online and tab)") + @GetMapping + public List getAllOrders() { + return orderService.findAll().stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + @Operation(summary = "Get any order by ID") + @GetMapping("/{id}") + public ResponseEntity getOrderById(@PathVariable Long id) { + return ResponseEntity.ok(OrderDto.from(orderService.findById(id))); + } + + @Operation(summary = "Update an existing order") + @PutMapping("/{id}") + public ResponseEntity updateOrder(@PathVariable Long id, @RequestBody CreateOrderDto dto) { + return ResponseEntity.ok(OrderDto.from(orderService.updateOrder(id, dto))); + } + + @Operation(summary = "Delete an order by ID") + @DeleteMapping("/{id}") + public ResponseEntity deleteOrder(@PathVariable Long id) { + orderService.deleteOrder(id); + return ResponseEntity.noContent().build(); + } + + @Operation(summary = "Calculate total price of an order") + @GetMapping("/{id}/total-price") + public ResponseEntity calculateTotalPrice(@PathVariable Long id) { + return ResponseEntity.ok(orderService.calculateTotalPrice(id)); + } + + @Operation(summary = "Update the status of an order") + @PatchMapping("/{id}/status") + public ResponseEntity updateOrderStatus(@PathVariable Long id, @RequestBody String status) { + orderService.updateOrderStatus(id, status); + return ResponseEntity.noContent().build(); + } + + @Operation(summary = "Cancel an order") + @PatchMapping("/{orderId}/cancel") + public ResponseEntity cancelOrder(@PathVariable Long orderId) { + return ResponseEntity.ok(OrderDto.from(orderService.cancelOrder(orderId))); + } + + // Order Item Endpoints + @Operation(summary = "Add an item to an existing order") + @PostMapping("/{orderId}/items") + public ResponseEntity addItemToOrder(@PathVariable Long orderId, @RequestBody CreateOrderItemDto itemDto) { + return ResponseEntity.ok(OrderItemDto.from(orderService.addItemToOrder(orderId, itemDto))); + } + + @Operation(summary = "Decrease the quantity of a specific order item") + @DeleteMapping("/items/{orderItemId}") + public ResponseEntity decreaseOrderItemQuantity(@PathVariable Long orderItemId) { + orderService.decreaseOrderItemQuantity(orderItemId); + return ResponseEntity.noContent().build(); + } + + @Operation(summary = "Update an existing order item") + @PutMapping("/items/{orderItemId}") + public ResponseEntity updateOrderItem(@PathVariable Long orderItemId, @RequestBody CreateOrderItemDto itemDto) { + return ResponseEntity.ok(OrderItemDto.from(orderService.updateOrderItem(orderItemId, itemDto))); + } + + @Operation(summary = "Delete an order item by ID") + @DeleteMapping("/items/{orderItemId}/delete") + public ResponseEntity deleteOrderItem(@PathVariable Long orderItemId) { + orderService.deleteOrderItem(orderItemId); + return ResponseEntity.noContent().build(); + } + + @Operation(summary = "Mark an order item as processed") + @PatchMapping("/items/{orderItemId}/process") + public ResponseEntity processOrderItem(@PathVariable Long orderItemId) { + return ResponseEntity.ok(OrderItemDto.from(orderService.processOrderItem(orderItemId))); + } + + // Online Order Endpoints + @Operation(summary = "Create a new online order for a logged-in customer") + @PostMapping("/online") + public ResponseEntity createOnlineOrder(@RequestBody CreateOrderDto dto, Authentication authentication) { + String userEmail = authentication.getName(); + return ResponseEntity.ok(OrderDto.from(orderService.createOnlineOrder(dto, userEmail))); + } + + @Operation(summary = "Get all online orders") + @GetMapping("/online") + public List getAllOnlineOrders() { + return orderService.findAllOnlineOrders().stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + @Operation(summary = "Get a specific online order by ID") + @GetMapping("/online/{id}") + public ResponseEntity getOnlineOrderById(@PathVariable Long id) { + return ResponseEntity.ok(OrderDto.from(orderService.findOnlineOrderById(id))); + } + + @Operation(summary = "Get all online orders for a specific customer") + @GetMapping("/online/customer/{customerId}") + public List getOnlineOrdersByCustomer(@PathVariable Long customerId) { + return orderService.findOnlineOrdersByCustomer(customerId).stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + // Tab Order Endpoints + @Operation(summary = "Create a new tab order for a logged-in front staff member") + @PostMapping("/tab") + public ResponseEntity createTabOrder(@RequestBody CreateOrderDto dto, Authentication authentication) { + String userEmail = authentication.getName(); + return ResponseEntity.ok(OrderDto.from(orderService.createTabOrder(dto, userEmail))); + } + + @Operation(summary = "Get all tab orders") + @GetMapping("/tab") + public List getAllTabOrders() { + return orderService.findAllTabOrders().stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + @Operation(summary = "Get a specific tab order by ID") + @GetMapping("/tab/{id}") + public ResponseEntity getTabOrderById(@PathVariable Long id) { + return ResponseEntity.ok(OrderDto.from(orderService.findTabOrderById(id))); + } + + @Operation(summary = "Get all tab orders for a specific table on a given date (defaults to today)") + @GetMapping("/tab/table/{tableNumber}") + public List getTabOrdersByTableAndDate( + @PathVariable Integer tableNumber, + @RequestParam(required = false, defaultValue = "#{T(java.time.LocalDate).now()}") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE) LocalDate date) { + return orderService.findTabOrdersByTableAndDate(tableNumber, date).stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + @Operation(summary = "Assign a TabOrder to a specific front staff member") + @PatchMapping("/tab/{orderId}/assign-staff/{frontStaffId}") + public ResponseEntity assignOrderToStaff(@PathVariable Long orderId, @PathVariable Long frontStaffId) { + return ResponseEntity.ok(OrderDto.from(orderService.assignOrderToStaff(orderId, frontStaffId))); + } + @Operation(summary = "Get all open orders (pending or in-progress)") + @GetMapping("/open") + public List getOpenOrders() { + return orderService.findOpenOrders().stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } + + @Operation(summary = "Get all closed orders (completed, canceled, or delivered)") + @GetMapping("/closed") + public List getClosedOrders() { + return orderService.findClosedOrders().stream() + .map(OrderDto::from) + .collect(Collectors.toList()); + } +} Index: src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderDto.java =================================================================== --- src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,11 @@ +package finki.db.tasty_tabs.web.dto; + +import java.util.List; + +public record CreateOrderDto( + List orderItems, + String status, + String type, // "online" or "tab" + String deliveryAddress, // For OnlineOrder + Integer tableNumber // For TabOrder +) { } Index: src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderItemDto.java =================================================================== --- src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderItemDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/web/dto/CreateOrderItemDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,7 @@ +package finki.db.tasty_tabs.web.dto; +public record CreateOrderItemDto( + Long productId, + Integer quantity, + Double price, + Boolean isProcessed +) { } Index: src/main/java/finki/db/tasty_tabs/web/dto/OrderDto.java =================================================================== --- src/main/java/finki/db/tasty_tabs/web/dto/OrderDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/web/dto/OrderDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,68 @@ +package finki.db.tasty_tabs.web.dto; + +import finki.db.tasty_tabs.entity.OnlineOrder; +import finki.db.tasty_tabs.entity.Order; +import finki.db.tasty_tabs.entity.TabOrder; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.stream.Collectors; + +public record OrderDto( + Long id, + LocalDateTime timestamp, + String status, + String type, + String customerName, + String deliveryAddress, + Integer tableNumber, + String frontStaffName, + List orderItems +) { + public static OrderDto from(Order order) { + if (order instanceof OnlineOrder onlineOrder) { + return new OrderDto( + onlineOrder.getId(), + onlineOrder.getTimestamp(), + onlineOrder.getStatus(), + "ONLINE", + onlineOrder.getCustomer().getEmail(), + onlineOrder.getDeliveryAddress(), + null, + null, + onlineOrder.getOrderItems().stream() + .map(OrderItemDto::from) + .collect(Collectors.toList()) + ); + } else if (order instanceof TabOrder tabOrder) { + return new OrderDto( + tabOrder.getId(), + tabOrder.getTimestamp(), + tabOrder.getStatus(), + "TAB", + null, + null, + tabOrder.getRestaurantTable().getTableNumber(), + tabOrder.getFrontStaff().getEmail(), + tabOrder.getOrderItems().stream() + .map(OrderItemDto::from) + .collect(Collectors.toList()) + ); + } else { + // Handle the base Order entity if needed + return new OrderDto( + order.getId(), + order.getTimestamp(), + order.getStatus(), + "base", + null, + null, + null, + null, + order.getOrderItems().stream() + .map(OrderItemDto::from) + .collect(Collectors.toList()) + ); + } + } +} Index: src/main/java/finki/db/tasty_tabs/web/dto/OrderItemDto.java =================================================================== --- src/main/java/finki/db/tasty_tabs/web/dto/OrderItemDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) +++ src/main/java/finki/db/tasty_tabs/web/dto/OrderItemDto.java (revision 07aed49d8bfab3550a488b63c9872cd86c74257c) @@ -0,0 +1,25 @@ +package finki.db.tasty_tabs.web.dto; + + +import finki.db.tasty_tabs.entity.OrderItem; +import java.time.LocalDateTime; + +public record OrderItemDto( + Long id, + Integer quantity, + Double price, + Boolean isProcessed, + LocalDateTime timestamp, + Long productId +) { + public static OrderItemDto from(OrderItem orderItem) { + return new OrderItemDto( + orderItem.getId(), + orderItem.getQuantity(), + orderItem.getPrice(), + orderItem.getIsProcessed(), + orderItem.getTimestamp(), + orderItem.getProduct().getId() + ); + } +}