@conversationlearner/sdk/lib/Memory/ClientMemoryManager.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const CLStrings_1 = require("../CLStrings");
const CLM = require("@conversationlearner/models");
class ReadOnlyClientMemoryManager {
    constructor(prevMemories, curMemories, allEntities, sessionInfo) {
        this.allEntities = [];
        this.allEntities = allEntities;
        this.sessionInfo = sessionInfo;
        this.prevMemories = prevMemories;
        this.curMemories = curMemories;
        this.__expired = false;
    }
    Expire() {
        this.__expired = true;
    }
    __FindEntity(entityName) {
        return this.allEntities.find(e => e.entityName == entityName);
    }
    __ToString(value) {
        if (typeof value == 'object') {
            return JSON.stringify(value);
        }
        return value.toString();
    }
    /**
     * Get current value of entity
     */
    Get(entityName, converter) {
        return this.GetValues(entityName, this.curMemories, converter);
    }
    /**
     * Get value of entity before most recent input
     */
    GetPrevious(entityName, converter) {
        return this.GetValues(entityName, this.prevMemories, converter);
    }
    /**
     * Get information about the current running session
     */
    SessionInfo() {
        return this.sessionInfo;
    }
    static AS_VALUE(memoryValues) {
        if (memoryValues.length > 1) {
            throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_VALUE_LIST_EXCEPTION);
        }
        return memoryValues.length == 0 ? null : memoryValues[0];
    }
    static AS_VALUE_LIST(memoryValues) {
        return memoryValues;
    }
    static AS_STRING(memoryValues) {
        return memoryValues.length == 0 ? null : CLM.memoryValuesAsString(memoryValues);
    }
    static AS_STRING_LIST(memoryValues) {
        return memoryValues.map(mv => {
            if (typeof mv.userText !== 'string') {
                throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_STRING_EXCEPTION);
            }
            return mv.userText;
        });
    }
    static AS_NUMBER(memoryValues) {
        if (memoryValues.length == 0) {
            return null;
        }
        if (memoryValues.length > 1) {
            throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NUMBER_LIST_EXCEPTION);
        }
        const number = Number(memoryValues[0].userText);
        if (isNaN(number)) {
            throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_NUMBER_EXCEPTION);
        }
        return number;
    }
    static AS_NUMBER_LIST(memoryValues) {
        return memoryValues.map(mv => {
            let number = Number(mv.userText);
            if (isNaN(number)) {
                throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_NUMBER_EXCEPTION);
            }
            return number;
        });
    }
    static AS_BOOLEAN(memoryValues) {
        if (memoryValues.length == 0) {
            return null;
        }
        if (memoryValues.length > 1) {
            throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_BOOLEAN_LIST_EXCEPTION);
        }
        let text = CLM.memoryValuesAsString(memoryValues);
        if (text.toLowerCase() === 'true') {
            return true;
        }
        if (text.toLowerCase() === 'false') {
            return false;
        }
        throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_BOOLEAN_EXCEPTION);
    }
    static AS_BOOLEAN_LIST(memoryValues) {
        return memoryValues.map(mv => {
            if (!mv.userText) {
                throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_BOOLEAN_EXCEPTION);
            }
            if (mv.userText.toLowerCase() === 'true') {
                return true;
            }
            if (mv.userText.toLowerCase() === 'false') {
                return false;
            }
            throw new Error(CLStrings_1.CLStrings.MEMORY_MANAGER_NOT_A_BOOLEAN_EXCEPTION);
        });
    }
    GetValues(entityName, entityMap, converter) {
        let values = entityMap.Values(entityName);
        const entity = this.__FindEntity(entityName);
        if (entity && entity.entityType === CLM.EntityType.LUIS && entity.enumValues) {
            for (let value of values) {
                const enumValue = entity.enumValues.find(ev => ev.enumValue === value.enumValueId);
                value.displayText = enumValue ? enumValue.enumValue : null;
            }
        }
        // cast to conditional type is necessary
        // see here for description https://github.com/Microsoft/TypeScript/issues/22735#issuecomment-376960435
        if (!converter) {
            const entityValues = entityMap.Values(entityName);
            const foundEntity = this.__FindEntity(entityName);
            if (foundEntity && !foundEntity.isMultivalue) {
                return ClientMemoryManager.AS_VALUE(entityValues);
            }
            return entityValues;
        }
        return converter(entityMap.Values(entityName));
    }
}
exports.ReadOnlyClientMemoryManager = ReadOnlyClientMemoryManager;
class ClientMemoryManager extends ReadOnlyClientMemoryManager {
    constructor(prevMemories, curMemories, allEntities, sessionInfo) {
        super(prevMemories, curMemories, allEntities, sessionInfo);
        this.DeleteAll = () => this.DeleteAllExcept();
    }
    AsReadOnly() {
        return this;
    }
    Set(entityName, value) {
        if (this.__expired) {
            throw new Error(`ClientMemoryManager: RememberEntity "${entityName}" ${CLStrings_1.CLStrings.MEMORY_MANAGER_EXPIRED_EXCEPTION}`);
        }
        let entity = this.__FindEntity(entityName);
        if (!entity) {
            throw new Error(`${CLStrings_1.CLStrings.API_MISSING_ENTITY} ${entityName}`);
        }
        if (CLM.isPrebuilt(entity)) {
            throw new Error(`${CLStrings_1.CLStrings.MEMORY_MANAGER_PRETRAINED_EXCEPTION} ${entityName}`);
        }
        // ENUM entity type
        if (entity.entityType === CLM.EntityType.ENUM && entity.enumValues) {
            const stringVal = this.__ToString(value).toUpperCase();
            const enumValue = entity.enumValues.find(ev => ev.enumValue === stringVal);
            if (!enumValue) {
                const enumValues = entity.enumValues.map(ev => ev.enumValue).join(", ");
                // Throw w/o a stack trace
                throw `"${entityName}"${CLStrings_1.CLStrings.MEMORY_MANAGER_INVALID_ENUM_EXCEPTION1}"${stringVal}"${CLStrings_1.CLStrings.MEMORY_MANAGER_INVALID_ENUM_EXCEPTION2}(${enumValues})`;
            }
            else {
                // Store ENUM ID not the string value
                this.curMemories.Remember(entity.entityName, entity.entityId, enumValue.enumValue, entity.isMultivalue, null, null, enumValue.enumValueId);
            }
        }
        else if (Array.isArray(value)) {
            if (!entity.isMultivalue) {
                throw new Error(`Array passed to Set for entity (${entityName}) that isn't Multi-Value.`);
            }
            let stringValues = value.map((v) => {
                return this.__ToString(v);
            });
            this.curMemories.RememberMany(entity.entityName, entity.entityId, stringValues, entity.isMultivalue);
        }
        else {
            let stringValue = this.__ToString(value);
            this.curMemories.Remember(entity.entityName, entity.entityId, stringValue, entity.isMultivalue);
        }
    }
    Delete(entityName, value = null) {
        if (this.__expired) {
            throw new Error(`ClientMemoryManager: ForgetEntity "${entityName}" ${CLStrings_1.CLStrings.MEMORY_MANAGER_EXPIRED_EXCEPTION}`);
        }
        let entity = this.__FindEntity(entityName);
        if (!entity) {
            throw new Error(`${CLStrings_1.CLStrings.API_MISSING_ENTITY} ${entityName}`);
        }
        this.curMemories.Forget(entity.entityName, value, entity.isMultivalue);
    }
    /** Delete all entity values apart from any included in the list of saveEntityNames
     * @param saveEntityNames Array of entity names not to forget
     */
    DeleteAllExcept(...saveEntityNames) {
        if (this.__expired) {
            throw new Error(`ClientMemoryManager: DeleteAll ${CLStrings_1.CLStrings.MEMORY_MANAGER_EXPIRED_EXCEPTION}`);
        }
        for (let entity of this.allEntities) {
            if (saveEntityNames.indexOf(entity.entityName) < 0) {
                this.curMemories.Forget(entity.entityName, null, entity.isMultivalue);
            }
        }
    }
    /**
     * Copy values from one entity to another
     * @param entityNameFrom Source Entity
     * @param entityNameTo Destination Entity
     */
    Copy(entityNameFrom, entityNameTo) {
        if (this.__expired) {
            throw new Error(`ClientMemoryManager: Copy ${CLStrings_1.CLStrings.MEMORY_MANAGER_EXPIRED_EXCEPTION}`);
        }
        let entityFrom = this.__FindEntity(entityNameFrom);
        let entityTo = this.__FindEntity(entityNameTo);
        if (!entityFrom) {
            throw new Error(`${CLStrings_1.CLStrings.API_MISSING_ENTITY} ${entityNameFrom}`);
        }
        if (!entityTo) {
            throw new Error(`${CLStrings_1.CLStrings.API_MISSING_ENTITY} ${entityNameTo}`);
        }
        if (entityFrom.isMultivalue != entityTo.isMultivalue) {
            throw new Error(`Can't copy between multivalue and non-multivalue Entity (${entityNameFrom} -> ${entityNameTo})`);
        }
        // Clear "To" entity
        this.curMemories.Forget(entityNameTo);
        // Get value of "From" entity
        let values = this.curMemories.ValueAsList(entityNameFrom);
        // Copy values from "From"
        for (let value of values) {
            this.Set(entityNameTo, value);
        }
    }
}
exports.ClientMemoryManager = ClientMemoryManager;
//# sourceMappingURL=ClientMemoryManager.js.map