@nlabs/reaktor 0.3.0 → 0.4.0

package/lib/data/files.js

@@ -0,0 +1,525 @@
+"use strict";
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.for-each");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.array.last-index-of");
+
+require("core-js/modules/es.array.map");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.date.now");
+
+require("core-js/modules/es.date.to-string");
+
+require("core-js/modules/es.function.name");
+
+require("core-js/modules/es.object.define-properties");
+
+require("core-js/modules/es.object.define-property");
+
+require("core-js/modules/es.object.freeze");
+
+require("core-js/modules/es.object.get-own-property-descriptor");
+
+require("core-js/modules/es.object.get-own-property-descriptors");
+
+require("core-js/modules/es.object.keys");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/es.regexp.exec");
+
+require("core-js/modules/es.regexp.to-string");
+
+require("core-js/modules/es.string.iterator");
+
+require("core-js/modules/es.string.match");
+
+require("core-js/modules/es.string.search");
+
+require("core-js/modules/es.string.split");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeBase64 = exports.encodeBase64 = exports.updateFiles = exports.linkFiles = exports.createFile = exports.getUrlUserFiles = exports.getPathUserFiles = exports.getYouTubeSearch = exports.getYouTubeTrends = exports.getGiphySearch = exports.getGiphyTrends = exports.addFile = void 0;
+
+var _ripHunter = require("@nlabs/rip-hunter");
+
+var _utils = require("@nlabs/utils");
+
+var _arangojs = require("arangojs");
+
+var _googleapis = require("googleapis");
+
+var _graphqlErrors = require("graphql-errors");
+
+var _isEmpty = _interopRequireDefault(require("lodash/isEmpty"));
+
+var request = _interopRequireWildcard(require("request-promise"));
+
+var _config = require("../config");
+
+var _utils2 = require("../utils");
+
+var _images = require("./images");
+
+var _posts = require("./posts");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _templateObject3() {
+  var data = _taggedTemplateLiteral(["REMOVE {_key:", "} IN isPosted"]);
+
+  _templateObject3 = function _templateObject3() {
+    return data;
+  };
+
+  return data;
+}
+
+function _templateObject2() {
+  var data = _taggedTemplateLiteral(["UPSERT {_key: ", "}\n    INSERT ", "\n    UPDATE {}\n    IN files RETURN NEW"]);
+
+  _templateObject2 = function _templateObject2() {
+    return data;
+  };
+
+  return data;
+}
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _templateObject() {
+  var data = _taggedTemplateLiteral(["INSERT ", " IN files RETURN NEW"]);
+
+  _templateObject = function _templateObject() {
+    return data;
+  };
+
+  return data;
+}
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+var youtube = _googleapis.google.youtube({
+  auth: _config.Config.get('google.key'),
+  version: 'v3'
+});
+
+request.defaults({
+  encoding: null
+}); // const eventCategory: string = 'files';
+// Upload file
+
+var addFile = function addFile(context) {
+  var item = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var database = context.database,
+      sessionId = context.userId,
+      userAccess = context.userAccess;
+  var description = item.description,
+      fileId = item.fileId,
+      fileType = item.fileType,
+      name = item.name,
+      url = item.url; // Id
+
+  var formatFileId = fileId ? (0, _utils.parseId)(fileId) : (0, _utils.createHash)("file-".concat(sessionId)); // Name
+
+  var isUrl = (0, _isEmpty["default"])(url); // If no name, get it from url path
+
+  var formatName = (0, _utils.parseString)(name, 160);
+  var formatType = (0, _utils.parseString)(fileType, 16);
+
+  if (formatName === '' && isUrl) {
+    formatName = url.substring(url.lastIndexOf('/') + 1);
+  }
+
+  if (formatType === '') {
+    var nameArr = formatName.split('.');
+    var ext = nameArr[nameArr.length - 1];
+
+    switch (ext) {
+      case 'jpeg':
+      case 'jpg':
+        formatType = 'image/jpeg';
+        break;
+
+      case 'png':
+        formatType = 'image/png';
+        break;
+
+      case 'zip':
+        formatType = 'application/zip';
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  var isImage;
+
+  switch (formatType) {
+    case 'image/jpeg':
+    case 'image/png':
+      isImage = true;
+      break;
+
+    default:
+      isImage = false;
+      break;
+  } // Description
+
+
+  var formatDesc = (0, _utils.parseString)(description, 500); // Only allow file uploads to premium users
+
+  if (!isImage && userAccess !== 2) {
+    throw new _graphqlErrors.UserError('account_restriction');
+  }
+
+  var saveToDb = function saveToDb(insert) {
+    var aqlQry = (0, _arangojs.aql)(_templateObject(), insert);
+    return (0, _utils2.useDb)(database).query(aqlQry).then(function (cursor) {
+      return cursor.next();
+    }).then(function () {
+      var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return file;
+    })["catch"](function (error) {
+      throw error;
+    });
+  };
+
+  var uploadFile = function uploadFile(buf, uploadType) {
+    var now = Date.now(); // If image, resize and create a thumbnail
+
+    if (isImage) {
+      return (0, _images.resizeSaveImage)(context, formatFileId, buf, uploadType).then(function (resizedImage) {
+        var insert = _objectSpread(_objectSpread({}, resizedImage), {}, {
+          _key: formatFileId,
+          added: now,
+          description: formatDesc,
+          fileType: formatType,
+          modified: now,
+          name: formatName,
+          userId: sessionId
+        });
+
+        return saveToDb(insert);
+      })["catch"](function (error) {
+        throw error;
+      });
+    }
+
+    var insert = {
+      _key: formatFileId,
+      added: now,
+      description: formatDesc,
+      fileType: formatType,
+      modified: now,
+      name: formatName,
+      userId: sessionId
+    };
+    return saveToDb(insert);
+  }; // If file is a url path, download the file and save
+
+
+  if (isUrl) {
+    return request.get({
+      encoding: null,
+      uri: url
+    }).then(function (body) {
+      return uploadFile(Buffer.from(body, 'binary'), formatType);
+    })["catch"](function () {
+      throw new _graphqlErrors.UserError('file_request');
+    });
+  } else if (item.base64 !== '') {
+    var buffer = Buffer.from(item.base64);
+    return uploadFile(buffer, formatType);
+  }
+
+  throw new Error('file_required');
+}; // Giphy
+
+
+exports.addFile = addFile;
+
+var getGiphyTrends = function getGiphyTrends(context) {
+  var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
+  var gifUrl = "http://api.giphy.com/v1/gifs/trending?api_key=".concat(_config.Config.get('giphy.key'), "&limit=").concat(limit);
+  return (0, _ripHunter.get)(gifUrl).then(function (res) {
+    return res.json();
+  }).then(function (json) {
+    return json.data.map(function () {
+      var gifImage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        id: null,
+        images: null
+      };
+      var id = gifImage.id,
+          _gifImage$images = gifImage.images;
+      _gifImage$images = _gifImage$images === void 0 ? {} : _gifImage$images;
+      var _gifImage$images$orig = _gifImage$images.original;
+      _gifImage$images$orig = _gifImage$images$orig === void 0 ? {} : _gifImage$images$orig;
+      var _gifImage$images$orig2 = _gifImage$images$orig.url,
+          url = _gifImage$images$orig2 === void 0 ? '' : _gifImage$images$orig2,
+          _gifImage$images$fixe = _gifImage$images.fixed_height_small;
+      _gifImage$images$fixe = _gifImage$images$fixe === void 0 ? {} : _gifImage$images$fixe;
+      var _gifImage$images$fixe2 = _gifImage$images$fixe.url,
+          thumb = _gifImage$images$fixe2 === void 0 ? '' : _gifImage$images$fixe2;
+      return {
+        id: id,
+        thumb: thumb,
+        type: 'giphy',
+        url: url
+      };
+    });
+  });
+};
+
+exports.getGiphyTrends = getGiphyTrends;
+
+var getGiphySearch = function getGiphySearch(context, query) {
+  var limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 30;
+  var formatQuery = encodeURI(query);
+  var gifUrl = "http://api.giphy.com/v1/gifs/search?q=".concat(formatQuery, "&api_key=").concat(_config.Config.get('giphy.key'), "&limit=").concat(limit);
+  return fetch(gifUrl).then(function (res) {
+    return res.json();
+  }).then(function (json) {
+    return json.data.map(function () {
+      var gifImage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+        id: null,
+        images: null
+      };
+      var id = gifImage.id,
+          _gifImage$images2 = gifImage.images;
+      _gifImage$images2 = _gifImage$images2 === void 0 ? {} : _gifImage$images2;
+      var _gifImage$images2$ori = _gifImage$images2.original;
+      _gifImage$images2$ori = _gifImage$images2$ori === void 0 ? {} : _gifImage$images2$ori;
+      var _gifImage$images2$ori2 = _gifImage$images2$ori.url,
+          url = _gifImage$images2$ori2 === void 0 ? '' : _gifImage$images2$ori2,
+          _gifImage$images2$fix = _gifImage$images2.fixed_height_small;
+      _gifImage$images2$fix = _gifImage$images2$fix === void 0 ? {} : _gifImage$images2$fix;
+      var _gifImage$images2$fix2 = _gifImage$images2$fix.url,
+          thumb = _gifImage$images2$fix2 === void 0 ? '' : _gifImage$images2$fix2;
+      return {
+        id: id,
+        thumb: thumb,
+        type: 'giphy',
+        url: url
+      };
+    });
+  });
+};
+
+exports.getGiphySearch = getGiphySearch;
+
+var getYouTubeTrends = function getYouTubeTrends(context) {
+  var limit = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 30;
+  return new Promise(function (resolve, reject) {
+    youtube.videos.list({
+      chart: 'mostPopular',
+      maxResults: limit,
+      part: ['snippet'],
+      regionCode: 'US'
+    }, function (error, data) {
+      if (error) {
+        console.error(error);
+        reject(new Error(error[0].message));
+      } else if (data) {
+        var list = data.items.map(function (item) {
+          return {
+            id: item.id,
+            thumb: item.snippet.thumbnails.high.url,
+            type: 'youtube',
+            url: "http://www.youtube.com/embed/".concat(item.id)
+          };
+        });
+        resolve(list);
+      }
+    });
+  });
+};
+
+exports.getYouTubeTrends = getYouTubeTrends;
+
+var getYouTubeSearch = function getYouTubeSearch(context, query) {
+  var limit = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 30;
+  return new Promise(function (resolve, reject) {
+    youtube.search.list({
+      maxResults: limit,
+      part: ['snippet'],
+      // eslint-disable-next-line
+      q: query,
+      regionCode: 'US'
+    }, function (error, data) {
+      if (error) {
+        console.error(error);
+        reject(new Error(error[0].message));
+      } else if (data) {
+        var items = data.items;
+        var list = items.map(function (item) {
+          return {
+            id: item.id,
+            thumb: item.snippet.thumbnails.high.url,
+            type: 'youtube',
+            url: "http://www.youtube.com/embed/".concat(item.id)
+          };
+        });
+        resolve(list);
+      }
+    });
+  });
+}; // Files
+
+
+exports.getYouTubeSearch = getYouTubeSearch;
+
+var getPathUserFiles = function getPathUserFiles(userId, filename) {
+  return "users/".concat(userId, "/files/").concat(filename);
+};
+
+exports.getPathUserFiles = getPathUserFiles;
+
+var getUrlUserFiles = function getUrlUserFiles(userId, filename) {
+  var dir = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'files';
+  var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'profile';
+
+  if (filename) {
+    return "https://box.".concat(_config.Config.get('app.url'), "/users/").concat(userId, "/").concat(dir, "/").concat(filename);
+  }
+
+  if (type === 'profile') {
+    return "https://box.".concat(_config.Config.get('app.url'), "/defaults/user_bk.jpg");
+  }
+
+  return "https://box.".concat(_config.Config.get('app.url'), "/defaults/user_wh.jpg");
+};
+
+exports.getUrlUserFiles = getUrlUserFiles;
+
+var createFile = function createFile(db, file) {
+  var fileId = file.fileId;
+  var insert = {
+    _key: fileId,
+    added: Date.now()
+  };
+  var aqlQry = (0, _arangojs.aql)(_templateObject2(), fileId, insert);
+  return db.query(aqlQry).then(function (cursor) {
+    return cursor.next();
+  }).then(function () {
+    var updatedFile = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return updatedFile;
+  })["catch"](function (error) {
+    throw error;
+  });
+};
+
+exports.createFile = createFile;
+
+var linkFiles = function linkFiles(db, files, postId) {
+  return Promise.all(files.map(function (file) {
+    return createFile(db, file).then(function (file) {
+      return (0, _posts.createPostEdge)(db, file, postId);
+    });
+  }));
+};
+
+exports.linkFiles = linkFiles;
+
+var updateFiles = function updateFiles(db, postId, files) {
+  var edgeCollection = db.collection('isPosted');
+  return edgeCollection.inEdges(postId).then(function (edges) {
+    if (edges.length) {
+      // Remove linked edges
+      return Promise.all(edges.map(function (edge) {
+        var edgeKey = edge._key;
+        var aqlQry = (0, _arangojs.aql)(_templateObject3(), edgeKey);
+        return db.query(aqlQry)["catch"](function (error) {
+          throw error;
+        });
+      })).then(function () {
+        if (files.length) {
+          // Link files
+          return linkFiles(db, files, postId).then(function () {
+            return files;
+          });
+        }
+
+        return files;
+      });
+    } else if (files.length) {
+      // Link files
+      return linkFiles(db, files, postId).then(function () {
+        return files;
+      });
+    }
+
+    return files;
+  })["catch"](function (error) {
+    throw error;
+  });
+};
+
+exports.updateFiles = updateFiles;
+
+var encodeBase64 = function encodeBase64(buffer) {
+  return Buffer.from(buffer).toString('base64');
+};
+
+exports.encodeBase64 = encodeBase64;
+
+var decodeBase64 = function decodeBase64(dataString) {
+  var getData = function getData(str) {
+    return str.match(/^data:([A-Za-z-+\/]+);base64,(.+)$/) || [];
+  }; // const getData = (base64: string) => base64.substr(base64.indexOf(',') + 1);
+
+
+  var matches = getData(dataString);
+
+  if (matches.length !== 3) {
+    // If invalid make sure we don't need to decode
+    matches = getData(decodeURIComponent(dataString)); // Check it again.
+
+    if (matches.length !== 3) {
+      throw Error('Invalid input string');
+    }
+  }
+
+  return {
+    data: Buffer.from(matches[2], 'base64'),
+    type: matches[1]
+  };
+};
+
+exports.decodeBase64 = decodeBase64;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/data/files.ts"],"names":["youtube","google","auth","Config","get","version","request","defaults","encoding","addFile","context","item","database","sessionId","userId","userAccess","description","fileId","fileType","name","url","formatFileId","isUrl","formatName","formatType","substring","lastIndexOf","nameArr","split","ext","length","isImage","formatDesc","UserError","saveToDb","insert","aqlQry","aql","query","then","cursor","next","file","error","uploadFile","buf","uploadType","now","Date","resizedImage","_key","added","modified","uri","body","Buffer","from","base64","buffer","Error","getGiphyTrends","limit","gifUrl","res","json","data","map","gifImage","id","images","original","fixed_height_small","thumb","type","getGiphySearch","formatQuery","encodeURI","fetch","getYouTubeTrends","Promise","resolve","reject","videos","list","chart","maxResults","part","regionCode","console","message","items","snippet","thumbnails","high","getYouTubeSearch","search","q","getPathUserFiles","filename","getUrlUserFiles","dir","createFile","db","updatedFile","linkFiles","files","postId","all","updateFiles","edgeCollection","collection","inEdges","edges","edge","edgeKey","encodeBase64","toString","decodeBase64","dataString","getData","str","match","matches","decodeURIComponent"],"mappings":"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","sourcesContent":["import {get as httpGet} from '@nlabs/rip-hunter';\nimport {createHash, parseId, parseString} from '@nlabs/utils';\nimport {aql, Database} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {EdgeCollection} from 'arangojs/collection';\nimport {ArrayCursor} from 'arangojs/cursor';\nimport {google} from 'googleapis';\nimport {UserError} from 'graphql-errors';\nimport isEmpty from 'lodash/isEmpty';\nimport * as request from 'request-promise';\nimport {ApiContext} from 'types/auth';\n\nimport {Config} from '../config';\nimport {FileType} from '../types/files';\nimport {useDb} from '../utils';\nimport {resizeSaveImage} from './images';\nimport {createPostEdge} from './posts';\n\n/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nconst youtube = google.youtube({auth: Config.get('google.key'), version: 'v3'});\nrequest.defaults({encoding: null});\n\n// const eventCategory: string = 'files';\n\n// Upload file\nexport const addFile = (context: ApiContext, item: FileType = {}): Promise<FileType> => {\n  const {database, userId: sessionId, userAccess} = context;\n  const {\n    description,\n    fileId,\n    fileType,\n    name,\n    url\n  } = item;\n\n  // Id\n  const formatFileId: string = fileId ? parseId(fileId) : createHash(`file-${sessionId}`);\n\n  // Name\n  const isUrl: boolean = isEmpty(url);\n\n  // If no name, get it from url path\n  let formatName: string = parseString(name, 160);\n  let formatType: string = parseString(fileType, 16);\n\n  if(formatName === '' && isUrl) {\n    formatName = url.substring(url.lastIndexOf('/') + 1);\n  }\n\n  if(formatType === '') {\n    const nameArr: string[] = formatName.split('.');\n    const ext: string = nameArr[nameArr.length - 1];\n\n    switch(ext) {\n      case 'jpeg':\n      case 'jpg':\n        formatType = 'image/jpeg';\n        break;\n      case 'png':\n        formatType = 'image/png';\n        break;\n      case 'zip':\n        formatType = 'application/zip';\n        break;\n      default:\n        break;\n    }\n  }\n\n  let isImage: boolean;\n\n  switch(formatType) {\n    case 'image/jpeg':\n    case 'image/png':\n      isImage = true;\n      break;\n    default:\n      isImage = false;\n      break;\n  }\n\n  // Description\n  const formatDesc: string = parseString(description, 500);\n\n  // Only allow file uploads to premium users\n  if(!isImage && userAccess !== 2) {\n    throw new UserError('account_restriction');\n  }\n\n  const saveToDb = (insert: FileType) => {\n    const aqlQry: AqlQuery = aql`INSERT ${insert} IN files RETURN NEW`;\n\n    return useDb(database).query(aqlQry)\n      .then((cursor: ArrayCursor) => cursor.next())\n      .then((file = {}) => file)\n      .catch((error: Error) => {\n        throw error;\n      });\n  };\n\n  const uploadFile = (buf: Buffer, uploadType: string) => {\n    const now: number = Date.now();\n\n    // If image, resize and create a thumbnail\n    if(isImage) {\n      return resizeSaveImage(context, formatFileId, buf, uploadType)\n        .then((resizedImage: FileType) => {\n          const insert: FileType = {\n            ...resizedImage,\n            _key: formatFileId,\n            added: now,\n            description: formatDesc,\n            fileType: formatType,\n            modified: now,\n            name: formatName,\n            userId: sessionId\n          };\n\n          return saveToDb(insert);\n        })\n        .catch((error: Error) => {\n          throw error;\n        });\n    }\n    const insert: FileType = {\n      _key: formatFileId,\n      added: now,\n      description: formatDesc,\n      fileType: formatType,\n      modified: now,\n      name: formatName,\n      userId: sessionId\n    };\n\n    return saveToDb(insert);\n  };\n\n  // If file is a url path, download the file and save\n  if(isUrl) {\n    return request.get({encoding: null, uri: url})\n      .then((body) => uploadFile(Buffer.from(body, 'binary'), formatType))\n      .catch(() => {\n        throw new UserError('file_request');\n      });\n  } else if(item.base64 !== '') {\n    const buffer: Buffer = Buffer.from(item.base64);\n    return uploadFile(buffer, formatType);\n  }\n  throw new Error('file_required');\n};\n\n// Giphy\nexport const getGiphyTrends = (context: ApiContext, limit: number = 30): Promise<any[]> => {\n  const gifUrl: string = `http://api.giphy.com/v1/gifs/trending?api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return httpGet(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {\n      const {\n        id,\n        images: {\n          original: {url = ''} = {},\n          fixed_height_small: {url: thumb = ''} = {}\n        } = {}\n      } = gifImage;\n\n      return {\n        id,\n        thumb,\n        type: 'giphy',\n        url\n      };\n    }));\n};\n\nexport const getGiphySearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> => {\n  const formatQuery: string = encodeURI(query);\n  const gifUrl: string = `http://api.giphy.com/v1/gifs/search?q=${formatQuery}&api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return fetch(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json) => json.data.map((gifImage = {id: null, images: null}) => {\n      const {\n        id,\n        images: {\n          original: {url = ''} = {},\n          fixed_height_small: {url: thumb = ''} = {}\n        } = {}\n      } = gifImage;\n\n      return {\n        id,\n        thumb,\n        type: 'giphy',\n        url\n      };\n    }));\n};\n\nexport const getYouTubeTrends = (context: ApiContext, limit: number = 30): Promise<any[]> =>\n  new Promise((resolve, reject) => {\n    youtube.videos.list({\n      chart: 'mostPopular',\n      maxResults: limit,\n      part: ['snippet'],\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(error[0].message));\n      } else if(data) {\n        const list = data.items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n\n\nexport const getYouTubeSearch = (context: ApiContext, query: string, limit: number = 30): Promise<any[]> =>\n  new Promise((resolve, reject) => {\n    youtube.search.list({\n      maxResults: limit,\n      part: ['snippet'],\n      // eslint-disable-next-line\n      q: query,\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(error[0].message));\n      } else if(data) {\n        const {items} = data;\n        const list = items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n\n// Files\nexport const getPathUserFiles = (userId: string, filename: string): string => `users/${userId}/files/${filename}`;\n\nexport const getUrlUserFiles = (userId: string, filename: string, dir: string = 'files', type: string = 'profile'): string => {\n  if(filename) {\n    return `https://box.${Config.get('app.url')}/users/${userId}/${dir}/${filename}`;\n  }\n\n  if(type === 'profile') {\n    return `https://box.${Config.get('app.url')}/defaults/user_bk.jpg`;\n  }\n\n  return `https://box.${Config.get('app.url')}/defaults/user_wh.jpg`;\n};\n\nexport const createFile = (db: Database, file: FileType): Promise<FileType> => {\n  const {fileId} = file;\n  const insert: any = {\n    _key: fileId,\n    added: Date.now()\n  };\n\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${fileId}}\n    INSERT ${insert}\n    UPDATE {}\n    IN files RETURN NEW`;\n\n  return db.query(aqlQry)\n    .then((cursor: ArrayCursor) => cursor.next())\n    .then((updatedFile: FileType = {}) => updatedFile)\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const linkFiles = (db: Database, files: FileType[], postId: string): Promise<any> =>\n  Promise.all(\n    files.map((file: FileType) => createFile(db, file)\n      .then((file: FileType) => createPostEdge(db, file, postId)))\n  );\n\nexport const updateFiles = (db: Database, postId: string, files: FileType[]): Promise<any> => {\n  const edgeCollection: EdgeCollection = db.collection('isPosted');\n\n  return edgeCollection.inEdges(postId)\n    .then((edges: any) => {\n      if(edges.length) {\n        // Remove linked edges\n        return Promise.all(\n          edges.map((edge) => {\n            const {_key: edgeKey} = edge;\n            const aqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN isPosted`;\n\n            return db.query(aqlQry).catch((error: Error) => {\n              throw error;\n            });\n          }))\n          .then(() => {\n            if(files.length) {\n              // Link files\n              return linkFiles(db, files, postId).then(() => files);\n            }\n            return files;\n          });\n      } else if(files.length) {\n        // Link files\n        return linkFiles(db, files, postId).then(() => files);\n      }\n      return files;\n    })\n    .catch((error: Error) => {\n      throw error;\n    });\n};\n\nexport const encodeBase64 = (buffer: Buffer): string => Buffer.from(buffer).toString('base64');\n\nexport const decodeBase64 = (dataString: string): object => {\n  const getData = (str: string) => str.match(/^data:([A-Za-z-+\\/]+);base64,(.+)$/) || [];\n  // const getData = (base64: string) => base64.substr(base64.indexOf(',') + 1);\n  let matches = getData(dataString);\n\n  if(matches.length !== 3) {\n    // If invalid make sure we don't need to decode\n    matches = getData(decodeURIComponent(dataString));\n\n    // Check it again.\n    if(matches.length !== 3) {\n      throw Error('Invalid input string');\n    }\n  }\n\n  return {\n    data: Buffer.from(matches[2], 'base64'),\n    type: matches[1]\n  };\n};\n"]}