coach4rb 0.0.1

data/lib/coach4rb/resource/page.rb

@@ -0,0 +1,74 @@
+module Coach4rb
+
+  module Resource
+
+    class Page
+
+      include Mixin::AutoConstructor
+      include Mixin::Iterable
+      include Mixin::AsHash
+      include Enumerable
+
+      attr_accessor :start, :end, :available, :links, :type, :uri
+
+      def self.from_coach(a_hash, entity_class=Entity)
+        new_hash = a_hash.dup
+        type_plural = pluralize(new_hash[:type]) if new_hash[:type]
+        type_plural ||= false
+        new_hash[:links] ||= []
+        new_hash[:type] = type_plural
+        new_hash[:entity_class] ||= entity_class
+        self.new new_hash
+      end
+
+
+      def entities
+        if @type && @entities.nil?
+          hashes = instance_variable_get("@#{@type}")
+          @entities = hashes.map { |a_hash| @entity_class.from_coach a_hash }
+        else
+          @entities
+        end
+      end
+
+      alias_method :items, :entities
+
+      def size
+        entities.size
+      end
+
+
+      def [](key)
+        case key
+          when Integer
+            entities[key]
+          when Symbol
+            super(key)
+          else
+            raise 'Error: param not supported!'
+        end
+      end
+
+
+      def each(&block)
+        entities.each do |item|
+          block.call item
+        end
+      end
+
+      def to_a
+        entities
+      end
+
+      private
+
+      def self.pluralize(type)
+        type[-1] == 's' ? type : type + 's' # pluralize
+      end
+
+
+    end
+
+  end
+
+end

data/lib/coach4rb/resource/partnership.rb

@@ -0,0 +1,37 @@
+module Coach4rb
+
+  module Resource
+
+    class Partnership < Entity
+
+      attr_accessor :uri, :id, :userconfirmed1, :userconfirmed2,
+                    :datecreated, :publicvisible, :user1, :user2,
+                    :links, :subscriptions
+
+      alias_method :created, :datecreated
+      alias_method :visible, :publicvisible
+      alias_method :first_user, :user1
+      alias_method :second_user, :user2
+      alias_method :first_user_confirmed, :userconfirmed1
+      alias_method :second_user_confirmed, :userconfirmed2
+
+      def self.from_coach(a_hash)
+        new_hash = a_hash.dup
+        new_hash[:datecreated] = Time.at(new_hash[:datecreated]/1000).to_datetime rescue nil
+        new_hash[:subscriptions] ||= []
+        new_hash[:subscriptions] = new_hash[:subscriptions].map {|a_hash| Resource::Subscription.from_coach a_hash }
+        new_hash[:user1] = Resource::User.from_coach(new_hash[:user1]) rescue nil
+        new_hash[:user2] = Resource::User.from_coach(new_hash[:user2]) rescue nil
+        super new_hash
+      end
+
+
+      def entity_path
+        "/partnerships/#{first_user.username};#{second_user.username}"
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/resource/sport.rb

@@ -0,0 +1,19 @@
+module Coach4rb
+
+  module Resource
+
+    class Sport < Entity
+
+      attr_accessor :id, :name, :description
+
+
+      def self.from_coach(a_hash)
+        new_hash = a_hash.dup
+        self.new(new_hash)
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/resource/subscription.rb

@@ -0,0 +1,47 @@
+module Coach4rb
+
+  module Resource
+
+    class Subscription < Entity
+      attr_accessor :id, :uri, :datesubscribed, :publicvisble,
+                    :partnership, :sport, :entries
+
+      alias_method :created, :datesubscribed
+      alias_method :visible, :publicvisble
+
+
+      def self.from_coach(a_hash)
+        new_hash = a_hash.dup
+        new_hash[:datesubscribed] = Time.at(a_hash[:datesubscribed]/1000).to_datetime rescue nil
+        new_hash[:partnership] =  Resource::Partnership.from_coach(new_hash[:partnership]) rescue nil
+        new_hash[:user] =  Resource::User.from_coach(new_hash[:user]) rescue nil
+        new_hash[:entries] =  new_hash[:entries].map {|a_hash| Resource::Entry.from_coach a_hash} rescue []
+        new_hash[:sport] = Resource::Sport.from_coach(new_hash[:sport]) rescue nil
+        super new_hash
+      end
+
+
+      def sport?(sport)
+        raise 'Error: Invalid sport param!' if sport.nil?
+        *, subscription_sport = uri.split('/') # get last part of the uri
+        subscription_sport = subscription_sport.downcase.to_sym
+        sport = sport.to_s.downcase.to_sym
+        sport == subscription_sport
+      end
+
+
+      def entity_path
+        if @user
+          "/users/#{@user.username}/#{@sport}"
+        elsif @partnership
+          "/partnerships/#{@partnership.first_user.username};#{@partnership.second_user.username}/#{@sport}"
+        else
+          raise 'Error: cannot create url!'
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/resource/user.rb

