pryv 2.1.8

package/src/Browser/LoginButton.js

@@ -0,0 +1,199 @@
+const Cookies = require('./CookieUtils');
+const AuthStates = require('../Auth/AuthStates');
+const AuthController = require('../Auth/AuthController');
+const Service = require('../Service');
+const Messages = require('../Auth/LoginMessages');
+const utils = require('../utils');
+
+/**
+ * @memberof Pryv.Browser
+ */
+class LoginButton {
+
+  constructor(authSettings, service) {
+    this.authSettings = authSettings;
+    this.service = service;
+    this.serviceInfo = service.infoSync();
+  }
+
+  /**
+   * setup button and load assets
+   */
+  async init () {
+    // initialize button visuals
+    setupButton(this);
+    this.languageCode = this.authSettings.authRequest.languageCode || 'en';    
+    this.messages = Messages(this.languageCode);
+    if (this.loginButtonText) {
+      await loadAssets(this);
+    }
+    // set cookie key for authorization data
+    this._cookieKey = 'pryv-libjs-' + this.authSettings.authRequest.requestingAppId;
+    
+    // initialize controller
+    this.auth = new AuthController(this.authSettings, this.service, this);
+    await this.auth.init();
+
+    return this.service;
+  }
+
+  onClick () {
+    this.auth.handleClick();
+  }
+
+  async onStateChange (state) {
+    switch (state.status) {
+      case AuthStates.LOADING:
+        this.text = getLoadingMessage(this);
+        break;
+      case AuthStates.INITIALIZED:
+        this.text = getInitializedMessage(this, this.serviceInfo.name);
+        break;
+      case AuthStates.NEED_SIGNIN:
+        const loginUrl = state.authUrl || state.url; // url is deprecated
+        if (this.authSettings.authRequest.returnURL) { // open on same page (no Popup) 
+          location.href = loginUrl; 
+          return;
+        } else {
+          startLoginScreen(this, loginUrl);
+        }
+        break;
+      case AuthStates.AUTHORIZED:
+        this.text = state.username;
+        this.saveAuthorizationData({
+          apiEndpoint: state.apiEndpoint,
+          username: state.username
+        });
+        break;
+      case AuthStates.SIGNOUT:
+        const message = this.messages.SIGNOUT_CONFIRM ? this.messages.SIGNOUT_CONFIRM : 'Logout ?';
+        if (confirm(message)) {
+          this.deleteAuthorizationData();
+          this.auth.init();
+        }
+        break;
+      case AuthStates.ERROR:
+        this.text = getErrorMessage(this, state.message);
+        break;
+      default:
+        console.log('WARNING Unhandled state for Login: ' + state.status);
+    }
+    if (this.loginButtonText) {
+      this.loginButtonText.innerHTML = this.text;
+    }
+  }
+
+  getAuthorizationData () {
+    return Cookies.get(this._cookieKey);
+  }
+
+  saveAuthorizationData (authData) {
+    Cookies.set(this._cookieKey,authData);
+  }
+
+  async deleteAuthorizationData () {
+    Cookies.del(this._cookieKey);
+  }
+
+  /**
+   * not mandatory to implement as non-browsers don't have this behaviour
+   * @param {*} authController 
+   */
+  async finishAuthProcessAfterRedirection (authController) {
+    // this step should be applied only for the browser
+    if (!utils.isBrowser()) return;
+
+    // 3. Check if there is a prYvkey as result of "out of page login"
+    const url = window.location.href;
+    let pollUrl = retrievePollUrl(url);
+    if (pollUrl !== null) {
+      try {
+        const res = await utils.superagent.get(pollUrl);
+        authController.state = res.body;
+      } catch (e) {
+        authController.state = {
+          status: AuthStates.ERROR,
+          message: 'Cannot fetch result',
+          error: e
+        };
+      }
+    }
+
+    function retrievePollUrl (url) {
+      const params = utils.getQueryParamsFromURL(url);
+      let pollUrl = null;
+      if (params.prYvkey) { // deprecated method - To be removed
+        pollUrl = authController.serviceInfo.access + params.prYvkey;
+      }
+      if (params.prYvpoll) {
+        pollUrl = params.prYvpoll;
+      }
+      return pollUrl;
+    }
+  }
+}
+
+async function startLoginScreen (loginButton, authUrl) {
+  let screenX = typeof window.screenX !== 'undefined' ? window.screenX : window.screenLeft,
+    screenY = typeof window.screenY !== 'undefined' ? window.screenY : window.screenTop,
+    outerWidth = typeof window.outerWidth !== 'undefined' ?
+      window.outerWidth : document.body.clientWidth,
+    outerHeight = typeof window.outerHeight !== 'undefined' ?
+      window.outerHeight : (document.body.clientHeight - 22),
+    width = 400,
+    height = 620,
+    left = parseInt(screenX + ((outerWidth - width) / 2), 10),
+    top = parseInt(screenY + ((outerHeight - height) / 2.5), 10),
+    features = (
+      'width=' + width +
+      ',height=' + height +
+      ',left=' + left +
+      ',top=' + top +
+      ',scrollbars=yes'
+    );
+    loginButton.popup = window.open(authUrl, 'prYv Sign-in', features);
+  
+  if (!loginButton.popup) {
+    // loginButton.auth.stopAuthRequest('FAILED_TO_OPEN_WINDOW');
+    console.log('Pop-up blocked. A second click should allow it.');
+  } else if (window.focus) {
+    loginButton.popup.focus();
+  }
+}
+
+function setupButton(loginBtn) {
+  loginBtn.loginButtonSpan = document.getElementById(loginBtn.authSettings.spanButtonID);
+
+  if (!loginBtn.loginButtonSpan) {
+    console.log('WARNING: Pryv.Browser initialized with no spanButtonID');
+  } else {
+    // up to the time the button is loaded use the Span to display eventual 
+    // error messages
+    loginBtn.loginButtonText = loginBtn.loginButtonSpan;
+
+    // bind actions dynamically to the button click
+    loginBtn.loginButtonSpan.addEventListener('click', loginBtn.onClick.bind(loginBtn));
+  }
+}
+
+/**
+ * Loads the style from the service info
+ */
+async function loadAssets(loginBtn) {
+  const assets = await loginBtn.service.assets();
+  loginBtn.loginButtonSpan.innerHTML = await assets.loginButtonGetHTML();
+  loginBtn.loginButtonText = document.getElementById('pryv-access-btn-text');
+}
+module.exports = LoginButton;
+
+function getErrorMessage (loginButton, message) {
+  return loginButton.messages.ERROR + ': ' + message;
+}
+
+function getLoadingMessage (loginButton) {
+  return loginButton.messages.LOADING;
+}
+
+function getInitializedMessage (loginButton, serviceName) {
+  return loginButton.messages.LOGIN + ': ' + serviceName;
+}

