Adding features

server/api/members/cancel-subscription.post.js

@@ -0,0 +1,100 @@
+// Cancel member subscription
+import jwt from "jsonwebtoken";
+import Member from "../../models/member.js";
+import { connectDB } from "../../utils/mongoose.js";
+
+const HELCIM_API_BASE = "https://api.helcim.com/v2";
+
+export default defineEventHandler(async (event) => {
+  try {
+    await connectDB();
+    const config = useRuntimeConfig(event);
+    const token = getCookie(event, "auth-token");
+
+    if (!token) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "Not authenticated",
+      });
+    }
+
+    // Decode JWT token
+    let decoded;
+    try {
+      decoded = jwt.verify(token, process.env.JWT_SECRET);
+    } catch (err) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "Invalid or expired token",
+      });
+    }
+
+    // Get member
+    const member = await Member.findById(decoded.memberId);
+    if (!member) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Member not found",
+      });
+    }
+
+    // If already on free tier, nothing to cancel
+    if (member.contributionTier === "0" || !member.helcimSubscriptionId) {
+      return {
+        success: true,
+        message: "No active subscription to cancel",
+        member,
+      };
+    }
+
+    const helcimToken =
+      config.public.helcimToken || process.env.NUXT_PUBLIC_HELCIM_TOKEN;
+
+    try {
+      // Cancel Helcim subscription
+      const response = await fetch(
+        `${HELCIM_API_BASE}/subscriptions/${member.helcimSubscriptionId}`,
+        {
+          method: "DELETE",
+          headers: {
+            accept: "application/json",
+            "api-token": helcimToken,
+          },
+        },
+      );
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        console.error(
+          "Failed to cancel Helcim subscription:",
+          response.status,
+          errorText,
+        );
+        // Continue anyway - we'll update the member record
+      }
+    } catch (error) {
+      console.error("Error canceling Helcim subscription:", error);
+      // Continue anyway - we'll update the member record
+    }
+
+    // Update member status
+    member.status = "cancelled";
+    member.contributionTier = "0";
+    member.helcimSubscriptionId = null;
+    member.paymentMethod = "none";
+    member.subscriptionEndDate = new Date();
+    await member.save();
+
+    return {
+      success: true,
+      message: "Subscription cancelled successfully",
+      member,
+    };
+  } catch (error) {
+    console.error("Error cancelling subscription:", error);
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || "Failed to cancel subscription",
+    });
+  }
+});

server/api/members/create.post.js

@@ -1,9 +1,74 @@
 // server/api/members/create.post.js
 import Member from '../../models/member.js'
 import { connectDB } from '../../utils/mongoose.js'
+import { getSlackService } from '../../utils/slack.ts'
 // Simple payment check function to avoid import issues
 const requiresPayment = (contributionValue) => contributionValue !== '0'
 
