coach_client 0.1.1

data/lib/coach_client/entry.rb

@@ -0,0 +1,248 @@
+module CoachClient
+  # A entry resource of the CyberCoach serivce.
+  class Entry < CoachClient::Resource
+    # @return [Integer]
+    attr_reader :id, :datecreated, :datemodified
+
+    # @return [Integer]
+    attr_accessor :publicvisible, :entryduration
+
+    # @return [Date]
+    attr_accessor :entrydate
+
+    # @return [CoachClient::Subscription]
+    attr_accessor :subscription
+
+    # @return [String]
+    attr_accessor :comment, :entrylocation
+
+    # For every sport but soccer.
+    #
+    # @return [Integer]
+    attr_accessor :numberofrounds
+
+    # For boxing.
+    #
+    # @return [Integer]
+    attr_accessor :roundduration
+
+    # For cycling and running.
+    #
+    # @return [Integer]
+    attr_accessor :courselength
+
+    # For cycling and running.
+    #
+    # @return [String]
+    attr_accessor :coursetype, :track
+
+    # For cycling.
+    #
+    # @return [String]
+    attr_accessor :bicycletype
+
+    # Extracts the entry id from the URI
+    #
+    # @param [String] uri
+    # @return [String] the entry id
+    def self.extract_id_from_uri(uri)
+      match = uri.match(/\/(\d+)\/\z/)
+      match.captures.first
+    end
+
+    # Creates a new entry.
+    #
+    # @param [CoachClient::Client] client
+    # @param [CoachClient::Subscription] subscription
+    # @param [Hash] info
+    # @option info [Integer] :id
+    # @option info [Integer] :publicvisible
+    # @option info [String] :comment
+    # @option info [Date] :entrydate
+    # @option info [Integer] :entryduration
+    # @option info [String] :entrylocation
+    # @return [CoachClient::Entry]
+    def initialize(client, subscription, info = {})
+      super(client)
+      @subscription = subscription
+      @id = info[:id]
+      @publicvisible = info[:publicvisible]
+      @comment = info[:comment]
+      @entrydate = info[:entrydate]
+      @entryduration = info[:entryduration]
+      @entrylocation = info[:entrylocation]
+      unless subscription.sport.sport == :soccer
+        @numberofrounds = info[:numberofrounds]
+      end
+      if subscription.sport.sport == :boxing
+        @roundduration = info[:roundduration]
+      end
+      if subscription.sport.sport == :cycling || subscription.sport.sport == :running
+        @courselength = info[:courselength]
+        @coursetype = info[:coursetype]
+        @track = info[:track]
+      end
+      @bicycletype = info[:bicycletype] if subscription.sport.sport == :cycling
+    end
+
+    # Updates the entry with the data from the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the entry does not exist
+    # @return [CoachClient::User] the updated user
+    def update
+      raise CoachClient::NotFound, 'Entry not found' unless exist?
+      response = if user.authenticated?
+                   CoachClient::Request.get(url, username: user.username,
+                                            password: user.password)
+                 else
+                   CoachClient::Request.get(url)
+                 end
+      tag = "entry#{@subscription.sport}"
+      response = response.to_h[tag.to_sym]
+      @datecreated = response[:datecreated]
+      @datemodified = response[:datemodified]
+      @publicvisible = response[:publicvisible]
+      @comment = response[:comment]
+      @entrydate = response[:entrydate]
+      @entryduration = response[:entryduration]
+      @entrylocation = response[:entrylocation]
+      unless @subscription.sport.sport == :soccer
+        @numberofrounds = response[:numberofrounds]
+      end
+      if @subscription.sport.sport == :boxing
+        @roundduration = response[:roundduration]
+      end
+      if @subscription.sport.sport == :cycling || @subscription.sport.sport == :running
+        @courselength = response[:courselength]
+        @coursetype = response[:coursetype]
+        @track = response[:track]
+      end
+      @bicycletype = response[:bicycletype] if @subscription.sport.sport == :cycling
+      self
+    end
+
+    # Creates the entry on the CyberCoach service.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @raise [CoachClient::IncompleteInformation] if not all needed information
+    #   is given
+    # @raise [CoachClient::NotSaved] if the entry could not be saved
+    # @return [CoachClient::Entry] the created entry
+    def create
+      unless user.authenticated?
+        raise CoachClient::Unauthorized.new(user), 'Unauthorized'
+      end
+      begin
+        response = CoachClient::Request.post(@subscription.url,
+                                             username: user.username,
+                                             password: user.password,
+                                             payload: payload,
+                                             content_type: :xml)
+      rescue RestClient::Conflict
+        raise CoachClient::IncompleteInformation.new(self), 'Incomplete information'
+      end
+      unless response.code == 200 || response.code == 201
+        raise CoachClient::NotSaved.new(self), 'Could not create entry'
+      end
+      @id = self.class.extract_id_from_uri(response.header[:location])
+      self
+    end
+
+    # Saves the entry to the CyberCoach service.
+    #
+    # The entry is created if it does not exist on the CyberCoach service,
+    # otherwise it tries to overwrite it.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @raise [CoachClient::IncompleteInformation] if not all needed information
+    #   is given
+    # @raise [CoachClient::NotSaved] if the entry could not be saved
+    # @return [CoachClient::Entry] the created entry
+    def save
+      return create unless @id
+      unless user.authenticated?
+        raise CoachClient::Unauthorized.new(user), 'Unauthorized'
+      end
+      begin
+        response = CoachClient::Request.put(url, username: user.username,
+                                            password: user.password,
+                                            payload: payload,
+                                            content_type: :xml)
+      rescue RestClient::Conflict
+        raise CoachClient::IncompleteInformation.new(self), 'Incomplete information'
+      end
+      unless response.code == 200 || response.code == 201
+        raise CoachClient::NotSaved.new(self), 'Could not save entry'
+      end
+      self
+    end
+
+    # Returns the user that is used for the authentication.
+    #
+    # @return [CoachClient::User]
+    def user
+      if @subscription.is_a?(CoachClient::PartnershipSubscription)
+        partnership = @subscription.partnership
+        if partnership.user1.authenticated?
+          partnership.user1
+        else
+          partnership.user2
+        end
+      else
+        @subscription.user
+      end
+    end
+
+    # Deletes the entry on the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the entry does not exist
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @return [true]
+    def delete
+      raise CoachClient::NotFound.new(self), 'Entry not found' unless exist?
+      unless user.authenticated?
+        raise CoachClient::Unauthorized.new(user), 'Unauthorized'
+      end
+      CoachClient::Request.delete(url, username: user.username,
+                                  password: user.password)
+      true
+    end
+
+    # Returns whether the resource exists on the CyberCoach service.
+    #
+    # @return [Boolean]
+    def exist?
+      return false unless @id
+      if user.authenticated?
+        super(username: user.username, password: user.password)
+      else
+        super
+      end
+    end
+
+    # Returns the URL of the entry.
+    #
+    # @return [String] the url of the entry
+    def url
+      "#{@subscription.url}/#{@id}"
+    end
+
+    # Returns the string representation of the entry.
+    #
+    # @return [String]
+    def to_s
+      @id.to_s
+    end
+
+    private
+
+    def payload
+      vals = self.to_h
+      vals.delete(:subscription)
+      vals.delete_if { |_k, v| v.nil? || v.to_s.empty? }
+      tag = "entry#{@subscription.sport}"
+      Gyoku.xml(tag.to_sym => vals)
+    end
+  end
+end
+