package/src/Browser/index.js

@@ -0,0 +1,55 @@
+const LoginButton = require('./LoginButton');
+const CookieUtils = require('./CookieUtils');
+const Service = require('../Service');
+const utils = require('../utils');
+
+/**
+ * @memberof Pryv
+ * @namespace Pryv.Browser
+ */
+
+/**
+ * Start an authentication process
+ * @memberof Pryv.Browser
+ * @param {Object} settings
+ * @param {Object} settings.authRequest See https://api.pryv.com/reference/#data-structure-access
+ * @param {string} [settings.authRequest.languageCode] Language code, as per LoginButton Messages: 'en', 'fr
+ * @param {string} settings.authRequest.requestingAppId Application id, ex: 'my-app'
+ * @param {Object} settings.authRequest.requestedPermissions
+ * @param {string | boolean} settings.authRequest.returnURL : false, // set this if you don't want a popup
+ * @param {string} [settings.authRequest.referer] To track registration source 
+ * @param {string} settings.spanButtonID set and <span> id in DOM to insert default login button or null for custom
+ * @param {Browser.AuthStateChangeHandler} settings.onStateChange
+ * @param {string} [settings.returnURL=auto#]  Set to "self#" to disable popup and force using the same page. Set a custom url when process is finished (specific use cases). Should always end by # ? or &
+ * @param {string} serviceInfoUrl
+ * @param {Object} [serviceCustomizations] override properties of serviceInfoUrl 
+ * @returns {Pryv.Service}
+ */
+async function setupAuth (settings, serviceInfoUrl, serviceCustomizations, HumanInteraction = LoginButton) {
+
+  let service = new Service(serviceInfoUrl, serviceCustomizations);
+  await service.info()
+
+  const humanInteraction = new HumanInteraction(settings, service);
+  await HumanInteraction.init();
+
+  return service;
+}
+
+/**
+ * Util to grab parameters from url query string
+ * @param {*} url 
+ */
+function getServiceInfoFromURL (url) {
+  const queryParams = utils.getQueryParamsFromURL(url || window.location.href);
+  return queryParams['pryvServiceInfoUrl'];
+}
+
+module.exports = {
+  LoginButton: LoginButton,
+  CookieUtils: CookieUtils,
+  // retro-compatibility for lib-js < 2.0.9
+  AuthStates: require('../Auth/AuthStates'),
+  setupAuth: require('../Auth').setupAuth,
+  serviceInfoFromUrl: getServiceInfoFromURL
+};

