readytalk 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b99b09a6d1d970fa24632e49608045c9202e5386
+  data.tar.gz: c282affb91f6f6ec5b736358e10dd39521f3380f
+SHA512:
+  metadata.gz: ffc13e91140e1b17b27acc311d83617b7fd8af54404699fc0e5482900402d6ed2b47ff78ef9035dbe8620ba6e0540917b0fb1063e18079df3e9a7d337ed6f1c9
+  data.tar.gz: 1f9ce897181e879b0a64470c1af8322653da5b10806346b2993a9f8a14bc31d69ab9d7449155245772ba70965723a1b7099bab9b5a32f6efe626953bfba0f01c

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,2 @@
+source 'http://rubygems.org'
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 ellevate
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# ReadyTalk
+A Ruby wrapper for the ReadyTalk API. It provides a set of
+classes that map to API endpoints and data structures.
+
+## Installation
+Include this line to your application's Gemfile:
+```
+gem 'readytalk'
+```
+
+And then execute:
+```
+$ bundle install
+```
+
+Or install it yourself as:
+```
+$ gem install readytalk
+```
+
+## Documentation
+[ReadyTalk API Docs](https://cc.readytalk.com/api/1.3/rest)
+
+## Configuration
+If you are using Rails, the readytalk gem can be configured in an initializer or
+environment file.
+
+Configuration options can be passed as a block or set as a Hash.
+
+```ruby
+ReadyTalk.configure do |config|
+  config.tollfree = 0000000000 # your toll free number
+  config.accesscode = 1212121 # your access code
+  config.passcode = 1234 # your passcode
+  config.test_mode = true # if true, operate in sandbox mode: https://apidev-cc.readytalk.com
+end
+```
+Outside the Rails environment configuration options can be set directly on the
+`ReadyTalk` module.
+```ruby
+ReadyTalk.config.tollfree = 0000000000
+ReadyTalk.config.accesscode = 1212121
+ReadyTalk.config.passcode = 1234
+
+```
+
+## Usage
+All ReadyTalk API endpoints have an equivalent method call. Consult API documentation
+for list of required and optional input parameters.
+
+* `ReadyTalk::Account`
+  * `self.get_option(option_name)` - [Get Account Option](https://cc.readytalk.com/api/1.3/rest#AccountService-getAccountOption)
+  * `self.list_international_numbers()` - [List International Numbers](https://cc.readytalk.com/api/1.3/rest#AccountService-listInternationalNumbers)
+  * `self.list_questions(input_params)` - [List Poll Questions](https://cc.readytalk.com/api/1.3/rest#RegistrationService-listPollQuestions)
+
+* `ReadyTalk::Meeting`
+  * `self.create(input_params)` - [Create Meetings](https://cc.readytalk.com/api/1.3/rest#MeetingService-createMeeting)
+  * `self.list(input_params)` - [List Meetings](https://cc.readytalk.com/api/1.3/rest#MeetingService-listMeetings)
+  * `self.details(id)` - [Meeting Details](https://cc.readytalk.com/api/1.3/rest#MeetingService-meetingDetails)
+  * `details()` - [Meeting Details](https://cc.readytalk.com/api/1.3/rest#MeetingService-meetingDetails)
+  * `cancel(input_params)` - [Cancel Meeting](https://cc.readytalk.com/api/1.3/rest#MeetingService-cancelMeeting)
+  * `update(input_params)` - [Update Meeting](https://cc.readytalk.com/api/1.3/rest#MeetingService-updateMeeting)
+  * `create_registration(input_params)` - [Create Registration](https://cc.readytalk.com/api/1.3/rest#RegistrationService-createRegistration)
+  * `create_invitations(input_params)` - [Create Invitations](https://cc.readytalk.com/api/1.3/rest#RegistrationService-createInvitations)
+  * `list_registrations(input_params)` - [List Registrations](https://cc.readytalk.com/api/1.3/rest#RegistrationService-listRegistrations)
+  * `list_surveys(input_params)` - [List Post Event Surveys](https://cc.readytalk.com/api/1.3/rest#RegistrationService-listPostEventSurveys)
+  * `list_chats()` - [List Chats](https://cc.readytalk.com/api/1.3/rest#ChatService-listChats)
+
+* `ReadyTalk::Recording`
+  * `self.list(input_params)` - [List Recordings](https://cc.readytalk.com/api/1.3/rest#RecordingService-listRecordings)
+  * `self.details(id, input_params)` - [Recording Details](https://cc.readytalk.com/api/1.3/rest#RecordingService-recordingDetails)
+  * `details(input_params)` - [Recording Details](https://cc.readytalk.com/api/1.3/rest#RecordingService-recordingDetails)
+  * `list_registrations(input_params)` - [List Recording Registrations](https://cc.readytalk.com/api/1.3/rest#RecordingRegistrationService-listRegistrations)
+
+An example API call might resemble the following:
+```ruby
+  ReadyTalk::Meeting.create(
+    title: 'Test Meeting',
+    host_name: 'Stevie Tester',
+    from_email: 'sevetester@example.com',
+    start_date_iso8601: '2016-01-30T08:00:00-05:00',
+    duration_in_seconds: '3600',
+    time_zone: 'EST',
+    registration: 'PRE_REG_AUTOMATIC_CONFIRMATION_NO_NOTIFICATION',
+    type: 'WEB_AND_AUDIO',
+    audio: {on_demand: 'DISPLAY_TOLLFREE_DISPLAY_TOLL'}
+  )
+```
+
+The documented [API Data Types](https://cc.readytalk.com/api/1.3/rest#data-types)
+have equivalent `ReadyTalk` namespaced classes. All attributes are accessible via
+method calls.
+
+```
+  > meeting = ReadyTalk::Meeting.details(012345)
+  => #<ReadyTalk::Meeting @data={"id"=>"012345"...}>
+  > meeting.id
+  => 012345
+  > meeting.meeting_details
+  => #<ReadyTalk::MeetingDetails @data={"meetingType"=>"WEB_AND_AUDIO"...}>
+  > meeting.meeting_details.meeting_type
+  => "WEB_AND_AUDIO"
+```
+
+API list endpoints return `ReadyTalk::ReadyTalkList` objects, which respond
+to `[]`, `first`, `last`, `size`, `each`, and `empty?`.
+
+Any additional attributes returned by a list endpoint, such as `paging_criteria`,
+are also available via method calls on the list object.
+
+## Handling Errors
+Errors returned by the API are raised as `ReadyTalk::ReadyTalkError`. It is possible
+for multiple errors to be returned for a given request. raw API errors are accessible
+via the `errors` method on `ReadyTalk::ReadyTalkError`.
+
+Additionally, the `full_messages` method will return an Array containing the messages
+for each error.

data/lib/readytalk.rb

@@ -0,0 +1,36 @@
+require 'base64'
+require 'json'
+require 'rest-client'
+
+require 'readytalk/railtie'
+require 'readytalk/operations'
+require 'readytalk/util'
+require 'readytalk/object'
+require 'readytalk/list'
+
+require 'readytalk/account'
+require 'readytalk/error'
+require 'readytalk/meeting'
+require 'readytalk/recording'
+
+
+module ReadyTalk
+  if defined?(Rails)
+    def self.configure(&block)
+      if block_given?
+        block.call(ReadyTalk::Railtie.config.readytalk)
+      else
+        ReadyTalk::Railtie.config.readytalk
+      end
+    end
+
+    def self.config
+      ReadyTalk::Railtie.config.readytalk
+    end
+  else
+    def self.config
+      @@config ||= OpenStruct.new
+      @@config
+    end
+  end
+end

data/lib/readytalk/account.rb

@@ -0,0 +1,19 @@
+module ReadyTalk
+  class Account < ReadyTalkObject
+
+    def self.get_option(option_name)
+      response = request(:get, "/accounts/option/#{option_name}", :get_account_option)
+      Util.new_helper_object(response, :option)
+    end
+
+    def self.list_international_numbers
+      response = request(:get, '/accounts/internationalNumbers', :list_international_numbers)
+      Util.new_list_object(response, :international_number)
+    end
+
+    def self.list_questions(opts = {})
+      response = request(:get, '/registrations/pollQuestions', opts, :list_poll_questions)
+      Util.new_list_object(response, :poll_question, :paging_criteria)
+    end
+  end
+end

data/lib/readytalk/error.rb

@@ -0,0 +1,18 @@
+module ReadyTalk
+  class ReadyTalkError < StandardError
+    attr_reader :errors
+
+    def initialize(errors_data = {})
+      @errors = errors_data['error'] || []
+    end
+
+    def full_messages
+      @errors.map { |e| e['message'] }
+    end
+
+    def to_s
+      "#{@errors.size} error(s): #{@errors.map { |e| "#{e['code']}: #{e['message']}" }}"
+    end
+
+  end
+end

data/lib/readytalk/list.rb

@@ -0,0 +1,48 @@
+module ReadyTalk
+  class ReadyTalkList
+    def initialize(data, list_key, klass, data_keys = nil)
+      @klass = klass
+      @list_data = data[ReadyTalk::Util.camelize(list_key)] || []
+      @list_data = @list_data.map { |d| klass.new(d) }
+
+      unless data_keys.nil?
+        data_keys.each do |key|
+          key_data = data[ReadyTalk::Util.camelize(key)]
+          if key_data.is_a?(Hash)
+            key_data = ReadyTalk::Util.new_helper_object(data, key)
+          end
+
+          self.class.send(:attr_reader, key)
+          self.instance_variable_set("@#{key.to_s}", key_data)
+        end
+      end
+    end
+
+    def [](value)
+      @list_data[value]
+    end
+
+    def first(*args)
+      @list_data.send(:first, *args)
+    end
+
+    def last(*args)
+      @list_data.send(:last, *args)
+    end
+
+    def size
+      @list_data.size
+    end
+
+    def each(&block)
+      @list_data.each(&block)
+    end
+
+    def empty?
+      @list_data.empty?
+    end
+
+    alias_method :count, :size
+
+  end
+end

data/lib/readytalk/meeting.rb

@@ -0,0 +1,64 @@
+module ReadyTalk
+  class Meeting < ReadyTalkObject
+
+    def self.create(opts = {})
+      response = request(:post, '/meetings', opts, :create_meeting)
+      self.new(response, :meeting)
+    end
+
+    def self.list(opts = {})
+      response = request(:get, '/meetings', opts, :list_meetings)
+      Util.new_list_object(response, :meeting, :paging_criteria)
+    end
+
+    def self.details(id)
+      response = request(:get, "/meetings/#{id}", :meeting_details)
+      self.new(response, :meeting)
+    end
+
+    def details
+      self.class.details(self.id)
+    end
+
+    def cancel(opts = {})
+      response = request(:delete, "/meetings/#{id}", opts, :cancel_meeting)
+      Util.parameterize_hash(response)
+    end
+
+    def update(opts = {})
+      response = request(:put, "/meetings/#{id}", opts, :update_meeting)
+      update_data(response, :meeting)
+    end
+
+    def create_registration(opts = {})
+      opts = opts.merge(meeting_id: self.id)
+      response = request(:post, '/registrations', opts, :create_registration)
+      Util.new_helper_object(response, :registration)
+    end
+
+    def create_invitations(opts = {})
+      opts = opts.merge(meeting_id: self.id)
+      opts[:email] = opts.fetch(:email, []).join(',')
+      response = request(:post, '/invites', opts, :create_invitations)
+      Util.new_list_object(response, :invite, :opt_out_email)
+    end
+
+    def list_registrations(opts = {})
+      opts = opts.merge(meeting_id: self.id)
+      response = request(:get, '/registrations', opts, :list_registrations)
+      Util.new_list_object(response, :registration, :paging_criteria)
+    end
+
+    def list_surveys(opts = {})
+      opts = opts.merge(meeting_id: self.id)
+      response = request(:get, '/registrations/surveys', opts, :list_post_event_surveys)
+      Util.new_list_object(response, :survey, :paging_criteria, :custom_link)
+    end
+
+    def list_chats
+      response = request(:get, '/chats', {id: self.id}, :list_chats)
+      Util.new_list_object(response, :chat)
+    end
+
+  end
+end

data/lib/readytalk/object.rb

@@ -0,0 +1,64 @@
+module ReadyTalk
+  class ReadyTalkObject
+
+    def initialize(data, object_key = nil)
+      if object_key.nil?
+        @data = data
+      else
+        @data = data[Util.camelize(object_key)]
+      end
+
+      unless @data.nil?
+        @data.each do |key, _value|
+          name = Util.parameterize(key)
+          self.class.send(:define_method, "#{name}") do
+             value = @data[key]
+             case value
+             when Array
+               value = Util.new_list_object({key => value}, key)
+               @data[key] = value
+             when Hash
+               value = Util.new_helper_object({key => value}, key)
+               @data[key] = value
+             end
+
+             value
+          end
+        end
+      end
+    end
+
+    protected
+    def update_data(data, object_key = nil)
+      if object_key.nil?
+        @data = data
+      else
+        @data = data[Util.camelize(object_key)]
+      end
+    end
+
+    def request(*args)
+      self.class.request(*args)
+    end
+
+    def self.request(*args)
+      verb = args.first
+      path = args[1]
+      end_point = args.last
+      opts = args.size == 4 ? args[2] : {}
+
+      opts = Util.format_hash(opts)
+      end_point = Util.camelize(end_point)
+
+      begin
+        response = Operations.request(verb, path, opts)
+        JSON.parse(response)["#{end_point}Result"]
+      rescue => e
+        response = e.response
+        error_data = JSON.parse(response)['errorsResult']
+        raise ReadyTalkError.new(error_data)
+      end
+    end
+
+  end
+end

data/lib/readytalk/operations.rb

@@ -0,0 +1,36 @@
+module ReadyTalk
+  module Operations
+
+    def self.request(verb, path, params)
+      opts = {
+        method: verb,
+        url: url(path),
+        headers: {
+          Authorization: authorization
+        }
+      }
+
+      case verb
+      when :post
+        opts[:payload] = params
+      else
+        opts[:headers][:params] = params
+      end
+
+      RestClient::Request.execute(opts)
+    end
+
+    private
+    def self.url(path)
+      domain = ReadyTalk.config.test_mode ? 'apidev-cc.readytalk.com' : 'cc.readytalk.com'
+      "https://#{domain}/api/1.3/svc/rs#{path}.json"
+    end
+
+    def self.authorization
+      config = ReadyTalk.config
+      credentials = "#{config.tollfree}:#{config.accesscode}:#{config.passcode}"
+      encoded_credentials = Base64.strict_encode64(credentials)
+      "Basic #{encoded_credentials}"
+    end
+  end
+end

data/lib/readytalk/railtie.rb

@@ -0,0 +1,8 @@
+if defined?(Rails)
+  require 'rails'
+  module ReadyTalk
+    class Railtie < Rails::Railtie
+      config.readytalk = ActiveSupport::OrderedOptions.new
+    end
+  end
+end

data/lib/readytalk/recording.rb

@@ -0,0 +1,25 @@
+module ReadyTalk
+  class Recording < ReadyTalkObject
+
+    def self.list(opts = {})
+      response = request(:get, '/recordings', opts, :list_recordings)
+      ReadyTalk::Util.new_list_object(response, :recording, :paging_criteria)
+    end
+
+    def self.details(id, opts = {})
+      response = request(:get, "/recordings/#{id}", opts, :recording_details)
+      self.new(response, :recording)
+    end
+
+    def details(opts = {})
+      self.class.details(self.id, opts)
+    end
+
+    def list_registrations(opts = {})
+      opts = opts.merge(recording_id: self.id)
+      response = request(:get, '/recording/registrations', opts, :list_registrations)
+      ReadyTalk::Util.new_list_object(response, :registration, :paging_criteria)
+    end
+
+  end
+end

data/lib/readytalk/util.rb

@@ -0,0 +1,86 @@
+module ReadyTalk
+  module Util
+
+    def self.format_hash(hash)
+      return {} if hash.nil?
+      rv = {}
+      hash.each do |k, v|
+        if v.is_a?(Hash)
+          nested = format_hash(v)
+          nested.each { |kn, vn| rv["#{camelize(k)}.#{kn}"] = vn }
+        else
+          rv[camelize(k)] = v
+        end
+      end
+
+      return rv
+    end
+
+    def self.camelize_hash(hash)
+      return {} if hash.nil?
+
+      Hash[hash.map { |k, v| [camelize(k), v] }]
+    end
+
+    def self.parameterize_hash(hash)
+      return {} if hash.nil?
+
+      Hash[hash.map { |k, v| [parameterize(k), v] }]
+    end
+
+    def self.parameterize(key)
+      str = key.to_s
+      return str if str.include?('_')
+
+      str.gsub(/([A-Z])/) { "_#{$1.downcase}" }
+    end
+
+    def self.camelize(key)
+      str = key.to_s
+      return str unless str.include?('_')
+
+      str.downcase.gsub!(/(?:_|(\/))([a-z\d]*)/) { $2.capitalize }
+    end
+
+    def self.create_helper_object(name, *args)
+      klass = Class.new(ReadyTalkObject)
+      Object.const_set(name, klass)
+      klass.send(:new, *args)
+    end
+
+    def self.new_helper_object(data, object_key)
+      klass = get_object_class(object_key)
+      klass.send(:new, data, object_key)
+    end
+
+    def self.new_list_object(data, list_key, *data_keys)
+      klass = get_object_class(list_key)
+      ReadyTalkList.new(data, list_key, klass, data_keys)
+    end
+
+    private
+    def self.get_object_class(key)
+      @@object_classes ||= {
+        recording: Recording,
+        meeting: Meeting
+      }
+      klass = @@object_classes[key]
+      if klass.nil?
+        klass = create_object_class(key)
+        @@object_classes[key] = klass
+      end
+
+      return klass
+    end
+
+    def self.create_object_class(key)
+      name = camelize(key)
+      name = "#{name[0].upcase}#{name[1..-1]}"
+      klass = Class.new(ReadyTalkObject)
+
+      ReadyTalk.const_set(name, klass)
+      return klass
+    end
+
+  end
+end

data/readytalk.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name = 'readytalk'
+  s.version = '0.6.0'
+  s.date = '2016-01-19'
+  s.summary = "Ruby binding for the ReadyTalk API"
+  s.description = "Ruby binding for the ReadyTalk - A web conferencing platform."
+  s.authors = ["Mike Pogran"]
+  s.email  = ['mike@ellevatenetwork.com']
+  s.license = 'MIT'
+  s.homepage = 'https://github.com/ellevate/readytalk'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('json', '~> 1.8')
+
+  s.files = `git ls-files`.split("\n")
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: readytalk
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Mike Pogran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Ruby binding for the ReadyTalk - A web conferencing platform.
+email:
+- mike@ellevatenetwork.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- lib/readytalk.rb
+- lib/readytalk/account.rb
+- lib/readytalk/error.rb
+- lib/readytalk/list.rb
+- lib/readytalk/meeting.rb
+- lib/readytalk/object.rb
+- lib/readytalk/operations.rb
+- lib/readytalk/railtie.rb
+- lib/readytalk/recording.rb
+- lib/readytalk/util.rb
+- readytalk.gemspec
+homepage: https://github.com/ellevate/readytalk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby binding for the ReadyTalk API
+test_files: []