zoom_rb 0.8.7 → 0.11.0

data/lib/zoom/actions/token.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+#
+module Zoom
+  module Actions
+    module Token
+      def access_tokens(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[auth_code redirect_uri])
+        response = self.class.post("/oauth/token?grant_type=authorization_code&code=#{options[:auth_code]}&redirect_uri=#{options[:redirect_uri]}", headers: oauth_request_headers, base_uri: 'https://zoom.us/')
+        Utils.parse_response(response)
+      end
+
+      def refresh_tokens(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(:refresh_token)
+        response = self.class.post("/oauth/token?grant_type=refresh_token&refresh_token=#{options[:refresh_token]}", headers: oauth_request_headers, base_uri: 'https://zoom.us/')
+        Utils.parse_response(response)
+      end
+
+      def data_compliance(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[client_id user_id account_id deauthorization_event_received compliance_completed])
+        response = self.class.post("/oauth/data/compliance", body: options.to_json, headers: oauth_request_headers, base_uri: 'https://zoom.us/')
+        Utils.parse_response response
+      end
+
+      def revoke_tokens(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[access_token])
+        response = self.class.post("/oauth/revoke?token=#{options[:access_token]}", headers: oauth_request_headers, base_uri: 'https://zoom.us/')
+        Utils.parse_response(response)
+      end
+    end
+  end
+end

data/lib/zoom/actions/user.rb

@@ -5,8 +5,8 @@ module Zoom
     module User
       def user_list(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
-        params.permit(%i[status page_size page_number])
-        response = self.class.get('/users', query: params.merge(access_token: access_token))
+        params.permit(%i[status page_size role_id page_number include_fields next_page_token])
+        response = self.class.get('/users', query: params, headers: request_headers)
         Utils.parse_response(response)
       end
 
@@ -15,133 +15,118 @@ module Zoom
         require_param_keys = %i[action email type]
         require_param_keys.append(:password) if params[:action] == 'autoCreate'
         params.require(require_param_keys)
-        params.permit_value(:action, Zoom::Constants::USER_CREATE_TYPES.keys)
-        Utils.parse_response self.class.post('/users', body: { action: params[:action], user_info: params.except(:action) }.to_json, query: { access_token: access_token })
+        params.permit_value(:action, Zoom::Constants::User::CREATE_TYPES.keys)
+        Utils.parse_response self.class.post('/users', body: { action: params[:action], user_info: params.except(:action) }.to_json, headers: request_headers)
       end
 
       def user_get(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id).permit(:login_type)
-        Utils.parse_response self.class.get("/users/#{params[:id]}", query: params.except(:id).merge(access_token: access_token))
+        Utils.parse_response self.class.get("/users/#{params[:id]}", query: params.except(:id), headers: request_headers)
       end
 
       def user_update(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id).permit(%i[first_name last_name type pmi timezone dept vanity_name host_key cms_user_id])
-        Utils.parse_response self.class.patch("/users/#{params[:id]}", body: params.except(:id), query: { access_token: access_token })
+        Utils.parse_response self.class.patch("/users/#{params[:id]}", body: params.except(:id), headers: request_headers)
       end
 
       def user_delete(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id).permit(%i[action transfer_email transfer_meeting transfer_webinar transfer_recording])
-        Utils.parse_response self.class.delete("/users/#{params[:id]}", query: params.except(:id).merge(access_token: access_token))
+        Utils.parse_response self.class.delete("/users/#{params[:id]}", query: params.except(:id), headers: request_headers)
       end
 
       def user_assistants_list(*args)
-        raise Zoom::NotImplemented, 'user_assistants_list is not yet implemented'
-        # TODO: implement user_assistants_list
-        # options = Utils.extract_options!(args)
-        # Utils.require_params([:user_id], options)
-        Utils.parse_response self.class.get("/users/#{options.slice!(:id)}/assistants", query: options.merge(access_token: access_token))
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id)
+        Utils.parse_response(self.class.get("/users/#{params[:user_id]}/assistants", query: params.except(:user_id), headers: request_headers))
       end
 
       def user_assistants_create(*args)
-        raise Zoom::NotImplemented, 'user_assistants_create is not yet implemented'
-        # TODO: validate body attributes
-        options = Utils.extract_options!(args)
-        Utils.parse_response self.class.post("/users/#{options.slice!(:id)}/assistants", body: options, query: { access_token: access_token })
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id).permit(:assistants)
+        Utils.parse_response self.class.post("/users/#{params[:user_id]}/assistants", body: params.except(:user_id).to_json, headers: request_headers)
       end
 
       def user_assistants_delete_all(*args)
