@solidxai/core 0.1.12-beta.0 → 0.1.12-beta.10

package/src/jobs/chatter-mention-notification-email-queue-handler.service.ts

@@ -0,0 +1,114 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { MailFactory } from 'src/factories/mail.factory';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueueMessage } from 'src/interfaces/mq';
+import { UserRepository } from 'src/repository/user.repository';
+import { SettingService } from 'src/services/setting.service';
+import type { SolidCoreSetting } from 'src/services/settings/default-settings-provider.service';
+import { In } from 'typeorm';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueHandler {
+    private readonly logger = new Logger(ChatterMentionNotificationEmailQueueHandler.name);
+
+    constructor(
+        private readonly mailFactory: MailFactory,
+        private readonly userRepository: UserRepository,
+        private readonly settingService: SettingService,
+    ) {}
+
+    private buildAdminRecordFormUrl(frontendAdminBaseUrl: string, moduleName: string, modelName: string, recordId: number) {
+        if (!frontendAdminBaseUrl || !moduleName || !modelName || !recordId) return '';
+        const normalizedModelName = modelName
+            .trim()
+            .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+            .replace(/[_\s]+/g, '-')
+            .toLowerCase();
+        return `${frontendAdminBaseUrl.replace(/\/+$/, '')}/admin/core/${moduleName.trim()}/${normalizedModelName}/form/${recordId}`;
+    }
+
+    async handle(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        const mailService = this.mailFactory.getMailService();
+        const payload = message.payload;
+
+        if (!payload?.mentions?.length) {
+            this.logger.debug('Skipping chatter mention notification because no mentions were provided.');
+            return { sent: 0 };
+        }
+
+        const mentionUserIds = payload.mentions
+            .map(mention => Number(mention.id))
+            .filter(id => Number.isInteger(id) && id > 0);
+        const userIdsToLoad = Array.from(new Set([
+            ...mentionUserIds,
+            ...(payload.actor?.id ? [Number(payload.actor.id)] : []),
+        ]));
+
+        if (userIdsToLoad.length === 0) {
+            this.logger.debug('Skipping chatter mention notification because mention user ids were not provided.');
+            return { sent: 0 };
+        }
+
+        const users = await this.userRepository.find({
+            where: { id: In(userIdsToLoad) },
+        });
+        const usersById = new Map(users.map(user => [Number(user.id), user]));
+        const actor = payload.actor?.id ? usersById.get(Number(payload.actor.id)) : null;
+        const recipients = Array.from(new Set(mentionUserIds))
+            .map(id => {
+                const user = usersById.get(id);
+                const mention = payload.mentions.find(item => Number(item.id) === id);
+                return {
+                    id,
+                    username: user?.username || mention?.username || '',
+                    displayName: user?.fullName || mention?.displayName || user?.username || mention?.username || '',
+                    email: user?.email || '',
+                };
+            })
+            .filter(recipient => Boolean(recipient.email));
+
+        if (recipients.length === 0) {
+            this.logger.debug('Skipping chatter mention notification because no mentioned users have email addresses.');
+            return { sent: 0 };
+        }
+
+        const frontendAdminBaseUrl = this.settingService.getConfigValue<SolidCoreSetting>('frontendAdminBaseUrl');
+        const commonTemplateParams = {
+            mentionedByDisplayName: actor?.fullName || payload.actor?.username || payload.actor?.email || 'Someone',
+            mentionedByEmail: actor?.email || payload.actor?.email,
+            noteBody: payload.noteBody,
+            entityDisplayName: payload.entity.displayName,
+            entityUserKey: payload.entity.userKey,
+            entityFormUrl: this.buildAdminRecordFormUrl(
+                frontendAdminBaseUrl,
+                payload.entity.moduleName,
+                payload.entity.modelName,
+                payload.entity.id,
+            ),
+            solidAppName: this.settingService.getConfigValue<SolidCoreSetting>('appTitle'),
+            solidAppWebsiteUrl: this.settingService.getConfigValue<SolidCoreSetting>('solidAppWebsiteUrl'),
+            companyLogoUrl: this.settingService.getConfigValue<SolidCoreSetting>('companylogo'),
+        };
+
+        let sent = 0;
+        for (const recipient of recipients) {
+            await mailService.sendEmailUsingTemplate(
+                recipient.email,
+                payload.templateName,
+                {
+                    ...commonTemplateParams,
+                    mentionedUserDisplayName: recipient.displayName || recipient.username,
+                    mentionedUserUsername: recipient.username,
+                },
+                false,
+                null,
+                null,
+                payload.parentEntity,
+                payload.parentEntityId,
+            );
+            sent += 1;
+        }
+
+        return { sent };
+    }
+}