+// Function to invite member to Slack
+async function inviteToSlack(member) {
+  try {
+    const slackService = getSlackService()
+    if (!slackService) {
+      console.warn('Slack service not configured, skipping invitation')
+      return
+    }
+
+    console.log(`Processing Slack invitation for ${member.email}...`)
+    
+    const inviteResult = await slackService.inviteUserToSlack(
+      member.email,
+      member.name
+    )
+
+    if (inviteResult.success) {
+      // Update member record based on the actual result
+      if (inviteResult.status === 'existing_user_added_to_channel' || 
+          inviteResult.status === 'user_already_in_channel' || 
+          inviteResult.status === 'new_user_invited_to_workspace') {
+        member.slackInviteStatus = 'sent'
+        member.slackUserId = inviteResult.userId
+        member.slackInvited = true
+      } else {
+        // Manual invitation required
+        member.slackInviteStatus = 'pending'
+        member.slackInvited = false
+      }
+      await member.save()
+      
+      // Send notification to vetting channel
+      await slackService.notifyNewMember(
+        member.name,
+        member.email,
+        member.circle,
+        member.contributionTier,
+        inviteResult.status
+      )
+      
+      console.log(`Successfully processed Slack invitation for ${member.email}: ${inviteResult.status}`)
+    } else {
+      // Update member record to reflect failed invitation
+      member.slackInviteStatus = 'failed'
+      await member.save()
+      
+      console.error(`Failed to process Slack invitation for ${member.email}: ${inviteResult.error}`)
+      // Don't throw error - member creation should still succeed
+    }
+  } catch (error) {
+    console.error('Error during Slack invitation process:', error)
+    
+    // Update member record to reflect failed invitation
+    try {
+      member.slackInviteStatus = 'failed'
+      await member.save()
+    } catch (saveError) {
+      console.error('Failed to update member Slack status:', saveError)
+    }
+    
+    // Don't throw error - member creation should still succeed
+  }
+}
+
 export default defineEventHandler(async (event) => {
   // Ensure database is connected
   await connectDB()
@@ -23,6 +88,9 @@ export default defineEventHandler(async (event) => {
     const member = new Member(body)
     await member.save()
     
+    // Send Slack invitation for new members
+    await inviteToSlack(member)
+    
     // TODO: Process payment with Helcim if not free tier
     if (requiresPayment(body.contributionTier)) {
       // Payment processing will be added here

server/api/members/directory.get.js

@@ -0,0 +1,115 @@
+import jwt from "jsonwebtoken";
+import Member from "../../models/member.js";
+import { connectDB } from "../../utils/mongoose.js";
+
+export default defineEventHandler(async (event) => {
+  await connectDB();
+
+  // Check if user is authenticated
+  const token = getCookie(event, "auth-token");
+  let isAuthenticated = false;
+  let currentMemberId = null;
+
+  if (token) {
+    try {
+      const decoded = jwt.verify(token, process.env.JWT_SECRET);
+      currentMemberId = decoded.memberId;
+      isAuthenticated = true;
+    } catch (err) {
+      // Invalid token, treat as public
+      isAuthenticated = false;
+    }
+  }
+
+  const query = getQuery(event);
+  const search = query.search || "";
+  const circle = query.circle || "";
+  const skills = query.skills ? query.skills.split(",") : [];
+
+  // Build query
+  const dbQuery = {
+    showInDirectory: true,
+    status: "active",
+  };
+
+  // Filter by circle if specified
+  if (circle) {
+    dbQuery.circle = circle;
+  }
+
+  // Search by name or bio
+  if (search) {
+    dbQuery.$or = [
+      { name: { $regex: search, $options: "i" } },
+      { bio: { $regex: search, $options: "i" } },
+    ];
+  }
+
+  // Filter by skills
+  if (skills.length > 0) {
+    dbQuery.skills = { $in: skills };
+  }
+
+  try {
+    const members = await Member.find(dbQuery)
+      .select(
+        "name pronouns timeZone avatar studio bio skills location socialLinks offering lookingFor privacy circle createdAt"
+      )
+      .sort({ createdAt: -1 })
+      .lean();
+
+    // Filter fields based on privacy settings
+    const filteredMembers = members.map((member) => {
+      const privacy = member.privacy || {};
+      const filtered = {
+        _id: member._id,
+        name: member.name,
+        circle: member.circle,
+        createdAt: member.createdAt,
+      };
+
+      // Helper function to check if field should be visible
+      const isVisible = (field) => {
+        const privacySetting = privacy[field] || "members";
+        if (privacySetting === "public") return true;
+        if (privacySetting === "members" && isAuthenticated) return true;
+        if (privacySetting === "private") return false;
+        return false;
+      };
+
+      // Add fields based on privacy settings
+      if (isVisible("avatar")) filtered.avatar = member.avatar;
+      if (isVisible("pronouns")) filtered.pronouns = member.pronouns;
+      if (isVisible("timeZone")) filtered.timeZone = member.timeZone;
+      if (isVisible("studio")) filtered.studio = member.studio;
+      if (isVisible("bio")) filtered.bio = member.bio;
+      if (isVisible("skills")) filtered.skills = member.skills;
+      if (isVisible("location")) filtered.location = member.location;
+      if (isVisible("socialLinks")) filtered.socialLinks = member.socialLinks;
+      if (isVisible("offering")) filtered.offering = member.offering;
+      if (isVisible("lookingFor")) filtered.lookingFor = member.lookingFor;
+
+      return filtered;
+    });
+
+    // Get unique skills for filter options
+    const allSkills = members
+      .flatMap((m) => m.skills || [])
+      .filter((skill, index, self) => self.indexOf(skill) === index)
+      .sort();
+
+    return {
+      members: filteredMembers,
+      totalCount: filteredMembers.length,
+      filters: {
+        availableSkills: allSkills,
+      },
+    };
+  } catch (error) {
+    console.error("Directory fetch error:", error);
+    throw createError({
+      statusCode: 500,
+      message: "Failed to fetch member directory",
+    });
+  }
+});

server/api/members/my-events.get.js

@@ -0,0 +1,60 @@
+import Event from "../../models/event";
+import Member from "../../models/member";
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event);
+  const { memberId } = query;
+
+  if (!memberId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Member ID is required",
+    });
+  }
+
+  try {
+    // Verify member exists
+    const member = await Member.findById(memberId);
+    if (!member) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Member not found",
+      });
+    }
+
+    // Find all events where the user is registered
+    // Filter out cancelled events and only show future events
+    const now = new Date();
+
+    const events = await Event.find({
+      "registrations.memberId": memberId,
+      isCancelled: { $ne: true },
+      startDate: { $gte: now },
+    })
+      .select(
+        "title slug description startDate endDate location featureImage maxAttendees registeredCount",
+      )
+      .sort({ startDate: 1 })
+      .limit(10);
+
+    console.log(
+      `Found ${events.length} registered events for member ${memberId}`,
+    );
+
+    return {
+      events,
+      count: events.length,
+    };
+  } catch (error) {
+    console.error("Error fetching member events:", error);
+
+    if (error.statusCode) {
+      throw error;
+    }
+
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to fetch registered events",
+    });
+  }
+});

