@aj-shadow/z-abs-complayer-visualizationlog-client 0.0.0-aj-beta.221

package/project/client/css/log-type-gui.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_gui{
+  color:Navy;
+  background-color:Turquoise;
+}
+
+div.log_gui{
+  background-color:Turquoise;
+}
+
+/*button.log_gui{
+  background-color:Turquoise !important;
+}*/
+
+rect.icon_log_gui{
+  stroke:Navy;
+}
+
+polyline.icon_log_gui{
+  stroke:Navy;
+}

package/project/client/css/log-type-ip.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_ip{
+  color:#0000ff;
+  background-color:#DDDDFF;
+}
+
+div.log_ip{
+  background-color:#DDDDFF;
+}
+
+/*button.log_ip{
+  background-color:#DDDDFF !important;
+}*/
+
+rect.icon_log_ip{
+  stroke:#0000ff;
+}
+
+polyline.icon_log_ip{
+  stroke:#0000ff;
+}

package/project/client/css/log-type-test-data.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_test_data{
+  color:DodgerBlue;
+  background-color:PaleTurquoise;
+}
+
+div.log_test_data{
+  background-color:PaleTurquoise;
+}
+
+/*button.log_test_data{
+  background-color:PaleTurquoise !important;
+}*/
+
+rect.icon_log_test_data{
+  stroke:DodgerBlue;
+}
+
+polyline.icon_log_test_data{
+  stroke:DodgerBlue;
+}

package/project/client/css/log-type-verify-failure.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_verify_failure{
+  color:red;
+  background-color:#FFDDDD;
+}
+
+div.log_verify_failure{
+  background-color:#FFDDDD;
+}
+
+/*button.log_verify_failure{
+  background-color:#FFDDDD !important;
+}*/
+
+rect.icon_log_verify_failure{
+  stroke:red;
+}
+
+polyline.icon_log_verify_failure{
+  stroke:red;
+}

package/project/client/css/log-type-verify-succes.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_verify_success{
+  color:green;
+  background-color:#D0E9C6;
+}
+
+div.log_verify_success{
+  background-color:#D0E9C6;
+}
+
+/*button.log_verify_success{
+  background-color:#D0E9C6 !important;
+}*/
+
+rect.icon_log_verify_success{
+  stroke:green;
+}
+
+polyline.icon_log_verify_success{
+  stroke:green;
+}

package/project/client/css/log-type-warning.css

@@ -0,0 +1,21 @@
+
+div.comp_layer_log_warning{
+  color:DarkOrange;
+  background-color:#FFDD88;
+}
+
+div.log_warning{
+  background-color:#FFDD88;
+}
+
+/*button.log_warning{
+  background-color:#FFDD88 !important;
+}*/
+
+rect.icon_log_warning{
+  stroke:DarkOrange;
+}
+
+polyline.icon_log_warning{
+  stroke:DarkOrange;
+}

package/project/client/css/log.css

@@ -0,0 +1,118 @@
+
+tr.log{
+  color:DimGray;
+  background-color:WhiteSmoke;
+  height:30px;
+  white-space:nowrap;
+  border-left:1px solid #337ab7;
+}
+
+div.test_case_table_heading {
+  color:#DDFFFF;
+  background-color:#596ACF;
+  padding:0px 5px;
+  font-size:16px;
+}
+
+div.test_case_breadcrump {
+  position:relative;
+  top:8px;
+  width:1000%;
+}
+
+div.test_case_log_body_table {
+  position:absolute;
+  overflow:auto;
+  top:48px;
+  right:0px;
+  bottom:0px;
+  left:0px;
+  z-index:1;
+}
+
+div.test_case_log_head_table{
+  position:relative;
+  overflow:hidden;
+  top:0px;
+  right:0px;
+  bottom:0px;
+  left:0px;
+  margin-top:-1px;
+  z-index:2;
+  background-color:transparent;
+  border-bottom:1px solid #337ab7;
+}
+
+table.test_case_log_head_table thead th,
+table.test_case_log_body_table tbody td {
+  padding:0px 4px;
+}
+
+table.test_case_log_head_table thead th.log_row_filter{
+  padding:3px 2px;
+  background-color:#F8F8F8;;
+}
+
+table.test_case_log_head_table{
+  background-color:white;
+  min-width:100%;
+}
+
+table.test_case_log_body_table{
+  min-width:100%;
+  content-visibility:auto;
+  contain-intrinsic-size:300px;
+}
+
+table.test_case_log_head_table thead tr th {
+  height:20px;
+  border-right:1px solid #337ab7;
+  color:#337ab7;
+}
+
+table.test_case_log_body_table tbody tr td {
+  border-top:1px solid #337ab7;
+  border-right:1px solid #337ab7;
+}
+
+table.test_case_log_head_table thead tr th:last-child,
+table.test_case_log_body_table tbody tr td:last-child {
+  border-right:none;
+}
+
+tr.log_row_nowrap{
+  white-space:nowrap;
+}
+
+tr.log_row_heading{
+  border-top:1px solid #337ab7;
+  white-space:nowrap;
+}
+
+th.log_column_nbr,
+td.log_column_nbr{
+  width:48px;  
+  min-width:48px;
+}
+
+th.log_column_type,
+td.log_column_type{
+  width:68px;  
+  min-width:68px;
+}
+
+th.log_column_date,
+td.log_column_date {
+  width:284px;  
+  min-width:284px;
+}
+
+svg.log_arrow{
+ position:absolute;
+ right:6px;
+ top:4px;
+}
+
+svg.log_arrow:hover{
+  cursor:pointer;
+}

