zoom_markazuna 0.10.0

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module IM
+      module Chat
+        # Get chat messages for a specified period.
+        def chat_get(*args)
+          options = Utils.extract_options!(args)
+          Zoom::Params.new(options).require(:access_token, :session_id, :from, :to)
+          # TODO handle date format for `from` and `to` params
+          # TODO implement `next_page_token`, will be returned whenever the set of available chat history list exceeds 100. The expiration period is 30 minutes.
+          Utils.parse_response self.class.post('/chat/get', query: options)
+        end
+
+        # Get chat history list for a specified time period.
+        def chat_list(*args)
+          options = Utils.extract_options!(args)
+          Zoom::Params.new(options).require(:access_token, :from, :to)
+          # TODO handle date format for `from` and `to` params
+          # TODO implement `next_page_token`, will be returned whenever the set of available chat history list exceeds 100. The expiration period is 30 minutes.
+          Utils.parse_response self.class.post('/chat/list', query: options)
+        end
+      end
+    end
+  end
+end

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,89 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Meeting
+      # List all the scheduled meetings on Zoom.
+      def meeting_list(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[user_id])
+        Utils.parse_response self.class.get("/users/#{options[:user_id]}/meetings", query: options.except(:user_id), headers: request_headers)
+      end
+
+      # Create a meeting on Zoom, return the created meeting URL
+      def meeting_create(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[user_id])
+        Utils.process_datetime_params!(:start_time, options)
+        Utils.parse_response self.class.post("/users/#{options[:user_id]}/meetings", body: options.except(:user_id).to_json, headers: request_headers)
+      end
+
+      # Get a meeting on Zoom via meeting ID, return the meeting info.
+      def meeting_get(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_id])
+        Utils.parse_response self.class.get("/meetings/#{options[:meeting_id]}", headers: request_headers)
+      end
+
+      # Update meeting info on Zoom via meeting ID.
+      def meeting_update(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_id])
+        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.patch("/meetings/#{options[:meeting_id]}", body: options.except(:meeting_id).to_json, headers: request_headers)
+      end
+
+      # Delete a meeting on Zoom, return the deleted meeting ID.
+      def meeting_delete(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_id])
+        Utils.parse_response self.class.delete("/meetings/#{options[:meeting_id]}", query: options.except(:meeting_id), headers: request_headers)
+      end
+
+      # Update a meeting's status
+      def meeting_update_status(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_id])
+        Utils.parse_response self.class.put("/meetings/#{options[:meeting_id]}/status", body: options.except(:meeting_id).to_json, headers: request_headers)
+      end
+
+      # End a meeting on Zoom, return the deleted meeting ID.
+      def meeting_end(*args)
+        options = Utils.extract_options!(args)
+        meeting_update_status(options.merge(action: 'end'))
+      end
+
+      # Lists the live meetings on Zoom.
+      def meeting_live(*args)
+        options = Utils.extract_options!(args)
+        meeting_list(options.merge(type: 'live'))
+      end
+
+      # Register for a meeting.
+      def meeting_register(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_id email first_name last_name])
+        Utils.parse_response self.class.post("/meetings/#{options[:meeting_id]}/registrants", body: options.except(:meeting_id).to_json, headers: request_headers)
+      end
+
+      # Retrieve ended meeting details
+      def past_meeting_details(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_uuid])
+        Utils.parse_response self.class.get("/past_meetings/#{options[:meeting_uuid]}", headers: request_headers)
+      end
+
+      # Retrieve ended meeting participants
+      def past_meeting_participants(*args)
+        options = Zoom::Params.new(Utils.extract_options!(args))
+        options.require(%i[meeting_uuid])
+        Utils.parse_response self.class.get("/past_meetings/#{options[:meeting_uuid]}/participants", headers: request_headers)
+      end
+    end
+  end
+end

data/lib/zoom/actions/metrics.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Metrics
+      def metrics_crc(*args)
+        options = Utils.extract_options!(args)
+        Zoom::Params.new(options).require(:from, :to)
+        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)
+        Zoom::Params.new(options).require(:from, :to, :type)
+        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)
+        Zoom::Params.new(options).require(:meeting_id, :type)
+        Utils.parse_response self.class.post('/metrics/meetingdetail', query: options)
+      end
+    end
+  end
+end

data/lib/zoom/actions/recording.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Recording
+      def recording_list(*args)
+        options = Utils.extract_options!(args)
+        Zoom::Params.new(options).require(:host_id)
+        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)
+        Zoom::Params.new(options).require(:host_id)
+        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)
+        Zoom::Params.new(options).require(:meeting_id)
+        Utils.parse_response self.class.post('/recording/get', query: options)
+      end
+
+      def recording_delete(*args)
+        options = Utils.extract_options!(args)
+        Zoom::Params.new(options).require(:meeting_id)
+        Utils.parse_response self.class.post('/recording/delete', query: options)
+      end
+    end
+  end
+end

data/lib/zoom/actions/report.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Zoom
+  module Actions
+    module Report
+      def daily_report(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.permit(:year, :month)
+        Utils.parse_response self.class.get('/report/daily', query: params, headers: request_headers)
+      end
+
+      def hosts_report(*args)
+        # TODO: implement hosts_report
+      end
+
+      def meetings_report(*args)
+        # TODO: implement meetings_report
+      end
+
+      def meeting_details_report(*args)
+        # TODO: implement meeting_details_report
+      end
+
+      def meeting_participants_report(*args)
+        # TODO: implement meeting_participants_report
+      end
+
+      def meeting_polls_report(*args)
+        # TODO: implement meeting_polls_report
+      end
+
+      def webinar_details_report(*args)
+        # TODO: implement webinar_details_report
+      end
+
+      def webinar_participants_report(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(:id).permit(:page_size, :next_page_token)
+        Utils.parse_response self.class.get("/report/webinars/#{params[:id]}/participants", query: params.except(:id).merge(access_token: access_token))
+      end
+
+      def webinar_polls_report(*args)
+        # TODO: implement report_hosts
+      end
+
+      def webinar_qa_report(*args)
+        # TODO: implement report_hosts
+      end
+
+      def telephone_report(*args)
+        # TODO: implement report_hosts
+      end
+    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, 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)
+        raise Zoom::NotImplemented, 'user_assistants_list is not yet implemented'
+        # TODO: implement user_assistants_list
+        # options = Utils.extract_options!(args)
+        Utils.parse_response self.class.get("/users/#{options.slice!(:id)}/assistants", query: options, 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, 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, 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'
+      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)
+        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'
+      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
+    end
+  end
+end

data/lib/zoom/actions/webinar.rb

@@ -0,0 +1,115 @@
+# 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 registrants_confirmation_email].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, 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)
+        # 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, 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]}", headers: request_headers)
+      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, 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), headers: request_headers)
+      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), 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)
+              .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
+
+      def webinar_registrants_status_update(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(: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), headers: request_headers)
+      end
+
+      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
+
+      def webinar_registrant_get(*args)
+        params = Zoom::Params.new(Utils.extract_options!(args))
+        params.require(: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
+    end
+  end
+end