@hed-hog/core 0.0.4

package/src/core/system.service.ts

@@ -0,0 +1,296 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+import { exec } from 'child_process';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+
+@Injectable()
+export class SystemService {
+  constructor(private prismaService: PrismaService) {}
+
+  async index() {
+    const cpus = os.cpus();
+    const totalSpeed = cpus.reduce((acc, cpu) => acc + cpu.speed, 0);
+    const averageSpeed = totalSpeed / cpus.length;
+
+    return {
+      os: {
+        name: this.getFriendlyOSName(),
+        platform: os.platform(),
+        version: os.release(),
+        architecture: os.arch(),
+        uptime: os.uptime(),
+        cpu: this.getCpuInfo(cpus, averageSpeed),
+        memory: this.getMemoryInfo(),
+        disk: await this.getDiskInfo(),
+      },
+      modules: await this.getModulesInfo(),
+      users: await this.getUsersInfo(),
+      database: await this.getDatabaseInfo(),
+    };
+  }
+
+  private getFriendlyOSName() {
+    switch (os.platform()) {
+      case 'aix':
+        return `AIX`;
+      case 'darwin':
+        return `macOS`;
+      case 'freebsd':
+        return `FreeBSD`;
+      case 'linux':
+        return `Linux`;
+      case 'openbsd':
+        return `OpenBSD`;
+      case 'sunos':
+        return `SunOS`;
+      case 'win32':
+        return `Windows`;
+      default:
+        return `Unknown`;
+    }
+  }
+
+  private async getDatabaseInfo() {
+    let connections, size, queriesPerSecond;
+
+    if (process.env.DATABASE_URL.includes('postgres')) {
+      [connections, size, queriesPerSecond] = await Promise.all([
+        this.prismaService.$queryRaw`SELECT COUNT(*) FROM pg_stat_activity`, // For PostgreSQL
+        this.prismaService
+          .$queryRaw`SELECT pg_database_size(current_database())`, // For PostgreSQL
+        this.prismaService
+          .$queryRaw`SELECT sum(numbackends) FROM pg_stat_database`, // For PostgreSQL
+      ]);
+    } else if (process.env.DATABASE_URL.includes('mysql')) {
+      [connections, size, queriesPerSecond] = await Promise.all([
+        this.prismaService
+          .$queryRaw`SHOW STATUS WHERE variable_name = 'Threads_connected'`, // For MySQL
+        this.prismaService
+          .$queryRaw`SELECT SUM(data_length + index_length) AS size FROM information_schema.tables WHERE table_schema = DATABASE()`, // For MySQL
+        this.prismaService
+          .$queryRaw`SHOW STATUS WHERE variable_name = 'Queries'`, // For MySQL
+      ]);
+    } else {
+      throw new Error('Unsupported database type');
+    }
+
+    return {
+      connections: +String(connections[0].count || connections[0].Value) || 0,
+      size: +String(size[0].pg_database_size || size[0].size) || 0,
+      queriesPerSecond:
+        +String(queriesPerSecond[0].sum || queriesPerSecond[0].Value) || 0,
+    };
+  }
+
+  private async getUsersInfo() {
+    const users = await this.prismaService.user.findMany({
+      include: {
+        role_user: {
+          where: {
+            role_id: 1,
+          },
+          select: {
+            role_id: true,
+          },
+        },
+      },
+    });
+
+    const activities = await this.prismaService.user_activity.findMany({
+      where: {
+        created_at: {
+          gte: new Date(new Date().getTime() - 7 * 24 * 60 * 60 * 1000),
+        },
+      },
+      take: 10,
+      orderBy: {
+        created_at: 'desc',
+      },
+      select: {
+        created_at: true,
+        user: {
+          select: {
+            name: true,
+            id: true,
+          },
+        },
+      },
+    });
+
+    return {
+      total: users.length,
+      admin: users.filter((user) => user.role_user.length > 0).length,
+      active: 0,
+      activities,
+    };
+  }
+
+  private async getModulesInfo() {
+    const packageJsonPath = path.resolve(process.cwd(), 'package.json');
+
+    return new Promise((resolve, reject) => {
+      fs.readFile(packageJsonPath, 'utf8', async (err, data) => {
+        if (err) {
+          reject(`Error reading package.json: ${err.message}`);
+          return;
+        }
+
+        try {
+          const packageJson = JSON.parse(data);
+          const dependencies = packageJson.dependencies || {};
+          const hedgehogModules = await Promise.all(
+            Object.keys(dependencies)
+              .filter((key) => key.startsWith('@hedhog'))
+              .map(async (key) => {
+                const currentVersion = dependencies[key].replace(/^[\^~]/, '');
+                const latestVersion = await this.getLatestVersion(key);
+                return {
+                  name: key,
+                  version: dependencies[key],
+                  latestVersion,
+                  upToDate: currentVersion === latestVersion,
+                };
+              }),
+          );
+
+          resolve(hedgehogModules);
+        } catch (parseError: any) {
+          reject(`Error parsing package.json: ${parseError?.message}`);
+        }
+      });
+    });
+  }
+
+  private async getLatestVersion(moduleName: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      exec(`npm show ${moduleName} version`, (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            `Error fetching latest version for ${moduleName}: ${error.message}`,
+          );
+          return;
+        }
+        if (stderr) {
+          reject(`stderr: ${stderr}`);
+          return;
+        }
+        resolve(stdout.trim());
+      });
+    });
+  }
+
+  private getCpuInfo(cpus: os.CpuInfo[], averageSpeed: number) {
+    return {
+      model: cpus[0].model,
+      speed: averageSpeed,
+      physicalCores: cpus.length / 2, // Assuming hyper-threading, this gives physical cores
+      virtualCores: cpus.length,
+    };
+  }
+
+  private getMemoryInfo() {
+    return {
+      total: os.totalmem(),
+      free: os.freemem(),
+    };
+  }
+
+  private async getDiskInfo() {
+    return new Promise((resolve, reject) => {
+      const command = this.getDiskCommand();
+      if (!command) {
+        reject('Unsupported OS');
+        return;
+      }
+
+      exec(command, (error, stdout, stderr) => {
+        if (error) {
+          reject(`error: ${error.message}`);
+          return;
+        }
+        if (stderr) {
+          reject(`stderr: ${stderr}`);
+          return;
+        }
+
+        const diskInfo =
+          os.platform() === 'win32'
+            ? this.parseWindowsDiskInfo(stdout)
+            : this.parseUnixDiskInfo(stdout);
+
+        resolve(diskInfo.filter((disk) => disk.filesystem !== undefined));
+      });
+    });
+  }
+
+  private getDiskCommand() {
+    switch (os.platform()) {
+      case 'win32':
+        if (fs.existsSync('C:\\Windows\\System32\\wbem\\wmic.exe')) {
+          return 'wmic logicaldisk get size,freespace,caption';
+        } else {
+          return 'powershell -Command "Get-PSDrive -PSProvider FileSystem | Select-Object Name,Used,Free"';
+        }
+      case 'darwin':
+      case 'linux':
+        return 'df -h';
+      default:
+        return null;
+    }
+  }
+
+  private parseWindowsDiskInfo(output: string) {
+    const lines = output.trim().split('\n');
+    const result = [];
+    for (let i = 1; i < lines.length; i++) {
+      const parts = lines[i].trim().split(/\s+/);
+      if (parts.length === 3) {
+        result.push({
+          filesystem: parts[0].replace(':', ''),
+          size: parseInt(parts[1], 10),
+          free: parseInt(parts[2], 10),
+        });
+      }
+    }
+    return result;
+  }
+
+  private parsedSizeFormated(size: string): number {
+    const unit = size.slice(-1).toUpperCase();
+    const value = parseFloat(size.slice(0, -1));
+
+    switch (unit) {
+      case 'T':
+        return value * 1024 ** 4;
+      case 'G':
+        return value * 1024 ** 3;
+      case 'M':
+        return value * 1024 ** 2;
+      case 'K':
+        return value * 1024;
+      default:
+        return value; // Assume bytes if no unit is provided
+    }
+  }
+
+  private parseUnixDiskInfo(output: string) {
+    const lines = output.trim().split('\n');
+    const result = [];
+    for (let i = 1; i < lines.length; i++) {
+      const parts = lines[i].split(/\s+/);
+      if (parts.length >= 6) {
+        const size = this.parsedSizeFormated(parts[1]);
+        const free = this.parsedSizeFormated(parts[3]);
+        result.push({
+          filesystem: parts[0],
+          free,
+          size,
+          mountpoint: parts[5],
+        });
+      }
+    }
+    return result;
+  }
+}

