autometal-piwik 0.6.2 → 1.0.0

data/lib/piwik/annotations.rb

@@ -0,0 +1,41 @@
+module Piwik
+  class Annotations < ApiModule
+    available_methods %W{
+      get
+      add
+      save
+      delete
+      getAll
+      getAnnotationCountForDates
+    }
+    
+    scoped_methods do
+      def load note_id
+        get(defaults.merge(:idNote => note_id))
+      end
+      
+      def all params = {}
+        getAll(defaults.merge(params))
+      end
+      
+      # params: ( date, note, starred = '0')
+      def add params = {}
+        super(defaults.merge(params))
+      end
+      
+      # params:  (date = '', note = '', starred = '')
+      def update note_id, params = {}
+        save(defaults.merge(params).merge(:idNote => note_id))
+      end
+
+      def delete note_id
+        super(defaults.merge(:idNote => note_id))
+      end
+      
+      # params: (date, period, lastN = '', getAnnotationText = '')
+      def count_for_dates params = {}
+        getAnnotationCountForDates(defaults.merge(params))
+      end
+    end
+  end
+end

data/lib/piwik/api.rb

@@ -0,0 +1,21 @@
+module Piwik
+  class API < ApiModule
+    available_methods %W{
+      getPiwikVersion
+      getSettings
+      getDefaultMetricTranslations
+      getDefaultMetrics
+      getDefaultProcessedMetrics
+      getDefaultMetricsDocumentation
+      getSegmentsMetadata
+      getLogoUrl
+      getHeaderLogoUrl
+      getMetadata
+      getReportMetadata
+      getProcessedReport
+      get
+      getRowEvolution
+      getBulkRequest
+    }
+  end
+end

data/lib/piwik/api_module.rb

@@ -0,0 +1,97 @@
+module Piwik
+  class ApiModule < Base
+    include Piwik::DataMethods
+    
+    # returns default API params, used all over the place, especially in <tt>scoped_methods</tt>
+    def self.defaults
+      {:period => :day, :date => Date.today, @obj.id_attr => @obj.id}
+    end
+    
+    # Catch incoming method calls and try to format them and send them over to the api
+    def self.method_missing(method, *args, &block)
+      formatted_method = method.to_s.camelize(:lower)
+      formatted_method = formatted_method.gsub(/ip$/i,'IP').gsub(/os/i,'OS') # Lame
+      # connect to API if this is a valid-looking method in the current class context
+      if @available_methods.include?(formatted_method)
+        handle_api_call(formatted_method, args.first)
+      else
+        super
+      end
+    end
+    
+    # allows the addition of scoped methods. It's basically a class << self wrapper
+    # mostly added to make ApiModule code more self-explanatory
+    # the @obj instance variable is set in the api_scope call. This is not very clean or anything,
+    # and I am still researching a better way to do it, 
+    # but the Piwik::Site API is certainly much better to work with due to this
+    def self.scoped_methods &block
+      if block_given?
+        extension =  Module.new(&Proc.new)
+        self.extend(extension)
+      end
+    end
+    
+    def self.available_methods method_array
+      @available_methods = method_array
+      @available_methods.each do |method|
+        class_eval %{
+          class #{self.api_call_to_const(method)} < Piwik::ApiResponse
+          end
+        }, __FILE__, __LINE__
+      end
+    end
+    
+    def self.api_call_to_const string, full = false
+      # We can get rid of the get prefix
+      string = case string
+      when /[A-Z]{1}[a-z]*\.[get|add|delete|save]$/,'get','add','delete','save'
+        string.camelize
+      else
+        string.gsub(/get|save|add|delete/, '')
+      end
+      string = string.split('.').map {|s| s.camelize }.join('::')
+      full ? "Piwik::#{string}" : string
+    end
+  protected
+    # Attempt an API call request
+    def self.handle_api_call method, params
+      method_name = "#{self.to_s.gsub('Piwik::','')}.#{method}"
+      config = load_config_from_file
+      xml = self.call(method_name, params, config[:piwik_url], config[:auth_token])
+      data = (xml.is_a?(String) && xml.is_binary_data?) ? xml : XmlSimple.xml_in(xml, {'ForceArray' => false})
+      if data.is_a?(String) && data.is_binary_data?
+        api_call_to_const(method_name,true).constantize.new(:data => [], :value => data)
+      elsif data.is_a?(String)
+        api_call_to_const(method_name,true).constantize.new(:data => [], :value => data)
+      elsif data['row'].present?
+        api_call_to_const(method_name,true).constantize.new(:data => data['row'])
+      elsif data.is_a?(Hash)
+        api_call_to_const(method_name,true).constantize.new(:data => data)
+      else
+        api_call_to_const(method_name,true).constantize.new(:data => [])
+      end
+    end
+    
+    # Attempt an API call request
+    def self.api_call method, params
+      method_name = "#{self.to_s.gsub('Piwik::','')}.#{method}"
+      config = load_config_from_file
+      if params.is_a?(OpenStruct)
+        params = params.marshal_dump
+      end
+      xml = self.call(method_name, params, config[:piwik_url], config[:auth_token])
+      data = XmlSimple.xml_in(xml, {'ForceArray' => false})
+      if data.is_a?(String)
+        data
+      elsif data['row'].present?
+        data['row']
+      elsif data.is_a?(Hash) and data['success'].is_a?(Hash)
+        true
+      elsif data.is_a?(Hash)
+        data
+      else
+        []
+      end
+    end
+  end
+end