package/project/client/data/data-log-end-result.js

@@ -0,0 +1,32 @@
+
+'use strict';
+
+import Const from '../logic/const';
+import MemoryCacheObject from 'z-abs-corelayer-cs/clientServer/memory/memory-cache-object';
+
+
+class DataLogEndResult {
+  constructor() {
+    this.dataType = Const.DATA_LOG_END;
+    this.testCaseId = 0;
+    this.resultId = 0;
+    this.duration = null;
+  }
+  
+  static memoryCacheObject = new MemoryCacheObject();
+  
+  static create(testCaseId, resultId, duration) {
+    const result = DataLogEndResult.memoryCacheObject.create(DataLogEndResult);
+    result.testCaseId = testCaseId;
+    result.resultId = resultId;
+    result.duration = duration;
+    return result;
+  }
+  
+  destroy() {
+    DataLogEndResult.memoryCacheObject.destroy(this);
+  }
+}
+
+
+module.exports = DataLogEndResult;

package/project/client/data/data-log-end.js

@@ -0,0 +1,52 @@
+
+'use strict';
+
+import DataLogEndResult from './data-log-end-result';
+import DataScrollListNode from 'z-abs-complayer-visualizationinner-client/client/data/data-scroll-list-node';
+import Decoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-decoder';
+import Encoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-encoder';
+import StoreBaseRealtime from 'z-abs-corelayer-client/client/store/store-base-realtime';
+import HighResolutionDuration from 'z-abs-corelayer-cs/clientServer/time/high-resolution-duration';
+
+
+class DataLogEnd {
+  //                                                Index                ResultId            Duration
+  static size = DataScrollListNode.renderDataSize + Encoder.Uint32Size + Encoder.Uint8Size + Encoder.Uint64Size;
+  static encoder = null;
+  static decoder = null;
+  
+  static init(pooledBuffers) {
+    DataLogEnd.encoder = new Encoder(StoreBaseRealtime.textCache);
+    DataLogEnd.decoder = new Decoder(StoreBaseRealtime.textCache);
+    DataLogEnd.encoder.init(pooledBuffers);
+    DataLogEnd.decoder.init(pooledBuffers);
+  }
+  
+  static exit() {
+    DataLogEnd.encoder = null;
+    DataLogEnd.decoder = null;
+  }
+  
+  static store(msg) {
+    const encoder = DataLogEnd.encoder;
+    const bufferData = encoder.createBuffer(DataLogEnd.size, DataScrollListNode.renderDataSize);
+    encoder.setUint32(msg.index + 1);
+    encoder.setUint8(msg.resultId);
+    encoder.setBigUint64(msg.duration);
+    encoder.release();
+    return bufferData;
+  }
+  
+  static restore(bufferData) {
+    const decoder = DataLogEnd.decoder;
+    decoder.attach(bufferData, DataScrollListNode.renderDataSize);
+    const testCaseId = decoder.getUint32();
+    const resultId = decoder.getUint8();
+    const duration = new HighResolutionDuration(decoder.getBigUint64()).getDuration();
+    decoder.detach();
+    return DataLogEndResult.create(testCaseId, resultId, duration);
+  }
+}
+
+
+module.exports = DataLogEnd;

package/project/client/data/data-log-log-result.js

