@barchart/portfolio-api-common 1.0.217 → 1.0.221

package/lib/api/failures/PortfolioFailureType.js

@@ -35,15 +35,21 @@ module.exports = (() => {
 		}
 
 		/**
-		 * The transaction type is not valid, given the current position size
-		 * (e.g. sell is invalid for a short position, sell short must be used).
-		 *
 		 * @public
 		 * @static
 		 * @returns {FailureType}
 		 */
-		static get TRANSACTION_CREATE_FAILED_TYPE_INVALID_FOR_POSITION() {
-			return transactionCreateFailedTypeInvalidForPosition;
+		static get TRANSACTION_CREATE_FAILED_TYPE_INVALID_FOR_INSTRUMENT() {
+			return transactionCreateFailedTypeInvalidForInstrument;
+		}
+
+		/**
+		 * @public
+		 * @static
+		 * @returns {FailureType}
+		 */
+		static get TRANSACTION_CREATE_FAILED_TYPE_INVALID_FOR_DIRECTION() {
+			return transactionCreateFailedTypeInvalidForDirection;
 		}
 
 		/**
@@ -54,12 +60,8 @@ module.exports = (() => {
 		 * @static
 		 * @returns {FailureType}
 		 */
-		static get TRANSACTION_CREATE_FAILED_DIRECTION_SWITCH() {
-			return transactionCreateFailedDirectionSwitch;
-		}
-
-		static get TRANSACTION_CREATE_REWRITE_UNSUPPORTED() {
-			return transactionCreateRewriteUnsupported;
+		static get TRANSACTION_CREATE_FAILED_INVALID_DIRECTION_SWITCH() {
+			return transactionCreateFailedInvalidDirectionSwitch;
 		}
 
 		/**
@@ -86,9 +88,9 @@ module.exports = (() => {
 	const positionCreateFailedNoPortfolio = new FailureType('POSITION_CREATE_FAILED_NO_PORTFOLIO', 'Unable to create transaction. The referenced portfolio does not exist. Has it been deleted?');
 
 	const transactionCreateFailedOutOfSequence = new FailureType('TRANSACTION_CREATE_FAILED_OUT_OF_SEQUENCE', 'Unable to create transaction, because the transaction date is out-of-sequence. In other words, it would occur before an existing transaction. Please confirm your intent to re-write transaction history (which could take some time and alter the historical results for this position).');
-	const transactionCreateFailedTypeInvalidForPosition = new FailureType('TRANSACTION_CREATE_FAILED_INVALID_FOR_POSITION', 'A {L|type.description} are not allowed. At the time of the transaction, your position is {L|direction} (i.e. {L|sign}).');
-	const transactionCreateFailedDirectionSwitch = new FailureType('TRANSACTION_CREATE_FAILED_DIRECTION_SWITCH', 'Unable to create transaction, because the position direction would be switched (from long to short or vice versa). Please close the position (to a zero balance), then enter a second transaction.');
-	const transactionCreateRewriteUnsupported = new FailureType('TRANSACTION_CREATE_REWRITE_UNSUPPORTED', 'Unable to re-write transaction history. This operation is not currently supported (but will be implemented soon).');
+	const transactionCreateFailedTypeInvalidForInstrument = new FailureType('TRANSACTION_CREATE_FAILED_TYPE_INVALID_FOR_INSTRUMENT', '{L|transactionType.description} are not allowed for {L|instrumentType.description}');
+	const transactionCreateFailedTypeInvalidForDirection = new FailureType('TRANSACTION_CREATE_FAILED_TYPE_INVALID_FOR_DIRECTION', 'A {L|type.description} are not allowed. At the time of the transaction, your position is {L|direction} (i.e. {L|sign}).');
+	const transactionCreateFailedInvalidDirectionSwitch = new FailureType('TRANSACTION_CREATE_FAILED_INVALID_DIRECTION_SWITCH', 'Unable to create transaction, because the position direction would be switched (from long to short or vice versa). Please close the position (to a zero balance), then enter a second transaction.');
 
 	const transactionDeleteFailedOutOfSequence = new FailureType('TRANSACTION_DELETE_FAILED_OUT_OF_SEQUENCE', 'Deleting any transaction, except for the most recent, will cause transaction history to be re-written. Please confirm your intent to re-write transaction history (which could take some time and alter the historical results for this position).');
 	const transactionDeleteUnsupported = new FailureType('TRANSACTION_DELETE_UNSUPPORTED', 'Unable to delete transaction. This operation is not currently supported (but will be implemented soon).');

package/lib/data/PositionDirection.js

@@ -19,7 +19,7 @@ module.exports = (() => {
 		constructor(code, description, sign) {
 			super(code, description);
 
-			assert.argumentIsString(sign, 'sign', String);
+			assert.argumentIsRequired(sign, 'sign', String);
 			
 			this._sign = sign;
 		}
@@ -118,20 +118,6 @@ module.exports = (() => {
 				return even;
 			}
 		}
-
-		/**
-		 * Returns true of the direction switched (from long to short, or
-		 * short to long).
-		 *
-		 * @public
-		 * @static
-		 * @param {PositionDirection} a
-		 * @param {PositionDirection} b
-		 * @returns {Boolean}
-		 */
-		static switched(a, b) {
-			return !a.closed && !b.closed && a.positive !== b.positive;
-		}
 	}
 
 	const long = new PositionDirection('LONG', 'Long', 'positive');

package/lib/data/TransactionValidator.js

@@ -0,0 +1,166 @@
+const assert = require('@barchart/common-js/lang/assert');
+
+const InstrumentType = require('./InstrumentType'),
+	PositionDirection = require('./PositionDirection'),
+	TransactionType = require('./TransactionType');
+
+module.exports = (() => {
+	'use strict';
+
+	/**
+	 * Static utilities for validating transactions.
+	 *
+	 * @public
+	 */
+	class TransactionValidator {
+		constructor() {
+
+		}
+
+		/**
+		 * Given an instrument type, returns all valid transaction types.
+		 *
+		 * @static
+		 * @public
+		 * @param {InstrumentType} instrumentType
+		 * @param {Boolean=} userInitiated
+		 * @pararm {PositionDirection=} currentDirection
+		 * @return {Array.<TransactionType>}
+		 */
+		static getTransactionTypesFor(instrumentType, userInitiated, currentDirection) {
+			assert.argumentIsRequired(instrumentType, 'instrumentType', InstrumentType, 'InstrumentType');
+			assert.argumentIsOptional(userInitiated, 'userInitiated', Boolean);
+
+			let valid = validTransactionTypes[instrumentType.code] || [ ];
+
+			if (userInitiated) {
+				valid = valid.filter(d => d.user === userInitiated);
+			}
+
+			return valid.map(d => d.type);
+		}
+
+		/**
+		 * Checks to see if an transaction type is applicable to an instrument type.
+		 *
+		 * @static
+		 * @public
+		 * @param {InstrumentType} instrumentType
+		 * @param {TransactionType} transactionType
+		 * @param {Boolean=} userInitiated
+		 * @return {Boolean}
+		 */
+		static validateTransactionType(instrumentType, transactionType, userInitiated) {
+			assert.argumentIsRequired(transactionType, 'transactionType', TransactionType, 'TransactionType');
+
+			const transactionTypes = TransactionValidator.getTransactionTypesFor(instrumentType, userInitiated);
+
+			return transactionType.some(t => t === transactionType);
+		}
+
+		/**
+		 * Checks to see if a position for a given instrument type can exist in
+		 * the given direction.
+		 *
+		 * @static
+		 * @public
+		 * @param {InstrumentType} instrumentType
+		 * @param {PositionDirection} direction
+		 * @return {Boolean}
+		 */
+		static validateDirection(transactionType, direction) {
+			assert.argumentIsRequired(transactionType, 'transactionType', TransactionType, 'TransactionType');
+			assert.argumentIsRequired(direction, 'direction', PositionDirection, 'PositionDirection');
+
+			return validDirections[transactionType.code].some(d => d === direction);
+		}
+
+		/**
+		 * Checks to see if the position switches direction and if the direction switch
+		 * is valid.
+		 *
+		 * @static
+		 * @public
+		 * @param {InstrumentType} instrumentType
+		 * @param {PositionDirection|null|undefined} currentDirection
+		 * @param {PositionDirection} proposedDirection
+		 * @return {Boolean}
+		 */
+		static validateDirectionSwitch(instrumentType, currentDirection, proposedDirection) {
+			return currentDirection === null || instrumentType.canSwitchDirection || (!currentDirection.closed && !proposedDirection.closed && currentDirection.positive !== proposedDirection.positive);
+		}
+
+		toString() {
+			return '[TransactionValidator]';
+		}
+	}
+
+	const validTransactionTypes = { };
+
+	function associateTypes(instrumentType, transactionType, userInitiated, directions) {
+		const instrumentTypeCode = instrumentType.code;
+
+		if (!validTransactionTypes.hasOwnProperty(instrumentTypeCode)) {
+			validTransactionTypes[instrumentTypeCode] = [ ];
+		}
+
+		validTransactionTypes[instrumentTypeCode].push({ type: transactionType, user: userInitiated });
+	}
+
+	associateTypes(InstrumentType.EQUITY, TransactionType.BUY, true);
+	associateTypes(InstrumentType.EQUITY, TransactionType.SELL, true);
+	associateTypes(InstrumentType.EQUITY, TransactionType.SELL_SHORT, true);
+	associateTypes(InstrumentType.EQUITY, TransactionType.BUY_SHORT, true);
+	associateTypes(InstrumentType.EQUITY, TransactionType.FEE, true);
+	associateTypes(InstrumentType.EQUITY, TransactionType.DIVIDEND, false);
+	associateTypes(InstrumentType.EQUITY, TransactionType.DIVIDEND_REINVEST, false);
+	associateTypes(InstrumentType.EQUITY, TransactionType.DIVIDEND_STOCK, false);
+	associateTypes(InstrumentType.EQUITY, TransactionType.SPLIT, false);
+
+	associateTypes(InstrumentType.FUND, TransactionType.BUY, true);
+	associateTypes(InstrumentType.FUND, TransactionType.SELL, true);
+	associateTypes(InstrumentType.FUND, TransactionType.FEE, true);
+	associateTypes(InstrumentType.FUND, TransactionType.FEE_UNITS, false);
+	associateTypes(InstrumentType.FUND, TransactionType.DISTRIBUTION_CASH, false);
+	associateTypes(InstrumentType.FUND, TransactionType.DISTRIBUTION_FUND, false);
+
+	associateTypes(InstrumentType.OTHER, TransactionType.BUY, true);
+	associateTypes(InstrumentType.OTHER, TransactionType.SELL, true);
+	associateTypes(InstrumentType.OTHER, TransactionType.INCOME, true);
+	associateTypes(InstrumentType.OTHER, TransactionType.FEE, true);
+	associateTypes(InstrumentType.OTHER, TransactionType.VALUATION, true);
+
+	associateTypes(InstrumentType.CASH, TransactionType.DEPOSIT, true);
+	associateTypes(InstrumentType.CASH, TransactionType.WITHDRAWAL, true);
+	associateTypes(InstrumentType.CASH, TransactionType.FEE, true);
+	associateTypes(InstrumentType.CASH, TransactionType.DEBIT, false);
+	associateTypes(InstrumentType.CASH, TransactionType.CREDIT, false);
+
+	const validDirections = { };
+
+	function associateDirections(instrumentType, positionDirection) {
+		const instrumentTypeCode = instrumentType.code;
+
+		if (!validDirections.hasOwnProperty(instrumentTypeCode)) {
+			validDirections[instrumentTypeCode] = [ ];
+		}
+
+		validDirections[instrumentTypeCode].push(positionDirection);
+	}
+
+	associateTypes(InstrumentType.EQUITY, PositionDirection.EVEN);
+	associateTypes(InstrumentType.EQUITY, PositionDirection.LONG);
+	associateTypes(InstrumentType.EQUITY, PositionDirection.SHORT);
+
+	associateTypes(InstrumentType.FUND, PositionDirection.EVEN);
+	associateTypes(InstrumentType.FUND, PositionDirection.LONG);
+
+	associateTypes(InstrumentType.OTHER, PositionDirection.EVEN);
+	associateTypes(InstrumentType.OTHER, PositionDirection.LONG);
+
+	associateTypes(InstrumentType.CASH, PositionDirection.EVEN);
+	associateTypes(InstrumentType.CASH, PositionDirection.LONG);
+	associateTypes(InstrumentType.CASH, PositionDirection.SHORT);
+
+	return TransactionValidator;
+})();

package/package.json

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