data/lib/piwik/api_response.rb

@@ -0,0 +1,6 @@
+module Piwik
+  class ApiResponse < Base
+    include Piwik::DataMethods
+  end
+end
+  

data/lib/piwik/api_scope.rb

@@ -0,0 +1,32 @@
+module Piwik
+  # Used to extend a wrapper class with class-aware api calls, allowing users to use a more DRY api interface.
+  # Example:
+  #
+  #   site = Piwik::Site.load(7)
+  #   p = site.actions # returns an extended version of the Piwik::Actions api module
+  #   => Piwik::Actions
+  #   p.outlinks # equivalent to Piwik::Actions.getOutlinks(:idSite => 7)
+  #   => #<Piwik::Actions::Outlinks @data=[snip]>
+  module ApiScope
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    module ClassMethods
+      def api_scope name, scope_options = {}, &block
+        name = name.to_sym
+        class_name = "Piwik::#{scope_options[:class_name] ? scope_options[:class_name] : name.to_s.camelize}"
+        extension =  Module.new(&Proc.new) if block_given?
+        instance_eval do          
+          define_method name do
+            klass = class_name.constantize
+            klass.extend(extension) if block_given?
+            klass.instance_variable_set(:@obj, self)
+            klass
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/piwik/base.rb

@@ -1,23 +1,20 @@
 require 'rubygems'
 require 'cgi'
-require 'active_support/all'
-require 'json/ext'
+require 'yaml'
 require 'rest_client'
+require 'xmlsimple'
+require 'ostruct'
 
 module Piwik
   class ApiError < StandardError; end
   class MissingConfiguration < ArgumentError; end
   class UnknownSite < ArgumentError; end
   class UnknownUser < ArgumentError; end
-
-  mattr_accessor :piwik_url
-  mattr_accessor :auth_token
-
-  def self.is_configured?
-    @@piwik_url!=nil && @@auth_token!=nil
-  end
-
+  class UnknownGoal < ArgumentError; end
+  
   class Base
+    include Piwik::Typecast
+    include Piwik::ApiScope
     @@template  = <<-EOF
 # .piwik
 # 
@@ -29,29 +26,80 @@ module Piwik
 piwik_url: 
 auth_token: 
 EOF
