Author Archives: David Navarre

So, I was reading about an open position that I might be interested in and followed some links that lead to an article on AI in programming and wondered just how good it would be. So, I went ahead and asked ChatGPT to write an agent for me.

write an agent for use in HCL Notes that sends messages to users at intervals determined by a configuration document that identifies which documents to notify about using a querystring and whom to notify by a list on the configuration document. The configuration document should specify whether to send individual messages for each document or a list of documents.

I thought it couldn’t do half the job that I did. I figured I’d need to go through a bunch of refining iterations, explaining that I wanted a function to do this and another function to do that. Nope.

Sub Initialize
    Dim session As New NotesSession
    Dim db As NotesDatabase
    Set db = session.CurrentDatabase

    ' Retrieve configuration document
    Dim configDoc As NotesDocument
    Set configDoc = GetConfigDocument(db)

    If configDoc Is Nothing Then
        MsgBox "Configuration document not found!", 48, "Error"
        Exit Sub
    End If

    ' Read configuration values
    Dim queryString As String
    queryString = configDoc.QueryString(0)

    Dim usersToNotify As Variant
    usersToNotify = configDoc.UsersToNotify

    Dim notificationMethod As String
    notificationMethod = configDoc.NotificationMethod(0)

    Dim interval As Integer
    interval = configDoc.IntervalInHours(0)

    ' Find the documents to notify about based on query string
    Dim view As NotesView
    Set view = db.GetView("YourDocumentsView") ' Adjust view as needed
    Dim doc As NotesDocument
    Set doc = view.GetFirstDocument

    Dim docsToNotify As NotesDocumentCollection
    Set docsToNotify = New NotesDocumentCollection

    Do While Not (doc Is Nothing)
        If Evaluate(queryString, doc) Then
            docsToNotify.Add doc
        End If
        Set doc = view.GetNextDocument(doc)
    Loop

    ' Send notifications based on configuration
    Dim user As String
    ForAll user In usersToNotify
        If notificationMethod = "Individual" Then
            Call SendIndividualMessages(user, docsToNotify)
        ElseIf notificationMethod = "List" Then
            Call SendListMessage(user, docsToNotify)
        End If
    End ForAll

    ' Wait for the interval before running again (example of a timed agent)
    Call ScheduleNextRun(interval)

End Sub

' Function to retrieve configuration document
Function GetConfigDocument(db As NotesDatabase) As NotesDocument
    Dim configView As NotesView
    Set configView = db.GetView("ConfigView") ' Adjust view as needed
    Set GetConfigDocument = configView.GetFirstDocument
End Function

' Function to send individual messages
Sub SendIndividualMessages(user As String, docs As NotesDocumentCollection)
    Dim doc As NotesDocument
    Set doc = docs.GetFirstDocument

    While Not (doc Is Nothing)
        Dim mailDoc As NotesDocument
        Set mailDoc = db.CreateDocument
        mailDoc.Form = "Memo"
        mailDoc.Subject = "Document Notification"
        mailDoc.SendTo = user
        mailDoc.Body = "You have a document to review: " & doc.GetItemValue("Subject")(0)

        ' Send the mail
        Call mailDoc.Send(False)
        
        ' Move to next document
        Set doc = docs.GetNextDocument(doc)
    Wend
End Sub

' Function to send list of documents in one message
Sub SendListMessage(user As String, docs As NotesDocumentCollection)
    Dim doc As NotesDocument
    Set doc = docs.GetFirstDocument

    Dim bodyText As String
    bodyText = "You have the following documents to review:" & Chr(10)

    While Not (doc Is Nothing)
        bodyText = bodyText & doc.GetItemValue("Subject")(0) & Chr(10)
        Set doc = docs.GetNextDocument(doc)
    Wend

    Dim mailDoc As NotesDocument
    Set mailDoc = db.CreateDocument
    mailDoc.Form = "Memo"
    mailDoc.Subject = "Documents Notification"
    mailDoc.SendTo = user
    mailDoc.Body = bodyText

    ' Send the mail
    Call mailDoc.Send(False)
End Sub

' Function to schedule the next run of the agent
Sub ScheduleNextRun(interval As Integer)
    ' Schedule the agent to run again in 'interval' hours
    Dim agent As NotesAgent
    Set agent = session.CurrentDatabase.GetAgent("YourAgentName") ' Adjust agent name
    Call agent.Schedule(Interval:=interval)
End Sub

