@hed-hog/core 0.0.4

package/src/menu/menu.service.spec.ts

@@ -0,0 +1,247 @@
+// import {
+//   PageOrderDirection,
+//   PaginationDTO,
+//   PaginationService,
+// } from '@hed-hog/api-pagination';
+// import { PrismaService } from '@hed-hog/api-prisma';
+// import { BadRequestException } from '@nestjs/common';
+// import { Test, TestingModule } from '@nestjs/testing';
+// import { MenuService } from './menu.service';
+
+// describe('MenuService', () => {
+//   let menuService: MenuService;
+//   let prismaService: PrismaService;
+//   let paginationService: PaginationService;
+
+//   const mockPrismaService = {
+//     menu: {
+//       create: jest.fn(),
+//       update: jest.fn(),
+//       deleteMany: jest.fn(),
+//       findUnique: jest.fn(),
+//       findMany: jest.fn(),
+//       count: jest.fn(),
+//     },
+//     role_menu: {
+//       deleteMany: jest.fn(),
+//       createMany: jest.fn(),
+//     },
+//     menu_screen: {
+//       deleteMany: jest.fn(),
+//       createMany: jest.fn(),
+//     },
+//   };
+
+//   const mockPaginationService = {
+//     paginate: jest.fn(),
+//     createInsensitiveSearch: jest.fn(),
+//   };
+
+//   beforeEach(async () => {
+//     const module: TestingModule = await Test.createTestingModule({
+//       providers: [
+//         MenuService,
+//         { provide: PrismaService, useValue: mockPrismaService },
+//         { provide: PaginationService, useValue: mockPaginationService },
+//       ],
+//     }).compile();
+
+//     menuService = module.get<MenuService>(MenuService);
+//     prismaService = module.get<PrismaService>(PrismaService);
+//     paginationService = module.get<PaginationService>(PaginationService);
+//   });
+
+//   afterEach(() => {
+//     jest.clearAllMocks();
+//   });
+
+//   describe('create', () => {
+//     it('should create a new menu', async () => {
+//       const createMenuDto = {
+//         name: 'Test Menu',
+//         url: '/test',
+//         icon: 'test-icon',
+//         order: 1,
+//         menu_id: undefined,
+//       };
+//       mockPrismaService.menu.create.mockResolvedValue(createMenuDto);
+
+//       const result = await menuService.create(createMenuDto);
+
+//       expect(result).toEqual(createMenuDto);
+//       expect(prismaService.menu.create).toHaveBeenCalledWith({
+//         data: createMenuDto,
+//       });
+//     });
+//   });
+
+//   describe('update', () => {
+//     it('should update a menu', async () => {
+//       const updateDto = { id: 1, data: { name: 'Updated Menu' } };
+//       mockPrismaService.menu.update.mockResolvedValue(updateDto.data);
+
+//       const result = await menuService.update(updateDto);
+
+//       expect(result).toEqual(updateDto.data);
+//       expect(prismaService.menu.update).toHaveBeenCalledWith({
+//         where: { id: updateDto.id },
+//         data: updateDto.data,
+//       });
+//     });
+//   });
+
+//   describe('delete', () => {
+//     it('should delete menu', async () => {
+//       const deleteDto = { ids: [1, 2, 3] };
+//       mockPrismaService.menu.deleteMany.mockResolvedValue({ count: 3 });
+
+//       const result = await menuService.delete(deleteDto);
+
+//       expect(result).toEqual({ count: 3 });
+//       expect(prismaService.menu.deleteMany).toHaveBeenCalledWith({
+//         where: { id: { in: deleteDto.ids } },
+//       });
+//     });
+
+//     it('should throw BadRequestException if no ids are provided', async () => {
+//       await expect(menuService.delete({ ids: null })).rejects.toThrow(
+//         BadRequestException,
+//       );
+//     });
+//   });
+
+//   describe('listScreens', () => {
+//     it('should paginate screens', async () => {
+//       const locale = 'en';
+//       const menuId = 1;
+//       const paginationParams: PaginationDTO = {
+//         page: 1,
+//         pageSize: 10,
+//         search: '',
+//         sortField: '',
+//         sortOrder: PageOrderDirection.Asc,
+//         fields: '',
+//       };
+
+//       const mockScreens = [{ id: 1, name: 'Screen 1' }];
+//       mockPaginationService.paginate.mockResolvedValue(mockScreens);
+
+//       const result = await menuService.listScreens(
+//         locale,
+//         menuId,
+//         paginationParams,
+//       );
+
+//       expect(result).toEqual(mockScreens);
+//       expect(paginationService.paginate).toHaveBeenCalledWith(
+//         prismaService.screens,
+//         paginationParams,
+//         expect.anything(),
+//         'screen_locale',
+//       );
+//     });
+//   });
+
+//   describe('updateScreens', () => {
+//     it('should update screens associated with a menu', async () => {
+//       const menuId = 1;
+//       const updateData = { ids: [1, 2, 3] };
+
+//       jest
+//         .spyOn(prismaService.menu_screen, 'deleteMany')
+//         .mockResolvedValue(null);
+//       jest
+//         .spyOn(prismaService.menu_screen, 'createMany')
+//         .mockResolvedValue(null);
+
+//       await menuService.updateScreens(menuId, updateData);
+
+//       expect(prismaService.menu_screen.deleteMany).toHaveBeenCalledWith({
+//         where: { menu_id: menuId },
+//       });
+
+//       expect(prismaService.menu_screen.createMany).toHaveBeenCalledWith({
+//         data: updateData.ids.map((screenId) => ({
+//           menu_id: menuId,
+//           screen_id: screenId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//     });
+//   });
+
+//   describe('updateRoles', () => {
+//     it('should update role associated with a menu', async () => {
+//       const menuId = 1;
+//       const updateData = { ids: [1, 2] };
+
+//       jest.spyOn(prismaService.role_menu, 'deleteMany').mockResolvedValue(null);
+//       jest.spyOn(prismaService.role_menu, 'createMany').mockResolvedValue(null);
+
+//       await menuService.updateRoles(menuId, updateData);
+
+//       expect(prismaService.role_menu.deleteMany).toHaveBeenCalledWith({
+//         where: { menu_id: menuId },
+//       });
+
+//       expect(prismaService.role_menu.createMany).toHaveBeenCalledWith({
+//         data: updateData.ids.map((roleId) => ({
+//           menu_id: menuId,
+//           role_id: roleId,
+//         })),
+//         skipDuplicates: true,
+//       });
+//     });
+//   });
+
+//   describe('updateOrder', () => {
+//     it('should update the order of menu', async () => {
+//       const orderData = { ids: [1, 2, 3] };
+
+//       jest.spyOn(prismaService.menu, 'count').mockResolvedValue(3);
+//       jest.spyOn(prismaService.menu, 'update').mockResolvedValue(null);
+
+//       await menuService.updateOrder(orderData);
+
+//       expect(prismaService.menu.count).toHaveBeenCalledWith({
+//         where: { id: { in: orderData.ids } },
+//       });
+
+//       expect(prismaService.menu.update).toHaveBeenCalledTimes(
+//         orderData.ids.length,
+//       );
+
+//       orderData.ids.forEach((id, index) => {
+//         expect(prismaService.menu.update).toHaveBeenCalledWith({
+//           where: { id },
+//           data: { order: index + 1 },
+//         });
+//       });
+//     });
+
+//     it('should throw BadRequestException if IDs are invalid', async () => {
+//       const orderData = { ids: [1, 2, 3] };
+
+//       jest.spyOn(prismaService.menu, 'count').mockResolvedValue(2); // IDs não batem com o número esperado
+
+//       await expect(menuService.updateOrder(orderData)).rejects.toThrow(
+//         BadRequestException,
+//       );
+//     });
+//   });
+//   /*
+//   describe('getMenus', () => {
+//     it('should get menu for a user', async () => {
+//       const locale = 'en';
+//       const userId = 1;
+//       const mockMenus = [{ id: 1, name: 'Menu 1' }];
+//       mockPrismaService.menu.findMany.mockResolvedValue(mockMenus);
+
+//       const result = await menuService.getMenus(locale, userId);
+
+//       expect(result).toEqual(mockMenus);
+//       expect(prismaService.menu.findMany).toHaveBeenCalled();
+//     });
+//   });
+//   */
+// });

