[eslint] no-negated-condition

.eslintrc.js

         'no-array-constructor': 2,
         'no-inline-comments': 0,
         'no-mixed-spaces-and-tabs': 2,
+        'no-negated-condition': 2,
         'no-nested-ternary': 0,
         'no-new-object': 2,
         'no-plusplus': 0,

modules/RTC/JitsiLocalTrack.js

                     const mediaType = self.getType();
                     const streamInfo = streamsInfo.find(info => info.mediaType === mediaType);
 
-                    if(!streamInfo) {
-                        throw new JitsiTrackError(
-                            JitsiTrackErrors.TRACK_NO_STREAM_FOUND);
-                    }else {
+                    if (streamInfo) {
                         self._setStream(streamInfo.stream);
                         self.track = streamInfo.track;
                         // This is not good when video type changes after
                                 self.videoType, streamInfo.videoType);
                             self.videoType = streamInfo.videoType;
                         }
+                    }else {
+                        throw new JitsiTrackError(
+                            JitsiTrackErrors.TRACK_NO_STREAM_FOUND);
                     }
 
                     self.containers = self.containers.map(cont => RTCUtils.attachMediaStream(cont, self.stream));

modules/RTC/JitsiTrack.js

  */
 function addMediaStreamInactiveHandler(mediaStream, handler) {
     // Temasys will use onended
-    if(typeof mediaStream.active !== 'undefined') {
-        mediaStream.oninactive = handler;
-    } else {
+    if (typeof mediaStream.active === 'undefined') {
         mediaStream.onended = handler;
+    } else {
+        mediaStream.oninactive = handler;
     }
 }
 

modules/RTC/RTC.js

         return RTCUtils.obtainAudioAndVideoPermissions(options).then(
             tracksInfo => {
                 const tracks = createLocalTracks(tracksInfo, options);
-                return !tracks.some(track =>
-                    !track._isReceivingData()) ? tracks
-                        : Promise.reject(new JitsiTrackError(
-                            JitsiTrackErrors.NO_DATA_FROM_SOURCE));
+                return tracks.some(track => !track._isReceivingData())
+                    ? Promise.reject(
+                        new JitsiTrackError(
+                            JitsiTrackErrors.NO_DATA_FROM_SOURCE))
+                    : tracks;
             });
     }
 

modules/RTC/RTCUtils.js

             // The react-native-webrtc project that we're currently using
             // expects the audio constraint to be a boolean.
             constraints.audio = true;
