@hed-hog/core 0.0.4

package/src/setting/setting.service.ts

@@ -0,0 +1,673 @@
+import { itemTranslations } from '@hed-hog/api';
+import { getLocaleText, LocaleService } from '@hed-hog/api-locale';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService, setting_type_enum } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    forwardRef,
+    Inject,
+    Injectable,
+} 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 {
+
+  private cachedSettings: Record<string, any> = {};
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+  ) { }
+
+  async exportSettings(includeSecrets = false) {
+    const settings = await this.prismaService.setting.findMany({
+      where: {
+        ...( !includeSecrets ? {
+              NOT: [
+                { type: setting_type_enum.secret },
+              ],
+        } : {}),
+      },
+      select: {
+        slug: true,
+        value: true, 
+      }
+    });
+
+    return settings;
+  }
+
+  async importSettings(file: MulterFile) {
+    const content = file.buffer?.toString('utf-8') || '';
+    let json;
+    try {
+      json = JSON.parse(content);
+    } catch (err) {
+      throw new BadRequestException(getLocaleText('invalidJsonFile', 'en', 'File does not contain valid JSON.'));
+    }
+
+    if (!Array.isArray(json)) {
+      throw new BadRequestException(getLocaleText('invalidJsonArray', 'en', 'The JSON file must contain an array of settings.'));
+    }
+
+    const slugsFromFile = json.map((item: any) => item.slug).filter(Boolean);
+    const existingSettings = await this.prismaService.setting.findMany({
+      where: {
+        slug: {
+          in: slugsFromFile,
+        },
+      },
+      select: {
+        slug: true,
+      },
+    });
+
+    const existingSlugs = existingSettings.map((s) => s.slug);
+    const validSlugs = slugsFromFile.filter((slug: string) => existingSlugs.includes(slug));
+    const invalidSlugs = slugsFromFile.filter((slug: string) => !existingSlugs.includes(slug));
+
+    return {
+      totalSettings: slugsFromFile.length,
+      validSettings: validSlugs.length,
+      invalidSlugs,
+      validSlugs,
+    };
+  }
+
+  async confirmImport(settings: Array<{ slug: string; value: string }>) {
+    this.clearCache();
+    const slugs = settings.map((s) => s.slug);
+    const existingSettings = await this.prismaService.setting.findMany({
+      where: {
+        slug: {
+          in: slugs,
+        },
+      },
+      select: {
+        id: true,
+        slug: true,
+        type: true,
+      },
+    });
+
+    const transaction = [];
+    for (const setting of settings) {
+      const existingSetting = existingSettings.find((s) => s.slug === setting.slug);
+      if (existingSetting) {
+        transaction.push(
+          this.prismaService.setting.update({
+            where: {
+              id: existingSetting.id,
+            },
+            data: {
+              value: this.setValueFormattedByType(existingSetting.type, setting.value),
+            },
+          }),
+        );
+      }
+    }
+
+    if (transaction.length > 0) {
+      await this.prismaService.$transaction(transaction);
+    }
+
+    return { 
+      success: true, 
+      updatedCount: transaction.length,
+    };
+  }
+
+  async getSystemSettings(): Promise<any> {
+    const locales = await this.localeService.getEnables();
+    const slugs = [
+      'system-name',
+      'system-slogan',
+      'icon-url',
+      'image-url',
+      'theme-primary',
+      'theme-primary-foreground',
+      'theme-secondary',
+      'theme-secondary-foreground',
+      'theme-accent',
+      'theme-accent-foreground',
+      'theme-muted',
+      'theme-muted-foreground',
+      'theme-radius',
+      'theme-font',
+      'theme-text-size',
+      'theme-mode',
+      'password-min-symbols',
+      'password-min-numbers',
+      'password-min-uppercase',
+      'password-min-length',
+      'mfa-email-code-length'
+    ];
+    const setting = await this.getSettingValues(slugs);
+    return { locales, setting };
+  }
+
+  async setManySettings(data: SettingDTO) {
+    this.clearCache();
+    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,
+    userId: number,
+  ) {
+    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_list: {
+            select: {
+              id: true,
+              order: true,
+              value: true,
+            },
+            orderBy: {
+              order: 'asc',
+            },
+          },
+          setting_user: {
+            where: {
+              user_id: userId,
+            },
+            select: {
+              setting_id: true,
+              value: 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: {
+          slug: {
+            not: 'hidden',
+          },
+          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) {
+    this.clearCache();
+    return this.prismaService.setting.create({
+      data: {
+        slug: data.slug,
+        type: data.type as any,
+        value: this.setValueFormattedByType(data.type, data.value),
+        user_override: data.user_override,
+        setting_group: {
+          connect: {
+            id: data.group_id,
+          },
+        },
+      },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    this.clearCache();
+
+    const { type } = await this.prismaService.setting.findFirst({
+      where: {
+        id,
+      },
+    });
+
+    if (!type) {
+      throw new BadRequestException(`Setting not found.`);
+    }
+
+    const updatedSetting = await this.prismaService.setting.update({
+      where: { id },
+      data: {
+        slug: data.slug,
+        type: data.type as any,
+        value: this.setValueFormattedByType(data.type, data.value),
+        user_override: data.user_override,
+        setting_group: {
+          connect: {
+            id: data.group_id,
+          },
+        },
+      },
+    });
+
+    // Garantir que o value sobrescreve o valor original
+    const result = { ...updatedSetting };
+    result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
+    return result;
+  }
+
+  async updateFromSlug(slug: string, data: UpdateDTO) {
+    this.clearCache();
+    const { id, type } = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+      },
+    });
+
+    if (!id) {
+      throw new BadRequestException(`Setting with slug ${slug} not found.`);
+    }
+
+    const updatedSetting = await this.prismaService.setting.update({
+      where: { id },
+      data: {
+        value: this.setValueFormattedByType(type, data.value),
+      },
+    });
+
+    const result = { ...updatedSetting };
+    result.value = this.getValueFormattedByType(updatedSetting.type, updatedSetting.value);
+    return result;
+  }
+
+  setValueFormattedByType(type: string, value: any) {
+    switch (type) {
+      case 'boolean':
+        return value === true || value === 'true' ? 'true' : 'false';
+      case 'number':
+        return Number(value).toString();
+      case 'array':
+      case 'json':
+        return typeof value === 'string' ? value : JSON.stringify(value);
+      default:
+        return value;
+    }
+  }
+
+  getValueFormattedByType(type: string, value: any) {
+
+    console.log('getValueFormattedByType', type, value);
+
+    switch (type) {
+      case 'boolean':
+        return value === true || value === 'true' ? 'true' : 'false';
+      case 'number':
+        return Number(value).toString();
+      case 'array':
+      case 'json':
+        return typeof value === 'string' ? value : JSON.stringify(value);
+      default:
+        return value;
+    }
+
+  }
+
+  async delete({ ids }: DeleteDTO) {
+    this.clearCache();
+    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(locale:string, user_id: number, slug: string, value: string) {
+    this.clearCache();
+    const user = await this.prismaService.user.findUnique({
+      where: {
+        id: user_id,
+      },
+      select: {
+        id: true,
+      },
+    });
+
+    if (!user) {
+      throw new BadRequestException(getLocaleText('userNotFound', locale, `User not found.`));
+    }
+
+    const setting = await this.prismaService.setting.findFirst({
+      where: {
+        slug,
+        user_override: true,
+      },
+    });
+
+    if (!setting) {
+      throw new BadRequestException(
+        getLocaleText('settingNotFound', locale, `Setting 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[],
+  ): Promise<Record<string, any>> {
+
+    const slugs = Array.isArray(slug) ? slug : [slug];
+    if (
+      this.cachedSettings &&
+      slugs.every(s => Object.prototype.hasOwnProperty.call(this.cachedSettings, s))
+    ) {
+      // Retorna apenas os slugs requisitados do cache
+      const cached: Record<string, any> = {};
+      slugs.forEach(s => {
+        cached[s] = this.cachedSettings[s];
+      });
+      return cached;
+    }
+
+    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((s) => s.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> = {};
+    const cacheData: Record<string, any> = {};
+
+    for (const s of setting) {
+      switch (s.type) {
+        case 'boolean':
+          data[s.slug] = s.value === 'true';
+          cacheData[s.slug] = s.value === 'true';
+          break;
+        case 'number':
+          data[s.slug] = Number(s.value);
+          cacheData[s.slug] = Number(s.value);
+          break;
+        case 'array':
+        case 'json':
+          try {
+            data[s.slug] = JSON.parse(s.value);
+            cacheData[s.slug] = JSON.parse(s.value);
+          } catch (err) {
+            console.error('Error parsing JSON', s.value, err);
+            data[s.slug] = s.value;
+            cacheData[s.slug] = s.value;
+          }
+          break;
+        default:
+          data[s.slug] = s.value;
+          cacheData[s.slug] = s.value;
+      }
+    }
+
+    // sobrescreve os valores em data, mas NÃO salva no cache
+    settingUser.forEach((ss) => {
+      const slugOverride = slugUserOverride.find((s) => s.id === ss.setting_id)?.slug;
+      if (slugOverride) {
+        data[slugOverride] = ss.value;
+      }
+    });
+
+    this.setCache(cacheData);
+    return data;
+  }
+
+  setCache(value: Record<string, any>) {
+    Object.keys(value).forEach(key => {
+      this.cachedSettings[key] = value[key];
+    });
+    return this.cachedSettings;
+  }
+
+  clearCache() {
+    this.cachedSettings = {};
+  }
+
+  async getUserSettings(user_id: number) {
+    return this.prismaService.setting_user.findMany({
+      where: {
+        user_id,
+      },
+      include: {
+        setting: {
+          select: {
+            slug: true,
+          },
+        },
+      },
+    });
+  }
+
+  async setValue(slug: string, value: string) {
+    this.clearCache();
+    return this.prismaService.setting.updateMany({
+      where: {
+        slug,
+      },
+      data: {
+        value,
+      },
+    });
+  }
+}

package/src/task/task.module.ts

@@ -0,0 +1,9 @@
+import { forwardRef, Module } from "@nestjs/common";
+import { TasksService } from "./task.service";
+import { PrismaModule } from '@hed-hog/api-prisma';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule),],
+  providers: [TasksService],
+})
+export class TaskModule { }