How One-Time URL API Transformed Secure Document Sharing for Remote Teams

// One-Time URL Implementation for Secure Document Sharing
const secureDocumentSharing = {
  // Generate secure one-time URL
  async createSecureLink(documentConfig) {
    const secureData = {
      documentId: documentConfig.id,
      accessLimit: 1, // Single access
      expirationTime: documentConfig.expiry || '24h',
      allowedIPs: documentConfig.restrictIPs || [],
      passwordRequired: documentConfig.password || false,
      downloadDisabled: documentConfig.viewOnly || false,
      watermarkEnabled: documentConfig.watermark || true
    };

    // Create one-time URL with Dev.me API
    const response = await devMeAPI.oneTime.create({
      url: documentConfig.originalUrl,
      ...secureData
    });

    // Generate audit log
    await this.logAccessEvent({
      documentId: documentConfig.id,
      linkId: response.linkId,
      createdBy: documentConfig.userId,
      purpose: documentConfig.purpose,
      timestamp: new Date().toISOString()
    });

    return response.secureUrl;
  },

  // Handle document access attempt
  async handleAccess(secureLinkId, accessContext) {
    const linkData = await devMeAPI.oneTime.get(secureLinkId);

    // Validate access conditions
    if (linkData.accessCount >= linkData.accessLimit) {
      throw new Error('Link access limit exceeded');
    }

    if (new Date() > new Date(linkData.expiresAt)) {
      throw new Error('Link has expired');
    }

    if (linkData.allowedIPs && !linkData.allowedIPs.includes(accessContext.ip)) {
      throw new Error('Access not allowed from this IP address');
    }

    // Log access attempt
    await this.logAccessAttempt({
      linkId: secureLinkId,
      ip: accessContext.ip,
      userAgent: accessContext.userAgent,
      timestamp: new Date().toISOString(),
      success: true
    });

    // Serve secure document
    return await this.serveDocument({
      documentId: linkData.documentId,
      watermark: accessContext.userEmail,
      viewOnly: linkData.downloadDisabled,
      expiration: linkData.expiresAt
    });
  },

  // Comprehensive audit trail
  async generateAuditReport(documentId, dateRange) {
    const accessLogs = await this.getAccessLogs({
      documentId,
      startDate: dateRange.start,
      endDate: dateRange.end
    });

    return {
      documentId,
      totalAccesses: accessLogs.length,
      uniqueUsers: [...new Set(accessLogs.map(log => log.userId))].length,
      accessTimeline: accessLogs.map(log => ({
        timestamp: log.timestamp,
        userId: log.userId,
        ip: log.ip,
        success: log.success
      })),
      complianceStatus: this.validateCompliance(accessLogs)
    };
  }
};