fotolia 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+nbproject/*
+doc/*
+pkg/*

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Planquadrat Software-Integration, Torsten Schönebaum
+
+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.rdoc

@@ -0,0 +1,76 @@
+= fotolia
+
+This is a client to the API of the royalty free stock image marketplace http://fotolia.com written in Ruby.
+
+You will need to register for an API key at Fotolia to use it: http://www.fotolia.com/Services/API/Introduction
+
+== Getting started
+  # install & configure gemcutter repos (skip if you already done this)
+  gem update --system
+  gem install gemcutter
+  gem tumble
+
+  # install gem
+  gem install fotolia
+
+== Usage
+  require 'fotolia'
+
+  # get client instance
+  fotolia = Fotolia.new(:api_key => 'YOUR_API_KEY')
+  # => #<Fotolia::Base ...>
+
+  # search for media
+  search_results = fotolia.search(:words => 'ruby')
+  # => #<Fotolia::SearchResultSet ...>
+
+  search_results.total # number of results
+  # => 3978
+
+  # Take care, the result sets are paged!
+  search_results.length
+  # => 50
+
+  # You may access the pages in various ways:
+  search_results.next_page    # get the next page of the current one
+  search_results.pages.length # get the total number of pages
+  search_results.pages[3]     # Fotolia::SearchResultSet::Pages includes the
+                              # Enumerable mixin!
+
+  # inspect a medium object
+  search_results.first
+  # => #<Fotolia::Medium ...>
+
+  search_results.first.id             # get its id
+  # => 18432121
+  search_results.first.title          # get its title
+  # => "Crowns"
+  search_results.first.licenses.collect{|l| {l.name => l.price}} # there are different licenses available at Fotolia
+  # => [{"XS"=>1}, {"S"=>2}, {"M"=>4}, {"L"=>5}, {"XL"=>6}, {"XXL"=>7}, {"V"=>6}, {"XV"=>80}]
+  search_results.first.creator_name   # who published that image?
+  # => "antipathique"
+  search_results.first.thumbnail.url  # get a thumbnail url
+  # => "http://static-p4.fotolia.com/jpg/....jpg"
+
+  # some basic fun with categories
+  categories = fotolia.representative_categories.root_level
+  # => [#<Fotolia::RepresentativeCategory..., ...]
+  {categories.first.id => categories.first.name}
+  # => {6000000=>"Transportation"}
+  categories.first.child_categories   # there are three category levels, this
+                                      # gets the second one for the first
+                                      # category in our previously fetched array
+  # => [#<Fotolia::RepresentativeCategory..., ...]
+  categories.first.child_categories[2].child_categories # the third level
+  # => [#<Fotolia::RepresentativeCategory..., ...]
+  categories.first.child_categories[2].child_categories.first.media # get media in a category
+  # => #<Fotolia::SearchResultSet ...>
+
+...
+
+== Author
+Planquadrat Software-Integration GmbH <http://www.planquadrat-software.de>
+Torsten Schönebaum <http://github.com/tosch>
+
+== License
+See LICENSE

data/Rakefile

@@ -0,0 +1,35 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "fotolia"
+    gemspec.summary = "Fotolia API Client"
+    gemspec.description = "Provides a ruby interface to Fotolia via its XML-RPC api."
+    gemspec.email = "torsten.schoenebaum@planquadrat-software.de"
+    gemspec.homepage = "http://github.com/tosch/fotolia"
+    gemspec.authors = ["Torsten Schönebaum"]
+    gemspec.add_dependency('patron', '>= 0.4.4')
+    gemspec.rdoc_options << '--line-numbers' << '--main' << 'README.rdoc'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README.rdoc', 'LICENSE', 'VERSION', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.rdoc" # page to start on
+  rdoc.title = "Fotolia Client"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/TODO

@@ -0,0 +1,3 @@
+- WRITE SOME TESTS
+- implement Fotolia::Medium#buy_and_save
+- implement ShoppingCart and Reseller API functions

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/fotolia.gemspec

@@ -0,0 +1,67 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fotolia}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Torsten Sch\303\266nebaum"]
+  s.date = %q{2009-11-25}
+  s.description = %q{Provides a ruby interface to Fotolia via its XML-RPC api.}
+  s.email = %q{torsten.schoenebaum@planquadrat-software.de}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "fotolia.gemspec",
+     "lib/fotolia.rb",
+     "lib/fotolia/base.rb",
+     "lib/fotolia/categories.rb",
+     "lib/fotolia/category.rb",
+     "lib/fotolia/color.rb",
+     "lib/fotolia/colors.rb",
+     "lib/fotolia/conceptual_categories.rb",
+     "lib/fotolia/conceptual_category.rb",
+     "lib/fotolia/countries.rb",
+     "lib/fotolia/country.rb",
+     "lib/fotolia/galleries.rb",
+     "lib/fotolia/gallery.rb",
+     "lib/fotolia/language.rb",
+     "lib/fotolia/medium.rb",
+     "lib/fotolia/representative_categories.rb",
+     "lib/fotolia/representative_category.rb",
+     "lib/fotolia/search_result_set.rb",
+     "lib/fotolia/tag.rb",
+     "lib/fotolia/tags.rb",
+     "lib/fotolia/user.rb"
+  ]
+  s.homepage = %q{http://github.com/tosch/fotolia}
+  s.rdoc_options = ["--charset=UTF-8", "--line-numbers", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Fotolia API Client}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<patron>, [">= 0.4.4"])
+    else
+      s.add_dependency(%q<patron>, [">= 0.4.4"])
+    end
+  else
+    s.add_dependency(%q<patron>, [">= 0.4.4"])
+  end
+end
+

data/lib/fotolia.rb

@@ -0,0 +1,161 @@
+require 'xmlrpc/client'
+
+[
+  'language',
+  'base',
+  'category',
+  'conceptual_category',
+  'representative_category',
+  'categories',
+  'conceptual_categories',
+  'representative_categories',
+  'color',
+  'colors',
+  'country',
+  'countries',
+  'gallery',
+  'galleries',
+  'medium',
+  'tag',
+  'tags',
+  'search_result_set',
+  'user'
+].each {|file| require File.join(File.dirname(__FILE__), 'fotolia', file)}
+
+require 'patron'
+
+#
+# Monkey patch XMLRPC::Client as Fotolia returns application/xml as content type
+# instead of text/xml which XMLRPC expects
+#
+# Another monkey patch so that XMLRPC::Client will use the much faster Patron
+# http client
+#
+class XMLRPC::HTTPException < Exception #:nodoc:
+end
+class XMLRPC::HTTPAuthenticationException < Exception #:nodoc:
+end
+module XMLRPC #:nodoc:
+  class Client #:nodoc:
+    def initialize(host=nil, path=nil, port=nil, proxy_host=nil, proxy_port=nil,
+        user=nil, password=nil, use_ssl=nil, timeout=nil)
+
+      @http_header_extra = nil
+      @http_last_response = nil
+      @cookie = nil
+
+      @host       = host || "localhost"
+      @path       = path || "/RPC2"
+      @proxy_host = proxy_host
+      @proxy_port = proxy_port
+      @proxy_host ||= 'localhost' if @proxy_port != nil
+      @proxy_port ||= 8080 if @proxy_host != nil
+      @use_ssl    = use_ssl || false
+      @timeout    = timeout || 30
+
+      @port = port || (use_ssl ? 443 : 80)
+
+      @user, @password = user, password
+
+      # convert ports to integers
+      @port = @port.to_i unless @port.nil?
+      @proxy_port = @proxy_port.to_i unless @proxy_port.nil?
+
+      # HTTP object for synchronous calls
+      @http = build_http_client
+      @http.handle_cookies
+
+      @parser = nil
+      @create = nil
+    end
+
+    def timeout=(new_timeout)
+      @timeout = new_timeout
+      @http.timeout = @timeout
+    end
+
+    private
+
+    def set_auth
+      if(@user.nil?)
+        @http.username = nil
+        @http.password = nil
+      else
+        @http.username = @user
+        @http.password = @password
+      end
+    end
+
+    def build_http_client
+      http = Patron::Session.new
+      require 'uri'
+      http.base_url = URI::HTTP.build(
+        :scheme => @use_ssl ? 'https' : 'http',
+        :host   => @host,
+        :port   => @port
+      ).to_s
+      http.timeout = @timeout
+      unless(@proxy_host.nil?)
+        http.proxy = URI::HTTP.build(:scheme => 'http', :host => @proxy_host, :port => @proxy_port).to_s
+      end
+      unless(@user.nil?)
+        http.username = @user
+        http.password = @password
+      end
+
+      http
+    end
+
+    def do_rpc(request, async=false) #:nodoc:
+      header = {
+        "User-Agent"     =>  USER_AGENT,
+        "Content-Type"   => "text/xml; charset=utf-8",
+        "Content-Length" => request.size.to_s,
+        "Connection"     => (async ? "close" : "keep-alive")
+      }
+
+      header.update(@http_header_extra) if @http_header_extra
+
+      resp = nil
+      @http_last_response = nil
+
+      resp = if async
+        # use a new HTTP object for each call
+        http = build_http_client
+
+        # post request
+        http.post(@path, request, header)
+      else
+        # reuse the HTTP object for each call => connection alive is possible we
+
+        # post request
+        @http.post(@path, request, header)
+      end
+
+      @http_last_response = resp
+
+      data = resp.body
+
+      if resp.status == 401
+        # Authorization Required
+        raise XMLRPC::HTTPAuthenticationException, "Authorization failed.\nHTTP-Error: #{resp.status} #{resp.status_line}"
+      elsif resp.status < 200 or resp.status >= 300
+        raise XMLRPC::HTTPException, "HTTP-Error: #{resp.status} #{resp.message}"
+      end
+
+      ct = parse_content_type(resp.headers["Content-Type"]).first
+      if (ct != "text/xml")  && (ct != "application/xml")
+        raise "Wrong content-type (received '#{ct}' but expected 'text/xml')"
+      end
+
+      expected = resp.headers["Content-Length"] || "<unknown>"
+      if data.nil? or data.size == 0
+        raise XMLRPC::HTTPException, "Wrong size. Was #{data.size}, should be #{expected}"
+      elsif expected != "<unknown>" and expected.to_i != data.size and resp["Transfer-Encoding"].nil?
+        raise XMLRPC::HTTPException, "Wrong size. Was #{data.size}, should be #{expected}"
+      end
+
+      return data
+    end
+  end
+end

data/lib/fotolia/base.rb

@@ -0,0 +1,294 @@
+module Fotolia
+  #
+  # See Fotolia::Base#new.
+  #
+  def self.new(*params)
+    Fotolia::Base.new(*params)
+  end
+
+  #
+  # This error is raised if Fotolia's Api returns an error
+  #
+  class CommunicationError < StandardError; end
+
+  #
+  # Raised if no api key is given to the initializer
+  #
+  class ApiKeyRequiredError < StandardError; end
+
+  #
+  # Raised if an user login via Fotolia's API fails
+  #
+  class UserLoginError < StandardError; end
+
+  #
+  # Raised if a function is called which requires a user login
+  #
+  class LoginRequiredError < StandardError; end
+
+  #
+  # == Example Usage
+  #
+  # 0. Require the lib:
+  #    <tt>require 'fotolia'</tt>
+  #
+  # 1. Get a new instance of the base class:
+  #    <tt>fotolia = Fotolia::Base.new :api_key => 'AAAAA'</tt>
+  #
+  #    Note: You may also use the shortcut <tt>Fotolia.new</tt>.
+  #
+  # 2. Search for some media:
+  #    <tt>search_results = fotolia.search :words => 'nitpick'</tt>
+  #
+  #    +search_result+ now contains an array of Fotolia media containing the
+  #    word 'nitpick' somewhere. Note that the array won't have more than 50
+  #    items per default as Fotolia limits the number of media returned (the max
+  #    is 64). However, the array is extended in some ways as it is not a plain
+  #    Array object, but a SearchResultSet instead. So you can call
+  #    <tt>search_results.total</tt> to get the total number of all results or
+  #    <tt>search_results.next_page</tt> to get the next set of results. See
+  #    SearchResultSet for more information.
+  #
+  #    Each medium is represented by the class Fotolia::Medium, so check its
+  #    documentation for further info.
+  #
+  # 3. Get all representative categories in root level (Fotolia has two types of
+  #    categories, representative and conceptual ones. Each root category may
+  #    have children and grand-children):
+  #    <tt>r_cats = fotolia.representative_categories</tt>
+  #
+  #    This gives you an array of all root-level representative categories. You
+  #    may get the children of the first cat by calling
+  #    <tt>r_cats.first.children</tt>
+  #
+  #    You can fetch a category's media by calling
+  #    <tt>r_cats.first.media</tt>
+  #    Note that this method takes the same options hash as parameter as
+  #    Base#search.
+  #
+  # 4. You may change the language used in all returns of Fotolia's API. Default
+  #    is <tt>:en_us</tt>. Also available are <tt>:en_uk</tt>, <tt>:fr</tt>,
+  #    <tt>:de</tt>, <tt>:es</tt>, <tt>:it</tt>, <tt>:pt_pt</tt>,
+  #    <tt>:pt_br</tt>, <tt>:jp</tt> and <tt>:pl</tt>. To use one of them, pass
+  #    the initializer of Base an Fotolia::Language instance:
+  #
+  #    <tt>fotolia = Fotolia.new :api_key => 'A...', :language => Fotolia::Language.new(:de)</tt>
+  #
+  #    Category names, tags and some other items will be returned in German now.
+  #    If it's not translated, it's Fotolia's fault, not this gem's ;-)
+  #
+  # 5. Get a Fotolia medium by its ID
+  #
+  #    You may use the :media_id option of Base#search, but calling
+  #
+  #    <tt>medium = Fotolia::Medium.new fotolia, :id => 12334567</tt>
+  #
+  #    is just more intuitive. The class will try to fetch all missing data from
+  #    Fotolia. You should catch CommunicationErrors when using any medium
+  #    object generated this way as an of those will be raised if the given
+  #    media id is unknown to Fotolia.
+  #
+  # 6. Login a user and get its galleries and add a medium to the first.
+  #
+  #   <tt>fotolia.login 'username', 'password'</tt>
+  #   <tt>galleries = fotolia.logged_in_user.galleries</tt>
+  #   <tt>medium = Fotolia::Medium.new fotolia, :id => 12345678</tt>
+  #   <tt>medium.add_to_user_gallery galleries.first</tt>
+  #   <tt>fotolia.logout</tt>
+  #
+  #
+  class Base
+    DEFAULT_API_URI = 'http://api.fotolia.com/Xmlrpc/rpc'
+    DEFAULT_LANGUAGE = :en_us
+
+    # <String> The API key the client is set to.
+    attr_reader :api_key
+    # <Fotolia::Language> The language for all requests which return i18n'd results.
+    attr_reader :language
+    # <String> The URI of the API.
+    attr_reader :api_uri
+    # <mixed> A string containing the user session id or nil if any.
+    attr_reader :session_id
+    # <mixed> A Fotolia::User object if there is a user session or nil.
+    attr_reader :logged_in_user
+
+    #
+    # ==options hash
+    # :api_key <String>:: Your Fotolia API key (an exception is raised if not included)
+    # :language <Fotolia::Language>:: The language the client should submit to the API if applicable. Defaults to Fotolia::Language.new(DEFAULT_LANGUAGE).
+    # :api_uri <String>:: The URI of the Fotolia API. Defaults to DEFAULT_API_URI.
+    #
+    def initialize(options = {})
+      @api_key = options[:api_key]
+      @language = options[:language] || Fotolia::Language.new(DEFAULT_LANGUAGE)
+      @api_uri = options[:api_uri] || DEFAULT_API_URI
+      @xmlrpc_client = XMLRPC::Client.new2(@api_uri)
+
+      raise ApiKeyRequiredError unless(@api_key)
+    end
+
+    #
+    # Returns a Fotolia::Colors object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.colors.find_all
+    #
+    def colors
+      @colors ||= Fotolia::Colors.new(self)
+    end
+
+    #
+    # Returns a Fotolia::ConceptualCategories object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.conceptual_categories.find
+    #
+    def conceptual_categories
+      @conceptual_categories ||= Fotolia::ConceptualCategories.new(self)
+    end
+
+    #
+    # Returns a Fotolia::RepresentativeCategories object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.representative_categories.find
+    #
+    def representative_categories
+      @representative_categories ||= Fotolia::RepresentativeCategories.new(self)
+    end
+
+    #
+    # Returns a Fotolia::Countries object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.countries.find_all
+    #
+    def countries
+      @countries ||= Fotolia::Countries.new(self)
+    end
+
+    #
+    # Returns a Fotolia::Galleries object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.galleries.find_all
+    #
+    def galleries
+      @galleries ||= Fotolia::Galleries.new(self)
+    end
+
+    #
+    # Returns a Fotolia::Tags object.
+    #
+    # ==Example
+    #   f = Fotolia.new(:api_key => YOUR_API_KEY)
+    #   f.tags.most_used
+    #   f.tags.most_searched
+    #
+    def tags
+      @tags ||= Fotolia::Tags.new(self)
+    end
+
+    #
+    # Searches for media in Fotolia's DB.
+    #
+    # ==options hash
+    # :language <Fotolia::Language>:: Return results in this language. Defaults to language set in Fotolia::Base#new.
+    # :per_page <Fixnum>:: Number of results per page. Defaults to 50. Fotolia API limits this to values from 1 to 64.
+    # :page <Fixnum>:: Page to show. Defaults to 1.
+    # :detailed_results <Boolean>:: Whether to fetch keywords, number of views and downloads of the media in the result set. Defaults to true.
+    # :content_types <Array>:: Limit search to certain content types. Valid values are :photo, :illustration, :vector and :all. These types may be mixed together.
+    # :only_licenses <Array>:: Only return media offering the listed licenses. Valid values may be 'L', 'XL', 'XXL', 'X' and 'E'. Values may be mixed, but unsure if Fotolia API combines them by AND or OR.
+    # :words <String>:: Keyword search. Words can also be media_id using # to search for some media ( ex : #20 #21 #22)
+    # :creator_id <Fixnum>:: Search by creator.
+    # :representative_category <Fotolia::RepresentativeCategory>:: Search by representative category.
+    # :conceptual_category <Fotolia::ConceptualCategory>:: Search by conceptual category.
+    # :gallery <Fotolia::Galery>:: Search by gallery.
+    # :color <Fotolia::Color>:: Search by color.
+    # :country <Fotolia::Country>:: Search by country.
+    # :media_id <Fixnum>:: Search by media id -- fetch a medium by its known media id.
+    # :model_id <Fixnum>:: Search by same model. Value must be a valid media id.
+    # :serie_id <Fixnum>:: Search by same serie. Value must be a valid media id.
+    # :similia_id <Fixnum>:: Search similar media. Value must be a valid media id.
+    # :offensive <Boolean>:: Include Explicit/Charm/Nudity/Violence media. Defaults to false.
+    # :panoramic <Boolean>:: Only fetch panoramic media. Defaults to false.
+    # :isolated <Boolean>:: Only fetch isolated media. Defaults to false.
+    # :orientation <String>:: Only fetch media in given orientation. Valid values are 'horizontal', 'vertical' and 'all'. Defaults to the latter.
+    # :order <String>:: Order the result set. Valid values are 'relevance', 'price_1', 'creation', 'nb_views' and 'nb_downloads'. Defaults to 'relevance'.
+    # :thumbnail_size <Fixnum>:: The size of the thumbnail images included in the result set. Valid values are 30, 110 and 400. Defaults to 110. Thumbs in 400px size are watermarked by Fotolia.
+    #
+    # ==returns
+    # Fotolia::SearchResultSet
+    #
+    def search(options)
+      Fotolia::SearchResultSet.new(self, options)
+    end
+
+    #
+    # Start an user authenticated session which is needed for some functions,
+    # especially user related ones.
+    #
+    # Won't work in Fotolia's Partner API! Business and Reseller API are limited
+    # to login the user the API key belongs to. Only Developer API allows login
+    # of all users.
+    #
+    def login(login, pass)
+      @logged_in_user = Fotolia::User.new(self, login, pass)
+      res = self.remote_call('loginUser', login, pass)
+      raise UserLoginError unless(res['session_id'])
+      @session_id = res['session_id']
+    end
+
+    #
+    # Ends an user authenticated session.
+    #
+    def logout
+      return false unless self.logged_in?
+      self.remote_call('logoutUser', self.session_id)
+      @session_id = nil
+      @logged_in_user = nil
+      true
+    end
+
+    #
+    # Returns true if there is a valid user authenticated session.
+    #
+    def logged_in?
+      !@session_id.nil?
+    end
+
+    # 
+    # The number of media objects in Fotolia's DB.
+    #
+    def count_media
+      general_data['nb_media']
+    end
+
+    #
+    # Does an API call and returns the response. Useful if you like to call
+    # methods not implemented by this library.
+    #
+    def remote_call(method, *args)
+      begin
+        @xmlrpc_client.call('xmlrpc.' + method.to_s, @api_key, *args)
+      rescue XMLRPC::FaultException => e
+        raise Fotolia::CommunicationError, e.message
+      end
+    end
+
+    def inspect #:nodoc:
+      "#<#{self.class} api_key=#{@api_key.inspect} language=#{@language.inspect} session_id=#{@session_id.inspect} logged_in_user=#{@logged_in_user.inspect}>"
+    end
+
+    protected
+
+    def general_data #:nodoc:
+      @general_data ||= self.remote_call('getData')
+    end
+  end
+end