package/src/menu/menu.service.ts

@@ -0,0 +1,264 @@
+import { itemTranslations } from '@hed-hog/api';
+import { getLocaleText } from '@hed-hog/api-locale';
+import { PaginationDTO, PaginationService } from '@hed-hog/api-pagination';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+    BadRequestException,
+    Inject,
+    Injectable,
+    forwardRef,
+} from '@nestjs/common';
+import { DeleteDTO } from '../dto/delete.dto';
+import { UpdateIdsDTO } from '../dto/update-ids.dto';
+import { CreateDTO } from './dto/create.dto';
+import { OrderDTO } from './dto/order.dto';
+import { UpdateDTO } from './dto/update.dto';
+
+@Injectable()
+export class MenuService {
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prismaService: PrismaService,
+    @Inject(forwardRef(() => PaginationService))
+    private readonly paginationService: PaginationService,
+  ) {}
+
+  async updateScreens(menuId: number, data: UpdateIdsDTO): Promise<{count:number}> {
+    await this.prismaService.menu_screen.deleteMany({
+      where: {
+        menu_id: menuId,
+      },
+    });
+
+    return this.prismaService.menu_screen.createMany({
+      data: data.ids.map((screenId) => ({
+        menu_id: menuId,
+        screen_id: screenId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async updateRoles(menuId: number, data: UpdateIdsDTO): Promise<{count:number}> {
+    await this.prismaService.role_menu.deleteMany({
+      where: {
+        menu_id: menuId,
+      },
+    });
+
+    return this.prismaService.role_menu.createMany({
+      data: data.ids.map((roleId) => ({
+        menu_id: menuId,
+        role_id: roleId,
+      })),
+      skipDuplicates: true,
+    });
+  }
+  async listScreens(
+    locale: string,
+    menuId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.screen,
+      paginationParams,
+      {
+        include: {
+          screen_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+          menu_screen: {
+            where: {
+              menu_id: menuId,
+            },
+            select: {
+              screen_id: true,
+              menu_id: true,
+            },
+          },
+        },
+      },
+      'screen_locale',
+    );
+  }
+  async listRoles(
+    locale: string,
+    menuId: number,
+    paginationParams: PaginationDTO,
+  ) {
+    return this.paginationService.paginate(
+      this.prismaService.role,
+      paginationParams,
+      {
+        include: {
+          role_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+              description: true,
+            },
+          },
+          role_menu: {
+            where: {
+              menu_id: menuId,
+            },
+            select: {
+              role_id: true,
+              menu_id: true,
+            },
+          },
+        },
+      },
+      'role_locale',
+    );
+  }
+
+  async getMenus(locale: string, userId: number, menuId = 0) {
+    if (menuId === 0) {
+      menuId = null;
+    }
+
+    let menu = (await this.prismaService.menu.findMany({
+      where: {
+        menu_id: menuId,
+        role_menu: {
+          some: {
+            role: {
+              role_user: {
+                some: {
+                  user_id: userId,
+                },
+              },
+            },
+          },
+        },
+      },
+      orderBy: {
+        order: 'asc',
+      },
+      include: {
+        menu_locale: {
+          where: {
+            locale: {
+              code: locale,
+            },
+          },
+          select: {
+            name: true,
+          },
+        },
+      },
+    })) as unknown[] as any[];
+
+    menu = menu.map((m) => itemTranslations('menu_locale', m));
+
+    for (let i = 0; i < menu.length; i++) {
+      menu[i].menu = await this.getMenus(locale, userId, menu[i].id);
+    }
+
+    return menu;
+  }
+
+  async getSystemMenu(locale: string, userId: number) {
+    return this.getMenus(locale, userId);
+  }
+
+  async list(locale: string, paginationParams: PaginationDTO) {
+    const fields = ['url', 'icon'];
+    const OR = this.prismaService.createInsensitiveSearch(
+      fields,
+      paginationParams,
+    );
+
+    return this.paginationService.paginate(
+      this.prismaService.menu,
+      paginationParams,
+      {
+        where: {
+          OR,
+        },
+        include: {
+          menu_locale: {
+            where: {
+              locale: {
+                code: locale,
+              },
+            },
+            select: {
+              name: true,
+            },
+          },
+        },
+      },
+      'menu_locale',
+    );
+  }
+
+  async get(menuId: number) {
+    return this.prismaService.menu.findUnique({
+      where: { id: menuId },
+    });
+  }
+
+  async create({ slug, url, icon, order, menuId }: CreateDTO) {
+    return this.prismaService.menu.create({
+      data: { slug, url, icon, order, menu_id: menuId },
+    });
+  }
+
+  async update({ id, data }: { id: number; data: UpdateDTO }) {
+    return this.prismaService.menu.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async delete({ ids }: DeleteDTO, locale: string = 'en'): Promise<{count:number}> {
+    if (ids == undefined || ids == null) {
+      throw new BadRequestException(
+        getLocaleText('deleteItemsRequired', locale, 'You must select at least one menu to delete.'),
+      );
+    }
+
+    return this.prismaService.menu.deleteMany({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+  }
+
+  async updateOrder({ ids }: OrderDTO, locale: string = 'en'): Promise<void> {
+    const count = await this.prismaService.menu.count({
+      where: {
+        id: {
+          in: ids,
+        },
+      },
+    });
+
+    if (count !== ids.length) {
+      throw new BadRequestException(getLocaleText('invalidIds', locale, 'Invalid IDs.'));
+    }
+
+    await Promise.all(
+      ids.map((id, index) =>
+        this.prismaService.menu.update({
+          where: { id },
+          data: { order: index + 1 },
+        }),
+      ),
+    );
+  }
+}

package/src/middlewares/locale-injection.middleware.ts

@@ -0,0 +1,15 @@
+import { Injectable, NestMiddleware } from '@nestjs/common';
+import { NextFunction, Request, Response } from 'express';
+import { localeStorage } from '../utils/locale-context';
+
+@Injectable()
+export class LocaleInjectionMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    const acceptLanguage = req.headers['accept-language'] || 'en';
+    const locale = acceptLanguage.split(',')[0].split('-')[0];
+
+    localeStorage.run({ locale }, () => {
+      next();
+    });
+  }
+}

package/src/oauth/interfaces/OAuthProvider.ts

@@ -0,0 +1,5 @@
+export interface OAuthProvider {
+  getAuthUrl(callbackPath: string): string;
+  getProfile(code: string, type?: string): Promise<any>;
+  getProviderType(): string;
+}

package/src/oauth/oauth.controller.ts

@@ -0,0 +1,116 @@
+
+import { Public, User } from '@hed-hog/api';
+import { Locale } from '@hed-hog/api-locale';
+import { user_account_provider_enum } from '@hed-hog/api-prisma';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Headers,
+  Ip,
+  Param,
+  Query,
+  Res,
+} from '@nestjs/common';
+import { SettingService } from '../setting/setting.service';
+import { OAuthService } from './oauth.service';
+
+@Controller('oauth')
+export class OAuthController {
+  constructor(private readonly service: OAuthService, private readonly settingService: SettingService) {}
+
+    @Public()
+  @Get('github/callback')
+  async githubCallback(
+    @Query('code') code: string,
+    @Query('state') state: string,
+    @Res() res,
+  ) {
+    const type = state || 'login';
+    const { url: frontendURL = '' } = await this.settingService.getSettingValues(['url']);
+    const redirectURL = `${frontendURL}/callback/github/${type}?code=${encodeURIComponent(code)}`;
+    return res.redirect(redirectURL);
+  }
+
+  @Public()
+  @Get(':provider/login')
+  async login(@Param('provider') provider: user_account_provider_enum, @Res() res) {
+    const url = this.service.getAuthUrl(
+      provider,
+      `/callback/${provider}/login`,
+    );
+    return res.redirect(url);
+  }
+
+  @Public()
+  @Get(':provider/register')
+  async register(@Param('provider') provider: user_account_provider_enum, @Res() res) {
+    const url = this.service.getAuthUrl(
+      provider,
+      `/callback/${provider}/register`,
+    );
+    return res.redirect(url);
+  }
+
+  @Public()
+  @Get(':provider/connect')
+  async connect(@Param('provider') provider: user_account_provider_enum, @Res() res) {
+    const url = this.service.getAuthUrl(
+      provider,
+      `/callback/${provider}/connect`,
+    );
+    return res.redirect(url);
+  }
+
+  @Public()
+  @Get(':provider/callback/login')
+  async callbackLogin(
+    @Locale() locale: string,
+    @Ip() ipAddress: string,
+    @Headers('user-agent') userAgent: string,
+    @Param('provider') provider: user_account_provider_enum,
+    @Query('code') code: string,
+    @Res({ passthrough: true }) res,
+  ) {
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider, code, type: 'login' });
+  }
+
+  @Public()
+  @Get(':provider/callback/register')
+  async callbackRegister(
+    @Locale() locale: string,
+    @Ip() ipAddress: string,
+    @Headers('user-agent') userAgent: string,
+    @Param('provider') provider: user_account_provider_enum,
+    @Query('code') code: string,
+    @Res({ passthrough: true }) res,
+  ) {
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider, code, type: 'register' });
+  }
+
+  @Get(':provider/callback/connect')
+  async callbackConnect(
+    @Locale() locale: string,
+    @Ip() ipAddress: string,
+    @Headers('user-agent') userAgent: string,
+    @User() { id },
+    @Param('provider') provider: user_account_provider_enum,
+    @Query('code') code: string,
+    @Res({ passthrough: true }) res,
+  ) {
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider, code, type: 'connect', userId: id });
+  }
+
+  @Delete(':provider')
+  async disconnect(
+    @Locale() locale: string,
+    @Ip() ipAddress: string,
+    @Headers('user-agent') userAgent: string,
+    @Param('provider') provider: user_account_provider_enum,
+    @Body('email') email: string,
+    @Res({ passthrough: true }) res,
+  ) {
+    return this.service.handleCallback({ res, locale, ipAddress, userAgent, provider, email, type: 'disconnect' });
+  }
+}

