Envio — SDKs e API

@Service
public class ConfirmacaoNotifier {

    private static final Logger LOG = LoggerFactory.getLogger(ConfirmacaoNotifier.class);
    private final Optional<NotificationsApi> notificationsApi;

    public ConfirmacaoNotifier(Optional<NotificationsApi> notificationsApi) {
        this.notificationsApi = notificationsApi;
    }

    public void enviar(String email, String nome, String numeroPedido) {
        if (notificationsApi.isEmpty()) {
            LOG.info("Notificações desativadas, confirmação {} não enviada", numeroPedido);
            return;
        }
        TemplateRefDto template = new TemplateRefDto();
        template.setCode("pedido-confirmacao");
        template.setLocale("pt-CV");

        RecipientDto recipient = new RecipientDto();
        recipient.setEmail(email);

        SendNotificationRequest request = new SendNotificationRequest();
        request.setChannelStrategy(ChannelStrategy.SPECIFIC);
        request.setChannels(List.of(Channel.EMAIL));
        request.setRecipients(List.of(recipient));
        request.setTemplate(template);
        request.setVariables(Map.of("nome", nome, "numeroPedido", numeroPedido));
        request.setBusinessKey(numeroPedido);
        request.setIdempotencyKey("pedido-confirmacao:" + numeroPedido);

        try {
            notificationsApi.get().send(request);
        } catch (ApiException e) {
            // o envio falhou; decide se isto deve falhar o comando de negócio
            LOG.warn("Confirmação {} não enviada: {} {}", numeroPedido, e.getErrorCode(), e.getErrorMessage());
        }
    }
}

pnpm add @igrp/platform-notification-client-ts

// src/lib/notification-client.ts
import 'server-only';
import { NotificationClient } from '@igrp/platform-notification-client-ts';
import { auth } from '@/lib/auth';

const baseUrl = process.env.NOTIFICATION_SERVICE_BASE_URL ?? '';

let m2mClient: NotificationClient | undefined;

/** Envio, anexos, templates — token client_credentials do Access Management. */
export function getNotificationM2MClient(): NotificationClient {
  m2mClient ??= NotificationClient.create(
    { baseUrl },
    {
      clientId: process.env.IGRP_M2M_CLIENT_ID!,
      clientSecret: process.env.IGRP_M2M_CLIENT_SECRET!,
      authBaseUrl: process.env.IGRP_ACCESS_MANAGEMENT_API || process.env.IGRP_AUTH_ISSUER!,
    },
  );
  return m2mClient;
}

/** Inbox do utilizador autenticado — o userId sai do token. */
export async function getNotificationUserClient(): Promise<NotificationClient> {
  const token = await auth.getAccessToken();
  if (!token?.accessToken) throw new Error('Sem sessão');
  return NotificationClient.create({
    baseUrl,
    timeout: 30000,
    headers: { Authorization: `Bearer ${token.accessToken}` },
  });
}

// src/app/(minha-app)/client/notification.ts
'use server';

import {
  ApiClientError,
  Channel,
  ChannelStrategy,
  IgrpNotificationErrorCode,
  type SendNotificationRequest,
} from '@igrp/platform-notification-client-ts';
import { getNotificationM2MClient } from '@/lib/notification-client';

export async function enviarConfirmacao(input: { email: string; nome: string; numeroPedido: string }) {
  const client = getNotificationM2MClient();
  const base: SendNotificationRequest = {
    applicationCode: process.env.IGRP_APP_CODE!,
    channelStrategy: ChannelStrategy.SPECIFIC,
    channels: [Channel.EMAIL],
    recipients: [{ email: input.email }],
    category: 'pedido-confirmacao',
    businessKey: input.numeroPedido,
    idempotencyKey: `pedido-confirmacao-${input.numeroPedido}`,
  };

  try {
    const { data } = await client.notifications.send({
      ...base,
      template: { code: 'pedido-confirmacao', locale: 'pt-CV' },
      variables: { nome: input.nome, numeroPedido: input.numeroPedido },
    });
    return data.id;
  } catch (error) {
    if (!(error instanceof ApiClientError)) throw error;
    const semTemplate =
      error.is(IgrpNotificationErrorCode.TEMPLATE_NOT_FOUND) || error.is(IgrpNotificationErrorCode.TEMPLATE_ERROR);
    if (!semTemplate) {
      // Server Actions só passam `message` ao browser
      throw new Error(`${error.serverMessage ?? error.message} [${error.errorCode ?? error.status}]`);
    }
    // template ainda não publicado: envia o mesmo texto inline
    const { data } = await client.notifications.send({
      ...base,
      inline: {
        subject: `Pedido ${input.numeroPedido} recebido`,
        title: 'Pedido recebido',
        body: `Olá ${input.nome}, recebemos o pedido ${input.numeroPedido}.`,
      },
    });
    return data.id;
  }
}

// src/lib/header-notifications.ts
import 'server-only';
import type { IGRPNotificationArgs } from '@igrp/framework-next-types';
import { getNotificationUserClient } from '@/lib/notification-client';
import { mapInboxItem } from '@/lib/map-inbox-notification';

export async function getHeaderNotifications(): Promise<IGRPNotificationArgs[]> {
  try {
    const client = await getNotificationUserClient();
    const { data } = await client.inbox.list({ unreadOnly: false }, { page: 0, size: 10 });
    return (data.content ?? []).map(mapInboxItem);
  } catch {
    return []; // o sino nunca deve partir a página
  }
}

// src/igrp.template.config.ts (excerto)
getHeaderData: async () => {
  const user = bypass ? getMockUser().mockUser : undefined;
  return {
    user,
    notifications: bypass ? [] : await getHeaderNotifications(),
    notificationsUrl: process.env.NEXT_PUBLIC_IGRP_NOTIFICATION_URL || '',
    showNotifications: true,
    // ... restantes flags
  };
},