This code defines a function bulkUploadEloqua that securely authenticates with Eloqua, handles import definition setup, and then uploads account data in bulk to Eloqua. It's likely designed to be used within a Lambda function for serverless execution.

Run example

npm run import -- "bulk upload eloqua"

bulk upload eloqua

var assert = require('assert');
var importer = require('../Core');
var eloquaImport = importer.import("eloqua import service");
var eloquaObjects = importer.import("eloqua existing import");

module.exports = {
    bulkUploadEloqua,
};

function bulkUploadEloqua(accounts, eloquaConfig, instanceId, executionId) {
    var eloquaToken, importUri;
    return eloquaImport.eloquaOauth(eloquaConfig)
        .then(token => {
            eloquaToken = token;
            assert(token.expires > (new Date()).getTime());
            if(instanceId) {
                return eloquaImport.createInstanceDefinition(instanceId, executionId, eloquaToken, eloquaConfig)
            } else {
                // get custom data object ID from API
                var existingId;
                return eloquaObjects.getCustomDataObject(eloquaToken, eloquaConfig)
                    .then(existing => {
                        if(!existing) {
                            throw new Error('Eloqua custom data object not configured.')
                        }
                        existingId = existing.uri.split('/').pop();
                        return eloquaObjects.getImportDefinitions(existing.uri, eloquaToken, eloquaConfig);
                    })
                    .then(importDef => importDef
                          ? importDef.uri
                          : eloquaImport.createImportDefinition(existingId, eloquaToken, eloquaConfig))
            }
        })
        .then(r => {
            importUri = r;
            return eloquaImport.startBulkImportData(accounts, importUri, eloquaToken, eloquaConfig);
        })
        .then(() => eloquaImport.completeBulkImportSync(importUri, eloquaToken, eloquaConfig))
        .then(() => accounts)
}

if(typeof $ !== 'undefined') {
    $.async();
    bulkUploadEloqua()
        .then(r => $.sendResult(r))
        .catch(e => $.sendError(e))
}

const assert = require('assert');
const importer = require('../Core');

const { EloquaImportService, EloquaExistingImport } = importer;

const bulkUploadEloqua = async (accounts, eloquaConfig, instanceId, executionId) => {
    const { EloquaOAuthService } = EloquaImportService;
    const eloquaOAuthService = new EloquaOAuthService(eloquaConfig);

    try {
        const eloquaToken = await eloquaOAuthService.getEloquaToken();
        assert(token.expires > Date.now());

        if (instanceId) {
            const { InstanceDefinitionService } = EloquaImportService;
            const instanceDefinitionService = new InstanceDefinitionService(eloquaToken, eloquaConfig);
            return await instanceDefinitionService.createInstanceDefinition(instanceId, executionId);
        } else {
            const { CustomDataObjectService } = EloquaExistingImport;
            const customDataObjectService = new CustomDataObjectService(eloquaToken, eloquaConfig);

            const existing = await customDataObjectService.getCustomDataObject();
            if (!existing) {
                throw new Error('Eloqua custom data object not configured.');
            }

            const { ImportDefinitionService } = EloquaImportService;
            const importDefinitionService = new ImportDefinitionService(eloquaToken, eloquaConfig);
            const importUri = await importDefinitionService.getImportDefinition(existing.uri);
            if (!importUri) {
                return await importDefinitionService.createImportDefinition(existing.uri);
            }
        }

        const { BulkImportDataService } = EloquaImportService;
        const bulkImportDataService = new BulkImportDataService(eloquaToken, eloquaConfig);
        await bulkImportDataService.startBulkImportData(accounts, importUri);

        await bulkImportDataService.completeBulkImportSync(importUri);
        return accounts;
    } catch (error) {
        throw error;
    }
}

module.exports = bulkUploadEloqua;
```

```javascript
if (typeof $!== 'undefined') {
    $.async();
    bulkUploadEloqua()
       .then(r => $.sendResult(r))
       .catch(e => $.sendError(e));
}

This code defines a function bulkUploadEloqua that handles the bulk upload of account data to Eloqua.

Here's a breakdown:

1. Initialization:

   • It imports necessary modules for Eloqua interaction and assertion testing.
   • It defines the bulkUploadEloqua function, which takes account data, Eloqua configuration, instance ID (optional), and execution ID (optional) as input.

2. Eloqua Authentication:

   • It first obtains an Eloqua access token using eloquaOauth.
   • It asserts that the token is valid (expires in the future).

3. Import Definition Handling:

   • If an instance ID is provided, it creates an instance definition in Eloqua.
   • Otherwise, it retrieves an existing custom data object ID and either uses an existing import definition or creates a new one.

4. Bulk Import Process:

   • It starts a bulk import using the obtained import URI, Eloqua token, and account data.
   • It then synchronously completes the import process.

5. Result Handling:

   • Finally, it returns the uploaded account data.

6. Lambda Function Integration:

   • The code includes a conditional block that suggests it's intended for use within a Lambda function, handling asynchronous execution and result/error sending.