@webresto/graphql 1.3.0

package/src/resolvers/checkout.ts

@@ -0,0 +1,242 @@
+import * as eventHelper from "../../lib/eventHelper";
+import { Error } from "../../lib/errorWrapper";
+
+export 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: boolean;
+
+        //@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: boolean;
+
+          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 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 Error(0,`${e}`);
+        }
+      },
+    },
+  },
+};

package/src/resolvers/dishAndModifier.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/src/resolvers/dishAndModifier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphqlHelper_1 = require("@webresto/graphql/lib/graphqlHelper");
+// init
+graphqlHelper_1.addToReplaceList("Dish.modifiers", "modifiers: [GroupModifier]");
+graphqlHelper_1.addToReplaceList("OrderDish.modifiers", "modifiers: [OrderModifier]");
+graphqlHelper_1.addType(`
+type GroupModifier {
+  maxAmount: Int
+  minAmount: Int
+  modifierId: String
+  required: Boolean
+  childModifiers: [Modifier]
+  group: Group
+}
+type Modifier {
+  modifierId: String
+  maxAmount: Int
+  minAmount: Int
+  defaultAmount: Int
+  hideIfDefaultAmount: Boolean
+  dish: Dish
+}
+`);
+graphqlHelper_1.addType(`
+type OrderModifier {
+  id: String
+  dish: Dish
+  amount: Int
+  groupId: String
+  group: Group
+}
+`);
+// resolver
+exports.default = {};

package/src/resolvers/dishAndModifier.ts

@@ -0,0 +1,38 @@
+import { addToReplaceList, addType } from "@webresto/graphql/lib/graphqlHelper";
+
+// init
+addToReplaceList("Dish.modifiers", "modifiers: [GroupModifier]");
+addToReplaceList("OrderDish.modifiers", "modifiers: [OrderModifier]");
+
+addType(`
+type GroupModifier {
+  maxAmount: Int
+  minAmount: Int
+  modifierId: String
+  required: Boolean
+  childModifiers: [Modifier]
+  group: Group
+}
+type Modifier {
+  modifierId: String
+  maxAmount: Int
+  minAmount: Int
+  defaultAmount: Int
+  hideIfDefaultAmount: Boolean
+  dish: Dish
+}
+`);
+addType(`
+type OrderModifier {
+  id: String
+  dish: Dish
+  amount: Int
+  groupId: String
+  group: Group
+}
+`);
+
+// resolver
+export default {
+
+}

package/src/resolvers/maintenance.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    Query: {
+        maintenance: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/Maintenance").default>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/maintenance.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    Query: {
+        maintenance: {
+            def: 'maintenance: Maintenance',
+            fn: async function (parent, args, context) {
+                return await Maintenance.getActiveMaintenance();
+            }
+        }
+    }
+};

package/src/resolvers/maintenance.ts

@@ -0,0 +1,11 @@
+
+export default {
+  Query: {
+    maintenance: {
+      def: 'maintenance: Maintenance',
+      fn: async function (parent, args, context) {
+        return await Maintenance.getActiveMaintenance();
+      }
+    }
+  }
+}

