1
// Intelligent document classification
2
const classifyDocument = async (document) => {
3
  // Extract text for analysis
4
  const text = await $node['PDF Extract'].extractText({
5
    file: document.buffer,
6
    options: {
7
      layout: true,
8
      tables: true,
9
      images: true
10
    }
11
  });
12

13
  // Use AI to classify document type
14
  const classification = await $node['OpenAI'].completions.create({
15
    model: "gpt-4",
16
    messages: [{
17
      role: "system",
18
      content: `Classify this document into one of these categories:
19
        - invoice
20
        - receipt
21
        - contract
22
        - resume
23
        - report
24
        - form
25
        - letter
26
        Return JSON with: { type, confidence, metadata }`
27
    }, {
28
      role: "user",
29
      content: text.substring(0, 2000) // First 2000 chars for classification
30
    }],
31
    temperature: 0.1
32
  });
33

34
  const result = JSON.parse(classification.choices[0].message.content);
35

36
  // Add document fingerprint
37
  result.fingerprint = await generateDocumentFingerprint(document);
38

39
  return result;
40
};
41

42
// Generate unique document fingerprint
43
const generateDocumentFingerprint = async (document) => {
44
  const hash = crypto.createHash('sha256');
45
  hash.update(document.buffer);
46
  return hash.digest('hex');
47
};

1
// Extract structured data from PDFs
2
const extractStructuredData = async (document, documentType) => {
3
  const extractors = {
4
    invoice: extractInvoiceData,
5
    receipt: extractReceiptData,
6
    contract: extractContractData,
7
    resume: extractResumeData,
8
    report: extractReportData
9
  };
10

11
  const extractor = extractors[documentType];
12
  if (!extractor) {
13
    throw new Error(`No extractor for document type: ${documentType}`);
14
  }
15

16
  return await extractor(document);
17
};
18

19
// Invoice data extraction with validation
20
const extractInvoiceData = async (document) => {
21
  // Extract text with layout preservation
22
  const pages = await $node['PDF'].parse({
23
    file: document.buffer,
24
    options: {
25
      preserveLayout: true,
26
      extractTables: true
27
    }
28
  });
29

30
  const invoiceData = {
31
    invoiceNumber: '',
32
    date: '',
33
    vendor: {},
34
    customer: {},
35
    lineItems: [],
36
    totals: {},
37
    paymentTerms: ''
38
  };
39

40
  // Extract using patterns and AI
41
  for (const page of pages) {
42
    // Find invoice number
43
    const invoicePattern = /Invoice\s*#?\s*:?\s*([A-Z0-9-]+)/i;
44
    const invoiceMatch = page.text.match(invoicePattern);
45
    if (invoiceMatch) {
46
      invoiceData.invoiceNumber = invoiceMatch[1];
47
    }
48

49
    // Extract tables for line items
50
    if (page.tables && page.tables.length > 0) {
51
      invoiceData.lineItems = parseLineItemsTable(page.tables[0]);
52
    }
53

54
    // Use AI for complex extraction
55
    const aiExtraction = await extractWithAI(page.text, 'invoice');
56
    Object.assign(invoiceData, aiExtraction);
57
  }
58

59
  // Validate extracted data
60
  const validation = await validateInvoiceData(invoiceData);
61
  if (!validation.isValid) {
62
    invoiceData.warnings = validation.warnings;
63
  }
64

65
  return invoiceData;
66
};
67

68
// Parse table data for line items
69
const parseLineItemsTable = (table) => {
70
  const headers = table[0].map(h => h.toLowerCase().trim());
71
  const items = [];
72

73
  for (let i = 1; i < table.length; i++) {
74
    const row = table[i];
75
    const item = {};
76

77
    headers.forEach((header, index) => {
78
      if (header.includes('description')) {
79
        item.description = row[index];
80
      } else if (header.includes('quantity') || header.includes('qty')) {
81
        item.quantity = parseFloat(row[index]) || 0;
82
      } else if (header.includes('price') || header.includes('rate')) {
83
        item.unitPrice = parseFloat(row[index].replace(/[$,]/g, '')) || 0;
84
      } else if (header.includes('amount') || header.includes('total')) {
85
        item.total = parseFloat(row[index].replace(/[$,]/g, '')) || 0;
86
      }
87
    });
88

89
    if (item.description) {
90
      items.push(item);
91
    }
92
  }
93

94
  return items;
95
};

