@barchart/portfolio-client-js 1.1.2

package/example/example.shim.js

@@ -0,0 +1,9 @@
+const JwtGateway = require('@barchart/tgam-jwt-js/lib/JwtGateway');
+
+module.exports = (() => {
+	'use strict';
+
+	window.Barchart = window.Barchart || { };
+	window.Barchart.Jwt = window.Barchart.Jwt || { };
+	window.Barchart.Jwt.JwtProvider = JwtGateway;
+})();

package/gulpfile.js

@@ -0,0 +1,148 @@
+const gulp = require('gulp');
+
+const browserify = require('browserify'),
+	buffer = require('vinyl-buffer'),
+	bump = require('gulp-bump'),
+	exec = require('child_process').exec,
+	git = require('gulp-git'),
+	gitStatus = require('git-get-status'),
+	glob = require('glob'),
+	jasmine = require('gulp-jasmine'),
+	jshint = require('gulp-jshint'),
+	replace = require('gulp-replace'),
+	runSequence = require('run-sequence'),
+	source = require('vinyl-source-stream'),
+	util = require('gulp-util');
+
+const fs = require('fs');
+
+function getVersionFromPackage() {
+	return JSON.parse(fs.readFileSync('./package.json', 'utf8')).version;
+}
+
+gulp.task('ensure-clean-working-directory', () => {
+	gitStatus(function(err, status) {
+		if (err, !status.clean) {
+			throw new Error('Unable to proceed, your working directory is not clean.');
+		}
+	});
+});
+
+gulp.task('bump-version', () => {
+	return gulp.src([ './package.json' ])
+		.pipe(bump({ type: 'patch' }).on('error', util.log))
+		.pipe(gulp.dest('./'));
+});
+
+gulp.task('embed-version', function () {
+	var version = getVersionFromPackage();
+
+	return gulp.src(['./lib/index.js'])
+		.pipe(replace(/(version:\s*')([0-9]+\.[0-9]+\.[0-9]+)(')/g, '$1' + version + '$3'))
+		.pipe(gulp.dest('./lib/'));
+});
+
+gulp.task('document', function (cb) {
+	exec('jsdoc . -c jsdoc.json -r -d docs', (error, stdout, stderr) => {
+		console.log(stdout);
+		console.log(stderr);
+
+		cb();
+	});
+});
+
+gulp.task('commit-changes', () => {
+	return gulp.src([ './', './test/', './package.json', './lib/index.js', './example/example.js', './test/SpecRunner.js' ])
+		.pipe(git.add())
+		.pipe(git.commit('Release. Bump version number'));
+});
+
+gulp.task('push-changes', (cb) => {
+	git.push('origin', 'master', cb);
+});
+
+gulp.task('create-tag', (cb) => {
+	const version = getVersionFromPackage();
+
+	git.tag(version, 'Release ' + version, function (error) {
+		if (error) {
+			return cb(error);
+		}
+
+		git.push('origin', 'master', { args: '--tags' }, cb);
+	});
+});
+
+gulp.task('build-example-bundle', function() {
+	return browserify([ './example/example.shim.js', './lib/index.js' ], { standalone: 'Barchart.Portfolio' })
+		.bundle()
+		.pipe(source('example.js'))
+		.pipe(buffer())
+		.pipe(gulp.dest('./example'));
+});
+
+gulp.task('build-test-bundle', () => {
+	return browserify({ entries: glob.sync('test/specs/**/*.js') })
+		.bundle()
+		.pipe(source('SpecRunner.js'))
+		.pipe(buffer())
+		.pipe(gulp.dest('test'));
+});
+
+gulp.task('execute-browser-tests', () => {
+	return gulp.src('test/SpecRunner.js')
+		.pipe(jasmine());
+});
+
+gulp.task('execute-node-tests', () => {
+	return gulp.src(['test/specs/**/*.js'])
+		.pipe(jasmine());
+});
+
+gulp.task('execute-tests', (cb) => {
+	runSequence(
+		'build-test-bundle',
+		'execute-browser-tests',
+		'execute-node-tests',
+
+		function (error) {
+			if (error) {
+				console.log(error.message);
+			}
+
+			cb(error);
+		});
+});
+
+gulp.task('release', (cb) => {
+	runSequence(
+		'ensure-clean-working-directory',
+		'execute-tests',
+		'document',
+		'bump-version',
+		'embed-version',
+		'build-example-bundle',
+		'commit-changes',
+		'push-changes',
+		'create-tag',
+
+		function (error) {
+			if (error) {
+				console.log(error.message);
+			} else {
+				console.log('Release complete');
+			}
+
+			cb(error);
+		});
+});
+
+gulp.task('lint', () => {
+	return gulp.src([ './**/*.js', './test/specs/**/*.js', '!./node_modules/**', '!./docs/**', '!./test/SpecRunner.js', '!./example/example.js' ])
+		.pipe(jshint({'esversion': 6}))
+		.pipe(jshint.reporter('default'));
+});
+
+gulp.task('test', [ 'execute-tests' ]);
+
+gulp.task('default', [ 'lint' ]);