I’ve written one myself and I’m pretty proud of it. I talk about it often. Now, I talk about how my team created the same kind of functionality in MS Dynamics 365 and was working on doing a full stack version before we all got furloughed (USAID contract cuts). Nonetheless,, I think this version for Notes, which completed in the amount of time it took to scroll through the message, would have been a great start.

Some of the positions I’m looking at use TypeScript in the tech stack, and I know TypeScript is still a Javascript-based language. So, I decided to ask it to do the same in TypeScript. Notes is integrated with email, so some of the extra coding in TypeScript wasn’t necessary in LotusScript.

import nodemailer from 'nodemailer';
import axios from 'axios';
import { CronJob } from 'cron';

// Interface for Configuration Document
interface ConfigDocument {
  queryString: string;
  usersToNotify: string[];
  notificationMethod: 'Individual' | 'List';
  intervalInHours: number;
}

// Function to fetch configuration document from an API or database
async function getConfigDocument(): Promise<ConfigDocument> {
  try {
    const response = await axios.get('http://your-api-url/config');
    return response.data;
  } catch (error) {
    console.error('Error fetching configuration document:', error);
    throw new Error('Failed to fetch config document');
  }
}

// Function to send email
async function sendEmail(to: string, subject: string, body: string): Promise<void> {
  // Create a transporter using your email service
  let transporter = nodemailer.createTransport({
    service: 'gmail', // Example service
    auth: {
      user: 'your-email@gmail.com', // Replace with your email
      pass: 'your-email-password',  // Replace with your email password
    },
  });

  // Set up email data
  let mailOptions = {
    from: 'your-email@gmail.com',
    to: to,
    subject: subject,
    text: body,
  };

  try {
    await transporter.sendMail(mailOptions);
    console.log('Email sent successfully to', to);
  } catch (error) {
    console.error('Error sending email:', error);
  }
}

// Function to get documents from the Notes database based on query string
async function fetchDocuments(query: string): Promise<any[]> {
  try {
    // Assuming there is an API endpoint to fetch documents based on a query
    const response = await axios.get(`http://your-api-url/documents?query=${encodeURIComponent(query)}`);
    return response.data;
  } catch (error) {
    console.error('Error fetching documents:', error);
    throw new Error('Failed to fetch documents');
  }
}

// Function to send individual messages for each document
async function sendIndividualMessages(users: string[], documents: any[]): Promise<void> {
  for (const user of users) {
    for (const doc of documents) {
      const subject = `Document Notification: ${doc.title}`;
      const body = `Hello, you have a document to review: ${doc.title}\n\nDetails: ${doc.details}`;
      await sendEmail(user, subject, body);
    }
  }
}

// Function to send a list of documents in one email
async function sendListMessage(users: string[], documents: any[]): Promise<void> {
  const documentList = documents.map((doc) => `- ${doc.title}`).join('\n');
  const body = `Hello, you have the following documents to review:\n\n${documentList}`;

  for (const user of users) {
    const subject = 'Documents Notification';
    await sendEmail(user, subject, body);
  }
}

// Function to run the agent logic
async function runAgent() {
  try {
    const config = await getConfigDocument();

    // Fetch documents based on the query string from the configuration
    const documents = await fetchDocuments(config.queryString);

    // Send notifications based on the method defined in the config
    if (config.notificationMethod === 'Individual') {
      await sendIndividualMessages(config.usersToNotify, documents);
    } else {
      await sendListMessage(config.usersToNotify, documents);
    }
  } catch (error) {
    console.error('Error during agent run:', error);
  }
}

// Scheduling the agent to run at a defined interval (in hours)
async function scheduleAgent() {
  const config = await getConfigDocument();

  // Using Cron to schedule the agent run based on the interval (in hours)
  const cronExpression = `0 0 */${config.intervalInHours} * * *`; // Run at interval in hours
  new CronJob(cronExpression, runAgent, null, true, 'America/New_York'); // Adjust timezone as needed

  console.log(`Agent scheduled to run every ${config.intervalInHours} hours`);
}

// Start the scheduling
scheduleAgent().catch((error) => console.error('Error scheduling agent:', error));

Why not get more afield and have it do the full stack concept version for me. This one is in C#

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Mail;
using System.Net.Http;
using System.Threading.Tasks;
using Quartz;
using Quartz.Impl;

class Program
{
    // Configuration Document class
    public class ConfigDocument
    {
        public string QueryString { get; set; }
        public List<string> UsersToNotify { get; set; }
        public string NotificationMethod { get; set; } // "Individual" or "List"
        public int IntervalInHours { get; set; }
    }

    // Document class that represents a document in the Notes database
    public class Document
    {
        public string Title { get; set; }
        public string Details { get; set; }
    }

