Merge pull request #191 from line/dev

release: 4.2408.39

apps/api/package.json

@@ -57,7 +57,7 @@
     "nestjs-cls": "^3.6.0",
     "nestjs-pino": "^3.5.0",
     "nestjs-typeorm-paginate": "^4.0.4",
-    "nodemailer": "^6.9.7",
+    "nodemailer": "^6.9.9",
     "passport": "^0.7.0",
     "passport-custom": "^1.1.1",
     "passport-jwt": "^4.0.1",

apps/api/src/domains/admin/auth/auth.service.ts

@@ -48,14 +48,11 @@ import { UserService } from '../user/user.service';
 import type {
   JwtDto,
   SendEmailCodeDto,
+  SignUpInvitationUserDto,
   ValidateEmailUserDto,
   VerifyEmailCodeDto,
 } from './dtos';
-import {
-  SignUpEmailUserDto,
-  SignUpInvitationUserDto,
-  SignUpOauthUserDto,
-} from './dtos';
+import { SignUpEmailUserDto, SignUpOauthUserDto } from './dtos';
 import { PasswordNotMatchException, UserBlockedException } from './exceptions';
 
 @Injectable()
@@ -96,11 +93,13 @@ export class AuthService {
   }
 
   async verifyEmailCode({ code, email }: VerifyEmailCodeDto) {
-    await this.codeService.verifyCode({
+    const { error } = await this.codeService.verifyCode({
       type: CodeTypeEnum.EMAIL_VEIRIFICATION,
       key: email,
       code,
     });
+
+    if (error) throw error;
   }
 
   async validateEmailUser({ email, password }: ValidateEmailUserDto) {
@@ -131,15 +130,15 @@ export class AuthService {
     return await this.createUserService.createEmailUser(dto);
   }
 
-  @Transactional()
   async signUpInvitationUser(dto: SignUpInvitationUserDto) {
     const { code, ...rest } = dto;
 
-    await this.codeService.verifyCode({
+    const { error } = await this.codeService.verifyCode({
       type: CodeTypeEnum.USER_INVITATION,
       key: dto.email,
       code,
     });
+    if (error) throw error;
 
     const data = await this.codeService.getDataByCodeAndType(
       CodeTypeEnum.USER_INVITATION,

apps/api/src/domains/admin/user/user-password.service.ts

@@ -22,7 +22,8 @@ import { Transactional } from 'typeorm-transactional';
 import { CodeTypeEnum } from '@/shared/code/code-type.enum';
 import { CodeService } from '@/shared/code/code.service';
 import { ResetPasswordMailingService } from '@/shared/mailing/reset-password-mailing.service';
-import { ChangePasswordDto, ResetPasswordDto } from './dtos';
+import type { ResetPasswordDto } from './dtos';
+import { ChangePasswordDto } from './dtos';
 import { UserEntity } from './entities/user.entity';
 import { InvalidPasswordException, UserNotFoundException } from './exceptions';
 
@@ -48,17 +49,18 @@ export class UserPasswordService {
     await this.resetPasswordMailingService.send({ email, code });
   }
 
-  @Transactional()
   async resetPassword({ email, code, password }: ResetPasswordDto) {
     const user = await this.userRepo.findOneBy({ email });
     if (!user) throw new UserNotFoundException();
 
-    await this.codeService.verifyCode({
+    const { error } = await this.codeService.verifyCode({
       type: CodeTypeEnum.RESET_PASSWORD,
       key: email,
       code,
     });
 
+    if (error) throw error;
+
     return await this.userRepo.save(
       Object.assign(user, {
         hashPassword: await this.createHashPassword(password),

apps/api/src/shared/code/code.service.spec.ts

@@ -161,13 +161,12 @@ describe('CodeService', () => {
       const invalidCode = faker.string.sample(6);
       jest.spyOn(codeRepo, 'findOneBy').mockResolvedValue(codeEntity);
 
-      await expect(
-        codeService.verifyCode({
-          code: invalidCode,
-          key,
-          type,
-        }),
-      ).rejects.toThrow(new BadRequestException('invalid code'));
+      const { error } = await codeService.verifyCode({
+        code: invalidCode,
+        key,
+        type,
+      });
+      expect(error).toEqual(new BadRequestException('invalid code'));
     });
     it('verifying code fails with an invalid code more than 5 times', async () => {
       const { type } = codeEntity;
@@ -176,35 +175,32 @@ describe('CodeService', () => {
         .spyOn(codeRepo, 'findOneBy')
         .mockResolvedValue({ ...codeEntity, tryCount: 5 } as CodeEntity);
 
-      await expect(
-        codeService.verifyCode({
-          code: invalidCode,
-          key,
-          type,
-        }),
-      ).rejects.toThrow(new BadRequestException('code expired'));
+      const { error } = await codeService.verifyCode({
+        code: invalidCode,
+        key,
+        type,
+      });
+      expect(error).toEqual(new BadRequestException('code expired'));
     });
     it('verifying code fails with an invalid key', async () => {
       const { code, type } = codeEntity;
       const invalidKey = faker.string.sample(6);
       jest.spyOn(codeRepo, 'findOneBy').mockResolvedValue(null);
 
-      await expect(
-        codeService.verifyCode({
-          code,
-          key: invalidKey,
-          type,
-        }),
-      ).rejects.toThrow(NotFoundException);
+      const { error } = await codeService.verifyCode({
+        code,
+        key: invalidKey,
+        type,
+      });
+      expect(error).toEqual(new NotFoundException('not found code'));
     });
     it('verifying code fails at expired date', async () => {
       MockDate.set(new Date(Date.now() + 5 * 60 * 1000 + 1000));
       const { code, type } = codeEntity;
       jest.spyOn(codeRepo, 'findOneBy').mockResolvedValue(codeEntity);
 
-      await expect(codeService.verifyCode({ code, key, type })).rejects.toThrow(
-        new BadRequestException('code expired'),
-      );
+      const { error } = await codeService.verifyCode({ code, key, type });
+      expect(error).toEqual(new BadRequestException('code expired'));
       MockDate.reset();
     });
   });

apps/api/src/shared/code/code.service.ts

@@ -19,7 +19,6 @@ import {
   Injectable,
   NotFoundException,
 } from '@nestjs/common';
-import { EventEmitter2, OnEvent } from '@nestjs/event-emitter';
 import { InjectRepository } from '@nestjs/typeorm';
 import { DateTime } from 'luxon';
 import { Repository } from 'typeorm';
@@ -37,7 +36,6 @@ export class CodeService {
   constructor(
     @InjectRepository(CodeEntity)
     private readonly codeRepo: Repository<CodeEntity>,
-    private readonly eventEmitter: EventEmitter2,
   ) {}
 
   @Transactional()
@@ -59,6 +57,7 @@ export class CodeService {
           .plus({ seconds: durationSec ?? SECONDS })
           .toJSDate(),
         data: type === CodeTypeEnum.USER_INVITATION ? dto.data : undefined,
+        tryCount: 0,
       }),
     );
 
@@ -69,24 +68,26 @@ export class CodeService {
   async verifyCode({ code, key, type }: VerifyCodeDto) {
     const codeEntity = await this.codeRepo.findOneBy({ key, type });
 
-    if (!codeEntity) throw new NotFoundException('not found code');
+    if (!codeEntity) return { error: new NotFoundException('not found code') };
     if (codeEntity.isVerified)
-      throw new BadRequestException('already verified');
+      return { error: new BadRequestException('already verified') };
 
     if (codeEntity.tryCount >= 5) {
-      throw new BadRequestException('code expired');
+      return { error: new BadRequestException('code expired') };
     }
 
     if (codeEntity.code !== code) {
-      this.eventEmitter.emit('code.verify.failed', codeEntity);
-      throw new BadRequestException('invalid code');
+      codeEntity.tryCount += 1;
+      await this.codeRepo.save(codeEntity);
+      return { error: new BadRequestException('invalid code') };
     }
 
     if (DateTime.utc() > DateTime.fromJSDate(codeEntity.expiredAt)) {
-      throw new BadRequestException('code expired');
+      return { error: new BadRequestException('code expired') };
     }
 
     await this.codeRepo.save(Object.assign(codeEntity, { isVerified: true }));
+    return { error: null };
   }
 
   async getDataByCodeAndType(
@@ -112,10 +113,4 @@ export class CodeService {
   private createCode() {
     return String(crypto.randomInt(1, 1000000)).padStart(6, '0');
   }
-
-  @OnEvent('code.verify.failed', { async: true })
-  private async handleCodeVerificationFailure(codeEntity: CodeEntity) {
-    codeEntity.tryCount += 1;
-    await this.codeRepo.save(codeEntity);
-  }
 }

apps/api/src/test-utils/providers/code.service.providers.ts

@@ -14,7 +14,6 @@
  * under the License.
  */
 
-import { EventEmitter2 } from '@nestjs/event-emitter';
 import { getRepositoryToken } from '@nestjs/typeorm';
 
 import { mockRepository } from '@/test-utils/util-functions';
@@ -23,6 +22,5 @@ import { CodeService } from '../../shared/code/code.service';
 
 export const CodeServiceProviders = [
   CodeService,
-  EventEmitter2,
   { provide: getRepositoryToken(CodeEntity), useValue: mockRepository() },
 ];

apps/web/src/components/etc/DateRangePicker/DateRangePicker.tsx

@@ -56,22 +56,22 @@ const DateRangePicker: React.FC<IProps> = (props) => {
       },
       {
         label: t('text.date.yesterday'),
-        startDate: dayjs().subtract(1, 'days').startOf('day').toDate(),
-        endDate: dayjs().endOf('day').toDate(),
+        startDate: dayjs().subtract(1, 'day').startOf('day').toDate(),
+        endDate: dayjs().subtract(1, 'day').endOf('day').toDate(),
       },
       {
         label: t('text.date.before-days', { day: 7 }),
-        startDate: dayjs().subtract(7, 'days').startOf('day').toDate(),
+        startDate: dayjs().subtract(7, 'day').startOf('day').toDate(),
         endDate: dayjs().endOf('day').toDate(),
       },
       {
         label: t('text.date.before-days', { day: 30 }),
-        startDate: dayjs().subtract(30, 'days').startOf('day').toDate(),
+        startDate: dayjs().subtract(30, 'day').startOf('day').toDate(),
         endDate: dayjs().endOf('day').toDate(),
       },
       {
         label: t('text.date.before-days', { day: 90 }),
-        startDate: dayjs().subtract(90, 'days').startOf('day').toDate(),
+        startDate: dayjs().subtract(90, 'day').startOf('day').toDate(),
         endDate: dayjs().endOf('day').toDate(),
       },
     ];

apps/web/src/containers/tables/FeedbackTable/FeedbackTable.tsx

@@ -82,6 +82,13 @@ const FeedbackTable: React.FC<IFeedbackTableProps> = (props) => {
     setRowSelection({});
   }, [limit, query]);
 
+  const { data: channelData, refetch: refetchChannelData } = useOAIQuery({
+    path: '/api/admin/projects/{projectId}/channels/{channelId}',
+    variables: { channelId, projectId },
+  });
+
+  const fieldData = channelData?.fields ?? [];
+
   const formattedQuery = useMemo(
     () =>
       produce(query, (draft) => {
@@ -101,37 +108,25 @@ const FeedbackTable: React.FC<IFeedbackTableProps> = (props) => {
             draft['issueIds'] = [draft['issueIds']].map((v) => +v);
           }
           Object.entries(draft).forEach(([key, value]) => {
-            if (typeof value === 'string' && value.split('~').length === 2) {
-              const [gte, lt] = value.split('~');
-              draft[key] = {
-                gte: dayjs(gte).startOf('day').toISOString(),
-                lt: dayjs(lt).endOf('day').toISOString(),
-              };
-            }
-            if (value === 'true' || value === 'false') {
-              draft[key] = value === 'true';
+            const field = fieldData.find((v) => v.key === key);
+            if (field) {
+              if (field.format === 'date') {
+                const [gte, lt] = value.split('~');
+                draft[key] = {
+                  gte: dayjs(gte).startOf('day').toISOString(),
+                  lt: dayjs(lt).endOf('day').toISOString(),
+                };
+              }
+              if (field.format === 'number') {
+                draft[key] = Number(value);
+              }
             }
           });
-          if (createdAtRange) {
-            draft['createdAt'] = {
-              gte: dayjs(createdAtRange.startDate).startOf('day').toISOString(),
-              lt: dayjs(createdAtRange.endDate).endOf('day').toISOString(),
-            };
-          } else {
-            delete draft['createdAt'];
-          }
         }
       }),
-    [issueId, query, createdAtRange, sub],
+    [issueId, query, createdAtRange, sub, fieldData],
   );
 
-  const { data: channelData, refetch: refetchChannelData } = useOAIQuery({
-    path: '/api/admin/projects/{projectId}/channels/{channelId}',
-    variables: { channelId, projectId },
-  });
-
-  const fieldData = channelData?.fields ?? [];
-
   const {
     data,
     refetch: refetchFeedbackData,

apps/web/src/containers/tables/FeedbackTable/FeedbackTableBar/FeedbackTableBar.tsx

@@ -225,7 +225,10 @@ const FeedbackTableBar: React.FC<IProps> = (props) => {
           {fieldData && (
             <TableSearchInput
               searchItems={searchItems}
-              onChangeQuery={setQuery}
+              onChangeQuery={(input) => {
+                const { createdAt } = query;
+                setQuery({ createdAt, ...input });
+              }}
               query={query}
             />
           )}