-
-  def self.config_file
-    if defined?(Rails.root) && Rails.root!=nil
-#     puts "config_file from Rails.root: #{Rails.root.to_s}"
-      Rails.root.join('config', 'piwik.yml')
-#   elsif defined?(RAILS_ROOT) && RAILS_ROOT!=nil
-#     puts "config_file from RAILS_ROOT: #{RAILS_ROOT}"
-#     File.join(RAILS_ROOT, 'config', 'piwik.yml')
-    else
-#     puts "config_file from ~/.piwik"
-      File.join( ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH'] || ".", '.piwik' )
+    
+    # common constructor, using ostruct for attribute storage
+    attr_accessor :attributes
+    def initialize params = {}
+      @attributes = OpenStruct.new
+      params.map do |k,v|
+        @attributes.send(:"#{k}=",typecast(v))
+      end
     end
-  end
-
-  def self.parse_json json
-    JSON.parse json
-  end
-  
-  def parse_json json 
-    self.class.parse_json json
-  end
-  
-  private
+    
+    def id_attr
+      self.class.id_attr
+    end
+    
+    def save
+      if new?
+        resp = collection.add(attributes)
+        attributes = resp.attributes
+        true
+      else
+        collection.save(attributes)
+      end
+      
+    end
+    alias :update :save
+    
+    def delete
+      collection.delete(attributes)
+    end
+    alias :destroy :delete
+    
+    # Returns <tt>true</tt> if the current site does not exists in the Piwik yet.
+    def new?
+      begin
+        if respond_to?(:id)
+          id.nil? && created_at.blank?
+        else
+          created_at.blank?
+        end
+        
+      rescue Exception => e
+        nil
+      end
+    end
+    
+    #id will try and return the value of the Piwik item id if it exists
+    def id
+      begin
+        if self.class == Piwik::Site
+          self.idsite
+        else
+          attributes.send(:"id#{self.class.to_s.gsub('Piwik::','')}")
+        end
+      rescue Exception => e
+        $stderr.puts e
+      end
+    end
+    
+    #created_at will try and return the value of the Piwik item id if it exists
+    def created_at
+      attributes.send(:ts_created) rescue nil
+    end
+    
+    # delegate attribute calls to @attributes storage
+    def method_missing(method,*args,&block)
+      if self.attributes.respond_to?(method)
+        self.attributes.send(method,*args,&block)
+      else
+        super
+      end
+    end
+    
+    def parse_xml xml; self.class.parse_xml xml; end
+    
     # Calls the supplied Piwik API method, with the supplied parameters.
     # 
     # Returns a string containing the XML reply from Piwik, or raises a 
@@ -61,49 +109,88 @@ EOF
       self.class.call(method, params, config[:piwik_url], config[:auth_token])
     end
     
-    # Calls the supplied Piwik API method, with the supplied parameters.
-    # 
-    # Returns the object parsed from JSON reply from Piwik, or raises a 
-    # <tt>Piwik::ApiError</tt> exception with the error message returned by Piwik 
-    # in case it receives an error.
-    def self.call(method, params={}, piwik_url=nil, auth_token=nil)
-      raise MissingConfiguration, "Please edit #{config_file} to include your piwik url and auth_token or configure Piwik.piwik_url and Piwik.auth_token before use" if piwik_url.nil? || auth_token.nil?
-      url = "#{piwik_url}/?module=API&format=json&method=#{method}"
-      url << "&token_auth=#{auth_token}" unless auth_token.nil?
-      params.each { |k, v| url << "&#{k}=#{CGI.escape(v.to_s)}" }
-      verbose_obj_save = $VERBOSE
-      $VERBOSE = nil # Suppress "warning: peer certificate won't be verified in this SSL session"
-      json = RestClient.get(url)
-      $VERBOSE = verbose_obj_save
-      result = self.parse_json json
-      if json =~ /error message=/
-        raise ApiError, result['error']['message'] if result['error']
-      end
-      result
+    def config
+      @config ||= self.class.load_config_from_file
     end
     
-    # Checks for the config, creates it if not found
-    def self.load_config
-      config = {}
-      if Piwik.is_configured?
-        config = { :piwik_url => Piwik.piwik_url, :auth_token => Piwik.auth_token }
-      else
-        config_file = self.config_file
-        if config_file
-          temp_config = if File.exists?(config_file)
-            YAML::load(open(config_file))
+    def collection
+      self.class.collection
+    end
+    
+    class << self
+      def collection
+        "#{self.to_s.pluralize}".safe_constantize
+      end
+      
+      # This is required to normalize the API responses when the Rails XmlSimple version is used
+      def parse_xml xml
+        result = XmlSimple.xml_in(xml, {'ForceArray' => false})
+        result = result['result'] if result['result']
+        result
+      end
+      
+      def load id
+        collection.get(id_attr => id)
+      end
+      alias :reload :load
+      
+      # Calls the supplied Piwik API method, with the supplied parameters.
+      # 
+      # Returns a string containing the XML reply from Piwik, or raises a 
+      # <tt>Piwik::ApiError</tt> exception with the error message returned by Piwik 
+      # in case it receives an error.
+      def call(method, params, piwik_url=nil, auth_token=nil)
+        params ||= {}
+        raise MissingConfiguration, "Please edit ~/.piwik to include your piwik url and auth_key" if piwik_url.nil? || auth_token.nil?
+        url = "#{piwik_url}/index.php?"
+        params.merge!({:module => 'API', :format => 'xml', :method => method})
+        params.merge!({:token_auth => auth_token}) unless auth_token.nil?
+        url << params.map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }.join('&')
+        verbose_obj_save = $VERBOSE
+        $VERBOSE = nil # Suppress "warning: peer certificate won't be verified in this SSL session"
+        xml = RestClient.get(url)
+        $VERBOSE = verbose_obj_save
+        if xml.is_a?(String) && xml.force_encoding('BINARY').is_binary_data?
+          xml.force_encoding('BINARY')
+        elsif xml =~ /error message=/
+          result = XmlSimple.xml_in(xml, {'ForceArray' => false})
+          raise ApiError, result['error']['message'] if result['error']
+        else
+          xml
+        end
+      end
+      
+      # Checks for the config, creates it if not found
+      def load_config_from_file
+        # Useful for testing or embedding credentials - although as always 
+        # it is not recommended to embed any kind of credentials in source code for security reasons
+        return { :piwik_url => PIWIK_URL, :auth_token => PIWIK_TOKEN } if PIWIK_URL.present? and PIWIK_TOKEN.present?
+        config = {}
+        if defined?(RAILS_ROOT) and RAILS_ROOT != nil
+          home =  RAILS_ROOT
+          filename = "config/piwik.yml"
+        else
+          home =  ENV['HOME'] || ENV['USERPROFILE'] || ENV['HOMEPATH'] || "."
+          filename = ".piwik"
+        end
+        temp_config = if File.exists?(File.join(home,filename))
+          YAML::load(open(File.join(home,filename)))
+        else
+          open(File.join(home,filename),'w') { |f| f.puts @@template }
+          YAML::load(@@template)
+        end
+        temp_config.each { |k,v| config[k.to_sym] = v } if temp_config
+        if config[:piwik_url] == nil || config[:auth_token] == nil
+          if defined?(RAILS_ROOT) and RAILS_ROOT != nil
+            raise MissingConfiguration, "Please edit ./config/piwik.yml to include your piwik url and auth_key"
           else
-            open(config_file,'w') { |f| f.puts @@template }
-            YAML::load(@@template)
+            raise MissingConfiguration, "Please edit ~/.piwik to include your piwik url and auth_key"
           end
-          temp_config.each { |k,v| config[k.to_sym] = v } if temp_config
+
         end
-        raise MissingConfiguration, "Please edit #{config_file} to include piwik url and auth_token or configure Piwik.piwik_url and Piwik.auth_token before use" if config[:piwik_url] == nil || config[:auth_token] == nil
-        #cache settings
-        Piwik.piwik_url = config[:piwik_url]
-        Piwik.auth_token = config[:auth_token]
+        config
       end
-      config
     end
   end
 end
+