@webresto/graphql 1.3.0

package/src/resolvers/cart.ts

@@ -0,0 +1,256 @@
+import * as eventHelper from "@webresto/graphql";
+import checkExpression from "@webresto/core/libs/checkExpression";
+import getEmitter from "@webresto/core/libs/getEmitter";
+
+import { Error } from "../../lib/errorWrapper";
+
+export default {
+  Query: {
+    order: {
+      def: '""" если orderId не задан, вернется новая корзина """ 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.error(
+            "GQL > order resolver error: ",
+            `order with id ${args.orderId} . Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+        return await Order.populate(order.id);
+      },
+    },
+  },
+  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)
+              throw new Error(
+                0,
+                "ERROR",
+                `modifier required (amount, id) for dish: ${args.dishId} current values: id: ${modifier.id}, amount: ${modifier.amount}`
+              );
+          });
+        }
+
+        if (args.orderId) order = await Order.findOne({ id: args.orderId });
+
+        if (!order) {
+          sails.log.error(
+            "GQL > orderAddDish resolver error: ",
+            `order with id ${args.orderId} has problem. Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+
+        const dish = await Dish.findOne({ id: args.dishId });
+
+        if (!dish && !args.replace)
+          throw new Error(0, "ERROR", `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 {
+            throw new Error(
+              0,
+              "ERROR",
+              `"${dish.name}" является акционным и не может быть добавлено пользователем`
+            );
+          }
+        }
+
+        await Order.addDish(
+          order.id,
+          args.dishId,
+          args.amount,
+          args.modifiers || [],
+          args.comment,
+          args.from,
+          args.replace,
+          args.orderDishId
+        );
+        return await Order.countCart(order);
+      },
+    },
+    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.error(
+            "GQL > orderReplaceDish resolver error: ",
+            `order with id ${args.orderId} has problem. Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        await Order.addDish(
+          order.id,
+          args.dishId,
+          args.amount,
+          args.modifiers || [],
+          args.comment,
+          args.from,
+          args.replace,
+          args.orderDishId
+        );
+        return await Order.countCart(order);
+      },
+    },
+    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.error(
+            "GQL > orderRemoveDish resolver error: ",
+            `order with id ${args.orderId} has problem. Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        const orderDish = await OrderDish.findOne({ id: args.orderDishId });
+
+        await Order.removeDish(order.id, orderDish, args.amount, false);
+        return await Order.countCart(order);
+      },
+    },
+    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.error(
+            "GQL > orderSetDishAmount resolver error: ",
+            `order with id ${args.orderId} has problem. Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        let dish = await OrderDish.findOne(args.orderDishId).populate("dish");
+        if (!dish)
+          throw new Error(
+            0,
+            "ERROR",
+            `OrderDish with id ${args.orderDishId} not found`
+          );
+        if (!dish.dish)
+          throw new Error(
+            0,
+            "ERROR",
+            `Dish in OrderDish with id ${args.orderDishId} not found`
+          );
+
+        await Order.setCount(order.id, dish, args.amount);
+        return await Order.countCart(order);
+      },
+    },
+    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) {
+          throw new Error(0, "ERROR", "dishId is required");
+        }
+
+        order = await Order.findOne(orderId);
+
+        if (!order) {
+          sails.log.error(
+            "GQL > orderSetDishComment resolver error: ",
+            `order with id ${args.orderId} has problem. Trying make new cart.`
+          );
+          order = await getNewCart(args.orderId);
+        }
+
+        if (order.paid || order.state === "ORDER") {
+          order = await getNewCart();
+        }
+
+        const dish = await OrderDish.findOne({ id: dishId }).populate("dish");
+        if (!dish) {
+          throw new Error(0, "ERROR", `Dish with id ${dishId} not found`);
+        }
+
+        await order.setComment(dish, comment);
+        return await Order.countCart(order);
+      },
+    },
+
+    orderUpdate: {
+      def: '"""Experimental! allowed only for trifleFrom """ orderUpdate(order: Json): Order',
+      fn: async function (parent, args, context) {
+        
+        let order = args.order;
+        if (!order.id) throw "order.id field is required"
+        await Order.update({id: order.id}, {trifleFrom: order.trifleFrom})
+        return await Order.populate(order.id);
+      },
+    },
+  },
+};
+
+// Generate new cart
+async function getNewCart(orderId?: string) {
+  let order: any;
+  let initOrder = {};
+
+  // Pass oredrId from frontend
+  if (orderId) initOrder["id"] = orderId;
+
+  getEmitter().emit("http-api:init-newcart", initOrder);
+  order = await Order.create(initOrder).fetch();
+  await getEmitter().emit("http-api:create-newcart", order);
+
+  return order;
+}