package/src/jobs/database/chatter-mention-notification-email-publisher-database.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { DatabasePublisher } from 'src/services/queues/database-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-database';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherDatabase extends DatabasePublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/database/chatter-mention-notification-email-queue-options-database.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue_database';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Database,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/database/chatter-mention-notification-email-subscriber-database.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { PollerService } from 'src/services/poller.service';
+import { DatabaseSubscriber } from 'src/services/queues/database-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-database';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberDatabase extends DatabaseSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        readonly poller: PollerService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService, poller);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/jobs/rabbitmq/chatter-mention-notification-email-publisher.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RabbitMqPublisher } from 'src/services/queues/rabbitmq-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherRabbitmq extends RabbitMqPublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/rabbitmq/chatter-mention-notification-email-queue-options.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.RabbitMQ,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/rabbitmq/chatter-mention-notification-email-subscriber.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RabbitMqSubscriber } from 'src/services/queues/rabbitmq-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberRabbitmq extends RabbitMqSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/jobs/redis/chatter-mention-notification-email-publisher-redis.service.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RedisPublisher } from 'src/services/queues/redis-publisher.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-redis';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueuePublisherRedis extends RedisPublisher<ChatterMentionNotificationPayload> {
+    constructor(
+        protected readonly mqMessageService: MqMessageService,
+        protected readonly mqMessageQueueService: MqMessageQueueService,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+}

package/src/jobs/redis/chatter-mention-notification-email-queue-options-redis.ts

@@ -0,0 +1,9 @@
+import { BrokerType } from "src/interfaces";
+
+const QUEUE_NAME = 'solid_chatter_mention_notification_email_queue_redis';
+
+export default {
+    name: QUEUE_NAME,
+    type: BrokerType.Redis,
+    queueName: QUEUE_NAME,
+};

package/src/jobs/redis/chatter-mention-notification-email-subscriber-redis.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { ChatterMentionNotificationEmailQueueHandler } from 'src/jobs/chatter-mention-notification-email-queue-handler.service';
+import { ChatterMentionNotificationPayload } from 'src/interfaces/chatter-mention-notification.interface';
+import { QueuesModuleOptions } from 'src/interfaces';
+import { QueueMessage } from 'src/interfaces/mq';
+import { MqMessageQueueService } from 'src/services/mq-message-queue.service';
+import { MqMessageService } from 'src/services/mq-message.service';
+import { RedisSubscriber } from 'src/services/queues/redis-subscriber.service';
+import queueOptions from './chatter-mention-notification-email-queue-options-redis';
+
+@Injectable()
+export class ChatterMentionNotificationEmailQueueSubscriberRedis extends RedisSubscriber<ChatterMentionNotificationPayload> {
+    constructor(
+        readonly mqMessageService: MqMessageService,
+        readonly mqMessageQueueService: MqMessageQueueService,
+        private readonly handler: ChatterMentionNotificationEmailQueueHandler,
+    ) {
+        super(mqMessageService, mqMessageQueueService);
+    }
+
+    options(): QueuesModuleOptions {
+        return {
+            ...queueOptions
+        };
+    }
+
+    subscribe(message: QueueMessage<ChatterMentionNotificationPayload>) {
+        return this.handler.handle(message);
+    }
+}

package/src/repository/media.repository.ts

@@ -44,6 +44,7 @@ export class MediaRepository extends SolidBaseRepository<Media> {
                 id: createDto['mediaStorageProviderMetadataId']
             },
         });