    // Function to fetch configuration from an API or database
    static async Task<ConfigDocument> GetConfigDocumentAsync()
    {
        // Replace with actual logic to fetch the configuration
        // For demonstration, we're using hardcoded values
        return new ConfigDocument
        {
            QueryString = "SELECT * FROM Documents WHERE status = 'pending'",
            UsersToNotify = new List<string> { "user1@example.com", "user2@example.com" },
            NotificationMethod = "Individual",
            IntervalInHours = 1
        };
    }

    // Function to fetch documents based on the query string
    static async Task<List<Document>> FetchDocumentsAsync(string query)
    {
        // Replace with actual logic to query the HCL Notes database or API
        // Simulating fetching documents
        return new List<Document>
        {
            new Document { Title = "Document 1", Details = "Details of Document 1" },
            new Document { Title = "Document 2", Details = "Details of Document 2" }
        };
    }

    // Function to send an email
    static async Task SendEmailAsync(string to, string subject, string body)
    {
        var smtpClient = new SmtpClient("smtp.gmail.com")
        {
            Port = 587,
            Credentials = new NetworkCredential("your-email@gmail.com", "your-email-password"),
            EnableSsl = true,
        };

        var message = new MailMessage
        {
            From = new MailAddress("your-email@gmail.com"),
            Subject = subject,
            Body = body,
            IsBodyHtml = false,
        };

        message.To.Add(to);

        await smtpClient.SendMailAsync(message);
    }

    // Function to send individual messages
    static async Task SendIndividualMessagesAsync(List<string> users, List<Document> documents)
    {
        foreach (var user in users)
        {
            foreach (var doc in documents)
            {
                var subject = $"Document Notification: {doc.Title}";
                var body = $"Hello, you have a document to review:\n\n{doc.Title}\n\nDetails: {doc.Details}";

                await SendEmailAsync(user, subject, body);
            }
        }
    }

    // Function to send a list of documents in a single email
    static async Task SendListMessageAsync(List<string> users, List<Document> documents)
    {
        var documentList = string.Join("\n", documents.ConvertAll(doc => $"- {doc.Title}"));
        var body = $"Hello, you have the following documents to review:\n\n{documentList}";

        foreach (var user in users)
        {
            var subject = "Documents Notification";
            await SendEmailAsync(user, subject, body);
        }
    }

    // Main Agent Logic
    static async Task RunAgentAsync()
    {
        try
        {
            var config = await GetConfigDocumentAsync();
            var documents = await FetchDocumentsAsync(config.QueryString);

            // Send notifications based on the method specified in the config
            if (config.NotificationMethod == "Individual")
            {
                await SendIndividualMessagesAsync(config.UsersToNotify, documents);
            }
            else if (config.NotificationMethod == "List")
            {
                await SendListMessageAsync(config.UsersToNotify, documents);
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error during agent run: {ex.Message}");
        }
    }

    // Scheduling the agent to run at the specified interval (in hours)
    static async Task ScheduleAgentAsync()
    {
        var config = await GetConfigDocumentAsync();

        var scheduler = await StdSchedulerFactory.GetDefaultScheduler();
        await scheduler.Start();

        // Schedule the job with Quartz.NET to run at the specified interval
        var job = JobBuilder.Create<Job>()
            .WithIdentity("DocumentNotificationJob")
            .Build();

        var trigger = TriggerBuilder.Create()
            .WithIdentity("DocumentNotificationTrigger")
            .StartNow()
            .WithSimpleSchedule(x => x.WithIntervalInHours(config.IntervalInHours).RepeatForever())
            .Build();

        await scheduler.ScheduleJob(job, trigger);

        Console.WriteLine($"Agent scheduled to run every {config.IntervalInHours} hours");
    }

    // Quartz job that triggers the agent run
    public class Job : IJob
    {
        public Task Execute(IJobExecutionContext context)
        {
            return RunAgentAsync();
        }
    }

    // Main Entry Point
    static async Task Main(string[] args)
    {
        await ScheduleAgentAsync();

        // Keep the application running
        Console.WriteLine("Press any key to exit...");
        Console.ReadKey();
    }
}

Now, in each case, the code needs to be refined and enhanced. I imagine that could just be done with more specific descriptions of what’s needed, but dang, this AI stuff is powerful. I suspect that if I give ChatGPT some of my code and ask it to port it to another tech stack, it’s going to save me loads of time. I can focus on design patterns and on getting interfaces right, leaving the grunt work to the AI. These are indeed exciting times.