@sinoia/hubdoc-tools 1.3.2 → 1.3.4

package/plugins/opentext/index.ts

@@ -0,0 +1,542 @@
+import axios, { AxiosInstance } from 'axios';
+import fs from 'fs-extra';
+import path from 'path';
+import {
+  DocumentSourcePlugin,
+  DocumentSource,
+  PluginConfig,
+  ScanResult,
+  PluginImportOptions,
+  PluginExportOptions,
+  ImportResult,
+  ExportResult
+} from '../../src/types/plugins';
+
+interface OpenTextConfig extends PluginConfig {
+  baseUrl: string;
+  username: string;
+  password: string;
+  ticket?: string; // Alternative authentication using OTDS ticket
+  startingFolderId?: number; // Starting folder ID, defaults to Enterprise workspace (2000)
+  limit?: number;
+}
+
+interface OpenTextNode {
+  id: number;
+  name: string;
+  type: number;
+  type_name: string;
+  container: boolean;
+  size?: number;
+  create_date: string;
+  modify_date: string;
+  created_by: number;
+  created_by_name: string;
+  modified_by: number;
+  modified_by_name: string;
+  parent_id: number;
+  mime_type?: string;
+  version_number?: number;
+  description?: string;
+  reserved?: boolean;
+  reserved_by?: number;
+  reserved_date?: string;
+}
+
+export default class OpenTextPlugin implements DocumentSourcePlugin {
+  readonly name = 'opentext';
+  readonly version = '1.0.0';
+  readonly description = 'OpenText Content Server document source';
+  readonly supportedOperations = ['import', 'export', 'both'] as const;
+
+  private config?: OpenTextConfig;
+  private apiClient?: AxiosInstance;
+  private authToken?: string;
+
+  async testConnection(config: PluginConfig): Promise<boolean> {
+    try {
+      const client = await this.createApiClient(config as OpenTextConfig);
+      const response = await client.get('/nodes/2000'); // Test access to Enterprise workspace
+      return response.status === 200;
+    } catch (error: any) {
+      console.error(`OpenText connection test failed: ${error.message}`);
+      return false;
+    }
+  }
+
+  async scan(config: PluginConfig, options?: PluginImportOptions): Promise<ScanResult> {
+    this.config = config as OpenTextConfig;
+    this.apiClient = await this.createApiClient(this.config);
+
+    const sources: DocumentSource[] = [];
+    const errors: string[] = [];
+    let totalSize = 0;
+
+    try {
+      const limit = (this.config as any).limit || (options as any)?.limit;
+      console.log(`🔍 Scanning OpenText Content Server${limit ? ` (limit: ${limit})` : ''}...`);
+
+      const startingFolderId = this.config.startingFolderId || 2000; // Enterprise workspace
+      const nodes = await this.scanNode(startingFolderId);
+
+      let processedCount = 0;
+      for (const node of nodes) {
+        if (!node.container && node.type === 144) { // Type 144 is Document
+          const source: DocumentSource = {
+            id: node.id.toString(),
+            name: node.name,
+            path: await this.getNodePath(node.id),
+            size: node.size || 0,
+            mimeType: node.mime_type || this.getMimeType(node.name),
+            lastModified: new Date(node.modify_date),
+            metadata: {
+              opentextId: node.id,
+              nodeType: node.type,
+              typeName: node.type_name,
+              createdAt: node.create_date,
+              createdBy: node.created_by_name,
+              modifiedBy: node.modified_by_name,
+              parentId: node.parent_id,
+              versionNumber: node.version_number,
+              description: node.description,
+              reserved: node.reserved,
+              reservedBy: node.reserved_by,
+              reservedDate: node.reserved_date
+            }
+          };
+
+          // Apply filters
+          if (this.shouldIncludeSource(source, options)) {
+            sources.push(source);
+            totalSize += source.size;
+            processedCount++;
+
+            // Check limit
+            if (limit && processedCount >= limit) {
+              console.log(`📏 Reached limit of ${limit} files`);
+              break;
+            }
+          }
+        }
+      }
+
+      return {
+        sources,
+        totalCount: sources.length,
+        totalSize,
+        errors
+      };
+    } catch (error: any) {
+      return {
+        sources: [],
+        totalCount: 0,
+        totalSize: 0,
+        errors: [`OpenText scan failed: ${error.message}`]
+      };
+    }
+  }
+
+  private async scanNode(nodeId: number, parentPath: string = ''): Promise<OpenTextNode[]> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    const allNodes: OpenTextNode[] = [];
+    let page = 1;
+    const limit = 100;
+
+    try {
+      while (true) {
+        const response = await this.apiClient.get(`/nodes/${nodeId}/nodes`, {
+          params: {
+            limit: limit,
+            page: page,
+            expand: 'properties{original_id,parent_id,name,type,type_name,container,size,create_date,modify_date,created_by,created_by_name,modified_by,modified_by_name,mime_type,version_number,description,reserved,reserved_by,reserved_date}'
+          }
+        });
+
+        const nodes: OpenTextNode[] = response.data.results || [];
+        
+        if (nodes.length === 0) {
+          break;
+        }
+
+        for (const node of nodes) {
+          const nodePath = parentPath ? `${parentPath}/${node.name}` : node.name;
+          (node as any).fullPath = nodePath;
+
+          if (!node.container) {
+            // It's a document
+            allNodes.push(node);
+          } else {
+            // It's a folder, recursively scan it
+            const subNodes = await this.scanNode(node.id, nodePath);
+            allNodes.push(...subNodes);
+          }
+        }
+
+        // Check if there are more pages
+        if (nodes.length < limit) {
+          break;
+        }
+        page++;
+      }
+
+      return allNodes;
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        console.warn(`Warning: Node not found: ${nodeId}`);
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  async import(
+    config: PluginConfig,
+    sources: DocumentSource[],
+    targetDir: string,
+    options?: PluginImportOptions
+  ): Promise<ImportResult[]> {
+    this.config = config as OpenTextConfig;
+    this.apiClient = await this.createApiClient(this.config);
+
+    const results: ImportResult[] = [];
+    const batchSize = options?.batchSize || 5;
+
+    // Process in batches to respect API limits
+    for (let i = 0; i < sources.length; i += batchSize) {
+      const batch = sources.slice(i, i + batchSize);
+      
+      for (const source of batch) {
+        const result = await this.importSingle(source, targetDir);
+        results.push(result);
+        
+        // Small delay to respect rate limits
+        await this.sleep(300);
+      }
+    }
+
+    return results;
+  }
+
+  private async importSingle(source: DocumentSource, targetDir: string): Promise<ImportResult> {
+    try {
+      if (!this.apiClient) throw new Error('API client not initialized');
+
+      const targetPath = path.join(targetDir, source.path);
+      const targetDirectory = path.dirname(targetPath);
+      
+      await fs.ensureDir(targetDirectory);
+
+      // Download file content from OpenText
+      const response = await this.apiClient.get(`/nodes/${source.id}/content`, {
+        responseType: 'stream'
+      });
+      
+      const writer = fs.createWriteStream(targetPath);
+      response.data.pipe(writer);
+
+      return new Promise((resolve) => {
+        writer.on('finish', () => {
+          resolve({
+            success: true,
+            source,
+            localPath: targetPath,
+            bytesTransferred: source.size
+          });
+        });
+
+        writer.on('error', (error) => {
+          resolve({
+            success: false,
+            source,
+            error: error.message
+          });
+        });
+      });
+    } catch (error: any) {
+      return {
+        success: false,
+        source,
+        error: error.message
+      };
+    }
+  }
+
+  async export?(
+    config: PluginConfig,
+    localSources: DocumentSource[],
+    options?: PluginExportOptions
+  ): Promise<ExportResult[]> {
+    this.config = config as OpenTextConfig;
+    this.apiClient = await this.createApiClient(this.config);
+
+    const results: ExportResult[] = [];
+    const rootFolderId = this.config.startingFolderId || 2000;
+
+    for (const source of localSources) {
+      try {
+        // Determine target folder
+        let targetFolderId = rootFolderId;
+        
+        if (options?.preserveStructure && source.path.includes('/')) {
+          const folderPath = path.dirname(source.path);
+          targetFolderId = await this.createFolderStructure(folderPath, rootFolderId);
+        }
+
+        // Read local file
+        const fileContent = await fs.readFile(source.id);
+        // Normalize filename to NFC to handle accented characters consistently across platforms
+        const fileName = (options?.preserveStructure ? path.basename(source.path) : source.name).normalize('NFC');
+
+        // Upload file to OpenText using multipart form data
+        const FormData = require('form-data');
+        const form = new FormData();
+        
+        form.append('type', '144'); // Document type
+        form.append('name', fileName);
+        form.append('description', `Uploaded via hubdoc-tools`);
+        form.append('file', fileContent, fileName);
+
+        const response = await this.apiClient!.post(`/nodes/${targetFolderId}/nodes`, form, {
+          headers: {
+            ...form.getHeaders()
+          }
+        });
+
+        const targetPath = options?.preserveStructure ? source.path : source.name;
+
+        results.push({
+          success: true,
+          targetPath,
+          source,
+          bytesTransferred: source.size
+        });
+      } catch (error: any) {
+        results.push({
+          success: false,
+          targetPath: options?.targetPath || '',
+          source,
+          error: error.message
+        });
+      }
+    }
+
+    return results;
+  }
+
+  private async createFolderStructure(folderPath: string, parentId: number): Promise<number> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    const parts = folderPath.split('/').filter(part => part.length > 0);
+    let currentParentId = parentId;
+
+    for (const folderName of parts) {
+      try {
+        // Check if folder already exists
+        const response = await this.apiClient.get(`/nodes/${currentParentId}/nodes`, {
+          params: {
+            where_name: folderName,
+            where_type: 0, // Folder type
+            limit: 1
+          }
+        });
+
+        const existingFolder = response.data.results?.[0];
+        
+        if (existingFolder) {
+          currentParentId = existingFolder.id;
+        } else {
+          // Create new folder
+          const createResponse = await this.apiClient.post(`/nodes/${currentParentId}/nodes`, {
+            type: 0, // Folder type
+            name: folderName,
+            description: `Created by hubdoc-tools`
+          });
+          currentParentId = createResponse.data.id;
+        }
+      } catch (error: any) {
+        throw new Error(`Failed to create folder structure: ${error.message}`);
+      }
+    }
+
+    return currentParentId;
+  }
+
+  private async getNodePath(nodeId: number): Promise<string> {
+    if (!this.apiClient) throw new Error('API client not initialized');
+
+    try {
+      // Get the node's ancestors to build the full path
+      const response = await this.apiClient.get(`/nodes/${nodeId}/ancestors`);
+      const ancestors = response.data.ancestors || [];
+      
+      // Filter out the Enterprise workspace and build path
+      const pathParts = ancestors
+        .filter((ancestor: any) => ancestor.id !== 2000) // Skip Enterprise workspace
+        .map((ancestor: any) => ancestor.name);
+
+      // Get the node itself to add its name
+      const nodeResponse = await this.apiClient.get(`/nodes/${nodeId}`);
+      const nodeName = nodeResponse.data.results.name;
+      
+      pathParts.push(nodeName);
+      
+      return pathParts.join('/');
+    } catch (error: any) {
+      // Fallback to just the node ID if path resolution fails
+      return `node_${nodeId}`;
+    }
+  }
+
+  getConfigSchema(): Record<string, any> {
+    return {
+      type: 'object',
+      properties: {
+        baseUrl: {
+          type: 'string',
+          description: 'OpenText Content Server base URL (e.g., http://localhost/otcs/cs.exe/api/v1)',
+          required: true
+        },
+        username: {
+          type: 'string',
+          description: 'OpenText username',
+          required: false
+        },
+        password: {
+          type: 'string',
+          description: 'OpenText password',
+          required: false
+        },
+        ticket: {
+          type: 'string',
+          description: 'OTDS authentication ticket (alternative to username/password)',
+          required: false
+        },
+        startingFolderId: {
+          type: 'number',
+          description: 'Starting folder ID (default: 2000 for Enterprise workspace)',
+          default: 2000
+        },
+        limit: {
+          type: 'number',
+          description: 'Maximum number of documents to scan (useful for testing)',
+          required: false
+        }
+      },
+      required: ['baseUrl'],
+      oneOf: [
+        { required: ['baseUrl', 'username', 'password'] },
+        { required: ['baseUrl', 'ticket'] }
+      ]
+    };
+  }
+
+  async initialize(config: PluginConfig): Promise<void> {
+    this.config = config as OpenTextConfig;
+    
+    if (!this.config.baseUrl) {
+      throw new Error('OpenText base URL is required');
+    }
+
+    if (!this.config.username && !this.config.ticket) {
+      throw new Error('Either username/password or OTDS ticket is required');
+    }
+
+    if (this.config.username && !this.config.password) {
+      throw new Error('Password is required when using username authentication');
+    }
+
+    this.apiClient = await this.createApiClient(this.config);
+  }
+
+  async destroy(): Promise<void> {
+    // Log out if we have an auth token
+    if (this.authToken && this.apiClient) {
+      try {
+        await this.apiClient.post('/auth');
+      } catch (error) {
+        // Ignore logout errors
+      }
+    }
+
+    this.config = undefined;
+    this.apiClient = undefined;
+    this.authToken = undefined;
+  }
+
+  private async createApiClient(config: OpenTextConfig): Promise<AxiosInstance> {
+    const client = axios.create({
+      baseURL: config.baseUrl,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+
+    // Authenticate and get token
+    if (config.ticket) {
+      // Use OTDS ticket
+      client.defaults.headers.common['OTDSTicket'] = config.ticket;
+    } else if (config.username && config.password) {
+      // Login with username/password
+      const authResponse = await client.post('/auth', {
+        username: config.username,
+        password: config.password
+      });
+
+      this.authToken = authResponse.data.ticket;
+      client.defaults.headers.common['OTCSTicket'] = this.authToken;
+    }
+
+    return client;
+  }
+
+  private getMimeType(fileName: string): string {
+    const ext = path.extname(fileName).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      '.pdf': 'application/pdf',
+      '.doc': 'application/msword',
+      '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+      '.xls': 'application/vnd.ms-excel',
+      '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+      '.ppt': 'application/vnd.ms-powerpoint',
+      '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+      '.txt': 'text/plain',
+      '.csv': 'text/csv',
+      '.json': 'application/json',
+      '.xml': 'application/xml',
+      '.jpg': 'image/jpeg',
+      '.jpeg': 'image/jpeg',
+      '.png': 'image/png',
+      '.gif': 'image/gif',
+      '.zip': 'application/zip'
+    };
+
+    return mimeTypes[ext] || 'application/octet-stream';
+  }
+
+  private shouldIncludeSource(source: DocumentSource, options?: PluginImportOptions): boolean {
+    // Apply size filter
+    if (options?.filters?.maxSize && source.size > options.filters.maxSize) {
+      return false;
+    }
+
+    // Apply date range filter
+    if (options?.filters?.dateRange) {
+      const { from, to } = options.filters.dateRange;
+      if (from && source.lastModified < from) return false;
+      if (to && source.lastModified > to) return false;
+    }
+
+    // Apply MIME type filter
+    if (options?.filters?.mimeTypes && !options.filters.mimeTypes.includes(source.mimeType)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+}

package/plugins/opentext/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "opentext",
+  "version": "1.0.0",
+  "description": "OpenText document source plugin",
+  "author": "HubDoc Tools",
+  "main": "index.ts",
+  "hubdocToolVersion": "^1.0.0",
+  "dependencies": {
+    "axios": "^1.5.0",
+    "fs-extra": "^11.1.0"
+  }
+}