+        // delete createDto['isPublic'];
         const media = this.create(createDto);
         return this.save(media);
     }

package/src/seeders/module-metadata-seeder.service.ts

@@ -1,4 +1,5 @@
 import { forwardRef, Inject, Injectable, Logger } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
@@ -39,7 +40,12 @@ import { User } from '../entities/user.entity';
 import { MENU_ROLE_JOIN_TABLE_NAME, MENU_ROLE_JOIN_TABLE_NAME_MENU_COL, MENU_ROLE_JOIN_TABLE_NAME_ROLE_COL } from '../dtos/create-menu-item-metadata.dto';
 import { DEFAULT_SA_PASSWORD } from '../dtos/create-user.dto';
 import { SignUpDto } from '../dtos/sign-up.dto';
-import { ADMIN_ROLE_NAME, CreateRoleMetadataDto } from 'src/dtos/create-role-metadata.dto';
+import {
+    ADMIN_ROLE_NAME,
+    ALLOWED_TO_EXPORT_ROLE_NAME,
+    ALLOWED_TO_IMPORT_ROLE_NAME,
+    CreateRoleMetadataDto,
+} from 'src/dtos/create-role-metadata.dto';
 import { CreateSavedFiltersDto } from 'src/dtos/create-saved-filters.dto';
 import { CreateScheduledJobDto } from 'src/dtos/create-scheduled-job.dto';
 import { CreateLocaleDto } from 'src/dtos/create-locale.dto';
@@ -60,6 +66,7 @@ import { FieldMetadata } from 'src/entities/field-metadata.entity';
 import { ModelMetadata } from 'src/entities/model-metadata.entity';
 import { PermissionMetadata } from 'src/entities/permission-metadata.entity';
 import { ViewMetadata } from 'src/entities/view-metadata.entity';