server/api/members/profile.patch.js

@@ -0,0 +1,117 @@
+import jwt from "jsonwebtoken";
+import Member from "../../models/member.js";
+import { connectDB } from "../../utils/mongoose.js";
+
+export default defineEventHandler(async (event) => {
+  await connectDB();
+
+  const token = getCookie(event, "auth-token");
+
+  if (!token) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Not authenticated",
+    });
+  }
+
+  let memberId;
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET);
+    memberId = decoded.memberId;
+  } catch (err) {
+    throw createError({
+      statusCode: 401,
+      statusMessage: "Invalid or expired token",
+    });
+  }
+
+  const body = await readBody(event);
+
+  // Define allowed profile fields
+  const allowedFields = [
+    "pronouns",
+    "timeZone",
+    "avatar",
+    "studio",
+    "bio",
+    "skills",
+    "location",
+    "socialLinks",
+    "offering",
+    "lookingFor",
+    "showInDirectory",
+    "helcimCustomerId",
+  ];
+
+  // Define privacy fields
+  const privacyFields = [
+    "pronounsPrivacy",
+    "timeZonePrivacy",
+    "avatarPrivacy",
+    "studioPrivacy",
+    "bioPrivacy",
+    "skillsPrivacy",
+    "locationPrivacy",
+    "socialLinksPrivacy",
+    "offeringPrivacy",
+    "lookingForPrivacy",
+  ];
+
+  // Build update object
+  const updateData = {};
+
+  allowedFields.forEach((field) => {
+    if (body[field] !== undefined) {
+      updateData[field] = body[field];
+    }
+  });
+
+  // Handle privacy settings
+  privacyFields.forEach((privacyField) => {
+    if (body[privacyField] !== undefined) {
+      const baseField = privacyField.replace("Privacy", "");
+      updateData[`privacy.${baseField}`] = body[privacyField];
+    }
+  });
+
+  try {
+    const member = await Member.findByIdAndUpdate(
+      memberId,
+      { $set: updateData },
+      { new: true, runValidators: true },
+    );
+
+    if (!member) {
+      throw createError({
+        statusCode: 404,
+        message: "Member not found",
+      });
+    }
+
+    // Return sanitized member data
+    return {
+      id: member._id,
+      email: member.email,
+      name: member.name,
+      circle: member.circle,
+      contributionTier: member.contributionTier,
+      pronouns: member.pronouns,
+      timeZone: member.timeZone,
+      avatar: member.avatar,
+      studio: member.studio,
+      bio: member.bio,
+      skills: member.skills,
+      location: member.location,
+      socialLinks: member.socialLinks,
+      offering: member.offering,
+      lookingFor: member.lookingFor,
+      showInDirectory: member.showInDirectory,
+    };
+  } catch (error) {
+    console.error("Profile update error:", error);
+    throw createError({
+      statusCode: 500,
+      message: "Failed to update profile",
+    });
+  }
+});

server/api/members/update-contribution.post.js