data/lib/coach_client/exceptions.rb

@@ -0,0 +1,78 @@
+module CoachClient
+  # The standard exception for CoachClient errors.
+  class Exception < StandardError; end
+
+  # The error when the resource could not be found on the CyberCoach service.
+  class NotFound < CoachClient::Exception; end
+
+  # The error for resources that could not have been saved.
+  class NotSaved < CoachClient::Exception
+    # Returns the resource that encountered the error.
+    #
+    # @return [CoachClient::Resource]
+    attr_reader :resource
+
+    # @param [CoachClient::Resource] resource
+    # @return [CoachClient::NotSaved]
+    def initialize(resource)
+      @resource = resource
+    end
+  end
+
+  # Returns the error for partnerships that could not be confirmed.
+  class NotConfirmed < CoachClient::Exception
+    # Returns the partnership that encountered the error.
+    #
+    # @return [CoachClient::Partnership]
+    attr_reader :partnership
+
+    # @param [CoachClient::Partnership] partnership
+    # @return [CoachClient::NotConfirmed]
+    def initialize(partnership)
+      @partnership = partnership
+    end
+  end
+
+  # The error for partnerships that could not be proposed.
+  class NotProposed < CoachClient::Exception
+    # Returns the partnership that encountered the error.
+    #
+    # @return [CoachClient::Partnership]
+    attr_reader :partnership
+
+    # @param [CoachClient::Partnership] partnership
+    # @return [CoachClient::NotProposed]
+    def initialize(partnership)
+      @partnership = partnership
+    end
+  end
+
+  # The error that the user is not authorized to see the resource.
+  class Unauthorized < CoachClient::Exception
+    # Returns the user that encountered the error.
+    #
+    # @return [CoachClient::User]
+    attr_reader :user
+
+    # @param [CoachClient::User] user
+    # @return [CoachClient::Unauthorized]
+    def initialize(user = nil)
+      @user = user
+    end
+  end
+
+  # The error for missing informations of a resource.
+  class IncompleteInformation < CoachClient::Exception
+    # Returns the resource that encountered the error.
+    #
+    # @return [CoachClient::Resource]
+    attr_reader :resource
+
+    # @param [CoachClient::Resource] resource
+    # @return [CoachClient::IncompleteInformation]
+    def initialize(resource)
+      @resource = resource
+    end
+  end
+end
+