-        raise Zoom::NotImplemented, 'user_assistants_delete_all is not yet implemented'
-        # TODO: implement user_assistants_delete_all
-        options = Utils.extract_options!(args)
-        Utils.parse_response self.class.delete("/users/#{options.slice!(:id)}/assistants", body: options, query: { access_token: access_token })
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id)
+        Utils.parse_response(self.class.delete("/users/#{params[:user_id]}/assistants", query: params.except(:user_id), headers: request_headers))
       end
 
       def user_assistants_delete(*args)
-        # TODO: implement user_assistants_delete
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_assistants_delete is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(%i[user_id assistant_id])
+        Utils.parse_response(self.class.delete("/users/#{params[:user_id]}/assistants/#{params[:assistant_id]}", query: params.except(:user_id, :assistant_id), headers: request_headers))
       end
 
       def user_schedulers_list(*args)
-        # TODO: implement user_schedulers_list
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_schedulers_list is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id)
+        Utils.parse_response(self.class.get("/users/#{params[:user_id]}/schedulers", query: params.except(:user_id), headers: request_headers))
       end
 
       def user_schedulers_delete_all(*args)
-        # TODO: implement user_schedulers_delete_all
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_schedulers_delete_all is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id)
+        Utils.parse_response(self.class.delete("/users/#{params[:user_id]}/schedulers", query: params.except(:user_id), headers: request_headers))
       end
 
       def user_schedulers_delete(*args)
-        # TODO: implement user_schedulers_delete
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_schedulers_delete is not yet implemented'
-      end
-
-      def user_upload_picture(*args)
-        # TODO: implement user_upload_picture
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_upload_picture is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(%i[user_id scheduler_id])
+        Utils.parse_response(self.class.delete("/users/#{params[:user_id]}/schedulers/#{params[:scheduler_id]}", query: params.except(:user_id, :scheduler_id), headers: request_headers))
       end
 
       def user_settings_get(*args)
-        # TODO: implement user_settings_get
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_settings_get is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id).permit(:login_type)
+        Utils.parse_response self.class.get("/users/#{params[:id]}/settings", query: params.except(:id), headers: request_headers)
       end
 
       def user_settings_update(*args)
-        # TODO: implement user_settings_update
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_settings_update is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id).permit(%i[schedule_meeting in_meeting email_notification recording telephony feature tsp])
+        Utils.parse_response self.class.patch("/users/#{params[:id]}/settings", body: params.except(:id).to_json, headers: request_headers)
       end
 
-      def user_status_update(*args)
-        # TODO: implement user_status_update
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_status_update is not yet implemented'
+      def user_email_check(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:email)
+        Utils.parse_response(self.class.get('/users/email', query: params.slice(:email), headers: request_headers))
       end
 
-      def user_password_update(*args)
-        # TODO: implement user_password_update
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_password_update is not yet implemented'
+      def user_recordings_list(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id).permit(%i[page_size next_page_token mc trash from to trash_type])
+        Utils.parse_response self.class.get("/users/#{params[:id]}/recordings", query: params.except(:id), headers: request_headers)
       end
 
-      def user_permissions_get(*args)
-        # TODO: implement user_permissions_get
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_permissions_get is not yet implemented'
+      def user_token(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id).permit(%i[type ttl])
+        Utils.parse_response self.class.get("/users/#{params[:user_id]}/token", query: params.except(:user_id), headers: request_headers)
       end
 
-      def user_token_get(*args)
-        # TODO: implement user_token_get
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_token_get is not yet implemented'
+      def user_permissions(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:user_id)
+        Utils.parse_response self.class.get("/users/#{params[:user_id]}/permissions", headers: request_headers)
       end
 
-      def user_token_delete(*args)
-        # TODO: implement user_token_delete
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_token_delete is not yet implemented'
+      def user_vanity_name(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:vanity_name)
+        Utils.parse_response self.class.get("/users/vanity_name", query: params.slice(:vanity_name), headers: request_headers)
       end
 
-      def user_email_check(*args)
-        # TODO: implement user_email_check
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_email_check is not yet implemented'
+      def user_password_update(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id).permit(%i[password])
+        Utils.parse_response self.class.patch("/users/#{params[:id]}/password", body: params.except(:id), headers: request_headers)
       end
 
-      def user_vanity_name_check(*args)
-        # TODO: implement user_vanity_name_check
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'user_vanity_name_check is not yet implemented'
-      end
     end
   end
 end