package/src/core.module.ts

@@ -0,0 +1,89 @@
+import { LogInterceptor } from '@hed-hog/api';
+import { LocaleModule } from '@hed-hog/api-locale';
+import { MailModule as MailSendModule } from '@hed-hog/api-mail';
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule, PrismaService } from '@hed-hog/api-prisma';
+import { HttpModule } from '@nestjs/axios';
+import { forwardRef, MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_INTERCEPTOR, Reflector } from '@nestjs/core';
+import { AuthModule } from './auth/auth.module';
+import { SystemModule } from './core/system.module';
+import { DashboardModule } from './dashboard/dashboard.module';
+import { FileModule } from './file/file.module';
+import { InstallModule } from './install/install.module';
+import { MailSentModule } from './mail-sent/mail-sent.module';
+import { MailVarModule } from './mail-var/mail-var.module';
+import { MailModule } from './mail/mail.module';
+import { MenuModule } from './menu/menu.module';
+import { LocaleInjectionMiddleware } from './middlewares/locale-injection.middleware';
+import { OAuthModule } from './oauth/oauth.module';
+import { ProfileModule } from './profile/profile.module';
+import { RoleModule } from './role/role.module';
+import { RouteModule } from './route/route.module';
+import { ScreenModule } from './screen/screen.module';
+import { SecurityModule } from './security/security.module';
+import { SessionModule } from './session/session.module';
+import { SettingModule } from './setting/setting.module';
+import { TaskModule } from './task/task.module';
+import { UserModule } from './user/user.module';
+
+@Module({
+  imports: [
+    HttpModule,
+    ConfigModule.forRoot(),
+    forwardRef(() => InstallModule),
+    forwardRef(() => AuthModule),
+    forwardRef(() => DashboardModule),
+    forwardRef(() => MailSendModule),
+    forwardRef(() => MenuModule),
+    forwardRef(() => PaginationModule),
+    forwardRef(() => RoleModule),
+    forwardRef(() => RouteModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => ScreenModule),
+    forwardRef(() => LocaleModule),
+    forwardRef(() => UserModule),
+    forwardRef(() => SystemModule),
+    forwardRef(() => SettingModule),
+    forwardRef(() => MailModule),
+    forwardRef(() => MailSentModule),
+    forwardRef(() => MailVarModule),
+    forwardRef(() => FileModule),
+    forwardRef(() => TaskModule),
+    forwardRef(() => SecurityModule),
+    forwardRef(() => ProfileModule),
+    forwardRef(() => SessionModule),
+    forwardRef(() => OAuthModule)
+  ],
+  exports: [
+    UserModule,
+    AuthModule,
+    MailModule,
+    RouteModule,
+    RoleModule,
+    MenuModule,
+    ScreenModule,
+    LocaleModule,
+    SettingModule,
+    FileModule,
+    SessionModule,
+  ],
+  providers: [
+      Reflector,
+    {
+      provide: APP_INTERCEPTOR,
+      useFactory: (reflector: Reflector, prismaService: PrismaService) => {
+        return new LogInterceptor(reflector, prismaService);
+      },
+      inject: [Reflector, PrismaService],
+    },
+  ]
+})
+export class CoreModule implements NestModule {
+  configure(consumer: MiddlewareConsumer) {
+    consumer
+      .apply(LocaleInjectionMiddleware)
+      .forRoutes('*');
+  }
+}