-        } else if (!RTCBrowserType.isFirefox()) {
+        } else if (RTCBrowserType.isFirefox()) {
+            if (options.micDeviceId) {
+                constraints.audio = {
+                    mandatory: {},
+                    deviceId: options.micDeviceId, // new style
+                    optional: [{
+                        sourceId: options.micDeviceId // old style
+                    }]};
+            } else {
+                constraints.audio = true;
+            }
+        } else {
             // same behaviour as true
             constraints.audio = { mandatory: {}, optional: []};
             if (options.micDeviceId) {
                 {googEchoCancellation2: !disableAEC},
                 {googAutoGainControl2: true}
             );
-        } else {
-            if (options.micDeviceId) {
-                constraints.audio = {
-                    mandatory: {},
-                    deviceId: options.micDeviceId, // new style
-                    optional: [{
-                        sourceId: options.micDeviceId // old style
-                    }]};
-            } else {
-                constraints.audio = true;
-            }
         }
     }
     if (um.indexOf('screen') >= 0) {

modules/RTC/ScreenObtainer.js

         } else if (RTCBrowserType.isTemasysPluginUsed()) {
             // XXX Don't require Temasys unless it's to be used because it
             // doesn't run on React Native, for example.
-            const AdapterJS = require('./adapter.screenshare');
+            const plugin
+                = require('./adapter.screenshare').WebRTCPlugin.plugin;
 
-            if (!AdapterJS.WebRTCPlugin.plugin.HasScreensharingFeature) {
-                logger.info('Screensharing not supported by this plugin '
-                    + 'version');
-            } else if(!AdapterJS.WebRTCPlugin.plugin.isScreensharingAvailable) {
-                logger.info(
-                    'Screensharing not available with Temasys plugin on'
-                    + ' this site');
+            if (plugin.HasScreensharingFeature) {
+                if (plugin.isScreensharingAvailable) {
+                    obtainDesktopStream = obtainWebRTCScreen;
+                    logger.info('Using Temasys plugin for desktop sharing');
+                } else {
+                    logger.info(
+                        'Screensharing not available with Temasys plugin on'
+                            + ' this site');
+                }
             } else {
-                obtainDesktopStream = obtainWebRTCScreen;
-                logger.info('Using Temasys plugin for desktop sharing');
+                logger.info(
+                    'Screensharing not supported by this plugin version');
             }
         } else if (RTCBrowserType.isChrome()) {
             if (options.desktopSharingChromeDisabled

modules/transcription/transcriptionServices/AbstractTranscriptionService.js

 TranscriptionService.prototype.send = function send(recordingResult, callback) {
     const t = this;
     this.sendRequest(recordingResult.blob, response => {
-        if(!t.verify(response)) {
-            console.log('the retrieved response from the server'
-                   + ' is not valid!');
-            recordingResult.wordArray = [];
-            callback(recordingResult);
-        } else{
+        if(t.verify(response)) {
             recordingResult.wordArray = t.formatResponse(response);
-            callback(recordingResult);
+        } else{
+            console.log('the retrieved response from the server is not valid!');
+            recordingResult.wordArray = [];
         }
+        callback(recordingResult);
     });
 };
 

modules/xmpp/JingleSession.js

         this.rtc = rtc;
         this.state = JingleSessionState.PENDING;
         this.initiator = isInitiator ? this.localJid : this.peerjid;
-        this.responder = !isInitiator ? this.localJid : this.peerjid;
+        this.responder = isInitiator ? this.peerjid : this.localJid;
         this.doInitialize();
     }
 

modules/xmpp/JingleSessionPC.js

             this.modificationQueue.push(
                 workFunction,
                 error => {
-                    if (!error) {
-                        resolve();
-                    } else {
-                        reject(error);
-                    }
-                }
-            );
+                    error ? reject(error) : resolve();
+                });
         });
     }
 
         this.modificationQueue.push(
             workFunction,
             error => {
-                if (!error) {
-                    callback();
-                } else {
-                    errorCallback(error);
-                }
-            }
-        );
+                error ? errorCallback(error) : callback();
+            });
     }
 
     /**
         this.modificationQueue.push(
             workFunction,
             error => {
-                if (!error) {
-                    callback();
-                } else {
-                    errorCallback(error);
-                }
-            }
-        );
+                error ? errorCallback(error) : callback();
+            });
     }
 
     /**

modules/xmpp/SDP.js

     } else {
         tmp.proto = 'RTP/AVPF';
     }
-    if (!sctp.length) {
-        tmp.fmt = desc.find('payload-type').map(
-            function() {
-                return this.getAttribute('id');
-            }).get();
-        media += `${SDPUtil.build_mline(tmp)}\r\n`;
-    } else {
+    if (sctp.length) {
         media += `m=application 1 DTLS/SCTP ${sctp.attr('number')}\r\n`;
-        media += `a=sctpmap:${sctp.attr('number')
-             } ${sctp.attr('protocol')}`;
+        media += `a=sctpmap:${sctp.attr('number')} ${sctp.attr('protocol')}`;
 
         const streamCount = sctp.attr('streams');
         if (streamCount) {
         } else {
             media += '\r\n';
         }
+    } else {
+        tmp.fmt = desc.find('payload-type').map(
+            function() {
+                return this.getAttribute('id');
+            }).get();
+        media += `${SDPUtil.build_mline(tmp)}\r\n`;
     }
 
     media += 'c=IN IP4 0.0.0.0\r\n';

modules/xmpp/SDPUtil.js

         const parts = line.substr(9).split(' ');
         const data = {};
         data.value = parts.shift();
-        if (data.value.indexOf('/') != -1) {
+        if (data.value.indexOf('/') === -1) {
+            data.direction = 'both';
+        } else {
             data.direction = data.value.substr(data.value.indexOf('/') + 1);
             data.value = data.value.substr(0, data.value.indexOf('/'));
-        } else {
-            data.direction = 'both';
         }
         data.uri = parts.shift();
         data.params = parts;

modules/xmpp/SdpConsistency.js

                 logger.info('Sdp-consistency couldn\'t parse new primary ssrc');
                 return sdpStr;
             }
-            if (!this.cachedPrimarySsrc) {
-                this.cachedPrimarySsrc = newPrimarySsrc;
-                logger.info(
-                    `Sdp-consistency caching primary ssrc ${
-                        this.cachedPrimarySsrc}`);
-            } else {
+            if (this.cachedPrimarySsrc) {
                 logger.info(
                     `Sdp-consistency replacing new ssrc ${newPrimarySsrc
                         } with cached ${this.cachedPrimarySsrc}`);
-                videoMLine.replaceSSRC(
-                    newPrimarySsrc, this.cachedPrimarySsrc);
+                videoMLine.replaceSSRC(newPrimarySsrc, this.cachedPrimarySsrc);
                 for (const group of videoMLine.ssrcGroups) {
                     if (group.semantics === 'FID') {
                         const primarySsrc = parsePrimarySSRC(group);
                         }
                     }
                 }
+            } else {
+                this.cachedPrimarySsrc = newPrimarySsrc;
+                logger.info(
+                    `Sdp-consistency caching primary ssrc ${
+                        this.cachedPrimarySsrc}`);
             }
         }
         return sdpTransformer.toRawSDP();

modules/xmpp/xmpp.js

                 this.eventEmitter.emit(
                     JitsiConnectionEvents.CONNECTION_FAILED,
                     JitsiConnectionErrors.OTHER_ERROR, errMsg);
-            } else if (!wasIntentionalDisconnect) {
+            } else if (wasIntentionalDisconnect) {
+                this.eventEmitter.emit(
+                    JitsiConnectionEvents.CONNECTION_DISCONNECTED, errMsg);
+            } else {
                 // XXX if Strophe drops the connection while not being asked to,
                 // it means that most likely some serious error has occurred.
                 // One currently known case is when a BOSH request fails for
                         JitsiConnectionErrors.CONNECTION_DROPPED_ERROR,
                         errMsg ? errMsg : 'connection-dropped-error');
                 }
-            } else {
-                this.eventEmitter.emit(
-                    JitsiConnectionEvents.CONNECTION_DISCONNECTED, errMsg);
             }
         } else if (status === Strophe.Status.AUTHFAIL) {
             // wrong password or username, prompt user