clickmeetings 0.1.3.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0f19b8ce1c8e56b9d7b5527a2a0f9fbae877ffc8
-  data.tar.gz: d0d66c38e43bf342e36f23c45589a20e2e4cea4f
+SHA256:
+  metadata.gz: c7957e3d0dec3844222ff970c64a81872eacc270078d53a8655991c494903b19
+  data.tar.gz: 19fc5201e2b1f29c5aaf3dbf526a633d69b378a9c722112cb7cc5b828dcfa184
 SHA512:
-  metadata.gz: c17aa7ea0ef517b1124be90404512b62e97b44337f3bc121175c9410057a0d71ff0f6af72d97cfadb77ccc09acf06afe775dd3a97c34fc0a9ba336fa1081cc31
-  data.tar.gz: b1f53ead06baac642b28112cfa30c67e4885053e6d4d2044518cde64e411f78537f16ebca893caf0c68f977ca8eb2155f2ed6a9875b002401333d08e6da53cf1
+  metadata.gz: b524e4c4f0162aa8d53e40884113b38bdda1518f828fd144f46c5b77ba8fe1408fc5a28b61fddd8ebcce445310cbb49417028e2fe6d13dcaf0c0a43983da8710
+  data.tar.gz: fb323a5b723b5ff3d7790d9366db536a59687a64fb72e7b0d1ea0c376ca8f3ad045e502506f54d1835118b1aa9c35b50e98be9b0d4612ac33f38d68e8c378f2c

data/.github/workflows/run-tests.yml

@@ -0,0 +1,26 @@
+name: Ruby CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        ruby-version: [2.7.3, 2.6.7, 2.5.9]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby ${{ matrix.ruby-version }}
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby-version }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run tests
+        run: bundle exec rspec

data/.gitignore

@@ -12,3 +12,4 @@
 examples.txt
 /clickmeetings.yml
 /clickmeetings-*.gem
+

data/README.md