package/src/dashboard/dashboard/dashboard.controller.ts

@@ -0,0 +1,49 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+} from '@nestjs/common';
+import { DashboardService } from './dashboard.service';
+import { Locale } from '@hed-hog/api-locale';
+import { Pagination } from '@hed-hog/api-pagination';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DeleteDTO } from '@hed-hog/api';
+
+@Controller('/dashboard')
+export class DashboardController {
+  constructor(private readonly dashboardService: DashboardService) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.dashboardService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.dashboardService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.dashboardService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.dashboardService.update({
+      id,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.dashboardService.delete(data);
+  }
+}

package/src/dashboard/dashboard/dashboard.module.ts

@@ -0,0 +1,13 @@
+import { LocaleModule } from '@hed-hog/api-locale';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { DashboardController } from './dashboard.controller';
+import { DashboardService } from './dashboard.service';
+
+@Module({
+  imports: [forwardRef(() => LocaleModule), forwardRef(() => PrismaModule)],
+  controllers: [DashboardController],
+  providers: [DashboardService],
+  exports: [forwardRef(() => DashboardService)],
+})
+export class DashboardModule2 {}

package/src/dashboard/dashboard/dashboard.service.ts

@@ -0,0 +1,71 @@
+import { DeleteDTO } from '@hed-hog/api';
+import { LocaleService } from '@hed-hog/api-locale';
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+import { BadRequestException } from '@nestjs/common/exceptions';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class DashboardService {
+  constructor(
+    private readonly localeService: LocaleService,
+    private readonly prismaService: PrismaService,
+  ) {}
+  private readonly modelName = 'dashboard';
+  private readonly foreignKey = 'dashboard_id';
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    return this.localeService.listModelWithLocale(
+      locale,
+      'dashboard',
+      paginationParams,
+      {},
+      {
+        dashboard_item: {
+          include: {
+            dashboard_component: true,
+          },
+        },
+      },
+    );
+  }
+
+  async get(id: number) {
+    return this.localeService.getModelWithLocale(this.modelName, id);
+  }
+
+  async create(data: CreateDTO) {
+    return this.localeService.createModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      data,
+    );
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.localeService.updateModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      id,
+      data,
+    );
+  }
+
+  async delete({ ids }: DeleteDTO): Promise<{count:number}> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.',
+      );
+    }
+
+    return this.prismaService.dashboard.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}