data/lib/zoom/actions/webinar.rb

@@ -5,14 +5,19 @@ module Zoom
     module Webinar
       RECURRENCE_KEYS = %i[type repeat_interval weekly_days monthly_day monthly_week
                            monthly_week_day end_times end_date_time].freeze
-      SETTINGS_KEYS = %i[panelists_video practice_session hd_video approval_type
+      SETTINGS_KEYS = %i[host_video panelists_video practice_session hd_video approval_type
                          registration_type audio auto_recording enforce_login
                          enforce_login_domains alternative_hosts close_registration
-                         show_share_button allow_multiple_devices registrants_confirmation_email].freeze
+                         show_share_button allow_multiple_devices on_demand
+                         request_permission_to_unmute_participants global_dial_in_countries
+                         contact_name contact_email registrants_restrict_number
+                         post_webinar_survey survey_url registrants_email_notification
+                         meeting_authentication authentication_option
+                         authentication_domains registrants_confirmation_email question_answer].freeze
       def webinar_list(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:host_id).permit(:page_size, :page_number)
-        Utils.parse_response self.class.get("/users/#{params[:host_id]}/webinars", query: params.merge(access_token: access_token))
+        params.require(:host_id).permit(%i[page_size page_number])
+        Utils.parse_response self.class.get("/users/#{params[:host_id]}/webinars", query: params.except(:host_id), headers: request_headers)
       end
 
       def webinar_create(*args)
@@ -21,15 +26,15 @@ module Zoom
                                         :timezone, :password, :agenda,
                                         recurrence: RECURRENCE_KEYS,
                                         settings: SETTINGS_KEYS)
-        # process recurrence keys based on constants
-        # process settings keys based on constants
-        Utils.parse_response self.class.post("/users/#{params[:host_id]}/webinars", body: params.except(:host_id).to_json, query: { access_token: access_token })
+        # TODO: process recurrence keys based on constants
+        # TODO: process settings keys based on constants
+        Utils.parse_response self.class.post("/users/#{params[:host_id]}/webinars", body: params.except(:host_id).to_json, headers: request_headers)
       end
 
       def webinar_get(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id)
-        Utils.parse_response self.class.get("/webinars/#{params[:id]}", query: { access_token: access_token })
+        Utils.parse_response self.class.get("/webinars/#{params[:id]}", headers: request_headers)
       end
 
       def webinar_update(*args)
@@ -38,71 +43,65 @@ module Zoom
                                    :timezone, :password, :agenda,
                                    recurrence: RECURRENCE_KEYS,
                                    settings: SETTINGS_KEYS)
-        Utils.parse_response self.class.patch("/webinars/#{params[:id]}", body: params.except(:id).to_json, query: { access_token: access_token })
+        Utils.parse_response self.class.patch("/webinars/#{params[:id]}", body: params.except(:id).to_json, headers: request_headers)
       end
 
       def webinar_delete(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id).permit(:occurrence_id)
-        Utils.parse_response self.class.delete("/webinars/#{params[:id]}", query: params.except(:id).merge(access_token: access_token))
-      end
-
-      def webinar_status_update(*args)
-        # TODO: implement webinar_panelists_list
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'webinar_status_update is not yet implemented'
-      end
-
-      def webinar_panelists_list(*args)
-        # TODO: implement webinar_panelists_list
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'webinar_panelists_list is not yet implemented'
-      end
-
-      def webinar_panelist_add(*args)
-        # TODO: implement webinar_panelist_add
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'webinar_panelist_add is not yet implemented'
-      end
-
-      def webinar_panelists_delete_all(*args)
-        # TODO: implement webinar_panelists_delete_all
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'webinar_panelists_delete_all is not yet implemented'
-      end
-
-      def webinar_panelist_delete(*args)
-        # TODO: implement webinar_panelist_delete
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'webinar_panelist_delete is not yet implemented'
+        Utils.parse_response self.class.delete("/webinars/#{params[:id]}", query: params.except(:id), headers: request_headers)
       end
 
       def webinar_registrants_list(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
         params.require(:id).permit(%i[occurrence_id status page_size page_number])
-        Utils.parse_response self.class.get("/webinars/#{params[:id]}/registrants", query: params.except(:id).merge(access_token: access_token))
+        Utils.parse_response self.class.get("/webinars/#{params[:id]}/registrants", query: params.except(:id), headers: request_headers)
       end
 
       def webinar_registrant_add(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id, :email, :first_name, :last_name)
+        params.require(%i[id email first_name last_name])
               .permit(%i[occurrence_ids address city country zip state phone
                          industry org job_title purchasing_time_frame role_in_purchase_process
                          no_of_employees comments custom_questions])
-        Utils.parse_response self.class.post("/webinars/#{params[:id]}/registrants", body: params.except(:id, :occurrence_ids).to_json, query: params.slice(:occurrence_ids).merge(access_token: access_token))
+        Utils.parse_response self.class.post("/webinars/#{params[:id]}/registrants", body: params.except(:id, :occurrence_ids).to_json, query: params.slice(:occurrence_ids), headers: request_headers)
       end
 
       def webinar_registrants_status_update(*args)
         params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id, :action)
