visualvault-api 1.1.0

package/README.md

@@ -0,0 +1,263 @@
+# visualvault-api
+
+A Node.js client library that provides convenient access to the VisualVault REST API for server-side applications.
+
+## Installation
+
+```bash
+npm install visualvault-api
+```
+
+## Requirements
+
+- Node.js 20.0.0 or higher
+
+## Quick Start
+
+### Basic Authentication and Setup
+
+```javascript
+const vvRestApi = require('visualvault-api');
+
+// Initialize authentication
+const auth = new vvRestApi.authorize();
+
+// Get authenticated client
+auth.getVaultApi(
+    'your-client-id',
+    'your-client-secret',
+    'username',
+    'password',
+    'your-audience',
+    'https://your-vault-url.com',
+    'customer-alias',
+    'database-alias'
+).then(client => {
+    console.log('Successfully authenticated!');
+    // Use the client for API calls
+}).catch(error => {
+    console.error('Authentication failed:', error);
+});
+```
+
+### JWT Authentication
+
+If you already have a JWT token:
+
+```javascript
+const auth = new vvRestApi.authorize();
+
+auth.getVaultApiFromJwt(
+    'your-jwt-token',
+    'https://your-vault-url.com',
+    'customer-alias',
+    'database-alias',
+    new Date('2024-12-31') // expiration date
+).then(client => {
+    console.log('JWT authentication successful!');
+}).catch(error => {
+    console.error('JWT authentication failed:', error);
+});
+```
+
+## API Usage Examples
+
+### Working with Documents
+
+```javascript
+// Get documents from a folder
+client.library.getDocuments(params, folderId)
+    .then(response => {
+        const documents = JSON.parse(response);
+        console.log('Documents:', documents.data);
+    });
+
+// Upload a new document
+const documentData = {
+    fileName: 'example.pdf',
+    description: 'Example document',
+    folderId: 'your-folder-id'
+};
+
+client.documents.postDocWithFile(documentData, fileBuffer)
+    .then(response => {
+        console.log('Document uploaded:', response);
+    });
+
+// Get document details
+client.documents.getDocumentRevision(params, revisionId)
+    .then(response => {
+        const document = JSON.parse(response);
+        console.log('Document details:', document);
+    });
+```
+
+### Working with Forms
+
+```javascript
+// Get forms by template name
+client.forms.getForms(params, 'Your Form Template Name')
+    .then(response => {
+        const forms = JSON.parse(response);
+        console.log('Forms:', forms.data);
+    });
+
+// Create a new form instance
+const formData = {
+    field1: 'value1',
+    field2: 'value2'
+};
+
+client.forms.postForms(params, formData, 'Your Form Template Name')
+    .then(response => {
+        console.log('Form created:', response);
+    });
+
+// Get form instance by ID
+client.forms.getFormInstanceById(templateId, instanceId)
+    .then(response => {
+        const form = JSON.parse(response);
+        console.log('Form instance:', form);
+    });
+```
+
+### Working with Folders
+
+```javascript
+// Get folders
+client.library.getFolders(params)
+    .then(response => {
+        const folders = JSON.parse(response);
+        console.log('Folders:', folders.data);
+    });
+
+// Create a new folder
+const folderData = {
+    name: 'New Folder',
+    description: 'Folder description'
+};
+
+client.library.postFolderByPath(params, folderData, '/Parent Folder/New Folder')
+    .then(response => {
+        console.log('Folder created:', response);
+    });
+```
+
+### Working with Users
+
+```javascript
+// Get current user information
+client.users.getUser(params)
+    .then(response => {
+        const user = JSON.parse(response);
+        console.log('Current user:', user);
+    });
+
+// Get users in a site
+client.users.getUsers(params, siteId)
+    .then(response => {
+        const users = JSON.parse(response);
+        console.log('Users:', users.data);
+    });
+```
+
+### Running Custom Queries
+
+```javascript
+// Execute a custom query by name
+client.customQuery.getCustomQueryResultsByName('Your Query Name', params)
+    .then(response => {
+        const results = JSON.parse(response);
+        console.log('Query results:', results.data);
+    });
+```
+
+### Working with Files
+
+```javascript
+// Upload a file
+const fileData = {
+    fileName: 'document.pdf',
+    description: 'My document'
+};
+
+client.files.postFile(fileData, fileBuffer)
+    .then(response => {
+        console.log('File uploaded:', response);
+    });
+
+// Download a file
+client.files.getFileBytesId(fileId)
+    .then(fileBuffer => {
+        // Process the file buffer
+        console.log('File downloaded, size:', fileBuffer.length);
+    });
+```
+
+### Running Web Services
+
+```javascript
+// Execute a web service
+const serviceData = {
+    param1: 'value1',
+    param2: 'value2'
+};
+
+client.scripts.runWebService('YourWebServiceName', serviceData)
+    .then(response => {
+        console.log('Web service result:', response);
+    });
+```
+
+## API Modules
+
+The client provides access to the following VisualVault API modules:
+
+- **documents** - Document management operations
+- **forms** - Form template and instance operations
+- **library** - Folder and library management
+- **users** - User management operations
+- **groups** - Group management operations
+- **sites** - Site management operations
+- **files** - File upload/download operations
+- **scripts** - Web service execution
+- **customQuery** - Custom query execution
+- **email** - Email operations
+- **constants** - API constants and enums
+- **scheduledProcess** - Scheduled process management
+- **customer** - Customer management operations
+- **projects** - Project management operations
+- **indexFields** - Document Index field operations
+- **outsideProcesses** - Outside process management
+- **securityMembers** - Security member management
+- **reports** - Report generation
+
+
+## Error Handling
+
+```javascript
+client.documents.getDocuments(params, folderId)
+    .then(response => {
+        const result = JSON.parse(response);
+        if (result.meta && result.meta.statusCode === 200) {
+            console.log('Success:', result.data);
+        } else {
+            console.error('API Error:', result);
+        }
+    })
+    .catch(error => {
+        console.error('Request failed:', error);
+    });
+```
+
+## Support
+
+For more information about the VisualVault API, visit the [VisualVault documentation](https://docs.visualvault.com/).
+
+## License
+
+Use of the VisualVault API requires a customer hosting contract which defines all license terms.
+
+## Repository
+
+[GitHub Repository](https://github.com/VisualVault/nodeJs-rest-client-library)

package/lib/VVRestApi/VVRestApiNodeJs/DocApi.js

@@ -0,0 +1,66 @@
+//DocApi
+var common = require('./common');
+
+module.exports = class DocApi {
+    constructor(sessionToken, docApiConfig) {
+        if (!sessionToken['tokenType'] && sessionToken['tokenType'] != 'jwt') {
+            return;
+        }
+
+        var yaml = require('js-yaml');
+        var fs = require('fs');
+        var yamlConfig = yaml.safeLoad(fs.readFileSync(__dirname + '/config.yml', 'utf8'));
+        this._httpHelper = new common.httpHelper(sessionToken, yamlConfig);
+
+        this.isEnabled = docApiConfig['isEnabled'] || false;
+        this.baseUrl = docApiConfig['apiUrl'] || null;
+        this.roleSecurity = docApiConfig['roleSecurity'] || false;
+
+    }
+
+    async GetRevision(documentRevisionId) {
+        let resourceUri = this._httpHelper._config.ResourceUri.DocApi.GetRevision;
+        resourceUri = resourceUri.replace('{id}', documentRevisionId);
+        const url = this._httpHelper.getUrl(resourceUri);
+        const opts = { method: 'GET' };
+
+        return this._httpHelper.doVvClientRequest(url, opts, null, null);
+    }
+
+    async getDocumentOcrStatus(documentRevisionId) {
+        let resourceUri = this._httpHelper._config.ResourceUri.DocApi.OcrStatus;
+        resourceUri = resourceUri.replace('{id}', documentRevisionId);
+        const url = this._httpHelper.getUrl(resourceUri);
+
+        const opts = { method: 'GET' };
+        return this._httpHelper.doVvClientRequest(url, opts, null, null);
+    }
+
+    async updateDocumentOcrStatus(documentRevisionId, data) {
+        let resourceUri = this._httpHelper._config.ResourceUri.DocApi.OcrStatus;
+        resourceUri = resourceUri.replace('{id}', documentRevisionId);
+        const url = this._httpHelper.getUrl(resourceUri);
+
+        const opts = { method: 'PUT' };
+        return this._httpHelper.doVvClientRequest(url, opts, null, data);
+    }
+
+    async search(criteriaList, searchFolders, excludeFolders, sortBy, sortDirection = 'desc', page = 0, take = 15, archiveType = 0, roleSecurity = false) {
+        const url = this._httpHelper.getUrl(this._httpHelper._config.ResourceUri.DocApi.AdvancedSearch);
+
+        var data = {
+            criteriaList,
+            searchFolders,
+            excludeFolders,
+            sortBy,
+            sortDirection,
+            page,
+            take,
+            archiveType,
+            roleSecurity
+        };
+
+        const options = { method: 'POST'};
+        return this._httpHelper.doVvClientRequest(url, options, null, data);
+    }
+}

package/lib/VVRestApi/VVRestApiNodeJs/FormsApi.js

@@ -0,0 +1,51 @@
+//forms api
+var common = require('./common');
+
+module.exports = class FormsApi {
+    constructor(sessionToken, formsApiConfig){
+        if(!sessionToken['tokenType'] && sessionToken['tokenType'] != 'jwt'){
+            return;
+        }
+        
+        var yaml = require('js-yaml');
+        var fs = require('fs');
+        var yamlConfig = yaml.safeLoad(fs.readFileSync(__dirname + '/config.yml', 'utf8'));
+        this._httpHelper = new common.httpHelper(sessionToken, yamlConfig);
+
+        this.isEnabled = formsApiConfig['isEnabled'] || false;
+        this.baseUrl = formsApiConfig['formsApiUrl'] || null;
+        
+        if(this.isEnabled){
+            this.formInstances = new FormInstanceManager(this._httpHelper);
+        }
+    }
+}
+
+class FormInstanceManager{
+    constructor(httpHelper){
+        this._httpHelper = httpHelper;
+    }
+
+    async postForm(params, data, formTemplateRevisionId) {
+        var resourceUri = this._httpHelper._config.ResourceUri.FormsApi.FormInstance;
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'POST' };
+
+        data['formTemplateId'] = formTemplateRevisionId || data['formTemplateId'];
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    async postFormRevision(params, data, formTemplateRevisionId, formId){
+        var resourceUri = this._httpHelper._config.ResourceUri.FormsApi.FormInstance;
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'PUT' };
+
+        // only add these if provided. params could already have the value
+        data['formTemplateId'] = formTemplateRevisionId || data['formTemplateId'];
+        data['formId'] = formId || data['formId'];
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+}
+

package/lib/VVRestApi/VVRestApiNodeJs/NotificationsApi.js

@@ -0,0 +1,39 @@
+// Notifications API
+var common = require('./common');
+
+module.exports = class NotificationsApi {
+    constructor(sessionToken, notificationsApiConfig) {
+        if(!sessionToken['tokenType'] && sessionToken['tokenType'] != 'jwt'){
+            return;
+        }
+
+        var yaml = require('js-yaml');
+        var fs = require('fs');
+        var yamlConfig = yaml.safeLoad(fs.readFileSync(__dirname + '/config.yml', 'utf8'));
+        console.log("Before")
+        this._httpHelper = new common.httpHelper(sessionToken, yamlConfig);
+        console.log('After');
+
+        this.isEnabled = notificationsApiConfig['isEnabled'] || false;
+        this.baseUrl = notificationsApiConfig['apiUrl'] || null;
+
+        if (this.isEnabled) {
+            this.users = new UserNotificationsManager(this._httpHelper);
+        }
+    }
+}
+
+class UserNotificationsManager {
+    constructor (httpHelper) {
+        this._httpHelper = httpHelper;
+    }
+
+    async forceUIRefresh(userGuid) {
+        var resourceUri = this._httpHelper._config.ResourceUri.NotificationsApi.ForceUIRefresh.replace('{id}', userGuid);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'POST' };
+        var params = {};
+        var data = {};
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+}

package/lib/VVRestApi/VVRestApiNodeJs/StudioApi.js

@@ -0,0 +1,136 @@
+//studio api
+var common = require('./common');
+
+module.exports = class StudioApi {
+    constructor(sessionToken, studioApiConfig){
+        if(!sessionToken['tokenType'] && sessionToken['tokenType'] != 'jwt'){
+            return;
+        }
+        
+        var yaml = require('js-yaml');
+        var fs = require('fs');
+        var yamlConfig = yaml.safeLoad(fs.readFileSync(__dirname + '/config.yml', 'utf8'));
+        this._httpHelper = new common.httpHelper(sessionToken, yamlConfig);
+
+        this.isEnabled = studioApiConfig['isEnabled'] || false;
+        this.baseUrl = studioApiConfig['studioApiUrl'] || null;
+        this.apiUrl = '';
+        
+        if(this.isEnabled){
+            this.workflow = new WorkflowManager(this._httpHelper);
+        }
+    }
+}
+
+/** Manage Workflows */
+class WorkflowManager{
+    constructor(httpHelper){
+        this._httpHelper = httpHelper;
+    }
+
+    /** Gets the latest published workflow by Id*/
+    async getWorkflow(workflowId){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowLatestPublishedId.replace('{id}', workflowId);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'GET' };
+        var data = {};
+        var params = {};
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /** Gets the latest published workflow by Name */
+    async getWorkflowByName(workflowName){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowLatestPublished;
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'GET' };
+        var data = {};
+        var params = { name: workflowName };
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /** Gets workflow variables assigned to the workflow */
+    async getWorkflowVariables(params, workflowId){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowVariables.replace('{id}', workflowId);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'GET' };
+        var data = {};
+        params = params || {};
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /** 
+     * Triggers workflow
+     * @param {string} workflowId
+     * @param {number} workflowRevision
+     * @param {string} objectId
+     * @param {object[]} workflowVariables - workflow values to be submitted to the workflow
+     * * @param {string} workflowVariables[].name = name of variable
+     * * @param {*} workflowVariables[].value - value to be passed
+     * * @param {number} workflowVariables[].dataType - Text: 1, Number: 2, Date: 3, Boolean: 4
+     */
+    async triggerWorkflow(workflowId, workflowRevision, objectId, workflowVariables){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowRun.replace('{id}', workflowId).replace('{revision}', workflowRevision);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'POST' };
+        var data ={
+            objectId: objectId,
+            reference: 'API',
+            data: {
+                workflowVariables: workflowVariables,
+                dataSetVariables: []
+            }
+        };
+        var params = {};
+
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /**
+     * Terminates the workflow instance
+     * @param {string} workflowId 
+     * @param {string} instanceId 
+     * @returns 
+     */
+    async terminateWorkflow(workflowId, instanceId){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowTerminate.replace('{workflowId}', workflowId).replace('{instanceId}', instanceId);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'POST' };
+        var data ={}
+        var params = {};
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /**
+         * Returns workflow history for an object under the provided workflow
+         * @param {string} workflowId 
+         * @param {string} objectId 
+         * @returns 
+         */
+    async GetWorkflowHistoryForObject(objectId, workflowId){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowHistoryObject.replace('{workflowId}', workflowId).replace('{objectId}', objectId);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'GET' };
+        var data ={}
+        var params = {};
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+
+    /**
+     * Returns the running workflow, if any, for an object under the provided workflow
+     * @param {string} workflowId 
+     * @param {string} objectId 
+     * @returns 
+     */
+    async GetRunningWorkflowForObject(objectId, workflowId){
+        var resourceUri = this._httpHelper._config.ResourceUri.StudioApi.WorkflowHistoryRunningObject.replace('{workflowId}', workflowId).replace('{objectId}', objectId);
+        var url = this._httpHelper.getUrl(resourceUri);
+        var opts = { method: 'GET' };
+        var data ={}
+        var params = {};
+        return this._httpHelper.doVvClientRequest(url, opts, params, data);
+    }
+}
+