Records Management

/**
 * Main operations class for CRM record management
 */
class RecordOperations {
    /**
     * Retrieve multiple records from a module
     * @param moduleAPIName - API name of the CRM module (e.g., "Leads", "Contacts", "Accounts")
     * @param paramInstance - Optional parameters for filtering and pagination
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing record data
     */
    getRecords(moduleAPIName: string, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Create new records in a module
     * @param moduleAPIName - API name of the CRM module
     * @param request - Body wrapper containing record data to create
     * @returns Promise with APIResponse containing creation results
     */
    createRecords(moduleAPIName: string, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Update existing records in a module
     * @param moduleAPIName - API name of the CRM module
     * @param request - Body wrapper containing record data to update
     * @returns Promise with APIResponse containing update results
     */
    updateRecords(moduleAPIName: string, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Delete multiple records from a module
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Parameters specifying records to delete
     * @returns Promise with APIResponse containing deletion results
     */
    deleteRecords(moduleAPIName: string, paramInstance: ParameterMap): Promise<APIResponse>;

    /**
     * Create or update records (upsert operation)
     * @param moduleAPIName - API name of the CRM module
     * @param request - Body wrapper containing record data for upsert
     * @returns Promise with APIResponse containing upsert results
     */
    upsertRecords(moduleAPIName: string, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Get a specific record by ID
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - Unique identifier of the record
     * @param paramInstance - Optional parameters for field selection
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing record data
     */
    getRecord(moduleAPIName: string, recordId: BigInt, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Update a specific record by ID
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - Unique identifier of the record
     * @param request - Body wrapper containing updated record data
     * @returns Promise with APIResponse containing update results
     */
    updateRecord(moduleAPIName: string, recordId: BigInt, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Delete a specific record by ID
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - Unique identifier of the record
     * @param paramInstance - Optional parameters for deletion
     * @returns Promise with APIResponse containing deletion results
     */
    deleteRecord(moduleAPIName: string, recordId: BigInt, paramInstance?: ParameterMap): Promise<APIResponse>;
}

const { RecordOperations } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/record_operations");
const { BodyWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/body_wrapper");
const { Record } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/record");

// Get records
const recordOperations = new RecordOperations();
const response = await recordOperations.getRecords("Leads");

// Create a new record
const record = new Record();
record.addFieldValue("Company", "Acme Corp");
record.addFieldValue("Last_Name", "Doe");
record.addFieldValue("First_Name", "John");
record.addFieldValue("Email", "john.doe@acme.com");

const bodyWrapper = new BodyWrapper();
bodyWrapper.setData([record]);

const createResponse = await recordOperations.createRecords("Leads", bodyWrapper);

// Update a record
record.setId("123456789012345678");
record.addFieldValue("Company", "Updated Company Name");

const updateResponse = await recordOperations.updateRecord("Leads", "123456789012345678", bodyWrapper);

// Delete a record
const deleteResponse = await recordOperations.deleteRecord("Leads", "123456789012345678");

/**
 * Extended record operations for advanced use cases
 */
class RecordOperations {
    /**
     * Get deleted records from a module
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Optional parameters for filtering deleted records
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing deleted record data
     */
    getDeletedRecords(moduleAPIName: string, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Search records using criteria
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Parameters containing search criteria
     * @returns Promise with APIResponse containing search results
     */
    searchRecords(moduleAPIName: string, paramInstance?: ParameterMap): Promise<APIResponse>;

    /**
     * Perform mass update operations on multiple records
     * @param moduleAPIName - API name of the CRM module
     * @param request - Body wrapper containing mass update specifications
     * @returns Promise with APIResponse containing mass update results
     */
    massUpdateRecords(moduleAPIName: string, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Get the status of a mass update operation
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Optional parameters for filtering mass update status
     * @returns Promise with APIResponse containing mass update status
     */
    getMassUpdateStatus(moduleAPIName: string, paramInstance?: ParameterMap): Promise<APIResponse>;

    /**
     * Get a record using external ID field
     * @param externalFieldValue - Value of the external field
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Optional parameters for field selection
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing record data
     */
    getRecordUsingExternalId(externalFieldValue: string, moduleAPIName: string, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Update a record using external ID field
     * @param externalFieldValue - Value of the external field
     * @param moduleAPIName - API name of the CRM module
     * @param request - Body wrapper containing updated record data
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing update results
     */
    updateRecordUsingExternalId(externalFieldValue: string, moduleAPIName: string, request: BodyWrapper, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Delete a record using external ID field
     * @param externalFieldValue - Value of the external field
     * @param moduleAPIName - API name of the CRM module
     * @param paramInstance - Optional parameters for deletion
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing deletion results
     */
    deleteRecordUsingExternalId(externalFieldValue: string, moduleAPIName: string, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;
}

const { GetRecordsParam, GetDeletedRecordsParam, SearchRecordsParam } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/record_operations");
const { ParameterMap } = require("@zohocrm/nodejs-sdk-2.0/routes/parameter_map");

// Search for records
const searchParams = new ParameterMap();
await searchParams.add(SearchRecordsParam.CRITERIA, "(Company:equals:Acme Corp)");
const searchResponse = await recordOperations.searchRecords("Leads", searchParams);

// Get deleted records
const deletedParams = new ParameterMap();
await deletedParams.add(GetDeletedRecordsParam.TYPE, "all");
const deletedResponse = await recordOperations.getDeletedRecords("Leads", deletedParams);

// Mass update records
const massUpdateWrapper = new BodyWrapper();
// Configure mass update data...
const massUpdateResponse = await recordOperations.massUpdateRecords("Leads", massUpdateWrapper);

/**
 * Lead conversion operations
 */
class RecordOperations {
    /**
     * Convert a lead to account, contact, and optionally a deal
     * @param leadId - ID of the lead to convert
     * @param request - Body wrapper containing conversion details
     * @returns Promise with APIResponse containing conversion results
     */
    convertLead(leadId: BigInt, request: BodyWrapper): Promise<APIResponse>;
}

const { ConvertBodyWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/convert_body_wrapper");
const { LeadConverter } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/lead_converter");

// Convert a lead
const converter = new LeadConverter();
converter.setOverwrite(true);
converter.setNotifyLeadOwner(true);
converter.setNotifyNewEntityOwner(true);

const convertWrapper = new ConvertBodyWrapper();
convertWrapper.setData([converter]);

const conversionResponse = await recordOperations.convertLead(123456789012345678n, convertWrapper);

/**
 * Photo management operations for records
 */
class RecordOperations {
    /**
     * Get photo associated with a record
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - ID of the record
     * @returns Promise with APIResponse containing photo file
     */
    getPhoto(moduleAPIName: string, recordId: BigInt): Promise<APIResponse>;

    /**
     * Upload photo for a record
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - ID of the record
     * @param request - File body wrapper containing photo data
     * @returns Promise with APIResponse containing upload results
     */
    uploadPhoto(moduleAPIName: string, recordId: BigInt, request: FileBodyWrapper): Promise<APIResponse>;

    /**
     * Delete photo associated with a record
     * @param moduleAPIName - API name of the CRM module
     * @param recordId - ID of the record
     * @returns Promise with APIResponse containing deletion results
     */
    deletePhoto(moduleAPIName: string, recordId: BigInt): Promise<APIResponse>;
}

const { FileBodyWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/record/file_body_wrapper");
const fs = require("fs");

// Upload photo
const fileStream = fs.createReadStream("path/to/photo.jpg");
const fileWrapper = new FileBodyWrapper();
fileWrapper.setFile(fileStream);

const uploadResponse = await recordOperations.uploadPhoto("Contacts", 123456789012345678n, fileWrapper);

// Get photo
const photoResponse = await recordOperations.getPhoto("Contacts", 123456789012345678n);

// Delete photo
const deletePhotoResponse = await recordOperations.deletePhoto("Contacts", 123456789012345678n);

/**
 * Operations for managing notes and comments on CRM records
 */
class NotesOperations {
    /**
     * Get all notes with optional filtering
     * @param paramInstance - Optional parameters for filtering and pagination
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing notes data
     */
    getNotes(paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Create new notes
     * @param request - Body wrapper containing note data to create
     * @returns Promise with APIResponse containing creation results
     */
    createNotes(request: BodyWrapper): Promise<APIResponse>;

    /**
     * Update existing notes
     * @param request - Body wrapper containing updated note data
     * @returns Promise with APIResponse containing update results
     */
    updateNotes(request: BodyWrapper): Promise<APIResponse>;

    /**
     * Delete multiple notes
     * @param paramInstance - Optional parameters specifying notes to delete
     * @returns Promise with APIResponse containing deletion results
     */
    deleteNotes(paramInstance?: ParameterMap): Promise<APIResponse>;

    /**
     * Get a specific note by ID
     * @param noteId - Unique identifier of the note
     * @param paramInstance - Optional parameters for field selection
     * @param headerInstance - Optional headers for request customization
     * @returns Promise with APIResponse containing note data
     */
    getNote(noteId: BigInt, paramInstance?: ParameterMap, headerInstance?: HeaderMap): Promise<APIResponse>;

    /**
     * Update a specific note by ID
     * @param noteId - Unique identifier of the note
     * @param request - Body wrapper containing updated note data
     * @returns Promise with APIResponse containing update results
     */
    updateNote(noteId: BigInt, request: BodyWrapper): Promise<APIResponse>;

    /**
     * Delete a specific note by ID
     * @param noteId - Unique identifier of the note
     * @returns Promise with APIResponse containing deletion results
     */
    deleteNote(noteId: BigInt): Promise<APIResponse>;
}

const { NotesOperations } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/notes/notes_operations");
const { BodyWrapper } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/notes/body_wrapper");
const { Note } = require("@zohocrm/nodejs-sdk-2.0/core/com/zoho/crm/api/notes/note");

const notesOp = new NotesOperations();

// Get all notes
const notesResponse = await notesOp.getNotes();

// Create a new note
const note = new Note();
note.setNoteTitle("Follow-up Required");
note.setNoteContent("Customer requested pricing information for enterprise plan");
note.setParentId({ id: "123456789012345678", name: "Leads" });

const bodyWrapper = new BodyWrapper();
bodyWrapper.setData([note]);

const createResponse = await notesOp.createNotes(bodyWrapper);

// Update a specific note
const updateNote = new Note();
updateNote.setId(987654321098765432n);
updateNote.setNoteContent("Updated: Customer confirmed interest in enterprise plan");

const updateWrapper = new BodyWrapper();
updateWrapper.setData([updateNote]);

const updateResponse = await notesOp.updateNote(987654321098765432n, updateWrapper);

// Delete a note
const deleteResponse = await notesOp.deleteNote(987654321098765432n);

/**
 * Represents a CRM record with field values and metadata
 */
class Record {
    /** Create a new record instance */
    constructor();

    /** Get record ID */
    getId(): string;
    /** Set record ID */
    setId(id: string): void;

    /** Get value of a specific field */
    getFieldValue(fieldName: string): any;
    /** Add or update a field value */
    addFieldValue(fieldName: string, value: any): void;
    /** Remove a field from the record */
    removeFieldValue(fieldName: string): void;

    /** Get all field values as key-value pairs */
    getKeyValues(): Map<string, any>;
    /** Set all field values */
    setKeyValues(keyValues: Map<string, any>): void;

    /** Get record creation time */
    getCreatedTime(): Date;
    /** Get record modification time */
    getModifiedTime(): Date;

    /** Get user who created the record */
    getCreatedBy(): User;
    /** Get user who last modified the record */
    getModifiedBy(): User;

    /** Get record owner */
    getOwner(): User;
    /** Set record owner */
    setOwner(owner: User): void;

    /** Get record tags */
    getTag(): Tag[];
    /** Set record tags */
    setTag(tags: Tag[]): void;
}

/**
 * Wrapper for record request bodies
 */
class BodyWrapper {
    /** Get record data */
    getData(): Record[];
    /** Set record data */
    setData(data: Record[]): void;

    /** Get duplicate check fields */
    getDuplicateCheckFields(): string[];
    /** Set duplicate check fields */
    setDuplicateCheckFields(fields: string[]): void;

    /** Get trigger workflow rules */
    getTrigger(): string[];
    /** Set trigger workflow rules */
    setTrigger(trigger: string[]): void;
}

/**
 * Wrapper for record responses (GET operations)
 */
class ResponseWrapper {
    /** Get record data from response */
    getData(): Record[];
    /** Get pagination info */
    getInfo(): Info;
}

/**
 * Wrapper for action responses (POST/PUT/DELETE operations)
 */
class ActionWrapper {
    /** Get action results */
    getData(): ActionResponse[];
}

/**
 * File wrapper for photo uploads
 */
class FileBodyWrapper {
    /** Set file stream for upload */
    setFile(file: any): void;
    /** Get file stream */
    getFile(): any;
}

/**
 * Parameters for getRecords operation
 */
class GetRecordsParam {
    static APPROVED: Param;          // Get approved/unapproved records
    static CONVERTED: Param;         // Get converted/unconverted leads
    static CVID: Param;             // Custom view ID
    static IDS: Param;              // Specific record IDs
    static FIELDS: Param;           // Fields to retrieve
    static SORT_BY: Param;          // Sort field
    static SORT_ORDER: Param;       // Sort order (asc/desc)
    static PAGE: Param;             // Page number
    static PER_PAGE: Param;         // Records per page
    static STARTDATETIME: Param;    // Start date for filtering
    static ENDDATETIME: Param;      // End date for filtering
    static TERRITORY_ID: Param;     // Territory filter
    static INCLUDE_CHILD: Param;    // Include child territories
}

/**
 * Headers for getRecords operation
 */
class GetRecordsHeader {
    static IF_MODIFIED_SINCE: Header; // Get records modified since date
    static X_EXTERNAL: Header;        // External system identifier
}

/**
 * Parameters for deleteRecords operation
 */
class DeleteRecordsParam {
    static IDS: Param;               // Record IDs to delete
    static WF_TRIGGER: Param;        // Trigger workflows
}

/**
 * Parameters for searchRecords operation
 */
class SearchRecordsParam {
    static CRITERIA: Param;          // Search criteria
    static EMAIL: Param;             // Email search
    static PHONE: Param;             // Phone search
    static WORD: Param;              // Keyword search
    static CONVERTED: Param;         // Converted status
    static APPROVED: Param;          // Approval status
    static PAGE: Param;              // Page number
    static PER_PAGE: Param;          // Records per page
}

const { ParameterMap } = require("@zohocrm/nodejs-sdk-2.0/routes/parameter_map");
const { HeaderMap } = require("@zohocrm/nodejs-sdk-2.0/routes/header_map");

// Setup parameters
const paramMap = new ParameterMap();
await paramMap.add(GetRecordsParam.FIELDS, "Company,Last_Name,First_Name,Email");
await paramMap.add(GetRecordsParam.PER_PAGE, 200);
await paramMap.add(GetRecordsParam.PAGE, 1);
await paramMap.add(GetRecordsParam.SORT_BY, "Modified_Time");
await paramMap.add(GetRecordsParam.SORT_ORDER, "desc");

// Setup headers
const headerMap = new HeaderMap();
await headerMap.add(GetRecordsHeader.IF_MODIFIED_SINCE, new Date("2023-01-01T00:00:00Z"));

// Use with operation
const response = await recordOperations.getRecords("Leads", paramMap, headerMap);