@foxpage/foxpage-manager/lib/condition/manager.js

foxpage resource manager

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConditionManagerImpl = void 0;
const common_1 = require("../common");
const data_service_1 = require("../data-service");
const condition_1 = require("./condition");
/**
 * condition manager
 *
 * @export
 * @class ConditionManager impl
 * @extends {ManagerBaseImpl}
 */
class ConditionManagerImpl extends common_1.ManagerBaseImpl {
    constructor(app) {
        super(app, { type: 'condition', diskCache: { enable: true } });
    }
    /**
     * add condition to manager
     *
     * @param {Condition} condition
     */
    addCondition(condition) {
        this.logger.info(`add condition@${condition.id}`);
        this.logger.debug(`add condition@${condition.id}, detail:`, JSON.stringify(condition));
        const instance = this.newCondition(condition);
        this.addOne(condition.id, condition, instance);
        return instance;
    }
    /**
     * remove application conditions
     *
     * @param {string[]} conditionIds
     */
    removeConditions(conditionIds) {
        this.remove(conditionIds);
    }
    /**
     * get condition via conditionId from  local
     *
     * @param {string} conditionId
     * @return {*}  {Promise<Condition|undefined>}
     */
    async getCondition(conditionId) {
        return (await this.find([conditionId]))[0];
    }
    /**
     * get conditions
     *
     * @param {string[]} conditionIds
     * @return {*}  {Promise<Condition[]>}
     */
    async getConditions(conditionIds) {
        return await this.find(conditionIds);
    }
    /**
     * fetch application conditions
     *
     * @param {string[]} conditionIds
     * @return {*}  {Promise<Condition[]>}
     */
    async freshConditions(conditionIds) {
        const conditions = await data_service_1.foxpageDataService.fetchConditions(this.appId, { conditionIds });
        return conditions.map(item => {
            return this.addCondition(item);
        });
    }
    async onFetch(list) {
        return await this.freshConditions(list);
    }
    async onPull(data) {
        const { updates, removes } = data.condition || {};
        if (updates && updates.length > 0) {
            const contentIds = await this.filterExists(updates);
            if (contentIds.length > 0) {
                this.markNeedUpdates(contentIds);
                await this.freshConditions(contentIds);
            }
        }
        if (removes && removes.length > 0) {
            this.removeConditions(removes);
        }
    }
    onStash(data) {
        var _a;
        (_a = data.conditions) === null || _a === void 0 ? void 0 : _a.map(item => {
            this.addCondition(item);
        });
    }
    async createInstance(data) {
        return this.newCondition(data);
    }
    newCondition(data) {
        return new condition_1.ConditionInstance(data);
    }
}
exports.ConditionManagerImpl = ConditionManagerImpl;