@barchart/portfolio-api-common 1.0.37 → 1.0.42

package/lib/data/InstrumentType.js

@@ -10,16 +10,22 @@ module.exports = (() => {
 	 * @public
 	 * @extends {Enum}
 	 * @param {String} description
+	 * @param {String} alternateDescription
 	 * @param {String} code
 	 * @param {Boolean} canReinvest
 	 */
 	class InstrumentType extends Enum {
-		constructor(code, description, canReinvest) {
+		constructor(code, description, alternateDescription, canReinvest) {
 			super(code, description);
 
+			this._alternateDescription = alternateDescription;
 			this._canReinvest = canReinvest;
 		}
 
+		get alternateDescription() {
+			return this._alternateDescription;
+		}
+
 		/**
 		 * Indicates if the instrument type allows automatic reinvestment.
 		 *
@@ -74,10 +80,10 @@ module.exports = (() => {
 		}
 	}
 
-	const cash = new InstrumentType('CASH', 'cash', false);
-	const equity = new InstrumentType('EQUITY', 'equity', true);
-	const fund = new InstrumentType('FUND', 'mutual fund', true);
-	const other = new InstrumentType('OTHER', 'other', false);
+	const cash = new InstrumentType('CASH', 'cash', 'Cash', false);
+	const equity = new InstrumentType('EQUITY', 'equity', 'Equities', true);
+	const fund = new InstrumentType('FUND', 'mutual fund', 'Funds', true);
+	const other = new InstrumentType('OTHER', 'other', 'Other', false);
 
 	return InstrumentType;
 })();

package/lib/processing/PositionContainer.js

@@ -0,0 +1,137 @@
+const array = require('@barchart/common-js/lang/array'),
+	assert = require('@barchart/common-js/lang/assert'),
+	is = require('@barchart/common-js/lang/is'),
+	Tree = require('@barchart/common-js/collections/Tree');
+
+const PositionGroup = require('./PositionGroup'),
+	PositionGroupDefinition = require('./PositionGroupDefinition'),
+	PositionItem = require('./PositionItem');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * @public
+	 */
+	class PositionContainer {
+		constructor(portfolios, positions, summaries, definitions) {
+			this._portfolios = portfolios.reduce((map, portfolio) => {
+				map[portfolio.portfolio] = portfolio;
+
+				return map;
+			}, { });
+
+			this._summaries = summaries.reduce((map, summary) => {
+				const key = summary.position;
+
+				if (!map.hasOwnProperty(key)) {
+					map[key] = [ ];
+				}
+
+				map[key].push(summary);
+
+				return map;
+			}, { });
+
+			this._items = positions.reduce((items, position) => {
+				const portfolio = this._portfolios[position.portfolio];
+
+				if (position) {
+					const summaries = this._summaries[position.position] || [ ];
+
+					items.push(new PositionItem(portfolio, position, summaries));
+				}
+
+				return items;
+			}, [ ]);
+
+			this._symbols = this._items.reduce((map, item) => {
+				let position = item.position;
+				let symbol = null;
+
+				if (position.instrument && position.instrument.symbol && position.instrument.barchart) {
+					symbol = position.instrument.barchart;
+
+					if (!map.hasOwnProperty(symbol)) {
+						map[symbol] = [ ];
+					}
+
+					map[symbol].push(item);
+				}
+
+				return map;
+			}, { });
+
+			this._definitions = definitions || [ new PositionGroupDefinition('Totals', i => true, i => 'Totals', [ 'Totals' ]) ];
+
+			this._tree = new Tree();
+
+			const createGroups = (tree, items, definitions) => {
+				if (definitions.length === 0) {
+					return;
+				}
+
+				const currentDefinition = definitions[0];
+				const additionalDefinitions = array.dropLeft(definitions);
+
+				const populatedGroups = array.batchBy(items, currentDefinition.keySelector).map((items) => {
+					const first = items[0];
+
+					return new PositionGroup(items, currentDefinition.descriptionSelector(first), currentDefinition.single && items.length === 1);
+				});
+
+				const missingGroups = array.difference(currentDefinition.requiredGroups, populatedGroups.map(group => group.description));
+
+				const empty = missingGroups.map((description) => {
+					return new PositionGroup(description, [ ]);
+				});
+
+				const compositeGroups = populatedGroups.concat(empty);
+
+				compositeGroups.forEach((group) => {
+					const child = tree.addChild(group);
+
+					createGroups(child, group.items, additionalDefinitions);
+				});
+			};
+
+			createGroups(this._tree, this._items, this._definitions);
+		}
+
+		getSymbols() {
+			return Object.keys(this._symbols);
+		}
+
+		setPrice(symbol, price) {
+			if (this._symbols.hasOwnProperty(symbol)) {
+				this._symbols.forEach(item.setPrice(price));
+			}
+		}
+
+		getGroup(keys) {
+			const node = keys.reduce((tree, key) => {
+				tree = tree.findChild((group) => group.description === key);
+
+				return tree;
+			}, this._tree);
+
+			return node.getValue();
+		}
+
+		getGroups(keys) {
+			const node = keys.reduce((tree, key) => {
+				tree = tree.findChild((group) => group.description === key);
+
+				return tree;
+			}, this._tree);
+
+			return node.getChildren().map((node) => node.getValue());
+		}
+
+		toString() {
+			return '[PositionContainer]';
+		}
+	}
+
+	return PositionContainer;
+})();

package/lib/processing/PositionGroup.js

@@ -0,0 +1,95 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Decimal = require('@barchart/common-js/lang/Decimal'),
+	is = require('@barchart/common-js/lang/is');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * @public
+	 */
+	class PositionGroup {
+		constructor(items, description, single) {
+			this._description = description;
+			this._items = items;
+
+			this._single = is.boolean(single) && single;
+
+			this._data = { };
+
+			this._data.description = this._description;
+
+			this._data.current = null;
+			this._data.previous = null;
+
+			this._data.basis = null;
+			this._data.market = null;
+
+			this._items.forEach((item) => {
+				item.registerPriceChangeHandler((data, sender) => {
+					if (this._single) {
+						data.current = data.current;
+					} else {
+						data.current = null;
+					}
+
+					calculateVariablePriceData(this, item, price);
+				});
+			});
+
+			calculateStaticData(this);
+		}
+
+		get description() {
+			return this._description;
+		}
+
+		get data() {
+			return this._data;
+		}
+
+		get items() {
+			return this._items;
+		}
+
+		get single() {
+			return this._single;
+		}
+
+		toString() {
+			return '[PositionGroup]';
+		}
+	}
+
+	function calculateStaticData(group) {
+		const items = group._items;
+		const data = group._data;
+
+		let updates;
+
+		if (group.single) {
+			const item = items[0];
+
+			updates.basis = item.basis;
+		} else {
+			updates = items.reduce(function(updates, item) {
+				const position = item.position;
+				const snapshot = item.position.snapshot;
+
+				updates.value = updates.basis.add(snapshot.basis);
+
+				return updates;
+			}, {
+				basis: Decimal.ZERO
+			});
+		}
+
+		data.basis = updates.basis;
+	}
+
+	function calculateVariablePriceData(group, item, price) {
+
+	}
+
+	return PositionGroup;
+})();

