@barchart/portfolio-api-common 1.0.162 → 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,127 +156,10 @@ 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);
-						});
-
-					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(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);
-
-						initializeGroupObservers(group, childTree);
-
-						addGroupBinding(group, group.registerMarketPercentChangeHandler(() => {
-							currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
-						}));
-
-						createGroups(childTree, group.items, array.dropLeft(levelDefinitions));
-					});
-				};
-
-				createGroups(tree, this._items, treeDefinition.definitions);
+				createGroups.call(this, tree, tree, this._items, treeDefinition, treeDefinition.definitions);
 				
 				map[treeDefinition.name] = tree;
 
@@ -293,7 +168,27 @@ module.exports = (() => {
 		}
 
 		addPortfolio(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
+			assert.argumentIsRequired(portfolio.name, 'portfolio.name', String);
+
+			const key = portfolio.portfolio;
 
+			if (!this._portfolios.hasOwnProperty(key)) {
+				this._portfolios[key] = portfolio;
+
+				this._definitions.forEach((treeDefinition) => {
+					const tree = this._trees[treeDefinition.name];
+
+					treeDefinition.definitions.forEach((levelDefinition) => {
+						const requiredGroup = levelDefinition.generateRequiredGroup(portfolio);
+
+						if (requiredGroup !== null) {
+
+						}
+					});
+				});
+			}
 		}
 
 		removePortfolio(portfolio) {
@@ -539,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/definitions/PositionLevelDefinition.js

@@ -20,9 +20,10 @@ module.exports = (() => {
 	 * @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);
@@ -34,6 +35,7 @@ module.exports = (() => {
 
 			assert.argumentIsOptional(single, 'single', Boolean);
 			assert.argumentIsOptional(aggregateCash, 'aggregateCash', Boolean);
+			assert.argumentIsOptional(requiredGroupGenerator, 'requiredGroupGenerator', Function);
 
 			this._name = name;
 
@@ -42,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);
 		}
 
 		/**
@@ -120,6 +125,23 @@ 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.
 		 *
@@ -136,7 +158,6 @@ module.exports = (() => {
 			};
 		}
 
-
 		static getKeyForPortfolioGroup(portfolio) {
 			assert.argumentIsRequired(portfolio, 'portfolio', Object);
 
@@ -149,6 +170,20 @@ module.exports = (() => {
 			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.
 		 *
@@ -163,10 +198,9 @@ module.exports = (() => {
 				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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barchart/portfolio-api-common",
-  "version": "1.0.162",
+  "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,127 +872,10 @@ 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);
-						});
-
-					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(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);
-
-						initializeGroupObservers(group, childTree);
-
-						addGroupBinding(group, group.registerMarketPercentChangeHandler(() => {
-							currentTree.walk((childGroup) => childGroup.refreshMarketPercent());
-						}));
-
-						createGroups(childTree, group.items, array.dropLeft(levelDefinitions));
-					});
-				};
-
-				createGroups(tree, this._items, treeDefinition.definitions);
+				createGroups.call(this, tree, tree, this._items, treeDefinition, treeDefinition.definitions);
 				
 				map[treeDefinition.name] = tree;
 
@@ -1009,7 +884,27 @@ module.exports = (() => {
 		}
 
 		addPortfolio(portfolio) {
+			assert.argumentIsRequired(portfolio, 'portfolio', Object);
+			assert.argumentIsRequired(portfolio.portfolio, 'portfolio.portfolio', String);
+			assert.argumentIsRequired(portfolio.name, 'portfolio.name', String);
+
+			const key = portfolio.portfolio;
+
+			if (!this._portfolios.hasOwnProperty(key)) {
+				this._portfolios[key] = portfolio;
+
+				this._definitions.forEach((treeDefinition) => {
+					const tree = this._trees[treeDefinition.name];
 
+					treeDefinition.definitions.forEach((levelDefinition) => {
+						const requiredGroup = levelDefinition.generateRequiredGroup(portfolio);
+
+						if (requiredGroup !== null) {
+
+						}
+					});
+				});
+			}
 		}
 
 		removePortfolio(portfolio) {
@@ -1255,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;
 })();
 
@@ -2342,9 +2364,10 @@ module.exports = (() => {
 	 * @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);
@@ -2356,6 +2379,7 @@ module.exports = (() => {
 
 			assert.argumentIsOptional(single, 'single', Boolean);
 			assert.argumentIsOptional(aggregateCash, 'aggregateCash', Boolean);
+			assert.argumentIsOptional(requiredGroupGenerator, 'requiredGroupGenerator', Function);
 
 			this._name = name;
 
@@ -2364,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);
 		}
 
 		/**
@@ -2442,6 +2469,23 @@ 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.
 		 *
@@ -2458,7 +2502,6 @@ module.exports = (() => {
 			};
 		}
 
-
 		static getKeyForPortfolioGroup(portfolio) {
 			assert.argumentIsRequired(portfolio, 'portfolio', Object);
 
@@ -2471,6 +2514,20 @@ module.exports = (() => {
 			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.
 		 *
@@ -2485,10 +2542,9 @@ module.exports = (() => {
 				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');