refactor BWS server support methods

packages/bitcore-wallet-service/src/lib/server/advertisements.ts

@@ -0,0 +1,146 @@
+import Uuid from 'uuid';
+import { Errors } from '../errors/errordefinitions';
+import { Advertisement } from '../model';
+import { checkRequired } from './shared';
+import type { WalletService } from '../server';
+
+type Callback = (err?: any, data?: any) => void;
+
+export function createAdvert(service: WalletService, opts, cb: Callback) {
+  opts = opts ? { ...opts } : {};
+
+  if (!checkRequired(opts, ['title'], cb)) {
+    return;
+  }
+
+  const checkIfAdvertExistsAlready = (adId, next: Callback) => {
+    service.storage.fetchAdvert(opts.adId, (err, result) => {
+      if (err) return next(err);
+
+      if (result) {
+        return next(Errors.AD_ALREADY_EXISTS);
+      }
+
+      const advert = new Advertisement();
+      advert.advertisementId = opts.advertisementId || Uuid.v4();
+      advert.name = opts.name;
+      advert.title = opts.title;
+      advert.country = opts.country;
+      advert.type = opts.type;
+      advert.body = opts.body;
+      advert.imgUrl = opts.imgUrl;
+      advert.linkText = opts.linkText;
+      advert.linkUrl = opts.linkUrl;
+      advert.isAdActive = opts.isAdActive;
+      advert.dismissible = opts.dismissible;
+      advert.signature = opts.signature;
+      advert.app = opts.app;
+      advert.isTesting = opts.isTesting;
+
+      return next(null, advert);
+    });
+  };
+
+  service._runLocked(
+    cb,
+    next => {
+      checkIfAdvertExistsAlready(opts.adId, (err, advert) => {
+        if (err) throw err;
+        if (advert) {
+          service.storage.storeAdvert(advert, next);
+        }
+      });
+    },
+    10 * 1000
+  );
+}
+
+export function getAdvert(service: WalletService, opts, cb: Callback) {
+  service.storage.fetchAdvert(opts.adId, (err, advert) => {
+    if (err) return cb(err);
+    return cb(null, advert);
+  });
+}
+
+export function getAdverts(service: WalletService, _opts, cb: Callback) {
+  service.storage.fetchActiveAdverts((err, adverts) => {
+    if (err) return cb(err);
+    return cb(null, adverts);
+  });
+}
+
+export function getAdvertsByCountry(service: WalletService, opts, cb: Callback) {
+  service.storage.fetchAdvertsByCountry(opts.country, (err, adverts) => {
+    if (err) return cb(err);
+    return cb(null, adverts);
+  });
+}
+
+export function getTestingAdverts(service: WalletService, _opts, cb: Callback) {
+  service.storage.fetchTestingAdverts((err, adverts) => {
+    if (err) return cb(err);
+    return cb(null, adverts);
+  });
+}
+
+export function getAllAdverts(service: WalletService, opts, cb: Callback) {
+  service._runLocked(cb, next => {
+    service.getAllAdverts(opts, next);
+  });
+}
+
+export function removeAdvert(service: WalletService, opts, cb: Callback) {
+  opts = opts ? { ...opts } : {};
+
+  if (!checkRequired(opts, ['adId'], cb)) {
+    throw new Error('adId is missing');
+  }
+
+  const checkIfAdvertExistsAlready = (adId, next: Callback) => {
+    service.storage.fetchAdvert(opts.adId, (err, result) => {
+      if (err) return next(err);
+
+      if (!result) {
+        throw new Error('Advertisement does not exist: ' + opts.adId);
+      }
+
+      service.logw('Advert already exists:', opts.adId);
+      return next(null, adId);
+    });
+  };
+
+  service._runLocked(
+    cb,
+    next => {
+      checkIfAdvertExistsAlready(opts.adId, (err, adId) => {
+        if (err) throw err;
+        service.storage.removeAdvert(adId, next);
+      });
+    },
+    10 * 1000
+  );
+}
+
+export function activateAdvert(service: WalletService, opts, cb: Callback) {
+  opts = opts ? { ...opts } : {};
+  if (!checkRequired(opts, ['adId'], cb)) {
+    throw new Error('adId is missing');
+  }
+
+  service.storage.activateAdvert(opts.adId, (err, result) => {
+    if (err) return cb(err);
+    return cb(null, result);
+  });
+}
+
+export function deactivateAdvert(service: WalletService, opts, cb: Callback) {
+  opts = opts ? { ...opts } : {};
+  if (!checkRequired(opts, ['adId'], cb)) {
+    throw new Error('adId is missing');
+  }
+
+  service.storage.deactivateAdvert(opts.adId, (err, result) => {
+    if (err) return cb(err);
+    return cb(null, result);
+  });
+}

packages/bitcore-wallet-service/src/lib/server/auth.ts

