@hed-hog/core 0.0.387 → 0.0.393

package/src/pdf/pdf.service.ts

@@ -1,6 +1,7 @@
 import { Inject, Injectable, InternalServerErrorException, Logger, forwardRef } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 
+import { BrandAssetService } from '../setting/brand-asset.service';
 import { SettingService } from '../setting/setting.service';
 import { PdfAreaType, PdfThemeConfig } from './interfaces/pdf-theme-config.interface';
 import { hcodeInstitutionalTemplate } from './templates/hcode-institutional.template';
@@ -43,6 +44,8 @@ export class PdfService {
   constructor(
     @Inject(forwardRef(() => SettingService))
     private readonly settingService: SettingService,
+    @Inject(forwardRef(() => BrandAssetService))
+    private readonly brandAsset: BrandAssetService,
     private readonly configService: ConfigService,
   ) {}
 
@@ -87,7 +90,9 @@ export class PdfService {
         (values['pdf-logo'] as string) ||
         (values['image-url'] as string) ||
         '';
-      const logoOverride = rawLogoUrl ? this.resolveUrl(rawLogoUrl) : '';
+      const logoOverride = rawLogoUrl
+        ? await this.brandAsset.resolveAssetUrl(rawLogoUrl)
+        : '';
 
       return {
         area,
@@ -115,29 +120,6 @@ export class PdfService {
     }
   }
 
-  /**
-   * Resolves a potentially relative URL (e.g. /logo.svg) to an absolute URL
-   * using the API base URL derived from environment variables.
-   */
-  private resolveUrl(url: string): string {
-    if (!url) return '';
-    if (
-      url.startsWith('data:') ||
-      url.startsWith('http://') ||
-      url.startsWith('https://')
-    ) {
-      return url;
-    }
-    const port = this.configService.get<string | number>('PORT') ?? 3100;
-    const baseUrl =
-      this.configService.get<string>('API_URL') ??
-      `http://localhost:${port}`;
-    return (
-      baseUrl.replace(/\/$/, '') +
-      (url.startsWith('/') ? url : '/' + url)
-    );
-  }
-
   // ── HTML → PDF ────────────────────────────────────────────────────────────
 
   /**
@@ -229,6 +211,81 @@ export class PdfService {
     }
   }
 
+  // ── HTML → PNG image ──────────────────────────────────────────────────────
+
+  /**
+   * Renders an HTML string to a PNG image buffer via a Playwright/Chromium
+   * screenshot. Shares the same layout contract as {@link generatePdfFromHtml}
+   * (the viewport matches `width`/`height`), so the image is a pixel-faithful
+   * preview of what the PDF would produce for the same HTML — used for
+   * certificate thumbnails on the web/app.
+   */
+  async generateImageFromHtml(html: string, options: PdfGenerateOptions = {}): Promise<Buffer> {
+    const executablePath = this.configService.get<string>('CHROMIUM_EXECUTABLE_PATH');
+    const noSandbox = this.configService.get<string>('CHROMIUM_NO_SANDBOX') === 'true';
+
+    const launchArgs = noSandbox
+      ? ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+      : [];
+
+    const width = parsePxSize(options.width, 794);
+    const height = parsePxSize(options.height, 1123);
+
+    let browser: any = null;
+
+    try {
+      const importPlaywright = new Function(
+        'moduleName',
+        'return import(moduleName);',
+      ) as (moduleName: string) => Promise<any>;
+
+      const playwright = await importPlaywright('playwright');
+
+      browser = await playwright.chromium.launch({
+        headless: true,
+        ...(executablePath ? { executablePath } : {}),
+        args: launchArgs,
+      });
+
+      const page = await browser.newPage();
+      await page.setViewportSize({ width, height });
+      await page.setContent(html, { waitUntil: 'networkidle' });
+
+      const imageBuffer = await page.screenshot({
+        type: 'png',
+        clip: { x: 0, y: 0, width, height },
+      });
+
+      return Buffer.from(imageBuffer);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errorStack = error instanceof Error ? (error.stack ?? errorMessage) : String(error);
+
+      const missingRuntime =
+        /Cannot find package ['"]playwright['"]|Cannot find module ['"]playwright['"]|Executable doesn't exist|browserType\.launch|Failed to launch|Please run the following command/i.test(
+          errorMessage,
+        );
+
+      this.logger.error(`Image generation failed. ${errorMessage}`, errorStack);
+
+      if (missingRuntime) {
+        throw new InternalServerErrorException(
+          'Playwright runtime is not available. Run `pnpm --filter api run playwright:install` in the API environment.',
+        );
+      }
+
+      throw new InternalServerErrorException(`Image generation failed: ${errorMessage}`);
+    } finally {
+      if (browser) {
+        try {
+          await browser.close();
+        } catch {
+          // Ignore close errors
+        }
+      }
+    }
+  }
+
   // ── Template engine ───────────────────────────────────────────────────────
 
   /**

package/src/presence/presence.controller.ts

@@ -0,0 +1,29 @@
+import { User } from '@hed-hog/api';
+import { Controller, Get, Post, Query } from '@nestjs/common';
+import { PresenceService } from './presence.service';
+
+/**
+ * Presence endpoints — authenticated (no @Role): any signed-in user may send
+ * their own heartbeat and read presence for a set of users.
+ */
+@Controller('presence')
+export class PresenceController {
+  constructor(private readonly presence: PresenceService) {}
+
+  /** Browser heartbeat: marks the signed-in user as online in the app. */
+  @Post('heartbeat')
+  async heartbeat(@User() user: any) {
+    await this.presence.heartbeat(Number(user?.id) || 0);
+    return { ok: true };
+  }
+
+  /** Combined presence for `userIds` (comma-separated). */
+  @Get()
+  async getStatuses(@Query('userIds') userIds?: string) {
+    const ids = String(userIds ?? '')
+      .split(',')
+      .map((s) => Number(s.trim()))
+      .filter((n) => Number.isInteger(n) && n > 0);
+    return this.presence.getStatuses(ids);
+  }
+}

package/src/presence/presence.listener.ts

@@ -0,0 +1,53 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+import { Cron } from '@nestjs/schedule';
+import { RealtimeService } from '../realtime/realtime.service';
+import { REALTIME_EVENTS } from '../realtime/realtime.gateway';
+import { PresenceService } from './presence.service';
+
+/**
+ * Bridges the generic realtime layer to presence: a live socket IS the app
+ * heartbeat. On (first) connect the user goes online and the change is pushed;
+ * while connected, a cron keeps the heartbeat fresh (so it never lapses under
+ * the 60s window); on disconnect the new status is pushed.
+ */
+@Injectable()
+export class PresenceListener {
+  private readonly logger = new Logger(PresenceListener.name);
+
+  constructor(
+    private readonly presence: PresenceService,
+    private readonly realtime: RealtimeService,
+  ) {}
+
+  @OnEvent(REALTIME_EVENTS.userConnected)
+  async onConnected(payload: { userId: number; firstConnection: boolean }) {
+    await this.presence.heartbeat(payload.userId);
+    // Only push when the user actually transitioned to online (first socket).
+    if (payload.firstConnection) {
+      await this.presence.pushStatus(payload.userId).catch(() => undefined);
+    }
+  }
+
+  @OnEvent(REALTIME_EVENTS.userDisconnected)
+  async onDisconnected(payload: { userId: number; remainingLocalSockets: number }) {
+    // Recompute/push; if the user still has sockets elsewhere the heartbeat keeps
+    // them online, otherwise they go offline once the heartbeat window elapses.
+    if (payload.remainingLocalSockets === 0) {
+      await this.presence.pushStatus(payload.userId).catch(() => undefined);
+    }
+  }
+
+  /**
+   * Keeps the app heartbeat fresh for every locally-connected user. A connected
+   * socket must stay "online" past the 60s heartbeat window, so refresh every
+   * 30s. Silent (no push) — nothing changed.
+   */
+  @Cron('*/30 * * * * *')
+  async refreshHeartbeats() {
+    const userIds = this.realtime.getLocallyConnectedUserIds();
+    for (const userId of userIds) {
+      await this.presence.heartbeat(userId).catch(() => undefined);
+    }
+  }
+}

package/src/presence/presence.module.ts

@@ -0,0 +1,19 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { RealtimeModule } from '../realtime/realtime.module';
+import { SettingModule } from '../setting/setting.module';
+import { PresenceController } from './presence.controller';
+import { PresenceListener } from './presence.listener';
+import { PresenceService } from './presence.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => RealtimeModule),
+  ],
+  controllers: [PresenceController],
+  providers: [PresenceService, PresenceListener],
+  exports: [PresenceService],
+})
+export class PresenceModule {}