@@ -1,8 +1,8 @@
-# Clickmeetings
+[![Ruby CI](https://github.com/teachbase/clickmeetings/actions/workflows/run-tests.yml/badge.svg)](https://github.com/teachbase/clickmeetings/actions/workflows/run-tests.yml/badge.svg)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/clickmeetings`. To experiment with that code, run `bin/console` for an interactive prompt.
+# Clickmeetings
 
-TODO: Delete this and the text above, and describe your gem
+Simple REST API client to interact with [Clickmeeting](https://clickmeeting.com) open and Privatelabel API.
 
 ## Installation
 
@@ -22,17 +22,315 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Configuration
+
+With Rails:
+
++ in `config/secrets.yml` add:
+```yml
+clickmeetings:
+  privatelabel_host: https://api.clickmeetings.com/privatelabel/v1 # or http://api.anysecond.com/privatelabel/v1
+  privatelabel_api_key: your_privatelabel_api_key
+  host: https://api.clickmeetings.com/v1 # or http://api.anysecond.com/v1
+  api_key: your_open_api_key
+  locale: es # default language (uses e.g. in invitations)
+```
++ in `config/clickmeetings.yml`:
+```yml
+privatelabel_host: https://api.clickmeetings.com/privatelabel/v1 # or http://api.anysecond.com/privatelabel/v1
+privatelabel_api_key: your_privatelabel_api_key
+host: https://api.clickmeetings.com/v1 # or http://api.anysecond.com/v1
+api_key: your_open_api_key
+locale: es # default language (uses e.g. in invitations)
+```
+
+With or without Rails:
+
++ Use environment variables `CLICKMEETINGS_*` (e.g. `CLICKMEETINGS_PRIVATELABEL_HOST`).
++ Use `configure` method:
+```ruby
+Clickmeetings.configure do |config|
+  config.privatelabel_api_key = 'your_privatelabel_api_key'
+  # and another configs like above
+end
+```
+
+### Usage
+
++ Privatelabel API
+  + Your profile
+  ```ruby
+  profile = Clickmeetings::PrivateLabel::Profile.get # => get your PrivateLabel profile  details
+  ```
+  + Accounts
+  ```ruby
+  account = Clickmeetings::PrivateLabel::Account.create(params)
+  # => Clickmeetings::PrivateLabel::Account object
+  # params is a Hash; see specification for params
+  # in your clickmeeting account
+  account = account.update username: "New account name"
+  # => updated Clickmeetings::PrivateLabel::Account object
+  # see specification to know what params you can provide
+  account = account.disable # sets account's status to 'disabled'
+  account = account.enable  # sets account's status to 'active'
+  account.destroy # => deleted account
+  Clickmeetings::PrivateLabel::Account.all # => array of accounts
+  Clickmeetings::PrivateLabel::Account.find(1) # => account details with id = 1 or
+                                               #    Clickmeetings::NotFoundError
+  ```
+  + Conferences
+    + Specify an account
+    ```ruby
+    Clickmeetings::PrivateLabel::Conference.account_id # => nil
+    Clickmeetings::PrivateLabel::Conference.by_account(account_id: 1)
+    # => Clickmeetings::PrivateLabel::Conference, so you can use #create,
+    # #update and #find in chain
+    Clickmeetings::PrivateLabel::Conference.account_id # => 1
+    ```
+    or
+    ```ruby
+    # Clickmeetings::PrivateLabel::Conference.account_id equals to nil
+    Clickmeetings::PrivateLabel::Conference.by_account(account_id: 1) do
+      # there Clickmeetings::PrivateLabel::Conference.account_id equals to 1
+    end
+    # and there Clickmeetings::PrivateLabel::Conference.account_id equals to nil
+
+    Clickmeetings::PrivateLabel::Conference.by_account(account_id: 1).new
+    # => #<Clickmeetings::PrivateLabel::Conference:0x... @account_id=1>
+    ```
+    + Do anything
+    ```ruby
+    Clickmeetings::PrivateLabel::Conference.by_account(account_id: 1) do
+      # use Clickmeetings::PrivateLabel::Conference.create, .all and .find methods+
+      # to create conference, get list of conferences for account or get conference
+      # details
+
+      # and #update and #destroy instance methods to change or delete any conference
+
+      # params same as in Open API (see below)
+    end
+    ```
++ [Open API](http://dev.clickmeeting.com/api-doc/)
+
+  Account is based on your config (from api key) or with every class you can use
+  ```ruby
+  Clickmeetings::Open::Conference.with_account(account_api_key: 'another_account_api_key') do
+    # do anything in another account
+  end
+  ```
+  + Сonference
+    ```ruby
+    Clickmeetings::Open::Conference.active   # => list of active conferences
+    Clickmeetings::Open::Conference.inactive # => list of inactive conferences
+    # .all, .find, .create, #update, #destroy as usual
+    ```
+    + params for `.create` and `#update`
+      + Required:
+        + name (String): room name
+        + room_type (String): 'webinar' or 'meeting'
+        + permanent_room (Integer): 1 - room is permanent; 0 - has start time and duration
+        + access_type (Integer): 1 - open, 2 - password (requires password in params), 3 - token
+      + Optional
+        + password (String): password for rooms with access_type 2
+        + custom_room_url_name (String): room url will be `https://{account_name}.clickmeeting.com/{custom_room_url_name}`
+        + lobby_description (String): Messagee in lobby
+        + lobby_enabled (String): 1 - true, 0 - false
+        + starts_at (iso8601 datetime): time conference starts at (if it is not permanent). Default is `now`
+        + duration (String "h:mm"): duration of conference, between 0:05 and 3:00
+        + timezone (String): Time zone of conference (e.g. “America/New_York”)
+        + skin_id (integer): Skin identifier
+        + registration (Hash):
+          + enabled (Boolean)
+          + template (Integer): registration template, between 1 and 3
+        + status (String): "active" or "inactive"
+        + settings (Hash): please, see on [Clickmeting API documentation](http://dev.clickmeeting.com/api-doc/#post_conferences) if need
+    + Other helpful methods
+    ```ruby
+    Clickmeetings::Open::Conference.skins # => array of available skins; each skin is a Hash
+    Clickmeetings::Open::Conference.find(1).create_tokens(10)
+    # creates tokens for confereces with access_type = 3;
+    # param specifies how many tokens will be created (default is 1)
+
+    Clickmeetings::Open::Conference.new(id: 1).send_invites(
+      attendees: [
+        {email: "first@teachbase.ru"},
+        {email: "second@teachbase.ru"}
+      ]
+      role: "presenter",
+      template: "basic" # or "advanced"
+    )
+    # send invites to emails in attendees for specified role. Template means view of email
+    # .new(id: 1) specifies id of conference. Unlike .find(1) it doesn't request to clickmeetings
+
+    Clickmeetings::Open::Conference.new(id: 1).files # => files for conference
+    Clickmeetings::Open::Conference.new(id: 1).tokens # => tokens for conference (if access_type is 3)
+    Clickmeetings::Open::Conference.new(id: 1).sessions # => sessions for conference
+    Clickmeetings::Open::Conference.new(id: 1).registrations # => registrations for conference
+    Clickmeetings::Open::Conference.new(id: 1).recordings # => recordings for conference
+
+    Clickmeetings::Open::Conference.new(id: 1).register(
+      registration: {
+        1 => "firstname",
+        2 => "lastname",
+        3 => "email@teachbase.ru"
+      },
+      confirmation_email: { # optional
+        enabled: 1, # or 0
+        lang: "ru", # or something else
+      }
+    )
+
+    Clickmeetings::Open::Conference.find(1).create_hash(
+      nickname: "User#1",
+      role: "presenter",
+      email: "user1@teachbase.ru
+      # :password for conference with access_type 2
+      # :token for conference with access_type 3
+    )
+    # creates autologin hash for user, specified in params
+    ```
+    For more information about autologin hashes see [docs](http://dev.clickmeeting.com/api-doc/#post_autologin_hash).
+  + Session
+    ```ruby
+    Clickmeetings::Open::Session.by_conference(conference_id: 1).all
+    # => sessions for conference with id 1
+    # now u can use
+    Clickmeetings::Open::Session.all
+    # => sessions for conference with id 1
+    Сlickmeetings::Open::Session.find(1)
+    # => session with id 1 in conference with id 1
+    ```
+    or
+    ```ruby
+    Clickmeetings::Open::Session.by_conference(conferecne_id: 1) do
+      Clickmeetings::Open::Session.all
+      # => sessions for conference with id 1
+      Сlickmeetings::Open::Session.find(1)
+      # => session with id 1 in conference with id 1
+    end
+    Clickmeetings::Open::Session.all
+    # => Clickmeetings::NotFoundError
+    ```
+    You can use only `.all`, `.find` and one of methods below
+    + `#attendees`
+
+      ```ruby
+      Clickmeetings::Open::Session.by_conference(conferecne_id: 1) do
+        Сlickmeetings::Open::Session.find(1).attendees
+        # => array of attendees; each attendee is  a hash
+      end
+      ```
+    + `#generate_pdf`
+
+      ```ruby
+      Clickmeetings::Open::Session.by_conference(conferecne_id: 1) do
+        Сlickmeetings::Open::Session.find(1).generate_pdf :ru
+        # => hash { status: "...", ... }
+        # if status id "FINISHED", it contains :url key with url of pdf
+        # params sets locale; default locale in config; default for config is "en"
+      end
+      ```
+    + `#get_report`
+
+      ```ruby
+      Clickmeetings::Open::Session.by_conference(conferecne_id: 1) do
+        Сlickmeetings::Open::Session.find(1).generate_pdf :ru
+        # => url of pdf is status for specified locale is "FINISHED"
+        #    nil else
+      end
+      ```
+    + `#registrations`
+
+      ```ruby
+      Clickmeetings::Open::Session.by_conference(conferecne_id: 1) do
+        Сlickmeetings::Open::Session.find(1).registrations
+        # => array of registrations
+      end
+      ```
+  + Contacts
+
+    Only `.create` method:
+    ```ruby
+    Clickmeetings::Open::Contact.create(
+      email: "...",
+      firstname: "...",
+      lastname: "...",
+      phone: "...", # optional
+      company: "...", # optional
+      country: "..." # optional
+    )
+    ```
+    If contact with passed email exists, it will be updated
+  
+  + TimeZone
+
+    Only `.all` method with optional param `:country`. Returns array of strings.
+    ```ruby
+    Clickmeetings::Open::TimeZone.all country: :ru # => time zones in Russia
+    Clickmeetings::Open::TimeZone.all # => all time zones
+    ```
+
+  + PhoneGateway
+
+    ```ruby
+    Clickmeetings::Open::PhoneGateway.all # => array of phone gateways
+    ```
+
+  + Registration
+
+    ```ruby
+    Clickmeetings::Open::Registration.by_conference(conference_id: 1) do
+      Clickmeetings::Open::Registration.all # => array of registrations
+      Clickmeetings::Open::Registration.active # => array of active registrations
+      Clickmeetings::Open::Registration.create(params) # => registration hash
+      # => params like in Clickmeetings::Open::Conference#register
+      Clickmeetings::Open::Registration.for_session(session_id: 1)
+      # => registrations for session with id 1
+    end
+    ```
+
+  + FileLibrary
+
+    ```ruby
+    Clickmeetings::Open::FileLibrary.create(path: '/path/to/file.pdf')
+    # => FileLibrary instance; creates file in your library
+    Clickmeetings::Open::FileLibrary.create(path: '/path/to/file.pdf', conference_id: 1)
+    # => FileLibrary instance; creates file in conference with id 1
+    Clickmeetings::Open::FileLibrary.all # => array of FileLibrary instances
+    Clickmeetings::Open::FileLibrary.for_conference(conference_id: 1)
+    # array of files in conference with id 1
+
+    # find and destroy as usually
+
+    Clickmeetings::Open::FileLibrary.new(id: 1).download # => content of file with id 1 as String
+    ```
+
+  + Recording
+
+    `Clickmeetings::Open::Recordings` interacts with recordings. Specify a conference with `by_conference` (as above) method and use `.all`, `.find`, and `.destroy_all` (to destroy all recordings of conference) methods.
+
+  + Chat
+
+    `Clickmeetings::Open::Chat` interacts with chats. Use `.all` to get info about chats. `.find` returns content of zip-archive with a chat.
+
+  + Other
+
+    Use `.ping` with any class to check API status.
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
++ Fork repo
++ Create new branch
++ install dependencies
+
+      $ bundle install
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
++ Commit your changes (do not forget about specs)
++ Create a pull request
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/clickmeetings.
+Bug reports and pull requests are welcome on GitHub at https://github.com/teachbase/clickmeetings.
 
 
 ## License

data/clickmeetings.gemspec

@@ -1,31 +1,36 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'clickmeetings/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "clickmeetings"
+  spec.name          = 'clickmeetings'
   spec.version       = Clickmeetings::VERSION
-  spec.authors       = ["Sergei Alekseenko", "Makar Ermokhin"]
-  spec.email         = ["alekseenkoss@gmail.com", "ermak95@gmail.com"]
-  spec.summary       = %q{Simple REST API client for ClickMeetings Private Label API}
-  spec.description   = %q{Simple REST API client for ClickMeetings Private Label API}
-  spec.homepage      = "https://github.com/teachbase/clickmeetings"
-  spec.license       = "MIT"
+  spec.authors       = ['Sergei Alekseenko', 'Makar Ermokhin']
+  spec.email         = ['alekseenkoss@gmail.com', 'ermak95@gmail.com']
+  spec.summary       = 'Simple REST API client for ClickMeetings Private Label and Open API'
+  spec.description   = 'Simple REST API client for ClickMeetings Private Label and Open API'
+  spec.homepage      = 'https://github.com/teachbase/clickmeetings'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 2.5'
 
-  spec.add_development_dependency "bundler", "~> 1.12"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "webmock", "~> 2"
-  spec.add_development_dependency 'pry', "~> 0.10"
-  spec.add_dependency "anyway_config", "~> 0", ">= 0.3"
-  spec.add_dependency "faraday", "~> 0.9"
-  spec.add_dependency "faraday_middleware", "~> 0.10"
-  spec.add_dependency 'activemodel', "~> 4.1"
+  spec.add_development_dependency 'pry', '~> 0.10'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '~> 12.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-gem-profile'
+  spec.add_development_dependency 'webmock', '~> 2'
+  spec.add_dependency 'activemodel', '>= 4.1', '< 6'
+  spec.add_dependency 'anyway_config', '>= 0.3'
+  spec.add_dependency 'faraday', '>= 1.0', '< 2'
+  spec.add_dependency 'faraday_middleware', '>= 1.0'
   spec.add_dependency 'json', '~> 1.0'
 end

data/lib/clickmeetings/client.rb

@@ -4,17 +4,16 @@ require 'json'
 
 module Clickmeetings
   class Client
-    attr_reader :url, :api_key
-
-    def initialize(url: Clickmeetings.config.host,
-                   api_key: Clickmeetings.config.api_key)
+    attr_reader :url, :connect
 
+    def initialize(url: Clickmeetings.config.host)
       @url = url
-      @api_key = api_key
 
       @connect = Faraday.new(url: url) do |faraday|
-        faraday.adapter Faraday.default_adapter
+        faraday.request :multipart
+        faraday.request :url_encoded
         faraday.use :instrumentation
+        faraday.adapter Faraday.default_adapter
       end
     end
 
@@ -52,10 +51,10 @@ module Clickmeetings
     end
 
     %w(get post put patch delete).each do |method|
-      define_method method do |url, params = {}|
+      define_method method do |url, params = {}, headers = {}|
         l = lambda do |req|
-          req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-          req.body = params.merge(api_key: api_key).to_query
+          req.headers.merge! headers
+          req.body = params
         end
         request(method, url, &l)
       end

data/lib/clickmeetings/config.rb

@@ -6,6 +6,7 @@ module Clickmeetings
     attr_config privatelabel_host: 'https://api.clickmeeting.com/privatelabel/v1',
                 host: 'https://api.clickmeeting.com/v1',
                 api_key: 'test_key',
-                privatelabel_api_key: 'privatelabel_api_key'
+                privatelabel_api_key: 'privatelabel_api_key',
+                locale: :en
   end
 end

data/lib/clickmeetings/engine.rb

@@ -1,4 +1,3 @@
-require 'clickmeetings'
 require 'rails'
 
 module Clickmeetings

data/lib/clickmeetings/model.rb

@@ -1,4 +1,3 @@
-require 'clickmeetings'
 require 'active_model'
 
 module Clickmeetings
@@ -8,34 +7,36 @@ module Clickmeetings
     include ActiveModel::Validations
 
     attr_accessor :id
-  
+
     class << self
       attr_accessor :resource_name
       attr_reader :client_host, :client_api_key
 
-      delegate :remote_url, :remote_path, :handle_response, :client, to: :new
-    
+      delegate :remote_url, :remote_path, :handle_response, :client,
+               :default_params, :default_headers, to: :new
+      delegate :first, :last, to: :all
+
       def resource_name
         @resource_name ||= self.name.demodulize.pluralize.downcase
       end
 
       def find(id)
         response = Clickmeetings.with_client(client_options) do
-          client.get(remote_url(__method__, id: id))
+          client.get(remote_url(__method__, id: id), default_params, default_headers)
         end
         handle_response(response)
       end
 
       def all
         response = Clickmeetings.with_client(client_options) do
-          client.get(remote_url(__method__))
+          client.get(remote_url(__method__), default_params, default_headers)
         end
         handle_response(response)
       end
 
       def create(params = {})
         response = Clickmeetings.with_client(client_options) do
-          client.post(remote_url(__method__), params)
+          client.post(remote_url(__method__), params.merge(default_params), default_headers)
         end
         handle_response(response)
       end
@@ -45,10 +46,7 @@ module Clickmeetings
       end
 
       def client_options
-        {
-          url: Clickmeetings.config.host,
-          api_key: Clickmeetings.config.api_key
-        }
+        { url: Clickmeetings.config.host }
       end
     end
 
@@ -60,28 +58,30 @@ module Clickmeetings
     end
 
     def remote_url(action = nil, params = {})
-      url = remote_path(action, params)
-    end
-
-    def persist?
-      !!id
+      remote_path(action, params)
     end
 
     def update(params = {})
       response = Clickmeetings.with_client(client_options) do
-        client.put(remote_url(__method__), params)
+        client.put(remote_url(__method__), params.merge(default_params), default_headers)
       end
       handle_response response
     end
 
-    def destroy(params = {})
-      Clickmeetings.with_client(client_options) { client.delete(remote_url(__method__), params) }
+    def destroy()
+      Clickmeetings.with_client(client_options) do
+        client.delete(remote_url(__method__), default_params, default_headers)
+      end
       self
     end
 
     def handle_response(body)
       return unless [Hash, Array].include? body.class
-      merge_attributes(body)
+      result = merge_attributes(body)
+      if respond_to?("api_key") && result.respond_to?("associations_api_key=")
+        result.associations_api_key = api_key
+      end
+      result
     end
 
     def remote_path(action = nil, params = {})
@@ -96,11 +96,25 @@ module Clickmeetings
         "#{resource_name}/#{id}"
       when :destroy
         "#{resource_name}/#{id}"
+      when :destroy_all
+        resource_name
       else
-        "#{resource_name}/#{params[:id]}/#{action}"
+        action_path(action, params[:id])
       end
     end
 
+    def action_path(action, id)
+      id ? "#{resource_name}/#{id}/#{action}" : "#{resource_name}/#{action}"
+    end
+
+    def default_params
+      Hash.new
+    end
+
+    def default_headers
+      Hash.new
+    end
+
     private
 
     def merge_attributes(attrs)
@@ -117,7 +131,7 @@ module Clickmeetings
 
     def merge_object(attrs)
       attrs.each do |attribute, val|
-        if respond_to?(attribute)
+        if respond_to?("#{attribute}=")
           send("#{attribute}=", val)
         elsif val.is_a? Hash
           merge_object val

data/lib/clickmeetings/models/open/chat.rb

@@ -0,0 +1,19 @@
+module Clickmeetings
+  module Open
+    class Chat < Model
+      attr_accessor :name, :time_zone, :date, :time, :download_link
+
+      class << self
+        def find(id)
+          response = Clickmeetings.with_client(client_options) do
+            Clickmeetings.client.connect.get remote_url(__method__, id: id) do |req|
+              req.headers.merge! default_headers
+            end
+          end
+
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/clickmeetings/models/open/concerns/with_conference.rb

@@ -0,0 +1,35 @@
+module Clickmeetings
+  module Open
+    module WithConference
+      extend ActiveSupport::Concern
+
+      included { attr_accessor :conference_id }
+
+      module ClassMethods
+        def by_conference(conference_id: nil)
+          Storage.cm_current_conference = conference_id
+          if block_given?
+            result = yield
+            Storage.cm_current_conference = nil
+            result
+          else
+            self
+          end
+        end
+
+        def conference_id
+          Storage.cm_current_conference
+        end
+      end
+
+      def initialize(params = {})
+        super
+        @conference_id ||= self.class.conference_id
+      end
+
+      def remote_url(action = nil, params = {})
+        Conference.remote_path(:find, id: conference_id) + '/' + remote_path(action, params)
+      end
+    end
+  end
+end