zoom_rb 0.8.1

data/lib/zoom/actions/im/group.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module IM
+      module Group
+      end
+    end
+  end
+end

data/lib/zoom/actions/m323_device.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module M323Device
+    end
+  end
+end

data/lib/zoom/actions/meeting.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Meeting
+      # Create a meeting on Zoom, return the created meeting URL
+      def meeting_create(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[host_id topic type], options)
+        Utils.process_datetime_params!(:start_time, options)
+        Utils.parse_response self.class.post('/meeting/create', query: options)
+      end
+
+      # Delete a meeting on Zoom, return the deleted meeting ID.
+      def meeting_delete(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[id host_id], options)
+        Utils.parse_response self.class.post('/meeting/delete', query: options)
+      end
+
+      # End a meeting on Zoom, return the deleted meeting ID.
+      def meeting_end(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[id host_id], options)
+        Utils.parse_response self.class.post('/meeting/end', query: options)
+      end
+
+      # Get a meeting on Zoom via meeting ID, return the meeting info.
+      def meeting_get(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[id host_id], options)
+        Utils.parse_response self.class.post('/meeting/get', query: options)
+      end
+
+      # List all the scheduled meetings on Zoom.
+      def meeting_list(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(:host_id, options)
+        Utils.process_datetime_params!(:start_time, options)
+        # TODO Handle `page_size` attr, Defaults to 30. Max of 300 meetings.
+        # TODO Handle `page_number` attr, Defaults to 1.
+        Utils.parse_response self.class.post('/meeting/list', query: options)
+      end
+
+      # Lists the live meetings on Zoom.
+      def meeting_live(*args)
+        options = Utils.extract_options!(args)
+        Utils.parse_response self.class.post('/meeting/live', query: options)
+      end
+
+      # Register for a meeting.
+      def meeting_register(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[id email first_name last_name], options)
+        # TODO Verify country param by referring to the id value in country list JSON file
+        # TODO Verify Purchasing Time Frame, should be "Within a month", "1-3 months", "4-6 months", "More than 6 months", "No timeframe".
+        # TODO Verify Role in Purchase Process, should be "Decision Maker", "Evaluator/Recommender", "Influencer", "Not involved".
+        # TODO Verify Number of Employees, should be "1-20", "21-50", "51-100", "101-250", "251-500", "501-1,000", "1,001-5,000", "5,001-10,000", "More than 10,000".
+        # TODO Verify Custom Questions, should be JSON format
+        # TODO Verify Language, should be "en-US", "en", "zh-CN", "zh", "en-ES", "es", “fr-FR” or "fr"
+        Utils.parse_response self.class.post('/meeting/register', query: options)
+      end
+
+      # Update meeting info on Zoom via meeting ID.
+      def meeting_update(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[id host_id type], options)
+        Utils.process_datetime_params!(:start_time, options)
+        # TODO Handle `topic` attr, Max of 300 characters.
+        # TODO Handle `timezone` attr, refer to the id value in timezone list JSON file. like "America/Los_Angeles"
+        # TODO Verify `password` attr, may only contain the following characters: a-z A-Z 0-9 @ - _
+        # TODO Handle `option_audio` attr, Can be "both", "telephony", "voip".
+        # TODO Handle `option_auto_record_type`, Can be "local", “cloud” or "none".
+        Utils.parse_response self.class.post('/meeting/update', query: options)
+      end
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end

data/lib/zoom/actions/metrics.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Metrics
+      def metrics_crc(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[from to], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/metrics/crc', query: options)
+      end
+
+      def metrics_meetings(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[from to type], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/metrics/meetings', query: options)
+      end
+
+      def metrics_meetingdetail(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[meeting_id type], options)
+        Utils.parse_response self.class.post('/metrics/meetingdetail', query: options)
+      end
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end

data/lib/zoom/actions/recording.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Recording
+      def recording_list(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params([:host_id], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/recording/list', query: options)
+      end
+
+      def mc_recording_list(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params([:host_id], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/mc/recording/list', query: options)
+      end
+
+      def recording_get(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params([:meeting_id], options)
+        Utils.parse_response self.class.post('/recording/get', query: options)
+      end
+
+      def recording_delete(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params([:meeting_id], options)
+        Utils.parse_response self.class.post('/recording/delete', query: options)
+      end
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end

data/lib/zoom/actions/report.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Report
+      def report_getaccountreport(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[from to], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/report/getaccountreport', query: options)
+      end
+
+      def report_getuserreport(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[user_id from to], options)
+        Utils.process_datetime_params!(%i[from to], options)
+        Utils.parse_response self.class.post('/report/getuserreport', query: options)
+      end
+
+      def report_getdailyreport(*args)
+        options = Utils.extract_options!(args)
+        Utils.require_params(%i[year month], options)
+        Utils.parse_response self.class.post('/report/getdailyreport', query: options)
+      end
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end

data/lib/zoom/actions/user.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    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))
+        Utils.parse_response(response)
+      end
+
+      def user_create(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(%i[email type first_name last_name password])
+        Utils.parse_response self.class.post('/users', body: { action: 'create', user_info: params }, query: { access_token: access_token })
+      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))
+      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 })
+      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))
+      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))
+      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 })
+      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 })
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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'
+      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
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end

data/lib/zoom/actions/webinar.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    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
+                         registration_type audio auto_recording enforce_login
+                         enforce_login_domains alternative_hosts close_registration
+                         show_share_button allow_multiple_devices].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))
+      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)
+        # process recurrence keys based on defaults
+        # process settings keys based on defaults
+        Utils.parse_response self.class.post("/users/#{params[:host_id]}/webinars", body: params.except(:host_id).to_json, query: { access_token: access_token })
+      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 })
+      end
+
+      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, query: { access_token: access_token })
+      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'
+      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))
+      end
+
+      def webinar_registrant_add(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(: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), query: params.slice(:occurrence_ids).merge(access_token: access_token))
+      end
+
+      def webinar_registrants_status_update(*args)
+        # TODO: implement webinar_registrants_status_update
+        # options = Utils.extract_options!(args)
+        raise Zoom::NotImplemented, 'webinar_registrants_status_update is not yet implemented'
+      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'
+      end
+
+      Utils.define_bang_methods(self)
+    end
+  end
+end