dominosjp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a8eff1dcad6edc6236af5a90239ecd2afd0cdc3
+  data.tar.gz: 3ca1d4888bb591523b1dbe3921e71ff6c3ec811f
+SHA512:
+  metadata.gz: 8c63d14703893d31846c4d2691b8c73ea49b5cda9ca69fa937cb40beff10e99a42820d562c8d0f7c50d15a47ff2e76f7796b73a9741f557e3c861dd913596793
+  data.tar.gz: 53dae35002494984757b89e65dbfda652ed6dfb26e0f9132741ee6948560076b33d5e7e8c84c297b80ec557e8c391678274b3ba307b09604984ea41e95e9149b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Mahdi Bchetnia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# DominosJP 🍕🛵🇯🇵
+🍕Domino's Pizza Japan CLI 🍕
+
+![](https://i.imgur.com/CRaTrSE.jpg)
+
+### Requirements
+
+- A [Domino's Pizza Japan](https://www.dominos.jp/eng/) account that you've ordered with at least once in the past
+
+### Install
+
+```bash
+$ gem install dominosjp
+```
+
+### Usage
+
+```bash
+$ dominosjp
+```
+and follow the instructions
+
+### Features
+
+- Order a pizza in less than a minute
+- Save your preferences for even faster ordering
+- Finds the best coupon for your order from your coupon box, by calculating the real value
+
+### Preferences
+
+Not really pizza-related, but by providing default values in a `.dominosjp.yml` file in your home directory you can skip most steps. See [.dominosjp.yml](blob/master/.dominosjp.yml) for examples.
+
+Note: All keys are optional. It even allows for partial credit card info.
+
+### Limitations/TODO
+
+(Prefixed by a difficulty estimation from 1 to 5)
+
+- (1) Allow for paying via cash (credit card-only now)
+- (5) Allow for selecting pizza toppings
+- (4) Allow for selecting pizza size/cut type/number of slices
+- (2) Allow for selecting sides (not only pizzas), (5) maybe even the special menu
+- (5) Extra: Pizza Tracking via the CLI, and hopefully automate the Mystery Deal
+
+### Contact
+
+[@inket](https://github.com/inket) / [@inket](https://twitter.com/inket) on Twitter / [mahdi.jp](https://mahdi.jp)

data/bin/dominosjp

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/dominosjp"
+
+begin
+  dominos = DominosJP.new
+  dominos.login
+  dominos.order
+rescue Interrupt
+  puts "Stopped by user"
+end

data/lib/dominosjp.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+require "colorize"
+require "highline"
+require "inquirer"
+require "nokogiri"
+
+require_relative "request"
+require_relative "preferences"
+require_relative "order_address"
+require_relative "order_coupon"
+require_relative "order_information"
+require_relative "order_payment"
+require_relative "order_review"
+require_relative "pizza"
+require_relative "pizza_selector"
+
+class DominosJP
+  attr_accessor :order_address, :order_information
+  attr_accessor :order_review
+  attr_accessor :order_coupon, :order_payment
+
+  def initialize(login_details = {})
+    @email = login_details[:email] || Preferences.instance.email
+    @password = login_details[:password]
+
+    self.order_address = OrderAddress.new
+    self.order_information = OrderInformation.new
+    self.order_review = OrderReview.new
+    self.order_coupon = OrderCoupon.new
+    self.order_payment = OrderPayment.new
+  end
+
+  def login
+    @email ||= Ask.input("Email")
+    @password ||= HighLine.new.ask("Password: ") { |q| q.echo = "*" }
+
+    Request.post(
+      "https://order.dominos.jp/eng/login/login/",
+      { "emailAccount" => @email, "webPwd" => @password },
+      expect: :redirect, failure: "Couldn't log in successfully"
+    )
+  end
+
+  def order
+    order_address.input
+    order_address.validate
+
+    order_information.input
+    order_information.validate
+    order_information.display
+    order_information.confirm
+
+    PizzaSelector.select_pizzas
+    # TODO: allow selecting sides
+
+    order_review.display
+
+    order_coupon.total_price_without_tax = order_review.total_price_without_tax
+    order_coupon.input
+    order_coupon.validate
+
+    order_review.display
+
+    order_payment.default_name = order_information.name
+    order_payment.input
+    order_payment.validate
+    order_payment.display
+
+    order_review.page = order_payment.page
+    order_review.display
+
+    order_payment.confirm
+  end
+end

data/lib/order_address.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+class OrderAddress
+  attr_accessor :address
+
+  def input
+    response = Request.get("https://order.dominos.jp/eng/receipt/",
+                           expect: :ok, failure: "Couldn't get order types page")
+
+    addresses = Addresses.from(response.body)
+    index = Ask.list "Choose an address", addresses.selection_list
+    self.address = addresses[index]
+  end
+
+  def validate
+    raise "Missing attributes" unless address
+
+    # Get the default parameters and add in the delivery address
+    params = default_params.merge("todokeSeq" => address.id)
+
+    Request.post("https://order.dominos.jp/eng/receipt/setReceipt", params,
+                 expect: :redirect, to: "https://order.dominos.jp/eng/receipt/input/",
+                 failure: "Couldn't set the delivery address")
+  end
+
+  private
+
+  def default_params
+    {
+      # Receipt method: 1=delivery, 3=pickup
+      "receiptMethod" => "1",
+      # Rest is untouched
+      "tenpoC" => "",
+      "jushoC" => "",
+      "kokyakuJushoBanchi" => "",
+      "banchiCheckBox" => "",
+      "buildNm" => "",
+      "buildCheckBox" => "",
+      "todokeShortNm" => "",
+      "kigyoNm" => "",
+      "bushoNm" => "",
+      "naisen" => "",
+      "targetYmd" => nil,
+      "targetYmdhm" => nil,
+      "gpsPinpointF" => false
+    }
+  end
+end
+
+class Addresses < Array
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+
+    Addresses.new(
+      doc.css(".l-section.m-addressSelect .addressSelect_content").map { |el| Address.new(el) }
+    )
+  end
+
+  def selection_list
+    map(&:list_item)
+  end
+end
+
+class Address
+  attr_accessor :id, :label, :address, :estimation
+
+  def initialize(element)
+    self.label = element.css(".addressSelect_labelName").text.strip
+    self.address = element.css(".addressSelect_information_address").text.strip
+    self.estimation = element.css(".time_content_text").text.strip
+    self.id = element.css("input[name=todokeSeq]").first["value"].strip
+  end
+
+  def list_item
+    [label, address, estimation].join("\n    ")
+  end
+end

data/lib/order_coupon.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+class OrderCoupon
+  attr_accessor :total_price_without_tax
+  attr_accessor :add_coupon
+  attr_accessor :coupon
+
+  def input
+    self.add_coupon = Ask.confirm "Add a coupon?"
+    return unless add_coupon
+
+    response = Request.get("https://order.dominos.jp/eng/coupon/use/",
+                           expect: :ok, failure: "Couldn't get coupons list")
+
+    coupons = Coupons.from(response.body, total_price_without_tax)
+    selected_coupon_index = Ask.list "Choose a coupon", coupons.selection_list
+    self.coupon = coupons[selected_coupon_index]
+  end
+
+  def validate
+    return unless add_coupon
+
+    unless coupon.usable?
+      puts "This coupon cannot be used."
+      return
+    end
+
+    Request.post("https://order.dominos.jp/eng/webapi/sides/setUserCoupon/", coupon.params,
+                 expect: :ok, failure: "Couldn't add coupon")
+  end
+end
+
+class Coupons < Array
+  def self.from(source, total_price_without_tax)
+    doc = Nokogiri::HTML(source)
+    coupons = doc.css("li").map { |item| Coupon.new(item, total_price_without_tax) }
+
+    # Sort coupons by real value, expiration date while deranking those that cannot be used (error)
+    coupons = [coupons.reject(&:error), coupons.select(&:error)].map do |coups|
+      coups.group_by(&:real_value).sort.reverse.map do |_real_value, same_value_coupons|
+        same_value_coupons.sort_by(&:expiry)
+      end
+    end.flatten
+
+    Coupons.new(coupons)
+  end
+
+  def selection_list
+    map(&:list_item)
+  end
+end
+
+class Coupon
+  attr_accessor :name, :expiry, :error, :couponcd, :couponseq, :expires_soon, :real_value
+
+  def initialize(item, total_price_without_tax)
+    name_element_text = item.css("h4").text
+    coupon_name = name_element_text.sub("\\", "¥").sub("Expires soon", "")
+    expires_soon = name_element_text.include?("Expires soon") ? "Expires soon" : ""
+
+    coupon_link = item.css(".jso-userCuponUse").first || {}
+
+    yen_value = coupon_name.scan(/¥(\d+)/).flatten.first.to_i
+    percent_value = coupon_name.scan(/(\d+)%/).flatten.first.to_i
+
+    if yen_value != 0
+      real_value = yen_value * 1.08 # 8% tax
+    elsif percent_value != 0
+      real_value = (total_price_without_tax / (100 / percent_value)) * 1.08 # 8% tax
+    end
+
+    error = item.css(".m-input__error").text
+    error = error && error.strip != "" ? "\n    #{error}" : nil
+
+    self.name = coupon_name
+    self.expiry = item.css(".m-entryPeriod").text.scan(/\d{4}-\d{2}-\d{2}/).first
+    self.error = error
+    self.couponcd = coupon_link["couponcd"]
+    self.couponseq = coupon_link["couponseq"]
+    self.expires_soon = expires_soon
+    self.real_value = real_value.to_i
+  end
+
+  def usable?
+    couponcd && couponseq
+  end
+
+  def params
+    { couponcd: couponcd, couponseq: couponseq }.compact
+  end
+
+  def list_item
+    "#{name.colorize(:blue)} (-¥#{real_value.to_s.colorize(:green)}) "\
+    "#{expires_soon.colorize(:yellow)} #{expiry} #{error.to_s.colorize(:red)}".strip
+  end
+end

data/lib/order_information.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+class OrderInformation
+  attr_accessor :name, :phone_number
+
+  def input
+    response = Request.get("https://order.dominos.jp/eng/receipt/input/",
+                           expect: :ok, failure: "Couldn't get information input page")
+
+    saved_name = Name.from(response.body)
+    phone_numbers = PhoneNumbers.from(response.body)
+
+    self.name = Preferences.instance.name || Ask.input("Name", default: saved_name)
+
+    self.phone_number = phone_numbers.find_number(Preferences.instance.phone_number)
+    unless phone_number
+      phone_number_index = Ask.list "Phone Number", phone_numbers.selection_list
+      self.phone_number = phone_numbers[phone_number_index]
+    end
+
+    @first_response = response
+  end
+
+  def validate
+    raise "Missing attributes" unless name && phone_number
+
+    # Get the default parameters and add in the client name and phone number
+    params = default_params.merge(
+      "kokyakuNm" => name,
+      "telSeq" => phone_number.value
+    )
+
+    @second_response = Request.post("https://order.dominos.jp/eng/receipt/confirm", params,
+                                    expect: :ok, failure: "Couldn't set your information") do |resp|
+      resp.body.include?("Order Type, Day&Time and Your Store")
+    end
+  end
+
+  def display
+    doc = Nokogiri::HTML(@second_response.body)
+    info = doc.css(".m-input__heading").map(&:text).
+           zip(doc.css(".section_content_table_td").map(&:text)).to_h
+    @page_params = doc.css("input[type=hidden]").map do |input|
+      [input["name"], input["value"]]
+    end.to_h
+
+    info.each { |title, value| puts "#{title.colorize(:blue)}: #{value}" }
+  end
+
+  def confirm
+    raise "Stopped by user" unless Ask.confirm "Continue?"
+
+    Request.post("https://order.dominos.jp/eng/receipt/complete", @page_params,
+                 expect: :redirect, to: "https://order.dominos.jp/eng/menu/",
+                 failure: "Couldn't validate your information")
+  end
+
+  private
+
+  def default_params
+    kokyaku_input = Nokogiri::HTML(@first_response.body).css("input[name=kokyakuC]").first
+    raise "Couldn't find client information" unless kokyaku_input
+
+    {
+      "kokyakuC" => kokyaku_input["value"],
+      # Rest is untouched
+      "errorMessage" => "",
+      "receiptMethod" => "1", # Receipt method again...
+      "deleteTelSeq" => "",
+      "telNoRadio" => "0",
+      "telNo" => ""
+    }
+  end
+end
+
+class Name
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+    input = doc.css("input[name=kokyakuNm]").first
+    raise "Couldn't get name field from information input page" unless input
+
+    input["value"]
+  end
+end
+
+class PhoneNumbers < Array
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+    numbers = doc.css("select[name=telSeq] > option").map { |option| PhoneNumber.new(option) }
+
+    if numbers.empty?
+      raise "Couldn't find any saved phone numbers in the information input page"
+    end
+
+    PhoneNumbers.new(numbers)
+  end
+
+  def find_number(number)
+    detect { |phone_number| phone_number.number == number }
+  end
+
+  def selection_list
+    map(&:list_item)
+  end
+end
+
+class PhoneNumber
+  attr_accessor :number, :value
+
+  def initialize(option)
+    self.number = option.text
+    self.value = option["value"]
+  end
+
+  def list_item
+    number
+  end
+end

data/lib/order_payment.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+require "credit_card_validations"
+require "credit_card_validations/string"
+
+class OrderPayment
+  attr_accessor :default_name
+  attr_accessor :note
+  attr_accessor :last_review
+  attr_accessor :page
+
+  def input
+    Request.get("https://order.dominos.jp/eng/regi/",
+                expect: :ok, failure: "Couldn't get payment page")
+
+    puts
+    puts
+    puts "#{"Payment information".colorize(:blue)} (you will be able to review your order later)"
+
+    @credit_card = Preferences.instance.credit_card || CreditCard.new
+    @credit_card.input(default_name)
+
+    self.note = Preferences.instance.note ||
+                Ask.input("Any special requests? (not food preparation requests)")
+  end
+
+  def validate
+    params = default_params.merge("bikoText" => note).merge(@credit_card.params)
+    response = Request.post("https://order.dominos.jp/eng/regi/confirm", params,
+                            expect: :ok, failure: "Couldn't submit payment information")
+    doc = Nokogiri::HTML(response.body)
+
+    token_input = doc.css("input[name='org.apache.struts.taglib.html.TOKEN']").first
+    raise "Couldn't get token for order validation" unless token_input && token_input["value"]
+
+    @insert_params = doc.css("input").map { |input| [input["name"], input["value"]] }.to_h
+
+    self.last_review = OrderLastReview.new(doc)
+    self.page = response.body
+  end
+
+  def display
+    puts last_review
+  end
+
+  def confirm
+    puts
+
+    unless Ask.confirm "Place order?"
+      puts "Stopped by user"
+      return
+    end
+
+    Request.post("https://order.dominos.jp/eng/regi/insert", @insert_params,
+                 expect: :redirect, to: %r{\Ahttps://order\.dominos\.jp/eng/regi/complete/\?},
+                 failure: "Order couldn't be placed for some reason :(")
+
+    puts
+    puts "Success!"
+    puts "Be sure to check the Domino's Pizza website in your browser "\
+         "to track your order status via the Pizza Tracker, and win a Mystery Deal coupon"
+  end
+
+  private
+
+  def default_params
+    {
+      "inquiryRiyoDStr" => "undefined",
+      "inquiryCardComCd" => "undefined",
+      "inquiryCardBrand" => "undefined",
+      "inquiryCreditCardNoXXX" => "undefined",
+      "inquiryGoodThruMonth" => "undefined",
+      "inquiryGoodThruYear" => "undefined",
+      "creditCard" => "undefined",
+      "receiptK" => "0",
+      "exteriorPayment" => "4",
+      "reuseCreditDiv" => "1",
+      "rakutenPayment" => "1",
+      "isDisplayMailmagaArea" => "true",
+      "isProvisionalKokyakuModalView" => "false",
+      "isProvisionalKokyaku" => "false"
+    }
+  end
+end
+
+class OrderLastReview
+  attr_accessor :doc
+
+  def initialize(doc)
+    self.doc = doc
+  end
+
+  def to_s
+    sections = doc.css(".l-section").map do |section|
+      next unless section.css(".m-heading__caption").count.positive?
+
+      section_name = section.css(".m-heading__caption").text.strip.gsub(/\s+/, " ").colorize(:green)
+      rows = section.css("tr").map do |row|
+        th = row.css(".m-input__heading").first || row.css("th").first
+        th_text = th.text.strip.gsub(/\s+/, " ").colorize(:blue)
+        td_text = row.css(".section_content_table_td").text.
+                  gsub(/ +/, " ").gsub(/\t+/, "").gsub(/(?:\r\n)+/, "\r\n").strip
+
+        "#{th_text}\n#{td_text}"
+      end
+
+      "\n#{section_name}\n#{rows.join("\n")}"
+    end
+
+    sections.join("\n")
+  end
+end
+
+class CreditCard
+  attr_accessor :number, :cvv
+  attr_accessor :expiration_date
+  attr_accessor :name_on_card
+
+  VALUES = {
+    visa: "00200",
+    mastercard: "00300",
+    jcb: "00500",
+    amex: "00400",
+    diners: "00100",
+    nicos: "00600"
+  }.freeze
+
+  def initialize(config = {})
+    info = config.map { |key, value| [(key.to_sym rescue key), value.to_s] }.to_h
+
+    self.number = info[:number] || ""
+    self.cvv = info[:cvv]
+    self.expiration_date = info[:expiration_date]
+    self.name_on_card = info[:name]
+  end
+
+  def input(default_name = nil)
+    loop do
+      until number.valid_credit_card_brand?(:visa, :mastercard, :jcb, :amex, :diners)
+        puts "Invalid card number" unless number == ""
+        self.number = Ask.input "Credit Card Number"
+      end
+
+      unless number.credit_card_brand == :diners
+        self.cvv ||= HighLine.new.ask("CVV: ") { |q| q.echo = "*" }
+      end
+
+      expiration_month, expiration_year = (expiration_date || "").split("/")
+      while !(1..12).cover?(expiration_month.to_i) || !(17..31).cover?(expiration_year.to_i)
+        self.expiration_date = Ask.input "Expiration Date (mm/yy)"
+        expiration_month, expiration_year = expiration_date.split("/")
+      end
+
+      self.name_on_card ||= Ask.input "Name on Card", default: default_name
+
+      break if valid?
+    end
+  end
+
+  def params
+    {
+      "existCreditCardF" => "",
+      "reuseCredit_check" => "1", # Seems to be 1 but it doesn't save the CC info
+      "cardComCd" => VALUES[number.credit_card_brand],
+      "creditCardNo" => number,
+      "creditCardSecurityCode" => cvv,
+      "creditCardSignature" => name_on_card,
+      "goodThruMonth" => expiration_date.split("/").first.rjust(2, "0"),
+      "goodThruYear" => expiration_date.split("/").last
+    }
+  end
+
+  def valid?
+    response = Request.post(
+      "https://order.dominos.jp/eng/webapi/regi/validate/creditCard/", params,
+      expect: :ok, failure: "Couldn't validate credit card info"
+    )
+
+    result = JSON.parse(response.body)
+    if result["errorDetails"]
+      puts result
+      return false
+    end
+
+    true
+  end
+end

data/lib/order_review.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+class OrderReview
+  attr_accessor :page
+  attr_accessor :total_price, :total_price_without_tax
+
+  def display
+    puts
+    puts
+    puts "Review Your Order".colorize(:red)
+
+    source = page || default_page
+
+    # Order items
+    puts OrderItems.from(source)
+    puts CouponItems.from(source)
+
+    # General information
+    puts retrieve_prices(source)
+  end
+
+  private
+
+  def retrieve_prices(source)
+    doc = Nokogiri::HTML(source)
+    total_price_element = doc.css(".totalPrice_taxin")
+    total_price_title = total_price_element.css("dt").text.strip.gsub(/\s+/, " ")
+    total_price_string = total_price_element.css("dd").text.strip.gsub(/\s+/, " ")
+
+    self.total_price = total_price_string.delete(",").scan(/¥(\d+)/).flatten.first.to_i
+    self.total_price_without_tax = total_price / 108 * 100 # 8% tax
+
+    "\n#{total_price_title}: #{total_price_string.colorize(:red)}\n"\
+      "#{doc.css(".totalPrice_tax").text}"
+  end
+
+  def default_page
+    Request.get("https://order.dominos.jp/eng/pizza/search/",
+                expect: :ok, failure: "Couldn't get pizza list page").body
+  end
+end
+
+class OrderItems < Array
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+    order_items = doc.css(".m-side_orderItems li").map { |item| OrderItem.new(item) }
+    OrderItems.new(order_items)
+  end
+
+  def to_s
+    map(&:to_s).join("\n")
+  end
+end
+
+class OrderItem
+  attr_accessor :name, :details
+
+  def initialize(item)
+    self.name = item.css(".orderItems_item_name").first.text.strip.gsub(/\s+/, " ")
+    # TODO: Get toppings list
+
+    details_element = item.css(".orderItems_item_detail")
+    details_dt = details_element.css("dt").map { |t| t.text.strip.gsub(/\s+/, " ") }
+    details_dd = details_element.css("dd").map { |t| t.text.strip.gsub(/\s+/, " ") }
+
+    self.details = details_dt.zip(details_dd).to_h
+    details["Price"] = item.css(".orderItems_item_price").text.strip.gsub(/\s+/, " ")
+  end
+
+  def to_s
+    deets = details.map { |key, value| "  #{key}: #{value}" }.join("\n")
+    "#{name.colorize(:blue)}\n#{deets}"
+  end
+end
+
+class CouponItems < Array
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+    coupon_items = doc.css(".m-side_useCoupon li").map { |item| CouponItem.new(item) }
+
+    CouponItems.new(coupon_items)
+  end
+
+  def to_s
+    return unless count.positive?
+    "\nCoupons".colorize(:green)
+  end
+end
+
+class CouponItem
+  attr_accessor :name, :value
+
+  def initialize(item)
+    self.name = item.css(".useCoupon_coupons_name").text.strip.gsub(/\s+/, " ").sub("\\", "¥")
+    self.value = item.css("dd span").text.strip
+  end
+
+  def to_s
+    "  #{name} #{value.colorize(:green)}"
+  end
+end

data/lib/pizza.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+class Pizzas < Array
+  def self.from(source)
+    doc = Nokogiri::HTML(source)
+
+    Pizzas.new(
+      doc.css(".jso-dataLayerProductClick").map { |el| Pizza.new(el) }.select(&:valid?)
+    )
+  end
+
+  def selection_list
+    map(&:list_item)
+  end
+end
+
+class Pizza
+  attr_accessor :id, :category_id, :url, :name, :description, :allergen_warning
+  attr_accessor :size, :crust
+
+  def initialize(element)
+    return unless element["iname"]
+
+    link = element["href"]
+    parts = link.split("/")
+    pizza_id = parts.pop
+    category_id = parts.pop
+    # some_other_number = parts.pop # TODO: figure out what this is
+
+    description = element.css(".menu_itemList_item_text").first
+    description = description.text if description
+
+    allergen_warning = element.css(".js-menuSetHeight_allergen").first
+    allergen_warning = allergen_warning.text if allergen_warning
+
+    self.url = "https://order.dominos.jp#{link}"
+    self.id = pizza_id # shohinC1
+    self.category_id = category_id # categoryC
+    self.name = element["iname"]
+    self.description = description
+    self.allergen_warning = allergen_warning
+  end
+
+  def valid?
+    url != nil
+  end
+
+  def available_sizes
+    @available_sizes ||=
+      detail_page_content.css("#detail_selectSize .m-input__radio").map do |option|
+        Pizza::Size.new(option)
+      end
+  end
+
+  def available_crusts
+    @available_crusts ||=
+      detail_page_content.css("#detail_selectCrust .m-input__radio").map do |option|
+        Pizza::Crust.new(option)
+      end
+  end
+
+  def params
+    {
+      "shohinC1" => id,
+      "categoryC" => category_id,
+      "sizeC" => size.value,
+      "crustC" => crust.value
+    }
+  end
+
+  def list_item
+    allergen = allergen_warning || ""
+
+    "#{name.colorize(:blue)} "\
+    "#{allergen.strip.colorize(:yellow)}\n  "\
+    "#{description.gsub(",", ", ").gsub(")", ") ")}\n"
+  end
+
+  private
+
+  def detail_page_content
+    @detail_page_content ||= Nokogiri::HTML(
+      Request.get(url, expect: :ok, failure: "Couldn't open pizza detail page").body
+    )
+  end
+end
+
+class Pizza
+  class Size
+    attr_accessor :text, :value
+
+    def initialize(option)
+      self.text = option.text.strip
+      self.value = option.css("input[name=sizeC]").first["value"]
+    end
+
+    def list_item
+      text.gsub(/\s+/, " ").sub("人 /", "人/").sub("cm ", "cm\n  ").sub(" ¥", "\n  ¥").strip
+    end
+  end
+
+  class Crust
+    attr_accessor :text, :value
+
+    def initialize(option)
+      self.text = option.css(".caption_radio").first.text.strip
+      self.value = option.css("input[name=crustC]").first["value"]
+    end
+
+    def list_item
+      text.gsub(/\s+/, " ").strip
+    end
+  end
+end

data/lib/pizza_selector.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+class PizzaSelector
+  def self.select_pizzas
+    response = Request.get("https://order.dominos.jp/eng/pizza/search/",
+                           expect: :ok, failure: "Couldn't get pizza list page")
+
+    pizzas = Pizzas.from(response.body)
+
+    cli = HighLine.new
+    choices = pizzas.selection_list
+
+    loop do
+      puts "-" * 42
+      cli.choose do |menu|
+        menu.prompt = "Add a pizza via number:"
+        menu.choices(*(choices + ["Cancel"])) do |choice|
+          index = choices.index(choice)
+
+          if index && index < choices.count
+            selected_pizza = pizzas[index]
+            add_pizza(customize_pizza(selected_pizza))
+          end
+        end
+        menu.default = "Cancel"
+      end
+
+      break unless Ask.confirm "Add another pizza?"
+    end
+  end
+
+  def self.customize_pizza(pizza)
+    puts "#{"→".colorize(:green)} #{pizza.name.colorize(:blue)}"
+
+    # TODO: Allow toppings selection
+
+    # Choosing the size
+    selected_size_index = Ask.list "Choose the size", pizza.available_sizes.map(&:list_item)
+    pizza.size = pizza.available_sizes[selected_size_index]
+
+    # Choosing the crust
+    selected_crust_index = Ask.list "Choose the crust", pizza.available_crusts.map(&:list_item)
+    pizza.crust = pizza.available_crusts[selected_crust_index]
+
+    pizza
+  end
+
+  def self.add_pizza(pizza)
+    params = pizza.params
+    params = params.merge(
+      "pageId" => "PIZZA_DETAIL",
+      # TODO: Allow cut type, number of slices and quantity selection
+      "cutTypeC" => 1, # Type of cut: 1=Round Cut
+      "cutSu" => 8, # Number of slices
+      "figure" => 1 # Quantity
+    )
+
+    response = Request.post(
+      "https://order.dominos.jp/eng/cart/add/pizza/", params,
+      expect: :redirect, to: %r{\Ahttps?://order\.dominos\.jp/eng/cart/added/\z},
+      failure: "Couldn't add the pizza you selected"
+    )
+
+    # For some reason we need to GET this URL otherwise it doesn't count as added <_<
+    Request.get(response["Location"],
+                expect: :redirect, to: "https://order.dominos.jp/eng/cart/",
+                failure: "Couldn't add the pizza you selected")
+  end
+end

data/lib/preferences.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require "yaml"
+
+class Preferences
+  include Singleton
+
+  attr_accessor :email, :name, :phone_number, :credit_card, :note
+
+  def initialize
+    preferences_path = File.join(Dir.home, ".dominosjp.yml")
+    return unless File.exist?(preferences_path)
+
+    prefs = YAML.safe_load(File.read(preferences_path)).map { |k, v| [(k.to_sym rescue k), v] }.to_h
+
+    self.email = prefs[:email] if prefs[:email]
+    self.name = prefs[:name] if prefs[:name]
+    self.phone_number = prefs[:phone_number] if prefs[:phone_number]
+    self.credit_card = CreditCard.new(prefs[:credit_card]) if prefs[:credit_card]
+    self.note = prefs[:note] if prefs[:note]
+  end
+end

data/lib/request.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+require "net/http"
+require "http-cookie"
+require "singleton"
+
+class Request
+  include Singleton
+
+  def self.get(url, options = {})
+    request = Net::HTTP::Get.new(URI(url))
+
+    Request.instance.perform(
+      request,
+      block_given? ? options.merge(proc: proc { |res| yield(res) }) : options
+    )
+  end
+
+  def self.post(url, form_data, options = {})
+    request = Net::HTTP::Post.new(URI(url))
+    request.set_form_data(form_data)
+
+    Request.instance.perform(
+      request,
+      block_given? ? options.merge(proc: proc { |res| yield(res) }) : options
+    )
+  end
+
+  def initialize
+    @base_uri = URI("https://order.dominos.jp/eng/")
+    @http = Net::HTTP.start(@base_uri.host, @base_uri.port, use_ssl: true)
+    @jar = HTTP::CookieJar.new
+  end
+
+  def perform(request, options)
+    request["Cookie"] = cookies_value
+    response = @http.request(request)
+
+    save_cookies(response)
+    parse_options(options, response)
+
+    response
+  end
+
+  private
+
+  def cookies_value
+    HTTP::Cookie.cookie_value(@jar.cookies(@base_uri))
+  end
+
+  def save_cookies(response)
+    response.get_fields("Set-Cookie").each do |value|
+      @jar.parse(value, @base_uri)
+    end
+  end
+
+  def parse_options(options, response)
+    validate_status(options, response) if options[:expect]
+    validate_block(options, response) if options[:proc]
+  end
+
+  def validate_status(options, response)
+    expectation, redirect, failure = options.values_at(:expect, :to, :failure)
+    expectation = { ok: 200, redirect: 302 }[expectation] if expectation.is_a?(Symbol)
+
+    correct_status = (response.code.to_i == expectation)
+    correct_location = redirect.nil? ||
+                       (redirect == response["Location"]) ||
+                       (redirect.is_a?(Regexp) && redirect.match(response["Location"]))
+
+    unless correct_status && correct_location
+      failure_message =
+        failure ||
+        "Expected a different server response. "\
+        "(expected: #{options} / actual: #{response.code}[#{response["Location"]}])"
+
+      puts failure_message.colorize(:red)
+      raise failure_message
+    end
+  end
+
+  def validate_block(options, response)
+    expectation, failure = options.values_at(:proc, :failure)
+
+    unless expectation.call(response)
+      failure_message = failure || "Expected a different server response. "
+
+      puts failure_message.colorize(:red)
+      raise failure_message
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+class DominosJP
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: dominosjp
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mahdi Bchetnia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: credit_card_validations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: http-cookie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: inquirer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+description: "A ruby gem for ordering Domino's Pizza in Japan via CLI \U0001F355"
+email:
+- injekter@gmail.com
+executables:
+- dominosjp
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/dominosjp
+- lib/dominosjp.rb
+- lib/order_address.rb
+- lib/order_coupon.rb
+- lib/order_information.rb
+- lib/order_payment.rb
+- lib/order_review.rb
+- lib/pizza.rb
+- lib/pizza_selector.rb
+- lib/preferences.rb
+- lib/request.rb
+- lib/version.rb
+homepage: https://github.com/inket/dominosjp
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: dominosjp
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: "Order Domino's Pizza Japan via CLI \U0001F355"
+test_files: []