coach_client 0.1.1

data/lib/coach_client/partnership_subscription.rb

@@ -0,0 +1,99 @@
+module CoachClient
+  # A partnership subscription resource of the CyberCoach service.
+  class PartnershipSubscription < CoachClient::Subscription
+    # @return [Integer]
+    attr_reader :id, :datesubscribed
+
+    # @return [CoachClient::Partnership]
+    attr_accessor :partnership
+
+    # Returns the relative path to the partnership subscription resource.
+    #
+    # @return [String] the relative path
+    def self.path
+      'partnerships/'
+    end
+
+    # Creates a new partnership subscription.
+    #
+    # @param [CoachClient::Client] client
+    # @param [String, CoachClient::Partnership] partnership
+    # @param [String, Symbol, CoachClient::Sport] sport
+    # @param [Integer] publicvisible
+    # @return [CoachClient::PartnershipSubscription]
+    def initialize(client, partnership, sport, publicvisible: nil)
+      super(client, sport, publicvisible: publicvisible)
+      @partnership = if partnership.is_a?(CoachClient::Partnership)
+                       partnership
+                     else
+                       uri = "partnerships/#{partnership}/"
+                       users = CoachClient::Partnership.extract_users_from_uri(uri)
+                       CoachClient::Partnership.new(client, *users)
+                     end
+    end
+
+    # Updates the partnership subscription with the data from the CyberCoach
+    # service.
+    #
+    # @raise [CoachClient::NotFound] if the partnership subscription does not
+    #   exist
+    # @return [CoachClient::PartnershipSubscription] the updated partnership
+    #   subscription
+    def update
+      if @partnership.user1.authenticated?
+        super(@partnership.user1)
+      else
+        super(@partnership.user2)
+      end
+    end
+
+    # Saves the partnership subscription to the CyberCoach service.
+    #
+    # The partnership subscription 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 subscription could not
+    #   be saved
+    # @return [CoachClient::PartnershipSubscription] the saved partnership
+    #   subscription
+    def save
+      if @partnership.user1.authenticated?
+        super(@partnership.user1)
+      else
+        super(@partnership.user2)
+      end
+    end
+
+    # Deletes the partnership subscription on the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the partnership subscription does not
+    #   exist
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @return [true]
+    def delete
+      if @partnership.user1.authenticated?
+        super(@partnership.user1)
+      else
+        super(@partnership.user2)
+      end
+    end
+
+    # Returns the URL of the partnership subscription.
+    #
+    # @return [String] the url of the partnership subscription
+    def url
+      "#{@partnership.url}/#{@sport}"
+    end
+
+    # Returns the string representation of the partnership subscription.
+    #
+    # @return [String]
+    def to_s
+      "#{@partnership}/#{@sport}"
+    end
+  end
+end
+

data/lib/coach_client/request.rb

@@ -0,0 +1,99 @@
+module CoachClient
+  # Request methods for the HTTP verbs GET, PUT, POST, DELETE.
+  module Request
+    # The default header.
+    DEFAULT_HEADER = { accept: :json }
+
+    # GET request to the RESTful service.
+    #
+    # @param [String] url
+    # @param [String] username
+    # @param [String] password
+    # @param [Hash] header
+    # @return [CoachClient::Response]
+    def self.get(url, username: nil, password: nil, **header)
+      header.merge!(DEFAULT_HEADER)
+      begin
+        response = RestClient::Request.execute(method: :get, url: url,
+                                               user: username,
+                                               password: password,
+                                               headers: header)
+      rescue RestClient::ResourceNotFound => e
+        raise CoachClient::NotFound, e.message
+      rescue RestClient::Unauthorized => e
+        raise CoachClient::Unauthorized, e.message
+      end
+      CoachClient::Response.new(response.headers, response.body, response.code)
+    end
+
+    # PUT request to the RESTful service.
+    #
+    # @param [String] url
+    # @param [String] username
+    # @param [String] password
+    # @param [String] payload required
+    # @param [Hash] header
+    # @return [CoachClient::Response]
+    def self.put(url, username: nil, password: nil, payload:, **header)
+      header.merge!(DEFAULT_HEADER)
+      begin
+        response = RestClient::Request.execute(method: :put, url: url,
+                                               user: username,
+                                               password: password,
+                                               payload: payload,
+                                               headers: header)
+      rescue RestClient::ResourceNotFound => e
+        raise CoachClient::NotFound, e.message
+      rescue RestClient::Unauthorized => e
+        raise CoachClient::Unauthorized, e.message
+      end
+      CoachClient::Response.new(response.headers, response.body, response.code)
+    end
+
+    # POST request to the RESTful service.
+    #
+    # @param [String] url
+    # @param [String] username
+    # @param [String] password
+    # @param [String] payload required
+    # @param [Hash] header
+    # @return [CoachClient::Response]
+    def self.post(url, username: nil, password: nil, payload:, **header)
+      header.merge!(DEFAULT_HEADER)
+      begin
+        response = RestClient::Request.execute(method: :post, url: url,
+                                               user: username,
+                                               password: password,
+                                               payload: payload,
+                                               headers: header)
+      rescue RestClient::ResourceNotFound => e
+        raise CoachClient::NotFound, e.message
+      rescue RestClient::Unauthorized => e
+        raise CoachClient::Unauthorized, e.message
+      end
+      CoachClient::Response.new(response.headers, response.body, response.code)
+    end
+
+    # DELETE request to the RESTful service.
+    #
+    # @param [String] url
+    # @param [String] username
+    # @param [String] password
+    # @param [Hash] header
+    # @return [CoachClient::Response]
+    def self.delete(url, username: nil, password: nil, **header)
+      begin
+        response = RestClient::Request.execute(method: :delete, url: url,
+                                               user: username,
+                                               password: password,
+                                               headers: header)
+      rescue RestClient::ResourceNotFound => e
+        raise CoachClient::NotFound, e.message
+      rescue RestClient::Unauthorized => e
+        raise CoachClient::Unauthorized, e.message
+      end
+      CoachClient::Response.new(response.headers, response.body, response.code)
+    end
+  end
+end
+

