@fabrix/spool-cart/dist/api/controllers/OrderController.js

Spool - eCommerce Spool for Fabrix

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const common_1 = require("@fabrix/fabrix/dist/common");
const Validator = require("../../validator");
const errors_1 = require("@fabrix/spool-sequelize/dist/errors");
const lodash_1 = require("lodash");
class OrderController extends common_1.FabrixController {
    generalStats(req, res) {
        res.json({});
    }
    count(req, res) {
        const EventsService = this.app.services.EventsService;
        EventsService.count('Order')
            .then(count => {
            const counts = {
                orders: count
            };
            return res.json(counts);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    findById(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        Order.findByIdDefault(req.params.id, {})
            .then(order => {
            if (!order) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order id ${req.params.id} not found`);
            }
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    findByToken(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        Order.findByTokenDefault(req.params.token, {})
            .then(order => {
            if (!order) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order token ${req.params.token} not found`);
            }
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    resolve(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        Order.resolve(req.params.id, {})
            .then(order => {
            if (!order) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order ${req.params.id} not found`);
            }
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    findAll(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        const where = req.jsonCriteria(req.query.where);
        Order.findAndCountDefault({
            order: sort,
            where: where,
            offset: offset,
            limit: limit
        })
            .then(orders => {
            res.paginate(orders.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, orders.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    search(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        const term = req.query.term;
        const where = req.jsonCriteria(req.query.where);
        const defaultQuery = lodash_1.defaults(where, {
            $or: [
                {
                    number: {
                        $iLike: `%${term}%`
                    }
                },
                {
                    name: {
                        $iLike: `%${term}%`
                    }
                },
                {
                    email: {
                        $iLike: `%${term}%`
                    }
                }
            ]
        });
        Order.findAndCountDefault({
            where: defaultQuery,
            order: sort,
            offset: offset,
            req: req,
            limit: limit
        })
            .then(orders => {
            res.paginate(orders.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, orders.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    customer(req, res) {
        const orm = this.app.models;
        const Order = orm['Order'];
        const Customer = orm['Customer'];
        Order.findById(req.params.id, {
            attributes: ['id', 'customer_id']
        })
            .then(order => {
            if (!order) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order id ${req.params.id} not found`);
            }
            if (!order.customer_id) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order id ${req.params.id} customer not found`);
            }
            return Customer.findById(order.customer_id);
        })
            .then(customer => {
            if (!customer) {
                throw new errors_1.ModelError('E_NOT_FOUND', `Order id ${req.params.id} customer not found`);
            }
            return this.app.services.PermissionsService.sanitizeResult(req, customer);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    create(req, res) {
        const OrderService = this.app.services.OrderService;
        const CartService = this.app.services.CartService;
        const SubscriptionService = this.app.services.SubscriptionService;
        Validator.validateOrder.create(req.body)
            .then(values => {
            if (req.body.cart || req.body.cart_token || req.body.cart_id) {
                if (!req.body.cart) {
                    req.body.cart = {};
                }
                if (req.body.cart_token) {
                    req.body.cart.token = req.body.cart_token;
                }
                if (req.body.cart_id) {
                    req.body.cart.id = req.body.cart_id;
                }
                return CartService.prepareForOrder(req);
            }
            else if (req.body.subscription || req.body.subscription_token || req.body.subscription_id) {
                if (!req.body.subscription) {
                    req.body.subscription = {};
                }
                if (req.body.subscription_token) {
                    req.body.subscription.token = req.body.subscription_token;
                }
                if (req.body.subscription_id) {
                    req.body.subscription.id = req.body.subscription_id;
                }
                return SubscriptionService.prepareForOrder(req.body.subscription);
            }
            else {
                throw new Error('Requires a Cart or Subscription to create Order');
            }
        })
            .then(preparedOrder => {
            if (!preparedOrder) {
                throw new Error('Not Ready For Order');
            }
            return OrderService.create(preparedOrder);
        })
            .then(order => {
            if (!order) {
                throw new Error('Unexpected Error while creating order');
            }
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    update(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.update(req.body)
            .then(values => {
            req.body.id = req.params.id;
            return OrderService.update(req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    cancel(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.cancel(req.body)
            .then(values => {
            req.body.id = req.params.id;
            return OrderService.cancel(req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    authorize(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.authorize(req.body)
            .then(values => {
            return OrderService.authorize(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    capture(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.capture(req.body)
            .then(values => {
            return OrderService.capture(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    void(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.void(req.body)
            .then(values => {
            return OrderService.void(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    retry(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.retry(req.body)
            .then(values => {
            return OrderService.retry(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    refund(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.refund(req.body)
            .then(values => {
            return OrderService.refund(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    refunds(req, res) {
        const Refund = this.app.models['Refund'];
        const orderId = req.params.id;
        if (!orderId && !req.user) {
            const err = new Error('A order id and a user in session are required');
            return res.send(401, err);
        }
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        Refund.findAndCountAll({
            order: sort,
            where: {
                order_id: orderId
            },
            offset: offset,
            limit: limit
        })
            .then(refunds => {
            res.paginate(refunds.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, refunds.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    send(req, res) {
        const orderId = req.params.id;
        if (!orderId) {
            const err = new Error('Order Id is required');
            return res.serverError(err);
        }
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.send(req.body)
            .then(values => {
            return OrderService.send(orderId, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    uploadCSV(req, res) {
        const OrderCsvService = this.app.services.OrderCsvService;
        const csv = req.file;
        if (!csv) {
            const err = new Error('File failed to upload');
            return res.serverError(err);
        }
        OrderCsvService.orderCsv(csv.path)
            .then(result => {
            return res.json({
                file: req.file,
                result: result
            });
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    processUpload(req, res) {
        const OrderCsvService = this.app.services.OrderCsvService;
        OrderCsvService.processOrderUpload(req.params.id)
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    exportOrders(req, res) {
    }
    addTag(req, res) {
        const OrderService = this.app.services.OrderService;
        OrderService.addTag(req.params.id, req.params.tag)
            .then(tag => {
            return this.app.services.PermissionsService.sanitizeResult(req, tag);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    removeTag(req, res) {
        const OrderService = this.app.services.OrderService;
        OrderService.removeTag(req.params.id, req.params.tag)
            .then(tag => {
            return this.app.services.PermissionsService.sanitizeResult(req, tag);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    pricingOverrides(req, res) {
        const OrderService = this.app.services.OrderService;
        let id = req.params.id;
        if (!id && req.body.id) {
            id = req.body.id;
        }
        if (!id && req.order) {
            id = req.order.id;
        }
        Validator.validateOrder.pricingOverrides(req.body)
            .then(values => {
            return OrderService.pricingOverrides(req.body, id, req.user);
        })
            .then(order => {
            if (!order) {
                throw new Error('Unexpected Error while overriding prices');
            }
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    addItem(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.addItem(req.body)
            .then(values => {
            return OrderService.addItem(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    addItems(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.addItems(req.body)
            .then(values => {
            return OrderService.addItems(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    updateItem(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.updateItem(req.body)
            .then(values => {
            return OrderService.updateItem(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    removeItem(req, res) {
        const OrderService = this.app.services.OrderService;
        if (req.params.item) {
            req.body.id = req.params.item;
        }
        Validator.validateOrder.removeItem(req.body)
            .then(values => {
            return OrderService.removeItem(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    addShipping(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.addShipping(req.body)
            .then(values => {
            return OrderService.addShipping(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    removeShipping(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.removeShipping(req.body)
            .then(values => {
            return OrderService.removeShipping(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    addTaxes(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.addTaxes(req.body)
            .then(values => {
            return OrderService.addTaxes(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    removeTaxes(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.removeTaxes(req.body)
            .then(values => {
            return OrderService.removeTaxes(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    pay(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.pay(req.body)
            .then(values => {
            return OrderService.pay(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    authorizeTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.authorize(req.body)
            .then(values => {
            return OrderService.authorizeTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    captureTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.capture(req.body)
            .then(values => {
            return OrderService.captureTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    payTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.sale(req.body)
            .then(values => {
            return OrderService.payTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    voidTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.void(req.body)
            .then(values => {
            return OrderService.voidTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    refundTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.refund(req.body)
            .then(values => {
            return OrderService.refundTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    retryTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.retry(req.body)
            .then(values => {
            return OrderService.retryTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    cancelTransaction(req, res) {
        const id = req.params.id;
        const transaction = req.params.transaction;
        const OrderService = this.app.services.OrderService;
        Validator.validateTransaction.cancel(req.body)
            .then(values => {
            return OrderService.cancelTransaction(id, transaction);
        })
            .then(orderAndTransactions => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndTransactions);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    fulfill(req, res) {
        const OrderService = this.app.services.OrderService;
        Validator.validateOrder.fulfill(req.body)
            .then(values => {
            return OrderService.fulfill(req.params.id, req.body);
        })
            .then(order => {
            return this.app.services.PermissionsService.sanitizeResult(req, order);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    updateFulfillment(req, res) {
        const OrderService = this.app.services.OrderService;
        const fulfillment = req.body;
        fulfillment.id = req.params.fulfillment;
        OrderService.manualUpdateFulfillment(req.params.id, fulfillment)
            .then(orderAndFulfillments => {
            return this.app.services.PermissionsService.sanitizeResult(req, orderAndFulfillments);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    event(req, res) {
        const Event = this.app.models['Event'];
        const eventId = req.params.event;
        if (!eventId || !req.user) {
            const err = new Error('A order id and a user in session are required');
            res.send(401, err);
        }
        Event.findById(eventId)
            .then(event => {
            return this.app.services.PermissionsService.sanitizeResult(req, event);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    events(req, res) {
        const Event = this.app.models['Event'];
        const orderId = req.params.id;
        if (!orderId && !req.user) {
            const err = new Error('A order id and a user in session are required');
            return res.send(401, err);
        }
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        Event.findAndCountAll({
            order: sort,
            where: {
                object_id: orderId,
                object: 'order'
            },
            offset: offset,
            limit: limit
        })
            .then(events => {
            res.paginate(events.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, events.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    transactions(req, res) {
        const Transaction = this.app.models['Transaction'];
        const orderId = req.params.id;
        if (!orderId && !req.user) {
            const err = new Error('A order id and a user in session are required');
            return res.send(401, err);
        }
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        Transaction.findAndCountAll({
            order: sort,
            where: {
                order_id: orderId
            },
            offset: offset,
            limit: limit
        })
            .then(transactions => {
            res.paginate(transactions.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, transactions.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
    fulfillments(req, res) {
        const Fulfillment = this.app.models['Fulfillment'];
        const orderId = req.params.id;
        if (!orderId && !req.user) {
            const err = new Error('A order id and a user in session are required');
            return res.send(401, err);
        }
        const limit = Math.max(0, req.query.limit || 10);
        const offset = Math.max(0, req.query.offset || 0);
        const sort = req.query.sort || [['created_at', 'DESC']];
        Fulfillment.findAndCountAll({
            order: sort,
            where: {
                order_id: orderId
            },
            offset: offset,
            limit: limit
        })
            .then(fulfillments => {
            res.paginate(fulfillments.count, limit, offset, sort);
            return this.app.services.PermissionsService.sanitizeResult(req, fulfillments.rows);
        })
            .then(result => {
            return res.json(result);
        })
            .catch(err => {
            return res.serverError(err);
        });
    }
}
exports.OrderController = OrderController;