@comparaonline/offers-models-factories/dist/offers-models-factories.js

Models for comparaonline offers

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var rosie = require('rosie');
var chance = require('chance');
var offersModelsConstants = require('@comparaonline/offers-models-constants');
var offersModels = require('@comparaonline/offers-models');

const chance$1 = new chance.Chance();
rosie.Factory.define('country')
    .attr('name', () => chance$1.country({ full: true }))
    .attr('code', () => chance$1.country());
class CountryFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('country', options);
    }
}
const countryFactory = new CountryFactory();

var getEnumValues = enumObject => Object.keys(enumObject).map(type => enumObject[type]);

const chance$2 = new chance.Chance();
rosie.Factory.define('businessUnit')
    .attr('name', () => chance$2.word())
    .attr('slug', () => chance$2.word())
    .attr('code', () => chance$2.word())
    .attr('country', () => countryFactory.build())
    .attr('logo', () => chance$2.url())
    .attr('category', () => chance$2.word())
    .attr('icon', () => chance$2.url())
    .attr('config', () => ({
    callToActionIcon: chance$2.pickone(getEnumValues(offersModelsConstants.ActionIcon))
}));
class BusinessUnitFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('businessUnit', options);
    }
}
const businessUnitFactory = new BusinessUnitFactory();

const chance$3 = new chance.Chance();
const PHONE_COUNT = 3;
rosie.Factory.define('company')
    .attr('name', () => chance$3.word())
    .attr('slug', () => chance$3.word())
    .attr('code', () => chance$3.word())
    .attr('logo', () => chance$3.url())
    .attr('email', () => chance$3.email())
    .attr('phone', () => chance$3.unique(chance$3.phone, PHONE_COUNT))
    .attr('webSite', () => chance$3.url())
    .attr('description', () => chance$3.paragraph());
class CompanyFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('country', options);
    }
}
const companyFactory = new CompanyFactory();

const chance$4 = new chance.Chance();
const PHONE_COUNT$1 = 3;
rosie.Factory.define('division')
    .attr('name', () => chance$4.word())
    .attr('slug', () => chance$4.word())
    .attr('businessUnit', () => businessUnitFactory.build())
    .attr('company', () => companyFactory.build())
    .attr('code', () => chance$4.word())
    .attr('logo', () => chance$4.url())
    .attr('email', () => chance$4.email())
    .attr('phone', () => chance$4.unique(chance$4.phone, PHONE_COUNT$1))
    .attr('webSite', () => chance$4.url())
    .attr('description', () => chance$4.paragraph())
    .attr('partner', () => chance$4.bool());
class DivisionFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('division', options);
    }
}
const divisionFactory = new DivisionFactory();

const chance$5 = new chance.Chance();
rosie.Factory.define('entity')
    .attr('code', () => chance$5.word())
    .attr('dataType', () => chance$5.pickone(getEnumValues(offersModelsConstants.EntityDataTypes)))
    .attr('slug', () => chance$5.word())
    .attr('label', () => chance$5.word())
    .attr('extraDescription', () => chance$5.paragraph())
    .attr('icon', () => chance$5.pickone(getEnumValues(offersModelsConstants.EntityIcon)))
    .attr('config', {});
class EntityFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('entity', options);
    }
}
const entityFactory = new EntityFactory();

const chance$6 = new chance.Chance();
rosie.Factory.define('entityFilter')
    .attr('order', () => chance$6.integer())
    .attr('level', () => chance$6.integer())
    .attr('entity', () => entityFactory.build())
    .attr('inclusive', () => chance$6.bool());
class EntityFilterFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('entityFilter', options);
    }
}
const entityFilterFactory = new EntityFilterFactory();

const chance$7 = new chance.Chance();
rosie.Factory.define('filter')
    .attr('operator', () => chance$7.integer())
    .attr('value', () => chance$7.bool() ? chance$7.word() : chance$7.integer())
    .attr('slug', () => chance$7.word())
    .attr('label', () => chance$7.word())
    .attr('code', () => chance$7.word())
    .attr('sortable', () => chance$7.bool())
    .attr('entityFilter', () => entityFilterFactory.build());
class FilterFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('filter', options);
    }
}
const filterFactory = new FilterFactory();

const chance$8 = new chance.Chance();
const minInstallment = 6;
const productAttributesValuesFactory = {
    integer: () => chance$8.integer({ min: 20000, max: 2000000 }),
    list: () => chance$8.n(chance$8.sentence, chance$8.integer({ min: 2, max: 5 }), { words: 6 }),
    money: () => ({
        type: chance$8.pickone(getEnumValues(offersModelsConstants.Currencies)),
        value: chance$8.integer({ min: 2000, max: 10000000 })
    }),
    percentage: () => chance$8.integer({ min: 0, max: 100 }),
    string: () => chance$8.sentence(),
    term: () => ({
        value: chance$8.integer({ min: 10, max: 40 }),
        datePart: chance$8.pickone(getEnumValues(offersModelsConstants.DateParts))
    }),
    'money-installment': () => {
        const maxInstallments = chance$8.integer({ min: minInstallment, max: 12 });
        const totalPrice = chance$8.integer({ min: 150000, max: 600000 });
        const installments = Array.from(Array(maxInstallments).keys())
            .map(index => ({
            price: (totalPrice * (1 + (index + 1) / maxInstallments)) / (index + 1),
            number: index + 1,
            total: totalPrice * (1 + (index + 1) / maxInstallments),
            hasInterest: index + 1 > minInstallment
        }));
        return {
            installments,
            total: { value: totalPrice },
            defaultInstallment: chance$8.integer({ min: 1, max: maxInstallments }),
            additionalPrices: [
                {
                    name: chance$8.string(),
                    price: chance$8.integer({ min: 50000, max: 1000000 })
                },
                {
                    name: chance$8.string(),
                    description: chance$8.string(),
                    price: chance$8.integer({ min: 50000, max: 1000000 })
                }
            ]
        };
    }
};

class EntityListFactory {
    constructor() {
        this.options = {
            dataType: offersModelsConstants.EntityDataTypes.list,
            config: {}
        };
    }
    build(options) {
        Object.assign(this.options, options);
        return entityFactory.build(this.options);
    }
}
const entityListFactory = new EntityListFactory();

rosie.Factory.define('format');
class BaseFormatFactory {
    build(options) {
        return rosie.Factory.build('format', options);
    }
}
const baseFormatFactory = new BaseFormatFactory();

const separators = [',', '.'];
const chance$9 = new chance.Chance();
class FormatNumberFactory {
    constructor() {
        this.options = {
            thousandSeparated: chance$9.bool(),
            thousandSeparator: chance$9.pickone(separators),
            decimalDigits: chance$9.d4(),
            decimalSeparator: chance$9.pickone(separators)
        };
    }
    build(options) {
        Object.assign(this.options, options);
        return baseFormatFactory.build(this.options);
    }
}
const formatNumberFactory = new FormatNumberFactory();

const chance$10 = new chance.Chance();
rosie.Factory.define('formatUnit')
    .attr('position', () => chance$10.pickone(getEnumValues(offersModels.UnitPosition)))
    .attr('spaceSeparated', () => chance$10.bool())
    .attr('symbol', () => chance$10.character());
class FormatUnitFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('formatUnit', options);
    }
}
const formatUnitFactory = new FormatUnitFactory();

const chance$11 = new chance.Chance();
class FormatMoneyFactory {
    constructor() {
        this.options = formatNumberFactory.build();
        Object.assign(this.options, {
            unit: formatUnitFactory.build({
                symbol: chance$11.pickone(getEnumValues(offersModelsConstants.Currencies))
            })
        });
    }
    build(options) {
        Object.assign(this.options, options);
        return baseFormatFactory.build(this.options);
    }
}
const formatMoneyFactory = new FormatMoneyFactory();

const chance$12 = new chance.Chance();
class FormatPercentageFactory {
    constructor() {
        this.options = formatNumberFactory.build();
        Object.assign(this.options, {
            unit: formatUnitFactory.build({
                symbol: '%',
                position: 'postfix',
                spaceSeparated: false
            })
        });
    }
    build(options) {
        Object.assign(this.options, options);
        return baseFormatFactory.build(this.options);
    }
}
const formatPercentageFactory = new FormatPercentageFactory();

