feat(database): implement WarningDatabaseService for managing warnings and remove spamtime option

- Add methods for creating, updating, deleting, and retrieving warnings:
  - `create`: Inserts a new warning into the database.
  - `update`: Updates an existing warning's reason and timestamp.
  - `delete`: Deletes a warning by ID.
  - `getById`: Retrieves a warning by ID.
  - `getByUserId`: Fetches all warnings associated with a specific user.
  - `getByGroupId`: Fetches the latest warning associated with a specific group.
  - `getAll`: Fetches warnings with optional filters for group ID and user ID.
  - `save`: Saves a new warning if one does not exist for a group.

- Ensure proper handling of database queries and parameters.
- Use a consistent approach for query structuring and parameter binding.
- Leverage `DatabaseService` for query execution and CRUD operations.

This implementation provides a robust interface for warning management, ensuring easy integration and scalability for user and group-related operations.

Author: m-mdy-m

src/database/models/Channel.ts

@@ -0,0 +1,6 @@
+export class ChannelService {
+  async create() {}
+  async update() {}
+  async delete() {}
+  async getByChannelId() {}
+}

src/database/models/Group.ts

@@ -16,8 +16,8 @@ export class GroupService {
       chat_permissions: JSON.stringify(group.chat_permissions),
       approved_users: group.approved_users || [],
       warnings: group.warnings || [],
-      is_spam_time: group.is_spam_time || false,
       members: group.members || [],
+      welcome_message: group.welcome_message,
       updated_at: group.updated_at || new Date(),
       joined_at: group.joined_at || new Date(),
     });
@@ -31,7 +31,7 @@ export class GroupService {
       chat_permissions: group.chat_permissions,
       approved_users: group.approved_users,
       warnings: group.warnings,
-      is_spam_time: group.is_spam_time,
+      welcome_message: group.welcome_message,
       members: group.members,
       updated_at: group.updated_at || new Date(),
     };
