fix: ereputation erefernce (#943)

* fix: ereputation erefernce

* fix: erep build script

* fix: ename dedupe

* fix: strip `@`

Author: coodos

platforms/cerberus/client/src/services/ReferenceWriterService.ts

@@ -86,6 +86,7 @@ export class ReferenceWriterService {
                     targetType: "user",
                     targetId: violation.targetId,
                     targetName: violation.targetName,
+                    targetEname: violation.targetEname,
                     content: violation.content,
                     referenceType: "violation",
                     numericScore: violation.numericScore,

platforms/ereputation/api/package.json

@@ -6,7 +6,7 @@
     "scripts": {
         "start": "ts-node --project tsconfig.json src/index.ts",
         "dev": "nodemon --exec \"npx ts-node\" src/index.ts",
-        "build": "tsc",
+        "build": "tsc && cp -r src/web3adapter/mappings dist/web3adapter/",
         "typeorm": "typeorm-ts-node-commonjs",
         "migration:generate": "bash -c 'read -p \"Migration name: \" name && npx typeorm-ts-node-commonjs migration:generate src/database/migrations/$name -d src/database/data-source.ts'",
         "migration:run": "typeorm-ts-node-commonjs migration:run -d src/database/data-source.ts",

platforms/ereputation/api/src/controllers/ReferenceController.ts

@@ -1,8 +1,12 @@
 import { Request, Response } from "express";
+import { AppDataSource } from "../database/data-source";
+import { User } from "../database/entities/User";
 import { ReferenceService } from "../services/ReferenceService";
 import { ReferenceSigningSessionService } from "../services/ReferenceSigningSessionService";
 import { authGuard } from "../middleware/auth";
 
+const SYSTEM_AUTHOR_NAME = "Cerberus Platform";
+
 export class ReferenceController {
     private referenceService: ReferenceService;
     private signingSessionService: ReferenceSigningSessionService;
@@ -307,25 +311,51 @@ export class ReferenceController {
                 return res.status(401).json({ error: "Unauthorized" });
             }
 
-            const { targetType, targetId, targetName, content, referenceType, numericScore, authorId, anonymous } = req.body;
+            const { targetType, targetId, targetName, targetEname, content, referenceType, numericScore, anonymous } = req.body;
 
-            if (!targetType || !targetId || !targetName || !content || !authorId) {
-                return res.status(400).json({ error: "Missing required fields: targetType, targetId, targetName, content, authorId" });
+            if (!targetType || !targetName || !content) {
+                return res.status(400).json({ error: "Missing required fields: targetType, targetName, content" });
             }
 
             if (numericScore && (numericScore < 1 || numericScore > 5)) {
                 return res.status(400).json({ error: "Numeric score must be between 1 and 5" });
             }
 
+            // Resolve the system author — use the "Cerberus Platform" user
+            const userRepo = AppDataSource.getRepository(User);
+            let systemUser = await userRepo.findOneBy({ name: SYSTEM_AUTHOR_NAME });
+            if (!systemUser) {
+                systemUser = userRepo.create({ name: SYSTEM_AUTHOR_NAME, handle: "cerberus" });
+                systemUser = await userRepo.save(systemUser);
+                console.log(`[erep] Created system user "${SYSTEM_AUTHOR_NAME}" id=${systemUser.id}`);
+            }
+
+            // Resolve the target user by ename to get the correct local eReputation user ID.
+            // Cross-platform calls (e.g. from Cerberus) send their own DB user ID which
+            // won't match eReputation's user ID — ename is the shared identifier.
+            let resolvedTargetId = targetId;
+            if (targetEname && targetType === "user") {
+                // Try both with and without @ prefix
+                const cleanEname = targetEname.replace(/^@/, "");
+                const targetUser = await userRepo.findOneBy({ ename: cleanEname })
+                    ?? await userRepo.findOneBy({ ename: `@${cleanEname}` });
+                if (targetUser) {
+                    resolvedTargetId = targetUser.id;
+                    console.log(`[erep] Resolved target ename=${targetEname} to local id=${targetUser.id}`);
+                } else {
+                    console.warn(`[erep] Could not resolve target ename=${targetEname}, using provided targetId=${targetId}`);
+                }
+            }
+
             // Create reference directly with "signed" status (trusted platform call)
             const reference = this.referenceService.referenceRepository.create({
                 targetType,
-                targetId,
+                targetId: resolvedTargetId,
                 targetName,
                 content,
                 referenceType: referenceType || "violation",
                 numericScore,
-                authorId,
+                authorId: systemUser.id,
                 anonymous: anonymous ?? false,
                 status: "signed"
             });