@@ -0,0 +1,76 @@
+
+'use strict';
+
+import Const from '../logic/const';
+import MemoryCacheObject from 'z-abs-corelayer-cs/clientServer/memory/memory-cache-object';
+
+function potocolIndexObject() {
+  this.innersData = null;
+  this.protocolIndex = 0;
+  this.transportType = 0;
+  this.type = 0;
+}
+
+function innersObject() {
+  this.innersData = null;
+}
+
+class DataLogLogResult {
+  constructor() {
+    this.dataType = Const.DATA_LOG_LOG;
+    this.logId = 0;
+    this.type = 0;
+    this.dataId = 0;
+    this.date = null;
+    this.actor = '';
+    this.actorPath = '';
+    this.fileName = '';
+    this.codePath = '';
+    this.log = '';
+    this.hasProtocolIndex = true;
+    this.extraData = null;
+  }
+  
+  static memoryCacheObject = new MemoryCacheObject();
+  static memoryCacheObjectProtocolIndex = new MemoryCacheObject();
+  static memoryCacheObjectInnersObject = new MemoryCacheObject();
+  
+  static create(logId, type, dataId, date, actor, actorPath, fileName, codePath, log, hasProtocolIndex, innersData, protocolIndex, transportType, extraDataType) {
+    const result = DataLogLogResult.memoryCacheObject.create(DataLogLogResult);
+    result.logId = logId;
+    result.type = type;
+    result.dataId = dataId;
+    result.date = date;
+    result.actor = actor;
+    result.actorPath = actorPath;
+    result.fileName = fileName;
+    result.codePath = codePath;
+    result.log = log;
+    this.hasProtocolIndex = hasProtocolIndex;
+    if(hasProtocolIndex) {
+      result.extraData = DataLogLogResult.memoryCacheObjectProtocolIndex.create(potocolIndexObject);
+      result.extraData.innersData = innersData;
+      result.extraData.protocolIndex = protocolIndex;
+      result.extraData.transportType = transportType;
+      result.extraData.type = extraDataType;
+    }
+    else {
+      result.extraData = DataLogLogResult.memoryCacheObjectInnersObject.create(innersObject);
+      result.extraData.innersData = innersData;
+    }
+    return result;
+  }
+  
+  destroy() {
+    if(this.hasProtocolIndex) {
+      DataLogLogResult.memoryCacheObjectProtocolIndex.destroy(this.extraData);
+    }
+    else {
+      DataLogLogResult.memoryCacheObjectInnersObject.create(this.extraData);
+    }
+    DataLogLogResult.memoryCacheObject.destroy(this);
+  }
+}
+
+
+module.exports = DataLogLogResult;

package/project/client/data/data-log-log.js

