Invite Users via the Wolfia API

curl -X POST https://api.wolfia.com/v1/organizations/invite \
  -H "X-API-Key: wolfia-api-YOUR_KEY_HERE" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "newuser@yourcompany.com",
    "name": "Jane Smith",
    "role": "USER"
  }'

{
  "message": "Invitation sent successfully to newuser@yourcompany.com"
}

import requests
from okta.client import Client as OktaClient
import os

WOLFIA_API_KEY = os.environ['WOLFIA_API_KEY']
OKTA_GROUP_ID = "00g1234567890abcdef"

async def sync_okta_group_to_wolfia():
    """
    Sync users from an Okta group to Wolfia.
    Run this as a scheduled job (e.g., daily cron).
    """
    okta_client = OktaClient()

    # Fetch all members from the Okta group
    group_members = await okta_client.list_group_users(OKTA_GROUP_ID)

    results = {
        'invited': [],
        'already_exists': [],
        'failed': []
    }

    for member in group_members:
        email = member.profile.email
        name = f"{member.profile.firstName} {member.profile.lastName}"

        try:
            response = requests.post(
                "https://api.wolfia.com/v1/organizations/invite",
                headers={
                    "X-API-Key": WOLFIA_API_KEY,
                    "Content-Type": "application/json"
                },
                json={
                    "email": email,
                    "name": name,
                    "role": "USER"
                },
                timeout=10
            )

            if response.status_code == 200:
                results['invited'].append(email)
                print(f"✓ Invited {email}")
            elif response.status_code == 409:
                results['already_exists'].append(email)
                print(f"→ {email} already in organization")
            else:
                results['failed'].append({
                    'email': email,
                    'status': response.status_code,
                    'error': response.text
                })
                print(f"✗ Failed to invite {email}: {response.text}")

        except Exception as e:
            results['failed'].append({
                'email': email,
                'error': str(e)
            })
            print(f"✗ Error inviting {email}: {str(e)}")

    # Summary
    print(f"\n📊 Summary:")
    print(f"   Invited: {len(results['invited'])}")
    print(f"   Already exists: {len(results['already_exists'])}")
    print(f"   Failed: {len(results['failed'])}")

    return results

# Run the sync
if __name__ == "__main__":
    import asyncio
    asyncio.run(sync_okta_group_to_wolfia())

const axios = require('axios');
const { Client } = require('@microsoft/microsoft-graph-client');

const WOLFIA_API_KEY = process.env.WOLFIA_API_KEY;
const AZURE_GROUP_ID = 'your-azure-group-id';

async function syncAzureGroupToWolfia() {
  // Initialize Microsoft Graph client
  const graphClient = Client.initWithMiddleware({
    authProvider: /* your auth provider */
  });

  // Get all members from the Azure AD group
  const response = await graphClient
    .api(`/groups/${AZURE_GROUP_ID}/members`)
    .get();

  const results = {
    invited: [],
    alreadyExists: [],
    failed: []
  };

  for (const member of response.value) {
    const email = member.mail || member.userPrincipalName;
    const name = member.displayName;

    try {
      const apiResponse = await axios.post(
        'https://api.wolfia.com/v1/organizations/invite',
        {
          email: email,
          name: name,
          role: 'USER'
        },
        {
          headers: {
            'X-API-Key': WOLFIA_API_KEY,
            'Content-Type': 'application/json'
          },
          timeout: 10000
        }
      );

      results.invited.push(email);
      console.log(`✓ Invited ${name}`);

    } catch (error) {
      if (error.response?.status === 409) {
        results.alreadyExists.push(email);
        console.log(`→ ${name} already exists`);
      } else {
        results.failed.push({
          email,
          error: error.message
        });
        console.error(`✗ Failed to invite ${name}:`, error.message);
      }
    }
  }

  // Print summary
  console.log('\n📊 Summary:');
  console.log(`   Invited: ${results.invited.length}`);
  console.log(`   Already exists: ${results.alreadyExists.length}`);
  console.log(`   Failed: ${results.failed.length}`);

  return results;
}

// Run the sync
syncAzureGroupToWolfia()
  .then(results => {
    console.log('\n✅ Sync completed');
    process.exit(0);
  })
  .catch(error => {
    console.error('❌ Sync failed:', error);
    process.exit(1);
  });

import requests
import csv
import os
from time import sleep

WOLFIA_API_KEY = os.environ['WOLFIA_API_KEY']
CSV_FILE_PATH = 'users_to_invite.csv'

def bulk_invite_from_csv(csv_path):
    """
    Bulk invite users from a CSV file.
    CSV format: email,name,role
    Example: jane.doe@company.com,Jane Doe,USER
    """
    results = {
        'invited': [],
        'already_exists': [],
        'failed': []
    }

    with open(csv_path, 'r') as csvfile:
        reader = csv.DictReader(csvfile)

        for row in reader:
            email = row['email'].strip()
            name = row['name'].strip()
            role = row.get('role', 'USER').strip().upper()

            # Validate role
            if role not in ['USER', 'EXPERT', 'ADMIN']:
                print(f"⚠️  Invalid role '{role}' for {email}, using USER instead")
                role = 'USER'

            try:
                response = requests.post(
                    'https://api.wolfia.com/v1/organizations/invite',
                    headers={
                        'X-API-Key': WOLFIA_API_KEY,
                        'Content-Type': 'application/json'
                    },
                    json={
                        'email': email,
                        'name': name,
                        'role': role
                    },
                    timeout=10
                )

                if response.status_code == 200:
                    results['invited'].append(email)
                    print(f"✓ Invited {name} ({email}) as {role}")
                elif response.status_code == 409:
                    results['already_exists'].append(email)
                    print(f"→ {email} already exists")
                else:
                    results['failed'].append({
                        'email': email,
                        'status': response.status_code,
                        'error': response.text
                    })
                    print(f"✗ Failed to invite {email}: {response.text}")

                # Rate limiting: be nice to the API
                sleep(0.1)

            except Exception as e:
                results['failed'].append({
                    'email': email,
                    'error': str(e)
                })
                print(f"✗ Error inviting {email}: {str(e)}")

    # Print summary
    print(f"\n📊 Summary:")
    print(f"   Total processed: {len(results['invited']) + len(results['already_exists']) + len(results['failed'])}")
    print(f"   ✓ Invited: {len(results['invited'])}")
    print(f"   → Already exists: {len(results['already_exists'])}")
    print(f"   ✗ Failed: {len(results['failed'])}")

    # Save failed invites for retry
    if results['failed']:
        with open('failed_invites.csv', 'w', newline='') as f:
            writer = csv.DictWriter(f, fieldnames=['email', 'error'])
            writer.writeheader()
            writer.writerows(results['failed'])
        print(f"\n💾 Failed invitations saved to failed_invites.csv")

    return results

if __name__ == '__main__':
    bulk_invite_from_csv(CSV_FILE_PATH)

email,name,role
jane.smith@company.com,Jane Smith,USER
john.doe@company.com,John Doe,EXPERT
admin@company.com,Sarah Admin,ADMIN

# Example: Map Okta roles to Wolfia roles
ROLE_MAPPING = {
    'Security Admin': 'ADMIN',
    'Security Team': 'EXPERT',
    'Engineering': 'USER',
    'Sales': 'USER'
}

okta_role = member.profile.customAttribute.get('department')
wolfia_role = ROLE_MAPPING.get(okta_role, 'USER')  # Default to USER

# Run daily at 2 AM
0 2 * * * /usr/bin/python3 /path/to/sync_users.py >> /var/log/wolfia_sync.log 2>&1