@@ -0,0 +1,49 @@
+module Coach4rb
+
+  module Resource
+
+    class User < Entity
+
+      attr_accessor :username, :password, :email, :realname,
+                    :datecreated, :publicvisible, :partnerships,
+                    :subscriptions
+
+      alias_method :real_name, :realname
+      alias_method :created, :datecreated
+      alias_method :public_visible, :publicvisible
+
+
+      def self.from_coach(a_hash)
+        new_hash = a_hash.dup
+        new_hash[:password] = nil # avoid having a star password
+        new_hash[:partnerships] ||= []
+        new_hash[:partnerships] = new_hash[:partnerships].map {|a_hash| Resource::Partnership.from_coach a_hash }
+        new_hash[:subscriptions] ||= []
+        new_hash[:subscriptions] = new_hash[:subscriptions].map {|a_hash| Resource::Subscription.from_coach a_hash }
+        new_hash[:datecreated] = Time.at(new_hash[:datecreated]/1000).to_datetime rescue nil
+        super(new_hash)
+      end
+
+
+      def entity_path
+        "/users/#{username}"
+      end
+
+
+      private
+
+      def to_flat_hash
+        a_hash = {
+            username: username,
+            password: password,
+            email: email,
+            publicvisible: public_visible,
+            realname: real_name
+        }
+      end
+
+    end
+
+  end
+
+end

data/lib/coach4rb/response_parser.rb

@@ -0,0 +1,11 @@
+module Coach4rb
+
+  class ResponseParser
+
+    def parse
+      raise 'Not implemented!'
+    end
+
+  end
+
+end

data/lib/coach4rb/version.rb

@@ -0,0 +1,3 @@
+module Coach4rb
+  VERSION = "0.0.1"
+end

data/test/test_access_proxy.rb

@@ -0,0 +1,58 @@
+require 'test/test_helper'
+
+class TestAccessProxy < MiniTest::Test
+  include Coach4rb::Mixin::BasicAuth
+
+  def setup
+    @coach = Coach4rb.configure(
+        scheme: 'http',
+        host: 'diufvm31.unifr.ch',
+        port: 8090,
+        path: '/CyberCoachServer/resources'
+    )
+    @proxy = Coach4rb::Proxy::Access.new'privatealex', 'scareface', @coach
+    @invalid_proxy = Coach4rb::Proxy::InvalidAccess.new @coach
+  end
+
+
+  def test_should_still_work_using_a_proxy
+    partnerships = @proxy.partnerships query: {start: 0, size: 10}
+    assert partnerships
+    assert_equal 10, partnerships.size
+  end
+
+  def test_access_on_private_resource_without_a_proxy
+    user = @coach.user 'privatealex', {authorization: basic_auth_encription('privatealex','test')}
+    assert user
+    assert user.username
+  end
+
+  def test_access_on_private_resource_without_a_proxy
+    users = @coach.users query: { start: 0, size: 2000 }, authorization: basic_auth_encryption('privatealex','test')
+    user = users.detect { |u| u.username == 'privatealex' }
+    assert user
+    assert user.username
+
+  end
+
+  def test_should_test_proxy_access
+    assert @proxy.valid?
+    assert @proxy.available?
+    user = @proxy.user 'privatealex'
+    assert user
+    assert user.real_name
+    assert user.email
+    assert user.username
+    assert_equal Coach4rb::Privacy::Private, user.public_visible
+  end
+
+
+
+  def test_should_test_invalid_proxy_access
+    assert @invalid_proxy.available?
+    refute @invalid_proxy.valid?
+  end
+
+
+
+end

data/test/test_client.rb

@@ -0,0 +1,41 @@
+require 'test/test_helper'
+
+class TestClient < MiniTest::Test
+
+  def setup
+    @client = Coach4rb::Client.new(
+        scheme: 'http',
+        host:  'diufvm31.unifr.ch',
+        port:  8090,
+        path:  '/CyberCoachServer/resources'
+    )
+  end
+
+
+  def test_should_have_path
+    assert @client.path
+    assert_equal  '/CyberCoachServer/resources', @client.path
+  end
+
+
+  def test_should_have_site
+    assert 'http://diufvm31.unifr.ch/CyberCoachServer/resources', @client.site
+  end
+
+
+  def test_should_have_port
+    assert 8090, @client.port
+  end
+
+
+  def test_should_have_host
+    assert 'diufvm31.unifr.ch', @client.host
+  end
+
+
+  def test_should_have_scheme
+    assert 'http', @client.scheme
+  end
+
+
+end

data/test/test_coach_client.rb

