adpa-enterprise-framework-automation/docs/ADOBE/ADOBE-IMMEDIATE-START-GUIDE.md

Modular, standards-compliant Node.js/TypeScript automation framework for enterprise requirements, project, and data management. Provides CLI and API for BABOK v3, PMBOK 7th Edition, and DMBOK 2.0 (in progress). Production-ready Express.js API with TypeSpe

# Start Adobe.io Development RIGHT NOW (No Azure Required)

## What You Can Do Immediately

Since you already have Adobe.io platform console access, you can start building the Adobe integration into your ADPA system today, without any Azure services or costs.

## Step 1: Get Your Adobe.io Credentials (5 minutes)

1. **Log into Adobe Developer Console:** https://developer.adobe.com/console
2. **Find your existing project** or create a new one
3. **Copy these credentials:**
   - Client ID
   - Client Secret
   - Organization ID

## Step 2: Test Your Adobe.io Access (2 minutes)

```bash
# Test your credentials work
curl -X POST "https://ims-na1.adobelogin.com/ims/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=openid,AdobeID,session"
```

If this returns an access token, you're ready to go!

## Step 3: Add Direct Adobe Integration to Your ADPA Word Add-in

Add this simple integration directly to your existing `word.ts` file:

```typescript
// Add to your existing ADPA/src/commands/word.ts

/**
 * Convert current Word document to PDF using Adobe.io
 */
export async function convertToAdobePDF(event: Office.AddinCommands.Event) {
  try {
    await Word.run(async (context) => {
      // Get document content
      const body = context.document.body;
      context.load(body, 'text');
      await context.sync();

      const content = body.text;
      
      // Convert to PDF using Adobe.io (direct API call)
      const pdfUrl = await callAdobePDFAPI(content);
      
      // Show success message with download link
      const successParagraph = context.document.body.insertParagraph(
        `✅ PDF Generated Successfully! Download: ${pdfUrl}`,
        Word.InsertLocation.end
      );
      successParagraph.font.color = "green";
      successParagraph.font.bold = true;
      
      await context.sync();
    });
  } catch (error) {
    console.error('Adobe PDF conversion failed:', error);
  }

  event.completed();
}

/**
 * Direct Adobe.io API call (no Azure required)
 */
async function callAdobePDFAPI(markdownContent: string): Promise<string> {
  // Your Adobe.io credentials (in production, store these securely)
  const ADOBE_CLIENT_ID = 'your-client-id';
  const ADOBE_CLIENT_SECRET = 'your-client-secret';
  
  try {
    // Step 1: Get Adobe access token
    const tokenResponse = await fetch('https://ims-na1.adobelogin.com/ims/token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
      body: new URLSearchParams({
        grant_type: 'client_credentials',
        client_id: ADOBE_CLIENT_ID,
        client_secret: ADOBE_CLIENT_SECRET,
        scope: 'openid,AdobeID,session'
      })
    });
    
    const { access_token } = await tokenResponse.json();
    
    // Step 2: Convert content to HTML
    const htmlContent = markdownToHTML(markdownContent);
    
    // Step 3: Upload to Adobe
    const uploadResponse = await uploadToAdobe(htmlContent, access_token, ADOBE_CLIENT_ID);
    
    // Step 4: Create PDF
    const pdfResponse = await createPDFJob(uploadResponse.assetID, access_token, ADOBE_CLIENT_ID);
    
    // Step 5: Poll for completion
    const resultUrl = await pollForPDF(pdfResponse.jobID, access_token, ADOBE_CLIENT_ID);
    
    return resultUrl;
    
  } catch (error) {
    throw new Error(`Adobe PDF conversion failed: ${error}`);
  }
}

// Helper functions
function markdownToHTML(markdown: string): string {
  let html = markdown;
  
  // Basic markdown conversion
  html = html.replace(/^# (.*$)/gim, '<h1 style="color: #2E86AB; border-bottom: 2px solid #2E86AB;">$1</h1>');
  html = html.replace(/^## (.*$)/gim, '<h2 style="color: #A23B72;">$1</h2>');
  html = html.replace(/^### (.*$)/gim, '<h3 style="color: #F18F01;">$1</h3>');
  html = html.replace(/\*\*(.*?)\*\*/gim, '<strong>$1</strong>');
  html = html.replace(/\*(.*?)\*/gim, '<em>$1</em>');
  html = html.replace(/\n/gim, '<br>');
  
  return `
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>ADPA Generated Document</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; line-height: 1.6; }
        h1 { color: #2E86AB; border-bottom: 2px solid #2E86AB; padding-bottom: 10px; }
        h2 { color: #A23B72; margin-top: 30px; }
        h3 { color: #F18F01; margin-top: 25px; }
    </style>
</head>
<body>
    <div style="text-align: center; margin-bottom: 40px;">
        <h1>ADPA Document</h1>
        <p><strong>Generated:</strong> ${new Date().toLocaleDateString()}</p>
        <p><strong>Powered by:</strong> Adobe.io + ADPA</p>
    </div>
    ${html}
</body>
</html>`;
}

async function uploadToAdobe(htmlContent: string, accessToken: string, clientId: string): Promise<any> {
  const blob = new Blob([htmlContent], { type: 'text/html' });
  const formData = new FormData();
  formData.append('file', blob, 'document.html');

  const response = await fetch('https://pdf-services.adobe.io/assets', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'x-api-key': clientId
    },
    body: formData
  });

  return await response.json();
}

async function createPDFJob(assetID: string, accessToken: string, clientId: string): Promise<any> {
  const response = await fetch('https://pdf-services.adobe.io/operation/createpdf', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`,
      'x-api-key': clientId,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      assetID: assetID,
      outputFormat: 'pdf'
    })
  });

  return await response.json();
}

