@open-mercato/core 0.4.5-develop-754ef4d2f0 → 0.4.5-develop-9f9549ebc8

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/query_index/i18n/es.json

@@ -20,7 +20,7 @@
   "query_index.table.columns.label": "Etiqueta",
   "query_index.table.columns.records": "Registros",
   "query_index.table.columns.status": "Estado",
-  "query_index.table.columns.vector": "Vector",
+  "query_index.table.columns.vector": "Vectorial",
   "query_index.table.confirm.fulltextPurge": "¿Eliminar el índice de texto completo de esta entidad? Esta acción no se puede deshacer.",
   "query_index.table.confirm.vectorPurge": "¿Eliminar los embeddings vectoriales de esta entidad? Esta acción no se puede deshacer.",
   "query_index.table.errors.actionFailed": "No se pudo ejecutar {{action}}.",
@@ -58,7 +58,7 @@
   "query_index.table.status.scope.stalled": "Detenido",
   "query_index.table.status.scopeLabel": "Ámbito",
   "query_index.table.status.stalled": "Detenido",
-  "query_index.table.status.vectorLabel": "Vector",
+  "query_index.table.status.vectorLabel": "Vectorial",
   "query_index.table.status.vectorValue": "{{count}} / {{total}}",
   "query_index.table.status.withProgress": "{{status}} ({{progress}})"
 }

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

@@ -76,6 +76,12 @@
   "resources.audit.availabilityRuleSets.create": "Verfügbarkeitszeitplan erstellen",
   "resources.audit.availabilityRuleSets.delete": "Verfügbarkeitszeitplan löschen",
   "resources.audit.availabilityRuleSets.update": "Verfügbarkeitszeitplan aktualisieren",
+  "resources.audit.resourceActivities.create": "Ressourcenaktivität erstellen",
+  "resources.audit.resourceActivities.delete": "Ressourcenaktivität löschen",
+  "resources.audit.resourceActivities.update": "Ressourcenaktivität aktualisieren",
+  "resources.audit.resourceComments.create": "Ressourcenkommentar erstellen",
+  "resources.audit.resourceComments.delete": "Ressourcenkommentar löschen",
+  "resources.audit.resourceComments.update": "Ressourcenkommentar aktualisieren",
   "resources.audit.resourceTags.assign": "Ressourcen-Tag zuweisen",
   "resources.audit.resourceTags.create": "Ressourcen-Tag erstellen",
   "resources.audit.resourceTags.delete": "Ressourcen-Tag löschen",
@@ -349,6 +355,7 @@
   "resources.resources.detail.activities.update": "Aktivität aktualisieren (Cmd/Ctrl + Enter)",
   "resources.resources.detail.activities.updateSuccess": "Aktivität aktualisiert.",
   "resources.resources.detail.back": "Zurück zu Ressourcen",
+  "resources.resources.detail.formTitle": "Ressourceneinstellungen",
   "resources.resources.detail.inline.cancel": "Stornieren",
   "resources.resources.detail.inline.clear": "Klar",
   "resources.resources.detail.inline.emailChecking": "Suche nach übereinstimmenden Datensätzen...",
@@ -435,13 +442,63 @@
   "resources.resources.detail.tabs.notes": "Notizen",
   "resources.resources.detail.untitled": "Unbenannte Ressource",
   "resources.resources.flash.createdAvailability": "Gespeichert. Du kannst jetzt die Verfügbarkeit festlegen.",
