feat(av-moderation) Remove from moderation whitelist functionality (#1729)

* feat(av-moderation) Remove from moderation whitelist functionality

* Fix comment

JitsiConference.js

 
         this.room.getAVModeration().approve(mediaType, participant.getJid());
     } else {
-        logger.warn(`AV moderation skipped , ${this.room ? '' : 'not in a room, '}${
+        logger.warn(`AV moderation approve skipped , ${this.room ? '' : 'not in a room, '}${
+            this.isModerator() ? '' : 'participant is not a moderator, '}${
+            this.room && this.isModerator() ? 'wrong media type passed' : ''}`);
+    }
+};
+
+/**
+ * Reject participant access to certain media, blocks unmuting audio or video.
+ *
+ * @param {MediaType} mediaType "audio" or "video"
+ * @param id the id of the participant.
+ */
+JitsiConference.prototype.avModerationReject = function(mediaType, id) {
+    if (this.room && this.isModerator()
+        && (mediaType === MediaType.AUDIO || mediaType === MediaType.VIDEO)) {
+
+        const participant = this.getParticipantById(id);
+
+        if (!participant) {
+            return;
+        }
+
+        this.room.getAVModeration().reject(mediaType, participant.getJid());
+    } else {
+        logger.warn(`AV moderation reject skipped , ${this.room ? '' : 'not in a room, '}${
             this.isModerator() ? '' : 'participant is not a moderator, '}${
             this.room && this.isModerator() ? 'wrong media type passed' : ''}`);
     }

JitsiConferenceEventManager.js

                 });
             }
         });
+    this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_PARTICIPANT_REJECTED,
+        (mediaType, jid) => {
+            const participant = conference.getParticipantById(Strophe.getResourceFromJid(jid));
+
+            if (participant) {
+                conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_PARTICIPANT_REJECTED, {
+                    participant,
+                    mediaType
+                });
+            }
+        });
     this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_APPROVED,
         value => conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_APPROVED, { mediaType: value }));
+    this._addConferenceXMPPListener(XMPPEvents.AV_MODERATION_REJECTED,
+        value => {
+            conference.eventEmitter.emit(JitsiConferenceEvents.AV_MODERATION_REJECTED, { mediaType: value });
+        });
 };
 
 /**

JitsiConferenceEvents.js

  */
 export const AV_MODERATION_APPROVED = 'conference.av_moderation.approved';
 
+/**
+ * The local participant was blocked to be able to unmute.
+ * @param {options} event - {
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_REJECTED = 'conference.av_moderation.rejected';
+
 /**
  * AV Moderation was enabled/disabled. The actor is the participant that is currently in the meeting,
  * or undefined if that participant has left the meeting.
  * }.
  */
 export const AV_MODERATION_PARTICIPANT_APPROVED = 'conference.av_moderation.participant.approved';
+
+/**
+ * AV Moderation, report for user being blocked to unmute.
+ * @param {options} event - {
+ *     {JitsiParticipant} participant,
+ *     {MediaType} mediaType
+ * }.
+ */
+export const AV_MODERATION_PARTICIPANT_REJECTED = 'conference.av_moderation.participant.rejected';

modules/xmpp/AVModeration.js

 
         this._mainRoom = room;
 
-        this._momderationEnabledByType = {
+        this._moderationEnabledByType = {
             [MediaType.AUDIO]: false,
             [MediaType.VIDEO]: false
         };
             return;
         }
 
-        if (state === this._momderationEnabledByType[mediaType]) {
+        if (state === this._moderationEnabledByType[mediaType]) {
             logger.warn(`Moderation already in state:${state} for mediaType:${mediaType}`);
 
             return;
         this._xmpp.connection.send(msg);
     }
 
+    /**
+     * Rejects that a participant can unmute by sending a msg with its jid to the component.
+     */
+    reject(mediaType, jid) {
+        if (!this.isSupported() || !this._mainRoom.isModerator()) {
+            logger.error(`Cannot reject in AV moderation supported:${this.isSupported()},
+                moderator:${this._mainRoom.isModerator()}`);
+
+            return;
+        }
+
+        // send a message to remove from whitelist the jid and reject it to unmute
+        const msg = $msg({ to: this._xmpp.avModerationComponentAddress });
+
+        msg.c('av_moderation', {
+            mediaType,
+            jidToBlacklist: jid
+        }).up();
+
+        this._xmpp.connection.send(msg);
+    }
+
     /**
      * Receives av_moderation parsed messages as json.
      * @param obj the parsed json content of the message to process.
      * @private
      */
     _onMessage(obj) {
-        const newWhitelists = obj.whitelists;
+        const { removed, mediaType: media, enabled, approved, actor, whitelists: newWhitelists } = obj;
 
         if (newWhitelists) {
-            const fireEventApprovedJids = (mediaType, oldList, newList) => {
+            const oldList = media === MediaType.AUDIO
+                ? this._whitelistAudio
+                : this._whitelistVideo;
+            const newList = Array.isArray(newWhitelists[media]) ? newWhitelists[media] : [];
+
+            if (removed) {
+                oldList.filter(x => !newList.includes(x))
+                    .forEach(jid => this._xmpp.eventEmitter
+                        .emit(XMPPEvents.AV_MODERATION_PARTICIPANT_REJECTED, media, jid));
+            } else {
                 newList.filter(x => !oldList.includes(x))
                     .forEach(jid => this._xmpp.eventEmitter
-                        .emit(XMPPEvents.AV_MODERATION_PARTICIPANT_APPROVED, mediaType, jid));
-            };
-
-            if (Array.isArray(newWhitelists[MediaType.AUDIO])) {
-                fireEventApprovedJids(MediaType.AUDIO, this._whitelistAudio, newWhitelists[MediaType.AUDIO]);
+                        .emit(XMPPEvents.AV_MODERATION_PARTICIPANT_APPROVED, media, jid));
             }
 
-            if (Array.isArray(newWhitelists[MediaType.VIDEO])) {
-                fireEventApprovedJids(MediaType.VIDEO, this._whitelistVideo, newWhitelists[MediaType.VIDEO]);
+            if (media === MediaType.AUDIO) {
+                this._whitelistAudio = newList;
+            } else {
+                this._whitelistVideo = newList;
             }
-        } else if (obj.enabled !== undefined && this._momderationEnabledByType[obj.mediaType] !== obj.enabled) {
-            this._momderationEnabledByType[obj.mediaType] = obj.enabled;
+        } else if (enabled !== undefined && this._moderationEnabledByType[media] !== enabled) {
+            this._moderationEnabledByType[media] = enabled;
+
+            this._xmpp.eventEmitter.emit(XMPPEvents.AV_MODERATION_CHANGED, enabled, media, actor);
+        } else if (approved) {
+            const event = removed ? XMPPEvents.AV_MODERATION_REJECTED : XMPPEvents.AV_MODERATION_APPROVED;
 
-            this._xmpp.eventEmitter.emit(XMPPEvents.AV_MODERATION_CHANGED, obj.enabled, obj.mediaType, obj.actor);
-        } else if (obj.approved) {
-            this._xmpp.eventEmitter.emit(XMPPEvents.AV_MODERATION_APPROVED, obj.mediaType);
+            this._xmpp.eventEmitter.emit(event, media);
         }
     }
 }

service/xmpp/XMPPEvents.js

      */
     AV_MODERATION_APPROVED: 'xmpp.av_moderation.approved',
 
+    /**
+    * Event fired when we receive a message for AV moderation rejected for the local participant.
+    */
+    AV_MODERATION_REJECTED: 'xmpp.av_moderation.rejected',
+
     /**
      * Event fired when we receive a message for AV moderation.
      */
      */
     AV_MODERATION_PARTICIPANT_APPROVED: 'xmpp.av_moderation.participant.approved',
 
+    /**
+     * Event fired when we receive message that a new jid was approved.
+     */
+    AV_MODERATION_PARTICIPANT_REJECTED: 'xmpp.av_moderation.participant.rejected',
+
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS: 'xmpp.start_muted_from_focus',