redquicklib/lib/redutil.js

import { bindActionCreators } from 'redux';
import { Platform } from 'react-native';
import { connect } from 'react-redux';
import * as UIActions from './actions/uiActions';
import * as AppActions from './actions/appActions';
import * as ILA from './actions/identityLoginActions';
import AR from './array';

export function RedConnect(component) {
  return connect(mapStateToProps, mapDispatchToProps)(component);
}
import {
  Linking
} from 'react-native';

var ReactNative = require('react-native');
var {
  AsyncStorage
} = ReactNative;

export const BATCH = 'BATCH';
export function batch(batch) {
  return {
    type: BATCH,
    batch
  }
}

export function capitalizeFirstLetter(string) {
  if (string)
    return string.charAt(0).toUpperCase() + string.slice(1);
  return string;
}
export function lowercaseFirstLetter(string) {
  if (string)
    return string.charAt(0).toLowerCase() + string.slice(1);
  return string;
}

export function GUID() {
  var guid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
    return v.toString(16);
  });
  return guid;
}

let actions = {};
export function addActions(_actions) {
  actions = Object.assign(actions, _actions);
}
export function mapDispatchToProps(dispatch) {
  var actionBlob = Object.assign({},
    ILA,
    AppActions,
    UIActions,
    actions
  );

  var result = bindActionCreators(actionBlob, dispatch);
  result.dispatch = dispatch;
  return result;
}

export function mapStateToProps(state) {
  return {
    state: state
  };
};

export function redAsyncStorage(store) {
  return ((store) => next => action => {
    var result = next(action);
    if (action.store)
      debouncedStoreAsync(store, action);
    return result;
  })(store);
}


function storeAsync(store, action) {
  var res = action;
  if (res.store) {
    try {
      var storeTarget = res.store;
      var storpart = store.getState()[storeTarget];
      if (res.storePart) {
        storpart = storpart[res.storePart];
        storpart = Object.assign({}, { ___isStorePart: res.storePart, store: res.store, [res.storePart]: storpart });
        storeTarget = res.storePart;
      }
      if (storpart) {
        var storestring = JSON.stringify(storpart);
        return AsyncStorage.setItem(storeTarget, storestring);
      }
    }
    catch (e) {
      UIA.log(e);
    }
  }
}

var debouncedStoreAsync = debounce(storeAsync, 1000, {})
/* Native method references for those with the same name as other `lodash` methods. */
var nativeMax = Math.max;

function isObject(value) {
  // Avoid a V8 JIT bug in Chrome 19-20.
  // See https://code.google.com/p/v8/issues/detail?id=2291 for more details.
  var type = typeof value;
  return !!value && (type == 'object' || type == 'function');
}

