Reload97 / sate24-to-xmpp

Browse Code »

Commit 8e029d5c260423ccc747495e6048f9f1a5944d0f

Authored by Adhidarma Hadiwinoto 9 years ago

1 parent 97aef7616d

Exists in master

cleaning isAFriend

Showing 2 changed files with 0 additions and 24 deletions Inline Diff

adaptor-xmpp.js
matrix-util.js

adaptor-xmpp.js

Diff comments View file @ 8e029d5

 var xmpp = require('simple-xmpp');
 var moment = require('moment');
 var MatrixUtil = require('./matrix-util');
 var username;
 var password;
 var callbacks;
 var matrix;
 var matrixUtil;
 function onOnline(data) {
     logger.info('XMPP login successful', {data: data});
     xmpp.getRoster();
     if (callbacks.onOnline) {
         callbacks.onOnline();
     }
 }
 function onPM(sender, msg) {
     if (sender.toLowerCase() == username.replace(/\/.*/, '').toLowerCase()) {
         return;
     }
     logger.verbose('Got a message', {from: sender, msg: msg});
     if (callbacks.onPM) {
         callbacks.onPM(sender, msg);
     }
     matrixUtil.updateLastIncoming(sender, msg);
 }
 function onError(err) {
     logger.warn('XMPP error, terminating in 3 secs', {err: err});
     setTimeout(process.exit, 3000, 1);
 }
 function onSubscribe(sender) {
     xmpp.acceptSubscription(sender);
 }
 function onUnsubscribe(sender) {
     xmpp.acceptUnsubscription(sender);
 }
 function onBuddy(jid, state, statusText, resource) {
     matrixUtil.updateBuddyState(jid, state, statusText, resource);
 }
 function isPartnerOffline(partner) {
-    if (!matrixUtil.isAFriend(partner)) {
-        logger.verbose(partner + ' is not a friend yet, adding it as a friend')
-        addFriend(partner);
-    }
     return matrixUtil.isPartnerOffline(partner);
 }
 function init(_username, _password, _logger, _callbacks) {
     username = _username;
     password = _password;
     logger = _logger;
     callbacks = _callbacks;
     xmpp.on('online', onOnline);
     xmpp.on('chat', onPM);
     xmpp.on('error', onError);
     xmpp.on('subscribe', onSubscribe);
     xmpp.on('unsubscribe', onUnsubscribe);
     xmpp.on('buddy', onBuddy);
     xmpp.unsubscribe();
     xmpp.connect({
         jid: username,
         password: password
     });
 }
 function setOptions(options) {
     if (!options.matrix) {
         return;
     }
     matrix = options.matrix;
     matrixUtil = new MatrixUtil({matrix: matrix, logger: logger});
 }
 function sendMessage(destination, msg) {
     if (!destination) {
         logger.warn('adaptorXmpp.sendMessage: Undefined destination, send message aborted', {destination: destination, msg: msg});
     }
     if (!msg) {
         logger.warn('adaptorXmpp.sendMessage: Undefined message, send message aborted', {destination: destination, msg: msg});
     }
     if (destination.toLowerCase() != username.replace(/\/.*/, '').toLowerCase()) {
         logger.verbose('Sending message', {from: username, destination: destination, msg: msg});
     }
     xmpp.send(destination, msg);
     matrixUtil.updateLastOutgoing(destination, msg);
 }
 function addFriend(friend) {
     logger.verbose('Adding XMP friend: ' + friend);
     xmpp.subscribe(friend);
 }
-function isAFriend(jid) {
-    return matrixUtil.isAFriend(jid);
-}
 exports.init = init;
 exports.sendMessage = sendMessage;
 exports.setOptions = setOptions;
 exports.addFriend = addFriend;
 exports.isPartnerOffline = isPartnerOffline;
-exports.isAFriend = isAFriend;

matrix-util.js

