Merge remote-tracking branch 'origin/RVA/NLIC-1980/Group_models_&_packages_in_a_license_bundle'

# Conflicts:
#	dist/netlicensing-client.js
#	dist/netlicensing-client.min.js
#	dist/netlicensing-client.node.js
#	dist/netlicensing-client.node.min.js
#	src/Constants.js
#	src/index.js

Author: r-brown

dist/netlicensing-client.js

@@ -206,14 +206,8 @@ export default {
         RED: 'RED',
     },
 
-    Notification: {
-        ENDPOINT_PATH: 'notification',
-        Type: {
-            WEBHOOK: 'WEBHOOK',
-        },
-        Event: {
-            CREATE_LICENSEE: 'CREATE_LICENSEE',
-            CREATE_LICENSE: 'CREATE_LICENSE',
-        },
+    Bundle: {
+        ENDPOINT_PATH: 'bundle',
+        ENDPOINT_OBTAIN_PATH: 'obtain',
     },
 };

dist/netlicensing-client.min.js

@@ -0,0 +1,4 @@
+import itemToObject from './itemToObject';
+import Bundle from '../entities/Bundle';
+
+export default (item) => new Bundle(itemToObject(item));

dist/netlicensing-client.node.js

@@ -0,0 +1,101 @@
+/**
+ * @author    Labs64 <netlicensing@labs64.com>
+ * @license   Apache-2.0
+ * @link      https://netlicensing.io
+ * @copyright 2017 Labs64 NetLicensing
+ */
+
+import BaseEntity from './BaseEntity';
+
+/**
+ * NetLicensing Bundle entity.
+ *
+ * Properties visible via NetLicensing  API:
+ *
+ * Unique number that identifies the bundle. Vendor can assign this number when creating a bundle or
+ * let NetLicensing generate one.
+ * @property string number
+ *
+ * If set to false, the bundle is disabled.
+ * @property boolean active
+ *
+ * Bundle name.
+ * @property string name
+ *
+ * Arbitrary additional user properties of string type may be associated with each bundle. The name of user property
+ * must not be equal to any of the fixed property names listed above and must be none of id, deleted.
+ *
+ * @constructor
+ */
+export default class Bundle extends BaseEntity {
+    constructor(properties) {
+        super({
+            properties,
+            // The attributes that should be cast to native types.
+            casts: {
+                number: 'string',
+                active: 'boolean',
+                name: 'string',
+            },
+        });
+    }
+
+    setNumber(number) {
+        return this.setProperty('number', number);
+    }
+
+    getNumber(def) {
+        return this.getProperty('number', def);
+    }
+
+    setActive(active) {
+        return this.setProperty('active', active);
+    }
+
+    getActive(def) {
+        return this.getProperty('active', def);
+    }
+
+    setName(name) {
+        return this.setProperty('name', name);
+    }
+
+    getName(def) {
+        return this.getProperty('name', def);
+    }
+
+    setDescription(description) {
+        return this.setProperty('description', description);
+    }
+
+    getDescription(def) {
+        return this.getProperty('description', def);
+    }
+
+    setLicenseTemplateNumbers(licenseTemplateNumbers) {
+        const numbers = (Array.isArray(licenseTemplateNumbers))
+            ? licenseTemplateNumbers.join(',')
+            : licenseTemplateNumbers;
+
+        return this.setProperty('licenseTemplateNumbers', numbers);
+    }
+
+    getLicenseTemplateNumbers(def) {
+        const numbers = this.getProperty('licenseTemplateNumbers', def);
+        return (numbers) ? numbers.split(',') : numbers;
+    }
+
+    addLicenseTemplateNumber(licenseTemplateNumber) {
+        const numbers = this.getLicenseTemplateNumbers([]);
+        numbers.push(licenseTemplateNumber);
+
+        return this.setLicenseTemplateNumbers(numbers);
+    }
+
+    removeLicenseTemplateNumber(licenseTemplateNumber) {
+        const numbers = this.getLicenseTemplateNumbers([]);
+        numbers.splice(numbers.indexOf(licenseTemplateNumber), 1);
+
+        return this.setLicenseTemplateNumbers(numbers);
+    }
+}

