tychat-contracts 1.6.52 → 1.6.56

package/src/legal-terms/legal-term-document-compile.ts

@@ -0,0 +1,192 @@
+import type {
+  LegalTermDocument,
+  LegalTermDocumentBlock,
+  LegalTermSectionLevel,
+  LegalTermTextAlign,
+} from './legal-term-document.types';
+
+type TextStyleOpts = {
+  align?: LegalTermTextAlign;
+  bold?: boolean;
+  italic?: boolean;
+  underline?: boolean;
+};
+
+function escapeHtmlText(s: string): string {
+  return s
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+function cssTextStyle(opts: TextStyleOpts, defaults: TextStyleOpts = {}): string {
+  const align = opts.align ?? defaults.align ?? 'left';
+  const bold = opts.bold ?? defaults.bold ?? false;
+  const italic = opts.italic ?? defaults.italic ?? false;
+  const underline = opts.underline ?? defaults.underline ?? false;
+  const parts = [`text-align:${align}`];
+  if (bold) parts.push('font-weight:700');
+  if (italic) parts.push('font-style:italic');
+  if (underline) parts.push('text-decoration:underline');
+  return parts.join(';');
+}
+
+function textToHtmlParagraphs(text: string, opts: TextStyleOpts = {}): string {
+  const trimmed = text.trim();
+  if (!trimmed) return '';
+  const style = cssTextStyle(opts, { align: 'left' });
+  const lines = trimmed.split(/\r?\n/);
+  return lines
+    .map((line) => {
+      const t = line.trim();
+      if (!t) return '<br/>';
+      return `<p style="margin:0.4em 0;line-height:1.45;${style}">${escapeHtmlText(t)}</p>`;
+    })
+    .join('');
+}
+
+function formatSectionNumber(counters: [number, number, number], level: LegalTermSectionLevel): string {
+  if (level === 1) return `${counters[0]}.`;
+  if (level === 2) return `${counters[0]}.${counters[1]}.`;
+  return `${counters[0]}.${counters[1]}.${counters[2]}.`;
+}
+
+function bumpSectionCounters(
+  counters: [number, number, number],
+  level: LegalTermSectionLevel,
+): [number, number, number] {
+  const next: [number, number, number] = [...counters] as [number, number, number];
+  if (level === 1) {
+    next[0] += 1;
+    next[1] = 0;
+    next[2] = 0;
+  } else if (level === 2) {
+    next[1] += 1;
+    next[2] = 0;
+  } else {
+    next[2] += 1;
+  }
+  return next;
+}
+
+function compileBlock(block: LegalTermDocumentBlock, sectionCounters: [number, number, number]): {
+  html: string;
+  counters: [number, number, number];
+} {
+  let counters = sectionCounters;
+  const wrap = (inner: string, extraStyle = '') =>
+    `<div class="legal-term-block" data-block-type="${block.type}" style="margin-bottom:0.75em;${extraStyle}">${inner}</div>`;
+
+  switch (block.type) {
+    case 'document_title': {
+      const title = (block.title ?? block.body ?? '').trim();
+      const style = cssTextStyle(
+        {
+          align: block.titleAlign,
+          bold: block.titleBold,
+          italic: block.titleItalic,
+          underline: block.titleUnderline,
+        },
+        { align: 'center', bold: true },
+      );
+      const inner = title
+        ? `<h1 style="font-size:1.25em;margin:0 0 0.5em;${style}">${escapeHtmlText(title)}</h1>`
+        : '';
+      return { html: wrap(inner), counters };
+    }
+    case 'legal_reference': {
+      const ref = (block.body ?? block.title ?? '').trim();
+      const inner = ref
+        ? textToHtmlParagraphs(ref, {
+            align: block.bodyAlign ?? 'center',
+            bold: block.bodyBold,
+            italic: block.bodyItalic,
+            underline: block.bodyUnderline,
+          })
+        : '';
+      return { html: wrap(inner), counters };
+    }
+    case 'section': {
+      const level: LegalTermSectionLevel = block.level === 2 || block.level === 3 ? block.level : 1;
+      counters = bumpSectionCounters(counters, level);
+      const num = formatSectionNumber(counters, level);
+      const title = (block.title ?? '').trim();
+      const titleStyle = cssTextStyle(
+        {
+          align: block.titleAlign,
+          bold: block.titleBold,
+          italic: block.titleItalic,
+          underline: block.titleUnderline,
+        },
+        { align: 'left', bold: true },
+      );
+      const bodyHtml = textToHtmlParagraphs(block.body ?? '', {
+        align: block.bodyAlign,
+        bold: block.bodyBold,
+        italic: block.bodyItalic,
+        underline: block.bodyUnderline,
+      });
+      const heading = title
+        ? `<h2 style="font-size:${level === 1 ? '1.05em' : '1em'};margin:0.75em 0 0.35em;${titleStyle}">${escapeHtmlText(`${num} ${title}`)}</h2>`
+        : '';
+      return { html: wrap(`${heading}${bodyHtml}`), counters };
+    }
+    case 'paragraph': {
+      return {
+        html: wrap(
+          textToHtmlParagraphs(block.body ?? '', {
+            align: block.bodyAlign,
+            bold: block.bodyBold,
+            italic: block.bodyItalic,
+            underline: block.bodyUnderline,
+          }),
+        ),
+        counters,
+      };
+    }
+    case 'table_side_effects': {
+      const intro = textToHtmlParagraphs(block.body ?? '', {
+        align: block.bodyAlign,
+        bold: block.bodyBold,
+        italic: block.bodyItalic,
+        underline: block.bodyUnderline,
+      });
+      const token = '<p>{{ table_side_effects_en_list }}</p>';
+      return { html: wrap(`${intro}${token}`), counters };
+    }
+    case 'signature_footer': {
+      return {
+        html: wrap(
+          textToHtmlParagraphs(block.body ?? '', {
+            align: block.bodyAlign ?? 'left',
+            bold: block.bodyBold,
+            italic: block.bodyItalic,
+            underline: block.bodyUnderline,
+          }),
+          'page-break-inside:avoid;margin-top:1.5em;padding-top:0.5em;border-top:1px solid #ddd',
+        ),
+        counters,
+      };
+    }
+    default:
+      return { html: '', counters };
+  }
+}
+
+export function compileLegalTermDocumentToHtml(document: LegalTermDocument): string {
+  if (!document?.blocks?.length) {
+    return '<p></p>';
+  }
+  let sectionCounters: [number, number, number] = [0, 0, 0];
+  const parts: string[] = [
+    '<div class="legal-term-document" style="font-family:Roboto,Helvetica,Arial,sans-serif;font-size:11pt;color:#111">',
+  ];
+  for (const block of document.blocks) {
+    const { html, counters } = compileBlock(block, sectionCounters);
+    sectionCounters = counters;
+    if (html) parts.push(html);
+  }
+  parts.push('</div>');
+  return parts.join('').trim() || '<p></p>';
+}

package/src/legal-terms/legal-term-document.dto.ts

@@ -0,0 +1,100 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsIn,
+  IsInt,
+  IsOptional,
+  IsString,
+  Max,
+  MaxLength,
+  Min,
+  MinLength,
+  ValidateNested,
+} from 'class-validator';
+import {
+  LEGAL_TERM_BLOCK_TYPES,
+  LEGAL_TERM_DOCUMENT_VERSION,
+  type LegalTermBlockType,
+  type LegalTermDocument,
+  type LegalTermSectionLevel,
+} from './legal-term-document.types';
+
+export class LegalTermDocumentBlockDto {
+  @ApiProperty({ description: 'Identificador estável do bloco (UUID ou id preset CFM)' })
+  @IsString()
+  @MinLength(1)
+  @MaxLength(64)
+  id: string;
+
+  @ApiProperty({ enum: LEGAL_TERM_BLOCK_TYPES })
+  @IsIn([...LEGAL_TERM_BLOCK_TYPES])
+  type: LegalTermBlockType;
+
+  @ApiPropertyOptional({ enum: [1, 2, 3] })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(3)
+  level?: LegalTermSectionLevel;
+
+  @ApiPropertyOptional({ maxLength: 500 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(500)
+  title?: string;
+
+  @ApiPropertyOptional({ maxLength: 50_000 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(50_000)
+  body?: string;
+
+  @ApiPropertyOptional({ enum: ['left', 'center', 'right'] })
+  @IsOptional()
+  @IsIn(['left', 'center', 'right'])
+  titleAlign?: 'left' | 'center' | 'right';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  titleBold?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  titleItalic?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  titleUnderline?: boolean;
+
+  @ApiPropertyOptional({ enum: ['left', 'center', 'right'] })
+  @IsOptional()
+  @IsIn(['left', 'center', 'right'])
+  bodyAlign?: 'left' | 'center' | 'right';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  bodyBold?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  bodyItalic?: boolean;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  bodyUnderline?: boolean;
+}
+
+export class LegalTermDocumentDto implements LegalTermDocument {
+  @ApiProperty({ enum: [LEGAL_TERM_DOCUMENT_VERSION] })
+  @IsInt()
+  @Min(1)
+  @Max(1)
+  version: 1;
+
+  @ApiProperty({ type: [LegalTermDocumentBlockDto] })
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => LegalTermDocumentBlockDto)
+  blocks: LegalTermDocumentBlockDto[];
+}

package/src/legal-terms/legal-term-document.types.ts

@@ -0,0 +1,42 @@
+/** Blocos do editor visual do termo jurídico (sem HTML do usuário). */
+export const LEGAL_TERM_BLOCK_TYPES = [
+  'document_title',
+  'legal_reference',
+  'section',
+  'paragraph',
+  'table_side_effects',
+  'signature_footer',
+] as const;
+
+export type LegalTermBlockType = (typeof LEGAL_TERM_BLOCK_TYPES)[number];
+
+export type LegalTermSectionLevel = 1 | 2 | 3;
+
+export const LEGAL_TERM_TEXT_ALIGNS = ['left', 'center', 'right'] as const;
+export type LegalTermTextAlign = (typeof LEGAL_TERM_TEXT_ALIGNS)[number];
+
+export type LegalTermDocumentBlock = {
+  id: string;
+  type: LegalTermBlockType;
+  /** Nível de numeração para `section` (1 → 1., 2 → 1.1., 3 → 1.1.1.). */
+  level?: LegalTermSectionLevel;
+  /** Título visível (seção) ou ignorado em tipos sem título. */
+  title?: string;
+  /** Texto com placeholders `{{ token }}`; vazio em blocos só estruturais. */
+  body?: string;
+  titleAlign?: LegalTermTextAlign;
+  titleBold?: boolean;
+  titleItalic?: boolean;
+  titleUnderline?: boolean;
+  bodyAlign?: LegalTermTextAlign;
+  bodyBold?: boolean;
+  bodyItalic?: boolean;
+  bodyUnderline?: boolean;
+};
+
+export type LegalTermDocument = {
+  version: 1;
+  blocks: LegalTermDocumentBlock[];
+};
+
+export const LEGAL_TERM_DOCUMENT_VERSION = 1 as const;

package/src/legal-terms/legal-term-preview.dto.ts

@@ -11,8 +11,11 @@ import {
   MaxLength,
   MinLength,
   ValidateIf,
+  ValidateNested,
 } from 'class-validator';
+import { Type } from 'class-transformer';
 import { LEGAL_TERM_BODY_FORMATS, type LegalTermBodyFormat } from './legal-term-body-format';
+import { LegalTermDocumentDto } from './legal-term-document.dto';
 
 const LEGAL_TERM_SIGNATURE_METHODS = ['digital', 'printed'] as const;
 export type LegalTermSignatureMethodDto = (typeof LEGAL_TERM_SIGNATURE_METHODS)[number];
@@ -20,7 +23,16 @@ export type LegalTermSignatureMethodDto = (typeof LEGAL_TERM_SIGNATURE_METHODS)[
 /** Valores explícitos para substituição na pré-visualização (sem inferência heurística). */
 export class LegalTermPreviewRequestDto {
   @ApiPropertyOptional({
-    description: 'HTML atual do editor (rascunho); se omitido, usa o modelo salvo no banco',
+    description: 'Rascunho do documento visual; se omitido, usa o modelo salvo',
+    type: LegalTermDocumentDto,
+  })
+  @IsOptional()
+  @ValidateNested()
+  @Type(() => LegalTermDocumentDto)
+  body_document?: LegalTermDocumentDto;
+
+  @ApiPropertyOptional({
+    description: 'HTML legado (rascunho); ignorado se body_document for enviado',
     maxLength: 500_000,
   })
   @IsOptional()

package/src/legal-terms/legal-term-template.dto.ts

@@ -1,4 +1,5 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
 import {
   IsArray,
   IsIn,
@@ -7,24 +8,32 @@ import {
   IsUUID,
   MaxLength,
   MinLength,
+  ValidateNested,
 } from 'class-validator';
 import { LEGAL_TERM_BODY_FORMATS, type LegalTermBodyFormat } from './legal-term-body-format';
+import { LegalTermDocumentDto } from './legal-term-document.dto';
 
 export class LegalTermTemplateDto {
   @ApiProperty({ format: 'uuid' })
   id: string;
 
   @ApiProperty({
-    description: 'Conteúdo do modelo (HTML, Markdown ou texto conforme body_format)',
+    description: 'HTML compilado a partir de body_document (cache para PDF)',
   })
   body_html: string;
 
   @ApiProperty({
     enum: LEGAL_TERM_BODY_FORMATS,
-    description: 'Como interpretar body_html antes de gerar PDF',
+    description: 'structured: editor visual; demais formatos legados',
   })
   body_format: LegalTermBodyFormat;
 
+  @ApiProperty({
+    description: 'Documento estruturado do editor visual',
+    type: LegalTermDocumentDto,
+  })
+  body_document: LegalTermDocumentDto;
+
   @ApiProperty({
     type: [String],
     format: 'uuid',
@@ -41,18 +50,25 @@ export class LegalTermTemplateDto {
 
 export class UpsertLegalTermTemplateDto {
   @ApiProperty({
-    description: 'Corpo do termo (HTML, Markdown ou texto puro conforme body_format)',
-    minLength: 1,
+    description: 'Documento do editor visual (obrigatório no fluxo structured)',
+    type: LegalTermDocumentDto,
+  })
+  @ValidateNested()
+  @Type(() => LegalTermDocumentDto)
+  body_document: LegalTermDocumentDto;
+
+  @ApiPropertyOptional({
+    description: 'Ignorado no fluxo structured; servidor compila body_html',
     maxLength: 500_000,
   })
+  @IsOptional()
   @IsString()
-  @MinLength(1)
   @MaxLength(500_000)
-  body_html: string;
+  body_html?: string;
 
   @ApiPropertyOptional({
     enum: LEGAL_TERM_BODY_FORMATS,
-    description: 'Padrão: html',
+    description: 'Padrão: structured',
   })
   @IsOptional()
   @IsIn(LEGAL_TERM_BODY_FORMATS)

package/src/notifications/index.ts

@@ -10,6 +10,7 @@ export {
   TOPIC_NOTIFICATIONS_REGISTER_PUSH_TOKEN,
   TOPIC_NOTIFICATIONS_UNREGISTER_PUSH_TOKEN,
   TOPIC_NOTIFICATIONS_UPDATE_VIEWED,
+  TOPIC_NOTIFICATIONS_MARK_ALL_VIEWED,
   TOPIC_NOTIFICATIONS_SEND_PUSH_TO_USER,
   EVENT_NOTIFICATIONS_ADMIN_BROADCAST_PUSH,
   EVENT_NOTIFICATIONS_CONVERSATION_HANDOFF_PUSH,
@@ -40,3 +41,7 @@ export {
   NotificationsUpdateViewedKafkaDto,
 } from './update-notification-viewed.dto';
 export { NotificationsSendPushToUserKafkaDto } from './notifications-send-push-to-user.dto';
+export {
+  MarkAllNotificationsViewedResultDto,
+  NotificationsMarkAllViewedKafkaDto,
+} from './mark-all-notifications-viewed.dto';

package/src/notifications/mark-all-notifications-viewed.dto.ts

@@ -0,0 +1,33 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsInt, IsNotEmpty, IsString, IsUUID, Min } from 'class-validator';
+
+/**
+ * Resposta HTTP PUT /notifications/mark-all-viewed e RPC `notifications.markAllViewed`.
+ */
+export class MarkAllNotificationsViewedResultDto {
+  @ApiProperty({
+    description: 'Quantidade de notificações atualizadas (viewed_at preenchido).',
+    example: 12,
+    minimum: 0,
+  })
+  @IsInt()
+  @Min(0)
+  updatedCount: number;
+}
+
+/**
+ * Payload RPC `notifications.markAllViewed` (sem body HTTP — só tenant + utilizador).
+ */
+export class NotificationsMarkAllViewedKafkaDto {
+  @ApiProperty({ example: 'default' })
+  @IsString()
+  @IsNotEmpty()
+  tenant: string;
+
+  @ApiProperty({
+    description: 'ID do utilizador (ex.: JWT sub).',
+    format: 'uuid',
+  })
+  @IsUUID('4')
+  userId: string;
+}

package/src/notifications/notifications-kafka-topics.ts

@@ -10,6 +10,9 @@ export const TOPIC_NOTIFICATIONS_UNREGISTER_PUSH_TOKEN =
 /** Kafka request–reply: atualizar visualização de uma notificação persistida. */
 export const TOPIC_NOTIFICATIONS_UPDATE_VIEWED = 'notifications.updateViewed';
 
+/** Kafka request–reply: marcar todas as notificações não visualizadas do utilizador. */
+export const TOPIC_NOTIFICATIONS_MARK_ALL_VIEWED = 'notifications.markAllViewed';
+
 /** RabbitMQ request–reply: enviar push FCM a um utilizador (serviços internos). */
 export const TOPIC_NOTIFICATIONS_SEND_PUSH_TO_USER = 'notifications.sendPushToUser';