@@ -0,0 +1,185 @@
+import * as async from 'async';
+import { Common } from '../common';
+import { Errors } from '../errors/errordefinitions';
+import { Session } from '../model';
+import { UPGRADES, checkRequired } from './shared';
+import type { WalletService } from '../server';
+
+const { Utils } = Common;
+
+interface WalletServiceClass {
+  new(): WalletService;
+  upgradeNeeded(paths, opts);
+}
+
+export function getInstance(WalletServiceClass: WalletServiceClass, opts?): WalletService {
+  opts = opts || {};
+
+  const upgradeMessage = WalletServiceClass.upgradeNeeded(UPGRADES.bwc_$lt_1_2, opts);
+  if (upgradeMessage) {
+    throw Errors.UPGRADE_NEEDED.withMessageMaybe(upgradeMessage);
+  }
+
+  const service = new WalletServiceClass();
+  service._setClientVersion(opts.clientVersion);
+  service._setAppVersion(opts.userAgent);
+  service.userAgent = opts.userAgent;
+  return service;
+}
+
+export function getInstanceWithAuth(WalletServiceClass: WalletServiceClass, opts, cb): void {
+  const withSignature = cb => {
+    if (!checkRequired(opts, ['copayerId', 'message', 'signature'], cb)) {
+      return;
+    }
+
+    let service: WalletService;
+    try {
+      service = getInstance(WalletServiceClass, opts);
+    } catch (ex) {
+      return cb(ex);
+    }
+
+    service.storage.fetchCopayerLookup(opts.copayerId, (err, copayer) => {
+      if (err) {
+        return cb(err);
+      }
+      if (!copayer) {
+        return cb(Errors.NOT_AUTHORIZED.withMessage('Copayer not found'));
+      }
+
+      const isValid = !!service._getSigningKey(opts.message, opts.signature, copayer.requestPubKeys);
+      if (!isValid) {
+        return cb(Errors.NOT_AUTHORIZED.withMessage('Invalid signature'));
+      }
+
+      service.walletId = copayer.walletId;
+
+      if (copayer.isSupportStaff) {
+        service.walletId = opts.walletId || copayer.walletId;
+        service.copayerIsSupportStaff = true;
+      }
+      if (copayer.isMarketingStaff) {
+        service.copayerIsMarketingStaff = true;
+      }
+
+      service.copayerId = opts.copayerId;
+      return cb(null, service);
+    });
+  };
+
+  const withSession = cb => {
+    if (!checkRequired(opts, ['copayerId', 'session'], cb)) {
+      return;
+    }
+
+    let service: WalletService;
+    try {
+      service = getInstance(WalletServiceClass, opts);
+    } catch (ex) {
+      return cb(ex);
+    }
+
+    service.storage.getSession(opts.copayerId, (err, s) => {
+      if (err) {
+        return cb(err);
+      }
+
+      const isValid = s && s.id === opts.session && s.isValid();
+      if (!isValid) {
+        return cb(Errors.NOT_AUTHORIZED.withMessage('Session expired'));
+      }
+
+      service.storage.fetchCopayerLookup(opts.copayerId, (err, copayer) => {
+        if (err) {
+          return cb(err);
+        }
+        if (!copayer) {
+          return cb(Errors.NOT_AUTHORIZED.withMessage('Copayer not found'));
+        }
+
+        service.copayerId = opts.copayerId;
+        service.walletId = copayer.walletId;
+        return cb(null, service);
+      });
+    });
+  };
+
+  const authFn = opts.session ? withSession : withSignature;
+  return authFn(cb);
+}
+
+export function login(service: WalletService, _opts, cb) {
+  let session;
+  async.series(
+    [
+      next => {
+        service.storage.getSession(service.copayerId, (err, s) => {
+          if (err) {
+            return next(err);
+          }
+          session = s;
+          next();
+        });
+      },
+      next => {
+        if (!session || !session.isValid()) {
+          session = Session.create({
+            copayerId: service.copayerId,
+            walletId: service.walletId
+          });
+        } else {
+          session.touch();
+        }
+        next();
+      },
+      next => {
+        service.storage.storeSession(session, next);
+      }
+    ],
+    err => {
+      if (err) {
+        return cb(err);
+      }
+      if (!session) {
+        return cb(new Error('Could not get current session for this copayer'));
+      }
+
+      return cb(null, session.id);
+    }
+  );
+}
+
+export function logout(_service: WalletService, _opts, _cb) {
+  // this.storage.removeSession(this.copayerId, cb);
+}
+
+export function setClientVersion(service: WalletService, version) {
+  delete service.parsedClientVersion;
+  service.clientVersion = version;
+}
+
+export function setAppVersion(service: WalletService, userAgent) {
+  const parsed = Utils.parseAppVersion(userAgent);
+  if (!parsed) {
+    service.appName = service.appVersion = null;
+  } else {
+    service.appName = parsed.app;
+    service.appVersion = parsed;
+  }
+}
+
+export function parseClientVersion(service: WalletService) {
+  if (service.parsedClientVersion == null) {
+    service.parsedClientVersion = Utils.parseVersion(service.clientVersion);
+  }
+  return service.parsedClientVersion;
+}
+
+export function clientSupportsPayProRefund(service: WalletService) {
+  const version = service._parseClientVersion();
+  if (!version) return false;
+  if (version.agent != 'bwc') return true;
+  if (version.major < 1 || (version.major == 1 && version.minor < 2)) return false;
+  return true;
+}