Diff comments View file @ 8e029d5

 'use strict';
 var moment = require('moment');
 var momentFormat = 'YYYY-MM-DD HH:mm:ss';
 module.exports = MatrixUtil;
 function _cleanPartnerId(partnerId) {
     let cleaned = partnerId;
     try {
         cleaned = cleaned.toLocaleString();
         cleaned = cleaned.trim().toLowerCase();
     } catch(e) {
         return partnerId;
     }
     return cleaned;
 }
 function MatrixUtil(options) {
     if (!options) {
         console.trace('Undefined options');
         process.exit(1);
     }
     this.matrix = options.matrix;
     if (!this.matrix) {
         console.trace("Matrix not set");
         process.exit(1);
     }
     this.logger = options.logger;
     if (!this.logger) {
         console.trace("Logger not set");
         process.exit(1);
     }
 }
 MatrixUtil.prototype.updateBuddyState = function(jid, state, statusText, resource) {
     if (!jid) {return; }
     if (jid == 'undefined') {return; }
     jid = _cleanPartnerId(jid);
     if (!resource) {
         resource = 'undefined';
     }
     let logger = this.logger;
     let matrix = this.matrix;
     logger.verbose('Buddy state change', {jid: jid, state: state, statusText: statusText, resource: resource});
     if (!matrix) {
         return;
     }
     if (!matrix.buddies) {
         matrix.buddies = {};
     }
     if (!matrix.buddies[jid]) {
         matrix.buddies[jid] = {resources: {}};
     }
     try {
         matrix.buddies[jid]['resources'][resource] = {
             state: state,
             statusText: statusText,
             last_update: moment().format(momentFormat)
         }
     }
     catch(e) {
         logger.warn('MatrixUtil: Exception on update resources on matrix', {jid: jid, state: state, statusText: statusText, resource: resource});
     }
     if (resource != 'undefined' && matrix.buddies[jid].resources['undefined']) {
         try {
             delete matrix.buddies[jid].resources['undefined'];
         }
         catch(e) {};
         }
 }
-MatrixUtil.prototype.isAFriend = function(jid) {
-    if (!jid) { return; }
-    jid = _cleanPartnerId(jid);
-    let matrix = this.matrix;
-    if (!matrix) { return false; };
-    if (!matrix.buddies) { return false; }
-    if (!matrix.buddies[jid]) { return false; }
-    return true;
-}
 MatrixUtil.prototype.isPartnerOffline = function(partner) {
     if (!partner) { return; }
     partner = _cleanPartnerId(partner);
     let matrix = this.matrix;
     let logger = this.logger;
     if (!matrix) { return false; }
     if (!matrix.buddies[partner]) { return false; }
     if (!matrix.buddies[partner].resources) { return false; };
     let resources = matrix.buddies[partner].resources;
     for (let key in resources) {
         if (resources.hasOwnProperty(key)) {
             let resource = resources[key];
             if (resources[key].state == 'online') {
                 return false;
             }
         }
     }
     logger.verbose('Offline partner detected: ' + partner);
     return true;
 }
 MatrixUtil.prototype._updateLastResponseTime = function(partner) {
     let matrix = this.matrix;
     let logger = this.logger;
     if (!matrix.buddies[partner]['last_outgoing']) {
         logger.verbose('No outgoing yet, skip updateLastResponseTime');
         return;
     }
     if (!matrix.buddies[partner]['last_outgoing']['last_update_ts']) {
         logger.verbose('No outgoing timestamp yet, skip updateLastResponseTime');
         return;
     }
     if (
         matrix.buddies[partner]['last_incoming']
         && (Number(matrix.buddies[partner]['last_incoming']['last_update_ts']) > Number(matrix.buddies[partner]['last_outgoing']['last_update_ts']))
     ) {
         return;
     }
     let delta = Date.now() - Number(matrix.buddies[partner]['last_outgoing']['last_update_ts']);
     delta = (delta / 1000).toFixed(2);
     logger.verbose('MatrixUtil: Response time in ' + delta + ' seconds', {partner: partner});
     matrix.buddies[partner]['last_response_time_in_secs'] = delta;
 }
 MatrixUtil.prototype._updateLastMessage = function(partner, msg, direction) {
     if (!partner) { return; }
     partner = _cleanPartnerId(partner);
     let matrix = this.matrix;
     let logger = this.logger;
     if (!matrix) {
         return;
     }
     if (!matrix.buddies) {
         matrix.buddies = {};
     }
     if (!matrix.buddies[partner]) {
         matrix.buddies[partner] = {};
     }
     if (direction == 'incoming') {
         try {
             this._updateLastResponseTime(partner);
         }
         catch(e) {
             logger.warn('Exception when updateLastResponseTime', {err: e});
         }
     }
     matrix.buddies[partner]['waiting_for_response'] = (direction == 'outgoing');
     matrix.buddies[partner]['last_' + direction] = {
         msg: msg,
         last_update: moment().format(momentFormat),
         last_update_ts: Date.now()
     }
     if (direction == 'outgoing') {
         return;
     }
 }
 MatrixUtil.prototype.updateLastIncoming = function(partner, msg) {
     this._updateLastMessage(partner, msg, 'incoming');
 }
 MatrixUtil.prototype.updateLastOutgoing = function(partner, msg) {
     this._updateLastMessage(partner, msg, 'outgoing');
 }