coach4rb 0.0.1

data/lib/coach4rb/json_response_parser.rb

@@ -0,0 +1,11 @@
+module Coach4rb
+
+  class JsonResponseParser < ResponseParser
+
+    def parse(response)
+      JSON.parse response, symbolize_names: true
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/as_hash.rb

@@ -0,0 +1,34 @@
+module Coach4rb
+
+  module Mixin
+
+    module AsHash
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+
+      module InstanceMethods
+
+        # Converts this object to a hash.
+        #
+        def to_hash
+          variables = instance_variables
+          hash = {}
+          variables.each do |name|
+            key = name.to_s.sub(/^@/, '')
+            hash[key.to_sym] = instance_variable_get(name)
+          end
+          hash
+        end
+
+        alias_method :to_h, :to_hash
+
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/auto_constructor.rb

@@ -0,0 +1,71 @@
+module Coach4rb
+
+  module Mixin
+
+    # This module provides an auto constructor and automatically provides
+    # setters and getters for instance variables.
+    #
+    # The instance variables are created by the given hash
+    # which is passed to the constructor.
+    #
+    # The keys in the hash are used as instance variable names and the corresponding
+    # values are used to initialize the instance variable values.
+    #
+    # ==== Examples
+    #
+    #   class Test
+    #       include Behaviours::AutoConstructor
+    #   end
+    #
+    #   test = Test.new { name: 'alex' }
+    #   test.name # => 'alex'
+    #
+    module AutoConstructor
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        # Creates a object using the keys and values given in the hash.
+        #
+        # == Parameters:
+        # @param a_hash [Hash] declaring the instance variables. The keys define the variable names
+        #   and the corresponding values the initial values.
+        #
+        # @return [Object] the object specified by the given hash.
+        def initialize(a_hash={})
+          raise 'Param a_hash is not a hash!' unless a_hash.is_a? Hash
+          a_hash.each do |key, value|
+            instance_variable_set("@#{key}", value)
+          end
+        end
+
+
+        # Provides hash-like access on the properties of this object.
+        # @param key [Symbol] used to access the corresponding property.
+        #
+        def [](key)
+          if value = instance_variable_get("@#{key}")
+            value
+          else
+            send key rescue nil
+          end
+        end
+
+
+        # Provides hash-like access on the properties of this object.
+        # @param key [Symbol] used to access the corresponding property.
+        #
+        def []=(key,value)
+          instance_variable_set("@#{key}",value)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/basic_auth.rb

@@ -0,0 +1,23 @@
+module Coach4rb
+
+  module Mixin
+
+    module BasicAuth
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def basic_auth_encryption(username, password)
+          'Basic ' + Base64.encode64("#{username}:#{password}").chomp
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/iterable.rb

@@ -0,0 +1,40 @@
+module Coach4rb
+
+  module Mixin
+
+    module Iterable
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def has_next?
+          link = self.next
+          link ? link[:href] : false
+        end
+
+
+        def next
+          links.detect { |link| link[:description] == 'next'}
+        end
+
+
+        def has_previous?
+          link = previous
+          link ? link[:href] : false
+        end
+
+
+        def previous
+          links.detect { |link| link[:description] == 'previous'}
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/track_reader.rb

@@ -0,0 +1,24 @@
+module Coach4rb
+
+  module Mixin
+
+
+    module TrackReader
+
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+
+        def read_track
+          Base64.decode64(track)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/mixin/track_writer.rb

@@ -0,0 +1,19 @@
+module Coach4rb
+
+  module Mixin
+
+    module TrackWriter
+
+      def track=(param)
+        struct.track = Base64.encode64(param)
+      end
+
+      def track
+        Base64.decode64(struct.track)
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/privacy.rb

@@ -0,0 +1,11 @@
+module Coach4rb
+
+  module Privacy
+
+    Public = 2
+    Member = 1
+    Private = 0
+
+  end
+
+end

data/lib/coach4rb/proxy.rb

