zoom_rb 0.11.0 → 1.1.0

data/lib/zoom/actions/report.rb

@@ -3,28 +3,18 @@
 module Zoom
   module Actions
     module Report
-      def daily_report(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.permit(%i[year month])
-        Utils.parse_response self.class.get('/report/daily', query: params, headers: request_headers)
-      end
-      def meeting_details_report(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id)
-        Utils.parse_response self.class.get("/report/meetings/#{params[:id]}", query: params.except(:id), headers: request_headers)
-      end
+      extend Zoom::Actions
 
-      def meeting_participants_report(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id).permit(%i[page_size next_page_token])
-        Utils.parse_response self.class.get("/report/meetings/#{params[:id]}/participants", query: params.except(:id), headers: request_headers)
-      end
+      get 'daily_report', '/report/daily',
+        permit: %i[year month]
 
-      def webinar_participants_report(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id).permit(%i[page_size next_page_token])
-        Utils.parse_response self.class.get("/report/webinars/#{params[:id]}/participants", query: params.except(:id), headers: request_headers)
-      end
+      get 'meeting_details_report', '/report/meetings/:id'
+
+      get 'meeting_participants_report', '/report/meetings/:id/participants',
+        permit: %i[page_size next_page_token]
+
+      get 'webinar_participants_report', '/report/webinars/:id/participants',
+        permit: %i[page_size next_page_token]
     end
   end
 end

data/lib/zoom/actions/roles.rb

@@ -3,39 +3,22 @@
 module Zoom
   module Actions
     module Roles
-      def roles_list(*_args)
-        Utils.parse_response self.class.get("/roles", headers: request_headers)
-      end
+      extend Zoom::Actions
 
-      def roles_create(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:name).permit(%i[description privileges])
-        Utils.parse_response self.class.post("/roles", body: params.to_json, headers: request_headers)
-      end
+      get 'roles_list', '/roles'
 
-      def roles_members(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:role_id)
-        Utils.parse_response self.class.get("/roles/#{params[:role_id]}/members", headers: request_headers)
-      end
+      post 'roles_create', '/roles',
+        require: :name,
+        permit: %i[description privileges]
 
-      def roles_assign(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(%i[role_id members])
-        Utils.parse_response self.class.post("/roles/#{params[:role_id]}/members", body: params.except(:role_id).to_json, headers: request_headers)
-      end
+      get 'roles_members', '/roles/:role_id/members'
 
-      def roles_unassign(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(%i[role_id member_id])
-        Utils.parse_response self.class.delete("/roles/#{params[:role_id]}/members/#{params[:member_id]}", headers: request_headers)
-      end
+      post 'roles_assign', '/roles/:role_id/members',
+        require: :members
 
-      def roles_get(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:role_id)
-        Utils.parse_response self.class.get("/roles/#{params[:role_id]}", headers: request_headers)
-      end
+      delete 'roles_unassign', '/roles/:role_id/members/:member_id'
+
+      get 'roles_get', '/roles/:role_id'
     end
   end
 end

data/lib/zoom/actions/sip_audio.rb

@@ -3,73 +3,32 @@
 module Zoom
   module Actions
     module SipAudio
-      def sip_trunks_get(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        Utils.parse_response self.class.get("/accounts/#{params[:account_id]}/sip_trunk/trunks", headers: request_headers)
-      end
+      extend Zoom::Actions
 
-      def sip_trunks_delete(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id, :trunk_id)
-        Utils.parse_response self.class.delete("/accounts/#{params[:account_id]}/sip_trunk/trunks/#{params[:trunk_id]}", headers: request_headers)
-      end
+      get 'sip_trunks_get', '/accounts/:account_id/sip_trunk/trunks'
 
-      def sip_trunk_numbers_delete(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        Utils.parse_response self.class.delete("/accounts/#{params[:account_id]}/sip_trunk/numbers", headers: request_headers)
-      end
+      delete 'sip_trunks_delete', '/accounts/:account_id/sip_trunk/trunks/:trunk_id'
 
-      def sip_trunks_internal_numbers_delete(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(%i[account_id number_id])
-        Utils.parse_response self.class.delete("/accounts/#{params[:account_id]}/sip_trunk/internal_numbers/#{params[:number_id]}", headers: request_headers)
-      end
+      delete 'sip_trunk_numbers_delete', '/accounts/:account_id/sip_trunk/numbers'
 
-      def sip_trunks_internal_callout_country_delete(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(%i[account_id country_id])
-        Utils.parse_response self.class.delete("/accounts/#{params[:account_id]}/sip_trunk/callout_countries/#{params[:country_id]}", headers: request_headers)
-      end
+      delete 'sip_trunks_internal_numbers_delete',
+        '/accounts/:account_id/sip_trunk/internal_numbers/:number_id'
 
-      def sip_trunks_internal_numbers_list(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id).permit(%i[page_size next_page_token])
-        response = self.class.get("/accounts/#{params[:account_id]}/sip_trunk/internal_numbers", query: params, headers: request_headers)
-        Utils.parse_response(response)
-      end
+      delete 'sip_trunks_internal_callout_country_delete',
+        '/accounts/:account_id/sip_trunk/callout_countries/:country_id'
 
-      def sip_trunks_internal_callout_country_list(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        response = self.class.get("/accounts/#{params[:account_id]}/sip_trunk/callout_countries", headers: request_headers)
-        Utils.parse_response(response)
-      end
+      get 'sip_trunks_internal_numbers_list', '/accounts/:account_id/sip_trunk/internal_numbers',
+        permit: %i[page_size next_page_token]
 
-      def sip_trunks_numbers_list(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        response = self.class.get("/sip_trunk/numbers", headers: request_headers)
-        Utils.parse_response(response)
-      end
+      get 'sip_trunks_internal_callout_country_list', '/accounts/:account_id/sip_trunk/callout_countries'
 
-      def sip_trunks_internal_numbers_add(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        Utils.parse_response self.class.post("/accounts/#{params[:account_id]}/sip_trunk/internal_numbers", headers: request_headers)
-      end
+      get 'sip_trunks_numbers_list', '/sip_trunk/numbers'
 
-      def sip_trunks_internal_callout_countries_add(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        Utils.parse_response self.class.post("/accounts/#{params[:account_id]}/sip_trunk/callout_countries", headers: request_headers)
-      end
+      post 'sip_trunks_internal_numbers_add', '/accounts/:account_id/sip_trunk/internal_numbers'
 
-      def sip_trunks_numbers_assign(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:account_id)
-        Utils.parse_response self.class.post("/accounts/#{params[:account_id]}/sip_trunk/numbers", headers: request_headers)
-      end
+      post 'sip_trunks_internal_callout_countries_add', '/accounts/:account_id/sip_trunk/callout_countries'
+
+      post 'sip_trunks_numbers_assign', '/accounts/:account_id/sip_trunk/numbers'
     end
   end
 end

data/lib/zoom/actions/token.rb

@@ -3,33 +3,30 @@
 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
+      extend Zoom::Actions
 
-      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
+      post 'access_tokens',
+        '/oauth/token',
+        oauth: true,
+        require: %i[grant_type code redirect_uri],
+        permit: :code_verifier,
+        args_to_params: { auth_code: :code }
 
-      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
+      post 'refresh_tokens',
+        '/oauth/token',
+        oauth: true,
+        require: %i[grant_type refresh_token]
 
-      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
+      post 'data_compliance', '/oauth/data/compliance',
+        oauth: true,
+        require: %i[
+          client_id user_id account_id deauthorization_event_received compliance_completed
+        ]
+
+      post 'revoke_tokens', '/oauth/revoke',
+        oauth: true,
+        require: :token,
+        args_to_params: { access_token: :token }
     end
   end
 end

data/lib/zoom/actions/user.rb

@@ -3,130 +3,72 @@
 module Zoom
   module Actions
     module User
-      def user_list(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        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
-
-      def user_create(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        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, 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), 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), 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), headers: request_headers)
-      end
-
-      def user_assistants_list(*args)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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)
-        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_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_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_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_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_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_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
+      extend Zoom::Actions
 
+      get 'user_list', '/users',
+        permit: %i[status page_size role_id page_number include_fields next_page_token]
+
+      post 'user_create', '/users',
+        require: [
+          :action,
+          user_info: %i[email type]
+        ],
+        permit: {
+          user_info: %i[first_name last_name password]
+        }
+
+      get 'user_get', '/users/:id',
+        permit: :login_type
+
+      patch 'user_update', '/users/:id',
+        permit: %i[first_name last_name type pmi timezone dept vanity_name host_key cms_user_id]
+
+      delete 'user_delete', '/users/:id',
+        permit: %i[action transfer_email transfer_meeting transfer_webinar transfer_recording]
+
+      get 'user_assistants_list', '/users/:user_id/assistants'
+
+      post 'user_assistants_create', '/users/:user_id/assistants',
+        permit: :assistants
+
+      delete 'user_assistants_delete_all', '/users/:user_id/assistants'
+
+      delete 'user_assistants_delete', '/users/:user_id/assistants/:assistant_id'
+
+      get 'user_schedulers_list', '/users/:user_id/schedulers'
+
+      delete 'user_schedulers_delete_all', '/users/:user_id/schedulers'
+
+      delete 'user_schedulers_delete', '/users/:user_id/schedulers/:scheduler_id'
+
+      get 'user_settings_get', '/users/:id/settings',
+        permit: [:login_type, :option, :custom_query_fields]
+
+      patch 'user_settings_update', '/users/:id/settings',
+        permit: %i[schedule_meeting in_meeting email_notification recording telephony feature tsp]
+
+      get 'user_email_check', '/users/email',
+        require: :email
+
+      get 'user_recordings_list', '/users/:id/recordings',
+        permit: %i[page_size next_page_token mc trash from to trash_type]
+
+      get 'user_token', '/users/:user_id/token',
+        permit: %i[type ttl]
+
+      get 'user_permissions', '/users/:user_id/permissions'
+
+      get 'user_vanity_name', '/users/vanity_name',
+        require: :vanity_name
+
+      patch 'user_password_update', '/users/:id/password',
+        permit: :password
+
+      patch 'user_email_update', '/users/:id/email',
+        permit: :email
+
+      patch 'user_status_update', '/users/:id/status',
+        permit: :status
     end
   end
 end

data/lib/zoom/actions/webinar.rb

@@ -3,6 +3,8 @@
 module Zoom
   module Actions
     module Webinar
+      extend Zoom::Actions
+
       RECURRENCE_KEYS = %i[type repeat_interval weekly_days monthly_day monthly_week
                            monthly_week_day end_times end_date_time].freeze
       SETTINGS_KEYS = %i[host_video panelists_video practice_session hd_video approval_type
@@ -14,95 +16,53 @@ module Zoom
                          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(%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)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:host_id).permit(:topic, :type, :start_time, :duration,
-                                        :timezone, :password, :agenda,
-                                        recurrence: RECURRENCE_KEYS,
-                                        settings: SETTINGS_KEYS)
-        # 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
+      get 'webinar_list', '/users/:host_id/webinars',
+        permit: %i[page_size page_number]
+
+      # TODO: process recurrence keys based on constants
+      # TODO: process settings keys based on constants
+      post 'webinar_create', '/users/:host_id/webinars',
+        permit: [
+          :topic, :type, :start_time, :duration, :timezone, :password, :agenda,
+          { recurrence: RECURRENCE_KEYS, settings: SETTINGS_KEYS }
+        ]
 
-      def webinar_get(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id)
-        Utils.parse_response self.class.get("/webinars/#{params[:id]}", headers: request_headers)
-      end
+      get 'webinar_get', '/webinars/:id'
 
-      def webinar_update(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        params.require(:id).permit(:topic, :type, :start_time, :duration,
-                                   :timezone, :password, :agenda,
-                                   recurrence: RECURRENCE_KEYS,
-                                   settings: SETTINGS_KEYS)
-        Utils.parse_response self.class.patch("/webinars/#{params[:id]}", body: params.except(:id).to_json, headers: request_headers)
-      end
+      patch 'webinar_update', '/webinars/:id',
+        permit: [
+          :topic, :type, :start_time, :duration, :timezone, :password, :agenda,
+          { recurrence: RECURRENCE_KEYS, settings: SETTINGS_KEYS }
+        ]
 
-      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), headers: request_headers)
-      end
+      delete 'webinar_delete', '/webinars/:id',
+        permit: :occurrence_id
 
-      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), headers: request_headers)
-      end
+      get 'webinar_registrants_list', '/webinars/:id/registrants',
+        permit: %i[occurrence_id status page_size page_number]
 
-      def webinar_registrant_add(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        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), headers: request_headers)
-      end
+      post 'webinar_registrant_add', '/webinars/:id/registrants',
+        require: %i[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
+        ]
 
-      def webinar_registrants_status_update(*args)
-        params = Zoom::Params.new(Utils.extract_options!(args))
-        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_id).to_json, query: params.slice(:occurrence_id), headers: request_headers)
-      end
+      put 'webinar_registrants_status_update', '/webinars/:id/registrants/status',
+        require: :action,
+        permit: [ :occurrence_id, registrants: [] ]
 
-      def past_webinar_list(*args)
-        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
+      get 'past_webinar_list', '/past_webinars/:id/instances'
 
-      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
+      get 'webinar_registrant_get', '/webinars/:webinar_id/registrants/:id',
+        permit: :occurrence_id
 
-      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
+      get 'webinar_polls_list', '/webinars/:webinar_id/polls'
 
-      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
+      get 'webinar_poll_get', '/webinars/:webinar_id/polls/:poll_id'
 
-      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
+      get 'webinar_panelist_list', '/webinars/:webinar_id/panelists'
     end
   end
 end

data/lib/zoom/actions.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    def self.extract_path_keys(path)
+      path.scan(/:\w+/).map { |match| match[1..].to_sym }
+    end
+
+    def self.parse_path(path, path_keys, params)
+      parsed_path = path.dup
+      path_keys.each do |key|
+        value        = params[key].to_s
+        parsed_path  = parsed_path.sub(":#{key}", value)
+      end
+      parsed_path
+    end
+
+    def self.determine_request_options(client, oauth)
+      if oauth
+        {
+          headers: client.oauth_request_headers,
+          base_uri: 'https://zoom.us/'
+        }
+      else
+        { headers: client.request_headers }
+      end
+    end
+
+    def self.make_request(args)
+      client, method, parsed_path, params, request_options, oauth =
+        args.values_at :client, :method, :parsed_path, :params, :request_options, :oauth
+      case method
+      when :get
+        request_options[:query] = params
+      when :post, :put, :patch
+        request_options[:body] =
+          oauth ? URI.encode_www_form(params.to_a) : params.to_json
+      end
+      client.class.public_send(method, parsed_path, **request_options)
+    end
+
+    [:get, :post, :patch, :put, :delete].each do |method|
+      define_method(method) do |name, path, options={}|
+        required, permitted, oauth, args_to_params, headers =
+          options.values_at :require, :permit, :oauth, :args_to_params, :headers
+        required = Array(required) unless required.is_a?(Hash)
+        permitted = Array(permitted) unless permitted.is_a?(Hash)
+
+        define_method(name) do |*args|
+          path_keys = Zoom::Actions.extract_path_keys(path)
+          params = Utils.extract_options!(args)
+          args_to_params&.each { |key, value| params[value] = params.delete key if params[key] }
+          params = Zoom::Params.new(params)
+          parsed_path = Zoom::Actions.parse_path(path, path_keys, params)
+          request_options = Zoom::Actions.determine_request_options(self, oauth)
+          params = params.require(path_keys) unless path_keys.empty?
+          params_without_required = required.empty? ? params : params.require(required)
+          params_without_required.permit(permitted) unless permitted.empty?
+          response = Zoom::Actions.make_request({
+            client: self, method: method, parsed_path: parsed_path,
+            params: params, request_options: request_options, oauth: oauth
+          })
+          Utils.parse_response(response)
+        end
+      end
+    end
+  end
+end