@webresto/graphql 1.3.7 → 1.3.8

package/src/resolvers/order.ts

@@ -0,0 +1,435 @@
+import * as eventHelper from "@webresto/graphql";
+import checkExpression from "@webresto/core/libs/checkExpression";
+import Order from "@webresto/core/models/Order"
+import { JWTAuth } from "../../lib/jwt";
+
+import { addToReplaceList } from "@webresto/graphql/lib/graphqlHelper";
+addToReplaceList("Order.promotionState", "promotionState: [PromotionState]");
+addToReplaceList("Order.pickupPoint", "pickupPoint: PickupPoint");
+import graphqlHelper from "../../lib/graphqlHelper";
+
+graphqlHelper.addType(`#graphql    
+  input InputOrderUpdate {
+    id: String!
+    trifleFrom: Int
+    comment: String
+    date: String
+    isSelfService: Boolean
+    paymentMethodId: String
+    promotionCodeString: String
+  }
+  `);
+
+export default {
+  Query: {
+    order: {
+      def: `#graphql
+      """ if orderId is not set, a new cart will be returned """ 
+      order(orderId: String, shortId: String, orderNumber: String): Order`,
+
+      fn: async function (parent, args, context) {
+        let order;
+
+        let criteria = {};
+        if (args.orderNumber) {
+          criteria["rmsOrderNumber"] = args.orderNumber;
+          criteria["sort"] = "createdAt DESC";
+        } else if (args.orderId) {
+          criteria["id"] = args.orderId;
+        } else if (args.shortId) {
+          criteria["shortId"] = args.shortId;
+        }
+
+        if (Object.keys(criteria).length !== 0) {
+          order = (await Order.find(criteria))[0];
+        }
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > order resolver error: ",
+            `order with id ${args.orderId}  not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order", fullOrder);
+        return fullOrder
+      },
+    },
+  },
+  Mutation: {
+    orderAddDish: {
+      def: "orderAddDish(orderId: String, dishId: String, amount: Int, modifiers: Json, comment: String, from: String, replace: Boolean, orderDishId: Int): Order",
+      fn: async function (parent, args, context) {
+        let order;
+
+
+
+        if (args.modifiers) {
+          args.modifiers.forEach((modifier) => {
+            if (modifier.amount === undefined || modifier.id === undefined){
+              const error = `modifier required (amount, id) for dish: ${args.dishId} current values: id: ${modifier.id}, amount: ${modifier.amount}`
+              sails.log(error)
+              throw new Error(error);
+            }
+          });
+        }
+
+        if (args.orderId) order = await Order.findOne({ id: args.orderId });
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > orderAddDish resolver error: ",
+            `order with id ${args.orderId} not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        const dish = await Dish.findOne({ id: args.dishId });
+
+        if (!dish && !args.replace)
+          throw `dish with id ${args.dishId} not found`;
+
+        if (dish && checkExpression(dish) === "promo") {
+          let additionalInfo;
+          try {
+            additionalInfo = JSON.parse(dish.additionalInfo);
+          } catch (e) {}
+
+          if (additionalInfo && additionalInfo.defaultOrderDish) {
+            // Исключение на товар в каждую корзину
+          } else {
+            const error = `"${dish.name}" not promo item`
+            sails.log(error)
+            throw new Error(error);
+          }
+        }
+
+        try {
+          await Order.addDish(
+            order.id,
+            args.dishId,
+            args.amount,
+            args.modifiers === undefined ?  [] : args.modifiers,
+            args.comment,
+            'user',
+            args.replace,
+            args.orderDishId
+          );
+        } catch (error) {
+          if(await Settings.get("PASS_ORDERS_ERRORS") === "TRUE") {
+            throw error
+          } else {
+            // TODO: need think about it, it not clean
+            order = await getNewCart(context);
+          }
+        }
+
+        await Order.countCart({id: order.id});
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-add-dish", fullOrder);
+        return fullOrder
+      },
+    },
+    orderReplaceDish: {
+      def: "orderReplaceDish(orderId: String!, orderDishId: Int!, amount: Int, modifiers: Json, comment: String, from: String): Order",
+      fn: async (parent, args, context) => {
+        let order;
+        if (args.orderId) order = await Order.findOne({ id: args.orderId });
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > orderReplaceDish resolver error: ",
+            `order with id ${args.orderId} not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        try {
+          await Order.addDish(
+            order.id,
+            args.dishId,
+            args.amount,
+            args.modifiers === undefined ?  [] : args.modifiers,
+            args.comment,
+            args.from,
+            args.replace,
+            args.orderDishId
+          );
+        } catch (error) {
+          if(await Settings.get("PASS_ORDERS_ERRORS") === "TRUE") {
+            throw error
+          } else {
+            // TODO: need think about it, it not clean
+            order = await getNewCart(context);
+          }
+        }
+
+        await Order.countCart({id: order.id});
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-replace-dish", fullOrder);
+        return fullOrder
+      },
+    },
+    orderRemoveDish: {
+      def: "orderRemoveDish(id: String!, orderDishId: Int!, amount: Int): Order",
+      fn: async function (parent, args, context) {
+        let order;
+        order = await Order.findOne({ id: args.id });
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > orderRemoveDish resolver error: ",
+            `order with id ${args.orderId} not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        const orderDish = await OrderDish.findOne({ id: args.orderDishId });
+
+        try {
+          await Order.removeDish(order.id, orderDish, args.amount, false);
+        } catch (error) {
+          if(await Settings.get("PASS_ORDERS_ERRORS") === "TRUE") {
+            throw error
+          } else {
+            // TODO: need think about it, it not clean
+            order = await getNewCart(context);
+          }
+        }
+        
+        
+        await Order.countCart({id: order.id});
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-remove-dish", fullOrder);
+        return fullOrder
+      },
+    },
+    orderSetDishAmount: {
+      def: "orderSetDishAmount(id: String, orderDishId: Int, amount: Int): Order",
+      fn: async function (parent, args, context) {
+        let order;
+
+        order = await Order.findOne(args.id);
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > orderSetDishAmount resolver error: ",
+            `order with id ${args.orderId} not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        let dish = await OrderDish.findOne(args.orderDishId).populate("dish");
+        if (!dish){
+          const error = `OrderDish with id ${args.orderDishId} not found`;
+          sails.log.error(error)
+          throw new Error(error);
+        }
+        if (!dish.dish) {
+          const error = `Dish in OrderDish with id ${args.orderDishId} not found`;
+          sails.log.error(error)
+          throw new Error(error);
+        }
+
+        try {
+          await Order.setCount(order.id, dish, args.amount);
+        } catch (error) {
+          if(await Settings.get("PASS_ORDERS_ERRORS") === "TRUE") {
+            throw error
+          } else {
+            // TODO: need think about it, it not clean
+            order = await getNewCart(context);
+          }
+        }
+  
+        await Order.countCart({id: order.id});
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-set-dish-amount", fullOrder);
+        return fullOrder
+      },
+    },
+    orderSetDishComment: {
+      def: "orderSetDishComment(id: String, orderDishId: Int, comment: String): Order",
+      fn: async function (parent, args, context) {
+        let order;
+
+        const data = args;
+        const orderId = data.orderId;
+        const comment = data.comment || "";
+        const dishId = data.dishId;
+        if (!dishId) {
+          const error = "dishId is required";
+          sails.log.error(error)
+          throw new Error(error);
+        }
+
+        order = await Order.findOne(orderId);
+
+        if (!order) {
+          sails.log.silly(
+            "GQL > orderSetDishComment resolver error: ",
+            `order with id ${args.orderId} not found. Trying make new cart.`
+          );
+          order = await getNewCart(context, args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        const dish = await OrderDish.findOne({ id: dishId }).populate("dish");
+        if (!dish) {
+          const error = `Dish with id ${dishId} not found`
+          sails.log.error(error)
+          throw new Error(error);
+        }
+
+        await order.setComment(dish, comment);
+        await Order.countCart({id: order.id});
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-set-dish-comment", fullOrder);
+        return fullOrder      
+      },
+    },
+
+    orderUpdate: {
+      def: '"""Experimental! allowed only for trifleFrom """ orderUpdate(order: InputOrderUpdate): Order',
+      fn: async function (parent, args, context) {
+        
+        let order = args.order;
+        if (!order.id) throw "order.id field is required"
+        let _order = await Order.findOne(order.id);
+
+        if(['CART', 'CHECKOUT', 'PAYMENT'].includes(_order.state) !== true) {
+          throw `Order in state [${order.state}] update not allowed`
+        }
+        
+        let orderToCartState = false;
+
+        if(Object.keys(order).length === 1) {
+          throw `no passed updates`
+        }
+
+        const orderUpd = {}
+        if(order.trifleFrom) {
+          orderUpd['trifleFrom'] = order.trifleFrom
+        }
+
+        if(order.comment) {
+          orderUpd['comment'] = order.comment
+        }
+
+        if(order.date) {
+          orderUpd['date'] = order.date
+          orderToCartState = true
+        }
+
+        if(order.isSelfService) {
+          orderUpd['isSelfService'] = order.isSelfService
+          orderToCartState = true
+        }
+
+        if(order.paymentMethodId) {
+          orderUpd['paymentMethodId'] = order.paymentMethodId
+          orderToCartState = true
+        }
+
+        if(order.promotionCodeString || order.promotionCodeString === ""){
+          await Order.applyPromotionCode({id: order.id}, order.promotionCodeString)
+          delete order.promotionCodeString;
+        }
+
+        if(Object.keys(order).length > 1){
+          await Order.update({id: order.id}, orderUpd)
+        }
+
+        // TODO: Need move logic update in Order Model
+        if(orderToCartState) {
+          await Order.next("CART")
+        }
+
+        let fullOrder = await Order.populate(order.id);
+        emitter.emit("http-api:before-response-order-update", fullOrder);
+        return fullOrder   
+      },
+    },
+
+    orderClone: {
+      def: 'orderClone(orderId: String!): Order',
+      fn: async function (parent, args, context) {
+        
+        let orderId = args.orderId;
+        let newcart = await Order.clone({id: orderId});
+        let fullOrder = await Order.populate({id: newcart.id});
+        emitter.emit("http-api:before-response-order-update", fullOrder);
+        return fullOrder
+      },
+    },
+
+    orderPromocodeApply: {
+      def: 'orderPromocodeApply(orderId: String!, promocode: String!): Order',
+      fn: async function (parent, args, context) {
+        let orderId = args.orderId;
+        let promocode = args.promocode;
+        await Order.applyPromotionCode({id: orderId}, promocode)
+        let fullOrder = await Order.populate({id: orderId});
+        emitter.emit("http-api:before-response-order-update", fullOrder);
+        return fullOrder
+      },
+    },
+
+    orderPromocodeReset: {
+      def: 'orderPromocodeReset(orderId: String!): Order',
+      fn: async function (parent, args, context) {
+        let orderId = args.orderId;
+        let promocode = null;
+        await Order.applyPromotionCode({id: orderId}, promocode)
+        let fullOrder = await Order.populate({id: orderId});
+        emitter.emit("http-api:before-response-order-update", fullOrder);
+        return fullOrder
+      },
+    },
+
+  },
+};
+
+// Generate new cart
+async function getNewCart(context?: any, orderId?: string) {
+
+  if (!context.connectionParams.deviceId) {
+    throw `Missed deviceId`
+  }
+
+  let userId = null;
+  if (context && context.connectionParams.authorization) {
+    userId = (await JWTAuth.verify(context.connectionParams.authorization)).userId;
+  }
+
+  let order: any;
+  let initOrder: Order = {};
+
+  // Pass oredrId from frontend
+  if (orderId) initOrder["id"] = orderId;
+  if (userId) initOrder["user"] = userId;
+  initOrder.deviceId = context.connectionParams.deviceId
+
+  emitter.emit("http-api:init-newcart", initOrder);
+  order = await Order.create(initOrder).fetch();
+  await emitter.emit("http-api:create-newcart", order);
+
+  return order;
+}

package/src/resolvers/paymentMethod.js

@@ -1,6 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const getEmitter_1 = require("@webresto/core/libs/getEmitter");
 exports.default = {
     Query: {
         paymentMethod: {
@@ -8,13 +7,18 @@ exports.default = {
             fn: async function (parent, args, context) {
                 const orderId = args.orderId;
                 try {
+                    const order = await Order.findOne({ id: orderId });
+                    if (!order) {
+                        // TODO: implement logic for event
+                        console.log(`order not found`);
+                    }
                     const data = await PaymentMethod.getAvailable();
-                    await getEmitter_1.default().emit('graphql-return-payment-method', orderId, data);
+                    await emitter.emit('graphql-return-payment-method', orderId, data);
                     return data;
                 }
                 catch (e) {
                     sails.log.error(e);
-                    throw new Error(0, JSON.stringify(e));
+                    throw `${JSON.stringify(e)}`;
                 }
             }
         }

package/src/resolvers/paymentMethod.ts

@@ -1,5 +1,3 @@
-import getEmitter from "@webresto/core/libs/getEmitter";
-
 export default {
     Query: {
         paymentMethod: {
@@ -7,12 +5,18 @@ export default {
             fn: async function (parent, args, context) {
               const orderId = args.orderId;
                 try {
+                  const order = await Order.findOne({id: orderId});
+                  if(!order) {
+                    // TODO: implement logic for event
+                    console.log(`order not found`)
+                  }
+                  
                   const data = await PaymentMethod.getAvailable();
-                  await getEmitter().emit('graphql-return-payment-method', orderId, data);
+                  await emitter.emit('graphql-return-payment-method', orderId, data);
                   return data;
                 } catch (e) {
-                  sails.log.error(e); throw new Error(0, JSON.stringify(e));
-
+                  sails.log.error(e); 
+                  throw `${JSON.stringify(e)}`
                 }
             }
         }

package/src/resolvers/pickupPoint.d.ts

@@ -0,0 +1 @@
+export {};

package/src/resolvers/pickupPoint.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphqlHelper_1 = require("@webresto/graphql/lib/graphqlHelper");
+(0, graphqlHelper_1.addType)(`type PickupPoint {
+  id: String
+  title: String
+  address: String
+  order: Int
+  enable: Boolean
+  worktime: Json
+  active: Boolean
+  phone: String
+}`);
+exports.default = {
+    Query: {
+        pickuppoints: {
+            def: "pickuppoints: [PickupPoint]",
+            fn: async () => {
+                let result = await Place.find({ isPickupPoint: true, enable: true });
+                return result;
+            }
+        }
+    }
+};

package/src/resolvers/pickupPoint.ts

@@ -0,0 +1,23 @@
+import { addType } from "@webresto/graphql/lib/graphqlHelper"
+addType(`type PickupPoint {
+  id: String
+  title: String
+  address: String
+  order: Int
+  enable: Boolean
+  worktime: Json
+  active: Boolean
+  phone: String
+}`);
+
+exports.default = {
+    Query: {
+      pickuppoints: {
+            def: "pickuppoints: [PickupPoint]",
+            fn: async () => {
+                let result = await Place.find({ isPickupPoint: true, enable: true });
+                return result;
+            }
+        }
+    }
+};

package/src/resolvers/recomended.d.ts

@@ -0,0 +1,13 @@
+declare const _default: {
+    Query: {
+        recomendedForDish: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<any[]>;
+        };
+        recomendedForOrder: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<any[]>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/recomended.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getRecomended_1 = require("../../lib/getRecomended");
+exports.default = {
+    Query: {
+        recomendedForDish: {
+            def: 'recomendedForDish(dishId: String): [Dish]',
+            fn: async function (parent, args, context) {
+                try {
+                    let criteria = {};
+                    const RECOMENDED_GROUPID_FOR_DISHES = await Settings.get("RECOMENDED_GROUPID_FOR_DISHES");
+                    let defaultGroup = null;
+                    let listOfAllowedGroups = null;
+                    if (RECOMENDED_GROUPID_FOR_DISHES) {
+                        defaultGroup = await Group.find({ id: RECOMENDED_GROUPID_FOR_DISHES });
+                        listOfAllowedGroups = await Group.getMenuTree(defaultGroup);
+                    }
+                    else {
+                        listOfAllowedGroups = await Group.getMenuTree();
+                    }
+                    let dish = await Dish.findOne({ id: args.dishId });
+                    criteria['where'] = {
+                        'and': [
+                            { 'parentGroup': { 'in': listOfAllowedGroups } },
+                            { 'balance': { "!=": 0 } },
+                            { 'modifier': false },
+                            { 'isDeleted': false }
+                        ]
+                    };
+                    if (dish) {
+                        criteria['where']['and'].push({ 'parentGroup': { "!=": dish.parentGroup } });
+                    }
+                    const array = await Dish.find(criteria);
+                    return (0, getRecomended_1.getRecomendElements)(array, 7);
+                }
+                catch (e) {
+                    sails.log.error(e);
+                    throw `${JSON.stringify(e)}`;
+                }
+            }
+        },
+        recomendedForOrder: {
+            def: 'recomendedForOrder(orderId: String): [Dish]',
+            fn: async function (parent, args, context) {
+                try {
+                    const RECOMENDED_GROUPID_FOR_ORDER = await Settings.get("RECOMENDED_GROUPID_FOR_ORDER");
+                    let orderDishes = await OrderDish.find({ order: args.orderId });
+                    const orderDishIds = orderDishes.map(orderDish => orderDish.dish);
+                    let criteria = {};
+                    let defaultGroup = null;
+                    let listOfAllowedGroups = null;
+                    if (RECOMENDED_GROUPID_FOR_ORDER) {
+                        defaultGroup = await Group.find({ id: RECOMENDED_GROUPID_FOR_ORDER });
+                        listOfAllowedGroups = await Group.getMenuTree(defaultGroup);
+                    }
+                    else {
+                        listOfAllowedGroups = await Group.getMenuTree();
+                    }
+                    criteria['where'] = {
+                        'and': [
+                            { 'parentGroup': { 'in': listOfAllowedGroups } },
+                            { 'balance': { "!=": 0 } },
+                            { 'modifier': false },
+                            { 'isDeleted': false }
+                        ]
+                    };
+                    if (orderDishIds.length) {
+                        criteria["where"]["and"].push({ id: { "!=": orderDishIds } });
+                    }
+                    const allDishes = await Dish.find(criteria);
+                    return (0, getRecomended_1.getRecomendElements)(allDishes, 7);
+                }
+                catch (e) {
+                    sails.log.error(e);
+                    throw `${JSON.stringify(e)}`;
+                }
+            }
+        }
+    }
+};