@@ -0,0 +1,143 @@
+module Coach4rb
+
+  # This module provides global access to the cyber coach resources in the scope
+  # of the given user credentials.
+  #
+  module Proxy
+
+    # This class provides an interface that all subclasses must implement.
+    #
+    class Base
+      include Mixin::BasicAuth
+
+      attr_reader :coach
+
+      # Base access proxy which is extended by the subclasses to provide more specific access to the coach client.
+      #
+      # @param [Coach] coach
+      #
+      def initialize(coach)
+        @coach = coach
+      end
+
+
+      def username
+        raise 'Not implemented!'
+      end
+
+
+      def password
+        raise 'Not implemented!'
+      end
+
+      # Always returns an empty hash.
+      # @return [Hash]
+      #
+      def proxy_options
+        {}
+      end
+
+
+      # Tests if the provided user credentials are valid.
+      # @return [Boolean]
+      #
+      def valid?
+        begin
+          coach.authenticate(username, password)
+        rescue
+          false
+        end
+      end
+
+
+      # Delegates all messages send to this proxy to the coach client
+      #
+      def method_missing(meth, *args, &block)
+        params = *args
+
+        # handle options hash
+        if params.last.is_a?(Hash) # if last param is a hash then it's a option hash.
+          params[-1] = params.last.merge(proxy_options)
+        else # otherwise add a option hash with the given proxy options.
+          params << proxy_options
+        end
+
+        # check if coach responds to the message meth / or method meth
+        if coach.respond_to?(meth)
+          begin # try to pass the options hash
+            coach.send meth, *params, &block
+          rescue # otherwise do it without options hash
+            coach.send meth, *args, &block
+          end
+        else
+          raise 'Error: Method missing in coach!'
+        end
+      end
+    end
+
+
+    # This class provides a general access proxy for the cyber coach service.
+    # It is used to have global access to the cuber coach service in the perspective of a specific user.
+    #
+    class Access < Base
+
+      attr_reader :username, :password
+
+      # Creates an access proxy which provides global access to the cyber coach in the scope of the
+      # given user credentials.
+      #
+      # @param [String] username
+      # @param [String] password
+      # @param [Coach] coach
+      #
+      def initialize(username, password, coach)
+        @username = username
+        @password = password
+        @coach = coach
+        @base64 = basic_auth_encryption(@username, @password)
+      end
+
+
+      # Returns an hash with basic auth http options.
+      # @return [Hash]
+      #
+      def proxy_options
+        {authorization: @base64}
+      end
+
+    end
+
+
+    # This class provides an invalid access proxy which will always fail.
+    #
+    class InvalidAccess < Base
+
+      # Returns always false.
+      # @return [FalseClass]
+      #
+      def valid?
+        false
+      end
+
+
+      # Returns always nil.
+      # @return [NilClass]
+      #
+      def username
+        nil
+      end
+
+
+      # Returns always nil.
+      # @return [NilClass]
+      #
+      def password
+        nil
+      end
+
+    end
+
+  end
+
+
+end

data/lib/coach4rb/resource/entity.rb

@@ -0,0 +1,47 @@
+module Coach4rb
+
+  module Resource
+
+    class Entity
+
+      include Mixin::AutoConstructor
+      include Mixin::Iterable
+      include Mixin::AsHash
+      include Enumerable
+
+      attr_accessor :uri, :links
+
+      def self.from_coach(param)
+        a_hash = param.dup
+        a_hash[:links] ||= []
+        self.new a_hash
+      end
+
+
+      def each(&block)
+        instance_variables.each do |variable|
+          value = instance_variable_get(variable)
+          block.call variable, value
+        end
+      end
+
+
+      def [](key)
+        case key
+          when Symbol
+            super(key)
+          else
+            raise 'Error: param not supported!'
+        end
+      end
+
+
+      def entity_path
+        raise 'Not implemented!'
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/resource/entry.rb

@@ -0,0 +1,126 @@
+module Coach4rb
+
+  module Resource
+
+    class Entry < Entity
+
+      attr_accessor :id, :uri, :datecreated, :datemodified,
+                    :entrydate, :comment, :entryduration,
+                    :subscription, :entrylocation
+
+      alias_method :created, :datecreated
+      alias_method :modified, :datemodified
+
+      alias_method :entry_date, :entrydate
+      alias_method :entry_location, :entrylocation
+
+
+      def self.from_coach(a_hash)
+        entry_type = get_type(a_hash)
+        raise 'Error: Entry type not supported!' unless CLASS.keys.include?(entry_type)
+
+        entry = a_hash[entry_type].dup
+        entry[:datecreated] = Time.at(entry[:datecreated]/1000).to_datetime if entry[:datecreated]
+        entry[:datemodified] = Time.at(entry[:datemodified]/1000).to_datetime if entry[:datemodified]
+        entry[:subscription] = Resource::Subscription.from_coach entry[:subscription] if entry[:subscription]
+        entry[:links] ||= []
+
+        klass = CLASS[entry_type] # pick the right class to create the entry
+        klass.new(entry)
+      end
+
+
+      def type
+        raise 'Not implemented!'
+      end
+
+
+      private
+
+      def self.get_type(a_hash)
+        a_hash.keys.first
+      end
+
+    end
+
+
+    class Running < Entry
+
+      include Mixin::TrackReader
+
+      attr_accessor :coursetype, :courselength, :numberofrounds, :track
+
+      alias_method :course_type, :coursetype
+      alias_method :course_length, :courselength
+      alias_method :number_of_rounds, :numberofrounds
+
+
+      def type
+        :running
+      end
+
+    end
+
+
+    class Boxing < Entry
+
+      attr_accessor :roundduration, :numberofrounds
+
+      alias_method :round_duration, :roundduration
+      alias_method :number_of_rounds, :numberofrounds
+
+
+
+      def type
+        :boxing
+      end
+
+    end
+
+
+    class Soccer < Entry
+
+      def type
+        :soccer
+      end
+
+    end
+
+
+    class Cycling < Entry
+
+      include Mixin::TrackReader
+
+      attr_accessor :coursetype, :courselength, :numberofrounds,
+                    :bicycletype, :track
+
+      alias_method :course_type, :coursetype
+      alias_method :course_length, :courselength
+      alias_method :number_of_rounds, :numberofrounds
+      alias_method :bicycle_type, :bicycletype
+
+
+      def type
+        :cycling
+      end
+
+    end
+
+
+    class Entry
+
+      # lookup table which associates the types to the correct classes.
+      CLASS = {
+          # :type => Class
+          :entryrunning => Running,
+          :entrysoccer => Soccer,
+          :entryboxing => Boxing,
+          :entrycycling => Cycling
+      }
+
+    end
+
+
+  end
+
+end