package/jsdoc.json

@@ -0,0 +1,8 @@
+{
+    "source": {
+        "include": [ "." ],
+        "exclude": [ "./node_modules", "./test" ],
+        "includePattern": ".+\\.js(doc|x)?$",
+        "excludePattern": "(^|\\/|\\\\)_"
+    }
+}

package/lib/common/Configuration.js

@@ -0,0 +1,42 @@
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * Static configuration data.
+	 *
+	 * @public
+	 */
+	class Configuration {
+		constructor() {
+
+		}
+
+		/**
+		 * The host of the development system.
+		 *
+		 * @public
+		 * @static
+		 * @returns {String}
+		 */
+		static get developmentHost() {
+			return 'g4zerhpif5.execute-api.us-east-1.amazonaws.com/dev';
+		}
+
+		/**
+		 * The host of the production system.
+		 *
+		 * @public
+		 * @static
+		 * @returns {String}
+		 */
+		static get productionHost() {
+			return 'g4zerhpif5.execute-api.us-east-1.amazonaws.com/prod';
+		}
+
+		toString() {
+			return '[Configuration]';
+		}
+	}
+
+	return Configuration;
+})();

package/lib/gateway/PortfolioGateway.js

@@ -0,0 +1,292 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Disposable = require('@barchart/common-js/lang/Disposable'),
+	Enum = require('@barchart/common-js/lang/Enum'),
+	is = require('@barchart/common-js/lang/is');
+
+const TransactionSchema = require('@barchart/portfolio-api-common/lib/serialization/TransactionSchema');
+
+const EndpointBuilder = require('@barchart/common-js/api/http/builders/EndpointBuilder'),
+	Gateway = require('@barchart/common-js/api/http/Gateway'),
+	ProtocolType = require('@barchart/common-js/api/http/definitions/ProtocolType'),
+	ErrorInterceptor = require('@barchart/common-js/api/http/interceptors/ErrorInterceptor'),
+	RequestInterceptor = require('@barchart/common-js/api/http/interceptors/RequestInterceptor'),
+	ResponseInterceptor = require('@barchart/common-js/api/http/interceptors/ResponseInterceptor'),
+	VerbType = require('@barchart/common-js/api/http/definitions/VerbType');
+
+const Configuration = require('./../common/Configuration');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * Web service gateway for invoking the Portfolio API.
+	 *
+	 * @public
+	 * @param {String} protocol - The protocol to use (either HTTP or HTTPS).
+	 * @param {String} host - The host name of the Portfolio web service.
+	 * @param {Number} port - The TCP port number of the Portfolio web service.
+	 * @param {RequestInterceptor=} requestInterceptor - A request interceptor used with each request (typically used to inject JWT tokens).
+	 * @extends {Disposable}
+	 */
+	class PortfolioGateway extends Disposable {
+		constructor(protocol, host, port, requestInterceptor) {
+			super();
+
+			this._started = false;
+			this._startPromise = null;
+
+			const protocolType = Enum.fromCode(ProtocolType, protocol.toUpperCase());
+
+			let requestInterceptorToUse;
+
+			if (requestInterceptor) {
+				requestInterceptorToUse = requestInterceptor;
+			} else {
+				requestInterceptorToUse = RequestInterceptor.EMPTY;
+			}
+
+			this._readPortfoliosEndpoint = EndpointBuilder.for('read-portfolios', 'read portfolios')
+				.withVerb(VerbType.GET)
+				.withProtocol(protocolType)
+				.withHost(host)
+				.withPort(port)
+				.withPathBuilder((pb) => {
+					pb.withLiteralParameter('portfolios', 'portfolios')
+						.withVariableParameter('portfolio', 'portfolio', 'portfolio', false);
+				})
+				.withRequestInterceptor(requestInterceptorToUse)
+				.withResponseInterceptor(responseInterceptorForPortfolioDeserialization)
+				.withErrorInterceptor(ErrorInterceptor.GENERAL)
+				.endpoint;
+
+			this._readPositionsEndpoint = EndpointBuilder.for('read-positions', 'read positions')
+				.withVerb(VerbType.GET)
+				.withProtocol(protocolType)
+				.withHost(host)
+				.withPort(port)
+				.withPathBuilder((pb) => {
+					pb.withLiteralParameter('portfolios', 'portfolios')
+						.withVariableParameter('portfolio', 'portfolio', 'portfolio', false)
+						.withLiteralParameter('positions', 'positions')
+						.withVariableParameter('position', 'position', 'position', false);
+				})
+				.withRequestInterceptor(requestInterceptorToUse)
+				.withResponseInterceptor(responseInterceptorForPositionDeserialization)
+				.withErrorInterceptor(ErrorInterceptor.GENERAL)
+				.endpoint;
+
+			this._readTransactionsEndpoint = EndpointBuilder.for('read-transactions', 'read transactions')
+				.withVerb(VerbType.GET)
+				.withProtocol(protocolType)
+				.withHost(host)
+				.withPort(port)
+				.withPathBuilder((pb) => {
+					pb.withLiteralParameter('portfolios', 'portfolios')
+						.withVariableParameter('portfolio', 'portfolio', 'portfolio', false)
+						.withLiteralParameter('positions', 'positions')
+						.withVariableParameter('position', 'position', 'position', false)
+						.withLiteralParameter('transactions', 'transactions');
+				})
+				.withQueryBuilder((qb) => {
+					qb.withLiteralParameter('mode', 'mode', 'text');
+				})
+				.withRequestInterceptor(RequestInterceptor.PLAIN_TEXT_RESPONSE)
+				.withRequestInterceptor(requestInterceptorToUse)
+				.withResponseInterceptor(responseInterceptorForTransactionDeserialization)
+				.withErrorInterceptor(ErrorInterceptor.GENERAL)
+				.endpoint;
+
+			this._readTransactionsReportEndpoint = EndpointBuilder.for('read-transactions', 'read transactions')
+				.withVerb(VerbType.GET)
+				.withProtocol(protocolType)
+				.withHost(host)
+				.withPort(port)
+				.withPathBuilder((pb) => {
+					pb.withLiteralParameter('portfolios', 'portfolios')
+					.withVariableParameter('portfolio', 'portfolio', 'portfolio', false)
+					.withLiteralParameter('positions', 'positions')
+					.withVariableParameter('position', 'position', 'position', true)
+					.withLiteralParameter('transactions', 'transactions')
+					.withLiteralParameter('formatted', 'formatted');
+				})
+				.withRequestInterceptor(requestInterceptorToUse)
+				.withResponseInterceptor(ResponseInterceptor.DATA)
+				.withErrorInterceptor(ErrorInterceptor.GENERAL)
+				.endpoint;
+		}
+
+		/**
+		 * Initializes the connection to the remote server and returns a promise
+		 * containing the current instance.
+		 *
+		 * @public
+		 * @returns {Promise.<PortfolioGateway>}
+		 */
+		start() {
+			return Promise.resolve()
+				.then(() => {
+					if (this._startPromise === null) {
+						this._startPromise = Promise.resolve()
+							.then(() => {
+								this._started = true;
+
+								return this;
+							}).catch((e) => {
+								this._startPromise = null;
+
+								throw e;
+							});
+					}
+
+					return this._startPromise;
+				});
+		}
+
+		/**
+		 * Reads all portfolios for a user, or a single portfolio.
+		 *
+		 * @public
+		 * @param {String=} portfolio
+		 * @return {Promise.<Portfolio[]>}
+		 */
+		readPortfolios(portfolio) {
+			return Promise.resolve()
+				.then(() => {
+					checkStart.call(this);
+
+					assert.argumentIsOptional(portfolio, 'portfolio', String);
+
+					return Gateway.invoke(this._readPortfoliosEndpoint, { portfolio: portfolio || '*' });
+				});
+		}
+
+		/**
+		 * Retrieves positions for a user, a user's portfolio, or a single position.
+		 *
+		 * @public
+		 * @param {String=} portfolio
+		 * @param {String=} position
+		 * @returns {Promise.<Position[]>}
+		 */
+		readPositions(portfolio, position) {
+			return Promise.resolve()
+				.then(() => {
+					checkStart.call(this);
+
+					assert.argumentIsOptional(portfolio, 'portfolio', String);
+					assert.argumentIsOptional(position, 'position', String);
+
+					return Gateway.invoke(this._readPositionsEndpoint, { portfolio: portfolio, position: position || '*' });
+				});
+		}
+
+		/**
+		 * Retrieves transactions for a portfolio, or a single position.
+		 *
+		 * @public
+		 * @param {String} portfolio
+		 * @param {String=} position
+		 * @returns {Promise.<Transaction[]>}
+		 */
+		readTransactions(portfolio, position) {
+			return Promise.resolve()
+				.then(() => {
+					checkStart.call(this);
+
+					assert.argumentIsRequired(portfolio, 'portfolio', String);
+					assert.argumentIsOptional(position, 'position', String);
+
+					return Gateway.invoke(this._readTransactionsEndpoint, { portfolio: portfolio, position: position || '*' });
+				});
+		}
+
+		getTransactionsFormatted(portfolio, position) {
+			return Promise.resolve()
+				.then(() => {
+					checkStart.call(this);
+
+					assert.argumentIsRequired(portfolio, 'portfolio', String);
+					assert.argumentIsOptional(position, 'position', String);
+
+					return Gateway.invoke(this._readTransactionsReportEndpoint, { portfolio: portfolio, position: position || '*' });
+				});
+		}
+
+		/**
+		 * Creates and starts a new {@link PortfolioGateway} for use in the development environment.
+		 *
+		 * @public
+		 * @static
+		 * @param {RequestInterceptor=|Promise.<RequestInterceptor>=} requestInterceptor - A request interceptor used with each request (typically used to inject JWT tokens).
+		 * @returns {Promise.<PortfolioGateway>}
+		 */
+		static forDevelopment(requestInterceptor) {
+			return Promise.resolve(requestInterceptor)
+				.then((requestInterceptor) => {
+					assert.argumentIsOptional(requestInterceptor, 'requestInterceptor', RequestInterceptor, 'RequestInterceptor');
+
+					return start(new PortfolioGateway('https', Configuration.developmentHost, 443, requestInterceptor));
+				});
+		}
+
+		/**
+		 * Creates and starts a new {@link PortfolioGateway} for use in the production environment.
+		 *
+		 * @public
+		 * @static
+		 * @param {RequestInterceptor=|Promise.<RequestInterceptor>=} requestInterceptor - A request interceptor used with each request (typically used to inject JWT tokens).
+		 * @returns {Promise.<PortfolioGateway>}
+		 */
+		static forProduction(requestInterceptor) {
+			return Promise.resolve(requestInterceptor)
+				.then((requestInterceptor) => {
+					assert.argumentIsOptional(requestInterceptor, 'requestInterceptor', RequestInterceptor, 'RequestInterceptor');
+
+					return start(new PortfolioGateway('https', Configuration.productionHost, 443, requestInterceptor));
+				});
+		}
+
+		_onDispose() {
+			return;
+		}
+		
+		toString() {
+			return '[PortfolioGateway]';
+		}
+	}
+
+	const responseInterceptorForPortfolioDeserialization = ResponseInterceptor.fromDelegate((response, ignored) => {
+		return response.data;
+	});
+
+	const responseInterceptorForPositionDeserialization = ResponseInterceptor.fromDelegate((response, ignored) => {
+		return response.data;
+	});
+
+	const responseInterceptorForTransactionDeserialization = ResponseInterceptor.fromDelegate((response, ignored) => {
+		debugger;
+
+		const reviver = TransactionSchema.COMPLETE.schema.getReviver();
+
+		return JSON.parse(response.data, reviver);
+	});
+
+	function start(gateway) {
+		return gateway.start()
+			.then(() => {
+				return gateway;
+			});
+	}
+
+	function checkStart() {
+		if (this.getIsDisposed()) {
+			throw new Error('Unable to use gateway, the gateway has been disposed.');
+		}
+
+		if (!this._started) {
+			throw new Error('Unable to use gateway, the gateway has not started.');
+		}
+	}
+
+ 	return PortfolioGateway;
+})();