Merge pull request #1 from Backendless/vitaly/services

Vitaly/services

Author: vengrov

examples/models/order.js

@@ -0,0 +1,23 @@
+/* global Backendless */
+
+'use strict';
+
+class Order extends Backendless.ServerCode.PersistenceItem {
+  constructor(items) {
+    super();
+
+    /**
+     * @type {Array.<ShoppingItem>}
+     */
+    this.items = items || [];
+
+    /**
+     * @type {Number}
+     */
+    this.orderPrice = this.items.reduce((sum, item) => {
+      return (sum || 0) + (item.price * item.quantity);
+    }, 0);
+  }
+}
+
+module.exports = Backendless.ServerCode.addType(Order);

examples/models/shopping-item.js

@@ -0,0 +1,15 @@
+/* global Backendless */
+
+'use strict';
+
+/**
+ * @property {String} objectId
+ * @property {String} product
+ * @property {Number} price
+ * @property {Number} quantity
+ */
+class ShoppingItem extends Backendless.ServerCode.PersistenceItem {
+
+}
+
+module.exports = Backendless.ServerCode.addType(ShoppingItem);

examples/services/greetings.js

@@ -0,0 +1,30 @@
+/* global Backendless */
+
+'use strict';
+
+const DICT = {};
+DICT['English'] = 'Welcome';
+DICT['German'] = 'Willkommen';
+DICT['Spanish'] = 'Bienvenido';
+
+class GreetingsService {
+  /**
+   * @param {String} userName
+   * @returns {String}
+   */
+  getGreeting(userName) {
+    return `${DICT[this.config.lang]} ${userName} !`;
+  }
+}
+
+Backendless.ServerCode.addService(GreetingsService, [
+  {
+    name        : 'lang',
+    type        : 'choice',
+    displayName : 'Language',
+    required    : true,
+    defaultValue: 'English',
+    options     : ['English', 'German', 'Spanish'],
+    hint        : 'Please select a Greetings Language'
+  }
+]);

examples/services/shopping-cart.js

@@ -2,98 +2,141 @@
 
 'use strict';
 