@@ -47,6 +47,7 @@ export class GroupService {
     const [id, title] = [ctx.chat!.id!, ctx.chat!.title];
     const perrmission = (await ctx.api.getChat(id)).permissions;
     let group = await this.getByGroupId(id);
+    const default_welcome_message = `Welcome to ${ctx.chat!.title}\n\nWe are so glad to have you here!. If you have any questions, don't hesitate to ask! 💬\n\nEnjoy your time here!`;
     if (!group) {
       const newGroupData: Omit<Group, 'id'> = {
         joined_at: new Date(),
@@ -56,8 +57,8 @@ export class GroupService {
         black_list: [],
         chat_permissions: perrmission || {},
         approved_users: [],
-        warnings: 0,
-        is_spam_time: false,
+        warnings: [],
+        welcome_message: default_welcome_message,
         members: [],
       };
       group = await this.create(newGroupData);

src/database/models/Warning.ts

@@ -0,0 +1,105 @@
+import { PoolClient } from 'pg';
+import { Warning } from '../../types/database/TablesTypes';
+import { DatabaseService } from '../service/Databas';
+export class WarningDatabaseService {
+  private _db: DatabaseService;
+  constructor(private _client: PoolClient) {
+    this._db = new DatabaseService(_client);
+  }
+
+  // Create a new warning
+  async create(warning: Omit<Warning, 'id'>): Promise<Warning> {
+    return await this._db.insert<Warning>('Warning', {
+      user_id: warning.user_id,
+      group_id: warning.group_id,
+      reason: warning.reason,
+      warned_at: warning.warned_at || new Date(),
+    });
+  }
+
+  // Update an existing warning (reason)
+  async update(warning: Warning): Promise<Warning | null> {
+    const updatedWarning = await this._db.update<Warning>(
+      'Warning',
+      {
+        reason: warning.reason,
+        warned_at: warning.warned_at || new Date(),
+      },
+      { id: warning.id }
+    );
+
+    return updatedWarning ?? null;
+  }
+
+  // Delete a specific warning
+  async delete(warningId: number): Promise<boolean> {
+    const deletedWarnings = await this._db.delete<Warning>('Warning', { id: warningId });
+    return deletedWarnings.length > 0;
+  }
+
+  // Fetch a warning by ID
+  async getById(warningId: number): Promise<Warning | null> {
+    const query = `SELECT * FROM "Warning" WHERE id = $1;`;
+    const result = await this._db.query<Warning>(query, [warningId]);
+    return result.rows[0] || null;
+  }
+
+  // Fetch all warnings for a specific user
+  async getByUserId(userId: number): Promise<Warning[]> {
+    const query = `
+      SELECT * FROM "Warning"
+      WHERE user_id = $1
+      ORDER BY warned_at DESC;
+    `;
+    const result = await this._db.query<Warning>(query, [userId]);
+    return result.rows;
+  }
+
+  // Fetch all warnings for a specific group
+  async getByGroupId(groupId: number): Promise<Warning> {
+    const query = `
+      SELECT * FROM "Warning"
+      WHERE group_id = $1
+      ORDER BY warned_at DESC;
+    `;
+    const result = await this._db.query<Warning>(query, [groupId]);
+    return result.rows[0];
+  }
+  async getAll(filter: { groupId?: number; userId?: number } = {}): Promise<Warning[]> {
+    const conditions: string[] = [];
+    const params: any[] = [];
+
+    if (filter.groupId) {
+      conditions.push(`group_id = $${params.length + 1}`);
+      params.push(filter.groupId);
+    }
+    if (filter.userId) {
+      conditions.push(`user_id = $${params.length + 1}`);
+      params.push(filter.userId);
+    }
+
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
+    const query = `
+      SELECT * FROM "Warning"
+      ${whereClause}
+      ORDER BY warned_at DESC;
+    `;
+
+    const result = await this._db.query<Warning>(query, params);
+    return result.rows;
+  }
+
+  async save(groupId: number, userId: number, reason: string): Promise<Warning> {
+    let warn = await this.getByGroupId(groupId);
+    if (!warn) {
+      const newGroupData: Omit<Warning, 'id'> = {
+        group_id: groupId,
+        reason: reason,
+        user_id: userId,
+        warned_at: new Date(),
+      };
+      warn = await this.create(newGroupData);
+    }
+    return warn!;
+  }
+}

src/database/sql/Tables.sql

@@ -22,7 +22,6 @@ CREATE TABLE IF NOT EXISTS "Group" (
     joined_at TIMESTAMP DEFAULT NOW(),
     approved_users BIGINT[],                  -- Array of approved user IDs
     warnings BIGINT[],                   -- Number of warnings in the group
-    is_spam_time BOOLEAN DEFAULT FALSE,       -- Flag for spam detection
     welcome_message TEXT,
     members BIGINT[]
 );

src/database/sql/seed/SeedDataTables.sql

@@ -6,10 +6,10 @@ VALUES
   (777888999, 'user3','fuser3' ,'user', 0, ARRAY[123456789],NOW(),NOW()),
   (333444555, 'user4', 'fuser4','user', 1, ARRAY[123456789, 987654321],NOW(),NOW());
 -- Seeding the Group table
-INSERT INTO "Group" (group_id, group_name, black_list, chat_permissions, updated_at, joined_at, approved_users, warnings, is_spam_time,welcome_message,members)
+INSERT INTO "Group" (group_id, group_name, black_list, chat_permissions, updated_at, joined_at, approved_users, warnings,welcome_message,members)
 VALUES
-  (123456789, 'Test Group 1', ARRAY['BadWord1', 'BadWord2'], '{"can_post": true, "can_message": true}', NOW(), NOW(), ARRAY[1, 2], ARRAY[0], FALSE,'welcome message',ARRAY[0,2]),
-  (987654321, 'Test Group 2', ARRAY['OffensiveUser1'], '{"can_post": false, "can_message": false}', NOW(), NOW(), ARRAY[3, 4], ARRAY[1], TRUE,'welcome message2',ARRAY[3,4]);
+  (123456789, 'Test Group 1', ARRAY['BadWord1', 'BadWord2'], '{"can_post": true, "can_message": true}', NOW(), NOW(), ARRAY[1, 2], ARRAY[0],'welcome message',ARRAY[0,2]),
+  (987654321, 'Test Group 2', ARRAY['OffensiveUser1'], '{"can_post": false, "can_message": false}', NOW(), NOW(), ARRAY[3, 4], ARRAY[1],'welcome message2',ARRAY[3,4]);
 -- Seeding the Warning table after Group data has been inserted
 INSERT INTO "Warning" (user_id, group_id, warned_at, reason)
 VALUES

src/types/database/TablesTypes.ts

@@ -7,10 +7,10 @@ export interface Group {
   black_list: string[];
   chat_permissions: ChatPermissions;
   approved_users: number[];
-  warnings: number;
-  is_spam_time: boolean;
+  warnings: number[];
   members: number[];
   updated_at: Date;
+  welcome_message: string;
   joined_at: Date;
 }
 export interface User {
@@ -31,12 +31,6 @@ export interface Warning {
   reason: string;
   warned_at: Date;
 }
-export interface ApprovedUser {
-  id: number;
-  user_id: User['id'];
-  group_id: Group['id'];
-  username: string;
-}
 export interface Channel {
   id: number;
   name: string;
@@ -50,9 +44,3 @@ export interface GroupRule {
   added_by: User['id'];
   added_at: Date;
 }
-export interface GroupMessageSettings {
-  id: number;
-  group_id: Group['id'];
-  is_locked: boolean;
-  welcome_message: string;
-}