Merge pull request #41 from efdevcon/improve-destino

Improve Destino events

Author: didierkrux

devcon-api/package.json

@@ -1,13 +1,13 @@
 {
   "name": "devcon-api",
-  "description": "Devcon API exposes information about Devcon, past events, schedules and our video archive. You can find more information at https://github.com/efdevcon/api",
+  "description": "Devcon API exposes information about Devcon, past events, schedules and our video archive. You can find more information at https://github.com/efdevcon/monorepo/tree/main/devcon-api",
   "homepage": "https://api.devcon.org",
   "author": "support@devcon.org",
   "version": "0.6.2",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/efdevcon/api"
+    "url": "https://github.com/efdevcon/monorepo/tree/main/devcon-api"
   },
   "scripts": {
     "build": "tsc --project tsconfig.json && tsc-alias -p tsconfig.json",

devcon-api/src/controllers/destino.ts

@@ -1,5 +1,6 @@
 import { Request, Response, Router } from 'express'
 import { destinoApi } from '../services/ai/open-ai/open-ai'
+import { apikeyHandler } from '@/middleware/apikey'
 
 export const destinoRouter = Router()
 
@@ -14,7 +15,10 @@ const generateDestinoEvents = async () => {
 destinoRouter.get('/destino', async (req: Request, res: Response) => {
   const eventsList = await destinoApi.getAllDestinoEvents()
 
-  res.json(eventsList)
+  // filter out events that don't have a date
+  const eventsListWithDate = eventsList.filter((event) => event.date)
+
+  res.json(eventsListWithDate)
 })
 
 destinoRouter.get('/destino/:event', async (req: Request, res: Response) => {
@@ -25,6 +29,52 @@ destinoRouter.get('/destino/:event', async (req: Request, res: Response) => {
   res.json(eventData)
 })
 
+destinoRouter.get('/regenerate/:eventId', apikeyHandler, async (req: Request, res: Response) => {
+  // Private route: requires apiKey
+  // #swagger.ignore = true
+  const { eventId } = req.params
+
+  const eventData = await destinoApi.getDestinoEvent(eventId)
+
+  if (!eventData) {
+    return res.status(404).json({ error: 'Event not found' })
+  }
+
+  try {
+    console.log('[regenerate-destino-event] Starting event regeneration')
+
+    console.log('[regenerate-destino-event] Event data:', eventData)
+
+    // Format the event data to match the expected structure
+    const formattedEvent = {
+      Id: eventData.event_id,
+      Name: eventData.name,
+      Location: eventData.location,
+      Date: { startDate: eventData.date },
+      Type: eventData.type_of_event,
+      Twitter: eventData.twitter_handle,
+      Link: eventData.link,
+      TargetAudience: eventData.target_audience,
+      Details: eventData.details,
+      LastModifiedDate: eventData.last_modified_at,
+    }
+
+    const updatedEventData = await destinoApi.generateDestinoEvent(formattedEvent, true)
+
+    console.log('[regenerate-destino-event] Generated event result: OK', updatedEventData)
+
+    if (!updatedEventData) {
+      console.error('[regenerate-destino-event] No event data returned from generateDestinoEvent')
+      return res.status(500).json({ error: 'Failed to generate event' })
+    }
+
+    res.json(updatedEventData)
+  } catch (error: any) {
+    console.error('[regenerate-destino-event] Error generating event:', error)
+    res.status(500).json({ error: 'Internal server error', details: error.message })
+  }
+})
+
 generateDestinoEvents()
 
 // Refresh events every hour

devcon-api/src/services/ai/open-ai/image-generation/destino.png

@@ -517,6 +517,15 @@ export const destinoApi = (() => {
     }
     updated_at: string
     last_modified_at: string
+    name: string
+    location: string
+    date: string
+    type_of_event: string
+    twitter_handle: string
+    link: string
+    target_audience: string
+    details: string
+    image_url?: string
   }
 
   // Initialize Supabase client once to reuse across functions
@@ -535,128 +544,172 @@ export const destinoApi = (() => {
 
       return data as EventRecord | null
     },
-    generateDestinoEvent: async (event: any) => {
-      const eventRecord = await _interface.getDestinoEvent(event.Id)
-      const eventExists = !!eventRecord
-
-      // If exists and updated after last modification, return cached content
-      if (eventRecord) {
-        // console.log('record found')
-        // console.log('updated_at:', eventRecord.updated_at)
-        // console.log('LastModifiedDate:', event.LastModifiedDate)
-        // console.log('updated_at date:', new Date(eventRecord.updated_at))
-        // console.log('LastModifiedDate date:', new Date(event.LastModifiedDate))
-        // console.log('comparison result:', new Date(eventRecord.updated_at) > new Date(event.LastModifiedDate))
-
-        if (new Date(eventRecord.updated_at) > new Date(event.LastModifiedDate)) {
+    generateDestinoEvent: async (event: any, forceImageGeneration = false) => {
+      try {
+        console.log(`[generateDestinoEvent] Starting for event ${event.Id}${forceImageGeneration ? ' (force image generation)' : ''}`)
+
+        if (!event || !event.Id) {
+          console.error('[generateDestinoEvent] Invalid event data:', event)
+          throw new Error('Invalid event data')
+        }
+
+        const eventRecord = await _interface.getDestinoEvent(event.Id)
+        const eventExists = !!eventRecord
+        console.log(`[generateDestinoEvent] Event exists in database: ${eventExists}`)
+
+        // If exists and updated after last modification, return cached content
+        if (!forceImageGeneration && eventRecord && new Date(eventRecord.updated_at) > new Date(event.LastModifiedDate)) {
           return eventRecord.content
         }
-      }
 
-      // Otherwise generate new content
-      console.log(`Generating new content for Destino event ${event.Id}`)
-
-      const upsert = {
-        event_id: event.Id,
-        twitter_handle: event.Twitter,
-        type_of_event: event['Type of Event'],
-        location: event.Location,
-        link: event.Link,
-        name: event.Name,
-        date: event.Date.startDate,
-        target_audience: event.TargetAudience,
-        details: event.Details,
-        updated_at: new Date().toISOString(),
-        last_modified_at: event.LastModifiedDate,
-      } as any
-
-      if (!eventExists) {
-        const eventCompletion = await openai.beta.chat.completions.parse({
-          temperature: 0,
-          model: 'gpt-4.1',
-          messages: [
-            {
-              role: 'system',
-              content:
-                'You take an event object and generate a simple summary of it in English, Spanish and Portuguese. Max 500 characters. It will be used to advertise the event.',
-            },
-            { role: 'user', content: JSON.stringify({ ...event, description: '' }) },
-          ],
-          response_format: zodResponseFormat(EventSchema, 'summary'),
-        })
+        // Otherwise generate new content
+        console.log(`[generateDestinoEvent] Generating new content for event ${event.Id}`)
+
+        const upsert = {
+          event_id: event.Id,
+          twitter_handle: event.Twitter,
+          type_of_event: event['Type of Event'],
+          location: event.Location,
+          link: event.Link,
+          name: event.Name,
+          date: event.Date.startDate,
+          target_audience: event.TargetAudience,
+          details: event.Details,
+          updated_at: new Date().toISOString(),
+          last_modified_at: event.LastModifiedDate,
+        } as any
+
+        if (!eventExists || forceImageGeneration) {
+          console.log(`[generateDestinoEvent] Generating multilingual content for event ${event.Id}`)
+          const eventCompletion = await openai.beta.chat.completions.parse({
+            temperature: 0,
+            model: 'gpt-4.1',
+            messages: [
+              {
+                role: 'system',
+                content:
+                  'You take an event object and generate a simple summary of it in English, Spanish and Portuguese. Max 500 characters. It will be used to advertise the event.',
+              },
+              { role: 'user', content: JSON.stringify({ ...event, description: '' }) },
+            ],
+            response_format: zodResponseFormat(EventSchema, 'summary'),
+          })
 
-        const content = eventCompletion.choices[0].message.parsed as { en: string; es: string; pt: string }
+          if (!eventCompletion.choices?.[0]?.message?.parsed) {
+            console.error('[generateDestinoEvent] Failed to generate content:', eventCompletion)
+            throw new Error('Failed to generate content')
+          }
 
-        const prompt = `
-          Adjust the reference image to match the event. Don't use any text in the generated image.
-          
-          Event name: ${event.Name}
-          Event location: ${event.Location}
-          Event summary: ${content.en}
-        `
+          // Fetch reference image from Supabase Storage
+          const { data: imageData, error: imageError } = await supabase.storage.from('destino-events').download('reference/destino.png')
 
-        // Fetch reference image from Supabase Storage
-        const { data: imageData, error: imageError } = await supabase.storage.from('destino-events').download('reference/destino.png')
+          if (imageError) {
+            console.error('Error fetching reference image:', imageError)
+            throw new Error('Failed to fetch reference image')
+          }
 
-        if (imageError) {
-          console.error('Error fetching reference image:', imageError)
-          throw new Error('Failed to fetch reference image')
-        }
+          const openAICompatibleImage = await toFile(imageData, null, { type: 'image/png' })
 
-        const openAICompatibleImage = await toFile(imageData, null, { type: 'image/png' })
+          const content = eventCompletion.choices[0].message.parsed as { en: string; es: string; pt: string }
+          console.log(`[generateDestinoEvent] Generated content for event ${event.Id}:`, {
+            en: content.en.substring(0, 50) + '...',
+            es: content.es.substring(0, 50) + '...',
+            pt: content.pt.substring(0, 50) + '...',
+          })
 
-        const resultImage = await openai.images.edit({
-          model: 'gpt-image-1',
-          prompt,
-          image: openAICompatibleImage,
-          // @ts-ignore
-          size: '1536x1024',
-          n: 1,
-        })
+          const prompt = `Adjust the reference image to suit the context of the event.
+DO NOT add or include any text in the generated image.
+Keep composition of the reference image.
+
+Context:
+- Event name: "${event.Name}"
+- Event location: "${event.Location}"
+DO NOT include Event name or event location in the generated image.`
+          console.log(`[generateDestinoEvent] Generating image for event ${event.Id} with prompt:`, prompt)
+
+          const resultImage = await openai.images.edit({
+            model: 'gpt-image-1',
+            prompt,
+            image: openAICompatibleImage,
+            // @ts-ignore
+            size: '1536x1024',
+            n: 1,
+          })
 
-        // Save the image to a file
-        const image_base64 = resultImage.data?.[0]?.b64_json
-        const image_bytes = image_base64 ? Buffer.from(image_base64, 'base64') : null
+          if (!resultImage.data?.[0]?.b64_json) {
+            console.error('[generateDestinoEvent] Failed to generate image:', resultImage)
+            throw new Error('Failed to generate image')
+          }
 
-        let imageUrl = null
+          // Save the image to a file
+          const image_base64 = resultImage.data[0].b64_json
+          const image_bytes = Buffer.from(image_base64, 'base64')
+          console.log(`[generateDestinoEvent] Image generated for event ${event.Id}: ${image_bytes ? 'success' : 'failed'}`)
 
-        if (image_bytes) {
-          // Twitter resize
-          const resizedImage = await sharp(image_bytes).resize(1200, 675, { fit: 'cover' }).toBuffer()
+          let imageUrl = null
 
-          // Upload to Supabase Storage
-          const { data: uploadData1, error: uploadError1 } = await supabase.storage
-            .from('destino-events')
-            .upload(`${event.Id}-twitter.png`, resizedImage, {
+          if (image_bytes) {
+            console.log(`[generateDestinoEvent] Processing and uploading images for event ${event.Id}`)
+            // Social media resize
+            const resizedImage = await sharp(image_bytes).resize(1200, 628, { fit: 'cover' }).jpeg({ quality: 90 }).toBuffer()
+
+            // Generate timestamp for versioning
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+            const socialImagePath = `${event.Id}-social-${timestamp}.jpg`
+            const originalImagePath = `${event.Id}-original-${timestamp}.png`
+
+            // Upload to Supabase Storage
+            const { data: uploadData1, error: uploadError1 } = await supabase.storage.from('destino-events').upload(socialImagePath, resizedImage, {
+              contentType: 'image/jpeg',
+              upsert: true,
+            })
+
+            const { data: uploadData2, error: uploadError2 } = await supabase.storage.from('destino-events').upload(originalImagePath, image_bytes, {
               contentType: 'image/png',
               upsert: true,
             })
 
-          const { data: uploadData2, error: uploadError2 } = await supabase.storage.from('destino-events').upload(`${event.Id}.png`, image_bytes, {
-            contentType: 'image/png',
-            upsert: true,
-          })
+            if (uploadError1 || uploadError2) {
+              console.error(`[generateDestinoEvent] Error uploading images for event ${event.Id}:`, uploadError1 || uploadError2)
+              throw new Error('Failed to upload images')
+            } else {
+              // Get public URL
+              const {
+                data: { publicUrl },
+              } = supabase.storage.from('destino-events').getPublicUrl(socialImagePath)
+
+              imageUrl = publicUrl
+              console.log(`[generateDestinoEvent] Images uploaded successfully for event ${event.Id}. URL: ${imageUrl}`)
+            }
+          }
+
+          upsert.image_url = imageUrl
+          upsert.content = content
+        }
+
+        // Save to Supabase
+        console.log(`[generateDestinoEvent] Saving event ${event.Id} to database`)
+        const result = await supabase.from('destino_events').upsert(upsert, { defaultToNull: false })
+        console.log(`[generateDestinoEvent] Event ${event.Id} saved successfully`)
 
-          if (uploadError1 || uploadError2) {
-            console.error('Error uploading image:', uploadError1 || uploadError2)
-          } else {
-            // Get public URL
-            const {
-              data: { publicUrl },
-            } = supabase.storage.from('destino-events').getPublicUrl(`${event.Id}.png`)
+        // If forceImageGeneration is true, return the image URL
+        if (forceImageGeneration) {
+          // update image_url in the database
+          await supabase.from('destino_events').update({ image_url: upsert.image_url }).eq('event_id', event.Id)
 
-            imageUrl = publicUrl
+          console.log(`[generateDestinoEvent] Returning content and image URL for event ${event.Id}`)
+          return {
+            content: upsert.content,
+            imageUrl: upsert.image_url,
+            updated: true,
           }
         }
 
-        upsert.image_url = imageUrl
-        upsert.content = content
+        return result
+      } catch (error: any) {
+        console.error('[generateDestinoEvent] Error:', error)
+        throw error
       }
-
-      // Save to Supabase
-      const result = await supabase.from('destino_events').upsert(upsert, { defaultToNull: false })
-
-      return result
     },
     generateDestinoEvents: async () => {
       const events = await fetchFromSalesforce()