@bash-app/bash-common 30.36.0 → 30.37.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bash-app/bash-common",
-  "version": "30.36.0",
+  "version": "30.37.0",
   "description": "Common data and scripts to use on the frontend and backend",
   "type": "module",
   "main": "src/index.ts",

package/prisma/schema.prisma

@@ -314,6 +314,7 @@ model BashEvent {
   userPromoCodeRedemption         UserPromoCodeRedemption[]
   averageRating                   Float?                    @default(0)
   serviceBookings                 ServiceBooking[] // Add this field to create the reverse relation
+  userReport                      UserReport[]
 }
 
 model Coordinates {
@@ -984,7 +985,7 @@ model User {
   stripeCustomerId              String?              @unique
   stripeAccountId               String?              @unique
   isSuperUser                   Boolean              @default(false)
-  // isSuspended                   Boolean                   @default(false)
+  isSuspended                   Boolean              @default(false)
   intent                        UserIntent?
   googleCalendarAccess          String?
   givenName                     String?
@@ -997,6 +998,9 @@ model User {
   gender                        Gender?
   sex                           Sex?
   roles                         UserRole[]           @default([User])
+  aboutMe                       String?
+  levelBadge                    String?
+  temporaryBadges               String[]             @default([])
   ownedServices                 Service[]            @relation("OwnedService")
   createdServices               Service[]            @relation("CreatedService")
   createdEvents                 BashEvent[]          @relation("CreatedEvent")
@@ -1054,13 +1058,11 @@ model User {
   volunteerService         VolunteerService[]
   stripeAccounts           StripeAccount[]
   userPromoCodeRedemption  UserPromoCodeRedemption[]
-  accepted                 Boolean?                  @default(false) // Tracks if the user accepted the invitation
-  boughtTicket             Boolean?                  @default(false) // Tracks if the user bought a ticket
-  noPay                    Boolean?                  @default(false) // Tracks if the user is marked as "noPay"
-  supportedEvent           Boolean?                  @default(false) // Tracks if the user supported the event
+  accepted                 Boolean?                  @default(false)
+  boughtTicket             Boolean?                  @default(false)
+  noPay                    Boolean?                  @default(false)
+  supportedEvent           Boolean?                  @default(false)
 
-  // primaryStripeAccountDBId String?        @unique
-  // primaryStripeAccountDB   StripeAccount? @relation("PrimaryStripeAccount", fields: [primaryStripeAccountDBId], references: [id], onDelete: Restrict, onUpdate: Restrict)
   serviceBookingForCreator ServiceBooking[]         @relation("BookingCreator")
   serviceBookingForUser    ServiceBooking[]         @relation("BookingForUser")
   serviceBookingCheckout   ServiceBookingCheckout[]
@@ -1073,6 +1075,20 @@ model User {
   unblocksReceived UnblockedUserHistory[] @relation("UserUnblocksReceived")
 
   preferences UserPreferences?
+
+  // Add fields for user suspension
+  suspendedUntil DateTime?
+  suspendedById  String?
+  suspendedBy    User?     @relation("SuspendedUsers", fields: [suspendedById], references: [id], onDelete: SetNull)
+  suspendedUsers User[]    @relation("SuspendedUsers")
+
+  // Add relations for reports and demerits
+  reportsMade      UserReport[] @relation("ReportsMade")
+  reportsReceived  UserReport[] @relation("ReportsReceived")
+  reportsReviewed  UserReport[] @relation("ReportsReviewed")
+  demerits         Demerit[]    @relation("UserDemerits")
+  issuedDemerits   Demerit[]    @relation("IssuedDemerits")
+  expungedDemerits Demerit[]    @relation("ExpungedDemerits")
 }
 
 model UserPreferences {
@@ -2140,3 +2156,58 @@ enum EntityType {
   ORGANIZATION
   BASH_EVENT // For BashEvents
 }
+
+// Adding new models for the demerit system
+
+model UserReport {
+  id          String       @id @default(cuid())
+  reporterId  String // Host/reporter user ID
+  reporter    User         @relation("ReportsMade", fields: [reporterId], references: [id], onDelete: Cascade)
+  reportedId  String // Reported user ID
+  reported    User         @relation("ReportsReceived", fields: [reportedId], references: [id], onDelete: Cascade)
+  bashEventId String?
+  bashEvent   BashEvent?   @relation(fields: [bashEventId], references: [id], onDelete: SetNull)
+  reason      String
+  details     String
+  createdAt   DateTime     @default(now())
+  status      ReportStatus @default(Pending)
+  reviewerId  String? // Super user who reviewed the report
+  reviewer    User?        @relation("ReportsReviewed", fields: [reviewerId], references: [id], onDelete: SetNull)
+  reviewedAt  DateTime?
+  reviewNotes String?
+  demerits    Demerit[]
+
+  @@index([reporterId])
+  @@index([reportedId])
+  @@index([bashEventId])
+  @@index([status])
+}
+
+model Demerit {
+  id           String      @id @default(cuid())
+  userId       String
+  user         User        @relation("UserDemerits", fields: [userId], references: [id], onDelete: Cascade)
+  reportId     String?
+  report       UserReport? @relation(fields: [reportId], references: [id], onDelete: SetNull)
+  issuerId     String // Super user who issued the demerit
+  issuer       User        @relation("IssuedDemerits", fields: [issuerId], references: [id], onDelete: Cascade)
+  reason       String
+  points       Int         @default(1)
+  issuedAt     DateTime    @default(now())
+  expiresAt    DateTime?
+  isExpunged   Boolean     @default(false)
+  expungedAt   DateTime?
+  expungedById String?
+  expungedBy   User?       @relation("ExpungedDemerits", fields: [expungedById], references: [id], onDelete: SetNull)
+
+  @@index([userId])
+  @@index([issuerId])
+  @@index([reportId])
+}
+
+enum ReportStatus {
+  Pending
+  Approved
+  Rejected
+  Resolved
+}

package/src/definitions.ts

@@ -946,3 +946,217 @@ export interface SocialMediaProfile {
   url: string;
   userId: string;
 }
+
+// Badge Types
+export enum BadgeLevel {
+  Novice = "Novice",
+  Beginner = "Beginner",
+  Regular = "Regular",
+  Enthusiast = "Enthusiast",
+  Aficionado = "Aficionado",
+  Connoisseur = "Connoisseur",
+  Maverick = "Maverick",
+  Master = "Master",
+  Elite = "Elite",
+  Legend = "Legend"
+}
+
+export enum BadgeCategory {
+  Hosting = "Hosting",
+  Attendance = "Attendance",
+  Community = "Community",
+  Achievement = "Achievement",
+  Special = "Special"
+}
+
+// Type definitions for badges and reviews
+export interface Badge {
+  id: string;
+  name: string;
+  description: string;
+  imageUrl: string;
+  category: BadgeCategory;
+  earnedOn?: string;
+  isActive: boolean;
+}
+
+export interface LevelBadge extends Badge {
+  level: BadgeLevel;
+  requiredEvents: number;
+  requiredRating?: number;
+}
+
+export interface TemporaryBadge extends Badge {
+  expiresOn?: string;
+}
+
+export interface UserLevelBadge {
+  badgeId: string;
+  earnedOn: string;
+}
+
+export interface UserTemporaryBadge {
+  badgeId: string;
+  earnedOn: string;
+  expiresOn?: string;
+}
+
+export interface Review {
+  id: string;
+  rating: number; // 1-5 stars
+  creatorId: string;
+  bashEventId: string;
+  createdAt: string;
+  updatedAt: string;
+  comments?: ReviewComment[];
+}
+
+export interface ReviewComment {
+  id: string;
+  creatorId: string;
+  content: string;
+  reviewId: string;
+  createdAt?: string;
+}
+
+export interface ReviewWithEvent extends Review {
+  bashEvent: {
+    id: string;
+    title: string;
+    startDateTime: string;
+  };
+}
+
+export interface ReviewWithUser extends Review {
+  creator: {
+    id: string;
+    givenName?: string;
+    familyName?: string;
+    image?: string;
+    email: string;
+  };
+}
+
+export interface ReviewWithUserAndEvent extends ReviewWithUser, ReviewWithEvent {}
+
+export interface NewReview {
+  rating: number;
+  bashEventId: string;
+  commentContent?: string;
+}
+
+export interface ReviewStats {
+  averageRating: number;
+  totalRatings: number;
+  ratings: {
+    1: number;
+    2: number;
+    3: number;
+    4: number;
+    5: number;
+  };
+}
+
+// Default badge collections
+export const DEFAULT_LEVEL_BADGES: Record<string, LevelBadge> = {
+  novice: {
+    id: "novice",
+    name: "Novice Basher",
+    description: "Just getting started with Bash. Has hosted 1-2 events.",
+    imageUrl: "/badges/novice.png",
+    category: BadgeCategory.Hosting,
+    level: BadgeLevel.Novice,
+    requiredEvents: 1,
+    isActive: true
+  },
+  regular: {
+    id: "regular",
+    name: "Regular Basher",
+    description: "A consistent Bash user who has hosted 5+ events with good ratings.",
+    imageUrl: "/badges/regular.png",
+    category: BadgeCategory.Hosting,
+    level: BadgeLevel.Regular,
+    requiredEvents: 5,
+    requiredRating: 4.0,
+    isActive: true
+  },
+  maverick: {
+    id: "maverick",
+    name: "Maverick Basher",
+    description: "A seasoned Bash host with 15+ successful events and excellent ratings.",
+    imageUrl: "/badges/maverick.png",
+    category: BadgeCategory.Hosting,
+    level: BadgeLevel.Maverick,
+    requiredEvents: 15,
+    requiredRating: 4.5,
+    isActive: true
+  },
+  legend: {
+    id: "legend",
+    name: "Bash Legend",
+    description: "An elite Bash host with 30+ events and exceptional community standing.",
+    imageUrl: "/badges/legend.png",
+    category: BadgeCategory.Hosting,
+    level: BadgeLevel.Legend,
+    requiredEvents: 30,
+    requiredRating: 4.8,
+    isActive: true
+  }
+};
+
+export const DEFAULT_TEMPORARY_BADGES: Record<string, TemporaryBadge> = {
+  trendingStar: {
+    id: "trendingStar",
+    name: "Trending Star",
+    description: "Your event was trending in the last 30 days!",
+    imageUrl: "/badges/trending.png",
+    category: BadgeCategory.Achievement,
+    isActive: true,
+    expiresOn: undefined // Set dynamically when awarded
+  },
+  topHost: {
+    id: "topHost",
+    name: "Top Host",
+    description: "One of the top-rated hosts this month.",
+    imageUrl: "/badges/top-host.png",
+    category: BadgeCategory.Hosting,
+    isActive: true,
+    expiresOn: undefined // Set dynamically when awarded
+  },
+  earlyAdopter: {
+    id: "earlyAdopter",
+    name: "Early Adopter",
+    description: "Joined the platform early and helped shape the community.",
+    imageUrl: "/badges/early-adopter.png",
+    category: BadgeCategory.Special,
+    isActive: true
+  },
+  socialButterfly: {
+    id: "socialButterfly",
+    name: "Social Butterfly",
+    description: "Attended 10+ events in the last 30 days.",
+    imageUrl: "/badges/butterfly.png",
+    category: BadgeCategory.Attendance,
+    isActive: true,
+    expiresOn: undefined // Set dynamically when awarded
+  }
+};
+
+// Badge API endpoints
+export const BADGE_API_ENDPOINTS = {
+  GET_USER_BADGES: (userId: string) => `/user/${userId}/badges`,
+  UPDATE_USER_BADGES: (userId: string) => `/user/${userId}/badges`,
+  GET_HOST_RATING: (userId: string) => `/user/${userId}/host-rating`,
+  GET_USER_TRENDING_EVENTS: (userId: string) => `/user/${userId}/trending-events`,
+  GET_USER_TOP_HOST_STATUS: (userId: string) => `/user/${userId}/is-top-host`,
+  CALCULATE_BADGES: (userId: string) => `/user/${userId}/calculate-badges`,
+};
+
+// Review API endpoints
+export const REVIEW_API_ENDPOINTS = {
+  GET_HOST_REVIEWS: (userId: string) => `/user/${userId}/host-reviews`,
+  GET_REVIEW_STATS: (userId: string) => `/user/${userId}/review-stats`,
+  ELIGIBLE_FOR_REVIEW: (userId: string, hostId: string) => 
+    `/user/${userId}/eligible-for-review/${hostId}`,
+  CREATE_REVIEW: () => `/reviews`,
+};

package/src/extendedSchemas.ts

@@ -41,26 +41,24 @@ import {
   SocialMediaPlatform,
   SocialMediaProfile,
   Sponsor,
+  SponsoredEvent,
   StripeAccount,
   TargetAudience,
   Ticket,
+  TicketMetadata,
   TicketTier,
+  TicketTransfer,
   User,
+  UserPreferences,
   UserSubscription,
   Vendor,
   Venue,
   VolunteerService,
-  TicketTransfer,
-  TicketMetadata,
-  SponsoredEvent,
-  UserPreferences,
 } from "@prisma/client";
 import { SERVICE_LINK_DATA_TO_INCLUDE } from "./definitions";
-import { serviceKeysArray } from "./utils/service/serviceUtils";
 import {
-  createAllTrueObject,
   RemoveCommonProperties,
-  UnionFromArray,
+  UnionFromArray
 } from "./utils/typeUtils";
 
 //------------------------------------------------------user subscriptions------------------------------------------------------
@@ -114,6 +112,9 @@ export const FRONT_END_USER_DATA_TO_SELECT = {
   boughtTicket: true,
   noPay: true,
   supportedEvent: true,
+  aboutMe: true,
+  levelBadge: true,
+  temporaryBadges: true,
 } satisfies Prisma.UserSelect;
 
 export const PRIVATE_USER_ACCOUNT_TO_SELECT = {

package/src/utils/badgeUtils.ts

@@ -0,0 +1,69 @@
+import { DEFAULT_LEVEL_BADGES, DEFAULT_TEMPORARY_BADGES, LevelBadge, TemporaryBadge, UserTemporaryBadge } from "../definitions";
+
+/**
+ * Get the level badge details for a given badge ID
+ * @param badgeId The ID of the level badge
+ * @returns The level badge details or undefined if not found
+ */
+export const getLevelBadgeById = (badgeId: string): LevelBadge | undefined => {
+  return DEFAULT_LEVEL_BADGES[badgeId];
+};
+
+/**
+ * Get the temporary badge details for a given badge ID
+ * @param badgeId The ID of the temporary badge
+ * @returns The temporary badge details or undefined if not found
+ */
+export const getTemporaryBadgeById = (badgeId: string): TemporaryBadge | undefined => {
+  return DEFAULT_TEMPORARY_BADGES[badgeId];
+};
+
+/**
+ * Check if a temporary badge is expired
+ * @param badge The temporary badge to check
+ * @returns True if the badge is expired, false otherwise
+ */
+export const isTemporaryBadgeExpired = (badge: UserTemporaryBadge): boolean => {
+  if (!badge.expiresOn) return false;
+  
+  const expiryDate = new Date(badge.expiresOn);
+  const currentDate = new Date();
+  
+  return expiryDate < currentDate;
+};
+
+/**
+ * Filter out expired temporary badges
+ * @param badges Array of temporary badges
+ * @returns Array of non-expired temporary badges
+ */
+export const filterExpiredTemporaryBadges = (badges: UserTemporaryBadge[]): UserTemporaryBadge[] => {
+  return badges.filter(badge => !isTemporaryBadgeExpired(badge));
+};
+
+/**
+ * Determine the appropriate level badge based on event count and rating
+ * @param eventCount Number of hosted events
+ * @param rating Average host rating
+ * @returns The ID of the highest level badge the user qualifies for, or null if none
+ */
+export const determineLevelBadge = (eventCount: number, rating: number): string | null => {
+  // Sort badge IDs by required events in descending order
+  const sortedBadgeIds = Object.keys(DEFAULT_LEVEL_BADGES).sort(
+    (a, b) => DEFAULT_LEVEL_BADGES[b].requiredEvents - DEFAULT_LEVEL_BADGES[a].requiredEvents
+  );
+  
+  // Find the highest level badge the user qualifies for
+  for (const badgeId of sortedBadgeIds) {
+    const badge = DEFAULT_LEVEL_BADGES[badgeId];
+    
+    if (
+      eventCount >= badge.requiredEvents &&
+      (badge.requiredRating === undefined || rating >= badge.requiredRating)
+    ) {
+      return badgeId;
+    }
+  }
+  
+  return null;
+}; 

package/src/utils/reviewUtils.ts

@@ -0,0 +1,79 @@
+import { Review, ReviewStats } from "../definitions";
+
+/**
+ * Calculate average rating from an array of reviews
+ * @param reviews Array of reviews
+ * @returns Average rating (1-5)
+ */
+export const calculateAverageRating = (reviews: Review[]): number => {
+  if (!reviews.length) return 0;
+  
+  const sum = reviews.reduce((total, review) => total + review.rating, 0);
+  return parseFloat((sum / reviews.length).toFixed(1));
+};
+
+/**
+ * Generate review statistics from an array of reviews
+ * @param reviews Array of reviews
+ * @returns ReviewStats object with distribution and averages
+ */
+export const generateReviewStats = (reviews: Review[]): ReviewStats => {
+  const ratings = {
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0,
+    5: 0
+  };
+  
+  // Count each rating level
+  reviews.forEach(review => {
+    const rating = review.rating;
+    if (rating >= 1 && rating <= 5) {
+      ratings[rating as keyof typeof ratings]++;
+    }
+  });
+  
+  return {
+    averageRating: calculateAverageRating(reviews),
+    totalRatings: reviews.length,
+    ratings
+  };
+};
+
+/**
+ * Format rating as a string with star emoji
+ * @param rating Numeric rating
+ * @returns Formatted string (e.g., "4.5 ★★★★½")
+ */
+export const formatRatingWithStars = (rating: number): string => {
+  const fullStars = Math.floor(rating);
+  const hasHalfStar = rating % 1 >= 0.5;
+  
+  let stars = '★'.repeat(fullStars);
+  if (hasHalfStar) stars += '½';
+  
+  return `${rating.toFixed(1)} ${stars}`;
+};
+
+/**
+ * Check if a user is eligible to review an event
+ * @param userId User ID
+ * @param eventId Event ID
+ * @param alreadyReviewed Array of event IDs user has already reviewed
+ * @param eventsAttended Array of event IDs user has attended
+ * @returns Boolean indicating if user can review the event
+ */
+export const isEligibleToReview = (
+  userId: string, 
+  eventId: string,
+  hostId: string,
+  alreadyReviewed: string[],
+  eventsAttended: string[]
+): boolean => {
+  return (
+    userId !== hostId && // User is not the host
+    eventsAttended.includes(eventId) && // User attended the event
+    !alreadyReviewed.includes(eventId) // User has not already reviewed the event
+  );
+};