@hed-hog/core 0.0.237 → 0.0.238

package/src/dashboard/dashboard-component-role/dashboard-component-role.service.ts

@@ -7,7 +7,10 @@ import {
     Injectable,
     NotFoundException,
 } from '@nestjs/common';
-import { CreateDashboardComponentRoleDTO } from './dto';
+import {
+    CreateDashboardComponentRoleBatchDTO,
+    CreateDashboardComponentRoleDTO,
+} from './dto';
 
 @Injectable()
 export class DashboardComponentRoleService {
@@ -117,6 +120,46 @@ export class DashboardComponentRoleService {
     });
   }
 
+  async createBatch(data: CreateDashboardComponentRoleBatchDTO, locale: string) {
+    const uniqueRoleIds = [...new Set(data.role_ids)];
+
+    const existingRelations = await this.prismaService.dashboard_component_role.findMany({
+      where: {
+        component_id: data.component_id,
+        role_id: {
+          in: uniqueRoleIds,
+        },
+      },
+      select: {
+        role_id: true,
+      },
+    });
+
+    const existingRoleIds = new Set(existingRelations.map((item) => item.role_id));
+    const roleIdsToCreate = uniqueRoleIds.filter((roleId) => !existingRoleIds.has(roleId));
+
+    if (roleIdsToCreate.length > 0) {
+      await this.prismaService.dashboard_component_role.createMany({
+        data: roleIdsToCreate.map((roleId) => ({
+          component_id: data.component_id,
+          role_id: roleId,
+        })),
+        skipDuplicates: true,
+      });
+    }
+
+    return {
+      success: true,
+      created: roleIdsToCreate.length,
+      skipped: uniqueRoleIds.length - roleIdsToCreate.length,
+      message: getLocaleText(
+        'dashboardComponentRoleBatchCreated',
+        locale,
+        'Dashboard component roles processed successfully',
+      ),
+    };
+  }
+
   async delete(id: number, locale: string) {
     const relation = await this.prismaService.dashboard_component_role.findUnique({
       where: { id },

package/src/dashboard/dashboard-component-role/dto/create-batch.dto.ts

@@ -0,0 +1,11 @@
+import { ArrayNotEmpty, IsArray, IsInt } from 'class-validator';
+
+export class CreateDashboardComponentRoleBatchDTO {
+  @IsInt()
+  component_id: number;
+
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsInt({ each: true })
+  role_ids: number[];
+}

package/src/dashboard/dashboard-component-role/dto/index.ts

@@ -1 +1,3 @@
+export * from './create-batch.dto';
 export * from './create.dto';
+

package/src/dashboard/dashboard-role/dashboard-role.controller.ts

@@ -2,19 +2,22 @@ import { Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Inject,
-  Param,
-  ParseIntPipe,
-  Post,
-  Query,
-  forwardRef,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Inject,
+    Param,
+    ParseIntPipe,
+    Post,
+    Query,
+    forwardRef,
 } from '@nestjs/common';
 import { DashboardRoleService } from './dashboard-role.service';
-import { CreateDashboardRoleDTO } from './dto';
+import {
+    CreateDashboardRoleBatchDTO,
+    CreateDashboardRoleDTO,
+} from './dto';
 
 @Role()
 @Controller('dashboard-role')
@@ -38,6 +41,14 @@ export class DashboardRoleController {
     return this.service.create(data, locale);
   }
 
+  @Post('batch')
+  createBatch(
+    @Body() data: CreateDashboardRoleBatchDTO,
+    @Locale() locale: string,
+  ) {
+    return this.service.createBatch(data, locale);
+  }
+
   @Delete(':id')
   delete(@Param('id', ParseIntPipe) id: number, @Locale() locale: string) {
     return this.service.delete(id, locale);

package/src/dashboard/dashboard-role/dashboard-role.service.ts

@@ -2,12 +2,15 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  forwardRef,
-  Inject,
-  Injectable,
-  NotFoundException,
+    forwardRef,
+    Inject,
+    Injectable,
+    NotFoundException,
 } from '@nestjs/common';
-import { CreateDashboardRoleDTO } from './dto';
+import {
+    CreateDashboardRoleBatchDTO,
+    CreateDashboardRoleDTO,
+} from './dto';
 
 @Injectable()
 export class DashboardRoleService {
@@ -116,6 +119,46 @@ export class DashboardRoleService {
     });
   }
 
+  async createBatch(data: CreateDashboardRoleBatchDTO, locale: string) {
+    const uniqueRoleIds = [...new Set(data.role_ids)];
+
+    const existingRelations = await this.prismaService.dashboard_role.findMany({
+      where: {
+        dashboard_id: data.dashboard_id,
+        role_id: {
+          in: uniqueRoleIds,
+        },
+      },
+      select: {
+        role_id: true,
+      },
+    });
+
+    const existingRoleIds = new Set(existingRelations.map((item) => item.role_id));
+    const roleIdsToCreate = uniqueRoleIds.filter((roleId) => !existingRoleIds.has(roleId));
+
+    if (roleIdsToCreate.length > 0) {
+      await this.prismaService.dashboard_role.createMany({
+        data: roleIdsToCreate.map((roleId) => ({
+          dashboard_id: data.dashboard_id,
+          role_id: roleId,
+        })),
+        skipDuplicates: true,
+      });
+    }
+
+    return {
+      success: true,
+      created: roleIdsToCreate.length,
+      skipped: uniqueRoleIds.length - roleIdsToCreate.length,
+      message: getLocaleText(
+        'dashboardRoleBatchCreated',
+        locale,
+        'Dashboard roles processed successfully',
+      ),
+    };
+  }
+
   async delete(id: number, locale: string) {
     const relation = await this.prismaService.dashboard_role.findUnique({ where: { id } });
 

package/src/dashboard/dashboard-role/dto/create-batch.dto.ts

@@ -0,0 +1,11 @@
+import { ArrayNotEmpty, IsArray, IsInt } from 'class-validator';
+
+export class CreateDashboardRoleBatchDTO {
+  @IsInt()
+  dashboard_id: number;
+
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsInt({ each: true })
+  role_ids: number[];
+}

package/src/dashboard/dashboard-role/dto/index.ts

@@ -1 +1,3 @@
+export * from './create-batch.dto';
 export * from './create.dto';
+

package/src/file/file.controller.ts

@@ -44,13 +44,13 @@ export class FileController {
     return this.fileService.get(id);
   }
 
-  @Public()
-  @Get('open/:fileId')
-  async getLocalFile(
-    @Param('fileId', ParseIntPipe) fileId: number,
-    @Res() res,
-  ) {
-    return this.fileService.getLocalFile(fileId, res)
+  @Put('open/:id')
+  async getTempOpenURL(@Param('id', ParseIntPipe) id: number) {
+    return {
+      url: await this.fileService.tempOpenURL(
+        (await this.fileService.get(id)).path,
+      ),
+    };
   }
 
   @Put('download/:id')
@@ -109,6 +109,49 @@ export class FileController {
     }
   }
 
+  @Public()
+  @Get('open/:token')
+  async open(
+    @Param('token') token: string,
+    @Res({ passthrough: true }) res: Response,
+    @Locale() locale: string,
+  ) {
+
+    try {
+
+      const { stream, filename, mimetype } = await this.fileService.download(locale, token);
+
+      res.set({
+        'Content-Type': mimetype || 'application/octet-stream',
+        'Content-Disposition': `inline; filename="${filename}"`,
+      });
+
+      return new StreamableFile(stream);
+
+    } catch (error:any) {
+      const errorTitle = getLocaleText('file.download.error_title', locale);
+      const errorMessage = getLocaleText('file.download.error_message', locale);
+      const errorDetailsLabel = getLocaleText('file.download.error_details', locale);
+      const goBackText = getLocaleText('file.download.go_back', locale);
+
+      const templatePath = join(__dirname, 'templates', 'download-error.html');
+      const templateSource = readFileSync(templatePath, 'utf-8');
+      const template = Handlebars.compile(templateSource);
+
+      const html = template({
+        locale: locale || 'en',
+        errorTitle,
+        errorMessage,
+        errorDetailsLabel,
+        errorDetails: error?.message || 'Unknown error occurred',
+        goBackText,
+      });
+
+      res.set('Content-Type', 'text/html');
+      return html;
+    }
+  }
+
   @Post()
   @UseInterceptors(FileInterceptor('file'))
   async upload(

package/src/file/file.service.ts

@@ -423,4 +423,14 @@ export class FileService implements OnModuleInit {
   async tempURL(filepath: string, expires = 3600) {
     return (await this.getProvider()).tempURL(filepath, expires);
   }
+
+  async tempOpenURL(filepath: string, expires = 3600) {
+    const url = await this.tempURL(filepath, expires);
+
+    if (typeof url === 'string') {
+      return url.replace('/file/download/', '/file/open/');
+    }
+
+    return url;
+  }
 }

package/src/user/user.controller.ts

@@ -1,4 +1,4 @@
-import { Role } from '@hed-hog/api';
+import { Public, Role } from '@hed-hog/api';
 import { Locale } from '@hed-hog/api-locale';
 import { Pagination } from '@hed-hog/api-pagination';
 import {
@@ -12,6 +12,7 @@ import {
   ParseIntPipe,
   Patch,
   Post,
+  Res,
   UploadedFile,
   UseInterceptors,
   forwardRef,
@@ -40,6 +41,16 @@ export class UserController {
     return this.userService.get(locale, userId);
   }
 
+  @Public()
+  @Get('avatar/:fileId')
+  async openPublicAvatar(
+    @Param('fileId', ParseIntPipe) fileId: number,
+    @Locale() locale: string,
+    @Res() res,
+  ) {
+    return this.userService.openPublicAvatar(locale, fileId, res);
+  }
+
   @Post()
   async create(@Body() data: CreateWithEmailAndPasswordDTO, @Locale() locale: string) {
     return this.userService.createWithEmailAndPassword(locale, data);

package/src/user/user.service.ts

@@ -2,11 +2,11 @@ import { getLocaleText } from '@hed-hog/api-locale';
 import { PaginationService } from '@hed-hog/api-pagination';
 import { PrismaService } from '@hed-hog/api-prisma';
 import {
-  BadRequestException,
-  Inject,
-  Injectable,
-  NotFoundException,
-  forwardRef,
+    BadRequestException,
+    Inject,
+    Injectable,
+    NotFoundException,
+    forwardRef,
 } from '@nestjs/common';
 import { ChallengeService } from '../challenge/challenge.service';
 import { DeleteDTO } from '../dto/delete.dto';
@@ -238,6 +238,33 @@ export class UserService {
     };
   }
 
+  async openPublicAvatar(locale: string, fileId: number, res: any) {
+    const userWithAvatar = await this.prismaService.user.findFirst({
+      where: {
+        photo_id: fileId,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!userWithAvatar) {
+      throw new NotFoundException(
+        getLocaleText('userNotFound', locale, 'User not found')
+      );
+    }
+
+    const { file, buffer } = await this.file.getBuffer(fileId);
+
+    res.set({
+      'Content-Type': file.file_mimetype.name,
+      'Content-Length': buffer.length,
+      'Cache-Control': 'public, max-age=3600',
+    });
+
+    res.send(buffer);
+  }
+
   // ==========================================
   // User Lookup Methods
   // ==========================================