@@ -0,0 +1,157 @@
+
+'use strict';
+
+import Const from '../logic/const';
+import DataLogLogResult from './data-log-log-result';
+import DataLogDynamicBuffer from 'z-abs-complayer-visualizationinner-client/client/data/data-log-dynamic-buffer';
+import DataScrollListNode from 'z-abs-complayer-visualizationinner-client/client/data/data-scroll-list-node';
+import Decoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-decoder';
+import Encoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-encoder';
+import StoreBaseRealtime from 'z-abs-corelayer-client/client/store/store-base-realtime';
+import HighResolutionDate from 'z-abs-corelayer-cs/clientServer/time/high-resolution-date';
+import LogDataAction from 'z-abs-funclayer-engine-cs/clientServer/log/log-data-action';
+import LogSourceType from 'z-abs-funclayer-engine-cs/clientServer/log/log-source-type';
+import LogType from 'z-abs-funclayer-engine-cs/clientServer/log/log-type';
+
+
+class DataLogLog {
+  //                                                Type                LogId                DataId              Date                 ActorName        ActorPath        FileName         SourceType          LineNumber                             
+  static size = DataScrollListNode.renderDataSize + Encoder.Uint8Size + Encoder.Uint32Size + Encoder.Uint8Size + Encoder.Uint64Size + Encoder.CtSize + Encoder.CtSize + Encoder.CtSize + Encoder.Uint8Size + Encoder.Uint32Size;
+  static encoder = null;
+  static decoder = null;
+  static pooledBuffers = null;
+  static stackStyles = null;
+  
+  static init(pooledBuffers, stackStyles) {
+    DataLogLog.pooledBuffers = pooledBuffers;
+    DataLogLog.stackStyles = stackStyles;
+    DataLogLog.encoder = new Encoder(StoreBaseRealtime.textCache);
+    DataLogLog.decoder = new Decoder(StoreBaseRealtime.textCache);
+    DataLogLog.encoder.init(pooledBuffers);
+    DataLogLog.decoder.init(pooledBuffers);
+  }
+  
+  static exit() {
+    DataLogLog.encoder = null;
+    DataLogLog.decoder = null;
+    DataLogLog.pooledBuffers = null;
+    DataLogLog.stackStyles = null;
+  }
+  
+  static store(msg, logId) {
+    const encoder = DataLogLog.encoder;
+    let protocolIndexSize = 0;
+    let protocolIndex = -1;
+    let transportType = -1;
+    let type = -1;
+    let localType = Const.LOCAL_TYPE_IS_UNKNOWN;
+    if(LogType.IP === msg.type) {
+      if(msg.data) {
+        protocolIndexSize = Encoder.Uint16Size + Encoder.Uint8Size;
+        const stackStyle = DataLogLog.stackStyles.get(msg.data.stack);
+        protocolIndex = stackStyle.index;
+        if(msg.data.local) {
+          transportType = msg.data.local.transportLayer.transportType;
+          localType = "client" === msg.data.local.type ? Const.LOCAL_TYPE_IS_CLIENT : Const.LOCAL_TYPE_IS_SERVER;
+        }
+        else if(LogDataAction.STACK === msg.data.actionId) {
+          type = msg.data.type;
+        }
+      }
+    }
+    const logLength = encoder.getStringBytes(msg.log);
+    const hasInners = null !== msg.inners;
+    const bufferData = encoder.createBuffer(DataLogLog.size + logLength + protocolIndexSize, DataScrollListNode.renderDataSize);
+    encoder.setUint8(msg.type);
+    encoder.setUint4_0(msg.sourceType, false);
+    encoder.setUint1_4(hasInners, false);
+    encoder.setUint1_5(protocolIndexSize ? 1 : 0, false);
+    encoder.setUint2_3(localType, true);
+    if(0 !== protocolIndexSize) {
+      encoder.setUint16(protocolIndex);
+      encoder.setUint8(-1 !== transportType ? transportType : type);
+    }
+    encoder.setUint32(logId);
+    encoder.setUint8(msg.data ? msg.data.actionId : 0);
+    encoder.setBigUint64(msg.date);
+    encoder.setCtStringInternal(msg.actor);
+    encoder.setCtStringInternal(msg.actorPath);
+    encoder.setCtStringInternal(msg.fileName);
+    encoder.setUint32(msg.lineNumber);
+    encoder.setString(msg.log);
+    encoder.release();
+    if(hasInners) {
+      DataLogDynamicBuffer.store(bufferData, msg.inners, null, false, 0, msg.type);
+    }
+    return bufferData;
+  }
+  
+  static restore(bufferData) {
+    const decoder = DataLogLog.decoder;
+    decoder.attach(bufferData, DataScrollListNode.renderDataSize);
+    let protocolIndex = 0;
+    let typeChoise = 0;
+    const type = decoder.getUint8();
+    const sourceType = decoder.getUint4_0(false);
+    const hasInners = !!decoder.getUint1_4(false);
+    const hasProtocolIndex = !!decoder.getUint1_5(false);
+    const localType = decoder.getUint2_3(true);
+    if(hasProtocolIndex) {
+      protocolIndex = decoder.getUint16();
+      typeChoise = decoder.getUint8();
+    }
+    const logId = decoder.getUint32();
+    const dataId = decoder.getUint8();
+    const timestamp = decoder.getBigUint64();
+    const actor = decoder.getCtString();
+    const actorPath = decoder.getCtString();
+    const fileName = decoder.getCtString();
+    const lineNumber = decoder.getUint32();
+    const log = decoder.getString();
+    const date = new HighResolutionDate(timestamp).getDateMilliSeconds();
+    let codePath = null;
+    if(LogSourceType.SERVER === sourceType) {
+      codePath = `/code-editor?file=/${fileName}&files=0;/${fileName};${lineNumber};${type}`;
+    }
+    else if(LogSourceType.ACTOR === sourceType) {
+      codePath = `/actor-editor/${fileName}?line=${lineNumber}&type=${type}`;
+    }
+    else if(LogSourceType.STACK === sourceType) {
+      codePath = `/stack-editor/${fileName}?line=${lineNumber}&type=${type}`;
+    }
+    decoder.detach();
+    let innersData = null;
+    if(hasInners) {
+      innersData = DataLogDynamicBuffer.restore(bufferData);
+    }
+    let transportType = null;
+    let stackStackType = null;
+    if(LogDataAction.STACK === dataId) {
+      stackStackType = typeChoise;
+    }
+    else {
+      transportType = typeChoise;
+    }
+    const extraDataType = hasProtocolIndex ? (LogDataAction.STACK === dataId ? typeChoise : localType) : 0;
+    return DataLogLogResult.create(logId, type, dataId, date, actor, `/actor-editor/${actorPath}`, `${fileName}:${lineNumber}`, codePath, log, hasProtocolIndex, innersData, protocolIndex, transportType, extraDataType);
+  }
+  
+  static restoreHeightData(bufferData) {
+    const decoder = DataLogLog.decoder;
+    decoder.attach(bufferData, DataScrollListNode.renderDataSize);
+    const type = decoder.getUint8();
+    const hasInners = !!decoder.getUint1_4(true);
+    decoder.detach();
+    let innersData = null;
+    if(hasInners) {
+      innersData = DataLogDynamicBuffer.restore(bufferData);
+    }
+    return {
+      type,
+      innersData
+    };
+  }
+}
+
+
+module.exports = DataLogLog;

