CSV Import APIs

import requests
import json
import time
 
BASE_URL = "https://chordian-core.chordian.ai"
 
# 1. Upload CSV
with open('companies.csv', 'rb') as file:
    files = {'file': file}
    response = requests.post(
        f"{BASE_URL}/api/lists/csv/upload",
        files=files
    )
    
    # Parse streaming response
    data = response.json()
    thread_id = data.get('thread_id')
    columns = data.get('columns', [])
 
# 2. Review and edit columns (user input)
edited_columns = [
    {
        "column_name": col['column_name'],
        "column_id": col.get('column_id'),
        "description": col['description']  # User can edit this
    }
    for col in columns
]
 
# 3. Continue import
review_response = requests.post(
    f"{BASE_URL}/api/lists/csv/review/{thread_id}",
    json={
        "listName": "My Custom List",
        "listDescription": "Description of my list",
        "category": "Sales",
        "column_descriptions": edited_columns
    }
)
list_id = review_response.json().get('list_id')
 
# 4. Monitor progress
def check_status():
    status_response = requests.get(
        f"{BASE_URL}/api/lists/csv/status/{thread_id}"
    )
    status = status_response.json()
    
    if status.get('status') == 'completed':
        print('Import complete!', status)
    elif status.get('status') == 'error':
        print('Import failed:', status.get('errors'))
    else:
        print(f"Progress: {status.get('progress', {}).get('percentage', 0)}%")
        time.sleep(2)
        check_status()  # Poll again
 
check_status()

const formData = new FormData();
formData.append('file', fileInput.files[0]);
 
const uploadResponse = await fetch(
  'https://chordian-core.chordian.ai/api/lists/csv/upload',
  {
    method: 'POST',
    body: formData
  }
);
 
// Handle streaming response
const reader = uploadResponse.body.getReader();
const decoder = new TextDecoder();
 
let threadId;
let columns = [];
 
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  
  const chunk = decoder.decode(value);
  const data = JSON.parse(chunk);
  
  if (data.status === 'ready_for_review') {
    threadId = data.thread_id;
    columns = data.columns;
    break;
  }
}
 
// 2. Review and edit columns
const editedColumns = columns.map(col => ({
  ...col,
  description: userEditedDescriptions[col.column_name] || col.description
}));
 
// 3. Continue import
const reviewResponse = await fetch(
  `https://chordian-core.chordian.ai/api/lists/csv/review/${threadId}`,
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      listName: 'My Custom List',
      listDescription: 'Description of my list',
      category: 'Sales',
      column_descriptions: editedColumns
    })
  }
);
 
const { list_id } = await reviewResponse.json();
 
// 4. Monitor progress
const checkStatus = async () => {
  const statusResponse = await fetch(
    `https://chordian-core.chordian.ai/api/lists/csv/status/${threadId}`
  );
  
  const status = await statusResponse.json();
  
  if (status.status === 'completed') {
    console.log('Import complete!', status);
  } else if (status.status === 'error') {
    console.error('Import failed:', status.errors);
  } else {
    console.log(`Progress: ${status.progress.percentage}%`);
    setTimeout(checkStatus, 2000); // Poll every 2 seconds
  }
};
 
checkStatus();

import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import java.io.File;
 
String BASE_URL = "https://chordian-core.chordian.ai";
CloseableHttpClient client = HttpClients.createDefault();
 
// 1. Upload CSV
HttpPost uploadRequest = new HttpPost(BASE_URL + "/api/lists/csv/upload");
 
MultipartEntityBuilder builder = MultipartEntityBuilder.create();
builder.addBinaryBody("file", new File("companies.csv"));
uploadRequest.setEntity(builder.build());
 
var uploadResponse = client.execute(uploadRequest);
String uploadBody = EntityUtils.toString(uploadResponse.getEntity());
JsonObject uploadData = JsonParser.parseString(uploadBody).getAsJsonObject();
 