package/src/resolvers/paymentMethod.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    Query: {
+        paymentMethod: {
+            def: string;
+            fn: (parent: any, args: any, context: any) => Promise<import("@webresto/core/models/PaymentMethod").default[]>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/paymentMethod.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const getEmitter_1 = require("@webresto/core/libs/getEmitter");
+exports.default = {
+    Query: {
+        paymentMethod: {
+            def: 'paymentMethod(orderId: String!): [PaymentMethod]',
+            fn: async function (parent, args, context) {
+                const orderId = args.orderId;
+                try {
+                    const data = await PaymentMethod.getAvailable();
+                    await getEmitter_1.default().emit('graphql-return-payment-method', orderId, data);
+                    return data;
+                }
+                catch (e) {
+                    sails.log.error(e);
+                    throw new Error(0, JSON.stringify(e));
+                }
+            }
+        }
+    }
+};

package/src/resolvers/paymentMethod.ts

@@ -0,0 +1,20 @@
+import getEmitter from "@webresto/core/libs/getEmitter";
+
+export default {
+    Query: {
+        paymentMethod: {
+            def: 'paymentMethod(orderId: String!): [PaymentMethod]',
+            fn: async function (parent, args, context) {
+              const orderId = args.orderId;
+                try {
+                  const data = await PaymentMethod.getAvailable();
+                  await getEmitter().emit('graphql-return-payment-method', orderId, data);
+                  return data;
+                } catch (e) {
+                  sails.log.error(e); throw new Error(0, JSON.stringify(e));
+
+                }
+            }
+        }
+    }
+}

package/src/resolvers/restrictions.d.ts

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

package/src/resolvers/restrictions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    Query: {
+        restrictions: {
+            def: 'restrictions: Restrictions',
+            fn: async function (parent, args, context) {
+                try {
+                    let restrictions = {};
+                    restrictions.workTime = await Settings.use('workTime');
+                    restrictions.periodPossibleForOrder = await Settings.use('PeriodPossibleForOrder');
+                    restrictions.timezone = await Settings.use('timezone');
+                    restrictions.deliveryDescription = await Settings.use('DeliveryDescription');
+                    restrictions.minDeliveryTime = await Settings.use('minDeliveryTime') || "40";
+                    return restrictions;
+                }
+                catch (e) {
+                    sails.log.error(e);
+                    throw new Error(0, JSON.stringify(e));
+                }
+            }
+        }
+    }
+};

package/src/resolvers/restrictions.ts

@@ -0,0 +1,22 @@
+
+export default {
+    Query: {
+        restrictions: {
+            def: 'restrictions: Restrictions',
+            fn: async function (parent, args, context) {
+                try {
+                  let restrictions :any = {};
+                  restrictions.workTime = await Settings.use('workTime');
+                  restrictions.periodPossibleForOrder = await Settings.use('PeriodPossibleForOrder');
+                  restrictions.timezone = await Settings.use('timezone');
+                  restrictions.deliveryDescription = await Settings.use('DeliveryDescription');
+                  restrictions.minDeliveryTime = await Settings.use('minDeliveryTime') || "40";
+                  return restrictions;
+                } catch (e) {
+                  sails.log.error(e); throw new Error(0, JSON.stringify(e));
+
+                }
+            }
+        }
+    }
+}

package/src/resolvers/streets.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    Query: {
+        streets: {
+            def: string;
+            fn: (parent: any, args: any, context: any, info: any) => Promise<any>;
+        };
+    };
+};
+export default _default;

package/src/resolvers/streets.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    Query: {
+        streets: {
+            def: "streets: [Street]",
+            fn: async (parent, args, context, info) => {
+                let streetModel = await Settings.use("StreetModel");
+                if (!streetModel && !sails.models[streetModel])
+                    streetModel = 'street';
+                const streets = await sails.models[streetModel.toLowerCase()].find({ isDeleted: false });
+                return streets;
+            }
+        }
+    }
+};

package/src/resolvers/streets.ts

@@ -0,0 +1,13 @@
+export default {
+  Query: {
+    streets: {
+      def: "streets: [Street]",
+      fn: async (parent, args, context, info) => {
+        let streetModel = await Settings.use("StreetModel")
+        if (!streetModel && ! sails.models[streetModel]) streetModel = 'street'
+        const streets = await sails.models[streetModel.toLowerCase()].find({isDeleted: false});
+        return streets;
+      }
+    }
+  }
+}

package/src/resolvers/subscriptions.d.ts

