ngx-hana-nameserver-history-viewer 1.1.3 → 1.1.9-3.beta

package/esm2020/src/nameserver-history-viewer/services/file.service.mjs

@@ -0,0 +1,390 @@
+import { Injectable } from '@angular/core';
+import { calculateValue, calculateValue4Time, getDefaultPort, getPort, getTimeFromTimeZone, isSamePort, isValidPort, printProcessedTime, validateData } from '../utils';
+import { parse } from 'papaparse';
+import { Abort } from '../types';
+import * as i0 from "@angular/core";
+/**
+ * prevent browser from crashing, set the max rows limitation.
+ * This could be overwritten by the input:maxRowsLimitation of the component.
+ */
+const _DEFAULT_MAX_ROWS_IN_MEMORY = 100000;
+export class FileService {
+    /**
+     * prevent browser from crashing, set the max rows limitation.
+     * @param limitation if this parameter is not null, the default value will be overwritten by this one.
+     */
+    static _getMaxRowsLimitation(limitation = null) {
+        if (limitation == null || isNaN(limitation) || limitation.length === 0) {
+            return _DEFAULT_MAX_ROWS_IN_MEMORY;
+        }
+        return Number(limitation);
+    }
+    /**
+     * get all available ports from data
+     */
+    static _getPorts(data, firstChunk, ports) {
+        let line = 0;
+        if (firstChunk) {
+            // start from line 3
+            line = 2;
+        }
+        for (; line < data.length; line++) {
+            const dataItem = data[line][1];
+            if (dataItem != null && dataItem.length > 0) {
+                if (isValidPort(dataItem) && ports.indexOf(dataItem) === -1) {
+                    ports.push(dataItem);
+                }
+            }
+        }
+    }
+    /**
+     * get the time column from the analyzed data
+     * @param data the analyzed data
+     * @param firstChunk whether it's first chunk or not
+     * @param startTime selected starting time. It's millisecond, need to be converted second.
+     * @param endTime selected ending time. It's millisecond, need to be converted second.
+     * @param lastProcessedTime last processed time form last chunk
+     * @param time time object which contains the time data for all ports
+     * @param selectedPort if the selected port is empty (did not select any port), all ports info are needed
+     * @param isMDC flag for MDC system
+     * @param timezone selected timezone
+     * @param maxRowsLimitation prevent browser from crashing, set the max rows limitation.
+     * This comes from the input: maxRowsLimitation of the component.
+     */
+    static _getTimeColumn(data, firstChunk, startTime, endTime, lastProcessedTime, time, selectedPort, isMDC, timezone, maxRowsLimitation) {
+        // convert millisecond to second for startTime and endTime.
+        startTime = startTime / 1000;
+        endTime = endTime / 1000;
+        const timeColumn = 2;
+        let startLine = 0;
+        let iStart = -1;
+        let iEnd = -1;
+        let curTime = lastProcessedTime;
+        let lastProcessedTimeReturn;
+        let totalNum = 0;
+        let mdcFlag = isMDC;
+        const defaultPort = getDefaultPort();
+        const maxRowNum = this._getMaxRowsLimitation(maxRowsLimitation);
+        if (firstChunk) {
+            if (curTime >= startTime && curTime <= endTime) {
+                iStart = 1; // start from first line
+                /** Modified at 2018/10/10,
+                 * in some case, eg: the nameserver history trace gets modified by Kook, Jin Young's python script,
+                 * the port show in the first line as well, and does not like the non-mdc system, this kind of file has
+                 * one port in it. The history for non-mdc system doesn't have port info in the port column.*/
+                // get port for the line 1.
+                const firstLinePort = getPort(data[1][1]);
+                // init time array for the first line.
+                if (!selectedPort || selectedPort.length === 0 || isSamePort(firstLinePort, selectedPort, mdcFlag)) {
+                    // does not select any port or
+                    // it's non-mdc (mdcFlag is false at the beginning) system and the selected port is the first line port
+                    time[firstLinePort] = [];
+                    time[firstLinePort][0] = curTime * 1000;
+                }
+            }
+            lastProcessedTimeReturn = curTime;
+            startLine = 2;
+        }
+        // get current total number
+        Object.keys(time).forEach(key => {
+            if (time[key]) {
+                totalNum += time[key].length;
+            }
+        });
+        if (curTime == null) {
+            console.error('getTimeColumn', 'Can not get the time from the file, internal error!');
+            return { indexStart: null, indexEnd: null, lastProcessedTime: null, isMDC: null };
+        }
+        for (let i = startLine; i < data.length; i++) {
+            // sometime the last line is empty, need to be skipped.
+            if (data[i] == null || data[i].length === 0 || (data[i].length === 1 && data[i][0].length === 0)) {
+                continue;
+            }
+            // get port number and initialize the relative port array in time
+            const port = getPort(data[i][1]); // data[i][1] == null || data[i][1].length == 0 ? __DEFAULT_PORT : data[i][1];
+            if (!(port in time)) {
+                // add undefined port to time, then we can find all ports in time
+                time[port] = void 0;
+            }
+            if (time[port] == null && isSamePort(port, selectedPort, mdcFlag)) {
+                time[port] = [];
+                // if other ports exists in this file, default port will be set to undefined.
+                if (!mdcFlag && port !== defaultPort && time[defaultPort]) {
+                    // update the total num;
+                    totalNum -= time[defaultPort].length;
+                    time[defaultPort].length = 0;
+                    time[defaultPort] = void 0;
+                    mdcFlag = true;
+                }
+            }
+            curTime = calculateValue4Time(curTime, data[i][timeColumn], timezone);
+            if (curTime > endTime) {
+                if (iEnd < 0) {
+                    iEnd = i - 1;
+                }
+                break;
+            }
+            if (iStart >= 0) {
+                if (time[port]) {
+                    // not null means it's the selected port
+                    time[port][time[port].length] = curTime * 1000;
+                    totalNum++;
+                }
+            }
+            else {
+                if (curTime >= startTime && curTime <= endTime) {
+                    if (time[port]) {
+                        // only selected port counted in
+                        if (iStart < 0) {
+                            iStart = i;
+                        }
+                        time[port][time[port].length] = curTime * 1000;
+                        totalNum++;
+                    }
+                }
+            }
+            // last processed time need to be recorded anyway
+            lastProcessedTimeReturn = curTime;
+            if (totalNum >= maxRowNum) {
+                iEnd = i;
+                break;
+            }
+        }
+        return { indexStart: iStart, indexEnd: iEnd, lastProcessedTime: lastProcessedTimeReturn, isMDC: mdcFlag };
+    }
+    /**
+     * Get data for all columns
+     * @param columnNum the total number of columns. For mdc system,
+     *                  the length of each row is different. Host relative data does not exist in tenant line.
+     *                  Needs to use column number from the first line.
+     * @param data      data parsed by papa
+     * @param firstChunk the flag which identifies whether it's the first chunk or not.
+     * @param time
+     * @param indexStart
+     * @param indexEnd
+     * @param lastProcessedLine
+     * @param resultData   the result data after analyzed
+     * @param selectedPort
+     * @param isMDC
+     */
+    static _getDataColumns(columnNum, data, firstChunk, time, indexStart, indexEnd, lastProcessedLine, resultData, selectedPort, isMDC) {
+        let startLine = 0;
+        // for mdc system, the length is not correct (host relative data only exists in the "empty" port line).
+        // Needs to use header from the first line.
+        // const columnNum = data[0].length;
+        if (firstChunk) {
+            /**
+             * Modified at 2018/10/10,
+             * in some case, eg: the nameserver history trace gets modified by Kook, Jin Young's python script,
+             * the port show in the first line as well, and does not like the non-mdc system, this kind of file has
+             * one port in it. The history for non-mdc system doesn't have port info in the port column.
+             */
+            // get port for the line 1.
+            const firstLinePort = getPort(data[1][1]);
+            // Initialize data column with default 'DEFAULT' port if it's not MDC system. MDC system, 'DEFAULT' gets ignored
+            if (!isMDC && time[firstLinePort]) {
+                resultData[firstLinePort] = [];
+                // removed below logic, because first line is the real number, do not need to do the convert.
+                // curLine = data[1].slice(3).map(Number);
+                for (let j = 3; j < columnNum; j++) {
+                    const index = j - 3;
+                    // initialize data array for all columns of the default '0000' port
+                    resultData[firstLinePort][index] = [];
+                    // get the first line data of the column if it's included
+                    if (indexStart === 1) {
+                        resultData[firstLinePort][index][0] = { x: time[firstLinePort][0], y: lastProcessedLine[index] };
+                    }
+                }
+            }
+            startLine = 2;
+        }
+        for (let j = 3; j < columnNum; j++) {
+            const index = j - 3;
+            for (let i = startLine; i < data.length; i++) {
+                // sometime the last line is empty, need to be skipped.
+                if (data[i] == null || data[i].length === 0 || (data[i].length === 1 && data[i][0].length === 0)) {
+                    continue;
+                }
+                // get port number and initialize the relative port array in data
+                const port = getPort(data[i][1]);
+                if (resultData[port] == null && isSamePort(port, selectedPort, isMDC)) {
+                    resultData[port] = [];
+                }
+                if (resultData[port] && resultData[port][index] == null) {
+                    resultData[port][index] = [];
+                }
+                lastProcessedLine[index] = calculateValue(lastProcessedLine[index], data[i][j]);
+                if (i >= indexStart && (i <= indexEnd || indexEnd < 0) && indexStart >= 0) {
+                    if (resultData[port]) {
+                        const length = resultData[port][index].length;
+                        resultData[port][index][length] = { x: time[port][length], y: lastProcessedLine[index] };
+                    }
+                }
+                else if (indexEnd > 0 && i > indexEnd) {
+                    break;
+                }
+            }
+        }
+    }
+    /**
+     * Get Chart data from provided file.
+     * @param file the nameserver history file
+     * @param startTime
+     * @param endTime
+     * @param port
+     * @param timezone
+     * @param maxRowsLimitation prevent browser from crashing, set the max rows limitation.
+     * @param progress call back function for updating progress
+     */
+    getChartContentFromFile(file, startTime, endTime, port, timezone, maxRowsLimitation, progress) {
+        // load done, beginning parsing
+        const beginTime = new Date();
+        let firstChunk = true;
+        // save last processed data just for the later calculation
+        let lastProcessedData;
+        // save last processed time just for the later calculation
+        let lastProcessedTime;
+        // save last processed cursor position for progress calculation.
+        // let lastProcessedCursor = 0;
+        let indexStart = -1, indexEnd = -1;
+        const time = {};
+        const data = {};
+        let header;
+        let host;
+        let isMDC = false;
+        let columnNum;
+        let abortType;
+        const rejectAndAbort = (reject, parser) => {
+            if (progress) {
+                progress(100);
+            }
+            reject(`${file.name} is empty or the format is not correct.`);
+            parser.abort();
+        };
+        return new Promise((resolve, reject) => {
+            parse(file, {
+                chunk: (results, parser) => {
+                    // the progress increment of this step
+                    // let analyzeStepProgress = (results.meta.cursor - lastProcessedCursor) / file.size * 100;
+                    printProcessedTime(beginTime, 'step1');
+                    if (indexEnd >= 0) {
+                        // already finished, quite.
+                        return;
+                    }
+                    else {
+                        // reset start point
+                        indexStart = -1;
+                    }
+                    // get time column
+                    if (firstChunk) {
+                        if (!validateData(results.data)) {
+                            return rejectAndAbort(reject, parser);
+                        }
+                        // initialize the header
+                        header = results.data[0].slice(3);
+                        // get column number
+                        columnNum = results.data[0].length;
+                        // get host name
+                        host = results.data[1][0];
+                        // get the first line time info from first line, it is a real number, do not need to do the convert with ">,<".
+                        lastProcessedTime = getTimeFromTimeZone(parseFloat(results.data[1][2]), timezone);
+                        // get the first line data info from first line, it is a real number, do not need to do the convert with ">,<".
+                        lastProcessedData = results.data[1].slice(3).map(Number);
+                    }
+                    printProcessedTime(beginTime, 'step2');
+                    if (!lastProcessedData) {
+                        return rejectAndAbort(reject, parser);
+                    }
+                    // get time column
+                    ({ indexStart, indexEnd, lastProcessedTime, isMDC } = FileService._getTimeColumn(results.data, firstChunk, startTime, endTime, lastProcessedTime, time, port, isMDC, timezone, maxRowsLimitation));
+                    printProcessedTime(beginTime, 'step3');
+                    if (indexStart == null && indexEnd == null && lastProcessedTime == null && isMDC == null) {
+                        return rejectAndAbort(reject, parser);
+                    }
+                    // get all other data columns
+                    FileService._getDataColumns(columnNum, results.data, firstChunk, time, indexStart, indexEnd, lastProcessedData, data, port, isMDC);
+                    if (firstChunk) {
+                        firstChunk = false;
+                    }
+                    printProcessedTime(beginTime, 'step4');
+                    if (indexEnd >= 0) {
+                        // do not need to process the left parts, manually trigger complete
+                        const processedLines = Object.keys(time).reduce((total, curKey) => time[curKey] ? total + time[curKey].length : total, 0);
+                        if (processedLines >= FileService._getMaxRowsLimitation(maxRowsLimitation)) {
+                            abortType = Abort.maxLineNumReached;
+                        }
+                        else {
+                            abortType = Abort.maxTimeRangeReached;
+                        }
+                        if (progress) {
+                            progress(100);
+                        }
+                        parser.abort();
+                        return;
+                    }
+                    else {
+                        // the overall progress if this step is finished
+                        if (progress) {
+                            progress(Math.round(results.meta.cursor / file.size * 100));
+                        }
+                        // lastProcessedCursor = results.meta.cursor;
+                    }
+                },
+                complete: () => {
+                    printProcessedTime(beginTime, 'step_complete');
+                    resolve({ header: header, host: host, time: time, data: data, aborted: abortType });
+                }
+            });
+        });
+    }
+    /**
+     * Get all ports from the name server history file
+     * @param file the name server history file
+     * @param progress call back for updating the progress
+     */
+    getPortsFromFile(file, progress) {
+        const beginTime = new Date();
+        let firstChunk = true;
+        const ports = [];
+        const defaultPort = getDefaultPort();
+        return new Promise((resolve, reject) => {
+            parse(file, {
+                chunk: (results, parser) => {
+                    // get time column
+                    if (firstChunk) {
+                        if (!validateData(results.data)) {
+                            if (progress) {
+                                progress(100);
+                            }
+                            reject(`${file.name} is empty or the format is not correct.`);
+                            parser.abort();
+                            return;
+                        }
+                    }
+                    printProcessedTime(beginTime, 'port.step1');
+                    FileService._getPorts(results.data, firstChunk, ports);
+                    if (firstChunk) {
+                        firstChunk = false;
+                    }
+                    if (progress) {
+                        progress(Math.round(results.meta.cursor / file.size * 100));
+                    }
+                },
+                complete: () => {
+                    // parsing done
+                    printProcessedTime(beginTime, 'step_complete');
+                    if (ports.length === 0) {
+                        ports[0] = defaultPort;
+                    }
+                    resolve(ports);
+                }
+            });
+        });
+    }
+}
+FileService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FileService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.11", ngImport: i0, type: FileService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file.service.js","sourceRoot":"","sources":["../../../../../src/nameserver-history-viewer/services/file.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,cAAc,EACd,mBAAmB,EACnB,cAAc,EACd,OAAO,EACP,mBAAmB,EACnB,UAAU,EACV,WAAW,EACX,kBAAkB,EAClB,YAAY,EACb,MAAM,UAAU,CAAC;AAClB,OAAO,EAAC,KAAK,EAAC,MAAM,WAAW,CAAC;AAChC,OAAO,EAAC,KAAK,EAAmD,MAAM,UAAU,CAAC;;AAEjF;;;GAGG;AACH,MAAM,2BAA2B,GAAG,MAAM,CAAC;AAG3C,MAAM,OAAO,WAAW;IACtB;;;OAGG;IACK,MAAM,CAAC,qBAAqB,CAAC,aAAkB,IAAI;QACzD,IAAI,UAAU,IAAI,IAAI,IAAI,KAAK,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YACtE,OAAO,2BAA2B,CAAC;SACpC;QACD,OAAO,MAAM,CAAC,UAAU,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACK,MAAM,CAAC,SAAS,CAAC,IAAgB,EAAE,UAAmB,EAAE,KAAe;QAC7E,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,IAAI,UAAU,EAAE;YACd,oBAAoB;YACpB,IAAI,GAAG,CAAC,CAAC;SACV;QAED,OAAO,IAAI,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE;YACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/B,IAAI,QAAQ,IAAI,IAAI,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;gBAC3C,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE;oBAC3D,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBACtB;aACF;SACF;IACH,CAAC;IAED;;;;;;;;;;;;;OAaG;IACK,MAAM,CAAC,cAAc,CAAC,IAAgB,EAChB,UAAmB,EACnB,SAAiB,EACjB,OAAe,EACf,iBAAyB,EACzB,IAAsB,EACtB,YAAoB,EACpB,KAAc,EACd,QAAgB,EAChB,iBAAsB;QAClD,2DAA2D;QAC3D,SAAS,GAAG,SAAS,GAAG,IAAI,CAAC;QAC7B,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;QACzB,MAAM,UAAU,GAAG,CAAC,CAAC;QACrB,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,IAAI,MAAM,GAAG,CAAC,CAAC,CAAC;QAChB,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC;QAEd,IAAI,OAAO,GAAG,iBAAiB,CAAC;QAChC,IAAI,uBAAuB,CAAC;QAC5B,IAAI,QAAQ,GAAG,CAAC,CAAC;QACjB,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;QACrC,MAAM,SAAS,GAAG,IAAI,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;QAEhE,IAAI,UAAU,EAAE;YACd,IAAI,OAAO,IAAI,SAAS,IAAI,OAAO,IAAI,OAAO,EAAE;gBAC9C,MAAM,GAAG,CAAC,CAAC,CAAC,wBAAwB;gBAEpC;;;8GAG8F;gBAE5F,2BAA2B;gBAC7B,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC1C,sCAAsC;gBACtC,IAAI,CAAC,YAAY,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,IAAI,UAAU,CAAC,aAAa,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;oBAClG,8BAA8B;oBAC9B,uGAAuG;oBACvG,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;oBACzB,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;iBACzC;aACF;YACD,uBAAuB,GAAG,OAAO,CAAC;YAClC,SAAS,GAAG,CAAC,CAAC;SACf;QAED,2BAA2B;QAC3B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YAC9B,IAAI,IAAI,CAAC,GAAG,CAAC,EAAE;gBACb,QAAQ,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;aAC9B;QACH,CAAC,CAAC,CAAC;QAEH,IAAI,OAAO,IAAI,IAAI,EAAE;YACnB,OAAO,CAAC,KAAK,CAAC,eAAe,EAAE,qDAAqD,CAAC,CAAC;YACtF,OAAO,EAAC,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,iBAAiB,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAC,CAAC;SACjF;QAED,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5C,uDAAuD;YACvD,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;gBAChG,SAAS;aACV;YAED,iEAAiE;YACjE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,8EAA8E;YAChH,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE;gBACnB,iEAAiE;gBACjE,IAAI,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;aACrB;YACD,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE;gBACjE,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;gBAChB,6EAA6E;gBAC7E,IAAI,CAAC,OAAO,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,CAAC,WAAW,CAAC,EAAE;oBACzD,wBAAwB;oBACxB,QAAQ,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;oBACrC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;oBAC7B,IAAI,CAAC,WAAW,CAAC,GAAG,KAAK,CAAC,CAAC;oBAC3B,OAAO,GAAG,IAAI,CAAC;iBAChB;aACF;YACD,OAAO,GAAG,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,QAAQ,CAAC,CAAC;YACtE,IAAI,OAAO,GAAG,OAAO,EAAE;gBACrB,IAAI,IAAI,GAAG,CAAC,EAAE;oBACZ,IAAI,GAAG,CAAC,GAAG,CAAC,CAAC;iBACd;gBACD,MAAM;aACP;YACD,IAAI,MAAM,IAAI,CAAC,EAAE;gBACf,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;oBACd,wCAAwC;oBACxC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;oBAC/C,QAAQ,EAAG,CAAC;iBACb;aACF;iBAAM;gBACL,IAAI,OAAO,IAAI,SAAS,IAAI,OAAO,IAAI,OAAO,EAAE;oBAC9C,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE;wBACd,gCAAgC;wBAChC,IAAI,MAAM,GAAG,CAAC,EAAE;4BACd,MAAM,GAAG,CAAC,CAAC;yBACZ;wBACD,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,OAAO,GAAG,IAAI,CAAC;wBAC/C,QAAQ,EAAG,CAAC;qBACb;iBACF;aACF;YACD,iDAAiD;YACjD,uBAAuB,GAAG,OAAO,CAAC;YAElC,IAAI,QAAQ,IAAI,SAAS,EAAE;gBACzB,IAAI,GAAG,CAAC,CAAC;gBACT,MAAM;aACP;SACF;QACD,OAAO,EAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,KAAK,EAAE,OAAO,EAAC,CAAC;IAC1G,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACK,MAAM,CAAC,eAAe,CAAC,SAAiB,EACjB,IAAgB,EAChB,UAAmB,EACnB,IAAsB,EACtB,UAAkB,EAClB,QAAgB,EAChB,iBAA2B,EAC3B,UAA4B,EAC5B,YAAoB,EACpB,KAAc;QAC3C,IAAI,SAAS,GAAG,CAAC,CAAC;QAClB,uGAAuG;QACvG,2CAA2C;QAC3C,oCAAoC;QAEpC,IAAI,UAAU,EAAE;YACd;;;;;eAKG;YAEH,2BAA2B;YAC3B,MAAM,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC1C,gHAAgH;YAChH,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,aAAa,CAAC,EAAE;gBACjC,UAAU,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;gBAC/B,6FAA6F;gBAC7F,0CAA0C;gBAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;oBAClC,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;oBAEpB,mEAAmE;oBACnE,UAAU,CAAC,aAAa,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;oBACtC,yDAAyD;oBACzD,IAAI,UAAU,KAAK,CAAC,EAAE;wBACpB,UAAU,CAAC,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAC,CAAC,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,EAAC,CAAC;qBAChG;iBACF;aACF;YACD,SAAS,GAAG,CAAC,CAAC;SACf;QAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE;YAClC,MAAM,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC;YACpB,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC5C,uDAAuD;gBACvD,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,EAAE;oBAChG,SAAS;iBACV;gBAED,iEAAiE;gBACjE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACjC,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,UAAU,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,CAAC,EAAE;oBACrE,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;iBACvB;gBACD,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE;oBACvD,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;iBAC9B;gBAED,iBAAiB,CAAC,KAAK,CAAC,GAAG,cAAc,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAChF,IAAI,CAAC,IAAI,UAAU,IAAI,CAAC,CAAC,IAAI,QAAQ,IAAI,QAAQ,GAAG,CAAC,CAAC,IAAI,UAAU,IAAI,CAAC,EAAE;oBACzE,IAAI,UAAU,CAAC,IAAI,CAAC,EAAE;wBACpB,MAAM,MAAM,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;wBAC9C,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,GAAG,EAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,EAAC,CAAC;qBACxF;iBACF;qBAAM,IAAI,QAAQ,GAAG,CAAC,IAAI,CAAC,GAAG,QAAQ,EAAE;oBACvC,MAAM;iBACP;aACF;SACF;IACH,CAAC;IAED;;;;;;;;;OASG;IACI,uBAAuB,CAAC,IAAU,EACV,SAAiB,EACjB,OAAe,EACf,IAAY,EACZ,QAAgB,EAChB,iBAAsB,EACtB,QAAa;QAC1C,+BAA+B;QAC/B,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAC7B,IAAI,UAAU,GAAG,IAAI,CAAC;QACtB,0DAA0D;QAC1D,IAAI,iBAAiB,CAAC;QACtB,0DAA0D;QAC1D,IAAI,iBAAiB,CAAC;QACtB,gEAAgE;QAChE,+BAA+B;QAC/B,IAAI,UAAU,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAC;QACnC,MAAM,IAAI,GAAqB,EAAE,CAAC;QAClC,MAAM,IAAI,GAAqB,EAAE,CAAC;QAClC,IAAI,MAAM,CAAC;QACX,IAAI,IAAI,CAAC;QACT,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,SAAS,CAAC;QACd,IAAI,SAAgB,CAAC;QAErB,MAAM,cAAc,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE;YACxC,IAAI,QAAQ,EAAE;gBACZ,QAAQ,CAAC,GAAG,CAAC,CAAC;aACf;YACD,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,yCAAyC,CAAC,CAAC;YAC9D,MAAM,CAAC,KAAK,EAAE,CAAC;QACjB,CAAC,CAAC;QACF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,KAAK,CAAC,IAAI,EAAE;gBACV,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBACzB,sCAAsC;oBACtC,2FAA2F;oBAC3F,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBACvC,IAAI,QAAQ,IAAI,CAAC,EAAE;wBACjB,2BAA2B;wBAC3B,OAAO;qBACR;yBAAM;wBACL,oBAAoB;wBACpB,UAAU,GAAG,CAAC,CAAC,CAAC;qBACjB;oBAED,kBAAkB;oBAClB,IAAI,UAAU,EAAE;wBACd,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;4BAC/B,OAAO,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;yBACvC;wBAED,wBAAwB;wBACxB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;wBAClC,oBAAoB;wBACpB,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;wBACnC,gBAAgB;wBAChB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;wBAC1B,+GAA+G;wBAC/G,iBAAiB,GAAG,mBAAmB,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;wBAClF,+GAA+G;wBAC/G,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;qBAC1D;oBAED,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBAEvC,IAAI,CAAC,iBAAiB,EAAE;wBACtB,OAAO,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;qBACvC;oBAED,kBAAkB;oBAClB,CAAC,EAAC,UAAU,EAAE,QAAQ,EAAE,iBAAiB,EAAE,KAAK,EAAC,GAAG,WAAW,CAAC,cAAc,CAC5E,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,iBAAiB,CAAC,CAAC,CAAC;oBACpH,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBAEvC,IAAI,UAAU,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,IAAI,iBAAiB,IAAI,IAAI,IAAI,KAAK,IAAI,IAAI,EAAE;wBACxF,OAAO,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;qBACvC;oBAED,6BAA6B;oBAC7B,WAAW,CAAC,eAAe,CACzB,SAAS,EAAE,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC;oBAEzG,IAAI,UAAU,EAAE;wBACd,UAAU,GAAG,KAAK,CAAC;qBACpB;oBAED,kBAAkB,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;oBAEvC,IAAI,QAAQ,IAAI,CAAC,EAAE;wBACjB,mEAAmE;wBACnE,MAAM,cAAc,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;wBAC1H,IAAI,cAAc,IAAI,WAAW,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,EAAE;4BAC1E,SAAS,GAAG,KAAK,CAAC,iBAAiB,CAAC;yBACrC;6BAAM;4BACL,SAAS,GAAG,KAAK,CAAC,mBAAmB,CAAC;yBACvC;wBAED,IAAI,QAAQ,EAAE;4BACZ,QAAQ,CAAC,GAAG,CAAC,CAAC;yBACf;wBACD,MAAM,CAAC,KAAK,EAAE,CAAC;wBACf,OAAO;qBACR;yBAAM;wBACL,gDAAgD;wBAChD,IAAI,QAAQ,EAAE;4BACZ,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC;yBAC7D;wBACD,6CAA6C;qBAC9C;gBACH,CAAC;gBACD,QAAQ,EAAE,GAAG,EAAE;oBACb,kBAAkB,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;oBAC/C,OAAO,CAAE,EAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAC,CAAC,CAAC;gBACrF,CAAC;aACF,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,IAAU,EAAE,QAAa;QAC/C,MAAM,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAC7B,IAAI,UAAU,GAAG,IAAI,CAAC;QACtB,MAAM,KAAK,GAAG,EAAE,CAAC;QACjB,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;QACrC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,KAAK,CAAC,IAAI,EAAE;gBACV,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;oBACzB,kBAAkB;oBAClB,IAAI,UAAU,EAAE;wBACd,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;4BAC/B,IAAI,QAAQ,EAAE;gCACZ,QAAQ,CAAC,GAAG,CAAC,CAAC;6BACf;4BACD,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,yCAAyC,CAAC,CAAC;4BAC9D,MAAM,CAAC,KAAK,EAAE,CAAC;4BACf,OAAO;yBACR;qBACF;oBACD,kBAAkB,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;oBAC5C,WAAW,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;oBACvD,IAAI,UAAU,EAAE;wBACd,UAAU,GAAG,KAAK,CAAC;qBACpB;oBACD,IAAI,QAAQ,EAAE;wBACZ,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC;qBAC7D;gBACH,CAAC;gBACD,QAAQ,EAAE,GAAG,EAAE;oBACb,eAAe;oBACf,kBAAkB,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;oBAC/C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;wBACtB,KAAK,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC;qBACxB;oBACD,OAAO,CAAE,KAAK,CAAC,CAAC;gBAClB,CAAC;aACF,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;;yGA1aU,WAAW;6GAAX,WAAW;4FAAX,WAAW;kBADvB,UAAU","sourcesContent":["import {Injectable} from '@angular/core';\r\nimport {\r\n  calculateValue,\r\n  calculateValue4Time,\r\n  getDefaultPort,\r\n  getPort,\r\n  getTimeFromTimeZone,\r\n  isSamePort,\r\n  isValidPort,\r\n  printProcessedTime,\r\n  validateData\r\n} from '../utils';\r\nimport {parse} from 'papaparse';\r\nimport {Abort, ChartContent, ChartContentData, ChartContentTime} from '../types';\r\n\r\n/**\r\n * prevent browser from crashing, set the max rows limitation.\r\n * This could be overwritten by the input:maxRowsLimitation of the component.\r\n */\r\nconst _DEFAULT_MAX_ROWS_IN_MEMORY = 100000;\r\n\r\n@Injectable()\r\nexport class FileService {\r\n  /**\r\n   * prevent browser from crashing, set the max rows limitation.\r\n   * @param limitation if this parameter is not null, the default value will be overwritten by this one.\r\n   */\r\n  private static _getMaxRowsLimitation(limitation: any = null) {\r\n    if (limitation == null || isNaN(limitation) || limitation.length === 0) {\r\n      return _DEFAULT_MAX_ROWS_IN_MEMORY;\r\n    }\r\n    return Number(limitation);\r\n  }\r\n\r\n  /**\r\n   * get all available ports from data\r\n   */\r\n  private static _getPorts(data: string[][], firstChunk: boolean, ports: string[]) {\r\n    let line = 0;\r\n    if (firstChunk) {\r\n      // start from line 3\r\n      line = 2;\r\n    }\r\n\r\n    for (; line < data.length; line++) {\r\n      const dataItem = data[line][1];\r\n      if (dataItem != null && dataItem.length > 0) {\r\n        if (isValidPort(dataItem) && ports.indexOf(dataItem) === -1) {\r\n          ports.push(dataItem);\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * get the time column from the analyzed data\r\n   * @param data the analyzed data\r\n   * @param firstChunk whether it's first chunk or not\r\n   * @param startTime selected starting time. It's millisecond, need to be converted second.\r\n   * @param endTime selected ending time. It's millisecond, need to be converted second.\r\n   * @param lastProcessedTime last processed time form last chunk\r\n   * @param time time object which contains the time data for all ports\r\n   * @param selectedPort if the selected port is empty (did not select any port), all ports info are needed\r\n   * @param isMDC flag for MDC system\r\n   * @param timezone selected timezone\r\n   * @param maxRowsLimitation prevent browser from crashing, set the max rows limitation.\r\n   * This comes from the input: maxRowsLimitation of the component.\r\n   */\r\n  private static _getTimeColumn(data: string[][],\r\n                                firstChunk: boolean,\r\n                                startTime: number,\r\n                                endTime: number,\r\n                                lastProcessedTime: number,\r\n                                time: ChartContentTime,\r\n                                selectedPort: string,\r\n                                isMDC: boolean,\r\n                                timezone: string,\r\n                                maxRowsLimitation: any) {\r\n    // convert millisecond to second for startTime and endTime.\r\n    startTime = startTime / 1000;\r\n    endTime = endTime / 1000;\r\n    const timeColumn = 2;\r\n    let startLine = 0;\r\n    let iStart = -1;\r\n    let iEnd = -1;\r\n\r\n    let curTime = lastProcessedTime;\r\n    let lastProcessedTimeReturn;\r\n    let totalNum = 0;\r\n    let mdcFlag = isMDC;\r\n    const defaultPort = getDefaultPort();\r\n    const maxRowNum = this._getMaxRowsLimitation(maxRowsLimitation);\r\n\r\n    if (firstChunk) {\r\n      if (curTime >= startTime && curTime <= endTime) {\r\n        iStart = 1; // start from first line\r\n\r\n        /** Modified at 2018/10/10,\r\n         * in some case, eg: the nameserver history trace gets modified by Kook, Jin Young's python script,\r\n         * the port show in the first line as well, and does not like the non-mdc system, this kind of file has\r\n         * one port in it. The history for non-mdc system doesn't have port info in the port column.*/\r\n\r\n          // get port for the line 1.\r\n        const firstLinePort = getPort(data[1][1]);\r\n        // init time array for the first line.\r\n        if (!selectedPort || selectedPort.length === 0 || isSamePort(firstLinePort, selectedPort, mdcFlag)) {\r\n          // does not select any port or\r\n          // it's non-mdc (mdcFlag is false at the beginning) system and the selected port is the first line port\r\n          time[firstLinePort] = [];\r\n          time[firstLinePort][0] = curTime * 1000;\r\n        }\r\n      }\r\n      lastProcessedTimeReturn = curTime;\r\n      startLine = 2;\r\n    }\r\n\r\n    // get current total number\r\n    Object.keys(time).forEach(key => {\r\n      if (time[key]) {\r\n        totalNum += time[key].length;\r\n      }\r\n    });\r\n\r\n    if (curTime == null) {\r\n      console.error('getTimeColumn', 'Can not get the time from the file, internal error!');\r\n      return {indexStart: null, indexEnd: null, lastProcessedTime: null, isMDC: null};\r\n    }\r\n\r\n    for (let i = startLine; i < data.length; i++) {\r\n      // sometime the last line is empty, need to be skipped.\r\n      if (data[i] == null || data[i].length === 0 || (data[i].length === 1 && data[i][0].length === 0)) {\r\n        continue;\r\n      }\r\n\r\n      // get port number and initialize the relative port array in time\r\n      const port = getPort(data[i][1]); // data[i][1] == null || data[i][1].length == 0 ? __DEFAULT_PORT : data[i][1];\r\n      if (!(port in time)) {\r\n        // add undefined port to time, then we can find all ports in time\r\n        time[port] = void 0;\r\n      }\r\n      if (time[port] == null && isSamePort(port, selectedPort, mdcFlag)) {\r\n        time[port] = [];\r\n        // if other ports exists in this file, default port will be set to undefined.\r\n        if (!mdcFlag && port !== defaultPort && time[defaultPort]) {\r\n          // update the total num;\r\n          totalNum -= time[defaultPort].length;\r\n          time[defaultPort].length = 0;\r\n          time[defaultPort] = void 0;\r\n          mdcFlag = true;\r\n        }\r\n      }\r\n      curTime = calculateValue4Time(curTime, data[i][timeColumn], timezone);\r\n      if (curTime > endTime) {\r\n        if (iEnd < 0) {\r\n          iEnd = i - 1;\r\n        }\r\n        break;\r\n      }\r\n      if (iStart >= 0) {\r\n        if (time[port]) {\r\n          // not null means it's the selected port\r\n          time[port][time[port].length] = curTime * 1000;\r\n          totalNum ++;\r\n        }\r\n      } else {\r\n        if (curTime >= startTime && curTime <= endTime) {\r\n          if (time[port]) {\r\n            // only selected port counted in\r\n            if (iStart < 0) {\r\n              iStart = i;\r\n            }\r\n            time[port][time[port].length] = curTime * 1000;\r\n            totalNum ++;\r\n          }\r\n        }\r\n      }\r\n      // last processed time need to be recorded anyway\r\n      lastProcessedTimeReturn = curTime;\r\n\r\n      if (totalNum >= maxRowNum) {\r\n        iEnd = i;\r\n        break;\r\n      }\r\n    }\r\n    return {indexStart: iStart, indexEnd: iEnd, lastProcessedTime: lastProcessedTimeReturn, isMDC: mdcFlag};\r\n  }\r\n\r\n  /**\r\n   * Get data for all columns\r\n   * @param columnNum the total number of columns. For mdc system,\r\n   *                  the length of each row is different. Host relative data does not exist in tenant line.\r\n   *                  Needs to use column number from the first line.\r\n   * @param data      data parsed by papa\r\n   * @param firstChunk the flag which identifies whether it's the first chunk or not.\r\n   * @param time\r\n   * @param indexStart\r\n   * @param indexEnd\r\n   * @param lastProcessedLine\r\n   * @param resultData   the result data after analyzed\r\n   * @param selectedPort\r\n   * @param isMDC\r\n   */\r\n  private static _getDataColumns(columnNum: number,\r\n                                 data: string[][],\r\n                                 firstChunk: boolean,\r\n                                 time: ChartContentTime,\r\n                                 indexStart: number,\r\n                                 indexEnd: number,\r\n                                 lastProcessedLine: number[],\r\n                                 resultData: ChartContentData,\r\n                                 selectedPort: string,\r\n                                 isMDC: boolean) {\r\n    let startLine = 0;\r\n    // for mdc system, the length is not correct (host relative data only exists in the \"empty\" port line).\r\n    // Needs to use header from the first line.\r\n    // const columnNum = data[0].length;\r\n\r\n    if (firstChunk) {\r\n      /**\r\n       * Modified at 2018/10/10,\r\n       * in some case, eg: the nameserver history trace gets modified by Kook, Jin Young's python script,\r\n       * the port show in the first line as well, and does not like the non-mdc system, this kind of file has\r\n       * one port in it. The history for non-mdc system doesn't have port info in the port column.\r\n       */\r\n\r\n      // get port for the line 1.\r\n      const firstLinePort = getPort(data[1][1]);\r\n      // Initialize data column with default 'DEFAULT' port if it's not MDC system. MDC system, 'DEFAULT' gets ignored\r\n      if (!isMDC && time[firstLinePort]) {\r\n        resultData[firstLinePort] = [];\r\n        // removed below logic, because first line is the real number, do not need to do the convert.\r\n        // curLine = data[1].slice(3).map(Number);\r\n        for (let j = 3; j < columnNum; j++) {\r\n          const index = j - 3;\r\n\r\n          // initialize data array for all columns of the default '0000' port\r\n          resultData[firstLinePort][index] = [];\r\n          // get the first line data of the column if it's included\r\n          if (indexStart === 1) {\r\n            resultData[firstLinePort][index][0] = {x: time[firstLinePort][0], y: lastProcessedLine[index]};\r\n          }\r\n        }\r\n      }\r\n      startLine = 2;\r\n    }\r\n\r\n    for (let j = 3; j < columnNum; j++) {\r\n      const index = j - 3;\r\n      for (let i = startLine; i < data.length; i++) {\r\n        // sometime the last line is empty, need to be skipped.\r\n        if (data[i] == null || data[i].length === 0 || (data[i].length === 1 && data[i][0].length === 0)) {\r\n          continue;\r\n        }\r\n\r\n        // get port number and initialize the relative port array in data\r\n        const port = getPort(data[i][1]);\r\n        if (resultData[port] == null && isSamePort(port, selectedPort, isMDC)) {\r\n          resultData[port] = [];\r\n        }\r\n        if (resultData[port] && resultData[port][index] == null) {\r\n          resultData[port][index] = [];\r\n        }\r\n\r\n        lastProcessedLine[index] = calculateValue(lastProcessedLine[index], data[i][j]);\r\n        if (i >= indexStart && (i <= indexEnd || indexEnd < 0) && indexStart >= 0) {\r\n          if (resultData[port]) {\r\n            const length = resultData[port][index].length;\r\n            resultData[port][index][length] = {x: time[port][length], y: lastProcessedLine[index]};\r\n          }\r\n        } else if (indexEnd > 0 && i > indexEnd) {\r\n          break;\r\n        }\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get Chart data from provided file.\r\n   * @param file the nameserver history file\r\n   * @param startTime\r\n   * @param endTime\r\n   * @param port\r\n   * @param timezone\r\n   * @param maxRowsLimitation prevent browser from crashing, set the max rows limitation.\r\n   * @param progress call back function for updating progress\r\n   */\r\n  public getChartContentFromFile(file: File,\r\n                                 startTime: number,\r\n                                 endTime: number,\r\n                                 port: string,\r\n                                 timezone: string,\r\n                                 maxRowsLimitation: any,\r\n                                 progress: any): Promise<ChartContent> {\r\n    // load done, beginning parsing\r\n    const beginTime = new Date();\r\n    let firstChunk = true;\r\n    // save last processed data just for the later calculation\r\n    let lastProcessedData;\r\n    // save last processed time just for the later calculation\r\n    let lastProcessedTime;\r\n    // save last processed cursor position for progress calculation.\r\n    // let lastProcessedCursor = 0;\r\n    let indexStart = -1, indexEnd = -1;\r\n    const time: ChartContentTime = {};\r\n    const data: ChartContentData = {};\r\n    let header;\r\n    let host;\r\n    let isMDC = false;\r\n    let columnNum;\r\n    let abortType: Abort;\r\n\r\n    const rejectAndAbort = (reject, parser) => {\r\n      if (progress) {\r\n        progress(100);\r\n      }\r\n      reject(`${file.name} is empty or the format is not correct.`);\r\n      parser.abort();\r\n    };\r\n    return new Promise((resolve, reject) => {\r\n      parse(file, {\r\n        chunk: (results, parser) => {\r\n          // the progress increment of this step\r\n          // let analyzeStepProgress = (results.meta.cursor - lastProcessedCursor) / file.size * 100;\r\n          printProcessedTime(beginTime, 'step1');\r\n          if (indexEnd >= 0) {\r\n            // already finished, quite.\r\n            return;\r\n          } else {\r\n            // reset start point\r\n            indexStart = -1;\r\n          }\r\n\r\n          // get time column\r\n          if (firstChunk) {\r\n            if (!validateData(results.data)) {\r\n              return rejectAndAbort(reject, parser);\r\n            }\r\n\r\n            // initialize the header\r\n            header = results.data[0].slice(3);\r\n            // get column number\r\n            columnNum = results.data[0].length;\r\n            // get host name\r\n            host = results.data[1][0];\r\n            // get the first line time info from first line, it is a real number, do not need to do the convert with \">,<\".\r\n            lastProcessedTime = getTimeFromTimeZone(parseFloat(results.data[1][2]), timezone);\r\n            // get the first line data info from first line, it is a real number, do not need to do the convert with \">,<\".\r\n            lastProcessedData = results.data[1].slice(3).map(Number);\r\n          }\r\n\r\n          printProcessedTime(beginTime, 'step2');\r\n\r\n          if (!lastProcessedData) {\r\n            return rejectAndAbort(reject, parser);\r\n          }\r\n\r\n          // get time column\r\n          ({indexStart, indexEnd, lastProcessedTime, isMDC} = FileService._getTimeColumn(\r\n            results.data, firstChunk, startTime, endTime, lastProcessedTime, time, port, isMDC, timezone, maxRowsLimitation));\r\n          printProcessedTime(beginTime, 'step3');\r\n\r\n          if (indexStart == null && indexEnd == null && lastProcessedTime == null && isMDC == null) {\r\n            return rejectAndAbort(reject, parser);\r\n          }\r\n\r\n          // get all other data columns\r\n          FileService._getDataColumns(\r\n            columnNum, results.data, firstChunk, time, indexStart, indexEnd, lastProcessedData, data, port, isMDC);\r\n\r\n          if (firstChunk) {\r\n            firstChunk = false;\r\n          }\r\n\r\n          printProcessedTime(beginTime, 'step4');\r\n\r\n          if (indexEnd >= 0) {\r\n            // do not need to process the left parts, manually trigger complete\r\n            const processedLines = Object.keys(time).reduce((total, curKey) => time[curKey] ? total + time[curKey].length : total, 0);\r\n            if (processedLines >= FileService._getMaxRowsLimitation(maxRowsLimitation)) {\r\n              abortType = Abort.maxLineNumReached;\r\n            } else {\r\n              abortType = Abort.maxTimeRangeReached;\r\n            }\r\n\r\n            if (progress) {\r\n              progress(100);\r\n            }\r\n            parser.abort();\r\n            return;\r\n          } else {\r\n            // the overall progress if this step is finished\r\n            if (progress) {\r\n              progress(Math.round(results.meta.cursor / file.size * 100));\r\n            }\r\n            // lastProcessedCursor = results.meta.cursor;\r\n          }\r\n        },\r\n        complete: () => {\r\n          printProcessedTime(beginTime, 'step_complete');\r\n          resolve ({header: header, host: host, time: time, data: data, aborted: abortType});\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Get all ports from the name server history file\r\n   * @param file the name server history file\r\n   * @param progress call back for updating the progress\r\n   */\r\n  public getPortsFromFile(file: File, progress: any): Promise<string[]> {\r\n    const beginTime = new Date();\r\n    let firstChunk = true;\r\n    const ports = [];\r\n    const defaultPort = getDefaultPort();\r\n    return new Promise((resolve, reject) => {\r\n      parse(file, {\r\n        chunk: (results, parser) => {\r\n          // get time column\r\n          if (firstChunk) {\r\n            if (!validateData(results.data)) {\r\n              if (progress) {\r\n                progress(100);\r\n              }\r\n              reject(`${file.name} is empty or the format is not correct.`);\r\n              parser.abort();\r\n              return;\r\n            }\r\n          }\r\n          printProcessedTime(beginTime, 'port.step1');\r\n          FileService._getPorts(results.data, firstChunk, ports);\r\n          if (firstChunk) {\r\n            firstChunk = false;\r\n          }\r\n          if (progress) {\r\n            progress(Math.round(results.meta.cursor / file.size * 100));\r\n          }\r\n        },\r\n        complete: () => {\r\n          // parsing done\r\n          printProcessedTime(beginTime, 'step_complete');\r\n          if (ports.length === 0) {\r\n            ports[0] = defaultPort;\r\n          }\r\n          resolve (ports);\r\n        }\r\n      });\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/src/nameserver-history-viewer/services/index.mjs

@@ -0,0 +1,4 @@
+export * from './chart.service';
+export * from './file.service';
+export * from './ui.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbmFtZXNlcnZlci1oaXN0b3J5LXZpZXdlci9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NoYXJ0LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZpbGUuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vdWkuc2VydmljZSc7XHJcbiJdfQ==