@barchart/portfolio-api-common 1.0.218 → 1.0.222

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/{Validator.js → TransactionValidator.js}

@@ -1,6 +1,7 @@
 const assert = require('@barchart/common-js/lang/assert');
 
 const InstrumentType = require('./InstrumentType'),
+	PositionDirection = require('./PositionDirection'),
 	TransactionType = require('./TransactionType');
 
 module.exports = (() => {
@@ -11,7 +12,7 @@ module.exports = (() => {
 	 *
 	 * @public
 	 */
-	class Validator {
+	class TransactionValidator {
 		constructor() {
 
 		}
@@ -23,9 +24,10 @@ module.exports = (() => {
 		 * @public
 		 * @param {InstrumentType} instrumentType
 		 * @param {Boolean=} userInitiated
+		 * @pararm {PositionDirection=} currentDirection
 		 * @return {Array.<TransactionType>}
 		 */
-		static getValidTransactionTypesFor(instrumentType, userInitiated) {
+		static getTransactionTypesFor(instrumentType, userInitiated, currentDirection) {
 			assert.argumentIsRequired(instrumentType, 'instrumentType', InstrumentType, 'InstrumentType');
 			assert.argumentIsOptional(userInitiated, 'userInitiated', Boolean);
 
@@ -39,28 +41,63 @@ module.exports = (() => {
 		}
 
 		/**
-		 * Checks to see is an transaction type is applicable to an instrument 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 validateTransactionTypeFor(instrumentType, transactionType, userInitiated) {
-			const transactionTypes = Validator.getValidTransactionTypesFor(instrumentType, userInitiated);
+		static validateTransactionType(instrumentType, transactionType, userInitiated) {
+			assert.argumentIsRequired(transactionType, 'transactionType', TransactionType, 'TransactionType');
 
-			return transactionType.some(t => t === transactionType);
+			const transactionTypes = TransactionValidator.getTransactionTypesFor(instrumentType, userInitiated);
+
+			return transactionTypes.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 '[Validator]';
+			return '[TransactionValidator]';
 		}
 	}
 
 	const validTransactionTypes = { };
 
-	function associateTypes(instrumentType, transactionType, userInitiated) {
+	function associateTypes(instrumentType, transactionType, userInitiated, directions) {
 		const instrumentTypeCode = instrumentType.code;
 
 		if (!validTransactionTypes.hasOwnProperty(instrumentTypeCode)) {
@@ -99,5 +136,31 @@ module.exports = (() => {
 	associateTypes(InstrumentType.CASH, TransactionType.DEBIT, false);
 	associateTypes(InstrumentType.CASH, TransactionType.CREDIT, false);
 
-	return Validator;
+	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.218",
+  "version": "1.0.222",
   "description": "Common classes used by the Portfolio system",
   "author": {
     "name": "Bryan Ingle",