@@ -0,0 +1,33 @@
+declare const _default: {
+    Subscription: {
+        order: {
+            def: string;
+            fn: {
+                subscribe: any;
+                resolve: (payload: any) => any;
+            };
+        };
+        message: {
+            def: string;
+            fn: {
+                subscribe: any;
+                resolve: (payload: any) => any;
+            };
+        };
+        action: {
+            def: string;
+            fn: {
+                subscribe: any;
+                resolve: (payload: any) => any;
+            };
+        };
+        maintenance: {
+            def: string;
+            fn: {
+                subscribe: any;
+                resolve: (payload: any) => any;
+            };
+        };
+    };
+};
+export default _default;

package/src/resolvers/subscriptions.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const { withFilter } = require('apollo-server');
+exports.default = {
+    Subscription: {
+        order: {
+            def: 'order(orderId: String): Order',
+            fn: {
+                subscribe: withFilter((rootValue, args, context, info) => context.pubsub.asyncIterator('order-changed'), (payload, query) => {
+                    return payload.id === query.orderId;
+                }),
+                resolve: payload => {
+                    const order = payload;
+                    return order;
+                }
+            }
+        },
+        message: {
+            def: 'message(orderId: String): Message',
+            fn: {
+                subscribe: withFilter((rootValue, args, context, info) => context.pubsub.asyncIterator('message'), (payload, query) => {
+                    return payload.orderId === query.orderId;
+                }),
+                resolve: payload => {
+                    return payload.message;
+                }
+            }
+        },
+        action: {
+            def: 'action(orderId: String): Action',
+            fn: {
+                subscribe: withFilter((rootValue, args, context, info) => context.pubsub.asyncIterator('action'), (payload, query) => {
+                    return payload.orderId === query.orderId;
+                }),
+                resolve: payload => {
+                    return payload.action;
+                }
+            }
+        },
+        maintenance: {
+            def: 'maintenance: Maintenance',
+            fn: {
+                subscribe: withFilter((rootValue, args, context, info) => context.pubsub.asyncIterator('maintenance'), (payload, query) => {
+                    return true;
+                }),
+                resolve: payload => {
+                    return payload;
+                }
+            }
+        }
+    }
+};

package/src/resolvers/subscriptions.ts

@@ -0,0 +1,63 @@
+const { withFilter } = require('apollo-server');
+
+export default {
+  Subscription: {
+    order: {
+      def: 'order(orderId: String): Order',
+      fn: {
+        subscribe: withFilter(
+          (rootValue, args, context, info) => context.pubsub.asyncIterator('order-changed'),
+          (payload, query) => {
+            return payload.id === query.orderId;
+          }
+        ),
+        resolve: payload => {
+          const order = payload;
+          return order;
+        }
+      }
+    },
+    message: {
+      def: 'message(orderId: String): Message',
+      fn: {
+        subscribe: withFilter(
+          (rootValue, args, context, info) => context.pubsub.asyncIterator('message'),
+          (payload, query) => {
+            return payload.orderId === query.orderId;
+          }
+        ),
+        resolve: payload => {
+          return payload.message;
+        }
+      }
+    },
+    action: {
+      def: 'action(orderId: String): Action',
+      fn: {
+        subscribe: withFilter(
+          (rootValue, args, context, info) => context.pubsub.asyncIterator('action'),
+          (payload, query) => {
+            return payload.orderId === query.orderId;
+          }
+        ),
+        resolve: payload => {
+          return payload.action;
+        }
+      }
+    },
+    maintenance: {
+      def: 'maintenance: Maintenance',
+      fn: {
+        subscribe: withFilter(
+          (rootValue, args, context, info) => context.pubsub.asyncIterator('maintenance'),
+          (payload, query) => {
+            return true;
+          }
+        ),
+        resolve: payload => {
+          return payload;
+        }
+      }
+    }
+  }
+}

package/test/.eslintrc

@@ -0,0 +1,8 @@
+{
+    "env": {
+        "mocha": true
+    },
+    "globals": {
+        "sails": true
+    }
+}