function debounce(func, wait, options) {
  var args,
    maxTimeoutId,
    result,
    stamp,
    thisArg,
    now = Date.now,
    timeoutId,
    trailingCall,
    lastCalled = 0,
    maxWait = false,
    trailing = true;

  if (typeof func != 'function') {
    throw new TypeError(FUNC_ERROR_TEXT);
  }
  wait = wait < 0 ? 0 : (+wait || 0);
  if (options === true) {
    var leading = true;
    trailing = false;
  } else if (isObject(options)) {
    leading = !!options.leading;
    maxWait = 'maxWait' in options && nativeMax(+options.maxWait || 0, wait);
    trailing = 'trailing' in options ? !!options.trailing : trailing;
  }

  function cancel() {
    if (timeoutId) {
      clearTimeout(timeoutId);
    }
    if (maxTimeoutId) {
      clearTimeout(maxTimeoutId);
    }
    lastCalled = 0;
    maxTimeoutId = timeoutId = trailingCall = undefined;
  }

  function complete(isCalled, id) {
    if (id) {
      clearTimeout(id);
    }
    maxTimeoutId = timeoutId = trailingCall = undefined;
    if (isCalled) {
      lastCalled = now();
      result = func.apply(thisArg, args);
      if (!timeoutId && !maxTimeoutId) {
        args = thisArg = undefined;
      }
    }
  }

  function delayed() {
    var remaining = wait - (now() - stamp);
    if (remaining <= 0 || remaining > wait) {
      complete(trailingCall, maxTimeoutId);
    } else {
      timeoutId = setTimeout(delayed, remaining);
    }
  }

  function maxDelayed() {
    complete(trailing, timeoutId);
  }

  function debounced() {
    args = arguments;
    stamp = now();
    thisArg = this;
    trailingCall = trailing && (timeoutId || !leading);

    if (maxWait === false) {
      var leadingCall = leading && !timeoutId;
    } else {
      if (!maxTimeoutId && !leading) {
        lastCalled = stamp;
      }
      var remaining = maxWait - (stamp - lastCalled),
        isCalled = remaining <= 0 || remaining > maxWait;

      if (isCalled) {
        if (maxTimeoutId) {
          maxTimeoutId = clearTimeout(maxTimeoutId);
        }
        lastCalled = stamp;
        result = func.apply(thisArg, args);
      }
      else if (!maxTimeoutId) {
        maxTimeoutId = setTimeout(maxDelayed, remaining);
      }
    }
    if (isCalled && timeoutId) {
      timeoutId = clearTimeout(timeoutId);
    }
    else if (!timeoutId && wait !== maxWait) {
      timeoutId = setTimeout(delayed, wait);
    }
    if (leadingCall) {
      isCalled = true;
      result = func.apply(thisArg, args);
    }
    if (isCalled && !timeoutId && !maxTimeoutId) {
      args = thisArg = undefined;
    }
    return result;
  }
  debounced.cancel = cancel;
  return debounced;
}

/** Extend Number object with method to convert numeric degrees to radians */
if (Number.prototype.toRadians === undefined) {
  Number.prototype.toRadians = function () { return this * Math.PI / 180; };
}

/** Extend Number object with method to convert radians to numeric (signed) degrees */
if (Number.prototype.toDegrees === undefined) {
  Number.prototype.toDegrees = function () { return this * 180 / Math.PI; };
}

export function convertMetersToMiles(dist) {
  var result = dist;
  result = (Math.round(100 * result * 0.000621371) / 100);
  return result;
}

export function getDistance(coords1, coords2) {
  if (!coords1 || !coords2) {
    return null;
  }
  var lat1 = coords1.latitude || coords1.lat;
  var lat2 = coords2.latitude || coords2.lat;
  var lon1 = coords1.longitude || coords1.lng;
  var lon2 = coords2.longitude || coords2.lng;
  if (lat1 !== undefined && lat2 !== undefined && lon1 !== undefined && lon2 !== undefined) {
    var R = 6371e3; // metres
    var φ1 = lat1.toRadians();
    var φ2 = lat2.toRadians();
    var Δφ = (lat2 - lat1).toRadians();
    var Δλ = (lon2 - lon1).toRadians();

    var a = Math.sin(Δφ / 2) * Math.sin(Δφ / 2) +
      Math.cos(φ1) * Math.cos(φ2) *
      Math.sin(Δλ / 2) * Math.sin(Δλ / 2);
    var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));

    var d = R * c;
    return d;
  }
}

export function estimatedTravelTime(directions) {
  if (directions && directions.routes && directions.routes[0]) {
    var legs = directions.routes[0].legs;
    var result = 0;
    legs.map(leg => {
      if (leg && leg.steps) {
        result += leg.duration.value;
      }
    });
    return Math.round(result / 60);
  }

  return null;
}

export function estimatedTravelTimeHM(directions) {
  var eta = estimatedTravelTime(directions);
  if (eta !== null) {
    var hours = Math.floor(eta / 60);
    var minutes = eta - (hours * 60);
    return { hours, minutes }
  }
  return null;
}