package/src/presence/presence.service.spec.ts

@@ -0,0 +1,97 @@
+import { beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { PresenceService } from './presence.service';
+
+const makeDeps = () => ({
+  prisma: { user_presence: { findMany: jest.fn(), upsert: jest.fn() } },
+  setting: { getSettingValues: jest.fn() },
+  realtime: { emitToChannel: jest.fn() },
+});
+
+const makeService = (deps = makeDeps()) => ({
+  service: new PresenceService(
+    deps.prisma as any,
+    deps.setting as any,
+    deps.realtime as any,
+  ),
+  deps,
+});
+
+const minutesAgo = (m: number) => new Date(Date.now() - m * 60 * 1000);
+const secondsAgo = (s: number) => new Date(Date.now() - s * 1000);
+
+describe('PresenceService.getStatuses', () => {
+  let deps: ReturnType<typeof makeDeps>;
+  let service: PresenceService;
+
+  beforeEach(() => {
+    const built = makeService();
+    deps = built.deps;
+    service = built.service;
+    // Teams enabled by default.
+    deps.setting.getSettingValues.mockResolvedValue({
+      'oauth-microsoft-entra-id-enabled': 'true',
+    } as any);
+  });
+
+  it('marks a user online from a recent app heartbeat', async () => {
+    deps.prisma.user_presence.findMany.mockResolvedValue([
+      { user_id: 1, last_heartbeat_at: secondsAgo(10), teams_availability: null, teams_updated_at: null },
+    ] as any);
+
+    const map = await service.getStatuses([1]);
+    expect(map[1]).toMatchObject({ online: true, appOnline: true, teamsOnline: false, source: 'app' });
+  });
+
+  it('marks a user online from a fresh Teams "Available" presence', async () => {
+    deps.prisma.user_presence.findMany.mockResolvedValue([
+      { user_id: 2, last_heartbeat_at: minutesAgo(30), teams_availability: 'Available', teams_updated_at: minutesAgo(1) },
+    ] as any);
+
+    const map = await service.getStatuses([2]);
+    expect(map[2]).toMatchObject({ online: true, appOnline: false, teamsOnline: true, source: 'teams' });
+    expect(map[2].teamsAvailability).toBe('Available');
+  });
+
+  it('reports source "both" when app + Teams are online', async () => {
+    deps.prisma.user_presence.findMany.mockResolvedValue([
+      { user_id: 3, last_heartbeat_at: secondsAgo(5), teams_availability: 'Busy', teams_updated_at: secondsAgo(30) },
+    ] as any);
+
+    const map = await service.getStatuses([3]);
+    expect(map[3]).toMatchObject({ online: true, source: 'both' });
+  });
+
+  it('ignores Teams presence when the integration is disabled', async () => {
+    deps.setting.getSettingValues.mockResolvedValue({ 'oauth-microsoft-entra-id-enabled': 'false' } as any);
+    deps.prisma.user_presence.findMany.mockResolvedValue([
+      { user_id: 4, last_heartbeat_at: minutesAgo(30), teams_availability: 'Available', teams_updated_at: minutesAgo(1) },
+    ] as any);
+
+    const map = await service.getStatuses([4]);
+    expect(map[4]).toMatchObject({ online: false, teamsOnline: false, source: 'offline' });
+    expect(map[4].teamsAvailability).toBeNull();
+  });
+
+  it('ignores a stale Teams presence and an Offline availability', async () => {
+    deps.prisma.user_presence.findMany.mockResolvedValue([
+      { user_id: 5, last_heartbeat_at: minutesAgo(30), teams_availability: 'Available', teams_updated_at: minutesAgo(90) },
+      { user_id: 6, last_heartbeat_at: minutesAgo(30), teams_availability: 'Offline', teams_updated_at: minutesAgo(1) },
+    ] as any);
+
+    const map = await service.getStatuses([5, 6]);
+    expect(map[5].online).toBe(false); // stale teams
+    expect(map[6].online).toBe(false); // offline availability
+  });
+
+  it('treats unknown users as offline', async () => {
+    deps.prisma.user_presence.findMany.mockResolvedValue([] as any);
+    const map = await service.getStatuses([7]);
+    expect(map[7]).toMatchObject({ online: false, source: 'offline' });
+  });
+
+  it('returns empty without querying for an empty id list', async () => {
+    const map = await service.getStatuses([]);
+    expect(map).toEqual({});
+    expect(deps.prisma.user_presence.findMany).not.toHaveBeenCalled();
+  });
+});

package/src/presence/presence.service.ts

@@ -0,0 +1,160 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { RealtimeService } from '../realtime/realtime.service';
+import { SettingService } from '../setting/setting.service';
+
+/** A heartbeat within this window counts the user as "online in the app". */
+const APP_WINDOW_MS = 60 * 1000;
+/** Ignore a Teams presence older than this (e.g. subscription lapsed). */
+const TEAMS_STALE_MS = 30 * 60 * 1000;
+/** Teams availabilities that do NOT count as present. */
+const TEAMS_OFFLINE = new Set(['Offline', 'PresenceUnknown', 'OutOfOffice']);
+
+export type PresenceSource = 'app' | 'teams' | 'both' | 'offline';
+
+export interface PresenceStatus {
+  userId: number;
+  /** Combined online = app heartbeat OR (Teams enabled AND Teams present). */
+  online: boolean;
+  appOnline: boolean;
+  teamsOnline: boolean;
+  /** Raw Teams availability (Available/Busy/Away/...), when known. */
+  teamsAvailability: string | null;
+  source: PresenceSource;
+}
+
+/**
+ * Unified user presence: the real-time app signal (a browser heartbeat) merged
+ * with Microsoft Teams presence. Teams only contributes when the Entra ID /
+ * Teams integration is enabled — so a user shows online if they're actively
+ * using this app OR are present in Teams.
+ *
+ * App presence is heartbeat-based (the browser pings while the tab is open), not
+ * activity-log-based, so it reflects "has the app open now", and it is shared
+ * across API instances via the `user_presence` table.
+ */
+@Injectable()
+export class PresenceService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => SettingService))
+    private readonly setting: SettingService,
+    @Inject(forwardRef(() => RealtimeService))
+    private readonly realtime: RealtimeService,
+  ) {}
+
+  /** Channel clients subscribe to for a given user's presence. */
+  static presenceChannel(userId: number): string {
+    return `presence:${userId}`;
+  }
+
+  /** Computes and pushes the current presence of a user to its subscribers. */
+  async pushStatus(userId: number): Promise<void> {
+    if (!userId) return;
+    const statuses = await this.getStatuses([userId]);
+    this.realtime.emitToChannel(
+      PresenceService.presenceChannel(userId),
+      'presence:update',
+      statuses[userId],
+    );
+  }
+
+  /** Records an app heartbeat for the user (browser is open/active). */
+  async heartbeat(userId: number): Promise<void> {
+    if (!userId) return;
+    const now = new Date();
+    await this.prisma.user_presence.upsert({
+      where: { user_id: userId },
+      create: { user_id: userId, last_heartbeat_at: now },
+      update: { last_heartbeat_at: now },
+    });
+  }
+
+  /** Stores the latest Microsoft Teams presence (called by the Graph processor). */
+  async setTeamsPresence(
+    userId: number,
+    availability: string | null,
+    activity: string | null,
+  ): Promise<void> {
+    if (!userId) return;
+    const now = new Date();
+    await this.prisma.user_presence.upsert({
+      where: { user_id: userId },
+      create: {
+        user_id: userId,
+        teams_availability: availability,
+        teams_activity: activity,
+        teams_updated_at: now,
+      },
+      update: {
+        teams_availability: availability,
+        teams_activity: activity,
+        teams_updated_at: now,
+      },
+    });
+    // Teams presence changed → push to subscribers in real time.
+    await this.pushStatus(userId);
+  }
+
+  private async isTeamsEnabled(): Promise<boolean> {
+    const settings = await this.setting.getSettingValues([
+      'oauth-microsoft-entra-id-enabled',
+    ]);
+    const v = settings['oauth-microsoft-entra-id-enabled'];
+    return v === true || v === 'true';
+  }
+
+  /** Resolves the combined presence for a set of users. */
+  async getStatuses(
+    userIds: number[],
+  ): Promise<Record<number, PresenceStatus>> {
+    const ids = [...new Set(userIds.filter((id) => Number.isInteger(id) && id > 0))];
+    const result: Record<number, PresenceStatus> = {};
+    if (ids.length === 0) return result;
+
+    const [rows, teamsEnabled] = await Promise.all([
+      this.prisma.user_presence.findMany({ where: { user_id: { in: ids } } }),
+      this.isTeamsEnabled(),
+    ]);
+    const byUser = new Map(rows.map((r) => [r.user_id, r]));
+    const now = Date.now();
+
+    for (const userId of ids) {
+      const row = byUser.get(userId);
+      const appOnline =
+        !!row?.last_heartbeat_at &&
+        now - row.last_heartbeat_at.getTime() < APP_WINDOW_MS;
+
+      const teamsFresh =
+        !!row?.teams_updated_at &&
+        now - row.teams_updated_at.getTime() < TEAMS_STALE_MS;
+      const teamsOnline =
+        teamsEnabled &&
+        teamsFresh &&
+        !!row?.teams_availability &&
+        !TEAMS_OFFLINE.has(row.teams_availability);
+
+      const online = appOnline || teamsOnline;
+      const source: PresenceSource =
+        appOnline && teamsOnline
+          ? 'both'
+          : appOnline
+            ? 'app'
+            : teamsOnline
+              ? 'teams'
+              : 'offline';
+
+      result[userId] = {
+        userId,
+        online,
+        appOnline,
+        teamsOnline,
+        teamsAvailability:
+          teamsEnabled && teamsFresh ? (row?.teams_availability ?? null) : null,
+        source,
+      };
+    }
+    return result;
+  }
+}

package/src/profile/dto/delete-account.dto.ts

@@ -0,0 +1,11 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class DeleteAccountDto {
+  /**
+   * Senha atual. Obrigatória para contas que têm senha; contas criadas
+   * apenas por login social (OAuth) não possuem credencial e podem omitir.
+   */
+  @IsOptional()
+  @IsString()
+  password?: string;
+}

package/src/profile/events/profile-account-deleted.event.ts

@@ -0,0 +1,13 @@
+export const PROFILE_ACCOUNT_DELETED = 'profile.account.deleted';
+
+/**
+ * Emitido depois que o core anonimiza a identidade do usuário.
+ * Cada library reage removendo/anonimizando o que é dela (assinaturas,
+ * progresso, mensagens), sem que o core precise conhecê-las.
+ */
+export class ProfileAccountDeletedEvent {
+  constructor(
+    public readonly userId: number,
+    public readonly deletedAt: Date,
+  ) {}
+}