File changes

Author: base44-builder[bot]

functions/slackRecognitionWebhook.ts

@@ -0,0 +1,247 @@
+/**
+ * slackRecognitionWebhook
+ * 
+ * Handles Slack slash command: /recognize @recipient category message
+ * 
+ * Usage from Slack:
+ *   /recognize @jane.doe teamwork Great job on the Q1 launch!
+ * 
+ * Supported categories: teamwork, innovation, leadership, going_above,
+ *   customer_focus, problem_solving, mentorship, culture_champion
+ * 
+ * Setup in Slack App:
+ *   - Slash Commands → /recognize → Request URL: <this function URL>/
+ *   - Interactivity not required
+ */
+
+import { createClientFromRequest } from 'npm:@base44/sdk@0.8.21';
+
+const VALID_CATEGORIES = [
+  'teamwork', 'innovation', 'leadership', 'going_above',
+  'customer_focus', 'problem_solving', 'mentorship', 'culture_champion'
+];
+
+const CATEGORY_LABELS = {
+  teamwork: '🤝 Teamwork',
+  innovation: '💡 Innovation',
+  leadership: '🌟 Leadership',
+  going_above: '🚀 Going Above & Beyond',
+  customer_focus: '🎯 Customer Focus',
+  problem_solving: '🧩 Problem Solving',
+  mentorship: '🎓 Mentorship',
+  culture_champion: '🏆 Culture Champion',
+};
+
+// Verify Slack request signature to prevent spoofing
+async function verifySlackSignature(req, body) {
+  const signingSecret = Deno.env.get('SLACK_SIGNING_SECRET');
+  if (!signingSecret) return true; // Skip if not configured (dev mode)
+
+  const timestamp = req.headers.get('x-slack-request-timestamp');
+  const signature = req.headers.get('x-slack-signature');
+
+  if (!timestamp || !signature) return false;
+
+  // Reject requests older than 5 minutes
+  const now = Math.floor(Date.now() / 1000);
+  if (Math.abs(now - parseInt(timestamp)) > 300) return false;
+
+  const baseString = `v0:${timestamp}:${body}`;
+  const key = await crypto.subtle.importKey(
+    'raw',
+    new TextEncoder().encode(signingSecret),
+    { name: 'HMAC', hash: 'SHA-256' },
+    false,
+    ['sign']
+  );
+  const sig = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(baseString));
+  const hexSig = 'v0=' + Array.from(new Uint8Array(sig)).map(b => b.toString(16).padStart(2, '0')).join('');
+  return hexSig === signature;
+}
+
+// Look up a Slack user's email via Slack API
+async function getSlackUserEmail(slackUserId, accessToken) {
+  const res = await fetch(`https://slack.com/api/users.info?user=${slackUserId}`, {
+    headers: { Authorization: `Bearer ${accessToken}` },
+  });
+  const data = await res.json();
+  if (!data.ok || !data.user?.profile?.email) return null;
+  return { email: data.user.profile.email, name: data.user.real_name || data.user.name };
+}
+
+// Post a confirmation message back to Slack
+async function postSlackMessage(channel, blocks, accessToken) {
+  await fetch('https://slack.com/api/chat.postMessage', {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      channel,
+      username: 'INTeract',
+      icon_emoji: ':star:',
+      blocks,
+    }),
+  });
+}
+
+Deno.serve(async (req) => {
+  if (req.method !== 'POST') {
+    return Response.json({ error: 'Method not allowed' }, { status: 405 });
+  }
+
+  // Read raw body for signature verification
+  const rawBody = await req.text();
+
+  // Verify Slack signature
+  const isValid = await verifySlackSignature(req, rawBody);
+  if (!isValid) {
+    return Response.json({ error: 'Invalid signature' }, { status: 401 });
+  }
+
+  // Parse form-encoded Slack payload
+  const params = new URLSearchParams(rawBody);
+  const slackUserId = params.get('user_id');
+  const channelId = params.get('channel_id');
+  const text = (params.get('text') || '').trim();
+  const responseUrl = params.get('response_url');
+
+  if (!text) {
+    return Response.json({
+      response_type: 'ephemeral',
+      text: '❌ Usage: `/recognize @recipient category message`\n\nCategories: `teamwork`, `innovation`, `leadership`, `going_above`, `customer_focus`, `problem_solving`, `mentorship`, `culture_champion`',
+    });
+  }
+
+  // Parse: @recipient category message...
+  // text example: "@jane.doe teamwork Great job on the launch!"
+  const parts = text.split(/\s+/);
+  if (parts.length < 3) {
+    return Response.json({
+      response_type: 'ephemeral',
+      text: '❌ Usage: `/recognize @recipient category message`\nExample: `/recognize @jane.doe teamwork Great job on the Q1 launch!`',
+    });
+  }
+
+  const recipientHandle = parts[0].replace(/^@/, '').toLowerCase();
+  const category = parts[1].toLowerCase();
+  const message = parts.slice(2).join(' ');
+
+  if (!VALID_CATEGORIES.includes(category)) {
+    return Response.json({
+      response_type: 'ephemeral',
+      text: `❌ Invalid category \`${category}\`.\n\nValid categories: ${VALID_CATEGORIES.map(c => `\`${c}\``).join(', ')}`,
+    });
+  }
+
+  if (message.length < 10) {
+    return Response.json({
+      response_type: 'ephemeral',
+      text: '❌ Recognition message must be at least 10 characters.',
+    });
+  }
+
+  try {
+    const base44 = createClientFromRequest(req);
+
+    // Get the Slack bot access token
+    const { accessToken } = await base44.asServiceRole.connectors.getConnection('slackbot');
+
+    // Resolve sender's Slack email
+    const sender = await getSlackUserEmail(slackUserId, accessToken);
+    if (!sender) {
+      return Response.json({
+        response_type: 'ephemeral',
+        text: '❌ Could not look up your Slack profile. Make sure your Slack email matches your INTeract account.',
+      });
+    }
+
+    // Find recipient by email or username match in UserProfile
+    let recipientProfile = null;
+    const profiles = await base44.asServiceRole.entities.UserProfile.filter({
+      user_email: { $regex: recipientHandle, $options: 'i' }
+    });
+
+    if (profiles.length > 0) {
+      recipientProfile = profiles[0];
+    } else {
+      // Try partial name match
+      const allProfiles = await base44.asServiceRole.entities.UserProfile.list('-created_date', 200);
+      recipientProfile = allProfiles.find(p =>
+        (p.user_email || '').toLowerCase().includes(recipientHandle) ||
+        (p.role || '').toLowerCase().includes(recipientHandle)
+      ) || null;
+    }
+
+    if (!recipientProfile) {
+      return Response.json({
+        response_type: 'ephemeral',
+        text: `❌ Could not find a user matching \`${recipientHandle}\` in INTeract. Make sure they have a profile set up.`,
+      });
+    }
+
+    // Prevent self-recognition
+    if (recipientProfile.user_email === sender.email) {
+      return Response.json({
+        response_type: 'ephemeral',
+        text: '❌ You cannot recognize yourself.',
+      });
+    }
+
+    // Create the Recognition record
+    await base44.asServiceRole.entities.Recognition.create({
+      sender_email: sender.email,
+      sender_name: sender.name,
+      recipient_email: recipientProfile.user_email,
+      recipient_name: recipientProfile.role || recipientProfile.user_email,
+      message,
+      category,
+      points_awarded: 25,
+      visibility: 'public',
+      status: 'approved', // Slack recognitions auto-approved
+      source: 'slack',
+    });
+
+    // Post public confirmation to channel
+    const confirmBlocks = [
+      {
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: `🌟 *Recognition Alert!*\n\n*${sender.name}* just recognized *${recipientProfile.user_email}*`,
+        },
+      },
+      {
+        type: 'section',
+        fields: [
+          { type: 'mrkdwn', text: `*Category:*\n${CATEGORY_LABELS[category]}` },
+          { type: 'mrkdwn', text: `*Points Awarded:*\n⭐ 25 pts` },
+        ],
+      },
+      {
+        type: 'section',
+        text: { type: 'mrkdwn', text: `"${message}"` },
+      },
+      {
+        type: 'context',
+        elements: [
+          { type: 'mrkdwn', text: 'Synced to INTeract · View the full recognition feed in the platform.' },
+        ],
+      },
+    ];
+
+    await postSlackMessage(channelId, confirmBlocks, accessToken);
+
+    return Response.json({
+      response_type: 'ephemeral',
+      text: `✅ Recognition sent to *${recipientProfile.user_email}* and posted to this channel!`,
+    });
+
+  } catch (err) {
+    return Response.json({
+      response_type: 'ephemeral',
+      text: `❌ Something went wrong: ${err.message}`,
+    });
+  }
+});