@hedhog/admin 0.48.10 → 0.48.11

package/src/setting/dto/setting.dto.ts

@@ -0,0 +1,17 @@
+import { Type } from 'class-transformer';
+import { IsArray, IsString, ValidateNested } from 'class-validator';
+
+class Setting {
+  @IsString()
+  slug: string;
+
+  @IsString()
+  value: string;
+}
+
+export class SettingDTO {
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => Setting)
+  setting: Setting[];
+}

package/src/setting/dto/update.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateDTO } from './create.dto';
+
+export class UpdateDTO extends PartialType(CreateDTO) {}

package/src/setting/setting.controller.ts

@@ -0,0 +1,105 @@
+import { Public, Role, User } from '@hedhog/core';
+import { Locale } from '@hedhog/locale';
+import { Pagination } from '@hedhog/pagination';
+import {
+  Body,
+  Controller,
+  Delete,
+  forwardRef,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Put,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from './dto/delete.dto';
+import { SettingUserDTO } from './dto/setting-user.dto';
+import { SettingDTO } from './dto/setting.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { SettingService } from './setting.service';
+
+@Role()
+@Controller('setting')
+export class SettingsController {
+  constructor(
+    @Inject(forwardRef(() => SettingService))
+    private readonly settingService: SettingService,
+  ) {}
+
+  @Get('group/:slug')
+  async getSettingFromGroup(
+    @Pagination() paginationParams,
+    @Locale() locale,
+    @Param('slug') slug: string,
+  ) {
+    return this.settingService.getSettingFromGroup(
+      locale,
+      paginationParams,
+      slug,
+    );
+  }
+
+  @Public()
+  @Get('group')
+  async listSettingGroups(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettingGroups(locale, paginationParams);
+  }
+
+  @Get('/user')
+  async getUserSettings(@User() { id }) {
+    return this.settingService.getUserSettings(id);
+  }
+
+  @Get()
+  async listSettings(@Pagination() paginationParams, @Locale() locale) {
+    return this.settingService.listSettings(locale, paginationParams);
+  }
+
+  @Get(':settingId')
+  async get(@Param('settingId', ParseIntPipe) settingId: number) {
+    return this.settingService.get(settingId);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.settingService.create(data);
+  }
+
+  @Put('user/:slug')
+  async updateUserFromSlug(
+    @Param('slug') slug: string,
+    @Body() { value }: SettingUserDTO,
+    @User() { id },
+  ) {
+    return this.settingService.setSettingUserValue(id, slug, value);
+  }
+
+  @Put(':slug')
+  async updateFromSlug(@Param('slug') slug: string, @Body() data: UpdateDTO) {
+    return this.settingService.updateFromSlug(slug, data);
+  }
+
+  @Put()
+  async setManySettings(@Body() data: SettingDTO) {
+    return this.settingService.setManySettings(data);
+  }
+
+  @Patch(':settingId')
+  async update(
+    @Param('settingId', ParseIntPipe) settingId: number,
+    @Body() data: UpdateDTO,
+  ) {
+    return this.settingService.update({
+      id: settingId,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.settingService.delete(data);
+  }
+}

package/src/setting/setting.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { SettingsController } from './setting.controller';
+import { SettingService } from './setting.service';
+
+@Module({
+  imports: [],
+  controllers: [SettingsController],
+  providers: [SettingService],
+  exports: [SettingService],
+})
+export class SettingModule {}

package/src/setting/setting.service.ts

@@ -0,0 +1,400 @@
+import path = require('path');
+import { itemTranslations } from '@hedhog/core';
+import { PaginationDTO, PaginationService } from '@hedhog/pagination';
+import { PrismaService } from '@hedhog/prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from './dto/delete.dto';
+import { SettingDTO } from './dto/setting.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class SettingService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async setManySettings(data: SettingDTO) {
+    const transaction = [];
+
+    for (const { slug, value } of data.setting) {
+      transaction.push(
+        this.prismaService.setting.updateMany({
+          where: {
+            slug,
+          },
+          data: {
+            value,
+          },
+        }),
+      );
+    }
+
+    await this.prismaService.$transaction(transaction);
+    return { success: true };
+  }
+
+  async getSettingFromGroup(locale: any, paginationParams: any, slug: string) {
+    const fields = ['slug', 'value'];
+
+    paginationParams.pageSize = 100;
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting,
+      paginationParams,
+      {
+        where: {
+          AND: {
+            setting_group: {
+              slug,
+            },
+            OR,
+          },
+        },
+        include: {
+          setting_group: {
+            include: {
+              setting_group_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
+          setting_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_locale',
+    );
+
+    result.data = result.data.map((setting: any) => {
+      setting.setting_group = itemTranslations(
+        'setting_group_locale',
+        setting.setting_group,
+      );
+      return setting;
+    });
+
+    return result;
+  }
+
+  async listSettingGroups(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'icon'];
+
+    paginationParams.pageSize = 100;
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting_group,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          setting_group_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_group_locale',
+    );
+
+    return result;
+  }
+
+  async listSettings(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['slug', 'value'];
+
+    const OR: any[] = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    const result = await this.paginationService.paginate(
+      this.prismaService.setting,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          setting_group: {
+            include: {
+              setting_group_locale: {
+                where: {
+                  locale: {
+                    code: locale,
+                  },
+                },
+                select: {
+                  name: true,
+                  description: true,
+                },
+              },
+            },
+          },
+          setting_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+        },
+      },
+      'setting_locale',
+    );
+
+    result.data = result.data.map((setting: any) => {
+      setting.setting_group = itemTranslations(
+        'setting_group_locale',
+        setting.setting_group,
+      );
+      return setting;
+    });
+
+    return result;
+  }
+
+  async get(settingId: number) {
+    return this.prismaService.setting.findUnique({
+      where: { id: settingId },
+    });
+  }
+
+  async create(data: CreateDTO) {
+    return this.prismaService.setting.create({
+      data: {
+        slug: data.slug,
+        type: data.type as any,
+        value: data.value,
+        user_override: data.user_override,
+        setting_group: {
+          connect: {
+            id: data.group_id,
+          },
+        },
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.setting.update({
+      where: { id },
+      data: {
+        slug: data.slug,
+        type: data.type as any,
+        value: data.value,
+        user_override: data.user_override,
+        setting_group: {
+          connect: {
+            id: data.group_id,
+          },
+        },
+      },
+    });
+  }
+
+  async updateFromSlug(slug: string, data: UpdateDTO) {
+    const { id } = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+      },
+    });
+
+    if (!id) {
+      throw new BadRequestException(`Setting with slug ${slug} not found.`);
+    }
+
+    return this.update({
+      id,
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        `You must select at least one setting to delete.`,
+      );
+    }
+
+    return this.prismaService.setting.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async setSettingUserValue(user_id: number, slug: string, value: string) {
+    const user = await this.prismaService.user.findUnique({
+      where: {
+        id: user_id,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!user) {
+      throw new BadRequestException(`User with id ${user_id} not found.`);
+    }
+
+    const setting = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+        user_override: true,
+      },
+    });
+
+    if (!setting) {
+      throw new BadRequestException(
+        `Setting with slug ${slug} not found or user can not override.`,
+      );
+    }
+
+    return await this.prismaService.setting_user.upsert({
+      where: {
+        user_id_setting_id: {
+          setting_id: setting.id,
+          user_id: user.id,
+        },
+      },
+      create: {
+        setting_id: setting.id,
+        value,
+        user_id: user.id,
+      },
+      update: {
+        value,
+      },
+      select: {
+        setting_id: true,
+        user_id: true,
+        value: true,
+      },
+    });
+  }
+
+  async getSettingValues(slug: string | string[]) {
+    slug = Array.isArray(slug) ? slug : [slug];
+
+    let setting = await this.prismaService.setting.findMany({
+      where: {
+        slug: {
+          in: slug,
+        },
+      },
+      select: {
+        id: true,
+        value: true,
+        slug: true,
+        type: true,
+        user_override: true,
+      },
+    });
+
+    const slugUserOverride = setting.filter((setting) => setting.user_override);
+
+    const settingUser = await this.prismaService.setting_user.findMany({
+      where: {
+        setting_id: {
+          in: slugUserOverride.map((setting) => setting.id),
+        },
+      },
+      select: {
+        value: true,
+        setting_id: true,
+      },
+    });
+
+    const data: Record<string, any> = {};
+
+    setting.forEach((setting) => {
+      switch (setting.type) {
+        case 'boolean':
+          data[setting.slug] = setting.value === 'true';
+          break;
+        case 'number':
+          data[setting.slug] = Number(setting.value);
+          break;
+        case 'array':
+        case 'json':
+          data[setting.slug] = JSON.parse(setting.value);
+          break;
+        default:
+          data[setting.slug] = setting.value;
+      }
+    });
+
+    settingUser.forEach((setting) => {
+      data[slugUserOverride.find((s) => s.id === setting.setting_id).slug] =
+        setting.value;
+    });
+
+    return data;
+  }
+
+  async getUserSettings(user_id: number) {
+    return this.prismaService.setting_user.findMany({
+      where: {
+        user_id,
+      },
+      include: {
+        setting: {
+          select: {
+            slug: true,
+          },
+        },
+      },
+    });
+  }
+}