dist/netlicensing-client.node.min.js

@@ -6,6 +6,7 @@ import Context from './vo/Context';
 import Page from './vo/Page';
 import ValidationParameters from './vo/ValidationParameters';
 import ValidationResults from './vo/ValidationResults';
+import BundleObtainParameters from './vo/BundleObtainParameters';
 
 // Services
 import Service from './services/Service';
@@ -18,7 +19,7 @@ import ProductService from './services/ProductService';
 import TokenService from './services/TokenService';
 import TransactionService from './services/TransactionService';
 import UtilityService from './services/UtilityService';
-import NotificationService from './services/NotificationService';
+import BundleService from './services/BundleService';
 
 // Entities
 import BaseEntity from './entities/BaseEntity';
@@ -33,7 +34,7 @@ import ProductModule from './entities/ProductModule';
 import Token from './entities/Token';
 import Transaction from './entities/Transaction';
 import LicenseTransactionJoin from './entities/LicenseTransactionJoin';
-import Notification from './entities/Notification';
+import Bundle from './entities/Bundle';
 
 // Converters
 import itemToCountry from './converters/itemToCountry';
@@ -46,7 +47,7 @@ import itemToProduct from './converters/itemToProduct';
 import itemToProductModule from './converters/itemToProductModule';
 import itemToToken from './converters/itemToToken';
 import itemToTransaction from './converters/itemToTransaction';
-import itemToNotification from './converters/itemToNotification';
+import itemToBundle from './converters/itemToBundle';
 
 // Utils
 import CastsUtils from './util/CastsUtils';