@@ -0,0 +1,21 @@
+require 'test/test_helper'
+
+class CoachTestRetrieval < MiniTest::Test
+
+  def setup
+    @coach = Coach4rb.configure(
+        scheme: 'http',
+        host: 'diufvm31.unifr.ch',
+        port: 8090,
+        path: '/CyberCoachServer/resources',
+        debug: true
+    )
+  end
+
+
+  def test_if_cyber_coach_is_available
+    assert @coach.available?
+  end
+
+
+end

data/test/test_coach_entry.rb

@@ -0,0 +1,141 @@
+require 'test/test_helper'
+
+class TestCoachEntry < MiniTest::Test
+
+  def setup
+    @coach = Coach4rb.configure(
+        scheme: 'http',
+        host: 'diufvm31.unifr.ch',
+        port: 8090,
+        path: '/CyberCoachServer/resources',
+        debug: true
+    )
+    @proxy = Coach4rb::Proxy::Access.new 'wantsomemoney', 'test', @coach
+    @user = @coach.user 'wantsomemoney'
+    assert @proxy.valid?
+  end
+
+
+  def test_should_get_entry_by_its_uri
+    uri = '/CyberCoachServer/resources/users/wantsomemoney/Running/1132/'
+    entry = @coach.entry_by_uri uri
+    assert entry
+  end
+
+
+  def test_should_get_entry
+    entry = @coach.entry_by_uri '/CyberCoachServer/resources/users/wantsomemoney/Running/1138/'
+    entry = @coach.entry entry
+    assert entry
+  end
+
+
+  def test_should_get_an_entry_of_a_partnership
+    partnership = @coach.partnership 'arueedlinger', 'asarteam5'
+    assert partnership.subscriptions.size > 0
+    running = partnership.subscriptions.detect { |s| s.sport? :running }
+    assert running
+    subscription = @coach.subscription running
+    assert subscription
+    subscription.entries.each do |entry|
+      assert @coach.entry entry
+    end
+
+  end
+
+
+  def test_should_get_an_entry_of_a_user
+    user = @coach.user 'arueedlinger'
+    assert user.subscriptions.size > 0
+    running = user.subscriptions.detect { |s| s.sport? :running }
+    assert running
+    subscription = @coach.subscription running
+    assert subscription
+    subscription.entries.each do |entry|
+      assert @coach.entry entry
+    end
+
+  end
+
+
+  def test_should_create_an_entry_for_a_user
+    res = @proxy.create_entry(@user, :running) do |entry|
+      entry.comment = 'test'
+      entry.number_of_rounds = 10
+      entry.public_visible = Coach4rb::Privacy::Public
+    end
+    assert res
+    assert res.uri
+  end
+
+
+  def test_should_create_an_entry_using_a_uri
+    res = @proxy.create_entry(@user.uri, :running) do |entry|
+      entry.comment = 'test'
+      entry.number_of_rounds = 10
+      entry.public_visible = Coach4rb::Privacy::Public
+    end
+    assert res
+    assert res.uri
+  end
+
+
+  def test_should_create_an_entry_for_a_partnership
+    proxy = Coach4rb::Proxy::Access.new 'arueedlinger', 'test', @coach
+    partnership = @coach.partnership 'arueedlinger', 'asarteam5'
+    res = proxy.create_entry(partnership, :running) do |entry|
+      entry.comment = 'test'
+      entry.number_of_rounds = 10
+      entry.public_visible = Coach4rb::Privacy::Public
+    end
+    assert res
+    assert res.uri
+  end
+
+
+
+  def test_should_update_an_entry_using_a_uri
+    uri = '/CyberCoachServer/resources/users/wantsomemoney/Running/1138/'
+    res = @proxy.update_entry(uri) do |entry|
+      entry.comment = 'Test!!'
+      entry.entry_location = 'sajfsjdjasd'
+      entry.number_of_rounbds = 10000
+      entry.entry_date = DateTime.now
+      entry.track = 'jhasjdhjashjkdasjdjkasndj'
+    end
+    assert res
+    assert res.uri
+  end
+
+
+  def test_should_update_an_entry
+    entry = @proxy.entry_by_uri '/CyberCoachServer/resources/users/wantsomemoney/Running/1139/'
+    updated_entry = @proxy.update_entry(entry) do |entry|
+      entry.comment = 'Test!!'
+      entry.track = 'muhaa!!!!'
+    end
+    assert updated_entry
+    assert updated_entry.uri
+    assert_equal 'Test!!', updated_entry.comment
+    pp updated_entry.read_track
+    assert_equal 'muhaa!!!!', updated_entry.read_track
+  end
+
+
+  def test_should_create_and_delete_an_entry
+    entry = @proxy.create_entry(@user, :running) do |e|
+      e.comment = 'test'
+      e.number_of_rounds = 10
+      e.public_visible = Coach4rb::Privacy::Public
+    end
+
+    assert entry
+    assert @proxy.entry_by_uri entry.uri
+    assert @proxy.delete_entry(entry)
+    sleep 2
+    refute @proxy.entry_by_uri(entry.uri)
+
+  end
+
+
+end