package/src/oauth/oauth.module.ts

@@ -0,0 +1,36 @@
+import { MailModule as MailSendModule } from '@hed-hog/api-mail';
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { HttpModule } from '@nestjs/axios';
+import { Module, forwardRef } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { AuthModule } from '../auth/auth.module';
+import { FileModule } from '../file/file.module';
+import { MailModule } from '../mail/mail.module';
+import { SecurityModule } from '../security/security.module';
+import { TokenModule } from '../token/token.module';
+import { UserModule } from '../user/user.module';
+import { OAuthController } from './oauth.controller';
+import { OAuthService } from './oauth.service';
+import { FacebookProvider } from './providers/facebook.provider';
+import { GithubProvider } from './providers/github.provider';
+import { GoogleProvider } from './providers/google.provider';
+import { MicrosoftProvider } from './providers/microsoft.provider';
+
+@Module({
+  imports: [
+    forwardRef(() => HttpModule),
+    forwardRef(() => PrismaModule),
+    forwardRef(() => MailSendModule),
+    forwardRef(() => ConfigModule),
+    forwardRef(() => FileModule),
+    forwardRef(() => MailModule),
+    forwardRef(() => SecurityModule),
+    forwardRef(() => TokenModule),
+    forwardRef(() => AuthModule),
+    forwardRef(() => UserModule),
+  ],
+  controllers: [OAuthController],
+  providers: [OAuthService, GoogleProvider, FacebookProvider, GithubProvider, MicrosoftProvider],
+  exports: [OAuthService],
+})
+export class OAuthModule {}