improvements

kitchen-service-api/src/lib/controllers.ts

@@ -7,6 +7,6 @@ export interface KitchenRpcController {
   createdTickets(): Promise<Observable<TicketCreated>>;
   rejectedTickets(): Promise<Observable<TicketRejected>>;
   confirmedTickets(): Promise<Observable<TicketConfirmed>>;
-  confirmTicket(id: UUID, readyAt: Date): Promise<void>;
-  rejectTicket(id: UUID, reason: string): Promise<void>;
+  confirmTicket(id: UUID, readyAt: Date): Promise<TicketConfirmed>;
+  rejectTicket(id: UUID, reason: string): Promise<TicketRejected>;
 }

kitchen-service/src/entities.ts

@@ -57,7 +57,6 @@ export class Ticket {
   ) {}
 
   reject(this: Writable<this>, reason: string): TicketRejected {
-    console.log('reject');
     if (this.state !== TicketState.CREATED) {
       throw new UnsupportedStateTransitionException(this.state);
     }

kitchen-service/src/kitchen.controller.ts

@@ -37,14 +37,12 @@ export class KitchenController implements KitchenRpcController {
   }
 
   @rpc.action()
-  async confirmTicket(id: UUID, readyAt: Date): Promise<void> {
-    // return await this.client.rpc(this.kitchen.confirmTicket(id, readyAt));
-    await this.client.send(this.kitchen.confirmTicket(id, readyAt));
+  async confirmTicket(id: UUID, readyAt: Date): Promise<TicketConfirmed> {
+    return await this.client.rpc(this.kitchen.confirmTicket(id, readyAt));
   }
 
   @rpc.action()
-  async rejectTicket(id: UUID, reason: string): Promise<void> {
-    // return await this.client.rpc(this.kitchen.rejectTicket(id, reason));
-    await this.client.send(this.kitchen.rejectTicket(id, reason));
+  async rejectTicket(id: UUID, reason: string): Promise<TicketRejected> {
+    return await this.client.rpc(this.kitchen.rejectTicket(id, reason));
   }
 }

order-service-api/src/lib/replies.ts

@@ -15,9 +15,23 @@ export class OrderNotFound extends Error {
   }
 }
 
-export class OrderApproved {}
+export class OrderCreated {
+  constructor(public readonly orderId: UUID) {}
+}
+
+export class OrderApproved {
+  constructor(
+    public readonly orderId: UUID,
+    public readonly approvedAt: Date,
+  ) {}
+}
 
-export class OrderRejected {}
+export class OrderRejected {
+  constructor(
+    public readonly orderId: UUID,
+    public readonly rejectedAt: Date,
+  ) {}
+}
 
 export class OrderRevisionProposed {
   constructor(

order-service-api/src/lib/services.ts

@@ -4,10 +4,10 @@ import { UUID } from '@deepkit/type';
 import { RestaurantCreatedEvent } from '@ftgo/restaurant-service-api';
 
 import { OrderDetails } from './entities';
-import { OrderApproved, OrderRejected } from './replies';
+import { OrderApproved, OrderCreated, OrderRejected } from './replies';
 
 export interface OrderServiceHandlers {
-  create(orderId: UUID, details: OrderDetails): Promise<UUID>;
+  create(orderId: UUID, details: OrderDetails): Promise<OrderCreated>;
   beginCancel(id: UUID): Promise<void>;
   undoBeginCancel(id: UUID): Promise<void>;
   undoCancel(id: UUID): Promise<void>;

order-service/src/entities.ts

@@ -16,8 +16,10 @@ import { Money, UnsupportedStateTransitionException } from '@ftgo/common';
 import {
   DeliveryInformation,
   LineItemQuantityChange,
+  OrderApproved,
   OrderLineItemNotFound,
   OrderMinimumNotMet,
+  OrderRejected,
   OrderRevised,
   OrderRevision,
   OrderRevisionProposed,
@@ -40,6 +42,7 @@ export class Order {
   readonly paymentInformation?: PaymentInformation;
   readonly lineItems: OrderLineItems;
   readonly rejectedAt?: Date;
+  readonly approvedAt?: Date;
 
   constructor(
     public readonly id: UUID & PrimaryKey,
@@ -72,19 +75,26 @@ export class Order {
     this.state = OrderState.CANCELLED;
   }
 
-  noteApproved(this: Writable<this>): void {
+  approve(this: Writable<this>): OrderApproved {
     if (this.state !== OrderState.APPROVAL_PENDING) {
       throw new UnsupportedStateTransitionException(this.state);
     }
+
     this.state = OrderState.APPROVED;
+    this.approvedAt = new Date();
+
+    return new OrderApproved(this.id, this.approvedAt);
   }
 
-  noteRejected(this: Writable<this>) {
+  reject(this: Writable<this>): OrderRejected {
     if (this.state !== OrderState.APPROVAL_PENDING) {
       throw new UnsupportedStateTransitionException(this.state);
     }
+
     this.state = OrderState.REJECTED;
     this.rejectedAt = new Date();
+
+    return new OrderRejected(this.id, this.rejectedAt);
   }
 
   noteReservingPayment() {}

order-service/src/order.service.ts

@@ -4,6 +4,7 @@ import { UUID } from '@deepkit/type';
 import { RestaurantCreatedEvent } from '@ftgo/restaurant-service-api';
 import {
   OrderApproved,
+  OrderCreated,
   OrderDetails,
   OrderRejected,
   OrderServiceApi,
@@ -31,15 +32,18 @@ export class OrderService implements OrderServiceHandlers {
 
   @restate.handler()
   async approve(id: UUID): Promise<OrderApproved> {
-    throw new Error('Not yet implemented');
+    const order = await this.order.findById(id);
+    const orderApproved = order.approve();
+    await this.order.save(order);
+    return orderApproved;
   }
 
   @restate.handler()
   async reject(id: UUID): Promise<OrderRejected> {
     const order = await this.order.findById(id);
-    order.noteRejected();
+    const orderRejected = order.reject();
     await this.order.save(order);
-    return new OrderRejected();
+    return orderRejected;
   }
 
   @restate.handler()
@@ -68,13 +72,13 @@ export class OrderService implements OrderServiceHandlers {
   async create(
     orderId: UUID,
     { customerId, restaurantId, lineItems }: OrderDetails,
-  ): Promise<UUID> {
+  ): Promise<OrderCreated> {
     const order = await this.order.create(
       orderId,
       customerId,
       restaurantId,
       lineItems,
     );
-    return order.id;
+    return new OrderCreated(order.id);
   }
 }