@fabrix/spool-cart/dist/api/models/FulfillmentEvent.js

Spool - eCommerce Spool for Fabrix

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const common_1 = require("@fabrix/fabrix/dist/common");
const spool_sequelize_1 = require("@fabrix/spool-sequelize");
const errors_1 = require("@fabrix/spool-sequelize/dist/errors");
const lodash_1 = require("lodash");
const enums_1 = require("../../enums");
class FulfillmentEventResolver extends spool_sequelize_1.SequelizeResolver {
    resolveByInstance(fulfillmentEvent, options = {}) {
        return Promise.resolve(fulfillmentEvent);
    }
    resolveById(fulfillmentEvent, options = {}) {
        return this.findById(fulfillmentEvent.id, options)
            .then(resUser => {
            if (!resUser && options.reject !== false) {
                throw new errors_1.ModelError('E_NOT_FOUND', `FulfillmentEvent ${fulfillmentEvent.id} not found`);
            }
            return resUser;
        });
    }
    resolveByNumber(fulfillmentEvent, options = {}) {
        return this.findById(fulfillmentEvent, options)
            .then(resUser => {
            if (!resUser && options.reject !== false) {
                throw new errors_1.ModelError('E_NOT_FOUND', `FulfillmentEvent ${fulfillmentEvent.token} not found`);
            }
            return resUser;
        });
    }
    resolveByString(fulfillmentEvent, options = {}) {
        return this.findOne(this.app.services.SequelizeService.mergeOptionDefaults(options, {
            where: {
                code: fulfillmentEvent
            }
        }))
            .then(resUser => {
            if (!resUser && options.reject !== false) {
                throw new errors_1.ModelError('E_NOT_FOUND', `FulfillmentEvent ${fulfillmentEvent} not found`);
            }
            return resUser;
        });
    }
    resolve(fulfillmentEvent, options = {}) {
        const resolvers = {
            'instance': fulfillmentEvent instanceof this.instance,
            'id': !!(fulfillmentEvent && lodash_1.isObject(fulfillmentEvent) && fulfillmentEvent.id),
            'number': !!(fulfillmentEvent && lodash_1.isNumber(fulfillmentEvent)),
            'string': !!(fulfillmentEvent && lodash_1.isString(fulfillmentEvent))
        };
        const type = Object.keys(resolvers).find((key) => resolvers[key]);
        switch (type) {
            case 'instance': {
                return this.resolveByInstance(fulfillmentEvent, options);
            }
            case 'id': {
                return this.resolveById(fulfillmentEvent, options);
            }
            case 'number': {
                return this.resolveByNumber(fulfillmentEvent, options);
            }
            case 'string': {
                return this.resolveByString(fulfillmentEvent, options);
            }
            default: {
                const err = new Error(`Unable to resolve FulfillmentEvent ${fulfillmentEvent}`);
                return Promise.reject(err);
            }
        }
    }
}
exports.FulfillmentEventResolver = FulfillmentEventResolver;
class FulfillmentEvent extends common_1.FabrixModel {
    static get resolver() {
        return FulfillmentEventResolver;
    }
    static config(app, Sequelize) {
        return {
            options: {
                underscored: true,
                hooks: {
                    beforeCreate: [
                        (fulfillmentEvent, options) => {
                            return app.services.FulfillmentService.beforeEventCreate(fulfillmentEvent, options)
                                .catch(err => {
                                return Promise.reject(err);
                            });
                        }
                    ],
                    beforeUpdate: [
                        (fulfillmentEvent, options) => {
                            return app.services.FulfillmentService.beforeEventUpdate(fulfillmentEvent, options)
                                .catch(err => {
                                return Promise.reject(err);
                            });
                        }
                    ],
                    afterCreate: [
                        (fulfillmentEvent, options) => {
                            return app.services.FulfillmentService.afterEventCreate(fulfillmentEvent, options)
                                .catch(err => {
                                return Promise.reject(err);
                            });
                        }
                    ],
                    afterUpdate: [
                        (fulfillmentEvent, options) => {
                            return app.services.FulfillmentService.afterEventUpdate(fulfillmentEvent, options)
                                .catch(err => {
                                return Promise.reject(err);
                            });
                        }
                    ]
                },
                enums: {
                    FULFILLMENT_EVENT_STATUS: enums_1.FULFILLMENT_EVENT_STATUS
                }
            }
        };
    }
    static schema(app, Sequelize) {
        return {
            fulfillment_id: {
                type: Sequelize.INTEGER,
                notNull: true
            },
            status: {
                type: Sequelize.ENUM,
                values: lodash_1.values(enums_1.FULFILLMENT_EVENT_STATUS)
            },
            message: {
                type: Sequelize.STRING
            },
            address_1: {
                type: Sequelize.STRING
            },
            province: {
                type: Sequelize.STRING
            },
            country: {
                type: Sequelize.STRING
            },
            postal_code: {
                type: Sequelize.STRING
            },
            latitude: {
                type: Sequelize.FLOAT
            },
            longitude: {
                type: Sequelize.FLOAT
            }
        };
    }
    static associate(models) {
        models.FulfillmentEvent.belongsTo(models.Fulfillment, {
            foreignKey: 'fulfillment_id'
        });
    }
}
exports.FulfillmentEvent = FulfillmentEvent;