@barchart/portfolio-api-common 1.0.35 → 1.0.40

package/lib/data/PositionSummaryFrame.js

@@ -15,14 +15,16 @@ module.exports = (() => {
 	 * @param {String} code
 	 * @param {String} description
 	 * @param {Function} rangeCalculator
+	 * @param {Function} startDateCalculator
 	 */
 	class PositionSummaryFrame extends Enum {
-		constructor(code, description, rangeCalculator) {
+		constructor(code, description, rangeCalculator, startDateCalculator) {
 			super(code, description);
 
 			assert.argumentIsRequired(rangeCalculator, 'rangeCalculator', Function);
 
 			this._rangeCalculator = rangeCalculator;
+			this._startDateCalculator = startDateCalculator;
 		}
 
 		getRanges(transactions) {
@@ -31,6 +33,12 @@ module.exports = (() => {
 			return this._rangeCalculator(getFilteredTransactions(transactions));
 		}
 
+		getStartDate(periods) {
+			assert.argumentIsRequired(periods, 'periods', Number);
+
+			return this._startDateCalculator(periods);
+		}
+
 		/**
 		 * A summary for a calendar year.
 		 *
@@ -76,10 +84,10 @@ module.exports = (() => {
 		}
 	}
 
-	const yearly = new PositionSummaryFrame('YEARLY', 'year', getYearlyRanges);
-	const quarterly = new PositionSummaryFrame('QUARTER', 'quarter', getQuarterlyRanges);
-	const monthly = new PositionSummaryFrame('MONTH', 'month', getMonthlyRanges);
-	const ytd = new PositionSummaryFrame('YTD', 'year-to-date', getYearToDateRanges);
+	const yearly = new PositionSummaryFrame('YEARLY', 'year', getYearlyRanges, getYearlyStartDate);
+	const quarterly = new PositionSummaryFrame('QUARTER', 'quarter', getQuarterlyRanges, getQuarterlyStartDate);
+	const monthly = new PositionSummaryFrame('MONTH', 'month', getMonthlyRanges, getMonthlyStartDate);
+	const ytd = new PositionSummaryFrame('YTD', 'year-to-date', getYearToDateRanges, getYearToDateStartDate);
 
 	function getRange(start, end) {
 		return {
@@ -142,6 +150,27 @@ module.exports = (() => {
 		return ranges;
 	}
 
+	function getYearlyStartDate(periods) {
+		const today = Day.getToday();
+
+		return Day.getToday()
+			.subtractMonths(today.month - 1)
+			.subtractDays(today.day)
+			.subtractYears(periods);
+	}
+
+	function getQuarterlyStartDate(periods) {
+		return null;
+	}
+
+	function getMonthlyStartDate(periods) {
+		return null;
+	}
+
+	function getYearToDateStartDate(periods) {
+		return null;
+	}
+
 	function getFilteredTransactions(transactions) {
 		return transactions.reduce((filtered, transaction) => {
 			if (!transaction.snapshot.open.getIsZero() || transaction.type.closing) {

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,66 @@
+const assert = require('@barchart/common-js/lang/assert'),
+	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.previous = null;
+			this._data.current = null;
+
+			this._items.forEach((item) => {
+				item.registerPriceChangeHandler((price, sender) => {
+					if (this._single) {
+						data.current = price;
+					} else {
+						data.current = null;
+					}
+				});
+			});
+
+			calculateStaticData(this);
+		}
+
+		get description() {
+			return this._description;
+		}
+
+		get data() {
+			return this._data;
+		}
+
+		get items() {
+			return this._items;
+		}
+
+		toString() {
+			return '[PositionGroup]';
+		}
+	}
+
+	function calculateStaticData(group) {
+		const items = group._items;
+		const data = group._data;
+
+		const updates = items.reduce(function(updates, item) {
+
+		}, { });
+
+
+	}
+
+	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,51 @@
+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._price = 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._price !== price) {
+				this._priceChangeEvent.fire(this._price = price);
+			}
+		}
+
+		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.35",
+  "version": "1.0.40",
   "description": "Common classes used by the Portfolio system",
   "author": {
     "name": "Bryan Ingle",