export function email(to, cc, bcc, subject, body) {
  let url = 'mailto:';
  let argLength = arguments.length;

  switch (argLength) {
    case 0:
      LaunchURL(url);
      return;
    case 5:
      break;
    default:
      console.log('you must supply either 0 or 5 arguments. You supplied ' + argLength);
      return;
  }

  // we use this Boolean to keep track of when we add a new parameter to the querystring
  // it helps us know when we need to add & to separate parameters
  let valueAdded = false;

  if (isCorrectType('Array', arguments[0])) {
    let validAddresses = getValidArgumentsFromArray(arguments[0], 'String');

    if (validAddresses.length > 0) {
      url += encodeURIComponent(validAddresses.join(','));
    }
  }

  url += '?';

  if (isCorrectType('Array', arguments[1])) {
    let validAddresses = getValidArgumentsFromArray(arguments[1], 'String');

    if (validAddresses.length > 0) {
      valueAdded = true;
      url += 'cc=' + encodeURIComponent(validAddresses.join(','));
    }
  }

  if (isCorrectType('Array', arguments[2])) {
    if (valueAdded) {
      url += '&';
    }

    let validAddresses = getValidArgumentsFromArray(arguments[2], 'String');

    if (validAddresses.length > 0) {
      valueAdded = true;
      url += 'bcc=' + encodeURIComponent(validAddresses.join(','));
    }
  }

  if (isCorrectType('String', arguments[3])) {
    if (valueAdded) {
      url += '&';
    }

    valueAdded = true;
    url += 'subject=' + encodeURIComponent(arguments[3]);
  }

  if (isCorrectType('String', arguments[4])) {
    if (valueAdded) {
      url += '&';
    }

    url += 'body=' + encodeURIComponent(arguments[4]);
  }

  LaunchURL(url);
}

export function phonecall(phoneNumber, prompt) {
  if (arguments.length !== 2) {
    console.log('you must supply exactly 2 arguments');
    return;
  }

  if (!isCorrectType('String', phoneNumber)) {
    console.log('the phone number must be provided as a String value');
    return;
  }

  if (!isCorrectType('Boolean', prompt)) {
    console.log('the prompt parameter must be a Boolean');
    return;
  }

  let url;

  if (Platform.OS !== 'android') {
    url = prompt ? 'telprompt:' : 'tel:';
  }
  else {
    url = 'tel:';
  }

  url += phoneNumber;

  LaunchURL(url);
}

export function text(phoneNumber = null, body = null) {
  if (arguments.length > 2) {
    console.log('you supplied too many arguments. You can either supply 0 or 1 or 2');
    return;
  }

  let url = 'sms:';

  if (phoneNumber) {
    if (isCorrectType('String', phoneNumber)) {
      url += phoneNumber;
    } else {
      console.log('the phone number should be provided as a string. It was provided as '
        + Object.prototype.toString.call(phoneNumber).slice(8, -1)
        + ',ignoring the value provided');
    }
  }

  if (body) {
    if (isCorrectType('String', body)) {
      // for some strange reason android seems to have issues with ampersands in the body unless it is encoded twice!
      // iOS only needs encoding once
      if (Platform.OS === 'android') body = encodeURIComponent(body);
      url += Platform.OS === 'ios' ? `&body=${encodeURIComponent(body)}` : `?body=${encodeURIComponent(body)}`;
    } else {
      console.log('the body should be provided as a string. It was provided as '
        + Object.prototype.toString.call(body).slice(8, -1)
        + ',ignoring the value provided');
    }
  }

  LaunchURL(url);
}

function getValidArgumentsFromArray(array, type) {
  var validValues = [];
  array.forEach(function (value) {
    if (isCorrectType(type, value)) {
      validValues.push(value);
    }
  });

  return validValues;
};

function isCorrectType(expected, actual) {
  return Object.prototype.toString.call(actual).slice(8, -1) === expected;
};

export function LaunchURL(url) {
  Linking.canOpenURL(url).then(supported => {
    if (!supported) {
      console.log('Can\'t handle url: ' + url);
    } else {
      Linking.openURL(url)
        .catch(err => {
          if (url.includes('telprompt')) {
            // telprompt was cancelled and Linking openURL method sees this as an error
            // it is not a true error so ignore it to prevent apps crashing
            // see https://github.com/anarchicknight/react-native-communications/issues/39
          } else {
            console.warn('openURL error', err)
          }
        });
    }
  }).catch(err => console.warn('An unexpected error happened', err));
};