Introduce an information system for important announcements

Implement a new announcement system with priority levels, role-based access, and store-specific filtering, replacing the customer order statistics card on the dashboard.

Replit-Commit-Author: Agent
Replit-Commit-Session-Id: e437ffed-c31b-44eb-9fd5-b6f9faa8e7ce
Replit-Commit-Checkpoint-Type: full_checkpoint
Replit-Commit-Screenshot-Url: https://storage.googleapis.com/screenshot-production-us-central1/1957c339-2757-4d1f-8e92-e9f71a1ce58e/e437ffed-c31b-44eb-9fd5-b6f9faa8e7ce/biGr9ER

server/storage.ts

@@ -10,6 +10,7 @@ import {
   customerOrders,
   dlcProducts,
   tasks,
+  announcements,
   nocodbConfig,
   invoiceVerificationCache,
   savTickets,
@@ -47,6 +48,9 @@ import {
   type Task,
   type InsertTask,
   type TaskWithRelations,
+  type Announcement,
+  type InsertAnnouncement,
+  type AnnouncementWithRelations,
   type NocodbConfig,
   type InsertNocodbConfig,
   type InvoiceVerificationCache,
@@ -170,6 +174,11 @@ export interface IStorage {
   updateTask(id: number, task: Partial<InsertTask>): Promise<Task>;
   deleteTask(id: number): Promise<void>;
   completeTask(id: number, completedBy?: string): Promise<void>;
+
+  // Announcement operations
+  createAnnouncement(announcement: InsertAnnouncement): Promise<Announcement>;
+  getAnnouncements(groupIds?: number[]): Promise<AnnouncementWithRelations[]>;
+  deleteAnnouncement(id: number): Promise<boolean>;
   
   // SAV operations
   getSavTickets(filters?: { 
@@ -1580,6 +1589,55 @@ export class DatabaseStorage implements IStorage {
       .where(eq(tasks.id, id));
   }
 
+  // Announcement operations
+  async createAnnouncement(announcementData: InsertAnnouncement): Promise<Announcement> {
+    const [announcement] = await db.insert(announcements).values(announcementData).returning();
+    return announcement;
+  }
+
+  async getAnnouncements(groupIds?: number[]): Promise<AnnouncementWithRelations[]> {
+    let query = db
+      .select({
+        announcement: announcements,
+        author: users,
+        group: groups,
+      })
+      .from(announcements)
+      .leftJoin(users, eq(announcements.authorId, users.id))
+      .leftJoin(groups, eq(announcements.groupId, groups.id));
+
+    // Filter by groupIds if provided (for admin filtering by store)
+    if (groupIds && groupIds.length > 0) {
+      query = query.where(
+        or(
+          isNull(announcements.groupId), // Global announcements (no group)
+          inArray(announcements.groupId, groupIds)
+        )
+      );
+    }
+
+    const results = await query.orderBy(
+      // Sort by priority (urgent > important > normal) then by date (newest first)
+      sql`CASE 
+        WHEN ${announcements.priority} = 'urgent' THEN 3
+        WHEN ${announcements.priority} = 'important' THEN 2
+        ELSE 1
+      END DESC`,
+      desc(announcements.createdAt)
+    );
+
+    return results.map(result => ({
+      ...result.announcement,
+      author: result.author!,
+      group: result.group,
+    }));
+  }
+
+  async deleteAnnouncement(id: number): Promise<boolean> {
+    const result = await db.delete(announcements).where(eq(announcements.id, id));
+    return result.rowCount ? result.rowCount > 0 : false;
+  }
+
   // SAV operations
   async getSavTickets(filters?: { 
     groupIds?: number[]; 
@@ -1861,6 +1919,7 @@ export class MemStorage implements IStorage {
   private customerOrders = new Map<number, CustomerOrder>();
   private dlcProducts = new Map<number, DlcProduct>();
   private tasks = new Map<number, Task>();
+  private announcements = new Map<number, Announcement>();
   private savTickets = new Map<number, SavTicket>();
   private savTicketHistories = new Map<number, SavTicketHistory[]>();
 
@@ -1873,6 +1932,7 @@ export class MemStorage implements IStorage {
     customerOrder: 1,
     dlcProduct: 1,
     task: 1,
+    announcement: 1,
     savTicket: 1,
     savTicketHistory: 1,
   };
@@ -3272,6 +3332,55 @@ export class MemStorage implements IStorage {
     // In development, this is a no-op
     console.log('🧹 DEV: Weather cache cleared due to location change');
   }
+
+  // Announcement operations
+  async createAnnouncement(announcementData: InsertAnnouncement): Promise<Announcement> {
+    const id = this.idCounters.announcement++;
+    const announcement: Announcement = {
+      id,
+      ...announcementData,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+    this.announcements.set(id, announcement);
+    return announcement;
+  }
+
+  async getAnnouncements(groupIds?: number[]): Promise<AnnouncementWithRelations[]> {
+    const announcements = Array.from(this.announcements.values());
+    
+    let filteredAnnouncements = announcements;
+    
+    // Filter by groupIds if provided (for admin filtering by store)
+    if (groupIds && groupIds.length > 0) {
+      filteredAnnouncements = announcements.filter(announcement => 
+        !announcement.groupId || groupIds.includes(announcement.groupId)
+      );
+    }
+
+    // Add relations
+    return filteredAnnouncements.map(announcement => {
+      const author = this.users.get(announcement.authorId);
+      const group = announcement.groupId ? this.groups.get(announcement.groupId) : undefined;
+      
+      return {
+        ...announcement,
+        author: author!,
+        group,
+      };
+    }).sort((a, b) => {
+      // Sort by priority (urgent > important > normal) then by date (newest first)
+      const priorityOrder = { urgent: 3, important: 2, normal: 1 };
+      const priorityDiff = (priorityOrder[b.priority as keyof typeof priorityOrder] || 1) - 
+                          (priorityOrder[a.priority as keyof typeof priorityOrder] || 1);
+      if (priorityDiff !== 0) return priorityDiff;
+      return new Date(b.createdAt!).getTime() - new Date(a.createdAt!).getTime();
+    });
+  }
+
+  async deleteAnnouncement(id: number): Promise<boolean> {
+    return this.announcements.delete(id);
+  }
 }
 
 // Use MemStorage in development, DatabaseStorage in production