String threadId = uploadData.get("thread_id").getAsString();
var columns = uploadData.getAsJsonArray("columns");
 
// 2. Review and edit columns (simplified)
// ... prepare edited columns JSON ...
 
// 3. Continue import
HttpPost reviewRequest = new HttpPost(
    BASE_URL + "/api/lists/csv/review/" + threadId
);
 
String reviewJson = "{\"listName\":\"My Custom List\"," +
                   "\"listDescription\":\"Description\"," +
                   "\"category\":\"Sales\"," +
                   "\"column_descriptions\":" + columns + "}";
 
reviewRequest.setEntity(new StringEntity(reviewJson));
reviewRequest.setHeader("Content-Type", "application/json");
 
var reviewResponse = client.execute(reviewRequest);
String reviewBody = EntityUtils.toString(reviewResponse.getEntity());
JsonObject reviewData = JsonParser.parseString(reviewBody).getAsJsonObject();
String listId = reviewData.get("list_id").getAsString();
 
// 4. Monitor progress
while (true) {
    HttpGet statusRequest = new HttpGet(
        BASE_URL + "/api/lists/csv/status/" + threadId
    );
    var statusResponse = client.execute(statusRequest);
    String statusBody = EntityUtils.toString(statusResponse.getEntity());
    JsonObject status = JsonParser.parseString(statusBody).getAsJsonObject();
    
    String statusValue = status.get("status").getAsString();
    
    if ("completed".equals(statusValue)) {
        System.out.println("Import complete!");
        break;
    } else if ("error".equals(statusValue)) {
        System.out.println("Import failed: " + status.get("errors"));
        break;
    } else {
        System.out.println("Progress: " + 
            status.getAsJsonObject("progress").get("percentage") + "%");
        Thread.sleep(2000);
    }
}

using System;
using System.IO;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
 
string baseUrl = "https://chordian-core.chordian.ai";
using var client = new HttpClient();
 
// 1. Upload CSV
using var content = new MultipartFormDataContent();
var fileContent = new ByteArrayContent(File.ReadAllBytes("companies.csv"));
content.Add(fileContent, "file", "companies.csv");
 
var uploadResponse = await client.PostAsync(
    $"{baseUrl}/api/lists/csv/upload",
    content
);
 
var uploadResult = await uploadResponse.Content.ReadAsStringAsync();
var uploadData = JObject.Parse(uploadResult);
 
var threadId = uploadData["thread_id"].ToString();
var columns = uploadData["columns"];
 
// 2. Review and edit columns
// ... user edits columns ...
 
// 3. Continue import
var reviewPayload = new
{
    listName = "My Custom List",
    listDescription = "Description of my list",
    category = "Sales",
    column_descriptions = columns
};
 
var reviewContent = new StringContent(
    JsonConvert.SerializeObject(reviewPayload),
    Encoding.UTF8,
    "application/json"
);
 
var reviewResponse = await client.PostAsync(
    $"{baseUrl}/api/lists/csv/review/{threadId}",
    reviewContent
);
 
var reviewResult = await reviewResponse.Content.ReadAsStringAsync();
var reviewData = JObject.Parse(reviewResult);
var listId = reviewData["list_id"].ToString();
 
// 4. Monitor progress
while (true)
{
    var statusResponse = await client.GetAsync(
        $"{baseUrl}/api/lists/csv/status/{threadId}"
    );
    
    var statusResult = await statusResponse.Content.ReadAsStringAsync();
    var status = JObject.Parse(statusResult);
    
    var statusValue = status["status"].ToString();
    
    if (statusValue == "completed")
    {
        Console.WriteLine("Import complete!");
        break;
    }
    else if (statusValue == "error")
    {
        Console.WriteLine($"Import failed: {status["errors"]}");
        break;
    }
    else
    {
        var percentage = status["progress"]["percentage"];
        Console.WriteLine($"Progress: {percentage}%");
        await Task.Delay(2000);
    }
}