@hed-hog/core 0.0.354 → 0.0.356

package/src/integration-profile/integration-profile.utils.ts

@@ -0,0 +1,156 @@
+import { BadRequestException } from '@nestjs/common';
+import { EnumProvider } from '../file/provider/provider.enum';
+
+type Cfg = Record<string, unknown>;
+
+export function buildMailConfigFromIntegration(
+  providerSlug: string,
+  config: unknown,
+): any {
+  const cfg = (config as Cfg) ?? {};
+
+  switch (providerSlug.toLowerCase()) {
+    case 'smtp':
+      return {
+        global: true,
+        type: 'SMTP' as const,
+        host: String(cfg.host ?? ''),
+        port: Number(cfg.port ?? 587),
+        secure: Boolean(cfg.secure),
+        username: String(cfg.username ?? ''),
+        password: String(cfg.password ?? ''),
+      };
+    case 'gmail':
+      return {
+        global: true,
+        type: 'GMAIL' as const,
+        clientId: String(cfg.client_id ?? ''),
+        clientSecret: String(cfg.client_secret ?? ''),
+        refreshToken: String(cfg.refresh_token ?? ''),
+        from: String(cfg.from_email ?? ''),
+      };
+    case 'ses':
+      return {
+        global: true,
+        type: 'SES' as const,
+        region: String(cfg.region ?? ''),
+        accessKeyId: String(cfg.access_key_id ?? ''),
+        secretAccessKey: String(cfg.secret_access_key ?? ''),
+        from: String(cfg.from_email ?? ''),
+      };
+    default:
+      throw new BadRequestException(`Unsupported mail provider: ${providerSlug}`);
+  }
+}
+
+export function getFromAddress(config: unknown): string {
+  const cfg = (config as Cfg) ?? {};
+  const fromEmail = String(cfg.from_email ?? '');
+  const fromName = String(cfg.from_name ?? '');
+  return fromName ? `${fromName} <${fromEmail}>` : fromEmail;
+}
+
+export function getReplyToAddress(config: unknown): string | undefined {
+  const cfg = (config as Cfg) ?? {};
+  const replyToEmail = String(cfg.reply_to_email ?? '').trim();
+  if (!replyToEmail) return undefined;
+  const replyToName = String(cfg.reply_to_name ?? '').trim();
+  return replyToName ? `${replyToName} <${replyToEmail}>` : replyToEmail;
+}
+
+// ─── Storage utilities ────────────────────────────────────────────────────────
+
+/**
+ * Maps an integration_profile config JSON to the flat settings dict that the
+ * existing provider classes (S3Provider, AzureProvider, etc.) expect.
+ *
+ * integration_provider slugs → EnumProvider:
+ *   local, s3, gcs       → same
+ *   azure-blob           → abs
+ *   s3-compatible        → spaces
+ */
+export function buildStorageConfigFromIntegration(
+  providerSlug: string,
+  config: unknown,
+): Record<string, string> {
+  const cfg = (config as Cfg) ?? {};
+
+  switch (providerSlug.toLowerCase()) {
+    case 'local':
+      return {
+        'storage-local-path': String(cfg.base_path ?? 'storage'),
+      };
+    case 's3':
+      return {
+        'storage-s3-key': String(cfg.access_key_id ?? ''),
+        'storage-s3-secret': String(cfg.secret_access_key ?? ''),
+        'storage-s3-region': String(cfg.region ?? 'us-east-1'),
+        'storage-s3-bucket': String(cfg.bucket ?? ''),
+      };
+    case 'gcs':
+      return {
+        'storage-gcs-keyfile': String(cfg.key_file_json ?? ''),
+        'storage-gcs-bucket': String(cfg.bucket ?? ''),
+      };
+    case 'azure-blob':
+      return {
+        'storage-abs-account': String(cfg.account ?? ''),
+        'storage-abs-key': String(cfg.key ?? ''),
+        'storage-abs-container': String(cfg.container ?? ''),
+      };
+    case 's3-compatible':
+      return {
+        'storage-spaces-key': String(cfg.access_key_id ?? ''),
+        'storage-spaces-secret': String(cfg.secret_access_key ?? ''),
+        'storage-spaces-region': String(cfg.region ?? ''),
+        'storage-spaces-bucket': String(cfg.bucket ?? ''),
+        'storage-spaces-cdn': String(cfg.endpoint ?? ''),
+      };
+    default:
+      throw new BadRequestException(`Unsupported storage provider: ${providerSlug}`);
+  }
+}
+
+/** Maps integration_provider slug to EnumProvider. */
+export function resolveStorageEnumProvider(providerSlug: string): EnumProvider {
+  switch (providerSlug.toLowerCase()) {
+    case 'local': return EnumProvider.LOCAL;
+    case 's3': return EnumProvider.S3;
+    case 'gcs': return EnumProvider.GCS;
+    case 'azure-blob': return EnumProvider.AZURE;
+    case 's3-compatible': return EnumProvider.SPACES;
+    default:
+      throw new BadRequestException(`Unsupported storage provider: ${providerSlug}`);
+  }
+}
+
+/** Maps integration_provider slug to the slug used in the file_provider table. */
+export function resolveFileProviderSlug(providerSlug: string): string {
+  switch (providerSlug.toLowerCase()) {
+    case 'azure-blob': return 'abs';
+    case 's3-compatible': return 'spaces';
+    default: return providerSlug.toLowerCase();
+  }
+}
+
+// ─── AI utilities ─────────────────────────────────────────────────────────────
+
+/** Maps an integration_profile config JSON to the API key and optional org needed by AI providers. */
+export function buildAiConfigFromIntegration(
+  providerSlug: string,
+  config: unknown,
+): { apiKey: string; organization?: string } {
+  const cfg = (config as Cfg) ?? {};
+  switch (providerSlug.toLowerCase()) {
+    case 'openai':
+      return {
+        apiKey: String(cfg.api_key ?? ''),
+        ...(cfg.organization ? { organization: String(cfg.organization) } : {}),
+      };
+    case 'gemini':
+    case 'claude':
+      return { apiKey: String(cfg.api_key ?? '') };
+    default:
+      throw new BadRequestException(`Unsupported AI provider: ${providerSlug}`);
+  }
+}