package/project/client/data/data-log-start-result.js

@@ -0,0 +1,36 @@
+
+'use strict';
+
+import Const from '../logic/const';
+import MemoryCacheObject from 'z-abs-corelayer-cs/clientServer/memory/memory-cache-object';
+
+
+class DataLogStartResult {
+  constructor() {
+    this.dataType = Const.DATA_LOG_START;
+    this.testCaseId = 0;
+    this.testSuiteIteration = 0;
+    this.testCaseIteration = 0;
+    this.name = '';
+    this.date = null;
+  }
+  
+  static memoryCacheObject = new MemoryCacheObject();
+  
+  static create(testCaseId, testSuiteIteration, testCaseIteration, name, date) {
+    const result = DataLogStartResult.memoryCacheObject.create(DataLogStartResult);
+    result.testCaseId = testCaseId;
+    result.testSuiteIteration = testSuiteIteration;
+    result.testCaseIteration = testCaseIteration;
+    result.name = name;
+    result.date = date;
+    return result;
+  }
+  
+  destroy() {
+    DataLogStartResult.memoryCacheObject.destroy(this);
+  }
+}
+
+
+module.exports = DataLogStartResult;

package/project/client/data/data-log-start.js

@@ -0,0 +1,56 @@
+
+'use strict';
+
+import DataLogStartResult from './data-log-start-result';
+import DataScrollListNode from 'z-abs-complayer-visualizationinner-client/client/data/data-scroll-list-node';
+import Decoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-decoder';
+import Encoder from 'z-abs-corelayer-client/client/communication/core-protocol/pooled-encoder';
+import StoreBaseRealtime from 'z-abs-corelayer-client/client/store/store-base-realtime';
+import HighResolutionDate from 'z-abs-corelayer-cs/clientServer/time/high-resolution-date';
+
+
+class DataLogStart {
+  //                                                Index                TS-Iteration         TC-Iteration         Name             Timestamp
+  static size = DataScrollListNode.renderDataSize + Encoder.Uint32Size + Encoder.Uint16Size + Encoder.Uint16Size + Encoder.CtSize + Encoder.Uint64Size;
+  static encoder = null;
+  static decoder = null;
+  
+  static init(pooledBuffers) {
+    DataLogStart.encoder = new Encoder(StoreBaseRealtime.textCache);
+    DataLogStart.decoder = new Decoder(StoreBaseRealtime.textCache);
+    DataLogStart.encoder.init(pooledBuffers);
+    DataLogStart.decoder.init(pooledBuffers);
+  }
+  
+  static exit() {
+    DataLogStart.encoder = null;
+    DataLogStart.decoder = null;
+  }
+  
+  static store(msg, testCaseIteration, testSuiteIteration, guid) {
+    const encoder = DataLogStart.encoder;
+    const bufferData = encoder.createBuffer(DataLogStart.size, DataScrollListNode.renderDataSize);
+    encoder.setUint32(msg.index + 1);
+    encoder.setUint16(testSuiteIteration);
+    encoder.setUint16(testCaseIteration);
+    encoder.setCtStringInternal(msg.name);
+    encoder.setBigUint64(msg.timestamp);
+    encoder.release();
+    return bufferData;
+  }
+  
+  static restore(bufferData) {
+    const decoder = DataLogStart.decoder;
+    decoder.attach(bufferData, DataScrollListNode.renderDataSize);
+    const testCaseId = decoder.getUint32();
+    const testSuiteIteration = decoder.getUint16();
+    const testCaseIteration = decoder.getUint16();
+    const name = decoder.getCtString();
+    const date = new HighResolutionDate(decoder.getBigUint64()).getDateMilliSeconds();
+    decoder.detach();
+    return DataLogStartResult.create(testCaseId, testSuiteIteration, testCaseIteration, name, date);
+  }
+}
+
+
+module.exports = DataLogStart;