async function pollForPDF(jobID: string, accessToken: string, clientId: string): Promise<string> {
  const maxAttempts = 30;
  let attempts = 0;

  while (attempts < maxAttempts) {
    const response = await fetch(`https://pdf-services.adobe.io/operation/${jobID}`, {
      method: 'GET',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'x-api-key': clientId
      }
    });

    const jobStatus = await response.json();

    if (jobStatus.status === 'done') {
      return jobStatus.downloadUri;
    } else if (jobStatus.status === 'failed') {
      throw new Error('PDF generation failed');
    }

    await new Promise(resolve => setTimeout(resolve, 5000)); // Wait 5 seconds
    attempts++;
  }

  throw new Error('PDF generation timed out');
}
```

## Step 4: Add the Button to Your Ribbon

Add this to your `manifest.xml`:

```xml
<Control xsi:type="Button" id="ConvertToAdobePDF">
  <Label resid="ConvertToAdobePDF.Label" />
  <Supertip>
    <Title resid="ConvertToAdobePDF.Label" />
    <Description resid="ConvertToAdobePDF.Tooltip" />
  </Supertip>
  <Icon>
    <bt:Image size="16" resid="Icon.16x16" />
    <bt:Image size="32" resid="Icon.32x32" />
    <bt:Image size="80" resid="Icon.80x80" />
  </Icon>
  <Action xsi:type="ExecuteFunction">
    <FunctionName>convertToAdobePDF</FunctionName>
  </Action>
</Control>
```

And add the labels to your resources section:

```xml
<bt:String id="ConvertToAdobePDF.Label" DefaultValue="Adobe PDF"/>
<bt:String id="ConvertToAdobePDF.Tooltip" DefaultValue="Convert document to professional PDF using Adobe.io"/>
```

## Step 5: Test It Right Now!

1. **Update your Adobe credentials** in the code above
2. **Build and run your ADPA add-in**: `npm run dev-server`
3. **Open Word**, load your add-in
4. **Click the "Adobe PDF" button**
5. **Watch your document convert to professional PDF!**

## What This Gets You Immediately

✅ **Direct Adobe.io integration** - No Azure costs  
✅ **Professional PDF generation** - PMBOK-style formatting  
✅ **Immediate testing** - Works with your existing Adobe.io access  
✅ **Proof of concept** - Demonstrate value to stakeholders  
✅ **Foundation for scaling** - Easy to add Azure orchestration later  

## Next Steps After This Works

1. **Test with real documents** from your `generated-documents` folder
2. **Add more Adobe services** (InDesign, Illustrator, Sign)
3. **Improve error handling** and user feedback
4. **Add batch processing** for multiple documents
5. **Plan Azure integration** when you get Partner Launch Benefits

## Why Start This Way?

- **Zero infrastructure costs** while developing
- **Immediate results** to show stakeholders
- **Validates Adobe.io integration** before investing in Azure
- **Builds confidence** in the technical approach
- **Creates working demo** for funding/partnership discussions

**Ready to start?** Just grab your Adobe.io credentials and add the code above to your existing `word.ts` file. You can have this working in 30 minutes!