feat: eVoting group thing done

Author: coodos

infrastructure/eid-wallet/src-tauri/gen/android/app/arm64/release/app-arm64-release.apk

@@ -305,6 +305,13 @@ export class Web3Adapter {
         );
 
         if (!this.mapping[tableName]) return;
+        
+        if (this.mapping[tableName].readOnly) {
+            // early return on mappings which are readonly so as to not 
+            // sync any update to the eVault which is not warranted
+            return;
+        }
+        
         console.log("We get here?");
         // If we already have a mapping, use that global ID
 

infrastructure/web3-adapter/src/index.ts

@@ -33,6 +33,12 @@ export interface IMapping {
      * String to String mapping between what path maps to what global ontology
      */
     localToUniversalMap: Record<string, string>;
+
+    /**
+     * If true, this mapping will not trigger handleChange and will be treated as read-only.
+     * Useful for entities that should not be synced to eVaults.
+     */
+    readOnly?: boolean;
 }
 
 export interface IMappingConversionOptions {

infrastructure/web3-adapter/src/mapper/mapper.types.ts

@@ -12,5 +12,6 @@
         "participants": "users(participants[].id),participantIds",
         "createdAt": "createdAt",
         "updatedAt": "updatedAt"
-    }
+    },
+    "readOnly": true
 } 

platforms/cerberus/src/web3adapter/mappings/group.mapping.json

@@ -17,5 +17,6 @@
         "isArchived": "isArchived",
         "followers": "followers",
         "following": "following"
-    }
+    },
+    "readOnly": true
 } 

platforms/cerberus/src/web3adapter/mappings/user.mapping.json

@@ -0,0 +1,162 @@
+import { Request, Response } from "express";
+import { GroupService } from "../services/GroupService";
+import { AppDataSource } from "../database/data-source";
+import { User } from "../database/entities/User";
+
+export class GroupController {
+    private groupService: GroupService;
+    private userRepository = AppDataSource.getRepository(User);
+
+    constructor() {
+        this.groupService = new GroupService();
+    }
+
+    // Create a new group
+    createGroup = async (req: Request, res: Response) => {
+        try {
+            const { name, description, memberIds, adminIds, isPrivate, visibility, avatarUrl, bannerUrl } = req.body;
+            
+            if (!name) {
+                return res.status(400).json({ error: "Group name is required" });
+            }
+
+            const group = await this.groupService.createGroup(
+                name,
+                description,
+                memberIds || [],
+                adminIds || [],
+                isPrivate || false,
+                visibility || "public",
+                avatarUrl,
+                bannerUrl
+            );
+
+            res.status(201).json(group);
+        } catch (error) {
+            console.error("Error creating group:", error);
+            res.status(500).json({ error: "Failed to create group" });
+        }
+    };
+
+    // Get group by ID
+    getGroupById = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const group = await this.groupService.getGroupById(id);
+            
+            if (!group) {
+                return res.status(404).json({ error: "Group not found" });
+            }
+
+            res.json(group);
+        } catch (error) {
+            console.error("Error getting group:", error);
+            res.status(500).json({ error: "Failed to get group" });
+        }
+    };
+
+    // Update group
+    updateGroup = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const updates = req.body;
+            
+            const group = await this.groupService.updateGroup(id, updates);
+            res.json(group);
+        } catch (error) {
+            console.error("Error updating group:", error);
+            res.status(500).json({ error: "Failed to update group" });
+        }
+    };
+
+    // Delete group
+    deleteGroup = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            await this.groupService.deleteGroup(id);
+            res.status(204).send();
+        } catch (error) {
+            console.error("Error deleting group:", error);
+            res.status(500).json({ error: "Failed to delete group" });
+        }
+    };
+
+    // Get user's groups
+    getUserGroups = async (req: Request, res: Response) => {
+        try {
+            const { userId } = req.params;
+            const { page = 1, limit = 10 } = req.query;
+            
+            const result = await this.groupService.getUserGroups(
+                userId,
+                parseInt(page as string),
+                parseInt(limit as string)
+            );
+            
+            res.json(result);
+        } catch (error) {
+            console.error("Error getting user groups:", error);
+            res.status(500).json({ error: "Failed to get user groups" });
+        }
+    };
+
+    // Add members to group
+    addMembers = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const { memberIds } = req.body;
+            
+            if (!Array.isArray(memberIds)) {
+                return res.status(400).json({ error: "memberIds must be an array" });
+            }
+
+            const group = await this.groupService.addMembers(id, memberIds);
+            res.json(group);
+        } catch (error) {
+            console.error("Error adding members:", error);
+            res.status(500).json({ error: "Failed to add members" });
+        }
+    };
+
+    // Remove member from group
+    removeMember = async (req: Request, res: Response) => {
+        try {
+            const { id, userId } = req.params;
+            const group = await this.groupService.removeMember(id, userId);
+            res.json(group);
+        } catch (error) {
+            console.error("Error removing member:", error);
+            res.status(500).json({ error: "Failed to remove member" });
+        }
+    };
+
+    // Add admins to group
+    addAdmins = async (req: Request, res: Response) => {
+        try {
+            const { id } = req.params;
+            const { adminIds } = req.body;
+            
+            if (!Array.isArray(adminIds)) {
+                return res.status(400).json({ error: "adminIds must be an array" });
+            }
+
+            const group = await this.groupService.addAdmins(id, adminIds);
+            res.json(group);
+        } catch (error) {
+            console.error("Error adding admins:", error);
+            res.status(500).json({ error: "Failed to add admins" });
+        }
+    };
+
+    // Remove admin from group
+    removeAdmin = async (req: Request, res: Response) => {
+        try {
+            const { id, userId } = req.params;
+            const group = await this.groupService.removeAdmin(id, userId);
+            res.json(group);
+        } catch (error) {
+            console.error("Error removing admin:", error);
+            res.status(500).json({ error: "Failed to remove admin" });
+        }
+    };
+} 

