@rockcarver/frodo-lib 2.0.0-2 → 2.0.0-4

package/esm/ops/AgentOps.mjs

@@ -1,9 +1,6 @@
 import { debugMessage, printMessage } from './utils/Console';
 import { getAgentsByType, getAgentByTypeAndId as _getAgentByTypeAndId, putAgentByTypeAndId, findAgentById, deleteAgentByTypeAndId, findAgentByTypeAndId } from '../api/AgentApi';
 import { validateImport } from './utils/ExportImportUtils';
-export const AGENT_TYPE_IG = 'IdentityGatewayAgent';
-export const AGENT_TYPE_JAVA = 'J2EEAgent';
-export const AGENT_TYPE_WEB = 'WebAgent';
 export default class AgentOps {
   constructor(state) {
     this.state = state;
@@ -448,7 +445,10 @@ export function createAgentExportTemplate() {
 export async function getAgents({
   state
 }) {
-  debugMessage(`AgentOps.getAgents: start`);
+  debugMessage({
+    message: `AgentOps.getAgents: start`,
+    state
+  });
   let agents = [];
   try {
     const resolved = await Promise.all([getAgentsByType({
@@ -465,11 +465,22 @@ export async function getAgents({
     agents = agents.concat(resolved[1].result);
     agents = agents.concat(resolved[2].result);
   } catch (error) {
-    printMessage(`${error.message}`, 'error');
-    printMessage(error.response.data, 'error');
+    printMessage({
+      message: `${error.message}`,
+      type: 'error',
+      state
+    });
+    printMessage({
+      message: error.response.data,
+      type: 'error',
+      state
+    });
   }
   agents.sort((a, b) => a._id.localeCompare(b._id));
-  debugMessage(`AgentOps.getAgents: end`);
+  debugMessage({
+    message: `AgentOps.getAgents: end`,
+    state
+  });
   return agents;
 }
 
@@ -482,7 +493,10 @@ export async function getAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.getAgent: start`);
+  debugMessage({
+    message: `AgentOps.getAgent: start`,
+    state
+  });
   const agents = await findAgentById({
     agentId,
     state
@@ -493,7 +507,10 @@ export async function getAgent({
       agentId: agents[0]._id,
       state
     });
-    debugMessage(`AgentOps.getAgent: end`);
+    debugMessage({
+      message: `AgentOps.getAgent: end`,
+      state
+    });
     return result;
   } else if (agents.length === 0) {
     throw new Error(`Agent '${agentId}' not found`);
@@ -513,13 +530,19 @@ export async function getAgentByTypeAndId({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.getAgentByTypeAndId: start`);
+  debugMessage({
+    message: `AgentOps.getAgentByTypeAndId: start`,
+    state
+  });
   const result = await _getAgentByTypeAndId({
     agentType,
     agentId,
     state
   });
-  debugMessage(`AgentOps.getAgentByTypeAndId: start`);
+  debugMessage({
+    message: `AgentOps.getAgentByTypeAndId: start`,
+    state
+  });
   return result;
 }
 
@@ -530,14 +553,20 @@ export async function getAgentByTypeAndId({
 export async function getIdentityGatewayAgents({
   state
 }) {
-  debugMessage(`AgentOps.getIdentityGatewayAgents: start`);
+  debugMessage({
+    message: `AgentOps.getIdentityGatewayAgents: start`,
+    state
+  });
   const {
     result
   } = await getAgentsByType({
-    agentType: AGENT_TYPE_IG,
+    agentType: 'IdentityGatewayAgent',
+    state
+  });
+  debugMessage({
+    message: `AgentOps.getIdentityGatewayAgents: end`,
     state
   });
-  debugMessage(`AgentOps.getIdentityGatewayAgents: end`);
   return result;
 }
 
@@ -550,13 +579,19 @@ export async function getIdentityGatewayAgent({
   gatewayId,
   state
 }) {
-  debugMessage(`AgentOps.getIdentityGatewayAgent: start`);
+  debugMessage({
+    message: `AgentOps.getIdentityGatewayAgent: start`,
+    state
+  });
   const result = await getAgentByTypeAndId({
-    agentType: AGENT_TYPE_IG,
+    agentType: 'IdentityGatewayAgent',
     agentId: gatewayId,
     state
   });
-  debugMessage(`AgentOps.getIdentityGatewayAgent: end`);
+  debugMessage({
+    message: `AgentOps.getIdentityGatewayAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -571,14 +606,20 @@ export async function putIdentityGatewayAgent({
   gatewayData,
   state
 }) {
-  debugMessage(`AgentOps.putIdentityGatewayAgent: start`);
+  debugMessage({
+    message: `AgentOps.putIdentityGatewayAgent: start`,
+    state
+  });
   const result = await putAgentByTypeAndId({
-    agentType: AGENT_TYPE_IG,
+    agentType: 'IdentityGatewayAgent',
     agentId: gatewayId,
     agentData: gatewayData,
     state
   });
-  debugMessage(`AgentOps.putIdentityGatewayAgent: end`);
+  debugMessage({
+    message: `AgentOps.putIdentityGatewayAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -589,14 +630,20 @@ export async function putIdentityGatewayAgent({
 export async function getJavaAgents({
   state
 }) {
-  debugMessage(`AgentOps.getJavaAgents: start`);
+  debugMessage({
+    message: `AgentOps.getJavaAgents: start`,
+    state
+  });
   const {
     result
   } = await getAgentsByType({
-    agentType: AGENT_TYPE_JAVA,
+    agentType: 'J2EEAgent',
+    state
+  });
+  debugMessage({
+    message: `AgentOps.getJavaAgents: end`,
     state
   });
-  debugMessage(`AgentOps.getJavaAgents: end`);
   return result;
 }
 
@@ -609,13 +656,19 @@ export async function getJavaAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.getJavaAgent: start`);
+  debugMessage({
+    message: `AgentOps.getJavaAgent: start`,
+    state
+  });
   const result = await getAgentByTypeAndId({
-    agentType: AGENT_TYPE_JAVA,
+    agentType: 'J2EEAgent',
     agentId,
     state
   });
-  debugMessage(`AgentOps.getJavaAgent: end`);
+  debugMessage({
+    message: `AgentOps.getJavaAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -630,14 +683,20 @@ export async function putJavaAgent({
   agentData,
   state
 }) {
-  debugMessage(`AgentOps.putJavaAgent: start`);
+  debugMessage({
+    message: `AgentOps.putJavaAgent: start`,
+    state
+  });
   const result = await putAgentByTypeAndId({
-    agentType: AGENT_TYPE_JAVA,
+    agentType: 'J2EEAgent',
     agentId,
     agentData,
     state
   });
-  debugMessage(`AgentOps.putJavaAgent: end`);
+  debugMessage({
+    message: `AgentOps.putJavaAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -648,14 +707,20 @@ export async function putJavaAgent({
 export async function getWebAgents({
   state
 }) {
-  debugMessage(`AgentOps.getWebAgents: start`);
+  debugMessage({
+    message: `AgentOps.getWebAgents: start`,
+    state
+  });
   const {
     result
   } = await getAgentsByType({
-    agentType: AGENT_TYPE_WEB,
+    agentType: 'WebAgent',
+    state
+  });
+  debugMessage({
+    message: `AgentOps.getWebAgents: end`,
     state
   });
-  debugMessage(`AgentOps.getWebAgents: end`);
   return result;
 }
 
@@ -668,13 +733,19 @@ export async function getWebAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.getWebAgent: start`);
+  debugMessage({
+    message: `AgentOps.getWebAgent: start`,
+    state
+  });
   const result = await getAgentByTypeAndId({
-    agentType: AGENT_TYPE_WEB,
+    agentType: 'WebAgent',
     agentId,
     state
   });
-  debugMessage(`AgentOps.getWebAgent: end`);
+  debugMessage({
+    message: `AgentOps.getWebAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -689,14 +760,20 @@ export async function putWebAgent({
   agentData,
   state
 }) {
-  debugMessage(`AgentOps.putWebAgent: start`);
+  debugMessage({
+    message: `AgentOps.putWebAgent: start`,
+    state
+  });
   const result = await putAgentByTypeAndId({
-    agentType: AGENT_TYPE_WEB,
+    agentType: 'WebAgent',
     agentId,
     agentData,
     state
   });
-  debugMessage(`AgentOps.putWebAgent: end`);
+  debugMessage({
+    message: `AgentOps.putWebAgent: end`,
+    state
+  });
   return result;
 }
 
@@ -707,7 +784,10 @@ export async function putWebAgent({
 export async function exportAgents({
   state
 }) {
-  debugMessage(`AgentOps.exportAgents: start`);
+  debugMessage({
+    message: `AgentOps.exportAgents: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agents = await getAgents({
     state
@@ -715,7 +795,10 @@ export async function exportAgents({
   for (const agent of agents) {
     exportData.agents[agent._id] = agent;
   }
-  debugMessage(`AgentOps.exportAgents: end`);
+  debugMessage({
+    message: `AgentOps.exportAgents: end`,
+    state
+  });
   return exportData;
 }
 
@@ -726,7 +809,10 @@ export async function exportAgents({
 export async function exportIdentityGatewayAgents({
   state
 }) {
-  debugMessage(`AgentOps.exportIdentityGatewayAgents: start`);
+  debugMessage({
+    message: `AgentOps.exportIdentityGatewayAgents: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agents = await getIdentityGatewayAgents({
     state
@@ -734,7 +820,10 @@ export async function exportIdentityGatewayAgents({
   for (const agent of agents) {
     exportData.agents[agent._id] = agent;
   }
-  debugMessage(`AgentOps.exportIdentityGatewayAgents: end`);
+  debugMessage({
+    message: `AgentOps.exportIdentityGatewayAgents: end`,
+    state
+  });
   return exportData;
 }
 
@@ -745,7 +834,10 @@ export async function exportIdentityGatewayAgents({
 export async function exportJavaAgents({
   state
 }) {
-  debugMessage(`AgentOps.exportJavaAgents: start`);
+  debugMessage({
+    message: `AgentOps.exportJavaAgents: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agents = await getJavaAgents({
     state
@@ -753,7 +845,10 @@ export async function exportJavaAgents({
   for (const agent of agents) {
     exportData.agents[agent._id] = agent;
   }
-  debugMessage(`AgentOps.exportJavaAgents: end`);
+  debugMessage({
+    message: `AgentOps.exportJavaAgents: end`,
+    state
+  });
   return exportData;
 }
 
@@ -764,7 +859,10 @@ export async function exportJavaAgents({
 export async function exportWebAgents({
   state
 }) {
-  debugMessage(`AgentOps.exportWebAgents: start`);
+  debugMessage({
+    message: `AgentOps.exportWebAgents: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agents = await getWebAgents({
     state
@@ -772,7 +870,10 @@ export async function exportWebAgents({
   for (const agent of agents) {
     exportData.agents[agent._id] = agent;
   }
-  debugMessage(`AgentOps.exportWebAgents: end`);
+  debugMessage({
+    message: `AgentOps.exportWebAgents: end`,
+    state
+  });
   return exportData;
 }
 
@@ -785,14 +886,20 @@ export async function exportAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.exportAgent: start`);
+  debugMessage({
+    message: `AgentOps.exportAgent: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agentObject = await getAgent({
     agentId,
     state
   });
   exportData.agents[agentId] = agentObject;
-  debugMessage(`AgentOps.exportAgent: end`);
+  debugMessage({
+    message: `AgentOps.exportAgent: end`,
+    state
+  });
   return exportData;
 }
 
@@ -805,14 +912,20 @@ export async function exportIdentityGatewayAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.exportIdentityGatewayAgent: start`);
+  debugMessage({
+    message: `AgentOps.exportIdentityGatewayAgent: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agentObject = await getIdentityGatewayAgent({
     gatewayId: agentId,
     state
   });
   exportData.agents[agentId] = agentObject;
-  debugMessage(`AgentOps.exportIdentityGatewayAgent: end`);
+  debugMessage({
+    message: `AgentOps.exportIdentityGatewayAgent: end`,
+    state
+  });
   return exportData;
 }
 
@@ -825,14 +938,20 @@ export async function exportJavaAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.exportJavaAgent: start`);
+  debugMessage({
+    message: `AgentOps.exportJavaAgent: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agentObject = await getJavaAgent({
     agentId,
     state
   });
   exportData.agents[agentId] = agentObject;
-  debugMessage(`AgentOps.exportJavaAgent: end`);
+  debugMessage({
+    message: `AgentOps.exportJavaAgent: end`,
+    state
+  });
   return exportData;
 }
 
@@ -845,14 +964,20 @@ export async function exportWebAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.exportWebAgent: start`);
+  debugMessage({
+    message: `AgentOps.exportWebAgent: start`,
+    state
+  });
   const exportData = createAgentExportTemplate();
   const agentObject = await getWebAgent({
     agentId,
     state
   });
   exportData.agents[agentId] = agentObject;
-  debugMessage(`AgentOps.exportWebAgent: end`);
+  debugMessage({
+    message: `AgentOps.exportWebAgent: end`,
+    state
+  });
   return exportData;
 }
 
@@ -864,11 +989,17 @@ export async function importAgents({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importAgents: start`);
+  debugMessage({
+    message: `AgentOps.importAgents: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     for (const agentId of Object.keys(importData.agents)) {
       const agentType = importData.agents[agentId]._type._id;
-      debugMessage(`AgentOps.importAgents: ${agentId} [${agentType}]`);
+      debugMessage({
+        message: `AgentOps.importAgents: ${agentId} [${agentType}]`,
+        state
+      });
       await putAgentByTypeAndId({
         agentType,
         agentId,
@@ -879,7 +1010,10 @@ export async function importAgents({
   } else {
     throw new Error('Invalid meta data.');
   }
-  debugMessage(`AgentOps.importAgents: end`);
+  debugMessage({
+    message: `AgentOps.importAgents: end`,
+    state
+  });
 }
 
 /**
@@ -890,11 +1024,14 @@ export async function importIdentityGatewayAgents({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importIdentityGatewayAgents: start`);
+  debugMessage({
+    message: `AgentOps.importIdentityGatewayAgents: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     for (const agentId of Object.keys(importData.agents)) {
       const agentType = importData.agents[agentId]._type._id;
-      if (agentType !== AGENT_TYPE_IG) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_IG}' but got '${agentType}'.`);
+      if (agentType !== 'IdentityGatewayAgent') throw new Error(`Wrong agent type! Expected 'IdentityGatewayAgent' but got '${agentType}'.`);
       await putAgentByTypeAndId({
         agentType,
         agentId,
@@ -905,7 +1042,10 @@ export async function importIdentityGatewayAgents({
   } else {
     throw new Error('Invalid meta data.');
   }
-  debugMessage(`AgentOps.importIdentityGatewayAgents: end`);
+  debugMessage({
+    message: `AgentOps.importIdentityGatewayAgents: end`,
+    state
+  });
 }
 
 /**
@@ -916,11 +1056,14 @@ export async function importJavaAgents({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importJavaAgents: start`);
+  debugMessage({
+    message: `AgentOps.importJavaAgents: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     for (const agentId of Object.keys(importData.agents)) {
       const agentType = importData.agents[agentId]._type._id;
-      if (agentType !== AGENT_TYPE_JAVA) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_JAVA}' but got '${agentType}'.`);
+      if (agentType !== 'J2EEAgent') throw new Error(`Wrong agent type! Expected 'J2EEAgent' but got '${agentType}'.`);
       await putAgentByTypeAndId({
         agentType,
         agentId,
@@ -931,7 +1074,10 @@ export async function importJavaAgents({
   } else {
     throw new Error('Invalid meta data.');
   }
-  debugMessage(`AgentOps.importJavaAgents: end`);
+  debugMessage({
+    message: `AgentOps.importJavaAgents: end`,
+    state
+  });
 }
 
 /**
@@ -942,11 +1088,14 @@ export async function importWebAgents({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importWebAgents: start`);
+  debugMessage({
+    message: `AgentOps.importWebAgents: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     for (const agentId of Object.keys(importData.agents)) {
       const agentType = importData.agents[agentId]._type._id;
-      if (agentType !== AGENT_TYPE_WEB) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_WEB}' but got '${agentType}'.`);
+      if (agentType !== 'WebAgent') throw new Error(`Wrong agent type! Expected 'WebAgent' but got '${agentType}'.`);
       await putAgentByTypeAndId({
         agentType,
         agentId,
@@ -957,7 +1106,10 @@ export async function importWebAgents({
   } else {
     throw new Error('Invalid meta data.');
   }
-  debugMessage(`AgentOps.importWebAgents: end`);
+  debugMessage({
+    message: `AgentOps.importWebAgents: end`,
+    state
+  });
 }
 
 /**
@@ -971,7 +1123,10 @@ export async function importAgent({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importAgent: start`);
+  debugMessage({
+    message: `AgentOps.importAgent: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     var _importData$agents$ag;
     const agentType = (_importData$agents$ag = importData.agents[agentId]) === null || _importData$agents$ag === void 0 ? void 0 : _importData$agents$ag._type._id;
@@ -981,7 +1136,10 @@ export async function importAgent({
       agentData: importData.agents[agentId],
       state
     });
-    debugMessage(`AgentOps.importAgent: end`);
+    debugMessage({
+      message: `AgentOps.importAgent: end`,
+      state
+    });
     return result;
   } else {
     throw new Error('Invalid meta data.');
@@ -999,18 +1157,24 @@ export async function importIdentityGatewayAgent({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importIdentityGatewayAgent: start`);
+  debugMessage({
+    message: `AgentOps.importIdentityGatewayAgent: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     var _importData$agents$ag2;
     const agentType = (_importData$agents$ag2 = importData.agents[agentId]) === null || _importData$agents$ag2 === void 0 ? void 0 : _importData$agents$ag2._type._id;
-    if (agentType !== AGENT_TYPE_IG) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_IG}' but got '${agentType}'.`);
+    if (agentType !== 'IdentityGatewayAgent') throw new Error(`Wrong agent type! Expected 'IdentityGatewayAgent' but got '${agentType}'.`);
     const result = await putAgentByTypeAndId({
       agentType,
       agentId,
       agentData: importData.agents[agentId],
       state
     });
-    debugMessage(`AgentOps.importIdentityGatewayAgent: end`);
+    debugMessage({
+      message: `AgentOps.importIdentityGatewayAgent: end`,
+      state
+    });
     return result;
   } else {
     throw new Error('Invalid meta data.');
@@ -1028,18 +1192,24 @@ export async function importJavaAgent({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importJavaAgent: start`);
+  debugMessage({
+    message: `AgentOps.importJavaAgent: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     var _importData$agents$ag3;
     const agentType = (_importData$agents$ag3 = importData.agents[agentId]) === null || _importData$agents$ag3 === void 0 ? void 0 : _importData$agents$ag3._type._id;
-    if (agentType !== AGENT_TYPE_JAVA) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_JAVA}' but got '${agentType}'.`);
+    if (agentType !== 'J2EEAgent') throw new Error(`Wrong agent type! Expected 'J2EEAgent' but got '${agentType}'.`);
     const result = await putAgentByTypeAndId({
       agentType,
       agentId,
       agentData: importData.agents[agentId],
       state
     });
-    debugMessage(`AgentOps.importJavaAgent: end`);
+    debugMessage({
+      message: `AgentOps.importJavaAgent: end`,
+      state
+    });
     return result;
   } else {
     throw new Error('Invalid meta data.');
@@ -1057,18 +1227,24 @@ export async function importWebAgent({
   importData,
   state
 }) {
-  debugMessage(`AgentOps.importWebAgent: start`);
+  debugMessage({
+    message: `AgentOps.importWebAgent: start`,
+    state
+  });
   if (validateImport(importData.meta)) {
     var _importData$agents$ag4;
     const agentType = (_importData$agents$ag4 = importData.agents[agentId]) === null || _importData$agents$ag4 === void 0 ? void 0 : _importData$agents$ag4._type._id;
-    if (agentType !== AGENT_TYPE_WEB) throw new Error(`Wrong agent type! Expected '${AGENT_TYPE_WEB}' but got '${agentType}'.`);
+    if (agentType !== 'WebAgent') throw new Error(`Wrong agent type! Expected 'WebAgent' but got '${agentType}'.`);
     const result = await putAgentByTypeAndId({
       agentType,
       agentId,
       agentData: importData.agents[agentId],
       state
     });
-    debugMessage(`AgentOps.importWebAgent: end`);
+    debugMessage({
+      message: `AgentOps.importWebAgent: end`,
+      state
+    });
     return result;
   } else {
     throw new Error('Invalid meta data.');
@@ -1081,19 +1257,28 @@ export async function importWebAgent({
 export async function deleteAgents({
   state
 }) {
-  debugMessage(`AgentOps.deleteAgents: start`);
+  debugMessage({
+    message: `AgentOps.deleteAgents: start`,
+    state
+  });
   const agents = await getAgents({
     state
   });
   for (const agent of agents) {
-    debugMessage(`AgentOps.deleteAgent: '${agent['_id']}'`);
+    debugMessage({
+      message: `AgentOps.deleteAgent: '${agent['_id']}'`,
+      state
+    });
     await deleteAgentByTypeAndId({
       agentType: agent['_type']['_id'],
       agentId: agent['_id'],
       state
     });
   }
-  debugMessage(`AgentOps.deleteAgents: end`);
+  debugMessage({
+    message: `AgentOps.deleteAgents: end`,
+    state
+  });
 }
 
 /**
@@ -1104,14 +1289,20 @@ export async function deleteAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.deleteAgent: start`);
+  debugMessage({
+    message: `AgentOps.deleteAgent: start`,
+    state
+  });
   const agents = await findAgentById({
     agentId,
     state
   });
   if (agents.length) {
     for (const agent of agents) {
-      debugMessage(`AgentOps.deleteAgent: '${agent['_id']}'`);
+      debugMessage({
+        message: `AgentOps.deleteAgent: '${agent['_id']}'`,
+        state
+      });
       await deleteAgentByTypeAndId({
         agentType: agent['_type'],
         agentId: agent['_id'],
@@ -1121,7 +1312,10 @@ export async function deleteAgent({
   } else {
     throw new Error(`Agent '${agentId}' not found!`);
   }
-  debugMessage(`AgentOps.deleteAgent: end`);
+  debugMessage({
+    message: `AgentOps.deleteAgent: end`,
+    state
+  });
 }
 
 /**
@@ -1130,19 +1324,28 @@ export async function deleteAgent({
 export async function deleteIdentityGatewayAgents({
   state
 }) {
-  debugMessage(`AgentOps.deleteIdentityGatewayAgents: start`);
+  debugMessage({
+    message: `AgentOps.deleteIdentityGatewayAgents: start`,
+    state
+  });
   const agents = await getIdentityGatewayAgents({
     state
   });
   for (const agent of agents) {
-    debugMessage(`AgentOps.deleteIdentityGatewayAgent: '${agent['_id']}'`);
+    debugMessage({
+      message: `AgentOps.deleteIdentityGatewayAgent: '${agent['_id']}'`,
+      state
+    });
     await deleteAgentByTypeAndId({
       agentType: agent['_type']['_id'],
       agentId: agent['_id'],
       state
     });
   }
-  debugMessage(`AgentOps.deleteIdentityGatewayAgents: end`);
+  debugMessage({
+    message: `AgentOps.deleteIdentityGatewayAgents: end`,
+    state
+  });
 }
 
 /**
@@ -1153,15 +1356,21 @@ export async function deleteIdentityGatewayAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.deleteIdentityGatewayAgent: start`);
+  debugMessage({
+    message: `AgentOps.deleteIdentityGatewayAgent: start`,
+    state
+  });
   const agents = await findAgentByTypeAndId({
-    agentType: AGENT_TYPE_IG,
+    agentType: 'IdentityGatewayAgent',
     agentId,
     state
   });
   if (agents.length) {
     for (const agent of agents) {
-      debugMessage(`AgentOps.deleteIdentityGatewayAgent: '${agent['_id']}'`);
+      debugMessage({
+        message: `AgentOps.deleteIdentityGatewayAgent: '${agent['_id']}'`,
+        state
+      });
       await deleteAgentByTypeAndId({
         agentType: agent['_type']['_id'],
         agentId: agent['_id'],
@@ -1171,7 +1380,10 @@ export async function deleteIdentityGatewayAgent({
   } else {
     throw new Error(`Identity gateway agent '${agentId}' not found!`);
   }
-  debugMessage(`AgentOps.deleteIdentityGatewayAgent: end`);
+  debugMessage({
+    message: `AgentOps.deleteIdentityGatewayAgent: end`,
+    state
+  });
 }
 
 /**
@@ -1180,19 +1392,28 @@ export async function deleteIdentityGatewayAgent({
 export async function deleteJavaAgents({
   state
 }) {
-  debugMessage(`AgentOps.deleteJavaAgents: start`);
+  debugMessage({
+    message: `AgentOps.deleteJavaAgents: start`,
+    state
+  });
   const agents = await getJavaAgents({
     state
   });
   for (const agent of agents) {
-    debugMessage(`AgentOps.deleteJavaAgent: '${agent['_id']}'`);
+    debugMessage({
+      message: `AgentOps.deleteJavaAgent: '${agent['_id']}'`,
+      state
+    });
     await deleteAgentByTypeAndId({
       agentType: agent['_type']['_id'],
       agentId: agent['_id'],
       state
     });
   }
-  debugMessage(`AgentOps.deleteJavaAgents: end`);
+  debugMessage({
+    message: `AgentOps.deleteJavaAgents: end`,
+    state
+  });
 }
 
 /**
@@ -1203,15 +1424,21 @@ export async function deleteJavaAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.deleteJavaAgent: start`);
+  debugMessage({
+    message: `AgentOps.deleteJavaAgent: start`,
+    state
+  });
   const agents = await findAgentByTypeAndId({
-    agentType: AGENT_TYPE_JAVA,
+    agentType: 'J2EEAgent',
     agentId,
     state
   });
   if (agents.length) {
     for (const agent of agents) {
-      debugMessage(`AgentOps.deleteJavaAgent: '${agent['_id']}'`);
+      debugMessage({
+        message: `AgentOps.deleteJavaAgent: '${agent['_id']}'`,
+        state
+      });
       await deleteAgentByTypeAndId({
         agentType: agent['_type']['_id'],
         agentId: agent['_id'],
@@ -1221,7 +1448,10 @@ export async function deleteJavaAgent({
   } else {
     throw new Error(`Java agent '${agentId}' not found!`);
   }
-  debugMessage(`AgentOps.deleteJavaAgent: end`);
+  debugMessage({
+    message: `AgentOps.deleteJavaAgent: end`,
+    state
+  });
 }
 
 /**
@@ -1230,19 +1460,28 @@ export async function deleteJavaAgent({
 export async function deleteWebAgents({
   state
 }) {
-  debugMessage(`AgentOps.deleteWebAgents: start`);
+  debugMessage({
+    message: `AgentOps.deleteWebAgents: start`,
+    state
+  });
   const agents = await getWebAgents({
     state
   });
   for (const agent of agents) {
-    debugMessage(`AgentOps.deleteWebAgent: '${agent['_id']}'`);
+    debugMessage({
+      message: `AgentOps.deleteWebAgent: '${agent['_id']}'`,
+      state
+    });
     await deleteAgentByTypeAndId({
       agentType: agent['_type']['_id'],
       agentId: agent['_id'],
       state
     });
   }
-  debugMessage(`AgentOps.deleteWebAgents: end`);
+  debugMessage({
+    message: `AgentOps.deleteWebAgents: end`,
+    state
+  });
 }
 
 /**
@@ -1253,15 +1492,21 @@ export async function deleteWebAgent({
   agentId,
   state
 }) {
-  debugMessage(`AgentOps.deleteWebAgent: start`);
+  debugMessage({
+    message: `AgentOps.deleteWebAgent: start`,
+    state
+  });
   const agents = await findAgentByTypeAndId({
-    agentType: AGENT_TYPE_WEB,
+    agentType: 'WebAgent',
     agentId,
     state
   });
   if (agents.length) {
     for (const agent of agents) {
-      debugMessage(`AgentOps.deleteWebAgent: '${agent['_id']}'`);
+      debugMessage({
+        message: `AgentOps.deleteWebAgent: '${agent['_id']}'`,
+        state
+      });
       await deleteAgentByTypeAndId({
         agentType: agent['_type']['_id'],
         agentId: agent['_id'],
@@ -1271,6 +1516,9 @@ export async function deleteWebAgent({
   } else {
     throw new Error(`Web agent '${agentId}' not found!`);
   }
-  debugMessage(`AgentOps.deleteWebAgent: end`);
+  debugMessage({
+    message: `AgentOps.deleteWebAgent: end`,
+    state
+  });
 }
 //# sourceMappingURL=AgentOps.js.map