+  "resources.resources.form.actions.create": "Erstellen",
+  "resources.resources.form.appearance.colorClear": "Farbe entfernen",
+  "resources.resources.form.appearance.colorHelp": "Wählen Sie eine Farbe für diese Ressource.",
+  "resources.resources.form.appearance.colorLabel": "Farbe",
+  "resources.resources.form.appearance.iconClear": "Symbol entfernen",
+  "resources.resources.form.appearance.iconLabel": "Symbol",
+  "resources.resources.form.appearance.iconPicker": "Symbole durchsuchen",
+  "resources.resources.form.appearance.iconPlaceholder": "Emoji oder Symbolname eingeben",
+  "resources.resources.form.appearance.iconSearch": "Symbole oder Emojis suchen…",
+  "resources.resources.form.appearance.iconSearchEmpty": "Keine Symbole entsprechen Ihrer Suche",
+  "resources.resources.form.appearance.iconSuggestions": "Vorschläge",
+  "resources.resources.form.appearance.label": "Darstellung",
+  "resources.resources.form.appearance.previewEmpty": "Keine Darstellung ausgewählt",
+  "resources.resources.form.createTitle": "Ressource erstellen",
+  "resources.resources.form.editTitle": "Ressource bearbeiten",
+  "resources.resources.form.errors.create": "Ressource konnte nicht erstellt werden.",
+  "resources.resources.form.errors.delete": "Ressource konnte nicht gelöscht werden.",
+  "resources.resources.form.errors.load": "Ressource konnte nicht geladen werden.",
+  "resources.resources.form.errors.nameRequired": "Ressourcenname ist erforderlich.",
+  "resources.resources.form.errors.notFound": "Ressource nicht gefunden.",
+  "resources.resources.form.errors.update": "Ressource konnte nicht aktualisiert werden.",
+  "resources.resources.form.fields.active": "Aktiv",
+  "resources.resources.form.fields.capacity": "Kapazität",
   "resources.resources.form.fields.capacity.help": "Hängt von der Ressource ab und kann Plätze, Einheiten, Menge oder eine andere Kapazitätsart bedeuten.",
   "resources.resources.form.fields.capacityUnit": "Kapazitätseinheit",
   "resources.resources.form.fields.capacityUnit.missing": "Das Kapazitätseinheiten-Wörterbuch ist nicht konfiguriert.",
+  "resources.resources.form.fields.description": "Beschreibung",
+  "resources.resources.form.fields.name": "Name",
+  "resources.resources.form.fields.type": "Ressourcentyp",
   "resources.resources.form.fields.type.add": "Ressourcentyp hinzufügen",
   "resources.resources.form.fields.type.manage": "Ressourcentypen verwalten",
+  "resources.resources.form.flash.deleted": "Ressource gelöscht.",
+  "resources.resources.form.flash.updated": "Ressource aktualisiert.",
+  "resources.resources.form.loading": "Ressource wird geladen…",
+  "resources.resources.list.actions.create": "Erstellen",
+  "resources.resources.list.columns.active": "Aktiv",
+  "resources.resources.list.columns.appearance": "Darstellung",
+  "resources.resources.list.columns.capacity": "Kapazität",
+  "resources.resources.list.columns.capacity.empty": "Nicht festgelegt",
+  "resources.resources.list.columns.name": "Name",
+  "resources.resources.list.columns.tags": "Tags",
+  "resources.resources.list.columns.tags.empty": "Keine Tags",
+  "resources.resources.list.columns.type": "Type",
+  "resources.resources.list.columns.type.empty": "Kein Typ",
+  "resources.resources.list.confirmDelete": "Diese Ressource löschen? Kann nicht rückgängig gemacht werden.",
+  "resources.resources.list.error.delete": "Ressource konnte nicht gelöscht werden.",
+  "resources.resources.list.error.load": "Ressourcen konnten nicht geladen werden.",
   "resources.resources.list.filters.resourceType": "Ressourcentyp",
   "resources.resources.list.filters.tags": "Schlagworte",
+  "resources.resources.list.flash.deleted": "Ressource gelöscht.",
+  "resources.resources.list.group.unassigned": "Nicht zugewiesen",
+  "resources.resources.list.group.unknown": "Unbekannt",
+  "resources.resources.page.title": "Ressourcen",
+  "resources.resources.schedule.actions.details": "Details anzeigen",
+  "resources.resources.tabs.availability": "Verfügbarkeit",
+  "resources.resources.tabs.details": "Details",
+  "resources.resources.tabs.label": "Ressourcenbereiche",
   "resources.resources.tags.cancelShortcut": "Abbrechen (Esc)",
   "resources.resources.tags.createError": "Tag konnte nicht erstellt werden.",
   "resources.resources.tags.errors.invalid": "Ungültige Tag-Daten",