shake_the_counter 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe41e0c19cf289a649602db970923a37029ced29
+  data.tar.gz: 912e1746cc0658f55857c34fbf0fbb1312bddf3a
+SHA512:
+  metadata.gz: 98ca515e9ef967e09028b2dba61b355d0c23f1ab79255c619796f623b0a4b1cf7792b270ef03aedb3a38ca2c0ce21b576e5a1f4170c7d357302e5665f3fb3dd3
+  data.tar.gz: cc1a4ac5286fa00e6d679274bbfaa4c07ca37ca85384db9c0bb868a1d4cbd12cd311f70fb84bb2ceb3261aac32bc67cdb90829a228d53427fe05ae0c22b3ce64

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in shake_the_counter.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    shake-the-counter (0.1.0)
+      json
+      rest-client
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.3)
+    domain_name (0.5.20170404)
+      unf (>= 0.0.5, < 1.0.0)
+    http-cookie (1.0.3)
+      domain_name (~> 0.5)
+    json (2.1.0)
+    mime-types (3.1)
+      mime-types-data (~> 3.2015)
+    mime-types-data (3.2016.0521)
+    netrc (0.11.0)
+    rake (10.5.0)
+    rest-client (2.0.2)
+      http-cookie (>= 1.0.2, < 2.0)
+      mime-types (>= 1.16, < 4.0)
+      netrc (~> 0.8)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.7.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  shake-the-counter!
+
+BUNDLED WITH
+   1.16.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Henk Meijer
+
+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,131 @@
+# ShakeTheCounter
+[![Gem Version](https://badge.fury.io/rb/shake_the_counter.svg)](https://badge.fury.io/rb/shake_the_counter)
+[![Dependency Status](https://gemnasium.com/henkm/shake_the_counter.svg)](https://gemnasium.com/henkm/shake_the_counter)
+[![Code Climate](https://codeclimate.com/github/henkm/shake_the_counter/badges/gpa.svg)](https://codeclimate.com/github/henkm/shake_the_counter)
+
+
+This gem works as a simple Ruby wrapper for the Shake The Counter API. At this point, only a limited number of options is implemented. To be more precise: only enough functionality is implemented to:
+- Authenticate
+- Get events and details from a `Client`
+- Make a reservation which is already marked as paid
+- Receive barcodes in return
+- Cancel a reservation
+
+Instead of working with JSON, you work with Ruby Classes and intuitive methods.
+
+**This gem communicates with the STC.Tickets TicketAPI Version 1.0** 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'shake_the_counter'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install shake_the_counter
+
+## Original documentation
+This gem is based on V1 of the API according to the documentation found here: [https://ticketstest.ticketcounter.nl/swagger/ui/index](https://ticketstest.ticketcounter.nl/swagger/ui/index).
+
+This gem tries to be intuitive and Object Oriented. The naming conventions between the original API and this Ruby implementation are identical. So we have these classes:
+
+`Client` > `Event` > `Performance` > `Section` > `PriceType`
+
+Please note that only parts of the original API are 'native' implemented. For example: `@client.events.first` will return a `<ShakeTheCounter::Event>` object with native methods like `name` and `key`, but some fields are left out. You can access all the fields by requesting the `raw_data` attribte, which has the entire original API response stored as JSON.
+
+## Implemented functions
+- [x] Configuration via simple config
+- [x] Authentication
+- [x] Work with a `Client` that is automatically authenticated
+- [x] Get subsequent `events > performances > sections > price_types`
+- [x] Make a reservation with minimal options
+- [ ] Use coupons / discount codes
+- [ ] Make reservations with extra options
+- [ ] Events that require date or seat selecting
+- [ ] Handle capacity (at this point, we assume that each ticket is always available with no limitation.
+- [x] Cancel a reservation
+- [ ] Functions from the Subscriptions API
+- [ ] Functions from the Statistics API
+- [ ] Functions from the Reseller API
+
+## Configuration
+
+First, obtain an API key from Shake The Counter. Set it up like this:
+
+To use this gem in a Rails project:
+```ruby
+# config/development.rb
+config.shake_the_counter.environment	= "test"
+config.shake_the_counter.refresh_token	= "MY-REFRESH-TOKEN"
+config.shake_the_counter.client_id		= "123-my-client-id-xyz"
+config.shake_the_counter.language_code	= "nl-NL"
+config.shake_the_counter.client_secret	= "client-secret-goes-here"
+```
+
+
+## Full example 
+The example below follows the 'Normal flow to order tickets' as described in the `Getting started with the tickets Api` section of the API Documentation.
+
+```ruby
+# setup a client
+@client = ShakeTheCounter::Client.new # when called without arguments, credentials will come from configuration 
+
+# get a list if events for client
+@events = @client.events
+# => [<ShakeTheCounter::Event @name="Event 1" @key="xxx">, <ShakeTheCounter::Event @name="Event 2" @key="yyy">]
+
+# get a list of performances
+@performances = @events.first.performances
+
+# get a list of sections
+@sections = @perfomances.first.sections
+
+# The above logic can also be a one-liner:
+# @sections = @client.events.first.performances.first.sections
+
+# get the prices for a givens section
+@section = @sections.first
+@price_types = @section.price_types
+@price_type.first # => <ShakeTheCounter::PriceType @key="xxx" @name="Ticket" @price=6.0 [...]>
+
+# make a reservation
+price_type_list = [{
+  PriceKey: @price_types.first.price_key,
+  NrOfSeats: 2
+}]
+@reservation = @section.make_reservation(price_type_list: price_type_list, first_name: 'Joe', last_name: 'Sixpack', email: 'jack@example.com')
+# => <ShakeTheCounter::Reservation>
+
+# send a message that we started payment
+@client.start_payment(@reservation.key)
+# => true
+
+# confirm the reservation
+@client.confirm_reservation(reservation_key: @reservation.key, payment_method: 'API Test', amount_paid: 12.0)
+# => [<ShakeTheCounter::Ticket @ticket_code="12345566">, <ShakeTheCounter::Ticket @ticket_code="12345567">]
+
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/henkm/shake-the-counter.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+This gem is made with love by the smart people at [Eskes Media B.V.](https://www.eskesmedia.nl) and [DagjeWeg.NL Tickets](https://www.dagjewegtickets.nl)
+Shake The Counter is not involved with this project and has no affiliation with Eskes Media B.V.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "shake_the_counter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/shake_the_counter.rb

@@ -0,0 +1,45 @@
+# require dependencies
+require 'rest_client'
+require 'json'
+require 'date'
+
+# require gem files
+require "shake_the_counter/version"
+require "shake_the_counter/shake_the_counter_error"
+require "shake_the_counter/config"
+require "shake_the_counter/engine" if defined?(Rails) && Rails::VERSION::MAJOR.to_i >= 3
+
+# require API parts
+require "shake_the_counter/api"
+require "shake_the_counter/authentication"
+require "shake_the_counter/client"
+require "shake_the_counter/event"
+require "shake_the_counter/performance"
+require "shake_the_counter/section"
+require "shake_the_counter/price_type"
+require "shake_the_counter/reservation"
+require "shake_the_counter/contact"
+require "shake_the_counter/ticket"
+
+
+module ShakeTheCounter
+
+  # For testing purpose only: set the username and password
+  # in environment variables to make the tests pass with your test
+  # credentials.
+  def self.set_credentials_from_environment
+    Config.environment = :test
+    Config.verbose = true
+  end
+
+end
+
+class String
+  def underscore
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end

data/lib/shake_the_counter/api.rb

@@ -0,0 +1,86 @@
+module ShakeTheCounter
+
+  # The communication layer implements all the methods available in the ShakeTheCounter API
+  # https://ticketstest.ticketcounter.nl/swagger/ui/index
+  class API
+
+    # 
+    # Returns the API endpoint to use
+    # 
+    # @return [type] [description]
+    def self.endpoint
+      if ShakeTheCounter::Config.environment.to_s == "test"
+        "https://apitest.shakethecounter.com"
+      else
+        "https://api.shakethecounter.com"
+      end
+    end
+
+
+    # 
+    # Returns the complete API URL 
+    # 
+    def self.url(path)
+      # Don't change the path if it already is a full url
+      if path.include?('http')
+        return path
+      else
+        "#{endpoint}/api/v#{ShakeTheCounter::Config.version}/#{path}"
+      end
+    end
+
+    # 
+    # Makes a HTTP POST call to the endpoint en returns the response
+    # 
+    # @param request_body [type] [description]
+    # @param request_identifier [type] [description]
+    # 
+    # @return OpenStruct object with nested methods.
+    def self.call(path, http_method: :get, body: {}, header: {})
+      values = body
+      unless header[:content_type]
+        if body && body != {}
+          header[:content_type] = "application/json" 
+        else
+          # blank body requires no JSON
+          header[:content_type] = "application/x-www-form-urlencoded" 
+        end
+      end
+
+      begin
+        if ShakeTheCounter::Config.verbose
+          puts "Calling #{http_method.upcase} to #{url(path)}"
+          puts "Header: #{header.to_json}"
+          puts "Body:"
+          puts values.to_json
+        end
+        if http_method == :post
+          response = RestClient.post url(path), values, header
+        else
+          response = RestClient.get url(path), header
+        end
+      rescue RestClient::ExceptionWithResponse => e
+        raise ShakeTheCounterError.new "#{e} #{e.response}"
+      end
+      if ShakeTheCounter::Config.verbose
+        puts "Result:\n#{response.inspect}"
+      end
+      if response.body != ''
+        object =  JSON.parse(response.body)
+      else
+        object = response
+      end
+      return object
+    end
+
+    # 
+    # Checks the connection
+    # GET /api/v1/ping
+    # 
+    def self.ping
+      call("ping", http_method: :get)
+    end
+
+
+  end
+end

data/lib/shake_the_counter/authentication.rb

@@ -0,0 +1,64 @@
+module ShakeTheCounter
+
+  # This class handles the login logic.
+  # Shake The Counter uses OAuth
+  # 
+  # A HTTP POST request must be done to https://apitest.shakethecounter.com/token 
+  # (the authorization server) with the following information:
+  # Header Content-Type must be set to application/form-url-encoded
+  class Authentication
+
+    # 
+    # Renews the access token from the refresh token.
+    # https://auth0.com/learn/refresh-tokens/
+    # 
+    # body: 
+    # grant_type=refresh_token&client_id=clientid&client_secret=clientsecret&refresh_token=refreshToken
+    # 
+    # @return String access_token
+    def self.renew_access_token(client_id: '', client_secret: '', refresh_token: '')
+      body = {
+        grant_type: "refresh_token",
+        client_id: client_id,
+        client_secret: client_secret,
+        refresh_token: refresh_token
+      }
+      result = ShakeTheCounter::API.call(
+        "#{ShakeTheCounter::API.endpoint}/token",
+        http_method: :post,
+        body: body,
+        header: {content_type: "application/x-www-form-urlencoded"}
+      )
+    end
+
+
+
+    # 
+    # Gets the authentication_token and refresh_token
+    # from a username and password.
+    # 
+    # body: 
+    # grant_type=password&client_id=clientid&client_secret=clientsecret&username=username&password=password
+    # 
+    # @return OpenStruct containing authentication_token and refresh_token
+    def self.get_access_token(client_id: '', client_secret: '', username: '', password: '')
+      body = {
+        grant_type: "password",
+        client_id: client_id,
+        client_secret: client_secret,
+        username: username,
+        password: password
+      }
+      header = { content_type: "application/x-www-form-urlencoded" }
+      result = ShakeTheCounter::API.call(
+        "#{ShakeTheCounter::API.endpoint}/token",
+        http_method: :post,
+        header: header,
+        body: body
+      )
+    end
+
+  end
+
+
+end

data/lib/shake_the_counter/client.rb

@@ -0,0 +1,136 @@
+module ShakeTheCounter
+
+  # Sets up a client to work with
+  class Client
+    attr_accessor :refresh_token
+    attr_accessor :id
+    attr_accessor :secret
+    attr_accessor :language_code
+
+
+    # 
+    # There are two ways to setup a new client:
+    # 1. Initialize with options `(Client.new(client_id: x)`)
+    # 2. Initilize without options, get options from config
+    # 
+    def initialize(args=nil)
+      if args.nil?
+        init! 
+        reset!
+      else
+        args.each do |key,value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+    end
+
+    # Set's the default value's
+    # @return [Hash] configuration options
+    def init!
+      @defaults = {
+        :@refresh_token => ShakeTheCounter::Config.refresh_token,
+        :@id            => ShakeTheCounter::Config.client_id,
+        :@secret        => ShakeTheCounter::Config.client_secret,
+        :@language_code => ShakeTheCounter::Config.language_code,
+      }
+    end
+
+    # Resets the value's to there previous value (instance_variable)
+    # @return [Hash] configuration options
+    def reset!
+      @defaults.each { |key, value| instance_variable_set(key, value) }
+    end
+
+    # 
+    # Retrieves a new authentication token to use for this client
+    # or reuse the same one from memory.
+    # 
+    def access_token
+      @access_token ||= ShakeTheCounter::Authentication.renew_access_token(client_id: id, client_secret: secret, refresh_token: refresh_token)["access_token"]
+    end
+
+
+    # 
+    # Make an API with access_token
+    # 
+    def call(path, http_method: :get, body: {}, header: {})
+      # add bearer token to header
+      header[:authorization] = "Bearer #{access_token}"
+      return ShakeTheCounter::API.call(path, http_method: http_method, body: body, header: header)
+    end
+
+    # 
+    # Fetches a list of events for this client
+    #  /api/v1/events/available/{languageCode}
+    # 
+    # @return Array
+    def events
+      return @events if @events
+      @events = []
+      path = "events/available/#{language_code}"
+      result = call(path, http_method: :get)
+      for event in result
+        @events << ShakeTheCounter::Event.new(event, client: self)
+      end
+      return @events
+    end
+
+    # 
+    # Find a reservation
+    # GET /api/v1/reservation/{reservationKey}
+    # 
+    # @return Reservation
+    def find_reservation(key)
+      path = "reservation/#{key}"
+      result = call(path, http_method: :get)
+      reservation = ShakeTheCounter::Reservation.new(result)
+      return reservation
+    end
+    alias_method :reservation, :find_reservation
+
+    # 
+    # Send a message to STC that a payment
+    # has started.
+    # 
+    # @return String status
+    def start_payment(reservation_key)
+      path = "reservation/#{reservation_key}/payment"
+      result = call(path, http_method: :post)
+      if result.code.to_i == 200
+        return true
+      else
+        raise ShakeTheCounterError.new "Payment failed"
+      end
+    end
+
+
+    # Confirm the reservation and receive tickets
+    # /api/v1/reservation/{reservationKey}/confirm
+    # 
+    # @return True (or error)
+    def confirm_reservation(reservation_key: '', payment_method: '', amount_paid: nil)
+
+      # step 1: confirm
+      path = "reservation/#{reservation_key}/confirm"
+      body = {
+        PaymentMethod: payment_method,
+        AmountPaid: amount_paid
+      }
+      call(path, http_method: :post, body: body.to_json)
+
+      # step 2: get tickets
+      # GET /api/v1/reservation/{reservationKey}/tickets
+      path = "reservation/#{reservation_key}/tickets"
+      result = call(path, http_method: :get)
+
+      # define new list
+      list = []
+
+      for ticket in result
+        list << ShakeTheCounter::Ticket.new(ticket)
+      end
+      return list
+    end
+
+  end
+end

data/lib/shake_the_counter/config.rb

@@ -0,0 +1,44 @@
+#
+# Configuration object for storing some parameters required for making transactions
+#
+module ShakeTheCounter::Config
+  class << self
+    attr_accessor :client_id
+    attr_accessor :client_secret
+    attr_accessor :refresh_token
+    attr_accessor :environment
+    attr_accessor :language_code
+    attr_accessor :version
+    attr_accessor :verbose # if set, give more output in the log/console
+
+    # Set's the default value's to nil and false
+    # @return [Hash] configuration options
+    def init!
+      @defaults = {
+        :@refresh_token => ENV["STC_REFRESH_TOKEN"],
+        :@client_id     => ENV["STC_CLIENT_ID"],
+        :@client_secret => ENV["STC_CLIENT_SECRET"],
+        :@language_code => "nl-NL",
+        :@environment => 'test',
+        :@version => 1,
+        :@verbose => false,
+      }
+    end
+
+    # Resets the value's to there previous value (instance_variable)
+    # @return [Hash] configuration options
+    def reset!
+      @defaults.each { |key, value| instance_variable_set(key, value) }
+    end
+
+    # Set's the new value's as instance variables
+    # @return [Hash] configuration options
+    def update!
+      @defaults.each do |key, value|
+        instance_variable_set(key, value) unless instance_variable_defined?(key)
+      end
+    end
+  end
+  init!
+  reset!
+end

data/lib/shake_the_counter/contact.rb

@@ -0,0 +1,15 @@
+module ShakeTheCounter
+
+  # Sets up a contact object
+  class Contact
+
+    attr_accessor :key
+    attr_accessor :raw_data
+
+    def initialize(args={}, performance: nil)
+      self.key = args["ContactKey"]
+      self.raw_data = args
+    end
+
+  end
+end

data/lib/shake_the_counter/engine.rb

@@ -0,0 +1,13 @@
+module ShakeTheCounter
+  #
+  # Simpel extend on the +Rails::Engine+ to add support for a new config section within
+  # the environment configs
+  #
+  # @example default
+  #   # /config/environments/development.rb
+  # config.shake_the_counter.environment  = "test"
+  #
+  class Engine < Rails::Engine
+    config.shake_the_counter = ShakeTheCounter::Config
+  end
+end

data/lib/shake_the_counter/event.rb

@@ -0,0 +1,41 @@
+module ShakeTheCounter
+
+  # Sets up an event object
+  class Event
+    attr_accessor :key
+    attr_accessor :name
+    attr_accessor :performer
+    attr_accessor :tagline
+    attr_accessor :blocked_countries_for_sales
+    attr_accessor :rating
+    attr_accessor :review_count
+    attr_accessor :currency
+    attr_accessor :lowest_price
+    attr_accessor :performances
+    attr_accessor :raw_data
+    attr_accessor :client
+
+
+    # Sets up a new event
+    # 
+    def initialize(args={}, client: nil)
+      self.client = client
+      self.key = args["EventKey"]
+      self.name = args["EventName"]
+      self.performer = args["Performer"]
+      self.tagline = args["Tagline"]
+      self.blocked_countries_for_sales = args["BlockedCountriesForSales"]
+      self.rating = args["Rating"]
+      self.review_count = args["ReviewCount"]
+      self.currency = args["Currency"]
+      self.lowest_price = args["LowestPrice"]
+      self.performances = []
+      for perf in args["Performances"]
+        self.performances << ShakeTheCounter::Performance.new(perf, event: self)
+      end
+      self.raw_data = args
+      
+    end
+
+  end
+end

data/lib/shake_the_counter/performance.rb

@@ -0,0 +1,41 @@
+module ShakeTheCounter
+
+  # Sets up a performance object
+  class Performance
+
+    attr_accessor :key
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :external_performance_id
+    attr_accessor :raw_data
+    attr_accessor :event
+
+    # Sets up a new event
+    # 
+    def initialize(args={}, event: nil)
+      self.key = args["PerformanceKey"]
+      self.name = args["PerformanceName"]
+      self.description = args["PerformanceDescription"]
+      self.external_performance_id = args["ExternalPerformanceID"]
+      self.raw_data = args
+      self.event = event
+    end
+
+    # 
+    # GET /api/v1/event/{eventKey}/performance/{performanceKey}/sections/{languageCode}
+    # Get available sections, pricetypes and prices of the selected performance
+    # 
+    # @return Array of sections
+    def sections
+      return @sections if @sections
+      @sections = []
+      path = "event/#{event.key}/performance/#{key}/sections/#{event.client.language_code}"
+      result = event.client.call(path, http_method: :get)
+      for section in result
+        @sections << ShakeTheCounter::Section.new(section, performance: self)
+      end
+      return @sections
+    end
+
+  end
+end

data/lib/shake_the_counter/price_type.rb

@@ -0,0 +1,37 @@
+module ShakeTheCounter
+
+  # Sets up a PriceType
+  class PriceType
+
+    attr_accessor :key
+    attr_accessor :price_key
+    attr_accessor :product_code
+    attr_accessor :name
+    attr_accessor :ticket_valid_from
+    attr_accessor :ticket_valid_to
+    attr_accessor :phone_number_required
+    attr_accessor :full_address_required
+    attr_accessor :price
+    attr_accessor :requires_capacity_slot
+
+    attr_accessor :section
+    attr_accessor :raw_data
+
+    # Sets up a new price type
+    # 
+    def initialize(args={}, section: nil)
+      self.section = section
+      self.key = args["PriceTypeKey"]
+      self.price_key = args["PriceKey"]
+      self.name = args["PriceTypeName"]
+      self.ticket_valid_from = DateTime.parse(args["TicketValidFrom"])
+      self.ticket_valid_to = DateTime.parse(args["TicketValidTo"])
+      self.phone_number_required = args["PhoneNumberRequired"]
+      self.full_address_required = args["FullAddressRequired"]
+      self.price = args["Price"].to_f
+      self.requires_capacity_slot = args["RequiresCapacitySlot"]
+      self.raw_data = args     
+    end
+
+  end
+end

data/lib/shake_the_counter/reservation.rb

@@ -0,0 +1,50 @@
+module ShakeTheCounter
+
+  # Describes a reservation
+  class Reservation
+  	attr_accessor :reservation_key
+		attr_accessor :nr_of_tickets
+		attr_accessor :contact_key
+		attr_accessor :affiliate
+		attr_accessor :reservation_number
+		attr_accessor :currency
+		attr_accessor :external_reservation_number
+		attr_accessor :currency_code
+		attr_accessor :basket_key
+		attr_accessor :total_amount
+		attr_accessor :status
+		attr_accessor :ticket_amount
+		attr_accessor :reservation_date
+		attr_accessor :original_ticket_amount
+		attr_accessor :confirmed_date
+		attr_accessor :reservation_costs_per_ticket
+		attr_accessor :tickets_url
+		attr_accessor :reservation_costs_per_transaction
+		attr_accessor :payment_method
+		attr_accessor :payment_costs
+		attr_accessor :is_paid
+		attr_accessor :discount
+		attr_accessor :is_confirmed
+		attr_accessor :discount_title
+		attr_accessor :is_blocked
+
+		attr_accessor :raw_data 
+
+    # Sets up a new reservation
+    # 
+    def initialize(args={})
+    	args.each do |key, value|
+    		instance_variable_set("@#{key.underscore}", value)
+    	end
+      self.raw_data = args
+    end
+
+    def key
+    	reservation_key
+    end
+
+
+
+
+  end
+end

data/lib/shake_the_counter/section.rb

@@ -0,0 +1,67 @@
+module ShakeTheCounter
+
+  # Sets up a section object
+  class Section
+
+    attr_accessor :key
+    attr_accessor :performance_section_key
+    attr_accessor :name
+    attr_accessor :available_seats
+    attr_accessor :price_types
+    attr_accessor :performance
+    attr_accessor :raw_data
+    attr_accessor :price_types    
+
+    # Sets up a new section
+    # 
+    def initialize(args={}, performance: nil)
+      self.key = args["SectionKey"]
+      self.name = args["SectionName"]
+      self.performance_section_key = args["PerformanceSectionKey"]
+      self.available_seats = args["AvailableSeats"]
+      self.performance = performance
+      self.price_types = []
+      for price_type in args["PriceTypes"]
+        self.price_types << ShakeTheCounter::PriceType.new(price_type, section: self)
+      end
+      self.raw_data = args
+    end
+
+    # 
+    # Makes a reservation for this section
+    # POST /api/v1/event/{eventKey}/performance/{performanceKey}/section/{performanceSectionKey}/reservation/{languageCode}
+    # @param email: '' [type] [description]
+    # 
+    # @return Reservation
+    def make_reservation(price_type_list: {}, affiliate: '', first_name: '', last_name: '', email: '')
+      # step 1: make the reservation
+      path = "event/#{performance.event.key}/performance/#{performance.key}/section/#{performance_section_key}/reservation/#{performance.event.client.language_code}"
+      body = { 
+        PriceTypeList: price_type_list
+      }
+      result = performance.event.client.call(path, http_method: :post, body: body.to_json)
+      reservation = ShakeTheCounter::Reservation.new(result)
+
+      # step 2: create a contact
+      path = "contact/#{performance.event.client.language_code}"
+      body = { 
+        FirstName: first_name,
+        LastName: last_name,
+        MailAddress: email,
+        LanguageCode: performance.event.client.language_code
+      }
+      result = performance.event.client.call(path, http_method: :post, body: body.to_json)
+      contact = ShakeTheCounter::Contact.new(result)      
+
+      # step 3: link contact to the reservation
+      path = "reservation/#{reservation.key}/contact"
+      body = {
+        ContactKey: contact.key
+      }
+      result = performance.event.client.call(path, http_method: :post, body: body.to_json)
+
+      return reservation
+    end
+
+  end
+end

data/lib/shake_the_counter/shake_the_counter_error.rb

@@ -0,0 +1,4 @@
+class ShakeTheCounterError < StandardError
+  attr_accessor :error_message
+  attr_accessor :error_code
+end

data/lib/shake_the_counter/ticket.rb

@@ -0,0 +1,24 @@
+module ShakeTheCounter
+
+  # Describes a ticket
+  class Ticket
+
+    # Sets up a new reservation
+    # 
+    def initialize(args={})
+      args.each do |key, value|
+        # {"TicketKey"=>"1539335d-865d-40eb-ac31-0ac4b687ef2e", "Currency"=>"EUR", "Price"=>6.0, "PriceTypeKey"=>"0e9e2088-f74a-4ef4-9fe4-e668f2a01241", "PriceTypeName"=>"55 Plus", "ExternalPriceTypeID"=>"", "BranchePriceID"=>nil, "SectionName"=>"Toegangskaart", "TicketCode"=>"9787821683696", "BarcodeType"=>nil, "TicketValidFrom"=>"2018-03-31T00:00:00+02:00", "TicketValidTo"=>"2018-10-28T23:59:00+01:00", "LastClaimDate"=>nil, "SubscriptionProductKey"=>"00000000-0000-0000-0000-000000000000", "ScanningDisplayMessage"=>"", "TicketText"=>nil, "SalesChannelName"=>nil, "ExternalPriceID"=>nil}
+        singleton_class.class_eval { attr_accessor key.underscore }
+        instance_variable_set("@#{key.underscore}", value)
+      end
+    end
+
+    def key
+      reservation_key
+    end
+
+
+
+
+  end
+end

data/lib/shake_the_counter/version.rb

@@ -0,0 +1,3 @@
+module ShakeTheCounter
+  VERSION = "0.1.2"
+end

data/shake_the_counter.gemspec

@@ -0,0 +1,40 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "shake_the_counter/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "shake_the_counter"
+  spec.version       = ShakeTheCounter::VERSION
+  spec.authors       = ["Henk Meijer"]
+  spec.email         = ["meijerhenk@gmail.com"]
+
+  spec.summary       = %q{Ruby implementation of the ShakeTheCounter API}
+  spec.description   = %q{Ruby implementation of the ShakeTheCounter API}
+  spec.homepage      = "https://github.com/henkm/shake-the-counter"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = 'https://rubygems.org'
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "rest-client"
+  spec.add_dependency "json"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: shake_the_counter
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- Henk Meijer
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Ruby implementation of the ShakeTheCounter API
+email:
+- meijerhenk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/shake_the_counter.rb
+- lib/shake_the_counter/api.rb
+- lib/shake_the_counter/authentication.rb
+- lib/shake_the_counter/client.rb
+- lib/shake_the_counter/config.rb
+- lib/shake_the_counter/contact.rb
+- lib/shake_the_counter/engine.rb
+- lib/shake_the_counter/event.rb
+- lib/shake_the_counter/performance.rb
+- lib/shake_the_counter/price_type.rb
+- lib/shake_the_counter/reservation.rb
+- lib/shake_the_counter/section.rb
+- lib/shake_the_counter/shake_the_counter_error.rb
+- lib/shake_the_counter/ticket.rb
+- lib/shake_the_counter/version.rb
+- shake_the_counter.gemspec
+homepage: https://github.com/henkm/shake-the-counter
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Ruby implementation of the ShakeTheCounter API
+test_files: []