1
// Advanced resume parsing system
2
const parseResume = async (resumePDF) => {
3
  // Extract text with formatting
4
  const resumeText = await $node['PDF Extract'].extractText({
5
    file: resumePDF.buffer,
6
    options: {
7
      preserveFormatting: true
8
    }
9
  });
10

11
  // Parse sections
12
  const sections = identifyResumeSections(resumeText);
13

14
  // Extract structured information
15
  const resumeData = {
16
    personalInfo: await extractPersonalInfo(sections.header || resumeText),
17
    education: await extractEducation(sections.education),
18
    experience: await extractExperience(sections.experience),
19
    skills: await extractSkills(sections.skills),
20
    certifications: await extractCertifications(sections.certifications),
21
    languages: await extractLanguages(resumeText),
22
    summary: sections.summary || await generateSummary(resumeText)
23
  };
24

25
  // Calculate ATS score
26
  resumeData.atsScore = await calculateATSScore(resumeData);
27

28
  // Extract contact information with validation
29
  resumeData.contact = await extractAndValidateContact(resumeText);
30

31
  return resumeData;
32
};
33

34
// AI-powered experience extraction
35
const extractExperience = async (experienceText) => {
36
  if (!experienceText) return [];
37

38
  const prompt = `
39
Extract work experience from this text and return JSON array:
40
${experienceText}
41

42
Format each entry as:
43
{
44
  "company": "Company Name",
45
  "position": "Job Title",
46
  "startDate": "MM/YYYY",
47
  "endDate": "MM/YYYY or Present",
48
  "location": "City, State",
49
  "responsibilities": ["responsibility1", "responsibility2"],
50
  "achievements": ["achievement1", "achievement2"]
51
}
52
  `;
53

54
  const extraction = await $node['OpenAI'].completions.create({
55
    model: "gpt-4",
56
    messages: [{ role: "user", content: prompt }],
57
    temperature: 0.1
58
  });
59

60
  return JSON.parse(extraction.choices[0].message.content);
61
};
62

63
// Calculate ATS compatibility score
64
const calculateATSScore = async (resumeData) => {
65
  const scores = {
66
    formatting: 0,
67
    keywords: 0,
68
    structure: 0,
69
    content: 0
70
  };
71

72
  // Check formatting
73
  if (resumeData.personalInfo.name) scores.formatting += 20;
74
  if (resumeData.contact.email) scores.formatting += 10;
75
  if (resumeData.contact.phone) scores.formatting += 10;
76

77
  // Check structure
78
  if (resumeData.experience.length > 0) scores.structure += 25;
79
  if (resumeData.education.length > 0) scores.structure += 15;
80
  if (resumeData.skills.length > 0) scores.structure += 10;
81

82
  // Check content quality
83
  const totalExperience = resumeData.experience.reduce((acc, exp) => {
84
    return acc + (exp.responsibilities?.length || 0) + (exp.achievements?.length || 0);
85
  }, 0);
86

87
  scores.content = Math.min(totalExperience * 5, 50);
88

89
  // Calculate total score
90
  const totalScore = Object.values(scores).reduce((a, b) => a + b, 0);
91

92
  return {
93
    total: totalScore,
94
    breakdown: scores,
95
    recommendations: generateATSRecommendations(scores)
96
  };
97
};

1
// OCR processing for scanned PDFs
2
const processScannedDocument = async (document) => {
3
  // Check if document needs OCR
4
  const needsOCR = await checkIfScanned(document);
5

6
  if (!needsOCR) {
7
    return await extractStructuredData(document);
8
  }
9

10
  // Perform OCR
11
  const ocrResult = await $node['Tesseract'].recognize({
12
    image: document.buffer,
13
    options: {
14
      lang: 'eng+fra+deu', // Multiple languages
15
      psm: 3, // Page segmentation mode
16
      oem: 3, // OCR Engine mode
17
      preserve_interword_spaces: 1
18
    }
19
  });
20

21
  // Enhance OCR accuracy with AI
22
  const enhancedText = await enhanceOCRWithAI(ocrResult.text);
23

24
  // Extract structured data from OCR text
25
  const structuredData = await extractFromOCRText(enhancedText);
26

27
  return {
28
    ...structuredData,
29
    ocrConfidence: ocrResult.confidence,
30
    isScanned: true
31
  };
32
};
33

