Cart.scala

case class Cart
(id: CartId,
 status: StatusType.Value,
 customerId: CustomerId,
 cartItems: List[CartItem]) extends Entity[CartId] {
  // ...
  def addCartItem(cartItem: CartItem): Cart = {
    require(cartItem.quantity > 0)
    cartItems.find(_.itemId == cartItem.itemId).map {
      currentItem =>
        val newCartItem = currentItem.addQuantity(cartItem.quantity).
         ensuring(_.quantity > 0)
        copy(cartItems = newCartItem :: 
          cartItems.filterNot(_.itemId == cartItem.itemId))
    }.getOrElse {
      copy(cartItems = cartItem :: cartItems)
    }
  }
  
}

Order.scala

case class Order
(id: OrderId,
 status: StatusType.Value,
 orderStatus: OrderStatus.Value,
 orderDate: DateTime,
 customerId: CustomerId,
 customerName: String,
 shippingAddress: PostalAddress,
 shippingContact: Contact,
 orderItems: List[OrderItem])
  extends Entity[OrderId] {
  // ...
  def addOrderItem(orderItem: OrderItem): Order =
    copy(orderItems = orderItem :: orderItems)
  // ...
}

object Order {

  def clearUp(cart: Cart)
             (implicit is: IdentifierService,
             cr: CustomerRepository,
             ctx: EntityIOContext): Try[Order] = Try {
    val customer = cart.customer.get
    Order(
      OrderId(is.generate),
      StatusType.Enabled,
      OrderStatus.Pending,
      DateTime.now,
      customer.id,
      customer.name,
      customer.profile.postalAddress,
      customer.profile.contact,
      cart.cartItems.map {
       cartItem =>
        OrderItem.fromCartItem(OrderItemId(is.generate), cartItem)
      }
    )
  }

}

Repository.scala

trait Repository[ID <: Identifier[_], E <: Entity[ID]] {

  type This <: Repository[ID, E]

  type Ctx = EntityIOContext

  def existById(id: ID)(implicit ctx: Ctx): Try[Boolean]

  def resolve(id: ID)(implicit ctx: Ctx): Try[E]

  def store(entity: E)(implicit ctx: Ctx): Try[(This, E)]

  def deleteById(id: ID)(implicit ctx: Ctx): Try[(This, E)]

}