data/lib/coach_client/partnership.rb

@@ -0,0 +1,294 @@
+module CoachClient
+  # A partnership resource of the CyberCoach service.
+  class Partnership < CoachClient::Resource
+    # The size of the requests for the {.list} with all = true
+    LIST_ALL_SIZE = 1000
+
+    # @return [Integer]
+    attr_reader :id, :datecreated
+
+    # @return [Boolean]
+    attr_reader :user1_confirmed, :user2_confirmed
+
+    # @return [Array<CoachClient::Subscription>]
+    attr_reader :subscriptions
+
+    # @return [CoachClient::User]
+    attr_accessor :user1, :user2
+
+    # @return [Integer]
+    attr_accessor :publicvisible
+
+    # Returns the relative path to the partnership resource.
+    #
+    # @return [String] the relative path
+    def self.path
+      'partnerships/'
+    end
+
+    # Extracts the usernames from the partnership URI
+    #
+    # @param [String] uri
+    # @return [Array<String>] the usernames
+    def self.extract_users_from_uri(uri)
+      match = uri.match(/partnerships\/(\w+);(\w+)\//)
+      match.captures
+    end
+
+    # Returns the total number of partnerships present on the CyberCoach service.
+    #
+    # @param [CoachClient::Client] client
+    # @return [Integer] the total number of partnerships
+    def self.total(client)
+      response = CoachClient::Request.get(client.url + path,
+                                          params: { size: 0 })
+      response.to_h[:available]
+    end
+
+    # Returns a list of partnerships from the CyberCoach service for which the
+    # given block returns a true value.
+    #
+    # If no block is given, the whole list is returned.
+    #
+    # @param [CoachClient::Client] client
+    # @param [Integer] size
+    # @param [Integer] start
+    # @param [Boolean] all
+    # @yieldparam [CoachClient::Partnership] partnership the partnership
+    # @yieldreturn [Boolean] whether the partnership should be added to the list
+    # @return [Array<CoachClient::Partnership>] the list of partnerships
+    def self.list(client, size: 20, start: 0, all: false)
+      list  = []
+      if all
+        total = self.total(client)
+        start = 0
+        size = LIST_ALL_SIZE
+      end
+      loop do
+        response = CoachClient::Request.get(client.url + path,
+                                            params: { start: start, size: size })
+        response.to_h[:partnerships].each do |p|
+          user1, user2 = extract_users_from_uri(p[:uri])
+          partnership = self.new(client, user1, user2)
+          list << partnership if !block_given? || yield(partnership)
+        end
+        break unless all
+        start += size
+        break if start >= total
+      end
+      list
+    end
+
+    # Creates a new partnership.
+    #
+    # @param [CoachClient::Client] client
+    # @param [String, CoachClient::User] user1
+    # @param [String, CoachClient::User] user2
+    # @param [Integer] publicvisible
+    # @return [CoachClient::Partnership]
+    def initialize(client, user1, user2, publicvisible: nil)
+      super(client)
+      @user1 = if user1.is_a?(CoachClient::User)
+                 user1
+               else
+                 CoachClient::User.new(client, user1)
+               end
+      @user2 = if user2.is_a?(CoachClient::User)
+                 user2
+               else
+                 CoachClient::User.new(client, user2)
+               end
+      @publicvisible = publicvisible
+    end
+
+    # Updates the partnership with the data from the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the partnership does not exist
+    # @return [CoachClient::Partnership] the updated partnership
+    def update
+      raise CoachClient::NotFound.new(self), 'Partnership not found' unless exist?
+      response = if @user1.authenticated?
+                   CoachClient::Request.get(url, username: @user1.username,
+                                            password: @user1.password)
+                 elsif @user2.authenticated?
+                   CoachClient::Request.get(url, username:@user2.username,
+                                            password: @user2.password)
+                 else
+                   CoachClient::Request.get(url)
+                 end
+      response = response.to_h
+      @id = response[:id]
+      @datecreated = response[:datecreated]
+      @publicvisible = response[:publicvisible]
+      @user1_confirmed = response[:userconfirmed1]
+      @user2_confirmed = response[:userconfirmed2]
+      @subscriptions = []
+      unless response[:subscriptions].nil?
+        response[:subscriptions].each do |s|
+          sport = s[:uri].match(/\/(\w+)\/\z/).captures.first
+          @subscriptions << CoachClient::PartnershipSubscription.new(client, self,
+                                                                     sport)
+        end
+      end
+      self
+    end
+
+    # Saves the partnership to the CyberCoach service.
+    #
+    # The partnership is created if it does not exist on the CyberCoach service,
+    # otherwise it tries to overwrite it.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @raise [CoachClient::IncompleteInformation] if not all needed information
+    #   is given
+    # @raise [CoachClient::NotSaved] if the partnership could not be saved
+    # @return [CoachClient::Partnership] the saved partnership
+    def save
+      unless operational?
+        propose unless @user1_confirmed
+        return confirm
+      end
+      user1 = @user1.authenticated?
+      user2 = @user2.authenticated? unless user1
+      unless user1 || user2
+        raise CoachClient::Unauthorized.new(@user2), 'Unauthorized'
+      end
+      begin
+        response = if user1
+                     CoachClient::Request.put(url, username: @user1.username,
+                                              password: @user1.password,
+                                              payload: payload,
+                                              content_type: :xml)
+                   else
+                     CoachClient::Request.put(url, username: @user2.username,
+                                              password: @user2.password,
+                                              payload: payload,
+                                              content_type: :xml)
+                   end
+      rescue RestClient::Conflict
+        raise CoachClient::IncompleteInformation.new(self), 'Incomplete information'
+      end
+      unless response.code == 200 || response.code == 201
+        raise CoachClient::NotSaved.new(self), 'Could not save partnership'
+      end
+      self
+    end
+
+    # Proposes the partnership on the CyberCoach service.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @raise [CoachClient::IncompleteInformation] if not all needed information
+    #   is given
+    # @raise [CoachClient::NotProposed] if the partnership could not be proposed
+    # @return [CoachClient::Partnership] the proposed partnership
+    def propose
+      unless @user1.authenticated?
+        raise CoachClient::Unauthorized.new(@user1), 'Unauthorized'
+      end
+      begin
+        response = CoachClient::Request.put(url, username: @user1.username,
+                                            password: @user1.password,
+                                            payload: payload,
+                                            content_type: :xml)
+      rescue RestClient::Conflict
+        raise CoachClient::IncompleteInformation.new(self), 'Incomplete information'
+      end
+      unless response.code == 200 || response.code == 201
+        raise CoachClient::NotProposed.new(self), 'Could not propose partnership'
+      end
+      @user1_confirmed = true
+      self
+    end
+
+    # Confirms the partnership on the CyberCoach service.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @raise [CoachClient::IncompleteInformation] if not all needed information
+    #   is given
+    # @raise [CoachClient::NotConfirmed] if the partnership could not be proposed
+    # @return [CoachClient::Partnership] the confirmed partnership
+    def confirm
+      unless @user2.authenticated?
+        raise CoachClient::Unauthorized.new(@user2), 'Unauthorized'
+      end
+      begin
+        response = CoachClient::Request.put(url, username: @user2.username,
+                                            password: @user2.password,
+                                            payload: payload,
+                                            content_type: :xml)
+      rescue RestClient::Conflict
+        raise CoachClient::IncompleteInformation.new(self), 'Incomplete information'
+      end
+      unless response.code == 200 || response.code == 201
+        raise CoachClient::NotConfirmed.new(self), 'Could not confirm partnership'
+      end
+      @user2_confirmed = true
+      self
+    end
+
+    # Invalidates the partnership on the CyberCoach service.
+    #
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @return [CoachClient::Partnership] the invalidated partnership
+    def invalidate
+      unless @user2.authenticated?
+          raise CoachClient::Unauthorized.new(@user2), 'Unauthorized'
+      end
+      CoachClient::Request.delete(url, username: @user2.username,
+                                  password: @user2.password)
+      @user2_confirmed = false
+      self
+    end
+
+    # Deletes the partnership on the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the partnership does not exist
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @return [true]
+    def delete
+      raise CoachClient::NotFound unless exist?
+      invalidate if user2_confirmed
+      if user1_confirmed
+        unless @user1.authenticated?
+          raise CoachClient::Unauthorized.new(@user1), 'Unauthorized'
+        end
+        CoachClient::Request.delete(url, username: @user1.username,
+                                    password: @user1.password)
+      end
+      @user1_confirmed = false
+      true
+    end
+
+    # Returns whether the partnership is operational.
+    #
+    # @return [Boolean]
+    def operational?
+      @user1_confirmed && @user2_confirmed
+    end
+
+    # Returns the URL of the partnership.
+    #
+    # @return [String] the url of the partnership
+    def url
+      "#{@client.url}#{self.class.path}#{@user1.username};#{@user2.username}"
+    end
+
+    # Returns the string representation of the user.
+    #
+    # @return [String]
+    def to_s
+      "#{@user1.username};#{@user2.username}"
+    end
+
+    private
+
+    def payload
+      vals = self.to_h
+      vals.delete(:user1)
+      vals.delete(:user2)
+      vals.delete_if { |_k, v| v.nil? || v.to_s.empty? }
+      Gyoku.xml(partnership: vals)
+    end
+  end
+end
+