feat(database): add GroupRuleService, GroupService, and UserService models

m-mdy-m · m-mdy-m · commit 3dbf77728899 · 2024-11-16T16:22:43.000+03:30
-  Added `GroupRuleService`:
  - Handles CRUD operations for group rules.
  - Implements methods to fetch, add, update, and delete group rules.
  - Ensures groups and users exist before adding or updating rules.

- Added `UserService`:
  - Manages user-related operations like creation, retrieval, and updates.
  - Ensures users are persisted in the database with proper data handling.

- Added `GroupService`:
  - Handles CRUD operations for groups.
  - Ensures group information is properly saved and updated, including members and permissions.
  - Supports synchronization with Telegram group data.

- Integrated database layer via `DatabaseService`:
  - All services utilize consistent database operations for queries, inserts, updates, and deletions.

- Improved modularity and reusability:
  - Services are designed to encapsulate specific responsibilities, ensuring clean architecture and easier future maintenance.
diff --git a/src/database/models/Group.ts b/src/database/models/Group.ts
@@ -0,0 +1,73 @@
+import { PoolClient } from 'pg';
+import { Group } from '../../types/database/TablesTypes';
+import { Context } from 'grammy';
+import { MembersService } from '../service/Members';
+import { DatabaseService } from '../service/Databas';
+export class GroupService {
+  private _db: DatabaseService;
+  constructor(private _client: PoolClient) {
+    this._db = new DatabaseService(_client);
+  }
+  async create(group: Omit<Group, 'id'>) {
+    return await this._db.insert<Group>('Group', {
+      group_id: group.group_id,
+      group_name: group.group_name,
+      black_list: group.black_list || [],
+      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 || [],
+      updated_at: group.updated_at || new Date(),
+      joined_at: group.joined_at || new Date(),
+    });
+  }
+  async update(group: Group) {
+    const condition = { group_id: group.group_id };
+    const data = {
+      group_id: group.group_id,
+      group_name: group.group_name,
+      black_list: group.black_list,
+      chat_permissions: group.chat_permissions,
+      approved_users: group.approved_users,
+      warnings: group.warnings,
+      is_spam_time: group.is_spam_time,
+      members: group.members,
+      updated_at: group.updated_at || new Date(),
+    };
+    return await this._db.update<Group>('Group', data, condition);
+  }
+  async delete(groupId: number) {}
+  async getByGroupId(groupId: number): Promise<Group | null> {
+    const query = `SELECT * FROM "Group" WHERE group_id = $1;`;
+    const result = await this._db.query<Group>(query, [groupId]);
+    return result.rows[0] || null;
+  }
+  async save(ctx: Context): Promise<Group> {
+    const [id, title] = [ctx.chat!.id!, ctx.chat!.title];
+    const perrmission = (await ctx.api.getChat(id)).permissions;
+    let group = await this.getByGroupId(id);
+    if (!group) {
+      const newGroupData: Omit<Group, 'id'> = {
+        joined_at: new Date(),
+        updated_at: new Date(),
+        group_id: id,
+        group_name: title || 'Unnamed Group',
+        black_list: [],
+        chat_permissions: perrmission || {},
+        approved_users: [],
+        warnings: 0,
+        is_spam_time: false,
+        members: [],
+      };
+      group = await this.create(newGroupData);
+    }
+    return group!;
+  }
+  private getMemebrsService() {
+    return new MembersService(this._client);
+  }
+  async updateMembers(groupId: number, newMember: number | string): Promise<Group> {
+    return await this.getMemebrsService().update(groupId, newMember);
+  }
+}
diff --git a/src/database/models/GroupRule.ts b/src/database/models/GroupRule.ts
@@ -0,0 +1,114 @@
+import { PoolClient } from 'pg';
+import { GroupRule } from '../../types/database/TablesTypes';
+import { ServiceProvider } from '../../service/database/ServiceProvider';
+import { Context } from 'grammy';
+import { DatabaseService } from '../service/Databas';
+
+export class GroupRuleService {
+  private _db: DatabaseService;
+
+  constructor(private _client: PoolClient) {
+    this._db = new DatabaseService(this._client);
+  }
+  private async createRule(groupRule: Omit<GroupRule, 'id'>): Promise<GroupRule> {
+    return await this._db.insert<GroupRule>('GroupRule', {
+      group_id: groupRule.group_id,
+      rule_text: groupRule.rule_text,
+      added_at: groupRule.added_at || new Date(),
+      added_by: groupRule.added_by,
+    });
+  }
+  private async update(ruleId: number, newRuleText: string[]): Promise<GroupRule> {
+    const result = await this._db.update<GroupRule>('GroupRule', { rule_text: newRuleText, added_at: new Date() }, { id: ruleId });
+    return result;
+  }
+  /**
+   * Fetches all rules for a specific group, sorted by added date (most recent first).
+   */
+  async getRulesByGroupId(groupId: number): Promise<GroupRule[]> {
+    const services = ServiceProvider.getInstance();
+    const groupService = await services.getGroupService();
+    let group = await groupService.getByGroupId(groupId);
+    const result = await this._db.query<GroupRule>('SELECT id, group_id, rule_text, added_at, added_by FROM "GroupRule" WHERE group_id = $1 ORDER BY added_at DESC;', [group?.id!]);
+    return result.rows;
+  }
+  /**
+   * Adds a new rule to a group.
+   */
+  async addGroupRule(ctx: Context, ruleText: string): Promise<GroupRule> {
+    const chat = ctx.chat!;
+    const groupId = chat.id;
+    const userId = ctx.from?.id!;
+
+    const services = ServiceProvider.getInstance();
+    const [groupService, userService] = await Promise.all([services.getGroupService(), services.getUserService()]);
+    // Ensure the group exists in the database
+    let group = await groupService.getByGroupId(groupId);
+    if (!group) {
+      group = await groupService.save(ctx); // Create group if not found
+    }
+    // Ensure the user exists in the database
+    let user = await userService.getByTelegramId(userId);
+    if (!user) {
+      const userData = { first_name: ctx.from?.first_name!, id: userId, username: ctx.from?.username! };
+      user = await userService.save(userData); // Create user if not found
+    }
+    // Check if there's an existing rule for this group
+    const groupRules = await this.getRulesByGroupId(groupId);
+    if (groupRules.length > 0) {
+      // Update the existing rule's text array by appending the new rule
+      const existingRule = groupRules[0]; // Assuming only one entry per group
+      const updatedRuleText = [...existingRule.rule_text, ruleText];
+
+      return this.update(existingRule.id, updatedRuleText);
+    } else {
+      // Create a new rule entry if no rules exist
+      return this.createRule({
+        group_id: group.id,
+        rule_text: [ruleText],
+        added_at: new Date(),
+        added_by: user.id,
+      });
+    }
+    // Create the new group rule
+  }
+  /**
+   * Deletes the most recently added rule for a group.
+   */
+  async deleteLastGroupRule(ctx: Context): Promise<GroupRule | null> {
+    const chat = ctx.chat!;
+    const groupId = chat.id;
+    const groupRules = await this.getRulesByGroupId(groupId);
+    if (groupRules.length === 0) {
+      // No rules to delete
+      return null;
+    }
+    const latestRule = groupRules[0];
+    const updatedRuleText = latestRule.rule_text.slice(0, -1);
+    if (updatedRuleText.length === 0) {
+      const result = await this._db.delete<GroupRule>('GroupRule', { id: latestRule.id });
+      return result[0] || null;
+    } else {
+      // Update the rule_text array with the last element removed
+      const result = await this._db.update<GroupRule>('GroupRule', { rule_text: updatedRuleText, added_at: new Date() }, { id: latestRule.id });
+      return result;
+    }
+  }
+
+  /**
+   * Deletes all rules for a specific group.
+   */
+  async clearAllRulesForGroup(ctx: Context): Promise<void> {
+    const chat = ctx.chat!;
+    const groupId = chat.id;
+
+    const groupRules = await this.getRulesByGroupId(groupId);
+    console.log('groupRules', groupRules);
+
+    if (groupRules.length === 0) {
+      console.log(`No rules found for group ID: ${groupId}.`);
+      return;
+    }
+    await this._db.delete<GroupRule>('GroupRule', { group_id: groupRules[0].group_id });
+  }
+}
diff --git a/src/database/models/User.ts b/src/database/models/User.ts
@@ -0,0 +1,61 @@
+import { PoolClient } from 'pg';
+import { User } from '../../types/database/TablesTypes';
+import { DatabaseService } from '../service/Databas';
+export class UserService {
+  private _db: DatabaseService;
+  constructor(private _client: PoolClient) {
+    this._db = new DatabaseService(_client);
+  }
+  async create(user: Omit<User, 'id'>): Promise<User> {
+    return await this._db.insert<User>('User', {
+      telegram_id: user.telegram_id,
+      username: user.username,
+      first_name: user.first_name,
+      created_at: user.created_at || new Date(),
+      updated_at: user.updated_at || new Date(),
+      role: user.role,
+      warnings: user.warnings,
+      approved_groups: user.approved_groups,
+    });
+  }
+  async update(user: User): Promise<User | null> {
+    const condition = { id: user.id };
+    const data = {
+      telegram_id: user.telegram_id,
+      username: user.username,
+      first_name: user.first_name,
+      role: user.role,
+      warnings: user.warnings,
+      approved_groups: user.approved_groups,
+      updated_at: new Date(),
+    };
+    return await this._db.update<User>('User', data, condition);
+  }
+  async delete(telegram_id: number): Promise<boolean> {
+    const deletedUser = await this._db.delete<User>('User', { telegram_id }, ['id']);
+    return deletedUser.length > 0;
+  }
+  async getByTelegramId(telegram_id: number): Promise<User | null> {
+    const query = `SELECT * FROM "User" WHERE telegram_id = $1;`;
+    const result = await this._db.query<User>(query, [telegram_id]);
+    return result.rows.length > 0 ? result.rows[0] : null;
+  }
+  async save(user_data: { id: number; username: string; first_name: string }): Promise<User> {
+    const { id, username, first_name } = user_data;
+    let user = await this.getByTelegramId(id);
+    if (!user) {
+      const newUserData: Omit<User, 'id'> = {
+        created_at: new Date(),
+        updated_at: new Date(),
+        telegram_id: id,
+        role: 'user',
+        username: username || null,
+        first_name: first_name,
+        warnings: 0,
+        approved_groups: [],
+      };
+      user = await this.create(newUserData);
+    }
+    return user!;
+  }
+}
