@fabrix/spool-cart/dist/api/models/Image.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 lodash_1 = require("lodash");
class ImageResolver extends spool_sequelize_1.SequelizeResolver {
    resolve(image, options) {
        return Promise.resolve(image);
    }
    transformImages(images = [], options = {}) {
        const ImageModel = this.app.models['Image'];
        const Sequelize = ImageModel.sequelize;
        return Sequelize.Promise.mapSeries(images, image => {
            if (image instanceof ImageModel.instance) {
                return Promise.resolve(image);
            }
            else if (image && image.id) {
                return ImageModel.findById(image.id, { transaction: options.transaction || null })
                    .then(_image => {
                    if (!_image) {
                        throw new Error('Image Could not be resolved');
                    }
                    return _image;
                });
            }
            else if (image && image.id) {
                return ImageModel.findById(image.id, { transaction: options.transaction || null })
                    .then(_image => {
                    if (!_image) {
                        throw new Error('Image Could not be resolved to create');
                    }
                    return _image;
                });
            }
            else if (image && lodash_1.isObject(image)) {
                return ImageModel.create(image, { transaction: options.transaction || null })
                    .then(_image => {
                    if (!_image) {
                        throw new Error('ImageModel Could not be resolved to create');
                    }
                    return _image;
                });
            }
            else if (image && lodash_1.isNumber(image)) {
                return ImageModel.findById(image, { transaction: options.transaction || null })
                    .then(_image => {
                    if (!_image) {
                        throw new Error('Image Could not be resolved');
                    }
                    return _image;
                });
            }
            else if (image && lodash_1.isString(image)) {
                return ImageModel.create({ src: image }, { transaction: options.transaction || null })
                    .then(_image => {
                    if (!_image) {
                        throw new Error('Image Could not be resolved to create');
                    }
                    return _image;
                });
            }
            else {
                const err = new Error(`Unable to resolve ImageModel ${image}`);
                return Promise.reject(err);
            }
        });
    }
}
exports.ImageResolver = ImageResolver;
class Image extends common_1.FabrixModel {
    static get resolver() {
        return ImageResolver;
    }
    static config(app, Sequelize) {
        return {
            options: {
                underscored: true,
                scopes: {
                    live: {
                        where: {
                            live_mode: true
                        }
                    }
                },
                hooks: {
                    beforeCreate: [
                        (values, options) => {
                            return app.services.ProxyCartService.buildImages(values.src, options)
                                .then(sizes => {
                                values.full = sizes.full;
                                values.thumbnail = sizes.thumbnail;
                                values.small = sizes.small;
                                values.medium = sizes.medium;
                                values.large = sizes.large;
                            })
                                .catch(err => {
                                return values;
                            });
                        }
                    ]
                }
            }
        };
    }
    static schema(app, Sequelize) {
        return {
            src: {
                type: Sequelize.STRING,
                allowNull: false
            },
            full: {
                type: Sequelize.STRING
            },
            thumbnail: {
                type: Sequelize.STRING
            },
            small: {
                type: Sequelize.STRING
            },
            medium: {
                type: Sequelize.STRING
            },
            large: {
                type: Sequelize.STRING
            },
            alt: {
                type: Sequelize.STRING,
                set: function (val) {
                    this.setDataValue('alt', app.services.ProxyCartService.description(val));
                }
            },
            live_mode: {
                type: Sequelize.BOOLEAN,
                defaultValue: app.config.get('cart.live_mode')
            }
        };
    }
    static associate(models) {
        models.Image.belongsToMany(models.Collection, {
            as: 'collections',
            through: {
                model: models.ItemImage,
                unique: false,
                scope: {
                    model: 'collection'
                }
            },
            foreignKey: 'image_id',
            constraints: false
        });
    }
}
exports.Image = Image;