+        params.require(%i[id action])
               .permit(:occurrence_id, registrants: [])
-        Utils.parse_response self.class.put("/webinars/#{params[:id]}/registrants/status", body: params.except(:id, :occurrence_ids).to_json, query: params.slice(:occurrence_ids).merge(access_token: access_token))
+        Utils.parse_response self.class.put("/webinars/#{params[:id]}/registrants/status", body: params.except(:id, :occurrence_id).to_json, query: params.slice(:occurrence_id), headers: request_headers)
       end
 
       def past_webinar_list(*args)
-        # TODO: implement past_webinars_list
-        # options = Utils.extract_options!(args)
-        raise Zoom::NotImplemented, 'past_webinars_list is not yet implemented'
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id)
+        Utils.parse_response self.class.get("/past_webinars/#{params[:id]}/instances", headers: request_headers)
+      end
+
+      def webinar_registrant_get(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(%i[webinar_id id]).permit(:occurrence_id)
+        Utils.parse_response self.class.get("/webinars/#{params[:webinar_id]}/registrants/#{params[:id]}", query: params.except(:webinar_id, :id), headers: request_headers)
+      end
+
+      def webinar_polls_list(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:webinar_id)
+        Utils.parse_response self.class.get("/webinars/#{params[:webinar_id]}/polls", headers: request_headers)
+      end
+
+      def webinar_poll_get(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(%i[webinar_id poll_id])
+        Utils.parse_response self.class.get("/webinars/#{params[:webinar_id]}/polls/#{params[:poll_id]}", headers: request_headers)
+      end
+
+      def webinar_panelist_list(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:webinar_id)
+        Utils.parse_response self.class.get("/webinars/#{params[:webinar_id]}/panelists", headers: request_headers)
       end
     end
   end

data/lib/zoom/client.rb

@@ -1,21 +1,24 @@
 # frozen_string_literal: true
 
 require 'httparty'
-require 'json'
-require 'jwt'
 
 module Zoom
   class Client
     include HTTParty
     include Actions::Account
-    include Actions::Group
+    include Actions::Billing
+    include Actions::Dashboard
+    include Actions::Groups
     include Actions::M323Device
-    include Actions::User
     include Actions::Meeting
-    include Actions::Metrics
-    include Actions::Webinar
-    include Actions::Report
+    include Actions::Phone
     include Actions::Recording
+    include Actions::Report
+    include Actions::Roles
+    include Actions::SipAudio
+    include Actions::Token
+    include Actions::User
+    include Actions::Webinar
     include Actions::IM::Chat
     include Actions::IM::Group
 
@@ -23,14 +26,30 @@ module Zoom
     headers 'Accept' => 'application/json'
     headers 'Content-Type' => 'application/json'
 
-    def initialize(config)
-      Utils.require_params(%i[api_key api_secret], config)
-      config.each { |k, v| instance_variable_set("@#{k}", v) }
-      self.class.default_timeout(@timeout)
+    def headers
+      {
+        'Accept' => 'application/json',
+        'Content-Type' => 'application/json',
+      }
     end
 
-    def access_token
-      JWT.encode({ iss: @api_key, exp: Time.now.to_i + @timeout }, @api_secret, 'HS256', { typ: 'JWT' })
+    def oauth_request_headers
+      {
+        'Authorization' => "Basic #{auth_token}"
+      }.merge(headers)
+    end
+
+    def request_headers
+      {
+        'Authorization' => "Bearer #{access_token}"
+      }.merge(headers)
+    end
+
+    def auth_token
+      Base64.encode64("#{Zoom.configuration.api_key}:#{Zoom.configuration.api_secret}").delete("\n")
     end
   end
 end
+
+require 'zoom/clients/jwt'
+require 'zoom/clients/oauth'