package/src/resolvers/checkout.d.ts

@@ -0,0 +1,30 @@
+declare const _default: {
+    Mutation: {
+        checkOrder: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<void | {
+                order: import("@webresto/core/models/Order").default;
+                message?: undefined;
+            } | {
+                message: {
+                    type: string;
+                    title: string;
+                    message: string;
+                };
+                order?: undefined;
+            }>;
+        };
+        sendOrder: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<{
+                order: import("@webresto/core/models/Order").default;
+                message: {
+                    type: string;
+                    title: string;
+                    message: string;
+                };
+            }>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/checkout.js

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eventHelper = require("../../lib/eventHelper");
+const errorWrapper_1 = require("../../lib/errorWrapper");
+exports.default = {
+    Mutation: {
+        checkOrder: {
+            def: "checkOrder(orderId: String!, paymentMethodId: String!, selfService: Boolean, address: Address, customer: Customer!, date: String, comment: String, customData: Json): CheckResponse",
+            fn: async function (parent, args, context) {
+                let data = args;
+                // if (data.date) {
+                //     let date = moment(data.date)
+                //     if(!date.isValid()){
+                //         return eventHelper.sendMessage(args.orderId, "Please order.date format is ISO (YYYY-MM-DD HH:mm:ss)");
+                //     } else {
+                //     data.date = date.format('YYYY-MM-DD HH:mm:ss');
+                //     }
+                // }
+                let isSelfService;
+                //@ts-ignore
+                if (data.selfService || data.selfDelivery) {
+                    isSelfService = true;
+                }
+                try {
+                    var order = await Order.findOne(data.orderId);
+                    if (!order) {
+                        return eventHelper.sendMessage(args.orderId, {
+                            type: "error",
+                            title: "Order not found",
+                            message: `Order with id ${data.orderId} not found`,
+                        });
+                    }
+                    if (order.state === "ORDER") {
+                        return eventHelper.sendMessage(args.orderId, {
+                            type: "error",
+                            title: "Ошибка",
+                            message: "Корзина уже заказана",
+                        });
+                    }
+                    if (data.paymentMethodId) {
+                        if (!PaymentMethod.checkAvailable(data.paymentMethodId)) {
+                            return eventHelper.sendMessage(args.orderId, {
+                                type: "error",
+                                title: "Ошибка",
+                                message: "Проверка платежной системы завершилась неудачей",
+                            });
+                        }
+                    }
+                    if (data.address) {
+                        data.address.city =
+                            data.address.city || (await Settings.use("city"));
+                    }
+                    order.personsCount = data.personsCount ? data.personsCount : "";
+                    if (data.comment)
+                        order.comment = data.comment;
+                    if (data.date)
+                        order.date = data.date;
+                    // callback: boolean - перезвонить для уточнения деталей
+                    if (data.customData && data.customData.callback) {
+                        if (!order.customData)
+                            order.customData = {};
+                        order.customData.callback = data.customData.callback;
+                    }
+                    await Order.update({ id: order.id }, order).fetch();
+                    let success;
+                    success = await Order.check(order.id, data.customer, isSelfService, data.address, data.paymentMethodId);
+                    order = await Order.findOne(data.orderId).populateAll();
+                    let message;
+                    if (success && order.state === "CHECKOUT") {
+                        message = {
+                            type: "info",
+                            title: "Внимание",
+                            message: order.message
+                                ? order.message
+                                : "Заказ готов к оформлению",
+                        };
+                    }
+                    else {
+                        if (order.message) {
+                            return eventHelper.sendMessage(args.orderId, {
+                                type: "error",
+                                title: "Внимание",
+                                message: order.message
+                                    ? order.message
+                                    : "Не удалось проверить заказ.",
+                            });
+                        }
+                    }
+                    return { order: order };
+                }
+                catch (e) {
+                    let message = {
+                        type: "error",
+                        title: "Ошибка",
+                        message: "",
+                    };
+                    if (e.code === 1) {
+                        message.message = "Введите имя заказчика";
+                    }
+                    else if (e.code === 2) {
+                        message.message = "Введите телефон заказчика";
+                    }
+                    else if (e.code === 3) {
+                        message.message = "Неверный формат имени заказчика";
+                    }
+                    else if (e.code === 4) {
+                        message.message = "Неверный формат номера заказчика";
+                    }
+                    else if (e.code === 5) {
+                        message.message = "Не указана улица";
+                    }
+                    else if (e.code === 6) {
+                        message.message = "Не указан номер дома";
+                    }
+                    else if (e.code === 7) {
+                        message.message = "Не указан город";
+                    }
+                    else if (e.code === 8) {
+                        message.message = "Платежная система недоступна";
+                    }
+                    else if (e.code === 10) {
+                        message.message = "Дата выполнения заказа не верная";
+                    }
+                    else {
+                        message.message = e.error
+                            ? e.error
+                            : `Проблема при проверки заказа: ${e}`;
+                    }
+                    eventHelper.sendMessage(args.orderId, message);
+                    sails.log.error(e);
+                    return { message: message };
+                }
+            },
+        },
+        sendOrder: {
+            def: "sendOrder(orderId: String!): CheckResponse",
+            fn: async function (parent, args, context) {
+                let data = args;
+                // if (data.date) {
+                //   let date = moment(data.date)
+                //   if(!date.isValid()){
+                //     return eventHelper.sendMessage(args.orderId,"Please order.date format is ISO (YYYY-MM-DD HH:mm:ss)");
+                //   } else {
+                //     data.date = date.format('YYYY-MM-DD HH:mm:ss');
+                //   }
+                // }
+                try {
+                    var order = await Order.findOne({ id: data.orderId });
+                    if (!order) {
+                        const errorMessage = `Order with id ${data.orderId} not found`;
+                        eventHelper.sendMessage(args.orderId, {
+                            type: "error",
+                            title: "Order not found",
+                            message: errorMessage,
+                        });
+                        sails.log.error(`${errorMessage}`);
+                        throw new errorWrapper_1.Error(0, errorMessage);
+                    }
+                    // if (data.comment) order.comment = data.comment;
+                    // if (data.paymentMethodId) {
+                    //   if (order.paymentMethod !== data.paymentMethodId) {
+                    //     await Order.check(
+                    //       order.id,
+                    //       null,
+                    //       null,
+                    //       null,
+                    //       data.paymentMethodId
+                    //     );
+                    //     order = await Order.findOne({ id: data.orderId });
+                    //   }
+                    // }
+                    // if (order.paymentMethod) {
+                    //   if (!(await PaymentMethod.checkAvailable(order.paymentMethod))) {
+                    //     let errorMessage = `Проверка платежной системы завершилась неудачно`;
+                    //     eventHelper.sendMessage(args.orderId, {
+                    //       type: "error",
+                    //       title: "Ошибка",
+                    //       message: errorMessage,
+                    //     });
+                    //     sails.log.error(`${errorMessage}`)
+                    //     throw new Error(0,errorMessage);
+                    //   }
+                    //   if (!(await PaymentMethod.isPaymentPromise(data.paymentMethodId))) {
+                    //     try {
+                    //       let paymentResponse = await order.payment();
+                    //       const action = {
+                    //         type: "PaymentRedirect",
+                    //         data: {
+                    //           redirectLink: paymentResponse.redirectLink,
+                    //         },
+                    //       };
+                    //       eventHelper.sendAction(args.orderId, action);
+                    //       return { order: order, action: action };
+                    //     } catch (e) {
+                    //       eventHelper.sendMessage(args.orderId, {
+                    //         type: "error",
+                    //         title: "Ошибка",
+                    //         message: "Попытка регистрации платежа завершилась неудачно",
+                    //       });
+                    //       sails.log.error(e);
+                    //       throw new Error(0, JSON.stringify(e));
+                    //     }
+                    //   }
+                    // }
+                    await Order.order(order.id);
+                    const message = {
+                        type: "info",
+                        title: "Успешно",
+                        message: "Ваш заказ принят в обработку",
+                    };
+                    eventHelper.sendMessage(args.orderId, message);
+                    return { order: order, message: message };
+                }
+                catch (e) {
+                    eventHelper.sendMessage(args.orderId, {
+                        type: "error",
+                        title: "Ошибка",
+                        message: e,
+                    });
+                    sails.log.error("sendOrder error :", e);
+                    throw new errorWrapper_1.Error(0, `${e}`);
+                }
+            },
+        },
+    },
+};