34
// AI-powered OCR correction
35
const enhanceOCRWithAI = async (ocrText) => {
36
  const prompt = `
37
The following text was extracted using OCR and may contain errors.
38
Please correct obvious OCR mistakes while preserving the original meaning:
39

40
${ocrText}
41

42
Return the corrected text.
43
  `;
44

45
  const correction = await $node['OpenAI'].completions.create({
46
    model: "gpt-4",
47
    messages: [{ role: "user", content: prompt }],
48
    temperature: 0.1
49
  });
50

51
  return correction.choices[0].message.content;
52
};

1
// Generate PDFs from templates
2
const generateDocument = async (template, data) => {
3
  const documentTypes = {
4
    invoice: generateInvoice,
5
    report: generateReport,
6
    certificate: generateCertificate,
7
    contract: generateContract
8
  };
9

10
  const generator = documentTypes[template.type];
11
  if (!generator) {
12
    throw new Error(`Unknown document type: ${template.type}`);
13
  }
14

15
  return await generator(template, data);
16
};
17

18
// Generate professional invoice PDF
19
const generateInvoice = async (template, invoiceData) => {
20
  // Load HTML template
21
  const html = await renderTemplate(template.path, invoiceData);
22

23
  // Add dynamic elements
24
  const enhancedHTML = `
25
    <!DOCTYPE html>
26
    <html>
27
    <head>
28
      <style>
29
        body { font-family: 'Helvetica', sans-serif; }
30
        .header { background: #f0f0f0; padding: 20px; }
31
        .invoice-number { font-size: 24px; font-weight: bold; }
32
        table { width: 100%; border-collapse: collapse; }
33
        th { background: #333; color: white; padding: 10px; }
34
        td { padding: 8px; border-bottom: 1px solid #ddd; }
35
        .total { font-size: 18px; font-weight: bold; text-align: right; }
36
      </style>
37
    </head>
38
    <body>
39
      ${html}
40
    </body>
41
    </html>
42
  `;
43

44
  // Convert to PDF
45
  const pdf = await $node['Puppeteer'].generatePDF({
46
    html: enhancedHTML,
47
    options: {
48
      format: 'A4',
49
      printBackground: true,
50
      margin: {
51
        top: '20mm',
52
        right: '20mm',
53
        bottom: '20mm',
54
        left: '20mm'
55
      }
56
    }
57
  });
58

59
  // Add metadata
60
  const finalPDF = await addPDFMetadata(pdf, {
61
    title: `Invoice ${invoiceData.invoiceNumber}`,
62
    author: invoiceData.company.name,
63
    subject: 'Invoice',
64
    keywords: ['invoice', invoiceData.invoiceNumber, invoiceData.customer.name],
65
    creator: 'n8n Document Automation'
66
  });
67

68
  return finalPDF;
69
};

1
// Process fillable forms
2
const processForm = async (formPDF, formData) => {
3
  // Extract form fields
4
  const fields = await $node['PDF Form'].getFields({
5
    file: formPDF.buffer
6
  });
7

8
  // Map data to fields with validation
9
  const fieldMapping = {};
10

11
  for (const field of fields) {
12
    const value = formData[field.name] || findMatchingValue(field, formData);
13

14
    if (value !== undefined) {
15
      // Validate field value
16
      const validation = validateFieldValue(field, value);
17

18
      if (validation.isValid) {
19
        fieldMapping[field.name] = validation.formattedValue;
20
      } else {
21
        console.warn(`Invalid value for field ${field.name}: ${validation.error}`);
22
      }
23
    }
24
  }
25

26
  // Fill form with mapped data
27
  const filledForm = await $node['PDF Form'].fillForm({
28
    file: formPDF.buffer,
29
    fields: fieldMapping,
30
    flatten: false // Keep form fillable
31
  });
32

33
  // Add digital signature if required
34
  if (formData.signature) {
35
    return await addDigitalSignature(filledForm, formData.signature);
36
  }
37

38
  return filledForm;
39
};

