@barchart/portfolio-api-common 1.0.165 → 1.0.169

package/lib/processing/PositionContainer.js

@@ -11,7 +11,9 @@ const array = require('@barchart/common-js/lang/array'),
 
 const PositionSummaryFrame = require('./../data/PositionSummaryFrame');
 
-const PositionTreeDefinition = require('./definitions/PositionTreeDefinition');
+const PositionLevelDefinition = require('./definitions/PositionLevelDefinition'),
+	PositionLevelType = require('./definitions/PositionLevelType'),
+	PositionTreeDefinition = require('./definitions/PositionTreeDefinition');
 
 const PositionGroup = require('./PositionGroup'),
 	PositionItem = require('./PositionItem');
@@ -128,10 +130,9 @@ module.exports = (() => {
 			}, { });
 
 			this._currencies = this._items.reduce((map, item) => {
-				const position = item.position;
+				const currency = extractCurrency(item.position);
 
-				if (position.instrument && position.instrument.currency) {
-					const currency = position.instrument.currency;
+				if (currency) {
 					const code = currency.code;
 
 					if (!map.hasOwnProperty(code)) {
@@ -167,6 +168,13 @@ module.exports = (() => {
 			}, { });
 		}
 
+		/**
+		 * Adds a new portfolio to the container, injecting it into aggregation
+		 * trees, as necessary.
+		 *
+		 * @public
+		 * @param {Object} portfolio
+		 */
 		addPortfolio(portfolio) {
 			assert.argumentIsRequired(portfolio, 'portfolio', Object);
 			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
@@ -209,7 +217,7 @@ module.exports = (() => {
 								if (group.definition === parentLevelDefinition) {
 									parentTrees.push(groupTree);
 								}
-							});
+							}, false, false);
 						}
 
 						const overrideRequiredGroups = [ portfolioRequiredGroup ];
@@ -222,8 +230,33 @@ module.exports = (() => {
 			}
 		}
 
+		/**
+		 * Removes an existing portfolio, and all of it's positions, from the container. This
+		 * also triggers removal of the portfolio and it's positions from any applicable
+		 * aggregation trees.
+		 *
+		 * @public
+		 * @param {Object} portfolio
+		 */
 		removePortfolio(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
+
+			this.startTransaction(() => {
+				getPositionItemsForPortfolio(this._items, portfolio.portfolio).forEach(item => removePositionItem.call(this, item));
+
+				delete this._portfolios[portfolio.portfolio];
+
+				Object.keys(this._trees).forEach((key) => {
+					const tree = this._tree[key];
 
+					tree.walk((group, groupNode) => {
+						if (group.definition.type === PositionLevelType.PORTFOLIO && group.key === PositionLevelDefinition.getKeyForPortfolioGroup(portfolio)) {
+							groupNode.sever();
+						}
+					}, true, false);
+				});
+			});
 		}
 
 		mutatePosition(position, summary) {
@@ -231,7 +264,7 @@ module.exports = (() => {
 		}
 
 		removePosition(position) {
-
+			removePositionItem.call(this, this._items.find((item) => item.position.position === position));
 		}
 
 		/**
@@ -314,7 +347,6 @@ module.exports = (() => {
 			assert.argumentIsRequired(quote, 'quote', Object);
 
 			const rate = Rate.fromPair(quote.lastPrice, symbol);
-
 			const index = this._forexQuotes.findIndex(existing => existing.formatPair() === rate.formatPair());
 
 			if (index < 0) {
@@ -409,13 +441,13 @@ module.exports = (() => {
 		}
 
 		/**
-		 * Returns all portfolios in the container
+		 * Returns all portfolios in the container.
 		 *
 		 * @public
 		 * @return {Array.<Object>}
 		 */
 		getPortfolios() {
-			return this._portfolios;
+			return Object.keys(this._portfolios).map(id => this._portfolios[id]);
 		}
 
 		/**
@@ -426,24 +458,42 @@ module.exports = (() => {
 		 * @return {Array.<Object>}
 		 */
 		getPositions(portfolio) {
-			return this._items.reduce((positions, item) => {
-				if (item.position.portfolio === portfolio) {
-					positions.push(item);
-				}
+			assert.argumentIsRequired(portfolio, 'portfolio', String);
 
-				return positions;
-			}, []);
+			return getPositionItemsForPortfolio(this._items, portfolio).map(item => item.position);
 		}
 
-		startTransaction(name, executor) {
-			assert.argumentIsRequired(name, 'name', String);
+		/**
+		 * Pauses aggregation calculations during the processing of an action.
+		 *
+		 * @public
+		 * @param {Function} executor
+		 * @param {String=|Array.<String>=} names
+		 */
+		startTransaction(executor, names) {
+			let namesToUse;
+
+			if (is.array(names)) {
+				assert.argumentIsArray(names, 'names', String);
+
+				namesToUse = names;
+			} else {
+				assert.argumentIsOptional(names, 'names', String);
+
+				if (names) {
+					namesToUse = [ names ];
+				} else {
+					namesToUse = Object.keys(this._trees);
+				}
+			}
+
 			assert.argumentIsRequired(executor, 'executor', Function);
 
-			this._trees[name].walk(group => group.setSuspended(true), false, false);
+			namesToUse.forEach((name) => this._trees[name].walk(group => group.setSuspended(true), false, false));
 
 			executor(this);
 
-			this._trees[name].walk(group => group.setSuspended(false), false, false);
+			namesToUse.forEach((name) => this._trees[name].walk(group => group.setSuspended(false), false, false));
 		}
 
 		toString() {
@@ -475,6 +525,14 @@ module.exports = (() => {
 		}
 	}
 
+	function extractCurrency(position) {
+		if (position.instrument && position.instrument.currency) {
+			return position.instrument.currency;
+		} else {
+			return null;
+		}
+	}
+
 	function addGroupBinding(group, dispoable) {
 		const id = group.id;
 
@@ -604,5 +662,46 @@ module.exports = (() => {
 		});
 	}
 
+	function getPositionItemsForPortfolio(items, portfolio) {
+		return items.reduce((positionItems, item) => {
+			if (item.position.portfolio === portfolio) {
+				positionItems.push(item.position);
+			}
+
+			return positionItems;
+		}, [ ]);
+	}
+
+	function removePositionItem(positionItem) {
+		if (!positionItem) {
+			return;
+		}
+
+		delete this._summariesCurrent[positionItem.position.position];
+		delete this._summariesPrevious[positionItem.position.position];
+
+		array.remove(this._items, i => i === positionItem);
+
+		const barchartSymbol = extractSymbolForBarchart(positionItem.position);
+
+		if (this._symbols.hasOwnProperty(barchartSymbol)) {
+			array.remove(this._symbols[barchartSymbol], i => i === positionItem);
+		}
+
+		const displaySymbol = extractSymbolForDisplay(positionItem.position);
+
+		if (this._symbolsDisplay.hasOwnProperty(displaySymbol)) {
+			array.remove(this._symbols[displaySymbol], i => i === positionItem);
+		}
+
+		const currency = extractCurrency(positionItem.position);
+
+		if (currency && this._currencies.hasOwnProperty(currency.code)) {
+			array.remove(this._currencies[currency.code], i => i === positionItem);
+		}
+
+		positionItem.dispose();
+	}
+
 	return PositionContainer;
 })();

package/lib/processing/PositionGroup.js

@@ -2,6 +2,7 @@ const array = require('@barchart/common-js/lang/array'),
 	assert = require('@barchart/common-js/lang/assert'),
 	Currency = require('@barchart/common-js/lang/Currency'),
 	Decimal = require('@barchart/common-js/lang/Decimal'),
+	Disposable = require('@barchart/common-js/lang/Disposable'),
 	DisposableStack = require('@barchart/common-js/collections/specialized/DisposableStack'),
 	Event = require('@barchart/common-js/messaging/Event'),
 	formatter = require('@barchart/common-js/lang/formatter'),
@@ -149,7 +150,7 @@ module.exports = (() => {
 			this._dataFormat.portfolioType = null;
 
 			this._items.forEach((item) => {
-				this._disposeStack.push(item.registerQuoteChangeHandler((quote, sender) => {
+				const quoteBinding = item.registerQuoteChangeHandler((quote, sender) => {
 					if (this._single) {
 						const precision = sender.position.instrument.currency.precision;
 
@@ -185,18 +186,39 @@ module.exports = (() => {
 					}
 
 					calculatePriceData(this, this._container.getForexQuotes(), sender, false);
-				}));
+				});
+
+				let newsBinding = Disposable.getEmpty();
+				let fundamentalBinding = Disposable.getEmpty();
 
 				if (this._single) {
-					this._disposeStack.push(item.registerNewsExistsChangeHandler((exists, sender) => {
+					newsBinding = item.registerNewsExistsChangeHandler((exists, sender) => {
 						this._dataActual.newsExists = exists;
 						this._dataFormat.newsExists = exists;
-					}));
+					});
 
-					this._disposeStack.push(item.registerFundamentalDataChangeHandler((data, sender) => {
+					fundamentalBinding = item.registerFundamentalDataChangeHandler((data, sender) => {
 						this._dataFormat.fundamental = data;
-					}));
+					});
 				}
+
+				this._disposeStack.push(quoteBinding);
+				this._disposeStack.push(newsBinding);
+				this._disposeStack.push(fundamentalBinding);
+
+				this._disposeStack.push(item.registerPositionItemDisposeHandler(() => {
+					quoteBinding.dispose();
+					newsBinding.dispose();
+					fundamentalBinding.dispose();
+
+					array.remove(this._items, i => i === item);
+					array.remove(this._excludedItems, i => i === item);
+					array.remove(this._consideredItems, i => i === item);
+
+					delete this._excludedItemMap[item.position.position];
+
+					this.refresh();
+				}));
 			});
 
 			this.refresh();
@@ -373,22 +395,35 @@ module.exports = (() => {
 			}
 		}
 
+		/**
+		 * Stops (or starts) group-level aggregation calculations.
+		 *
+		 * @public
+		 * @param {Boolean} value
+		 */
 		setSuspended(value) {
 			assert.argumentIsRequired(value, 'value', Boolean);
 
 			if (this._suspended !== value) {
-				if (this._suspended = value) {
+				this._suspended = value;
+
+				if (!this._suspended) {
 					this.refresh();
 				}
 			}
 		}
 
 		/**
-		 * Causes all aggregated data to be recalculated.
+		 * Causes all aggregated data to be recalculated (assuming the group has not
+		 * been suspended).
 		 *
 		 * @public
 		 */
 		refresh() {
+			if (this._suspended) {
+				return;
+			}
+
 			const rates = this._container.getForexQuotes();
 
 			calculateStaticData(this, rates);

package/lib/processing/PositionItem.js

@@ -2,6 +2,7 @@ const array = require('@barchart/common-js/lang/array'),
 	assert = require('@barchart/common-js/lang/assert'),
 	Currency = require('@barchart/common-js/lang/Currency'),
 	Decimal = require('@barchart/common-js/lang/Decimal'),
+	Disposable = require('@barchart/common-js/lang/Disposable'),
 	Event = require('@barchart/common-js/messaging/Event'),
 	is = require('@barchart/common-js/lang/is');
 
@@ -21,8 +22,10 @@ module.exports = (() => {
 	 * @param {Object} currentSummary
 	 * @param {Array.<Object>} previousSummaries
 	 */
-	class PositionItem {
+	class PositionItem extends Disposable {
 		constructor(portfolio, position, currentSummary, previousSummaries) {
+			super();
+
 			this._portfolio = portfolio;
 			this._position = position;
 			this._currency = position.instrument.currency || Currency.CAD;
@@ -67,6 +70,7 @@ module.exports = (() => {
 			this._quoteChangedEvent = new Event(this);
 			this._newsExistsChangedEvent = new Event(this);
 			this._fundamentalDataChangeEvent = new Event(this);
+			this._positionItemDisposeEvent = new Event(this);
 		}
 
 		/**
@@ -149,6 +153,10 @@ module.exports = (() => {
 		setQuote(quote) {
 			assert.argumentIsRequired(quote, 'quote', Object);
 
+			if (this.getIsDisposed()) {
+				return;
+			}
+
 			if (this._currentPricePrevious !== quote.lastPrice) {
 				calculatePriceData(this, quote.lastPrice);
 
@@ -170,6 +178,10 @@ module.exports = (() => {
 		setPositionFundamentalData(data) {
 			assert.argumentIsRequired(data, 'data', Object);
 
+			if (this.getIsDisposed()) {
+				return;
+			}
+
 			this._fundamentalDataChangeEvent.fire(this._data.fundamental = data);
 		}
 
@@ -183,6 +195,10 @@ module.exports = (() => {
 		setNewsArticleExists(value) {
 			assert.argumentIsRequired(value, 'value', Boolean);
 
+			if (this.getIsDisposed()) {
+				return;
+			}
+
 			if (this._data.newsExists !== value) {
 				this._newsExistsChangedEvent.fire(this._data.newsExists = value);
 			}
@@ -222,6 +238,26 @@ module.exports = (() => {
 			return this._newsExistsChangedEvent.register(handler);
 		}
 
+		/**
+		 * Registers an observer for object disposal.
+		 *
+		 * @public
+		 * @param {Function} handler
+		 * @returns {Disposable}
+		 */
+		registerPositionItemDisposeHandler(handler) {
+			return this._positionItemDisposeEvent.register(handler);
+		}
+
+		_onDispose() {
+			this._positionItemDisposeEvent.fire(this);
+
+			this._quoteChangedEvent.clear();
+			this._newsExistsChangedEvent.clear();
+			this._fundamentalDataChangeEvent.clear();
+			this._positionItemDisposeEvent.clear();
+		}
+
 		toString() {
 			return '[PositionItem]';
 		}

package/lib/processing/definitions/PositionLevelDefinition.js

@@ -4,6 +4,8 @@ const assert = require('@barchart/common-js/lang/assert'),
 
 const InstrumentType = require('./../../data/InstrumentType');
 
+const PositionLevelType = require('./PositionLevelType');
+
 module.exports = (() => {
 	'use strict';
 
@@ -20,11 +22,12 @@ module.exports = (() => {
 	 * @param {Array.<PositionLevelDefinition~RequiredGroup>=} requiredGroups
 	 * @param {Boolean=} single
 	 * @param {Boolean=} aggregateCash
-	 * @param {Function=} injectPositions
+	 * @param {Function=} requiredGroupGenerator
 	 */
 	class PositionLevelDefinition {
-		constructor(name, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash, requiredGroupGenerator) {
+		constructor(name, type, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash, requiredGroupGenerator) {
 			assert.argumentIsRequired(name, 'name', String);
+			assert.argumentIsRequired(type, 'type', PositionLevelType, 'PositionLevelType');
 			assert.argumentIsRequired(keySelector, 'keySelector', Function);
 			assert.argumentIsRequired(descriptionSelector, 'descriptionSelector', Function);
 			assert.argumentIsRequired(currencySelector, 'currencySelector', Function);
@@ -38,6 +41,7 @@ module.exports = (() => {
 			assert.argumentIsOptional(requiredGroupGenerator, 'requiredGroupGenerator', Function);
 
 			this._name = name;
+			this._type = type;
 
 			this._keySelector = keySelector;
 			this._descriptionSelector = descriptionSelector;
@@ -61,6 +65,16 @@ module.exports = (() => {
 			return this._name;
 		}
 
+		/**
+		 * A general description of the type of items grouped together.
+		 *
+		 * @public
+		 * @return {PositionLevelType}
+		 */
+		get type() {
+			return this._type;
+		}
+
 		/**
 		 * A function, when given a {@link PositionItem} returns a string that is used
 		 * to group {@link PositionItem} instances into different groups.

package/lib/processing/definitions/PositionLevelType.js

@@ -0,0 +1,29 @@
+const Enum = require('@barchart/common-js/lang/Enum');
+
+module.exports = (() => {
+	'use strict';
+
+	class PositionLevelType extends Enum {
+		constructor(code) {
+			super(code, code);
+		}
+
+		static get PORTFOLIO() {
+			return portfolio;
+		}
+
+		static get POSITION() {
+			return position;
+		}
+
+		static get OTHER() {
+			return other;
+		}
+	}
+
+	const portfolio = new PositionLevelType('PORTFOLIO');
+	const position = new PositionLevelType('POSITION');
+	const other = new PositionLevelType('OTHER');
+
+	return PositionLevelType;
+})();

package/package.json

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