class EntityMoneyFactory {
    build(options) {
        const userOptions = options || {};
        const defaultOptions = {
            dataType: offersModelsConstants.EntityDataTypes.money,
            config: {
                format: formatMoneyFactory.build()
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityMoneyFactory = new EntityMoneyFactory();

class EntityNumberFactory {
    constructor() {
        this.options = {
            dataType: offersModelsConstants.EntityDataTypes.integer,
            config: {
                format: formatNumberFactory.build()
            }
        };
    }
    build(options) {
        Object.assign(this.options, options);
        return entityFactory.build(this.options);
    }
}
const entityNumberFactory = new EntityNumberFactory();

class EntityPercentageFactory {
    build(options) {
        const userOptions = options || {};
        const defaultOptions = {
            dataType: offersModelsConstants.EntityDataTypes.percentage,
            config: {
                format: formatPercentageFactory.build()
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityPercentageFactory = new EntityPercentageFactory();

class EntityStringFactory {
    constructor() {
        this.options = {
            dataType: offersModelsConstants.EntityDataTypes.string,
            config: {}
        };
    }
    build(options) {
        Object.assign(this.options, options);
        return entityFactory.build(this.options);
    }
}
const entityStringFactory = new EntityStringFactory();

class EntityTermFactory {
    constructor() {
        this.options = {
            dataType: offersModelsConstants.EntityDataTypes.term,
            config: {}
        };
    }
    build(options) {
        Object.assign(this.options, options);
        return entityFactory.build(this.options);
    }
}
const entityTermFactory = new EntityTermFactory();

class EntityMoneyInstallmentFactory {
    build(options) {
        const userOptions = options || {};
        const defaultOptions = {
            dataType: offersModelsConstants.EntityDataTypes.moneyInstallment,
            config: {
                format: {
                    installments: formatMoneyFactory.build(),
                    money: formatMoneyFactory.build()
                }
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityMoneyInstallmentFactory = new EntityMoneyInstallmentFactory();

const chance$13 = new chance.Chance();
rosie.Factory.define('productAttribute')
    .attr('extraDescription', () => chance$13.paragraph())
    .attr('entity', () => entityFactory.build())
    .attr('level', () => chance$13.integer())
    .attr('featured', () => chance$13.bool())
    .attr('enabled', () => chance$13.bool())
    .attr('isAccurate', () => chance$13.bool())
    .attr('value', ['entity'], entity => BuildAttributeValue(entity.dataType))
    .attr('strikedthrough', () => chance$13.bool())
    .attr('landingGroup', () => chance$13.bool());
const BuildAttributeValue = (dataType) => {
    if (productAttributesValuesFactory[dataType] === undefined) {
        throw Error(`Undefined factory for '${dataType}' product attribute.`);
    }
    else {
        const value = productAttributesValuesFactory[dataType]();
        return value;
    }
};
class ProductAttributeFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('productAttribute', options);
    }
    buildType(dataType, options) {
        const valOptions = options || {};
        Object.assign(valOptions, { entity: this.buildEntity(dataType) });
        return rosie.Factory.build('productAttribute', options);
    }
    buildEntity(dataType) {
        switch (dataType) {
            case offersModelsConstants.EntityDataTypes.integer:
                return entityNumberFactory.build();
            case offersModelsConstants.EntityDataTypes.list:
                return entityListFactory.build();
            case offersModelsConstants.EntityDataTypes.money:
                return entityMoneyFactory.build();
            case offersModelsConstants.EntityDataTypes.percentage:
                return entityPercentageFactory.build();
            case offersModelsConstants.EntityDataTypes.string:
                return entityStringFactory.build();
            case offersModelsConstants.EntityDataTypes.term:
                return entityTermFactory.build();
            case offersModelsConstants.EntityDataTypes.moneyInstallment:
                return entityMoneyInstallmentFactory.build();
            default:
                throw Error(`Undefined factory for '${dataType}' product attribute.`);
        }
    }
}
const productAttributeFactory = new ProductAttributeFactory();

const chance$14 = new chance.Chance();
rosie.Factory.define('product')
    .attr('name', () => chance$14.sentence())
    .attr('slug', () => chance$14.word())
    .attr('logo', () => chance$14.url())
    .attr('division', () => divisionFactory.build())
    .attr('code', () => chance$14.word())
    .attr('relevance', () => chance$14.integer())
    .attr('active', () => chance$14.bool())
    .attr('enabled', () => chance$14.bool())
    .attr('partner', () => chance$14.bool())
    .attr('mainAttribute', () => productAttributeFactory.build())
    .attr('featuredAttributes', () => {
    const values = [];
    const featuredAttributesLength = 3;
    Array.from(Array(featuredAttributesLength)).forEach(() => {
        values.push(productAttributeFactory.build({ featured: true }));
    });
    return values;
})
    .attr('productAttributes', () => {
    const attributesLength = chance$14.integer({ min: 3, max: 8 });
    const values = [];
    Array.from(Array(attributesLength)).forEach(() => {
        values.push(productAttributeFactory.build());
    });
    return values;
});
class ProductFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('product', options);
    }
}
const productFactory = new ProductFactory();

class BaseProductAttributeFactory {
    constructor(dataType) {
        this.dataType = dataType;
        this.valueFactory = productAttributesValuesFactory[dataType];
    }
    build(options) {
        const valOptions = options || {};
        valOptions.value !== undefined ? '' : Object.assign(valOptions, { value: this.valueFactory() });
        return productAttributeFactory.buildType(this.dataType, valOptions);
    }
}

class MoneyInstallmentAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super(offersModels.EntityDataTypes.moneyInstallment);
    }
    build(options) {
        return super.build(options);
    }
}
const moneyInstallmentAttributeFactory = new MoneyInstallmentAttributeFactory();

class IntegerAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super('integer');
    }
    build(options) {
        return super.build(options);
    }
}
const integerAttributeFactory = new IntegerAttributeFactory();

class ListAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super('list');
    }
    build(options) {
        return super.build(options);
    }
}
const listAttributeFactory = new ListAttributeFactory();

class MoneyAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super(offersModels.EntityDataTypes.money);
    }
    build(options) {
        return super.build(options);
    }
}
const moneyAttributeFactory = new MoneyAttributeFactory();

class PercentageAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super('percentage');
    }
    build(options) {
        return super.build(options);
    }
}
const percetageAttributeFactory = new PercentageAttributeFactory();

class TermAttributeFactory extends BaseProductAttributeFactory {
    constructor() {
        super('term');
    }
    build(options) {
        return super.build(options);
    }
}
const termAttributeFactory = new TermAttributeFactory();

const chance$15 = new chance.Chance();
rosie.Factory.define('offer')
    .attr('id', () => chance$15.guid())
    .attr('formId', () => chance$15.guid())
    .attr('productExternalId', () => chance$15.word())
    .attr('product', () => productFactory.build())
    .attr('expiration', () => chance$15.date());
class OfferFactory {
    constructor() { }
    build(options) {
        return rosie.Factory.build('offer', options);
    }
}
const offerFactory = new OfferFactory();

exports.businessUnitFactory = businessUnitFactory;
exports.companyFactory = companyFactory;
exports.countryFactory = countryFactory;
exports.divisionFactory = divisionFactory;
exports.entityFactory = entityFactory;
exports.entityFilterFactory = entityFilterFactory;
exports.filterFactory = filterFactory;
exports.productFactory = productFactory;
exports.productAttributeFactory = productAttributeFactory;
exports.moneyInstallmentAttributeFactory = moneyInstallmentAttributeFactory;
exports.integerAttributeFactory = integerAttributeFactory;
exports.listAttributeFactory = listAttributeFactory;
exports.moneyAttributeFactory = moneyAttributeFactory;
exports.percetageAttributeFactory = percetageAttributeFactory;
exports.termAttributeFactory = termAttributeFactory;
exports.offerFactory = offerFactory;
//# sourceMappingURL=offers-models-factories.js.map