@rockcarver/frodo-lib 1.0.0 → 2.0.0-1

package/esm/ops/ResourceTypeOps.mjs

@@ -1,14 +1,156 @@
-import { deleteResourceType as _deleteResourceType, getResourceTypes as _getResourceTypes, getResourceType as _getResourceType, getResourceTypeByName as _getResourceTypeByName, createResourceType as _createResourceType, putResourceType } from '../api/ResourceTypesApi';
+import { deleteResourceType, getResourceTypes as _getResourceTypes, getResourceType, getResourceTypeByName as _getResourceTypeByName, createResourceType, putResourceType } from '../api/ResourceTypesApi';
 import { getMetadata } from './utils/ExportImportUtils';
 import { debugMessage } from './utils/Console';
-import { state } from '..';
+export default class ResourceTypeOps {
+  constructor(state) {
+    this.state = state;
+  }
+
+  /**
+   * Get all resource types
+   * @returns {Promise} a promise that resolves to an array of resource type objects
+   */
+  async getResourceTypes({
+    state
+  }) {
+    const {
+      result
+    } = await _getResourceTypes({
+      state
+    });
+    return result;
+  }
+
+  /**
+   * Get resource type by name
+   * @param {string} resourceTypeName resource type name
+   * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
+   */
+  async getResourceTypeByName(resourceTypeName) {
+    return getResourceTypeByName({
+      resourceTypeName,
+      state: this.state
+    });
+  }
+
+  /**
+   * Update resource type
+   * @param {string} resourceTypeData resource type id
+   * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
+   */
+  async updateResourceType(resourceTypeUuid, resourceTypeData) {
+    return updateResourceType({
+      resourceTypeUuid,
+      resourceTypeData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Delete resource type by name
+   * @param {string} resourceTypeName resource type name
+   * @returns {Promise<ResourceTypeSkeleton>} Promise resolvig to a resource type object
+   */
+  async deleteResourceTypeByName(resourceTypeName) {
+    return deleteResourceTypeByName({
+      resourceTypeName,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export resource type
+   * @param {string} resourceTypeUuid resource type uuid
+   * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
+   */
+  async exportResourceType(resourceTypeUuid) {
+    return exportResourceType({
+      resourceTypeUuid,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export resource type by name
+   * @param {string} resourceTypeName resource type name
+   * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
+   */
+  async exportResourceTypeByName(resourceTypeName) {
+    return exportResourceTypeByName({
+      resourceTypeName,
+      state: this.state
+    });
+  }
+
+  /**
+   * Export resource types
+   * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
+   */
+  async exportResourceTypes() {
+    return exportResourceTypes({
+      state: this.state
+    });
+  }
+
+  /**
+   * Import resource type by uuid
+   * @param {string} resourceTypeUuid client uuid
+   * @param {ResourceTypeExportInterface} importData import data
+   */
+  async importResourceType(resourceTypeUuid, importData) {
+    return importResourceType({
+      resourceTypeUuid,
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import resource type by name
+   * @param {string} resourceTypeName client id
+   * @param {ResourceTypeExportInterface} importData import data
+   */
+  async importResourceTypeByName(resourceTypeName, importData) {
+    return importResourceTypeByName({
+      resourceTypeName,
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import first resource type
+   * @param {ResourceTypeExportInterface} importData import data
+   */
+  async importFirstResourceType(importData) {
+    return importFirstResourceType({
+      importData,
+      state: this.state
+    });
+  }
+
+  /**
+   * Import resource types
+   * @param {ResourceTypeExportInterface} importData import data
+   */
+  async importResourceTypes(importData) {
+    return importResourceTypes({
+      importData,
+      state: this.state
+    });
+  }
+}
 /**
  * Create an empty export template
  * @returns {ResourceTypeExportInterface} an empty export template
  */
-function createResourceTypeExportTemplate() {
+function createResourceTypeExportTemplate({
+  state
+}) {
   return {
-    meta: getMetadata(),
+    meta: getMetadata({
+      state
+    }),
     script: {},
     policy: {},
     policyset: {},
@@ -20,31 +162,32 @@ function createResourceTypeExportTemplate() {
  * Get all resource types
  * @returns {Promise} a promise that resolves to an array of resource type objects
  */
-export async function getResourceTypes() {
+export async function getResourceTypes({
+  state
+}) {
   const {
     result
-  } = await _getResourceTypes();
+  } = await _getResourceTypes({
+    state
+  });
   return result;
 }
 
-/**
- * Get resource type
- * @param {string} resourceTypeId resource type id
- * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
- */
-export async function getResourceType(resourceTypeId) {
-  return _getResourceType(resourceTypeId);
-}
-
 /**
  * Get resource type by name
  * @param {string} resourceTypeName resource type name
  * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
  */
-export async function getResourceTypeByName(resourceTypeName) {
+export async function getResourceTypeByName({
+  resourceTypeName,
+  state
+}) {
   const {
     result
-  } = await _getResourceTypeByName(resourceTypeName);
+  } = await _getResourceTypeByName({
+    resourceTypeName,
+    state
+  });
   switch (result.length) {
     case 1:
       return result[0];
@@ -55,31 +198,21 @@ export async function getResourceTypeByName(resourceTypeName) {
   }
 }
 
-/**
- * Create resource type
- * @param {string} resourceTypeData resource type id
- * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
- */
-export async function createResourceType(resourceTypeData) {
-  return _createResourceType(resourceTypeData);
-}
-
 /**
  * Update resource type
  * @param {string} resourceTypeData resource type id
  * @returns {Promise<ResourceTypeSkeleton>} a promise that resolves to a resource type object
  */
-export async function updateResourceType(resourceTypeUuid, resourceTypeData) {
-  return putResourceType(resourceTypeUuid, resourceTypeData);
-}
-
-/**
- * Delete resource type
- * @param {string} resourceTypeId resource type id
- * @returns {Promise<ResourceTypeSkeleton>} Promise resolvig to a resource type object
- */
-export async function deleteResourceType(resourceTypeId) {
-  return _deleteResourceType(resourceTypeId);
+export async function updateResourceType({
+  resourceTypeUuid,
+  resourceTypeData,
+  state
+}) {
+  return putResourceType({
+    resourceTypeUuid,
+    resourceTypeData,
+    state
+  });
 }
 
 /**
@@ -87,9 +220,18 @@ export async function deleteResourceType(resourceTypeId) {
  * @param {string} resourceTypeName resource type name
  * @returns {Promise<ResourceTypeSkeleton>} Promise resolvig to a resource type object
  */
-export async function deleteResourceTypeByName(resourceTypeName) {
-  const resourceTypeUuid = (await getResourceTypeByName(resourceTypeName)).uuid;
-  return _deleteResourceType(resourceTypeUuid);
+export async function deleteResourceTypeByName({
+  resourceTypeName,
+  state
+}) {
+  const resourceTypeUuid = (await getResourceTypeByName({
+    resourceTypeName,
+    state
+  })).uuid;
+  return deleteResourceType({
+    resourceTypeUuid,
+    state
+  });
 }
 
 /**
@@ -97,12 +239,20 @@ export async function deleteResourceTypeByName(resourceTypeName) {
  * @param {string} resourceTypeUuid resource type uuid
  * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
  */
-export async function exportResourceType(resourceTypeUuid) {
+export async function exportResourceType({
+  resourceTypeUuid,
+  state
+}) {
   debugMessage(`ResourceTypeOps.exportResourceType: start`);
-  const exportData = createResourceTypeExportTemplate();
+  const exportData = createResourceTypeExportTemplate({
+    state
+  });
   const errors = [];
   try {
-    const resourceTypeData = await getResourceType(resourceTypeUuid);
+    const resourceTypeData = await getResourceType({
+      resourceTypeUuid,
+      state
+    });
     exportData.resourcetype[resourceTypeData.uuid] = resourceTypeData;
   } catch (error) {
     errors.push(error);
@@ -128,12 +278,20 @@ export async function exportResourceType(resourceTypeUuid) {
  * @param {string} resourceTypeName resource type name
  * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
  */
-export async function exportResourceTypeByName(resourceTypeName) {
+export async function exportResourceTypeByName({
+  resourceTypeName,
+  state
+}) {
   debugMessage(`ResourceTypeOps.exportResourceTypeByName: start`);
-  const exportData = createResourceTypeExportTemplate();
+  const exportData = createResourceTypeExportTemplate({
+    state
+  });
   const errors = [];
   try {
-    const resourceTypeData = await getResourceTypeByName(resourceTypeName);
+    const resourceTypeData = await getResourceTypeByName({
+      resourceTypeName,
+      state
+    });
     exportData.resourcetype[resourceTypeData.uuid] = resourceTypeData;
   } catch (error) {
     errors.push(error);
@@ -150,12 +308,18 @@ export async function exportResourceTypeByName(resourceTypeName) {
  * Export resource types
  * @returns {Promise<ResourceTypeExportInterface>} a promise that resolves to an ResourceTypeExportInterface object
  */
-export async function exportResourceTypes() {
+export async function exportResourceTypes({
+  state
+}) {
   debugMessage(`ResourceTypeOps.exportResourceType: start`);
-  const exportData = createResourceTypeExportTemplate();
+  const exportData = createResourceTypeExportTemplate({
+    state
+  });
   const errors = [];
   try {
-    const resourceTypes = await getResourceTypes();
+    const resourceTypes = await getResourceTypes({
+      state
+    });
     for (const resourceTypeData of resourceTypes) {
       exportData.resourcetype[resourceTypeData.uuid] = resourceTypeData;
     }
@@ -175,7 +339,11 @@ export async function exportResourceTypes() {
  * @param {string} resourceTypeUuid client uuid
  * @param {ResourceTypeExportInterface} importData import data
  */
-export async function importResourceType(resourceTypeUuid, importData) {
+export async function importResourceType({
+  resourceTypeUuid,
+  importData,
+  state
+}) {
   let response = null;
   const errors = [];
   const imported = [];
@@ -185,10 +353,17 @@ export async function importResourceType(resourceTypeUuid, importData) {
         const resourceTypeData = importData.resourcetype[id];
         delete resourceTypeData._rev;
         try {
-          response = await createResourceType(resourceTypeData);
+          response = await createResourceType({
+            resourceTypeData,
+            state
+          });
         } catch (createError) {
           var _createError$response;
-          if (((_createError$response = createError.response) === null || _createError$response === void 0 ? void 0 : _createError$response.status) === 409) response = await putResourceType(id, resourceTypeData);else throw createError;
+          if (((_createError$response = createError.response) === null || _createError$response === void 0 ? void 0 : _createError$response.status) === 409) response = await putResourceType({
+            resourceTypeUuid: id,
+            resourceTypeData,
+            state
+          });else throw createError;
         }
         imported.push(id);
       } catch (error) {
@@ -214,7 +389,11 @@ export async function importResourceType(resourceTypeUuid, importData) {
  * @param {string} resourceTypeName client id
  * @param {ResourceTypeExportInterface} importData import data
  */
-export async function importResourceTypeByName(resourceTypeName, importData) {
+export async function importResourceTypeByName({
+  resourceTypeName,
+  importData,
+  state
+}) {
   let response = null;
   const errors = [];
   const imported = [];
@@ -224,10 +403,17 @@ export async function importResourceTypeByName(resourceTypeName, importData) {
         const resourceTypeData = importData.resourcetype[id];
         delete resourceTypeData._rev;
         try {
-          response = await createResourceType(resourceTypeData);
+          response = await createResourceType({
+            resourceTypeData,
+            state
+          });
         } catch (createError) {
           var _createError$response2;
-          if (((_createError$response2 = createError.response) === null || _createError$response2 === void 0 ? void 0 : _createError$response2.status) === 409) response = await putResourceType(id, resourceTypeData);else throw createError;
+          if (((_createError$response2 = createError.response) === null || _createError$response2 === void 0 ? void 0 : _createError$response2.status) === 409) response = await putResourceType({
+            resourceTypeUuid: id,
+            resourceTypeData,
+            state
+          });else throw createError;
         }
         imported.push(id);
       } catch (error) {
@@ -252,7 +438,10 @@ export async function importResourceTypeByName(resourceTypeName, importData) {
  * Import first resource type
  * @param {ResourceTypeExportInterface} importData import data
  */
-export async function importFirstResourceType(importData) {
+export async function importFirstResourceType({
+  importData,
+  state
+}) {
   let response = null;
   const errors = [];
   const imported = [];
@@ -262,10 +451,17 @@ export async function importFirstResourceType(importData) {
       delete resourceTypeData._provider;
       delete resourceTypeData._rev;
       try {
-        response = await createResourceType(resourceTypeData);
+        response = await createResourceType({
+          resourceTypeData,
+          state
+        });
       } catch (createError) {
         var _createError$response3;
-        if (((_createError$response3 = createError.response) === null || _createError$response3 === void 0 ? void 0 : _createError$response3.status) === 409) response = await putResourceType(id, resourceTypeData);else throw createError;
+        if (((_createError$response3 = createError.response) === null || _createError$response3 === void 0 ? void 0 : _createError$response3.status) === 409) response = await putResourceType({
+          resourceTypeUuid: id,
+          resourceTypeData,
+          state
+        });else throw createError;
       }
       imported.push(id);
     } catch (error) {
@@ -290,7 +486,10 @@ export async function importFirstResourceType(importData) {
  * Import resource types
  * @param {ResourceTypeExportInterface} importData import data
  */
-export async function importResourceTypes(importData) {
+export async function importResourceTypes({
+  importData,
+  state
+}) {
   const response = [];
   const errors = [];
   const imported = [];
@@ -299,10 +498,17 @@ export async function importResourceTypes(importData) {
       const resourceTypeData = importData.resourcetype[id];
       delete resourceTypeData._rev;
       try {
-        response.push(await createResourceType(resourceTypeData));
+        response.push(await createResourceType({
+          resourceTypeData,
+          state
+        }));
       } catch (createError) {
         var _createError$response4;
-        if (((_createError$response4 = createError.response) === null || _createError$response4 === void 0 ? void 0 : _createError$response4.status) === 409) response.push(await putResourceType(id, resourceTypeData));else throw createError;
+        if (((_createError$response4 = createError.response) === null || _createError$response4 === void 0 ? void 0 : _createError$response4.status) === 409) response.push(await putResourceType({
+          resourceTypeUuid: id,
+          resourceTypeData,
+          state
+        }));else throw createError;
       }
       imported.push(id);
     } catch (error) {
@@ -321,4 +527,5 @@ export async function importResourceTypes(importData) {
   }
   return response;
 }
+export { getResourceType, createResourceType, deleteResourceType };
 //# sourceMappingURL=ResourceTypeOps.js.map