data/lib/coach_client/resource.rb

@@ -0,0 +1,48 @@
+module CoachClient
+  # A resource of the CyberCoach service.
+  class Resource
+    # @return [CoachClient::Client]
+    attr_accessor :client
+
+    # Creates a new resource.
+    #
+    # @param [CoachClient::Client] client
+    # @return [CoachClient::Resource]
+    def initialize(client)
+      @client = client
+    end
+
+    # Returns whether the resource exists on the CyberCoach service.
+    #
+    # @param [String] username
+    # @param [String] password
+    # @return [Boolean]
+    def exist?(username: nil, password: nil)
+      begin
+        CoachClient::Request.get(url, username: username, password: password)
+        true
+      rescue CoachClient::NotFound
+        false
+      end
+    end
+
+    # Returns the hash representation of the resource.
+    #
+    # @return [Hash]
+    def to_h
+      hash = {}
+      instance_variables.each do |var|
+        next if var.to_s == '@client'
+        value = instance_variable_get(var)
+        hash[var.to_s.delete('@').to_sym] =
+          if value && value.respond_to?(:to_h) && !value.is_a?(Array)
+            value.to_h
+          else
+            value
+          end
+      end
+      hash
+    end
+  end
+end
+

data/lib/coach_client/response.rb

@@ -0,0 +1,37 @@
+module CoachClient
+  # A response from RESTful request to the CyberCoach service.
+  class Response
+    # @return [Integer] the HTTP code
+    attr_reader :code
+
+    # @return [String] the HTTP headers
+    attr_reader :header
+
+    # Creates a new response.
+    #
+    # @param [String] header the headers of the HTTP response
+    # @param [String] body the body of the HTTP response
+    # @param [Integer] code the HTTP response code
+    # @return [CoachClient::Response]
+    def initialize(header, body, code)
+      @header = header
+      @body = body
+      @code = code
+    end
+
+    # Returns the body as Ruby Hash.
+    #
+    # @return [Hash]
+    def to_h
+      JSON.parse(@body, symbolize_names: true)
+    end
+
+    # Returns the body as String.
+    #
+    # @return [String]
+    def to_s
+      @body.to_s
+    end
+  end
+end
+

data/lib/coach_client/sport.rb

