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

Models for comparaonline offers

import { Factory } from 'rosie';
import { Chance } from 'chance';
import { ActionIcon, EntityDataTypes, EntityIcon, DateParts, Currencies } from '@comparaonline/offers-models-constants';
import { UnitPosition, EntityDataTypes as EntityDataTypes$1 } from '@comparaonline/offers-models';

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

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

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

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

const chance$3 = new Chance();
const PHONE_COUNT$1 = 3;
Factory.define('division')
    .attr('name', () => chance$3.word())
    .attr('slug', () => chance$3.word())
    .attr('businessUnit', () => businessUnitFactory.build())
    .attr('company', () => companyFactory.build())
    .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$1))
    .attr('webSite', () => chance$3.url())
    .attr('description', () => chance$3.paragraph())
    .attr('partner', () => chance$3.bool());
class DivisionFactory {
    constructor() { }
    build(options) {
        return Factory.build('division', options);
    }
}
const divisionFactory = new DivisionFactory();

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

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

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

const chance$7 = new Chance();
const minInstallment = 6;
const productAttributesValuesFactory = {
    integer: () => chance$7.integer({ min: 20000, max: 2000000 }),
    list: () => chance$7.n(chance$7.sentence, chance$7.integer({ min: 2, max: 5 }), { words: 6 }),
    money: () => ({
        type: chance$7.pickone(getEnumValues(Currencies)),
        value: chance$7.integer({ min: 2000, max: 10000000 })
    }),
    percentage: () => chance$7.integer({ min: 0, max: 100 }),
    string: () => chance$7.sentence(),
    term: () => ({
        value: chance$7.integer({ min: 10, max: 40 }),
        datePart: chance$7.pickone(getEnumValues(DateParts))
    }),
    'money-installment': () => {
        const maxInstallments = chance$7.integer({ min: minInstallment, max: 12 });
        const totalPrice = chance$7.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$7.integer({ min: 1, max: maxInstallments }),
            additionalPrices: [
                {
                    name: chance$7.string(),
                    price: chance$7.integer({ min: 50000, max: 1000000 })
                },
                {
                    name: chance$7.string(),
                    description: chance$7.string(),
                    price: chance$7.integer({ min: 50000, max: 1000000 })
                }
            ]
        };
    }
};

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

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

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

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

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

const chance$11 = new 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: EntityDataTypes.money,
            config: {
                format: formatMoneyFactory.build()
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityMoneyFactory = new EntityMoneyFactory();

class EntityNumberFactory {
    constructor() {
        this.options = {
            dataType: 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: EntityDataTypes.percentage,
            config: {
                format: formatPercentageFactory.build()
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityPercentageFactory = new EntityPercentageFactory();

class EntityStringFactory {
    constructor() {
        this.options = {
            dataType: 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: 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: EntityDataTypes.moneyInstallment,
            config: {
                format: {
                    installments: formatMoneyFactory.build(),
                    money: formatMoneyFactory.build()
                }
            }
        };
        Object.assign(defaultOptions, userOptions);
        return entityFactory.build(defaultOptions);
    }
}
const entityMoneyInstallmentFactory = new EntityMoneyInstallmentFactory();

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

const chance$13 = new Chance();
Factory.define('product')
    .attr('name', () => chance$13.sentence())
    .attr('slug', () => chance$13.word())
    .attr('logo', () => chance$13.url())
    .attr('division', () => divisionFactory.build())
    .attr('code', () => chance$13.word())
    .attr('relevance', () => chance$13.integer())
    .attr('active', () => chance$13.bool())
    .attr('enabled', () => chance$13.bool())
    .attr('partner', () => chance$13.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$13.integer({ min: 3, max: 8 });
    const values = [];
    Array.from(Array(attributesLength)).forEach(() => {
        values.push(productAttributeFactory.build());
    });
    return values;
});
class ProductFactory {
    constructor() { }
    build(options) {
        return 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(EntityDataTypes$1.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(EntityDataTypes$1.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$14 = new Chance();
Factory.define('offer')
    .attr('id', () => chance$14.guid())
    .attr('formId', () => chance$14.guid())
    .attr('productExternalId', () => chance$14.word())
    .attr('product', () => productFactory.build())
    .attr('expiration', () => chance$14.date());
class OfferFactory {
    constructor() { }
    build(options) {
        return Factory.build('offer', options);
    }
}
const offerFactory = new OfferFactory();

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