package/lib/processing/PositionGroupDefinition.js

@@ -0,0 +1,43 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	is = require('@barchart/common-js/lang/is');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * @public
+	 */
+	class PositionGroupDefinition {
+		constructor(name, keySelector, descriptionSelector, requiredGroups, single) {
+			this._name = name;
+
+			this._keySelector = keySelector;
+			this._descriptionSelector = descriptionSelector;
+
+			this._requiredGroups = requiredGroups || [ ];
+			this._single = is.boolean(single) && single;
+		}
+
+		get name() {
+			return this._name;
+		}
+
+		get keySelector() {
+			return this._keySelector;
+		}
+
+		get descriptionSelector() {
+			return this._descriptionSelector;
+		}
+
+		get requiredGroups() {
+			return this._requiredGroups;
+		}
+
+		toString() {
+			return '[PositionGroupDefinition]';
+		}
+	}
+
+	return PositionGroupDefinition;
+})();

package/lib/processing/PositionItem.js

@@ -0,0 +1,57 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	Event = require('@barchart/common-js/messaging/Event'),
+	is = require('@barchart/common-js/lang/is');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * @public
+	 */
+	class PositionItem {
+		constructor(portfolio, position, summaries) {
+			this._portfolio = portfolio;
+			this._position = position;
+			this._summaries = summaries || [ ];
+
+			this._data = { };
+
+			this._data.current = null;
+			this._data.previous = position.previous || null;
+
+			this._priceChangeEvent = new Event(this);
+		}
+
+		get portfolio() {
+			return this._portfolio;
+		}
+
+		get position() {
+			return this._position;
+		}
+
+		get summaries() {
+			return this._summaries;
+		}
+
+		setPrice(price) {
+			if (this._data.price !== price) {
+				this._data.price = price;
+
+				this._priceChangeEvent.fire(this._data);
+			}
+		}
+
+		registerPriceChangeHandler(handler) {
+			assert.argumentIsRequired(handler, 'handler', Function);
+
+			this._priceChangeEvent.register(handler);
+		}
+
+		toString() {
+			return '[PositionItem]';
+		}
+	}
+
+	return PositionItem;
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barchart/portfolio-api-common",
-  "version": "1.0.37",
+  "version": "1.0.42",
   "description": "Common classes used by the Portfolio system",
   "author": {
     "name": "Bryan Ingle",