@@ -0,0 +1,354 @@
+// Update member's contribution tier
+import jwt from "jsonwebtoken";
+import {
+  getHelcimPlanId,
+  requiresPayment,
+  isValidContributionValue,
+} from "../../config/contributions.js";
+import Member from "../../models/member.js";
+import { connectDB } from "../../utils/mongoose.js";
+
+const HELCIM_API_BASE = "https://api.helcim.com/v2";
+
+export default defineEventHandler(async (event) => {
+  try {
+    await connectDB();
+    const config = useRuntimeConfig(event);
+    const body = await readBody(event);
+    const token = getCookie(event, "auth-token");
+
+    if (!token) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "Not authenticated",
+      });
+    }
+
+    // Decode JWT token
+    let decoded;
+    try {
+      decoded = jwt.verify(token, process.env.JWT_SECRET);
+    } catch (err) {
+      throw createError({
+        statusCode: 401,
+        statusMessage: "Invalid or expired token",
+      });
+    }
+
+    // Validate contribution tier
+    if (
+      !body.contributionTier ||
+      !isValidContributionValue(body.contributionTier)
+    ) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "Invalid contribution tier",
+      });
+    }
+
+    // Get member
+    const member = await Member.findById(decoded.memberId);
+    if (!member) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Member not found",
+      });
+    }
+
+    const oldTier = member.contributionTier;
+    const newTier = body.contributionTier;
+
+    // If same tier, nothing to do
+    if (oldTier === newTier) {
+      return {
+        success: true,
+        message: "Already on this tier",
+        member,
+      };
+    }
+
+    const helcimToken =
+      config.public.helcimToken || process.env.NUXT_PUBLIC_HELCIM_TOKEN;
+    const oldRequiresPayment = requiresPayment(oldTier);
+    const newRequiresPayment = requiresPayment(newTier);
+
+    // Case 1: Moving from free to paid tier
+    if (!oldRequiresPayment && newRequiresPayment) {
+      // Check if member has Helcim customer ID with saved payment method
+      if (!member.helcimCustomerId) {
+        throw createError({
+          statusCode: 400,
+          statusMessage:
+            "Please use the subscription creation flow to upgrade to a paid tier",
+          data: { requiresPaymentSetup: true },
+        });
+      }
+
+      // Try to fetch customer info from Helcim to check for saved cards
+      const helcimToken =
+        config.public.helcimToken || process.env.NUXT_PUBLIC_HELCIM_TOKEN;
+
+      try {
+        const customerResponse = await fetch(
+          `${HELCIM_API_BASE}/customers/${member.helcimCustomerId}`,
+          {
+            method: "GET",
+            headers: {
+              accept: "application/json",
+              "api-token": helcimToken,
+            },
+          },
+        );
+
+        if (!customerResponse.ok) {
+          throw new Error("Failed to fetch customer info");
+        }
+
+        const customerData = await customerResponse.json();
+        const customerCode = customerData.customerCode;
+
+        if (!customerCode) {
+          throw new Error("No customer code found");
+        }
+
+        // Check if customer has saved cards
+        const cardsResponse = await fetch(
+          `${HELCIM_API_BASE}/card-terminals?customerId=${member.helcimCustomerId}`,
+          {
+            method: "GET",
+            headers: {
+              accept: "application/json",
+              "api-token": helcimToken,
+            },
+          },
+        );
+
+        let hasCards = false;
+        if (cardsResponse.ok) {
+          const cardsData = await cardsResponse.json();
+          hasCards = cardsData.cards && cardsData.cards.length > 0;
+        }
+
+        if (!hasCards) {
+          throw new Error("No saved payment methods");
+        }
+
+        // Create new subscription with saved payment method
+        const newPlanId = getHelcimPlanId(newTier);
+
+        if (!newPlanId) {
+          throw createError({
+            statusCode: 400,
+            statusMessage: `Plan not configured for tier ${newTier}`,
+          });
+        }
+
+        // Generate idempotency key
+        const chars =
+          "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+        let idempotencyKey = "";
+        for (let i = 0; i < 25; i++) {
+          idempotencyKey += chars.charAt(
+            Math.floor(Math.random() * chars.length),
+          );
+        }
+
+        // Get tier amount
+        const { getContributionTierByValue } = await import(
+          "../../config/contributions.js"
+        );
+        const tierInfo = getContributionTierByValue(newTier);
+
+        const subscriptionResponse = await fetch(
+          `${HELCIM_API_BASE}/subscriptions`,
+          {
+            method: "POST",
+            headers: {
+              accept: "application/json",
+              "content-type": "application/json",
+              "api-token": helcimToken,
+              "idempotency-key": idempotencyKey,
+            },
+            body: JSON.stringify({
+              subscriptions: [
+                {
+                  dateActivated: new Date().toISOString().split("T")[0],
+                  paymentPlanId: parseInt(newPlanId),
+                  customerCode: customerCode,
+                  recurringAmount: parseFloat(tierInfo.amount),
+                  paymentMethod: "card",
+                },
+              ],
+            }),
+          },
+        );
+
+        if (!subscriptionResponse.ok) {
+          const errorText = await subscriptionResponse.text();
+          console.error("Failed to create subscription:", errorText);
+          throw new Error(`Failed to create subscription: ${errorText}`);
+        }
+
+        const subscriptionData = await subscriptionResponse.json();
+        const subscription = subscriptionData.data?.[0];
+
+        if (!subscription) {
+          throw new Error("No subscription returned in response");
+        }
+
+        // Update member record
+        member.contributionTier = newTier;
+        member.helcimSubscriptionId = subscription.id;
+        member.paymentMethod = "card";
+        member.status = "active";
+        await member.save();
+
+        return {
+          success: true,
+          message: "Successfully upgraded to paid tier",
+          member,
+          subscription: {
+            subscriptionId: subscription.id,
+            status: subscription.status,
+            nextBillingDate: subscription.nextBillingDate,
+          },
+        };
+      } catch (error) {
+        console.error("Error creating subscription with saved payment:", error);
+        // If we can't use saved payment, require new payment setup
+        throw createError({
+          statusCode: 400,
+          statusMessage:
+            "Payment information required. You'll be redirected to complete payment setup.",
+          data: { requiresPaymentSetup: true },
+        });
+      }
+    }
+
+    // Case 2: Moving from paid to free tier (cancel subscription)
+    if (oldRequiresPayment && !newRequiresPayment) {
+      if (member.helcimSubscriptionId) {
+        try {
+          // Cancel Helcim subscription
+          const response = await fetch(
+            `${HELCIM_API_BASE}/subscriptions/${member.helcimSubscriptionId}`,
+            {
+              method: "DELETE",
+              headers: {
+                accept: "application/json",
+                "api-token": helcimToken,
+              },
+            },
+          );
+
+          if (!response.ok) {
+            console.error(
+              "Failed to cancel Helcim subscription:",
+              response.status,
+            );
+          }
+        } catch (error) {
+          console.error("Error canceling Helcim subscription:", error);
+          // Continue anyway - we'll update the member record
+        }
+      }
+
+      // Update member to free tier
+      member.contributionTier = newTier;
+      member.helcimSubscriptionId = null;
+      member.paymentMethod = "none";
+      await member.save();
+
+      return {
+        success: true,
+        message: "Successfully downgraded to free tier",
+        member,
+      };
+    }
+
+    // Case 3: Moving between paid tiers
+    if (oldRequiresPayment && newRequiresPayment) {
+      const newPlanId = getHelcimPlanId(newTier);
+
+      if (!newPlanId) {
+        throw createError({
+          statusCode: 400,
+          statusMessage: `Plan not configured for tier ${newTier}`,
+        });
+      }
+
+      if (!member.helcimSubscriptionId) {
+        // No subscription exists - they need to go through payment flow
+        throw createError({
+          statusCode: 400,
+          statusMessage:
+            "Payment information required. You'll be redirected to complete payment setup.",
+          data: { requiresPaymentSetup: true },
+        });
+      }
+
+      try {
+        // Update subscription plan in Helcim
+        const response = await fetch(
+          `${HELCIM_API_BASE}/subscriptions/${member.helcimSubscriptionId}`,
+          {
+            method: "PATCH",
+            headers: {
+              accept: "application/json",
+              "content-type": "application/json",
+              "api-token": helcimToken,
+            },
+            body: JSON.stringify({
+              paymentPlanId: parseInt(newPlanId),
+            }),
+          },
+        );
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          console.error(
+            "Failed to update Helcim subscription:",
+            response.status,
+            errorText,
+          );
+          throw new Error(`Failed to update subscription: ${errorText}`);
+        }
+
+        const subscriptionData = await response.json();
+
+        // Update member record
+        member.contributionTier = newTier;
+        await member.save();
+
+        return {
+          success: true,
+          message: "Successfully updated contribution level",
+          member,
+          subscription: subscriptionData,
+        };
+      } catch (error) {
+        console.error("Error updating Helcim subscription:", error);
+        throw createError({
+          statusCode: 500,
+          statusMessage: error.message || "Failed to update subscription",
+        });
+      }
+    }
+
+    // Case 4: Moving between free tiers (shouldn't happen but handle it)
+    member.contributionTier = newTier;
+    await member.save();
+
+    return {
+      success: true,
+      message: "Successfully updated contribution level",
+      member,
+    };
+  } catch (error) {
+    console.error("Error updating contribution tier:", error);
+    throw createError({
+      statusCode: error.statusCode || 500,
+      statusMessage: error.message || "Failed to update contribution tier",
+    });
+  }
+});