@@ -67,6 +68,7 @@ export {
     Page,
     ValidationParameters,
     ValidationResults,
+    BundleObtainParameters,
 
     // Expose Services
     Service,
@@ -79,7 +81,7 @@ export {
     TokenService,
     TransactionService,
     UtilityService,
-    NotificationService,
+    BundleService,
 
     // Expose Entities
     BaseEntity,
@@ -94,7 +96,7 @@ export {
     Token,
     Transaction,
     LicenseTransactionJoin,
-    Notification,
+    Bundle,
 
     // Expose Converters
     itemToCountry,
@@ -107,7 +109,7 @@ export {
     itemToProductModule,
     itemToToken,
     itemToTransaction,
-    itemToNotification,
+    itemToBundle,
 
     // Expose Utils
     CastsUtils,
@@ -117,3 +119,7 @@ export {
     // Errors
     NlicError,
 };
+
+// module.exports = NetLicensing;
+
+// Allow use of default import syntax in TypeScript

src/Constants.js

@@ -0,0 +1,184 @@
+/**
+ * @author    Labs64 <netlicensing@labs64.com>
+ * @license   Apache-2.0
+ * @link      https://netlicensing.io
+ * @copyright 2017 Labs64 NetLicensing
+ */
+
+import Service from './Service';
+import Constants from '../Constants';
+import CheckUtils from '../util/CheckUtils';
+import FilterUtils from '../util/FilterUtils';
+import itemToBundle from '../converters/itemToBundle';
+import itemToLicense from '../converters/itemToLicense';
+import Page from '../vo/Page';
+
+/**
+ * JS representation of the Bundle Service. See NetLicensingAPI for details:
+ * https://netlicensing.io/wiki/bundle-services
+ *
+ * @constructor
+ */
+
+export default {
+    /**
+     * Creates new bundle with given properties.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#create-bundle
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * non-null properties will be taken for the new object, null properties will either stay null, or will
+     * be set to a default value, depending on property.
+     * @param bundle NetLicensing.Bundle
+     *
+     * return the newly created bundle object in promise
+     * @returns {Promise}
+     */
+
+    async create(context, bundle) {
+        const { data: { items: { item: items } } } = await Service
+            .post(context, Constants.Bundle.ENDPOINT_PATH, bundle.asPropertiesMap());
+
+        const [item] = items.filter(({ type }) => type === 'Bundle');
+
+        return itemToBundle(item);
+    },
+
+    /**
+     * Gets bundle by its number.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#get-bundle
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * the bundle number
+     * @param number string
+     *
+     * return the bundle object in promise
+     * @returns {Promise}
+     */
+    async get(context, number) {
+        CheckUtils.paramNotEmpty(number, Constants.NUMBER);
+
+        const { data: { items: { item: items } } } = await Service
+            .get(context, `${Constants.Bundle.ENDPOINT_PATH}/${number}`);
+
+        const [item] = items.filter(({ type }) => type === 'Bundle');
+
+        return itemToBundle(item);
+    },
+
+    /**
+     * Returns bundle of a vendor.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#bundles-list
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * reserved for the future use, must be omitted / set to NULL
+     * @param filter string|null
+     *
+     * array of bundle entities or empty array if nothing found in promise.
+     * @returns {Promise}
+     */
+    async list(context, filter) {
+        const queryParams = {};
+
+        if (filter) {
+            if (!CheckUtils.isValid(filter)) throw new TypeError(`filter has bad value ${filter}`);
+            queryParams[Constants.FILTER] = typeof filter === 'string' ? filter : FilterUtils.encode(filter);
+        }
+
+        const { data } = await Service.get(context, Constants.Bundle.ENDPOINT_PATH, queryParams);
+
+        return Page(
+            data.items.item.filter(({ type }) => type === 'Bundle').map((v) => itemToBundle(v)),
+            data.items.pagenumber,
+            data.items.itemsnumber,
+            data.items.totalpages,
+            data.items.totalitems,
+        );
+    },
+
+    /**
+     * Updates bundle properties.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#update-bundle
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * bundle number
+     * @param number string
+     *
+     * non-null properties will be updated to the provided values, null properties will stay unchanged.
+     * @param bundle NetLicensing.Bundle
+     *
+     * updated bundle in promise.
+     * @returns {Promise}
+     */
+    async update(context, number, bundle) {
+        CheckUtils.paramNotEmpty(number, Constants.NUMBER);
+
+        const { data: { items: { item: items } } } = await Service
+            .post(context, `${Constants.Bundle.ENDPOINT_PATH}/${number}`, bundle.asPropertiesMap());
+
+        const [item] = items.filter(({ type }) => type === 'Bundle');
+
+        return itemToBundle(item);
+    },
+
+    /**
+     * Deletes bundle.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#delete-bundle
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * bundle number
+     * @param number string
+     *
+     * if true, any entities that depend on the one being deleted will be deleted too
+     * @param forceCascade boolean
+     *
+     * return boolean state of delete in promise
+     * @returns {Promise}
+     */
+    delete(context, number, forceCascade) {
+        CheckUtils.paramNotEmpty(number, Constants.NUMBER);
+
+        const queryParams = { forceCascade: Boolean(forceCascade) };
+
+        return Service.delete(context, `${Constants.Bundle.ENDPOINT_PATH}/${number}`, queryParams);
+    },
+
+    /**
+     * Obtain bundle.See NetLicensingAPI for details:
+     * @see https://netlicensing.io/wiki/bundle-services#obtain-bundle
+     *
+     * determines the vendor on whose behalf the call is performed
+     * @param context NetLicensing.Context
+     *
+     * bundle number
+     * @param number string
+     *
+     * licensee number
+     * @param bundleObtainParameters NetLicensing.BundleObtainParameters
+     *
+     * return array of licenses
+     * @returns {Promise}
+     */
+    async obtain(context, number, bundleObtainParameters) {
+        CheckUtils.paramNotEmpty(number, Constants.NUMBER);
+        CheckUtils.paramNotEmpty(bundleObtainParameters.getLicenseeNumber(), Constants.Licensee.LICENSEE_NUMBER);
+
+        const { ENDPOINT_PATH, ENDPOINT_OBTAIN_PATH } = Constants.Bundle;
+
+        const queryParams = { [Constants.Licensee.LICENSEE_NUMBER]: bundleObtainParameters.getLicenseeNumber() };
+
+        const { data: { items: { item: items } } } = await Service
+            .post(context, `${ENDPOINT_PATH}/${number}/${ENDPOINT_OBTAIN_PATH}`, queryParams);
+
+        return items.filter(({ type }) => type === 'License').map((i) => itemToLicense(i));
+    },
+};