-class Order {
-  constructor(items) {
-    /**
-     * @type {Array.<ShoppingItem>}
-     */
-    this.items = items;
-
-    /**
-     * @type {Number}
-     */
-    this.orderPrice = items.reduce((sum, item) => (sum || 0) + (item.price * item.quantity));
-  }
-}
+const Order = require('../models/order');
 
 class ShoppingCart {
-  constructor() {
-    this.items = [];
+  constructor(opts) {
+    opts = opts || {};
+
+    this.name = opts.name;
+    this.items = opts.items || [];
+    this.___class = ShoppingCart.name;
   }
 
   addItem(item) {
+    item.objectId = null;
+
     this.items.push(item);
   }
 
+  deleteItem(product) {
+    const idx = this.items.findIndex(item => item.product === product);
+
+    if (idx === -1) {
+      throw new Error(`No ${product} in cart`);
+    }
+
+    this.items.splice(idx, 1);
+
+    return this;
+  }
+
+  setQuantity(product, quantity) {
+    const productItem = this.items.find(item => item.product === product);
+
+    if (!productItem) {
+      throw new Error(`No [${product}] in cart`);
+    }
+
+    productItem.quantity = quantity;
+
+    return this;
+  }
+
   getItems() {
     return this.items;
   }
+
+  destroy() {
+    Backendless.Cache.remove(this.name, this);
+  }
+
+  save() {
+    Backendless.Cache.put(this.name, this);
+  }
+
+  static get(name, mustExist) {
+    Backendless.Cache.setObjectFactory(ShoppingCart.name, ShoppingCart);
+
+    return Backendless.Cache.get(name).then(cart => {
+      if (!cart && mustExist) {
+        throw new Error(`Shopping cart [${name}] does not exist`);
+      }
+
+      return cart;
+    });
+  }
 }
 
 class ShoppingCartService {
 
   /**
-   * A custom type can be described in jsdoc typedef declaration without having its own class
-   * This will help to build a valid Swager doc but the CodeRunner won't be able to transform a plain JS object
-   * from the request into concrete class.
-   *
-   * @typedef {Object} ShoppingItem
-   * @property {String} objectId
-   * @property {String} product
-   * @property {Number} price
-   * @property {Number} quantity
-   * */
-
-  /**
-   * @public
    * @param {String} cartName
    * @param {ShoppingItem} item
-   * @returns {void}
+   * @returns {Promise.<void>}
    */
   addItem(cartName, item) {
-    let shoppingCart = this.getCart(cartName);
+    return this.addItems(cartName, [item]);
+  }
 
-    if (!shoppingCart) {
-      shoppingCart = new ShoppingCart();
-    }
+  /**
+   * @param {String} cartName
+   * @param {Array.<ShoppingItem>} items
+   * @returns {Promise.<void>}
+   */
+  addItems(cartName, items) {
+    return ShoppingCart.get(cartName).then(cart => {
+      if (!cart) {
+        cart = new ShoppingCart({ name: cartName });
+      }
 
-    shoppingCart.addItem(item);
-    item.objectId = null;
+      items.forEach(item => cart.addItem(item));
 
-    Backendless.Cache.put(cartName, shoppingCart);
+      return cart.save();
+    });
   }
 
   /**
-   * @public
    * @param {String} cartName
-   * @returns {Promise.<Order>}
+   * @param {String} product
+   * @returns {Promise.<void>}
    */
-  purchase(cartName) {
-    const shoppingCart = this.getCart(cartName);
-
-    if (!shoppingCart) {
-      throw new Error(`Shopping cart ${cartName} does not exist`);
-    }
-
-    const order = new Order(shoppingCart.getItems());
+  deleteItem(cartName, product) {
+    return ShoppingCart.get(cartName, true).then(cart => cart.deleteItem(product).save());
+  }
 
-    return order.save()
-      .then(() => {
-        Backendless.Cache.delete(cartName);
+  /**
+   * @param {String} cartName
+   * @returns {Promise.<Array.<ShoppingItem>>}
+   */
+  getItems(cartName) {
+    return ShoppingCart.get(cartName, true).then(cart => cart.getItems());
+  }
 
-        return order;
-      });
+  /**
+   * @param {String} cartName
+   * @param {String} productName
+   * @param {Number} quantity
+   * @returns {Promise.<void>}
+   */
+  setQuantity(cartName, productName, quantity) {
+    return ShoppingCart.get(cartName, true).then(cart => cart.setQuantity(productName, quantity).save());
   }
 
   /**
-   * @private
    * @param {String} cartName
-   * @returns {ShoppingCart}
+   * @returns {Promise.<Order>}
    */
-  static getCart(cartName) {
-    return Backendless.Cache.get(cartName, ShoppingCart.class);
+  purchase(cartName) {
+    return ShoppingCart.get(cartName, true).then(cart => {
+      const order = new Order(cart.getItems());
+
+      return order.save()
+        .then(() => cart.destroy())
+        .then(() => order);
+    });
   }
 }
 
-Backendless.ServerCode.addType(Order);
+Backendless.enablePromises();
 Backendless.ServerCode.addService(ShoppingCartService);

examples/services/wsdl-proxy/ip2geo.js

@@ -0,0 +1,59 @@
+/* global Backendless */
+
+'use strict';
+
+//you should add 'easysoap' module to your project dependencies as [npm i easysoap --save]
+const easysoap = require('easysoap');
+const soapClient = easysoap.createClient({
+  host: 'http://ws.cdyne.com/',
+  path: 'ip2geo/ip2geo.asmx',
+  wsdl: 'ip2geo/ip2geo.asmx?WSDL'
+});
+
+/**
+ * @typedef {Object} ResolveIPRequest
+ * @property {String} ipAddress
+ * @property {String} licenseKey
+ */
+
+/**
+ * @typedef {Object} ResolveIPResponse
+ * @property {IPInformation} ResolveIPResult
+ */
+
+/**
+ * @typedef {Object} IPInformation
+ * @property {String} City
+ * @property {String} StateProvince
+ * @property {String} Country
+ * @property {String} Organization
+ * @property {Number} Latitude
+ * @property {Number} Longitude
+ * @property {String} AreaCode
+ * @property {String} TimeZone
+ * @property {Boolean} HasDaylightSavings
+ * @property {Number} Certainty
+ * @property {String} RegionName
+ * @property {String} CountryCode
+ */
+
+/**
+ * http://ws.cdyne.com/ip2geo/ip2geo.asmx?op=ResolveIP
+ */
+class Ip2Geo {
+  /**
+   * @param {ResolveIPRequest} request
+   * @returns {ResolveIPResponse}
+   */
+  resolveIp(request) {
+    return soapClient.call({
+      method: 'ResolveIP',
+      attributes: {
+        xmlns: 'http://ws.cdyne.com/'
+      },
+      params: request
+    }).then(callResponse => callResponse.data);
+  }
+}
+
+Backendless.ServerCode.addService(Ip2Geo);

examples/timers/heartbeat.js

@@ -6,7 +6,7 @@ Backendless.ServerCode.addTimer({
 
   frequency: {
     schedule: 'custom',
-    repeat  : { every: 60 }
+    repeat  : { every: 600 }
   },
 
   execute: function() {

lib/index.js

@@ -1,7 +1,6 @@
 'use strict';
 
-global.Backendless = require('backendless');
-global.Backendless.ServerCode = require('./server-code/api');
+require('backendless').ServerCode = require('./server-code/api');
 
 exports.debug = function(opts) {
   return require('./server-code/runners/debug').start(opts);