@open-mercato/core 0.4.5-develop-5191db4ef3 → 0.4.5-develop-033a719bf2

package/src/modules/messages/migrations/Migration20260213181243.ts

@@ -0,0 +1,34 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260213181243 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table "messages" ("id" uuid not null default gen_random_uuid(), "type" text not null default 'default', "thread_id" uuid null, "parent_message_id" uuid null, "sender_user_id" uuid not null, "subject" text not null, "body" text not null, "body_format" text not null default 'text', "priority" text not null default 'normal', "status" text not null default 'draft', "is_draft" boolean not null default true, "sent_at" timestamptz null, "action_data" jsonb null, "action_result" jsonb null, "action_taken" text null, "action_taken_by_user_id" uuid null, "action_taken_at" timestamptz null, "send_via_email" boolean not null default false, "tenant_id" uuid not null, "organization_id" uuid null, "created_at" timestamptz not null, "updated_at" timestamptz not null, "deleted_at" timestamptz null, "visibility" text null, "source_entity_type" text null, "source_entity_id" uuid null, "external_email" text null, "external_name" text null, "external_email_sent_at" timestamptz null, "external_email_failed_at" timestamptz null, "external_email_error" text null, constraint "messages_pkey" primary key ("id"));`);
+    this.addSql(`create index "messages_tenant_idx" on "messages" ("tenant_id", "organization_id");`);
+    this.addSql(`create index "messages_type_idx" on "messages" ("type", "tenant_id");`);
+    this.addSql(`create index "messages_thread_idx" on "messages" ("thread_id");`);
+    this.addSql(`create index "messages_sender_idx" on "messages" ("sender_user_id", "sent_at");`);
+
+    this.addSql(`create table "message_access_tokens" ("id" uuid not null default gen_random_uuid(), "message_id" uuid not null, "recipient_user_id" uuid not null, "token" text not null, "expires_at" timestamptz not null, "used_at" timestamptz null, "use_count" int not null default 0, "created_at" timestamptz not null, constraint "message_access_tokens_pkey" primary key ("id"));`);
+    this.addSql(`alter table "message_access_tokens" add constraint "message_access_tokens_token_unique" unique ("token");`);
+    this.addSql(`create index "message_access_tokens_message_idx" on "message_access_tokens" ("message_id");`);
+    this.addSql(`create index "message_access_tokens_token_idx" on "message_access_tokens" ("token");`);
+
+    this.addSql(`create table "message_objects" ("id" uuid not null default gen_random_uuid(), "message_id" uuid not null, "entity_module" text not null, "entity_type" text not null, "entity_id" uuid not null, "action_required" boolean not null default false, "action_type" text null, "action_label" text null, "entity_snapshot" jsonb null, "created_at" timestamptz not null, constraint "message_objects_pkey" primary key ("id"));`);
+    this.addSql(`create index "message_objects_entity_idx" on "message_objects" ("entity_type", "entity_id");`);
+    this.addSql(`create index "message_objects_message_idx" on "message_objects" ("message_id");`);
+
+    this.addSql(`create table "message_recipients" ("id" uuid not null default gen_random_uuid(), "message_id" uuid not null, "recipient_user_id" uuid not null, "recipient_type" text not null default 'to', "status" text not null default 'unread', "read_at" timestamptz null, "archived_at" timestamptz null, "deleted_at" timestamptz null, "email_sent_at" timestamptz null, "email_delivered_at" timestamptz null, "email_opened_at" timestamptz null, "email_failed_at" timestamptz null, "email_error" text null, "created_at" timestamptz not null, constraint "message_recipients_pkey" primary key ("id"));`);
+    this.addSql(`alter table "message_recipients" add constraint "message_recipients_message_user_unique" unique ("message_id", "recipient_user_id");`);
+    this.addSql(`create index "message_recipients_message_idx" on "message_recipients" ("message_id");`);
+    this.addSql(`create index "message_recipients_user_idx" on "message_recipients" ("recipient_user_id", "status");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "message_recipients" cascade;`);
+    this.addSql(`drop table if exists "message_objects" cascade;`);
+    this.addSql(`drop table if exists "message_access_tokens" cascade;`);
+    this.addSql(`drop table if exists "messages" cascade;`);
+  }
+
+}

package/src/modules/messages/migrations/Migration20260215165126.ts

@@ -0,0 +1,16 @@
+import { Migration } from '@mikro-orm/migrations';
+
+export class Migration20260215165126 extends Migration {
+
+  override async up(): Promise<void> {
+    this.addSql(`create table "message_confirmations" ("id" uuid not null default gen_random_uuid(), "message_id" uuid not null, "tenant_id" uuid not null, "organization_id" uuid null, "confirmed" boolean not null default true, "confirmed_by_user_id" uuid null, "confirmed_at" timestamptz null, "created_at" timestamptz not null, "updated_at" timestamptz not null, constraint "message_confirmations_pkey" primary key ("id"));`);
+    this.addSql(`create index "message_confirmations_scope_idx" on "message_confirmations" ("tenant_id", "organization_id");`);
+    this.addSql(`create index "message_confirmations_message_idx" on "message_confirmations" ("message_id");`);
+    this.addSql(`alter table "message_confirmations" add constraint "message_confirmations_message_unique" unique ("message_id");`);
+  }
+
+  override async down(): Promise<void> {
+    this.addSql(`drop table if exists "message_confirmations" cascade;`);
+  }
+
+}

package/src/modules/messages/notifications.ts

@@ -0,0 +1,25 @@
+import type { NotificationTypeDefinition } from '@open-mercato/shared/modules/notifications/types'
+
+export const notificationTypes: NotificationTypeDefinition[] = [
+  {
+    type: 'messages.new',
+    module: 'messages',
+    titleKey: 'messages.notifications.new.title',
+    bodyKey: 'messages.notifications.new.body',
+    icon: 'mail',
+    severity: 'info',
+    actions: [
+      {
+        id: 'view',
+        labelKey: 'common.view',
+        variant: 'outline',
+        href: '/backend/messages/{sourceEntityId}',
+        icon: 'external-link',
+      },
+    ],
+    linkHref: '/backend/messages/{sourceEntityId}',
+    expiresAfterHours: 168,
+  },
+]
+
+export default notificationTypes

package/src/modules/messages/setup.ts

@@ -0,0 +1,19 @@
+import type { ModuleSetupConfig } from '@open-mercato/shared/modules/setup'
+
+export const setup: ModuleSetupConfig = {
+  defaultRoleFeatures: {
+    superadmin: ['messages.*'],
+    admin: [
+      'messages.*',
+    ],
+    employee: [
+      'messages.view',
+      'messages.compose',
+      'messages.attach',
+      'messages.attach_files',
+      'messages.actions',
+    ],
+  },
+}
+
+export default setup

package/src/modules/messages/subscribers/message-notification.ts

@@ -0,0 +1,138 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { createQueue } from '@open-mercato/queue'
+import { buildBatchNotificationFromType } from '../../notifications/lib/notificationBuilder'
+import { resolveNotificationService } from '../../notifications/lib/notificationService'
+import {
+  MESSAGES_EMAIL_QUEUE_NAME,
+  type SendMessageEmailJob,
+} from '../workers/send-email.worker'
+import { User } from '../../auth/data/entities'
+import { Message } from '../data/entities'
+import { notificationTypes } from '../notifications'
+
+export const metadata = {
+  event: 'messages.message.sent',
+  persistent: true,
+  id: 'messages:queue-email-delivery',
+}
+
+type MessageSentPayload = {
+  messageId: string
+  senderUserId: string
+  recipientUserIds: string[]
+  sendViaEmail: boolean
+  externalEmail?: string | null
+  forwardedFrom?: string
+  replyTo?: string
+  tenantId: string
+  organizationId?: string | null
+}
+
+type ResolverContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+async function resolveNotificationVariables(payload: MessageSentPayload, ctx: ResolverContext): Promise<{ title: string; from: string }> {
+  try {
+    const em = ctx.resolve<EntityManager>('em')?.fork()
+    if (!em) return { title: '', from: '' }
+
+    const scope = {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    }
+    const whereUser: { id: string; tenantId: string; deletedAt: null; organizationId?: string | null } = {
+      id: payload.senderUserId,
+      tenantId: payload.tenantId,
+      deletedAt: null,
+    }
+    if (payload.organizationId !== undefined) {
+      whereUser.organizationId = payload.organizationId
+    }
+
+    const [message, sender] = await Promise.all([
+      findOneWithDecryption(
+        em,
+        Message,
+        {
+          id: payload.messageId,
+          tenantId: payload.tenantId,
+          deletedAt: null,
+        },
+        undefined,
+        scope,
+      ),
+      findOneWithDecryption(
+        em,
+        User,
+        whereUser,
+        undefined,
+        scope,
+      ),
+    ])
+
+    return {
+      title: typeof message?.subject === 'string' ? message.subject : '',
+      from: typeof sender?.name === 'string' && sender.name.trim().length > 0
+        ? sender.name
+        : typeof sender?.email === 'string'
+          ? sender.email
+          : '',
+    }
+  } catch {
+    return { title: '', from: '' }
+  }
+}
+
+
+export default async function handle(payload: MessageSentPayload, ctx: ResolverContext): Promise<void> {
+  const uniqueRecipientUserIds = Array.from(new Set(payload.recipientUserIds))
+
+  const typeDef = notificationTypes.find((type) => type.type === 'messages.new')
+  if (typeDef && uniqueRecipientUserIds.length > 0) {
+    const variables = await resolveNotificationVariables(payload, ctx)
+    const notificationService = resolveNotificationService(ctx)
+    const notificationInput = buildBatchNotificationFromType(typeDef, {
+      recipientUserIds: uniqueRecipientUserIds,
+      titleVariables: variables,
+      bodyVariables: variables,
+      sourceEntityType: 'message',
+      sourceEntityId: payload.messageId,
+      linkHref: `/backend/messages/${payload.messageId}`,
+    })
+    await notificationService.createBatch(notificationInput, {
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  }
+
+  if (!payload.sendViaEmail) {
+    return
+  }
+
+  const strategy = process.env.QUEUE_STRATEGY === 'async' ? 'async' : 'local'
+
+  const emailQueue = createQueue<SendMessageEmailJob>(MESSAGES_EMAIL_QUEUE_NAME, strategy)
+
+  for (const recipientUserId of uniqueRecipientUserIds) {
+    await emailQueue.enqueue({
+      type: 'recipient',
+      messageId: payload.messageId,
+      recipientUserId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  }
+
+  const externalEmail = payload.externalEmail?.trim()
+  if (externalEmail) {
+    await emailQueue.enqueue({
+      type: 'external',
+      messageId: payload.messageId,
+      email: externalEmail,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+    })
+  }
+}

package/src/modules/messages/workers/send-email.worker.ts

@@ -0,0 +1,321 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { JobContext, QueuedJob, WorkerMeta } from '@open-mercato/queue'
+import { findOneWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { User } from '../../auth/data/entities'
+import { Message, MessageObject, MessageRecipient } from '../data/entities'
+import { emitMessagesEvent } from '../events'
+import { getMessageEmailAttachments } from '../lib/attachments'
+import {
+  sendMessageEmailToExternal,
+  sendMessageEmailToRecipient,
+} from '../lib/email-sender'
+
+export const MESSAGES_EMAIL_QUEUE_NAME = 'messages-email'
+
+export type SendMessageEmailToRecipientJob = {
+  type: 'recipient'
+  messageId: string
+  recipientUserId: string
+  tenantId: string
+  organizationId?: string | null
+}
+
+export type SendMessageEmailToExternalJob = {
+  type: 'external'
+  messageId: string
+  email: string
+  tenantId: string
+  organizationId?: string | null
+}
+
+export type SendMessageEmailJob = SendMessageEmailToRecipientJob | SendMessageEmailToExternalJob
+
+export const metadata: WorkerMeta = {
+  queue: MESSAGES_EMAIL_QUEUE_NAME,
+  id: 'messages:send-email',
+  concurrency: 10,
+}
+
+type HandlerContext = {
+  resolve: <T = unknown>(name: string) => T
+}
+
+async function emitEmailDeliveryEvent(
+  ctx: HandlerContext,
+  eventId: 'messages.message.email_sent' | 'messages.message.email_failed',
+  payload: {
+    messageId: string
+    target: 'recipient' | 'external'
+    recipientUserId?: string
+    email?: string
+    error?: string
+    tenantId: string
+    organizationId?: string | null
+  }
+) {
+  const eventBus = ctx.resolve<{ emit?: unknown } | null>('eventBus')
+  if (!eventBus || typeof eventBus !== 'object' || typeof (eventBus as { emit?: unknown }).emit !== 'function') {
+    return
+  }
+  await emitMessagesEvent(eventId, payload, { persistent: true })
+}
+
+async function resolveSender(em: EntityManager, message: Message) {
+  const sender = await findOneWithDecryption(
+    em,
+    User,
+    {
+      id: message.senderUserId,
+      tenantId: message.tenantId,
+      deletedAt: null,
+    },
+    undefined,
+    { tenantId: message.tenantId, organizationId: message.organizationId ?? null }
+  )
+  return {
+    name: sender?.name ?? null,
+    email: sender?.email ?? null,
+  }
+}
+
+async function resolveMessageScope(
+  em: EntityManager,
+  payload: SendMessageEmailJob
+) {
+  return await em.findOne(Message, {
+    id: payload.messageId,
+    tenantId: payload.tenantId,
+    organizationId: payload.organizationId ?? null,
+    deletedAt: null,
+  })
+}
+
+export async function claimRecipientDelivery(
+  em: EntityManager,
+  payload: SendMessageEmailToRecipientJob,
+): Promise<Date | null> {
+  const claimTimestamp = new Date()
+  const updatedRows = await em.nativeUpdate(
+    MessageRecipient,
+    {
+      messageId: payload.messageId,
+      recipientUserId: payload.recipientUserId,
+      emailSentAt: null,
+    },
+    {
+      emailSentAt: claimTimestamp,
+      emailFailedAt: null,
+      emailError: null,
+    },
+  )
+  return updatedRows > 0 ? claimTimestamp : null
+}
+
+export async function releaseRecipientClaim(
+  em: EntityManager,
+  payload: SendMessageEmailToRecipientJob,
+  claimTimestamp: Date,
+  errorMessage: string,
+): Promise<void> {
+  await em.nativeUpdate(
+    MessageRecipient,
+    {
+      messageId: payload.messageId,
+      recipientUserId: payload.recipientUserId,
+      emailSentAt: claimTimestamp,
+    },
+    {
+      emailSentAt: null,
+      emailFailedAt: new Date(),
+      emailError: errorMessage,
+    },
+  )
+}
+
+export async function claimExternalDelivery(
+  em: EntityManager,
+  payload: SendMessageEmailToExternalJob,
+): Promise<Date | null> {
+  const claimTimestamp = new Date()
+  const updatedRows = await em.nativeUpdate(
+    Message,
+    {
+      id: payload.messageId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+      externalEmailSentAt: null,
+    },
+    {
+      externalEmailSentAt: claimTimestamp,
+      externalEmailFailedAt: null,
+      externalEmailError: null,
+    },
+  )
+  return updatedRows > 0 ? claimTimestamp : null
+}
+
+export async function releaseExternalClaim(
+  em: EntityManager,
+  payload: SendMessageEmailToExternalJob,
+  claimTimestamp: Date,
+  errorMessage: string,
+): Promise<void> {
+  await em.nativeUpdate(
+    Message,
+    {
+      id: payload.messageId,
+      tenantId: payload.tenantId,
+      organizationId: payload.organizationId ?? null,
+      externalEmailSentAt: claimTimestamp,
+    },
+    {
+      externalEmailSentAt: null,
+      externalEmailFailedAt: new Date(),
+      externalEmailError: errorMessage,
+    },
+  )
+}
+
+export default async function handle(
+  job: QueuedJob<SendMessageEmailJob>,
+  ctx: JobContext & HandlerContext
+): Promise<void> {
+  const { payload } = job
+  const em = (ctx.resolve('em') as EntityManager).fork()
+
+  const message = await resolveMessageScope(em, payload)
+  if (!message) {
+    console.error('[messages:send-email] Message not found', payload.messageId)
+    return
+  }
+
+  const objects = await em.find(MessageObject, { messageId: message.id })
+  const attachments = await getMessageEmailAttachments(
+    em,
+    message.id,
+    message.organizationId ?? null,
+    message.tenantId
+  )
+  const sender = await resolveSender(em, message)
+
+  if (payload.type === 'external') {
+    const externalClaimTimestamp = await claimExternalDelivery(em, payload)
+    if (!externalClaimTimestamp) {
+      return
+    }
+
+    try {
+      await sendMessageEmailToExternal({
+        message,
+        email: payload.email,
+        sender,
+        objects,
+        attachments,
+      })
+      await emitEmailDeliveryEvent(ctx, 'messages.message.email_sent', {
+        messageId: message.id,
+        target: 'external',
+        email: payload.email,
+        tenantId: message.tenantId,
+        organizationId: message.organizationId ?? null,
+      })
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+      await releaseExternalClaim(
+        em,
+        payload,
+        externalClaimTimestamp,
+        errorMessage,
+      )
+      await emitEmailDeliveryEvent(ctx, 'messages.message.email_failed', {
+        messageId: message.id,
+        target: 'external',
+        email: payload.email,
+        error: errorMessage,
+        tenantId: message.tenantId,
+        organizationId: message.organizationId ?? null,
+      })
+      console.error('[messages:send-email] External email send failed', error)
+    }
+    return
+  }
+
+  const recipientRecord = await em.findOne(MessageRecipient, {
+    messageId: payload.messageId,
+    recipientUserId: payload.recipientUserId,
+  })
+  if (!recipientRecord) {
+    console.error('[messages:send-email] Recipient row not found', payload)
+    return
+  }
+
+  if (recipientRecord.emailSentAt) {
+    return
+  }
+
+  const recipientClaimTimestamp = await claimRecipientDelivery(em, payload)
+  if (!recipientClaimTimestamp) {
+    return
+  }
+
+  const recipientUser = await findOneWithDecryption(
+    em,
+    User,
+    {
+      id: payload.recipientUserId,
+      tenantId: message.tenantId,
+      deletedAt: null,
+    },
+    undefined,
+    { tenantId: message.tenantId, organizationId: message.organizationId ?? null }
+  )
+
+  const recipientEmail = recipientUser?.email?.trim()
+  if (!recipientEmail) {
+    await releaseRecipientClaim(
+      em,
+      payload,
+      recipientClaimTimestamp,
+      'Recipient has no email address',
+    )
+    return
+  }
+
+  try {
+    await sendMessageEmailToRecipient({
+      em,
+      message,
+      recipientUserId: payload.recipientUserId,
+      recipientEmail,
+      sender,
+      objects,
+      attachments,
+    })
+    await emitEmailDeliveryEvent(ctx, 'messages.message.email_sent', {
+      messageId: message.id,
+      target: 'recipient',
+      recipientUserId: payload.recipientUserId,
+      email: recipientEmail,
+      tenantId: message.tenantId,
+      organizationId: message.organizationId ?? null,
+    })
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+    await releaseRecipientClaim(
+      em,
+      payload,
+      recipientClaimTimestamp,
+      errorMessage,
+    )
+    await emitEmailDeliveryEvent(ctx, 'messages.message.email_failed', {
+      messageId: message.id,
+      target: 'recipient',
+      recipientUserId: payload.recipientUserId,
+      email: recipientEmail,
+      error: errorMessage,
+      tenantId: message.tenantId,
+      organizationId: message.organizationId ?? null,
+    })
+    console.error('[messages:send-email] Recipient email send failed', error)
+  }
+}

package/src/modules/sales/backend/sales/documents/[id]/page.tsx

@@ -24,6 +24,7 @@ import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, D
 import { ArrowRightLeft, Building2, CreditCard, Mail, Pencil, Plus, Send, Store, Truck, UserRound, Wand2, X } from 'lucide-react'
 import { FormHeader, type ActionItem } from '@open-mercato/ui/backend/forms'
 import { VersionHistoryAction } from '@open-mercato/ui/backend/version-history'
+import { SendObjectMessageDialog } from '@open-mercato/ui/backend/messages'
 import Link from 'next/link'
 import { flash } from '@open-mercato/ui/backend/FlashMessages'
 import { apiCall, apiCallOrThrow, readApiResultOrThrow } from '@open-mercato/ui/backend/utils/apiCall'
@@ -4425,13 +4426,28 @@ export default function SalesDocumentDetailPage({
           backHref={kind === 'order' ? '/backend/sales/orders' : '/backend/sales/quotes'}
           backLabel={t('sales.documents.detail.back', 'Back to documents')}
           utilityActions={record ? (
-            <VersionHistoryAction
-              config={{
-                resourceKind: kind === 'order' ? 'sales.order' : 'sales.quote',
-                resourceId: record.id,
-              }}
-              t={t}
-            />
+            <>
+              <SendObjectMessageDialog
+                object={{
+                  entityModule: 'sales',
+                  entityType: kind,
+                  entityId: record.id,
+                  sourceEntityType: kind === 'order' ? 'sales.order' : 'sales.quote',
+                  sourceEntityId: record.id,
+                }}
+                defaultValues={{
+                  sourceEntityType: kind === 'order' ? 'sales.order' : 'sales.quote',
+                  sourceEntityId: record.id,
+                }}
+              />
+              <VersionHistoryAction
+                config={{
+                  resourceKind: kind === 'order' ? 'sales.order' : 'sales.quote',
+                  resourceId: record.id,
+                }}
+                t={t}
+              />
+            </>
           ) : null}
           entityTypeLabel={kind === 'order'
             ? t('sales.documents.detail.order', 'Sales order')

package/src/modules/sales/commands/payments.ts

@@ -564,21 +564,27 @@ const updatePaymentCommand: CommandHandler<
   },
   async execute(rawInput, ctx) {
     const input = paymentUpdateSchema.parse(rawInput ?? {})
-    ensureTenantScope(ctx, input.tenantId)
-    ensureOrganizationScope(ctx, input.organizationId)
     const em = (ctx.container.resolve('em') as EntityManager).fork()
     const { translate } = await resolveTranslations()
+    const scopeSeed = assertFound(
+      await em.findOne(SalesPayment, { id: input.id }),
+      'sales.payments.not_found'
+    )
+    const resolvedTenantId = input.tenantId ?? scopeSeed.tenantId
+    const resolvedOrganizationId = input.organizationId ?? scopeSeed.organizationId
+    ensureTenantScope(ctx, resolvedTenantId)
+    ensureOrganizationScope(ctx, resolvedOrganizationId)
     const payment = assertFound(
       await findOneWithDecryption(
         em,
         SalesPayment,
         { id: input.id },
         { populate: ['order'] },
-        { tenantId: input.tenantId, organizationId: input.organizationId },
+        { tenantId: resolvedTenantId, organizationId: resolvedOrganizationId },
       ),
       'sales.payments.not_found'
     )
-    ensureSameScope(payment, input.organizationId, input.tenantId)
+    ensureSameScope(payment, resolvedOrganizationId, resolvedTenantId)
     const previousOrder = payment.order as SalesOrder | null
     if (input.orderId !== undefined) {
       if (!input.orderId) {
@@ -588,7 +594,7 @@ const updatePaymentCommand: CommandHandler<
           await em.findOne(SalesOrder, { id: input.orderId }),
           'sales.payments.order_not_found'
         )
-        ensureSameScope(order, input.organizationId, input.tenantId)
+        ensureSameScope(order, resolvedOrganizationId, resolvedTenantId)
         if (
           order.currencyCode &&
           input.currencyCode &&
@@ -609,7 +615,7 @@ const updatePaymentCommand: CommandHandler<
           await em.findOne(SalesPaymentMethod, { id: input.paymentMethodId }),
           'sales.payments.method_not_found'
         )
-        ensureSameScope(method, input.organizationId, input.tenantId)
+        ensureSameScope(method, resolvedOrganizationId, resolvedTenantId)
         payment.paymentMethod = method
       }
     }

package/src/modules/sales/i18n/de.json

@@ -1106,6 +1106,9 @@
   "sales.errors.tag_required": "Tag ist erforderlich.",
   "sales.errors.tenant_required": "Mandantenkontext ist erforderlich",
   "sales.errors.unauthorized": "Nicht autorisiert",
+  "sales.messageObjects.notFound": "Nicht gefunden",
+  "sales.messageObjects.order.title": "Bestellung",
+  "sales.messageObjects.quote.title": "Angebot",
   "sales.module.description": "Angebote, Aufträge, Fulfillment, Rechnungsstellung und Zahlungen verbunden mit dem Produktkatalog.",
   "sales.module.title": "Vertriebsmanagement",
   "sales.nav.channels": "Vertriebskanäle",

package/src/modules/sales/i18n/en.json

@@ -1106,6 +1106,9 @@
   "sales.errors.tag_required": "Tag is required.",
   "sales.errors.tenant_required": "Tenant context is required",
   "sales.errors.unauthorized": "Unauthorized",
+  "sales.messageObjects.notFound": "Not found",
+  "sales.messageObjects.order.title": "Sales order",
+  "sales.messageObjects.quote.title": "Sales quote",
   "sales.module.description": "Quotes, orders, fulfillment, invoicing, and payments connected to the product catalog.",
   "sales.module.title": "Sales Management",
   "sales.nav.channels": "Channels",