package/src/mail/mail.module.ts

@@ -26,41 +26,50 @@ import { MailService } from './mail.service';
             return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;
           }
 
-          const profile = await prisma.mail_profile.findUnique({
+          const profile = await (prisma as any).integration_profile.findUnique({
             where: { id: profileId },
+            include: {
+              integration_provider: { select: { slug: true } },
+              integration_type: { select: { slug: true } },
+            },
           });
 
           if (!profile) {
             return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;
           }
 
+          if (profile.integration_type?.slug !== 'email') {
+            return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;
+          }
+
+          const cfg = (profile.config as Record<string, unknown>) ?? {};
           const base: MailModuleOptions = { global: true } as MailModuleOptions;
 
-          switch (profile.provider) {
-            case 'GMAIL':
+          switch (profile.integration_provider.slug) {
+            case 'gmail':
               return Object.assign(base, {
                 type: 'GMAIL',
-                clientId: profile.gmail_client_id ?? '',
-                clientSecret: profile.gmail_client_secret ?? '',
-                refreshToken: profile.gmail_refresh_token ?? '',
-                from: profile.from_email,
+                clientId: String(cfg.client_id ?? ''),
+                clientSecret: String(cfg.client_secret ?? ''),
+                refreshToken: String(cfg.refresh_token ?? ''),
+                from: String(cfg.from_email ?? ''),
               });
-            case 'SMTP':
+            case 'smtp':
               return Object.assign(base, {
                 type: 'SMTP',
-                host: profile.smtp_host ?? 'localhost',
-                port: profile.smtp_port ?? 1025,
-                secure: profile.smtp_secure ?? false,
-                username: profile.smtp_username ?? '',
-                password: profile.smtp_password ?? '',
+                host: String(cfg.host ?? 'localhost'),
+                port: Number(cfg.port ?? 1025),
+                secure: Boolean(cfg.secure),
+                username: String(cfg.username ?? ''),
+                password: String(cfg.password ?? ''),
               });
-            case 'SES':
+            case 'ses':
               return Object.assign(base, {
                 type: 'SES',
-                region: profile.ses_region ?? '',
-                accessKeyId: profile.ses_access_key_id ?? '',
-                secretAccessKey: profile.ses_secret_access_key ?? '',
-                from: profile.from_email,
+                region: String(cfg.region ?? ''),
+                accessKeyId: String(cfg.access_key_id ?? ''),
+                secretAccessKey: String(cfg.secret_access_key ?? ''),
+                from: String(cfg.from_email ?? ''),
               });
             default:
               return { global: true, type: 'SMTP', host: 'localhost', port: 1025, secure: false, username: '', password: '' } as MailModuleOptions;

package/src/mail/mail.service.ts

@@ -13,6 +13,10 @@ import {
   OnModuleInit,
 } from '@nestjs/common';
 import * as Handlebars from 'handlebars';
+import {
+  buildMailConfigFromIntegration,
+  getFromAddress,
+} from '../integration-profile/integration-profile.utils';
 import { IntegrationDeveloperApiService } from '../integration/services/integration-developer-api.service';
 import { SettingService } from '../setting/setting.service';
 import { CreateDTO } from './dto/create.dto';
@@ -96,89 +100,56 @@ export class MailService implements OnModuleInit {
 
   /**
    * Reload mail configuration from database and update MailMainService.
+   * When profileId is provided, that profile is used directly.
+   * Otherwise the global `mail-profile-id` setting is read.
    * Returns the active from address and the built config object.
    */
-  async reloadConfig(): Promise<{ success: boolean; provider: string; from: string; config: any }> {
+  async reloadConfig(profileId?: number): Promise<{ success: boolean; provider: string; from: string; config: any }> {
     try {
-      const settings = await this.setting.getSettingValues(['mail-profile-id']);
-      const profileId = Number(settings['mail-profile-id']);
+      let resolvedProfileId = profileId;
+
+      if (!resolvedProfileId) {
+        const settings = await this.setting.getSettingValues(['mail-profile-id']);
+        resolvedProfileId = Number(settings['mail-profile-id']);
+      }
 
-      if (!profileId || profileId <= 0) {
+      if (!resolvedProfileId || resolvedProfileId <= 0) {
         throw new BadRequestException('No mail profile configured. Set a mail profile in the Mail settings.');
       }
 
-      const profile = await this.prismaService.mail_profile.findUnique({
-        where: { id: profileId },
+      const profile = await this.prismaService.integration_profile.findUnique({
+        where: { id: resolvedProfileId },
+        include: {
+          integration_provider: { select: { slug: true } },
+          integration_type: { select: { slug: true } },
+        },
       });
 
       if (!profile) {
         throw new NotFoundException(`Mail profile with id ${profileId} not found.`);
       }
 
-      const config = this.buildMailConfig(profile);
+      if (profile.integration_type?.slug !== 'email') {
+        throw new BadRequestException(
+          `Integration profile ${resolvedProfileId} is not an email profile.`,
+        );
+      }
+
+      const providerSlug = profile.integration_provider.slug;
+      const config = buildMailConfigFromIntegration(providerSlug, profile.config);
 
       this.mailMainService.setConfig(config);
-      this.logger.log(`Mail configuration reloaded from profile "${profile.name}" (${profile.provider})`);
+      this.logger.log(`Mail configuration reloaded from profile "${profile.name}" (${providerSlug})`);
 
-      const from = profile.from_name
-        ? `${profile.from_name} <${profile.from_email}>`
-        : profile.from_email;
+      const from = getFromAddress(profile.config);
 
-      return { success: true, provider: profile.provider, from, config };
+      return { success: true, provider: providerSlug, from, config };
     } catch (error) {
       this.logger.error('Error reloading mail configuration:', error);
       throw error;
     }
   }
 
-  private buildMailConfig(profile: {
-    provider: string;
-    from_email: string;
-    smtp_host?: string | null;
-    smtp_port?: number | null;
-    smtp_secure?: boolean | null;
-    smtp_username?: string | null;
-    smtp_password?: string | null;
-    gmail_client_id?: string | null;
-    gmail_client_secret?: string | null;
-    gmail_refresh_token?: string | null;
-    ses_access_key_id?: string | null;
-    ses_secret_access_key?: string | null;
-    ses_region?: string | null;
-  }): any {
-    switch (profile.provider) {
-      case 'GMAIL':
-        return {
-          global: true,
-          type: 'GMAIL' as const,
-          clientId: profile.gmail_client_id ?? '',
-          clientSecret: profile.gmail_client_secret ?? '',
-          refreshToken: profile.gmail_refresh_token ?? '',
-          from: profile.from_email,
-        };
-      case 'SMTP':
-        return {
-          global: true,
-          type: 'SMTP' as const,
-          host: profile.smtp_host ?? '',
-          port: profile.smtp_port ?? 587,
-          secure: profile.smtp_secure ?? false,
-          username: profile.smtp_username ?? '',
-          password: profile.smtp_password ?? '',
-        };
-      case 'SES':
-        return {
-          global: true,
-          type: 'SES' as const,
-          region: profile.ses_region ?? '',
-          accessKeyId: profile.ses_access_key_id ?? '',
-          secretAccessKey: profile.ses_secret_access_key ?? '',
-          from: profile.from_email,
-        };
-      default:
-        throw new BadRequestException(`Invalid mail provider: ${profile.provider}`);
-    }
-  }
 
   async list(locale: string, paginationParams: PaginationDTO) {
     const result = await this.localeService.listModelWithLocale(

package/src/mcp/mcp.module.ts

@@ -6,8 +6,8 @@ import { AiModule } from '../ai/ai.module';
 import { SystemModule } from '../core/system.module';
 import { DashboardModule } from '../dashboard/dashboard.module';
 import { FileModule } from '../file/file.module';
+import { IntegrationProfileModule } from '../integration-profile/integration-profile.module';
 import { MailModule } from '../mail/mail.module';
-import { MailProfileModule } from '../mail-profile/mail-profile.module';
 import { MailSentModule } from '../mail-sent/mail-sent.module';
 import { McpChatService } from '../mcp-chat/mcp-chat.service';
 import { MenuModule } from '../menu/menu.module';
@@ -69,7 +69,7 @@ import { AccessLogModule } from '../access-log/access-log.module';
     forwardRef(() => ScreenModule),
     forwardRef(() => FileModule),
     forwardRef(() => MailModule),
-    forwardRef(() => MailProfileModule),
+    forwardRef(() => IntegrationProfileModule),
     forwardRef(() => MailSentModule),
     forwardRef(() => SessionModule),
     forwardRef(() => NotificationModule),

package/src/mcp/tools/core-mail-profile.mcp-tools.ts

@@ -1,15 +1,15 @@
 import { Injectable } from '@nestjs/common';
-import { MailProfileService } from '../../mail-profile/mail-profile.service';
+import { IntegrationProfileService } from '../../integration-profile/integration-profile.service';
 import { McpTool } from '../decorators/mcp-tool.decorator';
 import { McpContext } from '../types/mcp-context.type';
 
 @Injectable()
 export class CoreMailProfileMcpTools {
-  constructor(private readonly mailProfileService: MailProfileService) {}
+  constructor(private readonly integrationProfileService: IntegrationProfileService) {}
 
   @McpTool({
     name: 'core.mail-profile.list',
-    description: 'Lists mail profiles with optional pagination. Admin only.',
+    description: 'Lists integration profiles with optional pagination. Admin only.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -26,7 +26,7 @@ export class CoreMailProfileMcpTools {
     args: { page?: number; pageSize?: number; search?: string; sortField?: string; sortOrder?: string },
     _context: McpContext,
   ): Promise<any> {
-    return this.mailProfileService.list({
+    return this.integrationProfileService.list({
       page: args.page ?? 1,
       pageSize: args.pageSize ?? 20,
       search: args.search ?? '',
@@ -38,91 +38,32 @@ export class CoreMailProfileMcpTools {
 
   @McpTool({
     name: 'core.mail-profile.get',
-    description: 'Returns a single mail profile by ID. Admin only.',
+    description: 'Returns a single integration profile by ID. Admin only.',
     inputSchema: {
       type: 'object',
       properties: {
-        id: { type: 'number', description: 'Mail profile ID' },
+        id: { type: 'number', description: 'Profile ID' },
       },
       required: ['id'],
     },
     readOnly: true,
   })
   async getMailProfile(args: { id: number }, _context: McpContext): Promise<any> {
-    return this.mailProfileService.get(args.id);
-  }
-
-  @McpTool({
-    name: 'core.mail-profile.create',
-    description: 'Creates a new mail profile (SMTP configuration). Admin only.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Profile name' },
-        host: { type: 'string', description: 'SMTP host' },
-        port: { type: 'number', description: 'SMTP port' },
-        username: { type: 'string', description: 'SMTP username' },
-        password: { type: 'string', description: 'SMTP password' },
-      },
-      required: ['name', 'host', 'port', 'username'],
-    },
-  })
-  async createMailProfile(args: { name: string; host: string; port: number; username: string; password?: string }, _context: McpContext): Promise<any> {
-    return this.mailProfileService.create(args as any);
-  }
-
-  @McpTool({
-    name: 'core.mail-profile.update',
-    description: 'Updates an existing mail profile by ID. Admin only.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        id: { type: 'number', description: 'Mail profile ID' },
-        name: { type: 'string', description: 'New profile name' },
-        host: { type: 'string', description: 'New SMTP host' },
-        port: { type: 'number', description: 'New SMTP port' },
-        username: { type: 'string', description: 'New SMTP username' },
-        password: { type: 'string', description: 'New SMTP password' },
-      },
-      required: ['id'],
-    },
-  })
-  async updateMailProfile(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
-    const { id, ...data } = args;
-    return this.mailProfileService.update({ id, data: data as any });
+    return this.integrationProfileService.get(args.id);
   }
 
   @McpTool({
     name: 'core.mail-profile.delete',
-    description: 'Deletes one or more mail profiles by their IDs. Admin only.',
+    description: 'Deletes one or more integration profiles by their IDs. Admin only.',
     inputSchema: {
       type: 'object',
       properties: {
-        ids: { type: 'array', items: { type: 'number' }, description: 'Mail profile IDs to delete' },
+        ids: { type: 'array', items: { type: 'number' }, description: 'Profile IDs to delete' },
       },
       required: ['ids'],
     },
   })
   async deleteMailProfiles(args: { ids: number[] }, _context: McpContext): Promise<any> {
-    return this.mailProfileService.delete({ ids: args.ids });
-  }
-
-  @McpTool({
-    name: 'core.mail-profile.test',
-    description: 'Tests a mail profile by sending a test message. Admin only.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', description: 'Profile name' },
-        host: { type: 'string', description: 'SMTP host' },
-        port: { type: 'number', description: 'SMTP port' },
-        username: { type: 'string', description: 'SMTP username' },
-        password: { type: 'string', description: 'SMTP password' },
-      },
-      required: ['host', 'port', 'username'],
-    },
-  })
-  async testMailProfile(args: Record<string, any>, _context: McpContext): Promise<any> {
-    return this.mailProfileService.test(args as any);
+    return this.integrationProfileService.delete({ ids: args.ids });
   }
 }

package/src/mcp-chat/mcp-chat.service.ts

@@ -11,6 +11,7 @@ import {
     NotFoundException,
 } from '@nestjs/common';
 import axios from 'axios';
+import { buildAiConfigFromIntegration } from '../integration-profile/integration-profile.utils';
 import { McpRegistryService, McpToolEntry } from '../mcp/mcp-registry.service';
 import { McpContext } from '../mcp/types/mcp-context.type';
 import { SettingService } from '../setting/setting.service';
@@ -772,30 +773,32 @@ export class McpChatService {
   }
 
   private async getProviderKey(): Promise<{ provider: 'openai' | 'gemini'; apiKey: string }> {
-    const settings = await this.setting.getSettingValues([
-      'mcp-ai-provider',
-      'ai-openai-api-key',
-      'ai-gemini-api-key',
-    ]);
-    const provider = ((settings['mcp-ai-provider'] as string) || 'openai') as 'openai' | 'gemini';
+    const settings = await this.setting.getSettingValues(['mcp-ai-profile-id']);
+    const profileId = Number(settings['mcp-ai-profile-id']);
 
-    if (provider === 'gemini') {
-      const key = settings['ai-gemini-api-key'] as string;
-      if (!key) {
-        throw new BadRequestException(
-          'Gemini API key is not configured. Please set it in Settings → AI → Gemini API Key.',
-        );
-      }
-      return { provider: 'gemini', apiKey: key };
-    }
-
-    const key = settings['ai-openai-api-key'] as string;
-    if (!key) {
+    if (!profileId) {
       throw new BadRequestException(
-        'OpenAI API key is not configured. Please set it in Settings → AI → OpenAI API Key.',
+        'No MCP AI profile configured. Select one in Settings → MCP.',
       );
     }
-    return { provider: 'openai', apiKey: key };
+
+    const profile = await this.prisma.integration_profile.findUnique({
+      where: { id: profileId },
+      include: { integration_provider: { select: { slug: true } } },
+    });
+
+    if (!profile) {
+      throw new BadRequestException(`MCP AI profile ${profileId} not found.`);
+    }
+
+    const providerSlug = profile.integration_provider.slug;
+    const { apiKey } = buildAiConfigFromIntegration(providerSlug, profile.config);
+
+    if (!apiKey) {
+      throw new BadRequestException(`MCP AI profile ${profileId} has no API key configured.`);
+    }
+
+    return { provider: providerSlug === 'gemini' ? 'gemini' : 'openai', apiKey };
   }
 
   private async buildOpenAiTools(

package/src/setting/setting.service.ts

@@ -206,8 +206,6 @@ export class SettingService {
       'password-min-uppercase',
       'password-min-length',
       'mfa-email-code-length',
-      'ai-openai-api-key-enabled',
-      'ai-gemini-api-key-enabled',
       'mcp-enabled',
       'date-format',
       'time-format',

package/src/webhook-integration/event-webhook.controller.ts

@@ -1,50 +1,55 @@
-import { DeleteDTO, Role } from '@hed-hog/api';
-import { Pagination } from '@hed-hog/api-pagination';
-import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
-} from '@nestjs/common';
-import { EventWebhookService } from './event-webhook.service';
-
-@Role()
-@Controller('event-webhook')
-export class EventWebhookController {
-  constructor(private readonly service: EventWebhookService) {}
-
-  @Get()
-  list(@Pagination() paginationParams) {
-    return this.service.list(paginationParams);
-  }
-
-  @Get(':id')
-  get(@Param('id', ParseIntPipe) id: number) {
-    return this.service.get(id);
-  }
-
-  @Post()
-  create(@Body() data: any) {
-    return this.service.create(data);
-  }
-
-  @Patch(':id')
-  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
-    return this.service.update(id, data);
-  }
-
-  @Delete()
-  delete(@Body() data: DeleteDTO) {
-    return this.service.delete(data);
-  }
-
-  @Get(':id/log')
-  logs(@Param('id', ParseIntPipe) id: number, @Pagination() paginationParams) {
-    return this.service.listLogs(id, paginationParams);
-  }
-}
-
+import { DeleteDTO, Role } from '@hed-hog/api';
+import { Pagination } from '@hed-hog/api-pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { EventWebhookService } from './event-webhook.service';
+
+@Role()
+@Controller('event-webhook')
+export class EventWebhookController {
+  constructor(private readonly service: EventWebhookService) {}
+
+  @Get()
+  list(@Pagination() paginationParams) {
+    return this.service.list(paginationParams);
+  }
+
+  @Get(':id')
+  get(@Param('id', ParseIntPipe) id: number) {
+    return this.service.get(id);
+  }
+
+  @Post()
+  create(@Body() data: any) {
+    return this.service.create(data);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() data: any) {
+    return this.service.update(id, data);
+  }
+
+  @Delete()
+  delete(@Body() data: DeleteDTO) {
+    return this.service.delete(data);
+  }
+
+  @Post(':id/duplicate')
+  duplicate(@Param('id', ParseIntPipe) id: number) {
+    return this.service.duplicate(id);
+  }
+
+  @Get(':id/log')
+  logs(@Param('id', ParseIntPipe) id: number, @Pagination() paginationParams) {
+    return this.service.listLogs(id, paginationParams);
+  }
+}
+