@barchart/portfolio-api-common 1.0.159 → 1.0.163

package/lib/processing/PositionContainer.js

@@ -48,17 +48,9 @@ module.exports = (() => {
 			const currentSummaryFrame = PositionSummaryFrame.YTD;
 			const currentSummaryRange = array.last(currentSummaryFrame.getRecentRanges(0));
 
-			this._groupBindings = { };
-
-			const addGroupBinding = (group, dispoable) => {
-				const id = group.id;
-
-				if (!this._groupBindings.hasOwnProperty(id)) {
-					this._groupBindings[id] = new DisposableStack();
-				}
+			this._definitions = definitions;
 
-				this._groupBindings[id].push(dispoable);
-			};
+			this._groupBindings = { };
 
 			this._portfolios = portfolios.reduce((map, portfolio) => {
 				map[portfolio.portfolio] = portfolio;
@@ -164,132 +156,51 @@ module.exports = (() => {
 				return Rate.fromPair(Decimal.ONE, symbol);
 			});
 			
-			this._trees = definitions.reduce((map, treeDefinition) => {
+			this._trees = this._definitions.reduce((map, treeDefinition) => {
 				const tree = new Tree();
 
-				const createGroups = (currentTree, items, levelDefinitions) => {
-					if (levelDefinitions.length === 0) {
-						return;
-					}
-
-					const parent = currentTree.getValue() || null;
-
-					const levelDefinition = levelDefinitions[0];
-
-					const populatedObjects = array.groupBy(items, levelDefinition.keySelector);
-					const populatedGroups = Object.keys(populatedObjects).reduce((list, key) => {
-						const items = populatedObjects[key];
-						const first = items[0];
-
-						list.push(new PositionGroup(this, parent, items, levelDefinition.currencySelector(first), key, levelDefinition.descriptionSelector(first), levelDefinition.single && items.length === 1, levelDefinition.aggregateCash));
-
-						return list;
-					}, [ ]);
-
-					const missingGroups = array.difference(levelDefinition.requiredGroups.map(group => group.key), populatedGroups.map(group => group.key))
-						.map((key) => {
-							return levelDefinition.requiredGroups.find(g => g.key === key);
-						});
+				createGroups.call(this, tree, tree, this._items, treeDefinition, treeDefinition.definitions);
+				
+				map[treeDefinition.name] = tree;
 
-					const empty = missingGroups.map((group) => {
-						return new PositionGroup(this, parent, [ ], group.currency, group.key, group.description);
-					});
+				return map;
+			}, { });
+		}
 
-					const compositeGroups = populatedGroups.concat(empty);
+		addPortfolio(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
+			assert.argumentIsRequired(portfolio.name, 'portfolio.name', String);
 
-					let builder;
+			const key = portfolio.portfolio;
 
-					if (levelDefinition.requiredGroups.length !== 0) {
-						const ordering = levelDefinition.requiredGroups.reduce((map, group, index) => {
-							map[group.description] = index;
+			if (!this._portfolios.hasOwnProperty(key)) {
+				this._portfolios[key] = portfolio;
 
-							return map;
-						}, { });
+				this._definitions.forEach((treeDefinition) => {
+					const tree = this._trees[treeDefinition.name];
 
-						const getIndex = (description) => {
-							if (ordering.hasOwnProperty(description)) {
-								return ordering[description];
-							} else {
-								return Number.MAX_VALUE;
-							}
-						};
+					treeDefinition.definitions.forEach((levelDefinition) => {
+						const requiredGroup = levelDefinition.generateRequiredGroup(portfolio);
 
-						builder = ComparatorBuilder.startWith((a, b) => {
-							return comparators.compareNumbers(getIndex(a.description), getIndex(b.description));
-						}).thenBy((a, b) => {
-							return comparators.compareStrings(a.description, b.description);
-						});
-					} else {
-						builder = ComparatorBuilder.startWith((a, b) => {
-							return comparators.compareStrings(a.description, b.description);
-						});
-					}
+						if (requiredGroup !== null) {
 
-					compositeGroups.sort(builder.toComparator());
-
-					const initializeGroupObservers = (group, groupTree) => {
-						addGroupBinding(group, group.registerGroupExcludedChangeHandler((excluded, sender) => {
-							groupTree.climb((parentGroup) => {
-								if (parentGroup) {
-									let excludedItems = [];
-
-									currentTree.walk((childGroup) => {
-										if (childGroup.excluded) {
-											excludedItems = excludedItems.concat(childGroup.items);
-										}
-									}, false, false);
-
-									parentGroup.setExcludedItems(array.unique(excludedItems));
-								}
-							}, false);
-
-							if (treeDefinition.exclusionDependencies.length > 0) {
-								const dependantTrees = treeDefinition.exclusionDependencies.reduce((trees, name) => {
-									if (this._trees.hasOwnProperty(name)) {
-										trees.push(this._trees[name]);
-									}
-
-									return trees;
-								}, [ ]);
-
-								if (dependantTrees.length > 0) {
-									let excludedItems = [ ];
-
-									tree.walk((childGroup) => {
-										if (childGroup.excluded) {
-											excludedItems = excludedItems.concat(childGroup.items);
-										}
-									}, false, false);
-
-									dependantTrees.forEach((dependantTrees) => {
-										dependantTrees.walk((childGroup) => {
-											childGroup.setExcludedItems(excludedItems);
-										}, false, false);
-									});
-								}
-							}
-						}));
-					};
+						}
+					});
+				});
+			}
+		}
 
-					compositeGroups.forEach((group) => {
-						const childTree = currentTree.addChild(group);
+		removePortfolio(portfolio) {
 
-						initializeGroupObservers(group, childTree);
+		}
 
-						addGroupBinding(group, group.registerMarketPercentChangeHandler(() => {
-							currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
-						}));
+		mutatePosition(position, summary) {
 
-						createGroups(childTree, group.items, array.dropLeft(levelDefinitions));
-					});
-				};
+		}
 
-				createGroups(tree, this._items, treeDefinition.definitions);
-				
-				map[treeDefinition.name] = tree;
+		removePosition(position) {
 
-				return map;
-			}, { });
 		}
 
 		/**
@@ -523,5 +434,132 @@ module.exports = (() => {
 		}
 	}
 
+	function addGroupBinding(group, dispoable) {
+		const id = group.id;
+
+		if (!this._groupBindings.hasOwnProperty(id)) {
+			this._groupBindings[id] = new DisposableStack();
+		}
+
+		this._groupBindings[id].push(dispoable);
+	}
+
+	function createGroups(parentTree, currentTree, items, treeDefinition, levelDefinitions) {
+		if (levelDefinitions.length === 0) {
+			return;
+		}
+
+		const parent = currentTree.getValue() || null;
+
+		const levelDefinition = levelDefinitions[0];
+
+		const populatedObjects = array.groupBy(items, levelDefinition.keySelector);
+		const populatedGroups = Object.keys(populatedObjects).reduce((list, key) => {
+			const items = populatedObjects[key];
+			const first = items[0];
+
+			list.push(new PositionGroup(this, parent, items, levelDefinition.currencySelector(first), key, levelDefinition.descriptionSelector(first), levelDefinition.single && items.length === 1, levelDefinition.aggregateCash));
+
+			return list;
+		}, [ ]);
+
+		const missingGroups = array.difference(levelDefinition.requiredGroups.map(group => group.key), populatedGroups.map(group => group.key))
+			.map((key) => {
+				return levelDefinition.requiredGroups.find(g => g.key === key);
+			});
+
+		const empty = missingGroups.map((group) => {
+			return new PositionGroup(this, parent, [ ], group.currency, group.key, group.description);
+		});
+
+		const compositeGroups = populatedGroups.concat(empty);
+
+		let builder;
+
+		if (levelDefinition.requiredGroups.length !== 0) {
+			const ordering = levelDefinition.requiredGroups.reduce((map, group, index) => {
+				map[group.description] = index;
+
+				return map;
+			}, { });
+
+			const getIndex = (description) => {
+				if (ordering.hasOwnProperty(description)) {
+					return ordering[description];
+				} else {
+					return Number.MAX_VALUE;
+				}
+			};
+
+			builder = ComparatorBuilder.startWith((a, b) => {
+				return comparators.compareNumbers(getIndex(a.description), getIndex(b.description));
+			}).thenBy((a, b) => {
+				return comparators.compareStrings(a.description, b.description);
+			});
+		} else {
+			builder = ComparatorBuilder.startWith((a, b) => {
+				return comparators.compareStrings(a.description, b.description);
+			});
+		}
+
+		compositeGroups.sort(builder.toComparator());
+
+		const initializeGroupObservers = (group, groupTree) => {
+			addGroupBinding.call(this, group, group.registerGroupExcludedChangeHandler((excluded, sender) => {
+				groupTree.climb((parentGroup) => {
+					if (parentGroup) {
+						let excludedItems = [];
+
+						currentTree.walk((childGroup) => {
+							if (childGroup.excluded) {
+								excludedItems = excludedItems.concat(childGroup.items);
+							}
+						}, false, false);
+
+						parentGroup.setExcludedItems(array.unique(excludedItems));
+					}
+				}, false);
+
+				if (treeDefinition.exclusionDependencies.length > 0) {
+					const dependantTrees = treeDefinition.exclusionDependencies.reduce((trees, name) => {
+						if (this._trees.hasOwnProperty(name)) {
+							trees.push(this._trees[name]);
+						}
+
+						return trees;
+					}, [ ]);
+
+					if (dependantTrees.length > 0) {
+						let excludedItems = [ ];
+
+						parentTree.walk((childGroup) => {
+							if (childGroup.excluded) {
+								excludedItems = excludedItems.concat(childGroup.items);
+							}
+						}, false, false);
+
+						dependantTrees.forEach((dependantTrees) => {
+							dependantTrees.walk((childGroup) => {
+								childGroup.setExcludedItems(excludedItems);
+							}, false, false);
+						});
+					}
+				}
+			}));
+		};
+
+		compositeGroups.forEach((group) => {
+			const childTree = currentTree.addChild(group);
+
+			initializeGroupObservers(group, childTree);
+
+			addGroupBinding.call(this, group, group.registerMarketPercentChangeHandler(() => {
+				currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
+			}));
+
+			createGroups.call(this, parentTree, childTree, group.items, treeDefinition, array.dropLeft(levelDefinitions));
+		});
+	}
+
 	return PositionContainer;
 })();

package/lib/processing/PositionGroup.js

@@ -171,8 +171,8 @@ module.exports = (() => {
 						this._dataFormat.quoteTime = this._dataActual.quoteTime;
 						this._dataFormat.quoteVolume = formatNumber(this._dataActual.quoteVolume, 0);
 
-						const quoteChangePositive = is.number(this._dataActual.quoteChange) && this._dataActual.quoteChange > 0;
-						const quoteChangeNegative = is.number(this._dataActual.quoteChange) && this._dataActual.quoteChange < 0;
+						const quoteChangePositive = quote.lastPriceDirection === 'up';
+						const quoteChangeNegative = quote.lastPriceDirection === 'down';
 
 						setTimeout(() => this._dataFormat.quoteChangeDirection = { up: quoteChangePositive, down: quoteChangeNegative }, 0);
 						this._dataFormat.quoteChangeNegative = quoteChangeNegative;
@@ -294,6 +294,16 @@ module.exports = (() => {
 			return this._excluded;
 		}
 
+		addItems(items) {
+
+			this.refresh();
+		}
+
+		removeItems(items) {
+
+			this.refresh();
+		}
+
 		/**
 		 * Sets the list of items which are excluded from group aggregation calculations.
 		 *

package/lib/processing/definitions/PositionLevelDefinition.js

@@ -1,6 +1,9 @@
 const assert = require('@barchart/common-js/lang/assert'),
+	Currency = require('@barchart/common-js/lang/Currency'),
 	is = require('@barchart/common-js/lang/is');
 
+const InstrumentType = require('./../../data/InstrumentType');
+
 module.exports = (() => {
 	'use strict';
 
@@ -15,12 +18,12 @@ module.exports = (() => {
 	 * @param {PositionLevelDefinition~descriptionSelector} descriptionSelector
 	 * @param {PositionLevelDefinition~currencySelector} currencySelector
 	 * @param {Array.<PositionLevelDefinition~RequiredGroup>=} requiredGroups
-	 * @param {Array.<PositionLevelDefinition~RequiredGroup>=} requiredGroups
 	 * @param {Boolean=} single
 	 * @param {Boolean=} aggregateCash
+	 * @param {Function=} injectPositions
 	 */
 	class PositionLevelDefinition {
-		constructor(name, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash) {
+		constructor(name, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash, requiredGroupGenerator) {
 			assert.argumentIsRequired(name, 'name', String);
 			assert.argumentIsRequired(keySelector, 'keySelector', Function);
 			assert.argumentIsRequired(descriptionSelector, 'descriptionSelector', Function);
@@ -32,6 +35,7 @@ module.exports = (() => {
 
 			assert.argumentIsOptional(single, 'single', Boolean);
 			assert.argumentIsOptional(aggregateCash, 'aggregateCash', Boolean);
+			assert.argumentIsOptional(requiredGroupGenerator, 'requiredGroupGenerator', Function);
 
 			this._name = name;
 
@@ -40,8 +44,11 @@ module.exports = (() => {
 			this._currencySelector = currencySelector;
 
 			this._requiredGroups = requiredGroups || [ ];
+
 			this._single = is.boolean(single) && single;
 			this._aggregateCash = is.boolean(aggregateCash) && aggregateCash;
+
+			this._requiredGroupGenerator = requiredGroupGenerator || (input => null);
 		}
 
 		/**
@@ -118,6 +125,96 @@ module.exports = (() => {
 			return this._aggregateCash;
 		}
 
+		/**
+		 * Given an input, potentially creates a new {@link PositionLevelDefinition~RequiredGroup}.
+		 *
+		 * @public
+		 * @param {*} input
+		 * @returns {PositionLevelDefinition~RequiredGroup|null}
+		 */
+		generateRequiredGroup(input) {
+			const requiredGroup = this._requiredGroupGenerator(input);
+
+			if (requiredGroup !== null) {
+				this._requiredGroups.push(requiredGroup);
+			}
+
+			return requiredGroup;
+		}
+
+		/**
+		 * Builds a {@link PositionLevelDefinition~RequiredGroup} for a portfolio.
+		 *
+		 * @public
+		 * @static
+		 * @param {Object} portfolio
+		 * @return {PositionLevelDefinition~RequiredGroup}
+		 */
+		static buildRequiredGroupForPortfolio(portfolio) {
+			return {
+				key: PositionLevelDefinition.getKeyForPortfolioGroup(portfolio),
+				description: PositionLevelDefinition.getDescriptionForPortfolioGroup(portfolio),
+				currency: Currency.CAD
+			};
+		}
+
+		static getKeyForPortfolioGroup(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+
+			return portfolio.portfolio;
+		}
+
+		static getDescriptionForPortfolioGroup(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+
+			return portfolio.name;
+		}
+
+		static getRequiredGroupGeneratorForPortfolio() {
+			return (portfolio) => {
+				let requiredGroup;
+
+				if (is.object(portfolio) && is.string(portfolio.portfolio) && is.string(portfolio.name)) {
+					requiredGroup = PositionLevelDefinition.buildRequiredGroupForPortfolio(portfolio);
+				} else {
+					requiredGroup = null;
+				}
+
+				return requiredGroup;
+			};
+		}
+
+		/**
+		 * Builds a {@link PositionLevelDefinition~RequiredGroup} for an asset class.
+		 *
+		 * @public
+		 * @static
+		 * @param {InstrumentType} type
+		 * @param {Currency} currency
+		 * @return {PositionLevelDefinition~RequiredGroup}
+		 */
+		static buildRequiredGroupForAssetClass(type, currency) {
+			return {
+				key: PositionLevelDefinition.getKeyForAssetClassGroup(type, currency),
+				description: PositionLevelDefinition.getDescriptionForAssetClassGroup(type, currency),
+				currency: currency
+			};
+		}
+
+		static getKeyForAssetClassGroup(type, currency) {
+			assert.argumentIsRequired(type, 'type', InstrumentType, 'InstrumentType');
+			assert.argumentIsRequired(currency, 'currency', Currency, 'Currency');
+
+			return `${type.code}|${currency.code}`;
+		}
+
+		static getDescriptionForAssetClassGroup(type, currency) {
+			assert.argumentIsRequired(type, 'type', InstrumentType, 'InstrumentType');
+			assert.argumentIsRequired(currency, 'currency', Currency, 'Currency');
+
+			return `${type.alternateDescription}${currency.code === 'CAD' ? '' : ` (${currency.alternateDescription})`}`;
+		}
+
 		toString() {
 			return '[PositionLevelDefinition]';
 		}

package/package.json

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

package/test/SpecRunner.js

@@ -764,17 +764,9 @@ module.exports = (() => {
 			const currentSummaryFrame = PositionSummaryFrame.YTD;
 			const currentSummaryRange = array.last(currentSummaryFrame.getRecentRanges(0));
 
-			this._groupBindings = { };
-
-			const addGroupBinding = (group, dispoable) => {
-				const id = group.id;
-
-				if (!this._groupBindings.hasOwnProperty(id)) {
-					this._groupBindings[id] = new DisposableStack();
-				}
+			this._definitions = definitions;
 
-				this._groupBindings[id].push(dispoable);
-			};
+			this._groupBindings = { };
 
 			this._portfolios = portfolios.reduce((map, portfolio) => {
 				map[portfolio.portfolio] = portfolio;
@@ -880,132 +872,51 @@ module.exports = (() => {
 				return Rate.fromPair(Decimal.ONE, symbol);
 			});
 			
-			this._trees = definitions.reduce((map, treeDefinition) => {
+			this._trees = this._definitions.reduce((map, treeDefinition) => {
 				const tree = new Tree();
 
-				const createGroups = (currentTree, items, levelDefinitions) => {
-					if (levelDefinitions.length === 0) {
-						return;
-					}
-
-					const parent = currentTree.getValue() || null;
-
-					const levelDefinition = levelDefinitions[0];
-
-					const populatedObjects = array.groupBy(items, levelDefinition.keySelector);
-					const populatedGroups = Object.keys(populatedObjects).reduce((list, key) => {
-						const items = populatedObjects[key];
-						const first = items[0];
-
-						list.push(new PositionGroup(this, parent, items, levelDefinition.currencySelector(first), key, levelDefinition.descriptionSelector(first), levelDefinition.single && items.length === 1, levelDefinition.aggregateCash));
-
-						return list;
-					}, [ ]);
+				createGroups.call(this, tree, tree, this._items, treeDefinition, treeDefinition.definitions);
+				
+				map[treeDefinition.name] = tree;
 
-					const missingGroups = array.difference(levelDefinition.requiredGroups.map(group => group.key), populatedGroups.map(group => group.key))
-						.map((key) => {
-							return levelDefinition.requiredGroups.find(g => g.key === key);
-						});
+				return map;
+			}, { });
+		}
 
-					const empty = missingGroups.map((group) => {
-						return new PositionGroup(this, parent, [ ], group.currency, group.key, group.description);
-					});
+		addPortfolio(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
+			assert.argumentIsRequired(portfolio.name, 'portfolio.name', String);
 
-					const compositeGroups = populatedGroups.concat(empty);
+			const key = portfolio.portfolio;
 
-					let builder;
+			if (!this._portfolios.hasOwnProperty(key)) {
+				this._portfolios[key] = portfolio;
 
-					if (levelDefinition.requiredGroups.length !== 0) {
-						const ordering = levelDefinition.requiredGroups.reduce((map, group, index) => {
-							map[group.description] = index;
+				this._definitions.forEach((treeDefinition) => {
+					const tree = this._trees[treeDefinition.name];
 
-							return map;
-						}, { });
+					treeDefinition.definitions.forEach((levelDefinition) => {
+						const requiredGroup = levelDefinition.generateRequiredGroup(portfolio);
 
-						const getIndex = (description) => {
-							if (ordering.hasOwnProperty(description)) {
-								return ordering[description];
-							} else {
-								return Number.MAX_VALUE;
-							}
-						};
+						if (requiredGroup !== null) {
 
-						builder = ComparatorBuilder.startWith((a, b) => {
-							return comparators.compareNumbers(getIndex(a.description), getIndex(b.description));
-						}).thenBy((a, b) => {
-							return comparators.compareStrings(a.description, b.description);
-						});
-					} else {
-						builder = ComparatorBuilder.startWith((a, b) => {
-							return comparators.compareStrings(a.description, b.description);
-						});
-					}
+						}
+					});
+				});
+			}
+		}
 
-					compositeGroups.sort(builder.toComparator());
-
-					const initializeGroupObservers = (group, groupTree) => {
-						addGroupBinding(group, group.registerGroupExcludedChangeHandler((excluded, sender) => {
-							groupTree.climb((parentGroup) => {
-								if (parentGroup) {
-									let excludedItems = [];
-
-									currentTree.walk((childGroup) => {
-										if (childGroup.excluded) {
-											excludedItems = excludedItems.concat(childGroup.items);
-										}
-									}, false, false);
-
-									parentGroup.setExcludedItems(array.unique(excludedItems));
-								}
-							}, false);
-
-							if (treeDefinition.exclusionDependencies.length > 0) {
-								const dependantTrees = treeDefinition.exclusionDependencies.reduce((trees, name) => {
-									if (this._trees.hasOwnProperty(name)) {
-										trees.push(this._trees[name]);
-									}
-
-									return trees;
-								}, [ ]);
-
-								if (dependantTrees.length > 0) {
-									let excludedItems = [ ];
-
-									tree.walk((childGroup) => {
-										if (childGroup.excluded) {
-											excludedItems = excludedItems.concat(childGroup.items);
-										}
-									}, false, false);
-
-									dependantTrees.forEach((dependantTrees) => {
-										dependantTrees.walk((childGroup) => {
-											childGroup.setExcludedItems(excludedItems);
-										}, false, false);
-									});
-								}
-							}
-						}));
-					};
+		removePortfolio(portfolio) {
 
-					compositeGroups.forEach((group) => {
-						const childTree = currentTree.addChild(group);
+		}
 
-						initializeGroupObservers(group, childTree);
+		mutatePosition(position, summary) {
 
-						addGroupBinding(group, group.registerMarketPercentChangeHandler(() => {
-							currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
-						}));
+		}
 
-						createGroups(childTree, group.items, array.dropLeft(levelDefinitions));
-					});
-				};
+		removePosition(position) {
 
-				createGroups(tree, this._items, treeDefinition.definitions);
-				
-				map[treeDefinition.name] = tree;
-
-				return map;
-			}, { });
 		}
 
 		/**
@@ -1239,6 +1150,133 @@ module.exports = (() => {
 		}
 	}
 
+	function addGroupBinding(group, dispoable) {
+		const id = group.id;
+
+		if (!this._groupBindings.hasOwnProperty(id)) {
+			this._groupBindings[id] = new DisposableStack();
+		}
+
+		this._groupBindings[id].push(dispoable);
+	}
+
+	function createGroups(parentTree, currentTree, items, treeDefinition, levelDefinitions) {
+		if (levelDefinitions.length === 0) {
+			return;
+		}
+
+		const parent = currentTree.getValue() || null;
+
+		const levelDefinition = levelDefinitions[0];
+
+		const populatedObjects = array.groupBy(items, levelDefinition.keySelector);
+		const populatedGroups = Object.keys(populatedObjects).reduce((list, key) => {
+			const items = populatedObjects[key];
+			const first = items[0];
+
+			list.push(new PositionGroup(this, parent, items, levelDefinition.currencySelector(first), key, levelDefinition.descriptionSelector(first), levelDefinition.single && items.length === 1, levelDefinition.aggregateCash));
+
+			return list;
+		}, [ ]);
+
+		const missingGroups = array.difference(levelDefinition.requiredGroups.map(group => group.key), populatedGroups.map(group => group.key))
+			.map((key) => {
+				return levelDefinition.requiredGroups.find(g => g.key === key);
+			});
+
+		const empty = missingGroups.map((group) => {
+			return new PositionGroup(this, parent, [ ], group.currency, group.key, group.description);
+		});
+
+		const compositeGroups = populatedGroups.concat(empty);
+
+		let builder;
+
+		if (levelDefinition.requiredGroups.length !== 0) {
+			const ordering = levelDefinition.requiredGroups.reduce((map, group, index) => {
+				map[group.description] = index;
+
+				return map;
+			}, { });
+
+			const getIndex = (description) => {
+				if (ordering.hasOwnProperty(description)) {
+					return ordering[description];
+				} else {
+					return Number.MAX_VALUE;
+				}
+			};
+
+			builder = ComparatorBuilder.startWith((a, b) => {
+				return comparators.compareNumbers(getIndex(a.description), getIndex(b.description));
+			}).thenBy((a, b) => {
+				return comparators.compareStrings(a.description, b.description);
+			});
+		} else {
+			builder = ComparatorBuilder.startWith((a, b) => {
+				return comparators.compareStrings(a.description, b.description);
+			});
+		}
+
+		compositeGroups.sort(builder.toComparator());
+
+		const initializeGroupObservers = (group, groupTree) => {
+			addGroupBinding.call(this, group, group.registerGroupExcludedChangeHandler((excluded, sender) => {
+				groupTree.climb((parentGroup) => {
+					if (parentGroup) {
+						let excludedItems = [];
+
+						currentTree.walk((childGroup) => {
+							if (childGroup.excluded) {
+								excludedItems = excludedItems.concat(childGroup.items);
+							}
+						}, false, false);
+
+						parentGroup.setExcludedItems(array.unique(excludedItems));
+					}
+				}, false);
+
+				if (treeDefinition.exclusionDependencies.length > 0) {
+					const dependantTrees = treeDefinition.exclusionDependencies.reduce((trees, name) => {
+						if (this._trees.hasOwnProperty(name)) {
+							trees.push(this._trees[name]);
+						}
+
+						return trees;
+					}, [ ]);
+
+					if (dependantTrees.length > 0) {
+						let excludedItems = [ ];
+
+						parentTree.walk((childGroup) => {
+							if (childGroup.excluded) {
+								excludedItems = excludedItems.concat(childGroup.items);
+							}
+						}, false, false);
+
+						dependantTrees.forEach((dependantTrees) => {
+							dependantTrees.walk((childGroup) => {
+								childGroup.setExcludedItems(excludedItems);
+							}, false, false);
+						});
+					}
+				}
+			}));
+		};
+
+		compositeGroups.forEach((group) => {
+			const childTree = currentTree.addChild(group);
+
+			initializeGroupObservers(group, childTree);
+
+			addGroupBinding.call(this, group, group.registerMarketPercentChangeHandler(() => {
+				currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
+			}));
+
+			createGroups.call(this, parentTree, childTree, group.items, treeDefinition, array.dropLeft(levelDefinitions));
+		});
+	}
+
 	return PositionContainer;
 })();
 
@@ -1416,8 +1454,8 @@ module.exports = (() => {
 						this._dataFormat.quoteTime = this._dataActual.quoteTime;
 						this._dataFormat.quoteVolume = formatNumber(this._dataActual.quoteVolume, 0);
 
-						const quoteChangePositive = is.number(this._dataActual.quoteChange) && this._dataActual.quoteChange > 0;
-						const quoteChangeNegative = is.number(this._dataActual.quoteChange) && this._dataActual.quoteChange < 0;
+						const quoteChangePositive = quote.lastPriceDirection === 'up';
+						const quoteChangeNegative = quote.lastPriceDirection === 'down';
 
 						setTimeout(() => this._dataFormat.quoteChangeDirection = { up: quoteChangePositive, down: quoteChangeNegative }, 0);
 						this._dataFormat.quoteChangeNegative = quoteChangeNegative;
@@ -1539,6 +1577,16 @@ module.exports = (() => {
 			return this._excluded;
 		}
 
+		addItems(items) {
+
+			this.refresh();
+		}
+
+		removeItems(items) {
+
+			this.refresh();
+		}
+
 		/**
 		 * Sets the list of items which are excluded from group aggregation calculations.
 		 *
@@ -2295,8 +2343,11 @@ module.exports = (() => {
 
 },{"./../data/InstrumentType":1,"@barchart/common-js/lang/Currency":14,"@barchart/common-js/lang/Decimal":16,"@barchart/common-js/lang/array":20,"@barchart/common-js/lang/assert":21,"@barchart/common-js/lang/is":23,"@barchart/common-js/messaging/Event":25}],7:[function(require,module,exports){
 const assert = require('@barchart/common-js/lang/assert'),
+	Currency = require('@barchart/common-js/lang/Currency'),
 	is = require('@barchart/common-js/lang/is');
 
+const InstrumentType = require('./../../data/InstrumentType');
+
 module.exports = (() => {
 	'use strict';
 
@@ -2311,12 +2362,12 @@ module.exports = (() => {
 	 * @param {PositionLevelDefinition~descriptionSelector} descriptionSelector
 	 * @param {PositionLevelDefinition~currencySelector} currencySelector
 	 * @param {Array.<PositionLevelDefinition~RequiredGroup>=} requiredGroups
-	 * @param {Array.<PositionLevelDefinition~RequiredGroup>=} requiredGroups
 	 * @param {Boolean=} single
 	 * @param {Boolean=} aggregateCash
+	 * @param {Function=} injectPositions
 	 */
 	class PositionLevelDefinition {
-		constructor(name, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash) {
+		constructor(name, keySelector, descriptionSelector, currencySelector, requiredGroups, single, aggregateCash, requiredGroupGenerator) {
 			assert.argumentIsRequired(name, 'name', String);
 			assert.argumentIsRequired(keySelector, 'keySelector', Function);
 			assert.argumentIsRequired(descriptionSelector, 'descriptionSelector', Function);
@@ -2328,6 +2379,7 @@ module.exports = (() => {
 
 			assert.argumentIsOptional(single, 'single', Boolean);
 			assert.argumentIsOptional(aggregateCash, 'aggregateCash', Boolean);
+			assert.argumentIsOptional(requiredGroupGenerator, 'requiredGroupGenerator', Function);
 
 			this._name = name;
 
@@ -2336,8 +2388,11 @@ module.exports = (() => {
 			this._currencySelector = currencySelector;
 
 			this._requiredGroups = requiredGroups || [ ];
+
 			this._single = is.boolean(single) && single;
 			this._aggregateCash = is.boolean(aggregateCash) && aggregateCash;
+
+			this._requiredGroupGenerator = requiredGroupGenerator || (input => null);
 		}
 
 		/**
@@ -2414,6 +2469,96 @@ module.exports = (() => {
 			return this._aggregateCash;
 		}
 
+		/**
+		 * Given an input, potentially creates a new {@link PositionLevelDefinition~RequiredGroup}.
+		 *
+		 * @public
+		 * @param {*} input
+		 * @returns {PositionLevelDefinition~RequiredGroup|null}
+		 */
+		generateRequiredGroup(input) {
+			const requiredGroup = this._requiredGroupGenerator(input);
+
+			if (requiredGroup !== null) {
+				this._requiredGroups.push(requiredGroup);
+			}
+
+			return requiredGroup;
+		}
+
+		/**
+		 * Builds a {@link PositionLevelDefinition~RequiredGroup} for a portfolio.
+		 *
+		 * @public
+		 * @static
+		 * @param {Object} portfolio
+		 * @return {PositionLevelDefinition~RequiredGroup}
+		 */
+		static buildRequiredGroupForPortfolio(portfolio) {
+			return {
+				key: PositionLevelDefinition.getKeyForPortfolioGroup(portfolio),
+				description: PositionLevelDefinition.getDescriptionForPortfolioGroup(portfolio),
+				currency: Currency.CAD
+			};
+		}
+
+		static getKeyForPortfolioGroup(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+
+			return portfolio.portfolio;
+		}
+
+		static getDescriptionForPortfolioGroup(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+
+			return portfolio.name;
+		}
+
+		static getRequiredGroupGeneratorForPortfolio() {
+			return (portfolio) => {
+				let requiredGroup;
+
+				if (is.object(portfolio) && is.string(portfolio.portfolio) && is.string(portfolio.name)) {
+					requiredGroup = PositionLevelDefinition.buildRequiredGroupForPortfolio(portfolio);
+				} else {
+					requiredGroup = null;
+				}
+
+				return requiredGroup;
+			};
+		}
+
+		/**
+		 * Builds a {@link PositionLevelDefinition~RequiredGroup} for an asset class.
+		 *
+		 * @public
+		 * @static
+		 * @param {InstrumentType} type
+		 * @param {Currency} currency
+		 * @return {PositionLevelDefinition~RequiredGroup}
+		 */
+		static buildRequiredGroupForAssetClass(type, currency) {
+			return {
+				key: PositionLevelDefinition.getKeyForAssetClassGroup(type, currency),
+				description: PositionLevelDefinition.getDescriptionForAssetClassGroup(type, currency),
+				currency: currency
+			};
+		}
+
+		static getKeyForAssetClassGroup(type, currency) {
+			assert.argumentIsRequired(type, 'type', InstrumentType, 'InstrumentType');
+			assert.argumentIsRequired(currency, 'currency', Currency, 'Currency');
+
+			return `${type.code}|${currency.code}`;
+		}
+
+		static getDescriptionForAssetClassGroup(type, currency) {
+			assert.argumentIsRequired(type, 'type', InstrumentType, 'InstrumentType');
+			assert.argumentIsRequired(currency, 'currency', Currency, 'Currency');
+
+			return `${type.alternateDescription}${currency.code === 'CAD' ? '' : ` (${currency.alternateDescription})`}`;
+		}
+
 		toString() {
 			return '[PositionLevelDefinition]';
 		}
@@ -2463,7 +2608,7 @@ module.exports = (() => {
 	return PositionLevelDefinition;
 })();
 
-},{"@barchart/common-js/lang/assert":21,"@barchart/common-js/lang/is":23}],8:[function(require,module,exports){
+},{"./../../data/InstrumentType":1,"@barchart/common-js/lang/Currency":14,"@barchart/common-js/lang/assert":21,"@barchart/common-js/lang/is":23}],8:[function(require,module,exports){
 const assert = require('@barchart/common-js/lang/assert');
 
 const PositionLevelDefinition = require('./PositionLevelDefinition');