+import { EventDetails, EventType, ModuleMetadataSeederEventPayload } from 'src/interfaces';
 
 /**
  * Central metadata seeder for both solid-core and consuming modules.
@@ -79,6 +86,11 @@ import { ViewMetadata } from 'src/entities/view-metadata.entity';
  */
 @Injectable()
 export class ModuleMetadataSeederService {
+    private readonly adminPermissionExclusionPrefixes = [
+        'ImportTransactionController.',
+        'ExportTemplateController.',
+        'ExportTransactionController.',
+    ];
     private readonly logger = new Logger(ModuleMetadataSeederService.name);
     // Stable tag used on all verbose seed timing logs so runs can be grepped quickly.
     private readonly seedTimingTag = 'SEED_TIMING';
@@ -98,6 +110,7 @@ export class ModuleMetadataSeederService {
         private readonly moduleMetadataService: ModuleMetadataService,
         @Inject(forwardRef(() => ModelMetadataService))
         private readonly modelMetadataService: ModelMetadataService,
+        private readonly eventEmitter: EventEmitter2,
         private readonly fieldMetadataService: FieldMetadataService,
         private readonly mediaStorageProviderMetadataService: MediaStorageProviderMetadataService,
         private readonly roleService: RoleMetadataService,
@@ -131,7 +144,26 @@ export class ModuleMetadataSeederService {
         let currentModule = 'global';
         let currentStep = 'bootstrap';
         let modulesToSeed: string[] | null = null;
+        const requestedModulesToSeed = Array.isArray(conf?.modulesToSeed) ? [...conf.modulesToSeed] : null;
         const shouldSeedGlobalMetadata = conf?.seedGlobalMetadata !== false;
+        const seedOptions: ModuleMetadataSeederEventPayload['options'] = {
+            modulesToSeed: requestedModulesToSeed,
+            pruneMetadata: Boolean(conf?.pruneMetadata),
+            seedGlobalMetadata: shouldSeedGlobalMetadata,
+        };
+        const seedRunId = uuidv4();
+        const startedAt = new Date();
+        const seededModuleNames: string[] = [];
+
+        this.emitModuleMetadataSeederEvent(
+            EventType.MODULE_METADATA_SEEDER_STARTED,
+            {
+                seedRunId,
+                options: seedOptions,
+                startedAt: startedAt.toISOString(),
+                currentStep,
+            },
+        );
 
         try {
             this.enablePruning = Boolean(conf?.pruneMetadata);
@@ -190,6 +222,7 @@ export class ModuleMetadataSeederService {
 
                     console.log(`▶ Seeding Metadata for Module: ${moduleMetadata.name}`);
                     this.logger.log(`Seeding Metadata for Module: ${moduleMetadata.name}`);
+                    seededModuleNames.push(moduleMetadata.name);
 
                     await this.timeOperation('module-total', async () => {
                         currentStep = 'seedMediaStorageProviders';
@@ -283,10 +316,37 @@ export class ModuleMetadataSeederService {
             // Add a console log indicating seeding is finished. This needs to be console.log so that it looks proper when this code is run via CLI.
             console.log(`✔ Seeding completed.`);
             //this.logger.log(`All Seeders finished`);
+            await this.emitModuleMetadataSeederFinishedEvent(
+                EventType.MODULE_METADATA_SEEDER_FINISHED,
+                {
+                    seedRunId,
+                    options: seedOptions,
+                    startedAt: startedAt.toISOString(),
+                    finishedAt: new Date().toISOString(),
+                    durationMs: Date.now() - startedAt.getTime(),
+                    success: true,
+                    seededModuleNames,
+                    currentStep,
+                },
+            );
 
             //FIXME: Handle displaying the created users credentials in a better way.
             // this.logger.log(`Newly created username is: ${usersDetail?.length > 0 ? usersDetail[0]?.username : ''} and password is ${usersDetail?.length > 0 ? usersDetail[0]?.password : ''}`);
         } catch (error: any) {
+            await this.emitModuleMetadataSeederFinishedEvent(
+                EventType.MODULE_METADATA_SEEDER_FINISHED,
+                {
+                    seedRunId,
+                    options: seedOptions,
+                    startedAt: startedAt.toISOString(),
+                    finishedAt: new Date().toISOString(),
+                    durationMs: Date.now() - startedAt.getTime(),
+                    success: false,
+                    seededModuleNames,
+                    currentStep,
+                    errorMessage: error?.message,
+                },
+            );
             this.logSeedFailureForCli(error, {
                 moduleName: currentModule,
                 step: currentStep,
@@ -297,6 +357,31 @@ export class ModuleMetadataSeederService {
         }
     }
 
+    private emitModuleMetadataSeederEvent(
+        type: EventType.MODULE_METADATA_SEEDER_STARTED | EventType.MODULE_METADATA_SEEDER_FINISHED,
+        payload: ModuleMetadataSeederEventPayload,
+    ): void {
+        try {
+            this.eventEmitter.emit(type, new EventDetails<ModuleMetadataSeederEventPayload>(type, payload));
+        } catch (error: any) {
+            this.logger.warn(`Failed to emit ${type}: ${error?.message ?? error}`);
+        }
+    }
+
+    private async emitModuleMetadataSeederFinishedEvent(
+        type: EventType.MODULE_METADATA_SEEDER_FINISHED,
+        payload: ModuleMetadataSeederEventPayload,
+    ): Promise<void> {
+        try {
+            console.log(`▶ Running post-seed hooks for runId=${payload.seedRunId}`);
+            await this.eventEmitter.emitAsync(type, new EventDetails<ModuleMetadataSeederEventPayload>(type, payload));
+            console.log(`✔ Post-seed hooks completed for runId=${payload.seedRunId}`);
+        } catch (error: any) {
+            console.log(`✖ Post-seed hooks failed for runId=${payload.seedRunId}: ${error?.message ?? error}`);
+            this.logger.warn(`Failed to emit ${type}: ${error?.message ?? error}`);
+        }
+    }
+
     private buildTimingPrefix(itemTag: string, options?: { moduleName?: string; component?: string; serviceCall?: string }): string {
         const parts = [`[${this.seedTimingTag}]`, `[ITEM:${itemTag}]`];
         if (options?.moduleName) {
@@ -498,10 +583,17 @@ export class ModuleMetadataSeederService {
 
     private async setupDefaultRolesWithPermissions() {
         this.logger.debug(`About to add all permissions to the Admin role`);
-        await this.timeOperation('role-add-all-permissions', () => this.roleService.addAllPermissionsToRole(ADMIN_ROLE_NAME), {
+        await this.timeOperation('role-add-all-permissions', () => this.roleService.addAllPermissionsToRoleExceptPrefixes(ADMIN_ROLE_NAME, this.adminPermissionExclusionPrefixes), {
+            moduleName: 'global',
+            component: 'default-roles',
+            serviceCall: 'roleService.addAllPermissionsToRoleExceptPrefixes',
+            details: `role=${ADMIN_ROLE_NAME}`,
+        });
+
+        await this.timeOperation('attach-capability-roles-to-admin-users', () => this.attachCapabilityRolesToAdminUsers(), {
             moduleName: 'global',
             component: 'default-roles',
-            serviceCall: 'roleService.addAllPermissionsToRole',
+            serviceCall: 'attachCapabilityRolesToAdminUsers',
             details: `role=${ADMIN_ROLE_NAME}`,
         });
 
@@ -514,6 +606,20 @@ export class ModuleMetadataSeederService {
         // await this.roleService.addPermissionToRole(PUBLIC_ROLE_NAME, ['SettingController.wrapSettings', 'AuthenticationController.logout']);
     }
 
+    private async attachCapabilityRolesToAdminUsers(): Promise<void> {
+        const adminUsers = await this.userService.findUsersByRole(ADMIN_ROLE_NAME, {});
+        if (!adminUsers?.length) {
+            return;
+        }
+
+        const capabilityRoles = [ALLOWED_TO_IMPORT_ROLE_NAME, ALLOWED_TO_EXPORT_ROLE_NAME];
+        for (const adminUser of adminUsers) {
+            for (const capabilityRole of capabilityRoles) {
+                await this.userService.addRoleToUser(adminUser.username, capabilityRole);
+            }
+        }
+    }
+
     private async seedSecurityRules(overallMetadata: any): Promise<{ pruned: number; upserted: number }> {
         const securityRules = this.getSeedArray<CreateSecurityRuleDto>(overallMetadata?.securityRules);
         const pruned = this.enablePruning ? await this.timeOperation('prune-security-rules', () => this.pruneSecurityRules(securityRules, overallMetadata?.moduleMetadata?.name), {

package/src/seeders/permission-metadata-seeder.service.ts

@@ -6,6 +6,11 @@ import { RoleMetadataService } from '../services/role-metadata.service';
 @Injectable()
 export class PermissionMetadataSeederService {
   private readonly logger = new Logger(PermissionMetadataSeederService.name);
+  private readonly adminPermissionExclusionPrefixes = [
+    'ImportTransactionController.',
+    'ExportTemplateController.',
+    'ExportTransactionController.',
+  ];
 
   constructor(
     // @InjectRepository(PermissionMetadata)
@@ -58,6 +63,6 @@ export class PermissionMetadataSeederService {
     }
 
     // Associate the Admin role with all existing permissions. 
-    await this.roleService.addAllPermissionsToRole("Admin");
+    await this.roleService.addAllPermissionsToRoleExceptPrefixes("Admin", this.adminPermissionExclusionPrefixes);
   }
 }