package/src/Connection.js

@@ -0,0 +1,331 @@
+
+const utils = require('./utils.js');
+
+const jsonParser = require('./lib/json-parser');
+
+const browserGetEventStreamed = require('./lib/browser-getEventStreamed');
+
+
+/**
+ * @class Connection
+ * A connection is an authenticated link to a Pryv.io account.
+ * 
+ * @type {TokenAndEndpoint}
+ *
+ * @example
+ * create a connection for the user 'tom' on 'pryv.me' backend with the token 'TTZycvBTiq'
+ * const conn = new Pryv.Connection('https://TTZycvBTiq@tom.pryv.me');
+ *
+ * @property {string} [token]
+ * @property {string} endpoint
+ * @memberof Pryv
+ * 
+ * @constructor
+ * @this {Connection} 
+ * @param {PryvApiEndpoint} pryvApiEndpoint
+ * @param {Pryv.Service} [service] - eventually initialize Connection with a Service
+ */
+class Connection {
+
+  constructor(pryvApiEndpoint, service) {
+    const { token, endpoint } = utils.extractTokenAndApiEndpoint(pryvApiEndpoint);
+    this.token = token;
+    this.endpoint = endpoint;
+    this.options = {};
+    this.options.chunkSize = 1000;
+    this._deltaTime = { value: 0, weight: 0 };
+    if (! service instanceof Service) { throw new Error('Invalid service param'); }
+    this._service = service;
+  }
+
+  /**
+   * get Pryv.Service object relative to this connection
+   * @readonly
+   * @property {Pryv.Service} service
+   */
+  get service() {
+    if (this._service) return this._service;
+    this._service = new Service(this.endpoint + 'service/info');
+    return this._service;
+  }
+
+  /**
+   * get username. 
+   * It's async as in it constructed from access info
+   * @param {*} arrayOfAPICalls 
+   * @param {*} progress 
+   */
+  async username() {
+    const accessInfo = await this.accessInfo();
+    return accessInfo.user.username;
+  }
+
+  /**
+   * get access info
+   * It's async as it is constructed with get function.
+   */
+  async accessInfo(){
+    return this.get("access-info", null);
+  }
+
+  /**
+   * Issue a Batch call https://api.pryv.com/reference/#call-batch .
+   * arrayOfAPICalls will be splited in multiple calls if the size is > `conn.options.chunkSize` .
+   * Default chunksize is 1000.
+   * @param {Array.<MethodCall>} arrayOfAPICalls Array of Method Calls
+   * @param {Function} [progress] Return percentage of progress (0 - 100);
+   * @returns {Promise<Array>} Promise to Array of results matching each method call in order
+   */
+  async api(arrayOfAPICalls, progress) {
+    function httpHandler(batchCall) {
+      return this.post('', batchCall);
+    };
+    return await this._chunkedBatchCall(arrayOfAPICalls, progress, httpHandler.bind(this));
+  }
+
+  /**
+   * @private
+   */
+  async _chunkedBatchCall(arrayOfAPICalls, progress, callHandler) {
+    if (! Array.isArray(arrayOfAPICalls)) {
+      throw new Error('Pryv.api() takes an array as input');
+    }
+
+    const res = [];
+    let percent = 0;
+    for (let cursor = 0; arrayOfAPICalls.length >= cursor; cursor += this.options.chunkSize) {
+      const thisBatch = [];
+      const cursorMax = Math.min(cursor + this.options.chunkSize, arrayOfAPICalls.length);
+      // copy only method and params into a back call to be exuted
+      for (let i = cursor; i < cursorMax ; i++) {      
+        thisBatch.push({ method: arrayOfAPICalls[i].method, params: arrayOfAPICalls[i].params});
+      }
+      const resRequest = await callHandler(thisBatch);
+      
+      // result checks
+      if (! resRequest || ! Array.isArray(resRequest.results)) {
+        throw new Error('API call result is not an Array: ' + JSON.stringify(resRequest));
+      }
+      if (resRequest.results.length != thisBatch.length) {
+        throw new Error('API call result Array does not match request: ' + JSON.stringify(resRequest));
+      }
+
+
+      // eventually call handleResult 
+      for (let i = 0; i < resRequest.results.length; i++) {
+        if (arrayOfAPICalls[i + cursor].handleResult) {
+          await arrayOfAPICalls[i + cursor].handleResult.call(null, resRequest.results[i]);
+        }
+      }
+      Array.prototype.push.apply(res, resRequest.results)
+      percent =  Math.round(100 * res.length / arrayOfAPICalls.length);
+      if (progress) { progress(percent, res); }
+    }
+    return res;
+  }
+
+  /**
+   * Post to API return results  
+   * @param {(Array | Object)} data 
+   * @param {Object} queryParams
+   * @param {string} path 
+   * @returns {Promise<Array|Object>}  Promise to result.body
+   */
+  async post(path, data, queryParams) {
+    const now = Date.now() / 1000;
+    const res = await this.postRaw(path, data, queryParams);
+    this._handleMeta(res.body, now);
+    return res.body;
+  }
+
+  /**
+   * Raw Post to API return superagent object  
+   * @param {Array | Object} data 
+   * @param {Object} queryParams
+   * @param {string} path 
+   * @returns {request.superagent}  Promise from superagent's post request
+   */
+  async postRaw(path, data, queryParams) {
+    return this._post(path)
+      .query(queryParams)
+      .send(data);
+  }
+
+   _post(path) {
+    return utils.superagent.post(this.endpoint + path)
+      .set('Authorization', this.token)
+      .set('accept', 'json');
+  }
+
+  /**
+   * Post to API return results  
+   * @param {Object} queryParams
+   * @param {string} path 
+   * @returns {Promise<Array|Object>}  Promise to result.body
+   */
+  async get(path, queryParams) {
+    const now = Date.now() / 1000;
+    const res = await this.getRaw(path, queryParams);
+    this._handleMeta(res.body, now);
+    return res.body
+  }
+
+  /**
+   * Raw Get to API return superagent object
+   * @param {Object} queryParams 
+   * @param {string} path 
+   * @returns {request.superagent}  Promise from superagent's get request
+   */
+  getRaw(path, queryParams) {
+    path = path || '';
+    return utils.superagent.get(this.endpoint + path)
+      .set('Authorization', this.token)
+      .set('accept', 'json')
+      .query(queryParams);
+  }
+
+  /**
+   * ADD Data Points to HFEvent (flatJSON format)
+   * https://api.pryv.com/reference/#add-hf-series-data-points
+   */
+  async addPointsToHFEvent(eventId, fields, points) {
+    const res = await this.post('events/' + eventId + '/series',
+      {
+        format: 'flatJSON',
+        fields: fields,
+        points: points
+      });
+    if (!res.status === 'ok') {
+      throw new Error('Failed loading serie: ' + JSON.stringify(res.status));
+    }
+    return res;
+  }
+
+  /**
+   * Streamed get Event. 
+   * Fallbacks to not streamed, for browsers that does not support `fetch()` API 
+   * @see https://api.pryv.com/reference/#get-events
+   * @param {Object} queryParams See `events.get` parameters
+   * @param {Function} forEachEvent Function taking one event as parameter. Will be called for each event 
+   * @returns {Promise<Object>} Promise to result.body transformed with `eventsCount: {count}` replacing `events: [...]`
+   */
+  async getEventsStreamed(queryParams, forEachEvent) {
+    const myParser = jsonParser(forEachEvent, queryParams.includeDeletions);
+    let res = null;
+    if (typeof window === 'undefined') { // node
+      res = await this.getRaw('events', queryParams)
+        .buffer(false)
+        .parse(myParser);
+
+    } else if (typeof fetch !== 'undefined' && !(typeof navigator != 'undefined' && navigator.product == 'ReactNative')) { // browser supports fetch and it is not react native
+      res = await browserGetEventStreamed(this, queryParams, myParser);
+
+    } else { // browser no fetch supports
+      console.log('WARNING: Browser does not support fetch() required by Pryv.Connection.getEventsStreamed()');
+      res = await this.getRaw('events', queryParams);
+      res.body.eventsCount = 0;
+      if (res.body.events) {
+        res.body.events.forEach(forEachEvent);
+        res.body.eventsCount += res.body.events.length;
+        delete res.body.events;
+      }
+      if (res.body.eventDeletions) { // deletions are in a seprated Array 
+        res.body.eventDeletions.forEach(forEachEvent);
+        res.body.eventsCount += res.body.eventDeletions.length;
+        delete res.body.eventDeletions;
+      }
+    }
+
+    const now = Date.now() / 1000;
+    this._handleMeta(res.body, now);
+    return res.body
+  }
+
+  /**
+   * Create an event with attached file
+   * NODE.jS ONLY
+   * @param {Event} event
+   * @param {string} filePath
+   */
+  async createEventWithFile(event, filePath) {
+    const res = await this._post('events')
+      .field('event', JSON.stringify(event))
+      .attach('file', filePath);
+
+    const now = Date.now() / 1000;
+    this._handleMeta(res.body, now);
+    return res.body
+  }
+
+  /**
+   * Create an event from a Buffer
+   * NODE.jS ONLY
+   * @param {Event} event
+   * @param {Buffer} bufferData
+   * @param {string} fileName
+   */
+   async createEventWithFileFromBuffer(event, bufferData, filename) {
+    const res = await this._post('events')
+      .field('event', JSON.stringify(event))
+      .attach('file', bufferData, filename);
+
+    const now = Date.now() / 1000;
+    this._handleMeta(res.body, now);
+    return res.body
+  }
+
+  /**
+ * Create an event with attached formData
+ * !! BROWSER ONLY
+ * @param {Event} event
+ * @param {FormData} formData https://developer.mozilla.org/en-US/docs/Web/API/FormData/FormData
+ */
+  async createEventWithFormData(event, formData) {
+    formData.append('event', JSON.stringify(event));
+    const res = await this._post('events').send(formData);
+    return res.body
+  }
+
+  /**
+   * Difference in second between the API and locatime
+   * deltaTime is refined at each (non Raw) API call
+   * @readonly
+   * @property {number} deltaTime
+   */
+  get deltaTime() {
+    return this._deltaTime.value;
+  }
+
+  /**
+   * Pryv API Endpoint of this connection
+   * @readonly
+   * @property {PryvApiEndpoint} deltaTime
+   */
+  get apiEndpoint() {
+    return utils.buildPryvApiEndpoint(this);
+  }
+
+  // private method that handle meta data parsing
+    _handleMeta(res, requestLocalTimestamp) {
+    if (!res.meta) throw new Error('Cannot find .meta in response.');
+    if (!res.meta.serverTime) throw new Error('Cannot find .meta.serverTime in response.');
+
+    // update deltaTime and weight it 
+    this._deltaTime.value = (this._deltaTime.value * this._deltaTime.weight + res.meta.serverTime - requestLocalTimestamp) / ++this._deltaTime.weight;
+  }
+
+}
+
+
+module.exports = Connection;
+
+// service is require "after" to allow circular require
+const Service = require('./Service');
+
+/**
+ * API Method call, for batch call https://api.pryv.com/reference/#call-batch
+ * @typedef {Object} MethodCall
+ * @property {string} method - The method id
+ * @property {(Object|Array)}  params - The call parameters as required by the method.
+ * @property {(Function|Promise)} [handleResult] - Will be called with the result corresponding to this specific call.
+ */

package/src/Pryv.js

@@ -0,0 +1,19 @@
+
+/**
+ * Pryv library
+ * @version 1.0
+ * @exports Pryv
+ * @property {Pryv.Service} Service - To interact with Pryv.io at a "Platform level"
+ * @property {Pryv.Connection} Connection - To interact with an individual's (user) data set
+ * @property {Pryv.Browser} Browser - Browser Tools - Access request helpers and visuals (button)
+ * @property {Pryv.utils} utils - Exposes **superagent** for HTTP calls and tools to manipulate Pryv's Api Endpoints
+ */
+module.exports = {
+  Service: require('./Service'),
+  Connection: require('./Connection'),
+  Auth: require('./Auth'),
+  Browser: require('./Browser'),
+  utils: require('./utils'),
+  version: require('../package.json').version
+}
+