let page = 1;
// Get Shopify Products
async function getGorgiasTickets(nextPageToken, account, limit, maxPage, access_token, pinecone_index, pinecone_api_key, pinecone_namespace) {
logger.info('Getting Next Tokens');
if (page <= maxPage) {
const gorgiasRequestOptions = {
method: 'GET',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${access_token}`,
},
};
logger.info('access_token: ', access_token);
const response = await fetch(`https://${account}.gorgias.com/api/tickets?limit=5&cursor=${nextPageToken}`, gorgiasRequestOptions);
const tickets_data = await response.json();
const tickets = tickets_data.data;
var next_token = tickets_data.meta.next_cursor;
const documents = [];
for (const item of tickets) {
try {
const id = item.id || null;
const assignee_user = item.assignee_user || null;
const channel = item.channel || null;
const closed_datetime = item.closed_datetime || null;
const created_datetime = item.created_datetime || null;
const external_id = item.external_id || null;
const language = item.language || null;
const last_message_datetime = item.last_message_datetime || null;
const last_received_message_datetime = item.last_received_message_datetime || null;
const opened_datetime = item.opened_datetime || null;
const snooze_datetime = item.snooze_datetime || null;
const status = item.status || null;
const update_datetime = item.update_datetime || null;
const via = item.via || null;
const uri = item.uri || null;
const customer_id = item.customer.id || null;
const email = item.customer.email || null;
const name = item.customer.name || null;
const firstname = item.customer.firstname || null;
const lastname = item.customer.lastname || null;
const gorgiasMessagesRequestOptions = {
method: 'GET',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${access_token}`,
},
};
const messages_responses = await fetch(`https://${account}.gorgias.com/api/messages?ticket_id=${id}&limit=10`, gorgiasMessagesRequestOptions);
const messages_data = await messages_responses.json();
logger.info('messages_data: ', messages_data);
const messages = messages_data.data;
if (messages.length > 0) {
for (const message of messages) {
let body_text = message.body_text || null;
const max_length = 1000;
// Check if the body text exceeds the maximum length
if (body_text && body_text.length > max_length) {
// Shorten the text and assign it back to body_text
body_text = body_text.substring(0, max_length);
// Log the shortened text
logger.info("Shortened text:", body_text);
}
const message_id = message.id || null;
const channel = message.channel || null;
const created_datetime = message.created_datetime || null;
const from_agent = message.from_agent || null;
const receiver = message.receiver.name || null;
const sender = message.sender.name || null;
const subject = message.subject || null;
const ticket_id = message.ticket_id || null;
const via = message.via || null;
let metadata = {
id,
assignee_user,
channel,
closed_datetime,
created_datetime,
external_id,
language,
last_message_datetime,
last_received_message_datetime,
opened_datetime,
snooze_datetime,
status,
update_datetime,
via,
uri,
email,
customer_id,
name,
firstname,
lastname,
message_id,
body_text,
from_agent,
receiver,
sender,
subject,
ticket_id
};
const document = {
id: uuid(),
id,
metadata,
};
documents.push(document);
}
}
} catch (error) {
logger.info(`Error processing item: ${JSON.stringify(item)}`);
logger.info(error);
}
for (let i = 0; i < documents.length; i += DOCUMENT_UPSERT_BATCH_SIZE) {
// Split documents into batches
var batchDocuments = documents.slice(i, i + DOCUMENT_UPSERT_BATCH_SIZE);
logger.info(batchDocuments);
// Convert batchDocuments to string
var batchDocumentString = JSON.stringify(batchDocuments)
// Remove commas from string
logger.info(batchDocumentString);
// Create Embeddings
logger.info('Looping through documents...');
const user_id = process.env.STATESET_USER_ID;
// OpenAI Request Body
var raw = JSON.stringify({ "input": batchDocumentString, "model": "text-embedding-3-large", "user": user_id });
// OpenAI Request Options
var openaiRequestOptions = {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': ''
},
body: raw,
redirect: 'follow'
};
// Make Callout to OpenAI to get Embeddings
logger.info('Creating Embedding...');
// Make Callout to OpenAI
let embeddings_response = await fetch("https://api.openai.com/v1/embeddings", openaiRequestOptions)
// Create Pinecone Request Body
const vectors_embeddings = await embeddings_response.json();
logger.info(vectors_embeddings);
// Create Pinecone Request Body
var vectors_object = { id: uuid(), values: vectors_embeddings.data[0].embedding, metadata: { "text": batchDocumentString, "user": user_id } };
logger.info(vectors_object);
var raw = JSON.stringify({ "vectors": vectors_object, "namespace": pinecone_namespace });
var pineconeRequestOptions = {
method: "POST",
headers: {
"Content-Type": "application/json",
"Host": pinecone_index,
"Content-Length": 60,
"Api-Key": pinecone_api_key,
},
body: raw,
redirect: "follow",
};
// Make Callout to Pinecone
// Pinecone Upsert
logger.info('Upserting Pinecone...');
let pinecone_query_response = await fetch(`/vectors/upsert`, pineconeRequestOptions)
.then(response => response.text())
.then(json => {
logger.info(json);
})
.catch(error => {
logger.error(error);
});
}
}
page += 1;
logger.info(`On page ${page}, processing next page...`);
return getGorgiasTickets(next_token, account, limit, maxPage, access_token, pinecone_index, pinecone_api_key, pinecone_namespace);
} else {
return
}
};