@@ -0,0 +1,88 @@
+module CoachClient
+  # A sport resource of the CyberCoach service.
+  class Sport < CoachClient::Resource
+    # @return [Integer]
+    attr_reader :id
+
+    # @return [Symbol]
+    attr_reader :sport
+
+    # @return [String]
+    attr_reader :name, :description
+
+    # Returns the relative path to the sport resource.
+    #
+    # @return [String] the relative path
+    def self.path
+      'sports/'
+    end
+
+    # Returns the total number of sports present on the CyberCoach service.
+    #
+    # @param [CoachClient::Client] client
+    # @return [Integer] the total number of sports
+    def self.total(client)
+      response = CoachClient::Request.get(client.url + path,
+                                          params: { size: 0 })
+      response.to_h[:available]
+    end
+
+    # Returns a list of sports 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
+    # @yieldparam [CoachClient::Sport] sport the sport
+    # @yieldreturn [Boolean] whether the sport should be added to the list
+    # @return [Array<CoachClient::Sport>] the list of sports
+    def self.list(client)
+      sportlist  = []
+      response = CoachClient::Request.get(client.url + path)
+      response.to_h[:sports].each do |s|
+        sport = self.new(client, s[:name])
+        sportlist << sport if !block_given? || yield(sport)
+      end
+      sportlist
+    end
+
+    # Creates a new sport.
+    #
+    # @param [CoachClient::Client] client
+    # @param [String, Symbol] sport
+    # @return [CoachClient::Sport]
+    def initialize(client, sport)
+      super(client)
+      @sport = sport.downcase.to_sym
+    end
+
+    # Updates the sport with the data from the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the sport does not exist
+    # @return [CoachClient::Sport] the updated sport
+    def update
+      raise CoachClient::NotFound, 'Sport not found' unless exist?
+      response = CoachClient::Request.get(url)
+      response = response.to_h
+      @id = response[:id]
+      @name = response[:name]
+      @description = response[:description]
+      self
+    end
+
+    # Returns the URL of the sport.
+    #
+    # @return [String] the url of the sport
+    def url
+      @client.url + self.class.path + @sport.to_s
+    end
+
+    # Returns the string representation of the sport.
+    #
+    # @return [String]
+    def to_s
+      @sport.to_s
+    end
+  end
+end
+

data/lib/coach_client/subscription.rb

@@ -0,0 +1,116 @@
+module CoachClient
+  # A subscription resource of the CyberCoach service.
+  #
+  # @note Use the subclass {CoachClient::UserSubscription} or
+  #   {CoachClient::PartnershipSubscription} for a user or partnership
+  #   subscription respectively.
+  class Subscription < CoachClient::Resource
+    # @return [Integer]
+    attr_reader :id, :datesubscribed
+
+    # @return [Array<CoachClient::Entry>]
+    attr_reader :entries
+
+    # @return [CoachClient::Sport]
+    attr_accessor :sport
+
+    # @return [Integer]
+    attr_accessor :publicvisible
+
+    # Creates a new subscription.
+    #
+    # @param [CoachClient::Client] client
+    # @param [String, Symbol, CoachClient::Sport] sport
+    # @param [Integer] publicvisible
+    # @return [CoachClient::Subscription]
+    def initialize(client, sport, publicvisible: nil)
+      super(client)
+      @sport = if sport.is_a?(CoachClient::Sport)
+                 sport
+               else
+                 CoachClient::Sport.new(client, sport)
+               end
+      @publicvisible = publicvisible
+    end
+
+    # Updates the subscription with the data from the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the subscription does not exist
+    # @param [CoachClient::User] user
+    # @return [CoachClient::Subscription] the updated subscription
+    def update(user)
+      raise CoachClient::NotFound, 'Subscription not found' unless exist?
+      response = if user.authenticated?
+                   CoachClient::Request.get(url, username: user.username,
+                                            password: user.password)
+                 else
+                   CoachClient::Request.get(url)
+                 end
+      response = response.to_h
+      @id = response[:id]
+      @datesubscribed = response[:datesubscribed]
+      @publicvisible = response[:publicvisible]
+      @entries = []
+      unless response[:entries].nil?
+        response[:entries].each do |e|
+          tag = "entry#{@sport}"
+          id = CoachClient::Entry.extract_id_from_uri(e[tag.to_sym][:uri])
+          @entries << CoachClient::Entry.new(client, self, id: id)
+        end
+      end
+      self
+    end
+
+    # Saves the subscription to the CyberCoach service.
+    #
+    # The subscription 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 subscription could not be saved
+    # @param [CoachClient::User] user
+    # @return [CoachClient::Subscription] the saved subscription
+    def save(user)
+      vals = self.to_h
+      vals.delete(:user)
+      vals.delete(:partnership)
+      vals.delete(:sport)
+      vals.delete_if { |_k, v| v.nil? || v.to_s.empty? }
+      payload = Gyoku.xml(subscription: vals)
+      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 subscription'
+      end
+      self
+    end
+
+    # Deletes the subscription on the CyberCoach service.
+    #
+    # @raise [CoachClient::NotFound] if the subscription does not exist
+    # @raise [CoachClient::Unauthorized] if not authorized
+    # @param [CoachClient::User] user
+    # @return [true]
+    def delete(user)
+      raise CoachClient::NotFound unless exist?
+      unless user.authenticated?
+        raise CoachClient::Unauthorized.new(user), 'Unauthorized'
+      end
+      CoachClient::Request.delete(url, username: user.username,
+                                  password: user.password)
+      true
+    end
+  end
+end
+