Solution

README.md

@@ -41,3 +41,16 @@ docker-compose run web rake db:create
 docker-compose run web rake db:migrate
 ```
 
+# To run tests
+
+## Unit tests
+
+```sh
+docker-compose run web rspec spec/lib --order rand -fd
+```
+
+## Integrated tests
+
+```sh
+docker-compose run web rspec spec/gateways spec/presenters spec/controllers --order rand -fd
+```

app/controllers/orders_controller.rb

@@ -0,0 +1,21 @@
+require './lib/orders/create_order_usecase'
+
+class OrdersController < ActionController::Base
+  def create
+    customer_gateway = CustomerGatewayDatabase.new
+    product_gateway = ProductGatewayDatabase.new
+    order_gateway = OrderGatewayDatabase.new
+    presenter = Orders::CreateOrderPresenterJson.new
+
+    CreateOrderUsecase.new(customer_gateway, product_gateway, order_gateway, presenter)
+      .execute(params[:customer_id], get_products_id_with_quantity)
+
+    render presenter.response
+  end
+
+  private
+
+  def get_products_id_with_quantity
+    params[:products_id_with_quantity].map{ |p| {product_id: p[:product_id].to_i, quantity: p[:quantity].to_f} }
+  end
+end

app/gateways/customer_gateway_database.rb

@@ -0,0 +1,7 @@
+require './lib/customers/gateways'
+
+class CustomerGatewayDatabase < CustomerGateway
+  def customer_exists?(customer_id)
+    Customer.exists?(customer_id)
+  end
+end

app/gateways/order_gateway_database.rb

@@ -0,0 +1,22 @@
+require './lib/orders/gateways'
+
+class OrderGatewayDatabase < OrderGateway
+  def save_order(customer_id, order_products)
+    order = Order.create(customer_id: customer_id)
+
+    for order_product in order_products
+      OrderProduct.create(
+        product_id: order_product.product_id,
+        quantity: order_product.quantity,
+        price: order_product.price,
+        order_id: order.id
+      )
+    end
+
+    return order.id
+  end
+
+  def get_orders_by_customer_id(customer_id)
+    return Order.where(customer_id: customer_id)
+  end
+end

app/gateways/product_gateway_database.rb

@@ -0,0 +1,14 @@
+require './lib/products/gateways'
+require './lib/products/exceptions'
+
+class ProductGatewayDatabase < ProductGateway
+  def find_products_by_ids(products_ids)
+    products = Product.where(id: products_ids)
+
+    products_ids_found = products.map(&:id)
+    products_ids_not_found = products_ids.select{ |product_id| products_ids_found.exclude?(product_id) }
+    raise ProductsNotFoundException.new(products_ids_not_found) if products_ids_not_found.length > 0
+
+    return products
+  end
+end

app/models/order.rb

@@ -1,2 +1,3 @@
 class Order < ApplicationRecord
+  has_many :order_products
 end

app/models/product.rb

@@ -1,2 +1,5 @@
 class Product < ApplicationRecord
+    def product_id
+        id
+    end
 end

app/presenters/orders/create_order_presenter_json.rb

@@ -0,0 +1,50 @@
+require './lib/orders/presenters'
+
+module Orders
+  class CreateOrderPresenterJson < CreateOrderPresenter
+    def initialize
+      @status = :bad_request
+      @errors = []
+      @order = {:order_id => nil, :total_price => nil}
+    end
+
+    def show_error_customer_not_found
+      @status = :not_found
+      @errors += ['Customer not found.']
+    end
+
+    def show_error_product_not_found(product_id)
+      @status = :not_found
+      @errors += ['Product not found: ' + product_id.to_s]
+    end
+
+    def show_order(order_id, total_price)
+      @status = :ok
+      @order[:order_id] = order_id
+      @order[:total_price] = total_price
+    end
+
+    def response
+      {
+        'status': @status,
+        'json': create_json_response
+      }
+    end
+
+    private
+
+    def create_json_response
+      if @errors.empty?
+        if @order[:order_id].nil?
+          json = {}
+        else
+          json = @order
+        end
+      else
+        json = {:errors => @errors}
+      end
+
+      json
+    end
+  end
+end

config/routes.rb

@@ -1,3 +1,3 @@
 Rails.application.routes.draw do
-  # For details on the DSL available within this file, see http://guides.rubyonrails.org/routing.html
+  post '/orders/', to: 'orders#create'
 end

docker-compose.yml

@@ -1,9 +1,11 @@
 version: '2'
 services:
   db:
-    image: postgres
+    image: postgres:9.6.2
+    ports:
+      - '5432'
     volumes:
-      - ./tmp/db:/var/lib/postgresql/data
+      - /var/lib/postgresql/data
   web:
     build: .
     command: bundle exec rails s -p 3000 -b '0.0.0.0'

lib/customers/gateways.rb

@@ -0,0 +1,3 @@
+class CustomerGateway
+  def customer_exists?(customer_id); end
+end

lib/orders/create_order_usecase.rb

@@ -0,0 +1,60 @@
+require './lib/orders/structs'
+require './lib/products/exceptions'
+require './lib/orders/order_entity'
+
+class CreateOrderUsecase
+  def initialize(customer_gateway, product_gateway, order_gateway, create_order_presenter)
+    @customer_gateway = customer_gateway
+    @product_gateway = product_gateway
+    @order_gateway = order_gateway
+    @presenter = create_order_presenter
+  end
+
+  def execute(customer_id, products_id_with_quantity)
+    return if not customer_exists?(customer_id)
+
+    products, has_error = find_products(products_id_with_quantity)
+    return if has_error
+
+    order_products = get_order_products(products, products_id_with_quantity)
+    total_price = OrderEntity.get_total_price(order_products)
+
+    order_id = @order_gateway.save_order(customer_id, order_products)
+    @presenter.show_order(order_id, total_price.round(2))
+  end
+
+  private
+
+  def customer_exists?(customer_id)
+    if not @customer_gateway.customer_exists?(customer_id)
+      @presenter.show_error_customer_not_found
+      return false
+    end
+
+    return true
+  end
+
+  def find_products(products_id_with_quantity)
+    begin
+      products_ids = products_id_with_quantity.map { |p| p[:product_id] }
+      return @product_gateway.find_products_by_ids(products_ids), false
+    rescue ProductsNotFoundException => ex
+      for product_id in ex.products_ids
+        @presenter.show_error_product_not_found(product_id)
+      end
+
+      return [], true
+    end
+  end
+
+  def get_order_products(products, products_id_with_quantity)
+    order_products = []
+
+    for product in products
+      quantity = products_id_with_quantity.select { |p| p[:product_id] == product.product_id }[0][:quantity]
+      order_products += [OrderProductStruct.new(product.product_id, quantity, product.price)]
+    end
+
+    return order_products
+  end
+end

lib/orders/gateways.rb

@@ -0,0 +1,4 @@
+class OrderGateway
+  def save_order(customer_id, order_products); end
+  def get_orders_by_customer_id(customer_id); end
+end

lib/orders/order_entity.rb

@@ -0,0 +1,13 @@
+class OrderEntity
+  class << self
+    def get_total_price(order_products)
+      total_price = 0
+
+      for order_product in order_products
+        total_price += order_product.price * order_product.quantity
+      end
+
+      return total_price
+    end
+  end
+end

lib/orders/presenters.rb

@@ -0,0 +1,10 @@
+class CreateOrderPresenter
+  def show_error_customer_not_found; end
+  def show_error_product_not_found(product_id); end
+  def show_order(order_id, total_price); end
+end
+
+class ShowOrdersByCustomerPresenter
+  def show_orders(orders); end
+  def error_customer_not_found(customer_id); end
+end

lib/orders/show_orders_by_customer_usecase.rb

@@ -0,0 +1,28 @@
+require './lib/orders/structs'
+require './lib/orders/order_entity'
+
+class ShowOrdersByCustomerUsecase
+  def initialize(customer_gateway, order_gateway, show_orders_by_customer_presenter)
+    @customer_gateway = customer_gateway
+    @order_gateway = order_gateway
+    @presenter = show_orders_by_customer_presenter
+  end
+
+  def execute(customer_id)
+    if not @customer_gateway.customer_exists?(customer_id)
+      @presenter.error_customer_not_found(customer_id)
+      return
+    end
+
+    orders = @order_gateway.get_orders_by_customer_id(customer_id)
+    response = ShowOrdersByCustomerResponse.new([])
+    for order in orders
+      total_price = OrderEntity.get_total_price(order.order_products)
+      response.orders_response += [
+        OrderResponse.new(order.order_id, order.customer_id, total_price, order.order_products)
+      ]
+    end
+
+    @presenter.show_orders(response)
+  end
+end

lib/orders/structs.rb

@@ -0,0 +1,8 @@
+ProductStruct = Struct.new(:product_id, :name, :price)
+
+OrderProductStruct = Struct.new(:product_id, :quantity, :price)
+
+OrderGatewayStruct = Struct.new(:order_id, :customer_id, :order_products)
+
+ShowOrdersByCustomerResponse = Struct.new(:orders_response)
+OrderResponse = Struct.new(:order_id, :customer_id, :total_price, :order_products)

lib/products/exceptions.rb

@@ -0,0 +1,8 @@
+class ProductsNotFoundException < StandardError
+  attr_reader :products_ids
+
+  def initialize(products_ids)
+    @products_ids = products_ids
+    super
+  end
+end

lib/products/gateways.rb

@@ -0,0 +1,3 @@
+class ProductGateway
+  def find_products_by_ids(products_ids); end
+end

spec/controllers/orders_controller_spec.rb

@@ -0,0 +1,18 @@
+require 'rails_helper'
+
+RSpec.describe OrdersController do
+  describe 'create order' do
+    it 'create order with products and customer' do
+      product = Product.create(price: 100.0)
+      customer = Customer.create()
+      products_id_with_quantity = [{product_id: product.id, quantity: 20}]
+
+      post :create, as: :json, customer_id: customer.id, products_id_with_quantity: products_id_with_quantity, format: :json
+
+      response_body = ActiveSupport::JSON.decode(response.body)
+      expect(response.status).to eq(200)
+      expect(response_body["order_id"]).to_not eq(nil)
+      expect(response_body["total_price"]).to eq("2000.0")
+    end
+  end
+end

spec/gateways/customer_gateway_database_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_helper'
+
+RSpec.describe CustomerGatewayDatabase do
+  let(:gateway) { described_class.new() }
+
+  describe '#customer_exists?' do
+    context 'when customer exists' do
+      it 'returns true' do
+        customer = Customer.create()
+
+        result = gateway.customer_exists?(customer.id)
+
+        expect(result).to be true
+      end
+    end
+
+    context 'when customer does not exists' do
+      it 'returns false' do
+        result = gateway.customer_exists?(123)
+
+        expect(result).to be false
+      end
+    end
+  end
+end