amiando 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+/.rvmrc
+/TAGS

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in amiando.gemspec
+gemspec
+
+unless ENV["TRAVIS"]
+  gem 'ruby-debug19', :platforms => :ruby_19
+  gem 'ruby-debug', :platforms => :mri_18
+end
+
+group :development do
+  gem 'guard-minitest'
+  if RbConfig::CONFIG['target_os'] =~ /darwin/i
+    gem 'rb-fsevent', '>= 0.4.0', :require => false
+    gem 'growl',      '~> 1.0.3', :require => false
+  end
+end

data/Guardfile

@@ -0,0 +1,11 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'minitest' do
+  # with Minitest::Unit
+  watch(%r|^test/(.*)_test\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}#{m[2]}_test.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+  watch(%r|^test/support/(.*)\.rb|)   { "test" }
+  watch(%r|^lib/amiando.rb|)          { "test" }
+end

data/README.md

@@ -0,0 +1,26 @@
+# amiando
+
+This is a gem to access the amiando REST API. You can check the original
+documentation here:
+
+http://developers.amiando.com/index.php/REST_API
+
+## Basic usage
+
+The gem has been implemented with the idea that requests can be done in
+parallel using [Typhoeus](https://github.com/dbalatero/typhoeus).
+
+You can query multiple requests and run then like this:
+
+```ruby
+albert = Amiando::User.find(1234)
+jorge  = Amiando::User.find(5678)
+
+Amiando.run
+```
+
+Both requests will happen in parallel.
+
+All attributes should be used in snake_case format instead of the CamelCase
+used in the official documentation. For example, for a user, you should call
+first_name instead of firstName.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler/gem_tasks'
+require 'rake'
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = true
+end
+Rake::Task['test'].comment = "Run all tests"

data/amiando.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "amiando/version"
+
+Gem::Specification.new do |s|
+  s.name        = "amiando"
+  s.version     = Amiando::VERSION
+  s.authors     = ["Jorge Dias", "Albert Llop"]
+  s.email       = ["jorge@mrdias.com","mrsimo@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A ruby client for the amiando REST API}
+  s.description = %q{A ruby client for the amiando REST API with parallel requests in mind}
+
+  s.rubyforge_project = "amiando"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'yajl-ruby', '0.8.2'
+  s.add_dependency 'typhoeus',  '0.2.4'
+
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'rake'
+end

data/lib/amiando.rb

@@ -0,0 +1,59 @@
+require "amiando/version"
+require "typhoeus"
+require "yajl"
+
+module Amiando
+  autoload :Request,        'amiando/request'
+  autoload :Resource,       'amiando/resource'
+  autoload :Boolean,        'amiando/boolean'
+  autoload :Result,         'amiando/result'
+  autoload :ApiKey,         'amiando/api_key'
+  autoload :User,           'amiando/user'
+  autoload :Event,          'amiando/event'
+  autoload :TicketCategory, 'amiando/ticket_category'
+  autoload :TicketShop,     'amiando/ticket_shop'
+
+  module Error
+    class ServiceDown    < Exception; end
+    class ApiKeyNeeded   < Exception; end
+    class NotAuthorized  < Exception; end
+    class NotFound       < Exception; end
+    class NotImplemented < Exception; end
+    class NotInitialized < Exception; end
+    class MissingApiKey  < Exception; end
+  end
+
+  class << self
+    attr_accessor :api_key
+
+    URL       = 'https://amiando.com'
+    TEST_URL  = 'https://test.amiando.com'
+
+    def production!
+      @production = true
+    end
+
+    def development!
+      @production = false
+    end
+
+    def base_url
+      @production ? URL : TEST_URL
+    end
+
+    def requests
+      @requests ||= []
+    end
+
+    def run
+      requests.each{ |request| hydra.queue(request) }
+      hydra.run
+    ensure
+      @requests = []
+    end
+
+    def hydra
+      @hydra ||= Typhoeus::Hydra.new
+    end
+  end
+end

data/lib/amiando/api_key.rb

@@ -0,0 +1,35 @@
+module Amiando
+
+  ##
+  # http://developers.amiando.com/index.php/REST_API_ApiKey
+  class ApiKey < Resource
+
+    ##
+    # Creates an {ApiKey}.
+    #
+    # @param [Hash] possible attributes that can be set on creation.
+    def self.create(attributes)
+      raise ArgumentError.new('ApiKey name field is mandatory') unless attributes[:name]
+
+      object  = new
+      request = post object, '/api/apiKey/create', :params => attributes
+
+      object
+    end
+
+    ##
+    # Updates an {ApiKey}.
+    #
+    # @param [Hash] possible attributes that can be updated.
+    def self.update(id, attributes)
+      object  = Boolean.new(:success)
+      request = post object, "/api/apiKey/#{id}", :params => attributes
+
+      object
+    end
+
+    def populate(response_body)
+      extract_attributes_from(response_body, 'apiKey')
+    end
+  end
+end

data/lib/amiando/boolean.rb

@@ -0,0 +1,33 @@
+module Amiando
+
+  ##
+  # This object is intended to be used when an api will return a boolean
+  # response, but due to the delayed nature of doing requests in parallel,
+  # can't be initialized from the beginning.
+  #
+  # After the object is populated, you can ask the result with the result
+  # method.
+  class Boolean
+    attr_accessor :request, :response
+
+    def initialize(response_attribute)
+      @response_attribute = response_attribute.to_s
+    end
+
+    def populate(response_body)
+      if response_body.key?(@response_attribute)
+        @result = response_body[@response_attribute]
+      else
+        raise Error::NotInitialized.new("The response doesn't have the expected attribute")
+      end
+    end
+
+    def result
+      if defined?(@result)
+        @result
+      else
+        raise Error::NotInitialized.new('Called result before the query was run')
+      end
+    end
+  end
+end

data/lib/amiando/event.rb

@@ -0,0 +1,131 @@
+module Amiando
+
+  ##
+  # http://developers.amiando.com/index.php/REST_API_Events
+  class Event < Resource
+    map :host_id,                  :hostId
+    map :selected_date,            :selectedDate,     :type => :time
+    map :selected_end_date,        :selectedEndDate,  :type => :time
+    map :short_description,        :shortDescription
+    map :event_type,               :eventType
+    map :organisator_display_name, :organisatorDisplayName
+    map :partner_event_url,        :partnerEventUrl
+    map :publish_search_engines,   :publishSearchEngines
+    map :search_engine_tags,       :searchEngineTags
+    map :location_description,     :locationDescription
+    map :zip_code,                 :zipCode
+    map :creation_time,            :creationTime,     :type => :time
+    map :last_modified,            :lastModified,     :type => :time
+
+    ##
+    # Creates an event.
+    #
+    # @return [Event] will not return the full event and only the id attribute
+    #   will be available.
+    def self.create(attributes)
+      object  = new
+      request = post object, '/api/event/create',
+        :params          => map_params(attributes),
+        :populate_method => :populate_create
+
+      object
+    end
+
+    ##
+    # Updates an event.
+    #
+    # @return [Boolean] if it was successful or not.
+    def self.update(id, attributes)
+      object = Result.new do |response_body, result|
+        unless response_body['success']
+          result.errors = response_body['errors']
+        end
+        response_body['success']
+      end
+      request = post object, "/api/event/#{id}", :params => map_params(attributes)
+
+      object
+    end
+
+    ##
+    # Fetch an event
+    def self.find(id)
+      object  = new
+      request = get object, "/api/event/#{id}"
+
+      object
+    end
+
+    ##
+    # See if an event id exists
+    def self.exists?(identifier)
+      object  = Boolean.new('exists')
+      request = get object, "api/event/exists",
+        :params => { :identifier => identifier }
+
+      object
+    end
+
+    ##
+    # Deletes an event
+    #
+    # @param [Integer] event id
+    #
+    # @return [Boolean] with the result of the operation
+    def self.delete(id)
+      object = Boolean.new('deleted')
+      request = do_request object, :delete, "/api/event/#{id}"
+
+      object
+    end
+
+    ##
+    # Activate an event
+    #
+    # @param [Integer] the event id
+    #
+    # @return [Result] if it was activated or not.
+    def self.activate(id)
+      object = Result.new do |response_body, result|
+        unless response_body['success']
+          result.errors = response_body['errors']
+        end
+        response_body['success']
+      end
+      request = post object, "/api/event/#{id}/activate"
+
+      object
+    end
+
+    ##
+    # Search by identifier or title.
+    #
+    # @param [Hash] a hash with 1 entry, either :identifier or :title
+    #
+    # @return [Result] with an array of ids
+    def self.search(by)
+      unless by[:identifier].nil? ^ by[:title].nil? # XOR
+        raise ArgumentError.new('Events can be searched either by identifier or by title, include only one.')
+      end
+
+      object  = Result.new { |response_body| response_body['ids'] }
+      request = get object, '/api/event/find', :params => by
+
+      object
+    end
+
+    def self.find_all_by_user_id(user_id)
+      object = Result.new do |response_body|
+        response_body['events']
+      end
+      request = get object, "/api/user/#{user_id}/events"
+      object
+    end
+
+    private
+
+    def populate(response_body)
+      extract_attributes_from(response_body, 'event')
+    end
+  end
+end

data/lib/amiando/request.rb

@@ -0,0 +1,38 @@
+module Amiando
+  class Request < Typhoeus::Request
+    attr_reader :object
+
+    def initialize(object, verb, path, params)
+      @object = object
+
+      if verb == :post
+        path = build_url(path, default_params)
+      else
+        path = build_url(path)
+        params = default_params.merge(params || {})
+      end
+
+      super(path, :method => verb, :params => params, :verbose => 1)
+    end
+
+    private
+
+    def default_params
+      default = {
+        :format  => :json,
+        :version => 1
+      }
+      default.merge!(:apikey => Amiando.api_key) if Amiando.api_key
+      default
+    end
+
+    def build_url(url, merge_params = {})
+      url = URI.join(Amiando.base_url, url).to_s
+      unless merge_params.empty?
+        query_params = merge_params.map{|k,v| "#{k}=#{v}"}.join('&')
+        url = "#{url}?#{query_params}"
+      end
+      url
+    end
+  end
+end

data/lib/amiando/resource.rb

@@ -0,0 +1,152 @@
+module Amiando
+  class Resource
+    attr_accessor :request, :response
+    attr_reader :success, :attributes
+
+    class << self
+      def map(local, remote, options = {})
+        mapping[local] = remote
+        typecasting[local] = options[:type] if options[:type]
+      end
+
+      def typecasting
+        @@typecasting ||= {}
+      end
+
+      def mapping
+        @@mapping ||= {}
+      end
+
+      ##
+      # From { :first_name => '1', :last_name  => '2' }
+      # to   { :firstName  => '1', :lastName   => '2' }
+      def map_params(attributes)
+        mapped_attributes = attributes.map do |key,value|
+          mapped_key = mapping[key] || key
+          value = typecast(key, value)
+          [mapped_key, value]
+        end
+        Hash[mapped_attributes]
+      end
+
+      def reverse_map_params(attributes)
+        inverted_mapping = mapping.invert
+        mapped_attributes = attributes.map do |key,value|
+          key        = key.to_sym
+          mapped_key = inverted_mapping[key] || key
+          value      = inverse_typecast(key, value)
+          [mapped_key, value]
+        end
+        Hash[mapped_attributes]
+      end
+
+      private
+
+      def do_request(object, verb, path, options = {})
+        req = Request.new(object, verb, path, options[:params] || {})
+        object.request = req
+
+        req.on_complete do |response|
+
+          # Raise different errors depending on the return codes
+          case response.code
+          when 403
+            raise Error::NotAuthorized.new(response.body)
+          when 404
+            raise Error::NotFound.new(response.body)
+          when 503
+            raise Error::ServiceDown.new(response.body)
+          end
+
+          parsed_body = Yajl::Parser.parse(response.body)
+
+          if parsed_body['errors'] && parsed_body['errors'].include?('com.amiando.api.rest.MissingParam.apikey')
+            raise Error::MissingApiKey.new('This call requires an apikey')
+          end
+
+          object.response = response
+          object.send(options[:populate_method] || :populate, parsed_body)
+        end
+
+        Amiando.requests << req
+      end
+
+      def get(object, path, options = {})
+        do_request(object, :get, path, options)
+      end
+
+      def post(object, path, options = {})
+        do_request(object, :post, path, options)
+      end
+
+      def typecast(key, value)
+        if typecasting[key] == :time || value.is_a?(Time)
+          value.iso8601
+        else
+          value
+        end
+      end
+
+      def inverse_typecast(key, value)
+        if typecasting[key] == :time
+          Time.parse(value)
+        else
+          value
+        end
+      end
+    end
+
+    def initialize(attributes = nil)
+      set_attributes(attributes)
+    end
+
+    def [](key)
+      @attributes[key.to_sym]
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @attributes.key?(method_name) && args.empty?
+        @attributes[method_name]
+      else
+        super
+      end
+    end
+
+    def id
+      @attributes[:id]
+    end
+
+    def populate(reponse_body)
+      raise Error::NotImplemented.new("populate method not implemented for #{self.class}")
+    end
+
+    def populate_create(response_body)
+      @attributes = {:id => response_body['id'], :errors => response_body['errors']}
+      @success    = response_body['success']
+    end
+
+    def extract_attributes_from(response_body, key)
+      @attributes = {}
+
+      set_attributes(response_body[key])
+
+      @success = response_body['success']
+    end
+
+    def ==(resource)
+      id == resource.id
+    end
+
+    protected
+
+    def set_attributes(attributes)
+      @attributes = {}
+
+      if attributes
+        self.class.reverse_map_params(attributes).each do |k,v|
+          @attributes[k.to_sym] = v
+        end
+      end
+    end
+  end
+end