platforms/evoting-api/src/controllers/GroupController.ts

@@ -0,0 +1,65 @@
+import {
+    Entity,
+    CreateDateColumn,
+    UpdateDateColumn,
+    PrimaryGeneratedColumn,
+    Column,
+    ManyToMany,
+    JoinTable,
+} from "typeorm";
+import { User } from "./User";
+
+@Entity()
+export class Group {
+    @PrimaryGeneratedColumn("uuid")
+    id!: string;
+
+    @Column({ nullable: true })
+    name!: string;
+
+    @Column({ nullable: true })
+    description!: string;
+
+    @Column({ nullable: true })
+    owner!: string;
+
+    @Column("simple-array", { nullable: true })
+    admins!: string[];
+
+    @Column({ type: "text", nullable: true })
+    charter!: string; // Markdown content for the group charter
+
+    @Column({ default: false })
+    isPrivate!: boolean;
+
+    @Column({ default: "public" })
+    visibility!: "public" | "private" | "restricted";
+
+    @ManyToMany(() => User)
+    @JoinTable({
+        name: "group_members",
+        joinColumn: { name: "group_id", referencedColumnName: "id" },
+        inverseJoinColumn: { name: "user_id", referencedColumnName: "id" }
+    })
+    members!: User[];
+
+    @ManyToMany(() => User)
+    @JoinTable({
+        name: "group_participants",
+        joinColumn: { name: "group_id", referencedColumnName: "id" },
+        inverseJoinColumn: { name: "user_id", referencedColumnName: "id" }
+    })
+    participants!: User[];
+
+    @Column({ nullable: true })
+    avatarUrl!: string;
+
+    @Column({ nullable: true })
+    bannerUrl!: string;
+
+    @CreateDateColumn()
+    createdAt!: Date;
+
+    @UpdateDateColumn()
+    updatedAt!: Date;
+} 

platforms/evoting-api/src/database/entities/Group.ts

@@ -5,6 +5,8 @@ import {
     CreateDateColumn,
     UpdateDateColumn,
     OneToMany,
+    ManyToMany,
+    JoinTable,
 } from "typeorm";
 import { Poll } from "./Poll";
 import { Vote } from "./Vote";
@@ -50,6 +52,22 @@ export class User {
     @OneToMany(() => Vote, (vote) => vote.user)
     votes!: Vote[];
 
+    @ManyToMany(() => User)
+    @JoinTable({
+        name: "user_followers",
+        joinColumn: { name: "user_id", referencedColumnName: "id" },
+        inverseJoinColumn: { name: "follower_id", referencedColumnName: "id" },
+    })
+    followers!: User[];
+
+    @ManyToMany(() => User)
+    @JoinTable({
+        name: "user_following",
+        joinColumn: { name: "user_id", referencedColumnName: "id" },
+        inverseJoinColumn: { name: "following_id", referencedColumnName: "id" },
+    })
+    following!: User[];
+
     @CreateDateColumn()
     createdAt!: Date;