Source: jsxc.lib.xmpp.httpUpload.js

  1. /**
  2.  * Implements Http File Upload (XEP-0363)
  3.  *
  4.  * @namespace jsxc.xmpp.httpUpload
  5.  * @see {@link http://xmpp.org/extensions/xep-0363.html}
  6.  */
  7. jsxc.xmpp.httpUpload = {
  8.    conn: null,
  10.    ready: false,
  12.    CONST: {
  13.       NS: {
  14.          HTTPUPLOAD: 'urn:xmpp:http:upload'
  15.       }
  16.    }
  17. };
  19. /**
  20.  * Set up http file upload.
  21.  *
  22.  * @memberOf jsxc.xmpp.httpUpload
  23.  * @param  {Object} o options
  24.  */
  25. jsxc.xmpp.httpUpload.init = function(o) {
  26.    var self = jsxc.xmpp.httpUpload;
  27.    self.conn = jsxc.xmpp.conn;
  29.    var fileTransferOptions = jsxc.options.get('fileTransfer') || {};
  30.    var options = o || jsxc.options.get('httpUpload');
  32.    if (!fileTransferOptions.httpUpload.enable) {
  33.       jsxc.debug('http upload disabled');
  35.       jsxc.options.set('httpUpload', false);
  37.       return;
  38.    }
  40.    if (options && options.server) {
  41.       self.ready = true;
  43.       return;
  44.    }
  46.    var caps = jsxc.xmpp.conn.caps;
  47.    var domain = jsxc.xmpp.conn.domain;
  49.    if (!caps || !domain || typeof caps._knownCapabilities[caps._jidVerIndex[domain]] === 'undefined') {
  50.       jsxc.debug('Waiting for server capabilities');
  52.       $(document).on('caps.strophe', function onCaps(ev, from) {
  54.          if (from !== domain) {
  55.             return;
  56.          }
  58.          self.init();
  60.          $(document).off('caps.strophe', onCaps);
  61.       });
  63.       return;
  64.    }
  66.    self.discoverUploadService();
  67. };
  69. /**
  70.  * Discover upload service for http upload.
  71.  *
  72.  * @memberOf jsxc.xmpp.httpUpload
  73.  */
  74. jsxc.xmpp.httpUpload.discoverUploadService = function() {
  75.    var self = jsxc.xmpp.httpUpload;
  76.    var domain = self.conn.domain;
  78.    jsxc.debug('discover http upload service');
  80.    if (jsxc.xmpp.conn.caps.hasFeatureByJid(domain, self.CONST.NS.HTTPUPLOAD)) {
  81.       self.queryItemForUploadService(domain);
  82.    }
  84.    self.conn.disco.items(domain, null, function(items) {
  85.       $(items).find('item').each(function() {
  86.          var jid = $(this).attr('jid');
  88.          if (self.ready) {
  89.             // abort, because we already found a service
  90.             return false;
  91.          }
  93.          self.queryItemForUploadService(jid);
  94.       });
  95.    });
  96. };
  98. /**
  99.  * Query item for upload service.
  100.  *
  101.  * @param {String} jid
  102.  * @param {Function} cb Callback on success
  103.  * @memberOf jsxc.xmpp.httpUpload
  104.  */
  105. jsxc.xmpp.httpUpload.queryItemForUploadService = function(jid, cb) {
  106.    var self = jsxc.xmpp.httpUpload;
  108.    jsxc.debug('query ' + jid + ' for upload service');
  110.    self.conn.disco.info(jid, null, function(info) {
  111.       var httpUploadFeature = $(info).find('feature[var="' + self.CONST.NS.HTTPUPLOAD + '"]');
  112.       var httpUploadMaxSize = $(info).find('field[var="max-file-size"]');
  114.       if (httpUploadFeature.length > 0) {
  115.          jsxc.debug('http upload service found on ' + jid);
  117.          jsxc.options.set('httpUpload', {
  118.             server: jid,
  119.             name: $(info).find('identity').attr('name'),
  120.             maxSize: parseInt(httpUploadMaxSize.text()) || -1
  121.          });
  123.          self.ready = true;
  125.          if (typeof cb === 'function') {
  126.             cb.call(info);
  127.          }
  128.       }
  129.    });
  130. };
  132. /**
  133.  * Upload file and send link to peer.
  134.  *
  135.  * @memberOf jsxc.xmpp.httpUpload
  136.  * @param  {File} file
  137.  * @param  {Message} message Preview message
  138.  */
  139. jsxc.xmpp.httpUpload.sendFile = function(file, message) {
  140.    jsxc.debug('Send file via http upload');
  142.    var self = jsxc.xmpp.httpUpload;
  144.    // even if the link is encrypted the file isn't
  145.    message.encrypted = false;
  147.    self.requestSlot(file, function(data) {
  148.       if (!data) {
  149.          // general error
  150.          jsxc.warn('Unknown error occured. Please check the debug log.');
  151.       } else if (data.error) {
  152.          // specific error
  153.          jsxc.warn('The xmpp server responded with an error of the type "' + data.error.type + '"');
  155.          message.getDOM().remove();
  157.          jsxc.gui.window.postMessage({
  158.             bid: message.bid,
  159.             direction: jsxc.Message.SYS,
  160.             msg: data.error.text
  161.          });
  163.          message.delete();
  164.       } else if (data.get && data.put) {
  165.          jsxc.debug('slot received, start upload to ' + data.put);
  167.          self.uploadFile(data.put, file, message, function() {
  168.             var attachment = message.attachment;
  169.             var metaString = attachment.type + '|' + attachment.size + '|' + attachment.name;
  170.             var a = $('<a>');
  171.             a.attr('href', data.get);
  173.             attachment.data = data.get;
  175.             if (attachment.thumbnail) {
  176.                var img = $('<img>');
  177.                img.attr('alt', 'Preview:' + metaString);
  178.                img.attr('src', attachment.thumbnail);
  179.                a.prepend(img);
  180.             } else {
  181.                a.text(metaString);
  182.             }
  184.             message.msg = data.get;
  185.             message.htmlMsg = $('<span>').append(a).html();
  186.             message.type = jsxc.Message.HTML;
  187.             jsxc.gui.window.postMessage(message);
  188.          });
  189.       }
  190.    });
  191. };
  193. /**
  194.  * Upload the given file to the given url.
  195.  *
  196.  * @memberOf jsxc.xmpp.httpUpload
  197.  * @param  {String} url upload url
  198.  * @param  {File} file
  199.  * @param  {Message} message preview message
  200.  * @param  {Function} success_cb callback on successful transition
  201.  */
  202. jsxc.xmpp.httpUpload.uploadFile = function(url, file, message, success_cb) {
  203.    $.ajax({
  204.       url: url,
  205.       type: 'PUT',
  206.       contentType: 'application/octet-stream',
  207.       data: file,
  208.       processData: false,
  209.       xhr: function() {
  210.          var xhr = $.ajaxSettings.xhr();
  212.          // track upload progress
  213.          xhr.upload.onprogress = function(ev) {
  214.             if (ev.lengthComputable) {
  215.                jsxc.gui.window.updateProgress(message, ev.loaded, ev.total);
  216.             }
  217.          };
  218.          return xhr;
  219.       },
  220.       success: function() {
  221.          jsxc.debug('file successful uploaded');
  223.          // In case that upload progress is not available, inform user
  224.          jsxc.gui.window.updateProgress(message, 1, 1);
  226.          if (success_cb) {
  227.             success_cb();
  228.          }
  229.       },
  230.       error: function() {
  231.          jsxc.warn('error while uploading file to ' + url);
  233.          message.error = 'Could not upload file';
  234.          jsxc.gui.window.postMessage(message);
  235.       }
  236.    });
  237. };
  239. /**
  240.  * Request upload slot.
  241.  *
  242.  * @memberOf jsxc.xmpp.httpUpload
  243.  * @param  {File} file
  244.  * @param  {Function} cb Callback after finished request
  245.  */
  246. jsxc.xmpp.httpUpload.requestSlot = function(file, cb) {
  247.    var self = jsxc.xmpp.httpUpload;
  248.    var options = jsxc.options.get('httpUpload');
  250.    if (!options || !options.server) {
  251.       jsxc.warn('could not request upload slot, because I am not aware of a server or http upload is disabled');
  253.       return;
  254.    }
  256.    var iq = $iq({
  257.          to: options.server,
  258.          type: 'get'
  259.       }).c('request', {
  260.          xmlns: self.CONST.NS.HTTPUPLOAD
  261.       }).c('filename').t(file.name)
  262.       .up()
  263.       .c('size').t(file.size);
  265.    self.conn.sendIQ(iq, function(stanza) {
  266.       self.successfulRequestSlotCB(stanza, cb);
  267.    }, function(stanza) {
  268.       self.failedRequestSlotCB(stanza, cb);
  269.    });
  270. };
  272. /**
  273.  * Process successful response to slot request.
  274.  *
  275.  * @memberOf jsxc.xmpp.httpUpload
  276.  * @param {String} stanza
  277.  * @param {Function} cb
  278.  */
  279. jsxc.xmpp.httpUpload.successfulRequestSlotCB = function(stanza, cb) {
  280.    var self = jsxc.xmpp.httpUpload;
  281.    var slot = $(stanza).find('slot[xmlns="' + self.CONST.NS.HTTPUPLOAD + '"]');
  283.    if (slot.length > 0) {
  284.       var put = slot.find('put').text();
  285.       var get = slot.find('get').text();
  287.       cb({
  288.          put: put,
  289.          get: get
  290.       });
  291.    } else {
  292.       self.failedRequestSlotCB(stanza, cb);
  293.    }
  294. };
  296. /**
  297.  * Process failed response to slot request.
  298.  *
  299.  * @memberOf jsxc.xmpp.httpUpload
  300.  * @param  {String} stanza
  301.  * @param  {Function} cb
  302.  */
  303. jsxc.xmpp.httpUpload.failedRequestSlotCB = function(stanza, cb) {
  304.    if ($(stanza).find('error').length <= 0) {
  305.       jsxc.warn('response does not contain a slot element');
  307.       cb();
  309.       return;
  310.    }
  312.    var error = {
  313.       type: $(stanza).find('error').attr('type') || 'unknown',
  314.       text: $(stanza).find('error text').text()
  315.    };
  317.    if ($(stanza).find('error not-acceptable')) {
  318.       error.reason = 'not-acceptable';
  319.    } else if ($(stanza).find('error resource-constraint')) {
  320.       error.reason = 'resource-constraint';
  321.    } else if ($(stanza).find('error not-allowed')) {
  322.       error.reason = 'not-allowed';
  323.    }
  325.    cb({
  326.       error: error
  327.    });
  328. };
  330. $(document).on('stateUIChange.jsxc', function(ev, state) {
  331.    if (state === jsxc.CONST.UISTATE.INITIATING) {
  332.       jsxc.xmpp.httpUpload.init();
  333.    }
  334. });