lbry-desktop/ui/js/lbryio.js

import {getSession, setSession} from './utils.js';
import lbry from './lbry.js';

const querystring = require('querystring');

const lbryio = {
  _accessToken: getSession('accessToken'),
  _authenticationPromise: null,
  _user : null,
  enabled: true
};


const CONNECTION_STRING = process.env.LBRY_APP_API_URL ?
                            process.env.LBRY_APP_API_URL.replace(/\/*$/,'/') : // exactly one slash at the end
                            'https://api.lbry.io/'
const EXCHANGE_RATE_TIMEOUT = 20 * 60 * 1000;

lbryio._exchangePromise = null;
lbryio._exchangeLastFetched = null;
lbryio.getExchangeRates = function() {
  if (!lbryio._exchangeLastFetched || Date.now() - lbryio._exchangeLastFetched > EXCHANGE_RATE_TIMEOUT) {
    lbryio._exchangePromise = new Promise((resolve, reject) => {
      lbryio.call('lbc', 'exchange_rate', {}, 'get', true).then(({lbc_usd, lbc_btc, btc_usd}) => {
        const rates = {lbc_usd, lbc_btc, btc_usd};
        resolve(rates);
      }).catch(reject);
    });
    lbryio._exchangeLastFetched = Date.now();
  }
  return lbryio._exchangePromise;
}

lbryio.call = function(resource, action, params={}, method='get', evenIfDisabled=false) { // evenIfDisabled is just for development, when we may have some calls working and some not
  return new Promise((resolve, reject) => {
    if (!lbryio.enabled && !evenIfDisabled && (resource != 'discover' || action != 'list')) {
      console.log(__("Internal API disabled"));
      reject(new Error(__("LBRY internal API is disabled")))
      return
    }

    const xhr = new XMLHttpRequest;

    xhr.addEventListener('error', function (event) {
      reject(new Error(__("Something went wrong making an internal API call.")));
    });


    xhr.addEventListener('timeout', function() {
      reject(new Error(__('XMLHttpRequest connection timed out')));
    });

    xhr.addEventListener('load', function() {
      const response = JSON.parse(xhr.responseText);

      if (!response.success) {
        if (reject) {
          let error = new Error(response.error);
          error.xhr = xhr;
          reject(error);
        } else {
          document.dispatchEvent(new CustomEvent('unhandledError', {
            detail: {
              connectionString: connectionString,
              method: action,
              params: params,
              message: response.error.message,
              ... response.error.data ? {data: response.error.data} : {},
            }
          }));
        }
      } else {
        resolve(response.data);
      }
    });

    // For social media auth:
    //const accessToken = localStorage.getItem('accessToken');
    //const fullParams = {...params, ... accessToken ? {access_token: accessToken} : {}};

    // Temp app ID based auth:
    const fullParams = {app_id: lbryio.getAccessToken(), ...params};

    if (method == 'get') {
      xhr.open('get', CONNECTION_STRING + resource + '/' + action + '?' + querystring.stringify(fullParams), true);
      xhr.send();
    } else if (method == 'post') {
      xhr.open('post', CONNECTION_STRING + resource + '/' + action, true);
      xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
      xhr.send(querystring.stringify(fullParams));
    } else {
      reject(new Error(__("Invalid method")));
    }
  });
};

lbryio.getAccessToken = () => {
  const token = getSession('accessToken');
  return token ? token.toString().trim() : token;
}

lbryio.setAccessToken = (token) => {
  setSession('accessToken', token ? token.toString().trim() : token)
}

lbryio.authenticate = function() {
  if (!lbryio.enabled) {
    return new Promise((resolve, reject) => {
      resolve({
        id: 1,
        has_verified_email: true
      })
    })
  }
  if (lbryio._authenticationPromise === null) {
    lbryio._authenticationPromise = new Promise((resolve, reject) => {
      lbry.status().then((response) => {

        let installation_id = response.installation_id;

        function setCurrentUser() {
          lbryio.call('user', 'me').then((data) => {
              lbryio.user = data
              resolve(data)
          }).catch(function(err) {
            lbryio.setAccessToken(null);
            if (!getSession('reloadedOnFailedAuth')) {
              setSession('reloadedOnFailedAuth', true)
              window.location.reload();
            } else {
              reject(err);
            }
          })
        }

        if (!lbryio.getAccessToken()) {
          lbryio.call('user', 'new', {
            language: 'en',
            app_id: installation_id,
          }, 'post').then(function(responseData) {
            if (!responseData.id) {
              reject(new Error(__("Received invalid authentication response.")));
            }
            lbryio.setAccessToken(installation_id)
            setCurrentUser()
          }).catch(function(error) {
            /*
               until we have better error code format, assume all errors are duplicate application id
               if we're wrong, this will be caught by later attempts to make a valid call
             */
            lbryio.setAccessToken(installation_id)
            setCurrentUser()
          })
        } else {
          setCurrentUser()
        }
      }).catch(reject);
    });
  }
  return lbryio._authenticationPromise;
}

export default lbryio;