1
// AI-powered contract analysis
2
const analyzeContract = async (contractPDF) => {
3
  const contractText = await extractText(contractPDF);
4

5
  const analysisPrompt = `
6
Analyze this contract and extract:
7
1. Parties involved
8
2. Key dates (start, end, renewal)
9
3. Payment terms
10
4. Obligations and responsibilities
11
5. Termination clauses
12
6. Liability and indemnification
13
7. Governing law
14
8. Potential risks or concerns
15

16
Contract text:
17
${contractText}
18

19
Return structured JSON with all findings.
20
  `;
21

22
  const analysis = await $node['OpenAI'].completions.create({
23
    model: "gpt-4",
24
    messages: [{ role: "user", content: analysisPrompt }],
25
    max_tokens: 2000,
26
    temperature: 0.1
27
  });
28

29
  const result = JSON.parse(analysis.choices[0].message.content);
30

31
  // Add risk scoring
32
  result.riskScore = calculateContractRisk(result);
33

34
  // Generate summary
35
  result.executiveSummary = await generateContractSummary(result);
36

37
  return result;
38
};
39

40
// Calculate contract risk score
41
const calculateContractRisk = (analysis) => {
42
  let riskScore = 0;
43
  const riskFactors = [];
44

45
  // Check for missing important clauses
46
  if (!analysis.terminationClause) {
47
    riskScore += 20;
48
    riskFactors.push('No clear termination clause');
49
  }
50

51
  if (!analysis.liabilityLimitation) {
52
    riskScore += 25;
53
    riskFactors.push('Unlimited liability exposure');
54
  }
55

56
  // Check payment terms
57
  if (analysis.paymentTerms?.netDays > 60) {
58
    riskScore += 15;
59
    riskFactors.push('Extended payment terms');
60
  }
61

62
  // Check jurisdiction
63
  if (analysis.governingLaw?.jurisdiction === 'foreign') {
64
    riskScore += 10;
65
    riskFactors.push('Foreign jurisdiction');
66
  }
67

68
  return {
69
    score: riskScore,
70
    level: riskScore > 50 ? 'high' : riskScore > 25 ? 'medium' : 'low',
71
    factors: riskFactors
72
  };
73
};

1
// Create searchable document database
2
const indexDocument = async (document, metadata) => {
3
  // Extract text and structure
4
  const content = await extractFullContent(document);
5

6
  // Generate embeddings for semantic search
7
  const embeddings = await $node['OpenAI'].embeddings.create({
8
    model: "text-embedding-ada-002",
9
    input: content.text
10
  });
11

12
  // Index in Elasticsearch
13
  await $node['Elasticsearch'].index({
14
    index: 'documents',
15
    body: {
16
      id: document.id,
17
      title: metadata.title,
18
      content: content.text,
19
      type: metadata.type,
20
      date: metadata.date,
21
      tags: metadata.tags,
22
      embeddings: embeddings.data[0].embedding,
23
      metadata: {
24
        pages: content.pageCount,
25
        words: content.wordCount,
26
        tables: content.tables?.length || 0,
27
        images: content.images?.length || 0
28
      },
29
      extractedData: content.structuredData,
30
      timestamp: new Date().toISOString()
31
    }
32
  });
33

34
  // Update vector database for similarity search
35
  await $node['Pinecone'].upsert({
36
    vectors: [{
37
      id: document.id,
38
      values: embeddings.data[0].embedding,
39
      metadata: {
40
        title: metadata.title,
41
        type: metadata.type,
42
        content: content.text.substring(0, 1000)
43
      }
44
    }]
45
  });
46

47
  return {
48
    indexed: true,
49
    documentId: document.id,
50
    searchable: true
51
  };
52
};
53

54
// Semantic document search
55
const searchDocuments = async (query, filters = {}) => {
56
  // Generate query embedding
57
  const queryEmbedding = await $node['OpenAI'].embeddings.create({
58
    model: "text-embedding-ada-002",
59
    input: query
60
  });
61

62
  // Search in vector database
63
  const semanticResults = await $node['Pinecone'].query({
64
    vector: queryEmbedding.data[0].embedding,
65
    topK: 20,
66
    filter: filters,
67
    includeMetadata: true
68
  });
69

70
  // Combine with keyword search
71
  const keywordResults = await $node['Elasticsearch'].search({
72
    index: 'documents',
73
    body: {
74
      query: {
75
        multi_match: {
76
          query: query,
77
          fields: ['title^2', 'content', 'tags^1.5']
78
        }
79
      },
80
      size: 20
81
    }
82
  });
83

84
  // Merge and rank results
85
  const mergedResults = mergeSearchResults(semanticResults, keywordResults);
86

87
  return mergedResults;
88
};