package/src/dashboard/dashboard/dto/create.dto.ts

@@ -0,0 +1,8 @@
+import { WithLocaleDTO } from '@hed-hog/api-locale';
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class CreateDTO extends WithLocaleDTO {
+  @IsString()
+  @IsNotEmpty()
+  slug: string;
+}

package/src/dashboard/dashboard/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/dashboard/dashboard-component/dashboard-component.controller.ts

@@ -0,0 +1,55 @@
+import { Pagination } from '@hed-hog/api-pagination';
+import { Locale } from '@hed-hog/api-locale';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Inject,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { UpdateDTO } from './dto/update.dto';
+import { DashboardComponentService } from './dashboard-component.service';
+import { Role, DeleteDTO } from '@hed-hog/api';
+
+@Role()
+@Controller('dashboard-component')
+export class DashboardComponentController {
+  constructor(
+    @Inject(forwardRef(() => DashboardComponentService))
+    private readonly dashboardComponentService: DashboardComponentService,
+  ) {}
+
+  @Get()
+  async list(@Locale() locale, @Pagination() paginationParams) {
+    return this.dashboardComponentService.list(locale, paginationParams);
+  }
+
+  @Get(':id')
+  async get(@Param('id', ParseIntPipe) id: number) {
+    return this.dashboardComponentService.get(id);
+  }
+
+  @Post()
+  async create(@Body() data: CreateDTO) {
+    return this.dashboardComponentService.create(data);
+  }
+
+  @Patch(':id')
+  async update(@Param('id', ParseIntPipe) id: number, @Body() data: UpdateDTO) {
+    return this.dashboardComponentService.update({
+      id,
+      data,
+    });
+  }
+
+  @Delete()
+  async delete(@Body() data: DeleteDTO) {
+    return this.dashboardComponentService.delete(data);
+  }
+}

package/src/dashboard/dashboard-component/dashboard-component.module.ts

@@ -0,0 +1,14 @@
+import { PaginationModule } from '@hed-hog/api-pagination';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { LocaleModule } from '@hed-hog/api-locale';
+import { forwardRef, Module } from '@nestjs/common';
+import { DashboardComponentService } from './dashboard-component.service';
+import { DashboardComponentController } from './dashboard-component.controller';
+
+@Module({
+  imports: [forwardRef(() => LocaleModule), forwardRef(() => PrismaModule)],
+  controllers: [DashboardComponentController],
+  providers: [DashboardComponentService],
+  exports: [DashboardComponentService],
+})
+export class DashboardComponentModule {}

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

@@ -0,0 +1,70 @@
+import { PaginationDTO } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  BadRequestException,
+  Inject,
+  Injectable,
+  forwardRef,
+} from '@nestjs/common';
+import { CreateDTO } from './dto/create.dto';
+import { DeleteDTO } from '@hed-hog/api';
+import { UpdateDTO } from './dto/update.dto';
+import { LocaleService } from '@hed-hog/api-locale';
+
+@Injectable()
+export class DashboardComponentService {
+  private readonly modelName = 'dashboard_component';
+  private readonly foreignKey = 'component_id';
+
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => LocaleService))
+    private readonly localeService: LocaleService,
+  ) {}
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    return this.localeService.listModelWithLocale(
+      locale,
+      this.modelName,
+      paginationParams,
+    );
+  }
+
+  async get(id: number) {
+    return this.localeService.getModelWithLocale(this.modelName, id);
+  }
+
+  async create(data: CreateDTO) {
+    return this.localeService.createModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      data,
+    );
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.localeService.updateModelWithLocale(
+      this.modelName,
+      this.foreignKey,
+      id,
+      data,
+    );
+  }
+
+  async delete({ ids }: DeleteDTO): Promise<{count:number}> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        'You must select at least one item to delete.',
+      );
+    }
+
+    return this.prismaService.dashboard_component.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+}