Bulk Operations

/**
 * Operations for bulk data export from CRM modules
 */
class BulkReadOperations {
    /**
     * Create a bulk read job for data export
     * @param request - Request wrapper containing export specifications
     * @returns Promise with APIResponse containing job creation results
     */
    createBulkReadJob(request: RequestWrapper): Promise<APIResponse>;

    /**
     * Get details of a bulk read job including status and progress
     * @param jobId - Unique identifier of the bulk read job
     * @returns Promise with APIResponse containing job details
     */
    getBulkReadJobDetails(jobId: string): Promise<APIResponse>;

    /**
     * Download the result file of a completed bulk read job
     * @param jobId - Unique identifier of the bulk read job
     * @returns Promise with APIResponse containing file download
     */
    downloadResult(jobId: string): Promise<APIResponse>;
}

const { BulkReadOperations } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_read/bulk_read_operations");
const { RequestWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_read/request_wrapper");
const { CallBack } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_read/call_back");
const { Query } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_read/query");

// Create bulk read job
const bulkReadOperations = new BulkReadOperations();

// Configure callback URL for job completion notification
const callback = new CallBack();
callback.setUrl("https://your-app.com/webhook/bulk-read");
callback.setMethod("post");

// Configure query
const query = new Query();
query.setModule("Leads");
query.setCriteria("(Created_Time:greater_than:2023-01-01T00:00:00+00:00)");
query.setFields(["Company", "Last_Name", "First_Name", "Email", "Phone"]);

// Create request
const requestWrapper = new RequestWrapper();
requestWrapper.setCallback(callback);
requestWrapper.setQuery(query);

// Submit job
const createResponse = await bulkReadOperations.createBulkReadJob(requestWrapper);

if (createResponse != null) {
    const responseObject = createResponse.object;
    if (responseObject instanceof ActionWrapper) {
        const actionResponses = responseObject.getData();
        actionResponses.forEach(actionResponse => {
            if (actionResponse instanceof SuccessResponse) {
                const jobId = actionResponse.getDetails().get("id");
                console.log("Bulk Read Job ID: " + jobId);
            }
        });
    }
}

// Check job status
const jobDetailsResponse = await bulkReadOperations.getBulkReadJobDetails("job_id_here");

// Download results when job is complete
const downloadResponse = await bulkReadOperations.downloadResult("job_id_here");

/**
 * Operations for bulk data import into CRM modules
 */
class BulkWriteOperations {
    /**
     * Upload a file for bulk import
     * @param request - File body wrapper containing the file to upload
     * @returns Promise with APIResponse containing file upload results
     */
    uploadFile(request: FileBodyWrapper): Promise<APIResponse>;

    /**
     * Create a bulk write job for data import
     * @param request - Request wrapper containing import specifications
     * @returns Promise with APIResponse containing job creation results
     */
    createBulkWriteJob(request: RequestWrapper): Promise<APIResponse>;

    /**
     * Get details of a bulk write job including status and progress
     * @param jobId - Unique identifier of the bulk write job
     * @returns Promise with APIResponse containing job details
     */
    getBulkWriteJobDetails(jobId: string): Promise<APIResponse>;

    /**
     * Download the result file of a completed bulk write job
     * @param jobId - Unique identifier of the bulk write job
     * @returns Promise with APIResponse containing result file download
     */
    downloadBulkWriteResult(jobId: string): Promise<APIResponse>;
}

const { BulkWriteOperations } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_write/bulk_write_operations");
const { FileBodyWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_write/file_body_wrapper");
const { RequestWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_write/request_wrapper");
const { CallBack } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_write/call_back");
const { Resource } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/bulk_write/resource");
const fs = require("fs");

const bulkWriteOperations = new BulkWriteOperations();

// Step 1: Upload file
const fileStream = fs.createReadStream("path/to/leads_import.csv");
const fileWrapper = new FileBodyWrapper();
fileWrapper.setFile(fileStream);

const uploadResponse = await bulkWriteOperations.uploadFile(fileWrapper);
let fileId = null;

if (uploadResponse != null) {
    const responseObject = uploadResponse.object;
    if (responseObject instanceof ActionWrapper) {
        const actionResponses = responseObject.getData();
        actionResponses.forEach(actionResponse => {
            if (actionResponse instanceof SuccessResponse) {
                fileId = actionResponse.getDetails().get("file_id");
                console.log("File uploaded with ID: " + fileId);
            }
        });
    }
}

// Step 2: Create bulk write job
const callback = new CallBack();
callback.setUrl("https://your-app.com/webhook/bulk-write");
callback.setMethod("post");

const resource = new Resource();
resource.setType("data");
resource.setModule("Leads");
resource.setFileId(fileId);
resource.setIgnoreEmpty(true);
resource.setFindBy("Email"); // Unique field for upsert

// Configure field mappings
const fieldMappings = [
    { "api_name": "Company", "index": 0 },
    { "api_name": "Last_Name", "index": 1 },
    { "api_name": "First_Name", "index": 2 },
    { "api_name": "Email", "index": 3 },
    { "api_name": "Phone", "index": 4 }
];
resource.setFieldMappings(fieldMappings);

const requestWrapper = new RequestWrapper();
requestWrapper.setCharacterEncoding("UTF-8");
requestWrapper.setOperation("insert");
requestWrapper.setCallback(callback);
requestWrapper.setResource([resource]);

const createJobResponse = await bulkWriteOperations.createBulkWriteJob(requestWrapper);

// Step 3: Monitor job progress
const jobDetailsResponse = await bulkWriteOperations.getBulkWriteJobDetails("job_id_here");

// Step 4: Download results
const downloadResponse = await bulkWriteOperations.downloadBulkWriteResult("job_id_here");

/**
 * Request wrapper for bulk read operations
 */
class RequestWrapper {
    /** Get callback configuration */
    getCallback(): CallBack;
    /** Set callback configuration */
    setCallback(callback: CallBack): void;

    /** Get query configuration */
    getQuery(): Query;
    /** Set query configuration */
    setQuery(query: Query): void;

    /** Get file type for export */
    getFileType(): string;
    /** Set file type for export (csv, ics) */
    setFileType(fileType: string): void;
}

/**
 * Query configuration for bulk read
 */
class Query {
    /** Get module to export from */
    getModule(): string;
    /** Set module to export from */
    setModule(module: string): void;

    /** Get export criteria */
    getCriteria(): string;
    /** Set export criteria */
    setCriteria(criteria: string): void;

    /** Get fields to export */
    getFields(): string[];
    /** Set fields to export */
    setFields(fields: string[]): void;

    /** Get page number */
    getPage(): number;
    /** Set page number */
    setPage(page: number): void;

    /** Get custom view ID */
    getCvid(): string;
    /** Set custom view ID */
    setCvid(cvid: string): void;
}

/**
 * Callback configuration for job completion notification
 */
class CallBack {
    /** Get callback URL */
    getUrl(): string;
    /** Set callback URL */
    setUrl(url: string): void;

    /** Get HTTP method */
    getMethod(): string;
    /** Set HTTP method (post/put) */
    setMethod(method: string): void;
}

/**
 * Job details response
 */
class JobDetail {
    /** Get job ID */
    getId(): string;

    /** Get job operation */
    getOperation(): string;

    /** Get job state */
    getState(): string;

    /** Get query details */
    getQuery(): Query;

    /** Get job creation time */
    getCreatedTime(): Date;

    /** Get job completion time */
    getCompletedTime(): Date;

    /** Get created by user */
    getCreatedBy(): User;

    /** Get file type */
    getFileType(): string;

    /** Get result details */
    getResult(): Result;
}

/**
 * Request wrapper for bulk write operations
 */
class RequestWrapper {
    /** Get character encoding */
    getCharacterEncoding(): string;
    /** Set character encoding (UTF-8, ISO-8859-1, etc.) */
    setCharacterEncoding(characterEncoding: string): void;

    /** Get operation type */
    getOperation(): string;
    /** Set operation type (insert, update, upsert) */
    setOperation(operation: string): void;

    /** Get callback configuration */
    getCallback(): CallBack;
    /** Set callback configuration */
    setCallback(callback: CallBack): void;

    /** Get resource configuration */
    getResource(): Resource[];
    /** Set resource configuration */
    setResource(resource: Resource[]): void;
}

/**
 * Resource configuration for bulk write
 */
class Resource {
    /** Get resource type */
    getType(): string;
    /** Set resource type (data, template) */
    setType(type: string): void;

    /** Get module to import into */
    getModule(): string;
    /** Set module to import into */
    setModule(module: string): void;

    /** Get uploaded file ID */
    getFileId(): string;
    /** Set uploaded file ID */
    setFileId(fileId: string): void;

    /** Get ignore empty flag */
    getIgnoreEmpty(): boolean;
    /** Set ignore empty flag */
    setIgnoreEmpty(ignoreEmpty: boolean): void;

    /** Get field to find duplicates by */
    getFindBy(): string;
    /** Set field to find duplicates by (for upsert) */
    setFindBy(findBy: string): void;

    /** Get field mappings */
    getFieldMappings(): FieldMapping[];
    /** Set field mappings */
    setFieldMappings(fieldMappings: FieldMapping[]): void;
}

/**
 * Field mapping configuration
 */
class FieldMapping {
    /** Get API name of the field */
    getAPIName(): string;
    /** Set API name of the field */
    setAPIName(apiName: string): void;

    /** Get index in the file */
    getIndex(): number;
    /** Set index in the file */
    setIndex(index: number): void;

    /** Get format for date/time fields */
    getFormat(): string;
    /** Set format for date/time fields */
    setFormat(format: string): void;

    /** Get find by flag */
    getFindBy(): string;
    /** Set find by flag */
    setFindBy(findBy: string): void;

    /** Get default value */
    getDefaultValue(): any;
    /** Set default value */
    setDefaultValue(defaultValue: any): void;
}

/**
 * Bulk write result details
 */
class Result {
    /** Get download URL for results */
    getDownloadUrl(): string;

    /** Get record count */
    getCount(): number;
}

/**
 * Bulk operation job states
 */
class JobState {
    static ADDED: string = "ADDED";
    static IN_PROGRESS: string = "IN_PROGRESS";
    static COMPLETED: string = "COMPLETED";
    static FAILED: string = "FAILED";
    static PARTIALLY_COMPLETED: string = "PARTIALLY_COMPLETED";
}

/**
 * Bulk write operation types
 */
class OperationType {
    static INSERT: string = "insert";
    static UPDATE: string = "update";
    static UPSERT: string = "upsert";
}

/**
 * Supported file types for bulk operations
 */
class FileType {
    static CSV: string = "csv";
    static ICS: string = "ics"; // For calendar exports
    static ZIP: string = "zip"; // For results with attachments
}