@grouparoo/core/dist/modules/configLoaders/group.js

The Grouparoo Core

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.deleteGroups = exports.loadGroup = void 0;
const sequelize_1 = require("sequelize");
const codeConfig_1 = require("../../classes/codeConfig");
const __1 = require("../.."); // configLoader imports need to be from root
const topLevelGroupRules_1 = require("../../modules/topLevelGroupRules");
const configWriter_1 = require("../configWriter");
const deprecation_1 = require("../deprecation");
async function loadGroup(configObject, externallyValidate, validate = false) {
    let isNew = false;
    (0, codeConfig_1.validateConfigObjectKeys)(__1.Group, configObject, ["rules", "type"]);
    let group = await __1.Group.scope(null).findOne({
        where: {
            id: configObject.id,
            [sequelize_1.Op.or]: {
                locked: (0, codeConfig_1.getCodeConfigLockKey)(),
                state: "deleted",
            },
        },
    });
    if (!group) {
        isNew = true;
        group = await __1.Group.create({
            id: configObject.id,
            name: configObject.name,
            modelId: configObject.modelId,
        });
    }
    await group.update({
        name: configObject.name,
        modelId: configObject.modelId,
        locked: configWriter_1.ConfigWriter.getLockKey(configObject),
    });
    const previousState = group.state;
    await group.update({ state: "ready" });
    if (configObject.rules) {
        let groupRulesWithKey = [];
        const rules = [...configObject.rules];
        const calculatesWithDate = ["lte", "gt", "lt", "gte", "eq", "ne"];
        for (const rule of rules) {
            if (rule["propertyId"]) {
                let ruleKey, ruleType;
                const topLevelProperty = topLevelGroupRules_1.TopLevelGroupRules.find((r) => r.key === rule["propertyId"]);
                if (topLevelProperty) {
                    ruleKey = topLevelProperty.key;
                    ruleType = topLevelProperty.type;
                }
                else {
                    const property = await __1.Property.findById(rule["propertyId"]);
                    ruleKey = property.key;
                    ruleType = property.type;
                }
                delete rule["propertyId"];
                rule.key = ruleKey;
                // if calculating based on a date, parse to unix timestamp
                if (calculatesWithDate.includes(rule["op"])) {
                    if (ruleType === "date") {
                        rule["match"] = Date.parse(rule["match"].toString());
                    }
                }
            }
            let ruleWithKey = {
                key: rule.key,
                type: rule.type,
                operation: { op: rule.op },
                match: rule.match,
                relativeMatchNumber: rule.relativeMatchNumber,
                relativeMatchDirection: rule.relativeMatchDirection,
                relativeMatchUnit: rule.relativeMatchUnit,
            };
            groupRulesWithKey.push(ruleWithKey);
        }
        await group.setRules(group.fromConvenientRules(groupRulesWithKey));
    }
    if (previousState === "deleted") {
        await group.run();
    }
    //@ts-ignore
    if (!!configObject["type"]) {
        //@ts-ignore
        if (configObject["type"] === "manual") {
            throw new Error("There are manual Groups. Grouparoo v0.8 removes support for Manual Groups.  Please remove them and try again.");
        }
        else {
            deprecation_1.Deprecation.warnRemoved("config", "Group", "type");
        }
    }
    (0, codeConfig_1.logModel)(group, validate ? "validated" : isNew ? "created" : "updated");
    return { group: [group.id] };
}
exports.loadGroup = loadGroup;
async function deleteGroups(ids) {
    const groups = await __1.Group.scope(null).findAll({
        where: {
            locked: (0, codeConfig_1.getCodeConfigLockKey)(),
            id: { [sequelize_1.Op.notIn]: ids },
            state: { [sequelize_1.Op.ne]: "deleted" },
        },
    });
    for (const i in groups) {
        const group = groups[i];
        await group.update({ state: "deleted", locked: null });
        (0, codeConfig_1.logModel)(group, "deleted");
    }
    return groups.map((instance) => instance.id);
}
exports.deleteGroups = deleteGroups;