ravendb/dist/commonjs/Documents/Operations/TimeSeries/GetTimeSeriesOperation.js

RavenDB client for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.GetTimeSeriesCommand = exports.GetTimeSeriesOperation = void 0;
exports.reviveTimeSeriesRangeResult = reviveTimeSeriesRangeResult;
const TimeSeriesRangeResult_js_1 = require("./TimeSeriesRangeResult.js");
const TypeUtil_js_1 = require("../../../Utility/TypeUtil.js");
const StringUtil_js_1 = require("../../../Utility/StringUtil.js");
const index_js_1 = require("../../../Exceptions/index.js");
const DateUtil_js_1 = require("../../../Utility/DateUtil.js");
const TimeSeriesEntry_js_1 = require("../../Session/TimeSeries/TimeSeriesEntry.js");
const DocumentConventions_js_1 = require("../../Conventions/DocumentConventions.js");
const RavenCommand_js_1 = require("../../../Http/RavenCommand.js");
const StringBuilder_js_1 = require("../../../Utility/StringBuilder.js");
const TimeSeriesIncludeBuilder_js_1 = require("../../Session/Loaders/TimeSeriesIncludeBuilder.js");
class GetTimeSeriesOperation {
    _docId;
    _name;
    _start;
    _pageSize;
    _from;
    _to;
    _includes;
    _returnFullResults;
    constructor(docId, timeseries, from, to, start = 0, pageSize = TypeUtil_js_1.TypeUtil.MAX_INT32, includes, returnFullResults = false) {
        if (StringUtil_js_1.StringUtil.isNullOrEmpty(docId)) {
            (0, index_js_1.throwError)("InvalidArgumentException", "DocId cannot be null or empty");
        }
        if (StringUtil_js_1.StringUtil.isNullOrEmpty(timeseries)) {
            (0, index_js_1.throwError)("InvalidArgumentException", "Timeseries cannot be null or empty");
        }
        this._docId = docId;
        this._start = start;
        this._pageSize = pageSize;
        this._name = timeseries;
        this._from = from;
        this._to = to;
        this._includes = includes;
        this._returnFullResults = returnFullResults;
    }
    get resultType() {
        return "CommandResult";
    }
    getCommand(store, conventions, httpCache) {
        return new GetTimeSeriesCommand(conventions, this._docId, this._name, this._from, this._to, this._start, this._pageSize, this._includes, this._returnFullResults);
    }
}
exports.GetTimeSeriesOperation = GetTimeSeriesOperation;
class GetTimeSeriesCommand extends RavenCommand_js_1.RavenCommand {
    _conventions;
    _docId;
    _name;
    _start;
    _pageSize;
    _from;
    _to;
    _includes;
    _returnFullResults;
    constructor(conventions, docId, name, from, to, start, pageSize, includes, returnFullResults = false) {
        super();
        this._conventions = conventions;
        this._docId = docId;
        this._name = name;
        this._start = start;
        this._pageSize = pageSize;
        this._from = from;
        this._to = to;
        this._includes = includes;
        this._returnFullResults = returnFullResults;
    }
    createRequest(node) {
        const pathBuilder = new StringBuilder_js_1.StringBuilder(node.url);
        pathBuilder
            .append("/databases/")
            .append(node.database)
            .append("/timeseries")
            .append("?docId=")
            .append(this._urlEncode(this._docId));
        if (this._start > 0) {
            pathBuilder
                .append("&start=")
                .append(this._start.toString());
        }
        if (this._pageSize < TypeUtil_js_1.TypeUtil.MAX_INT32) {
            pathBuilder
                .append("&pageSize=")
                .append(this._pageSize.toString());
        }
        pathBuilder
            .append("&name=")
            .append(this._urlEncode(this._name));
        if (this._from) {
            pathBuilder
                .append("&from=")
                .append(encodeURIComponent(DateUtil_js_1.DateUtil.utc.stringify(this._from)));
        }
        if (this._to) {
            pathBuilder
                .append("&to=")
                .append(encodeURIComponent(DateUtil_js_1.DateUtil.utc.stringify(this._to)));
        }
        if (this._includes) {
            GetTimeSeriesCommand.addIncludesToRequest(pathBuilder, this._includes);
        }
        if (this._returnFullResults) {
            pathBuilder
                .append("&full=true");
        }
        const uri = pathBuilder.toString();
        return {
            method: "GET",
            uri
        };
    }
    static addIncludesToRequest(pathBuilder, includes) {
        const includeBuilder = new TimeSeriesIncludeBuilder_js_1.TimeSeriesIncludeBuilder(DocumentConventions_js_1.DocumentConventions.defaultConventions);
        includes(includeBuilder);
        if (includeBuilder.includeTimeSeriesDocument) {
            pathBuilder
                .append("&includeDocument=true");
        }
        if (includeBuilder.includeTimeSeriesTags) {
            pathBuilder
                .append("&includeTags=true");
        }
    }
    async setResponseAsync(bodyStream, fromCache) {
        if (!bodyStream) {
            return;
        }
        let body = null;
        const results = await this._pipeline()
            .parseJsonSync()
            .collectBody(b => body = b)
            .process(bodyStream);
        const transformedResults = GetTimeSeriesCommand.mapToLocalObject(results);
        this.result = reviveTimeSeriesRangeResult(transformedResults);
        return body;
    }
    get isReadRequest() {
        return true;
    }
    static mapToLocalObject(json) {
        const result = {
            to: json.To,
            from: json.From,
            includes: json.Includes,
            totalResults: json.TotalResults,
            entries: json.Entries.map(entry => ({
                timestamp: entry.Timestamp,
                tag: entry.Tag,
                values: entry.Values,
                isRollup: entry.IsRollup,
                nodeValues: entry.NodeValues
            }))
        };
        return result;
    }
}
exports.GetTimeSeriesCommand = GetTimeSeriesCommand;
function reviveTimeSeriesRangeResult(json) {
    const result = new TimeSeriesRangeResult_js_1.TimeSeriesRangeResult();
    const { to, from, entries, ...restProps } = json;
    const entryMapper = (rawEntry) => {
        const result = new TimeSeriesEntry_js_1.TimeSeriesEntry();
        result.timestamp = DateUtil_js_1.DateUtil.utc.parse(rawEntry.timestamp);
        result.isRollup = rawEntry.isRollup;
        result.tag = rawEntry.tag;
        result.values = rawEntry.values;
        result.nodeValues = rawEntry.nodeValues;
        return result;
    };
    const overrides = {
        ...restProps,
        to: DateUtil_js_1.DateUtil.utc.parse(to),
        from: DateUtil_js_1.DateUtil.utc.parse(from),
        entries: entries.map(entryMapper),
    };
    return Object.assign(result, overrides);
}
//# sourceMappingURL=GetTimeSeriesOperation.js.map