chore: quick access

src/modules/subscriptions/entities/user-quick-access.entity.ts

@@ -0,0 +1,18 @@
+import { Column, Entity, ManyToOne, Unique } from "typeorm";
+
+import { BaseEntity } from "../../../common/entities/base.entity";
+import { DanakService } from "../../danak-services/entities/danak-service.entity";
+import { User } from "../../users/entities/user.entity";
+
+@Entity()
+@Unique(["user", "service"])
+export class UserQuickAccess extends BaseEntity {
+  @ManyToOne(() => User, (user) => user.quickAccesses, { nullable: false, onDelete: "SET NULL" })
+  user: User;
+
+  @ManyToOne(() => DanakService, { nullable: false, onDelete: "SET NULL" })
+  service: DanakService;
+
+  @Column({ type: "boolean", default: true })
+  isActive: boolean;
+}

src/modules/subscriptions/providers/subscriptions.service.ts

@@ -419,4 +419,19 @@ export class SubscriptionsService {
     const growthRate = ((currentYearCount - lastYearCount) / lastYearCount) * 100;
     return Math.round(growthRate * 100) / 100;
   }
+
+  /********************************* */
+
+  async activeUserSubscription(userId: string, serviceId: string) {
+    const activeSubscription = await this.userSubscriptionsRepository.findOne({
+      where: {
+        user: { id: userId },
+        plan: { service: { id: serviceId } },
+        status: SubscriptionStatus.ACTIVE,
+      },
+      relations: ["plan", "plan.service"],
+    });
+    console.log(activeSubscription);
+    return activeSubscription;
+  }
 }

src/modules/subscriptions/providers/users-quick-access.service.ts

@@ -0,0 +1,63 @@
+import { BadRequestException, Injectable, NotFoundException } from "@nestjs/common";
+
+import { SubscriptionsService } from "./subscriptions.service";
+import { CommonMessage, ServiceMessage, UserMessage, UserQuickAccessMessage } from "../../../common/enums/message.enum";
+import { DanakServicesService } from "../../danak-services/providers/danak-services.service";
+import { UsersService } from "../../users/providers/users.service";
+import { UserQuickAccessRepository } from "../repositories/users-quick-access.repository";
+
+@Injectable()
+export class UserQuickAccessService {
+  constructor(
+    private readonly quickAccessRepository: UserQuickAccessRepository,
+    private readonly usersService: UsersService,
+    private readonly danakServicesService: DanakServicesService,
+    private readonly subscriptionService: SubscriptionsService,
+  ) {}
+
+  async addQuickAccess(userId: string, serviceId: string) {
+    const { user } = await this.usersService.findOneById(userId);
+    if (!user) throw new NotFoundException(UserMessage.USER_NOT_FOUND);
+
+    const service = await this.danakServicesService.findServiceById(serviceId);
+    if (!service) throw new NotFoundException(ServiceMessage.SERVICE_NOT_EXIST);
+
+    const activeSubscription = await this.subscriptionService.activeUserSubscription(user.id, service.id);
+    if (!activeSubscription) {
+      throw new BadRequestException(UserQuickAccessMessage.USER_SUBS_NOT_FOUND);
+    }
+
+    const userQuickAccesses = await this.quickAccessRepository.count({ where: { user: { id: userId }, isActive: true } });
+    if (userQuickAccesses >= 4) {
+      throw new BadRequestException(UserQuickAccessMessage.QUICK_ACCESS_LIMIT_REACHED);
+    }
+
+    const existQuickAccess = await this.quickAccessRepository.findOne({ where: { user: { id: user.id }, service: { id: service.id } } });
+    console.log(existQuickAccess);
+    if (existQuickAccess) throw new BadRequestException(UserQuickAccessMessage.QUICK_ACCESS_EXIST);
+
+    const quickAccess = this.quickAccessRepository.create({ user, service });
+
+    await this.quickAccessRepository.save(quickAccess);
+
+    return {
+      message: CommonMessage.CREATED,
+      quickAccess,
+    };
+  }
+
+  async removeQuickAccess(userId: string, serviceId: string) {
+    await this.quickAccessRepository.delete({ user: { id: userId }, service: { id: serviceId } });
+    return {
+      message: CommonMessage.DELETED,
+    };
+  }
+
+  async getUserQuickAccess(userId: string) {
+    const quickAccesses = await this.quickAccessRepository.find({
+      where: { user: { id: userId }, isActive: true },
+      relations: ["service"],
+    });
+    return { quickAccesses };
+  }
+}

src/modules/subscriptions/repositories/users-quick-access.repository.ts

@@ -0,0 +1,12 @@
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import { UserQuickAccess } from "../entities/user-quick-access.entity";
+
+@Injectable()
+export class UserQuickAccessRepository extends Repository<UserQuickAccess> {
+  constructor(@InjectRepository(UserQuickAccess) userQuickAccessRepository: Repository<UserQuickAccess>) {
+    super(userQuickAccessRepository.target, userQuickAccessRepository.manager, userQuickAccessRepository.queryRunner);
+  }
+}

src/modules/subscriptions/subscriptions.controller.ts

@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, Patch, Post, Query } from "@nestjs/common";
+import { Body, Controller, Delete, Get, Param, Patch, Post, Query } from "@nestjs/common";
 import { ApiOperation } from "@nestjs/swagger";
 
 import { AddSubscriptionsToServiceDto } from "./DTO/create-subscription.dto";
@@ -8,6 +8,7 @@ import { ServiceSubsQueryDto } from "./DTO/service-subs-query.dto";
 import { SubscribeServiceDto } from "./DTO/subscribe-service.dto";
 import { UpdateSubscriptionPlanDto } from "./DTO/update-subscription.dto";
 import { SubscriptionsService } from "./providers/subscriptions.service";
+import { UserQuickAccessService } from "./providers/users-quick-access.service";
 import { AuthGuards } from "../../common/decorators/auth-guard.decorator";
 import { PermissionsDec } from "../../common/decorators/permission.decorator";
 import { UserDec } from "../../common/decorators/user.decorator";
@@ -16,7 +17,10 @@ import { PermissionEnum } from "../users/enums/permission.enum";
 
 @Controller("subscriptions")
 export class SubscriptionsController {
-  constructor(private readonly subscriptionService: SubscriptionsService) {}
+  constructor(
+    private readonly subscriptionService: SubscriptionsService,
+    private readonly userQuickAccessService: UserQuickAccessService,
+  ) {}
 
   @ApiOperation({ summary: "Create a subscription plan" })
   @AuthGuards()
@@ -79,4 +83,25 @@ export class SubscriptionsController {
   subscribe(@Param() paramDto: ServiceIdParamDto, @Body() subscribeDto: SubscribeServiceDto, @UserDec("id") userId: string) {
     return this.subscriptionService.subscribeToPlan(paramDto.serviceId, subscribeDto, userId);
   }
+
+  @ApiOperation({ summary: "add quick access a service ==> user route" })
+  @AuthGuards()
+  @Post(":serviceId/add-quick-access")
+  addQuickAccess(@Param() paramDto: ServiceIdParamDto, @UserDec("id") userId: string) {
+    return this.userQuickAccessService.addQuickAccess(userId, paramDto.serviceId);
+  }
+
+  @ApiOperation({ summary: "get quick access a service ==> user route" })
+  @AuthGuards()
+  @Get("quick-access")
+  getQuickAccess(@UserDec("id") userId: string) {
+    return this.userQuickAccessService.getUserQuickAccess(userId);
+  }
+
+  @ApiOperation({ summary: "remove quick access a service ==> user route" })
+  @AuthGuards()
+  @Delete(":serviceId/remove-quick-access")
+  removeQuickAccess(@Param() paramDto: ServiceIdParamDto, @UserDec("id") userId: string) {
+    return this.userQuickAccessService.removeQuickAccess(userId, paramDto.serviceId);
+  }
 }

src/modules/subscriptions/subscriptions.module.ts

@@ -11,17 +11,26 @@ import { DanakServicesModule } from "../danak-services/danak-services.module";
 import { InvoicesModule } from "../invoices/invoices.module";
 import { UsersModule } from "../users/users.module";
 import { WalletsModule } from "../wallets/wallets.module";
+import { UserQuickAccess } from "./entities/user-quick-access.entity";
+import { UserQuickAccessService } from "./providers/users-quick-access.service";
+import { UserQuickAccessRepository } from "./repositories/users-quick-access.repository";
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([SubscriptionPlan, UserSubscription]),
+    TypeOrmModule.forFeature([SubscriptionPlan, UserSubscription, UserQuickAccess]),
     DanakServicesModule,
     UsersModule,
     WalletsModule,
     InvoicesModule,
   ],
-  providers: [SubscriptionsService, SubscriptionsPlanRepository, UserSubscriptionsRepository],
+  providers: [
+    SubscriptionsService,
+    SubscriptionsPlanRepository,
+    UserSubscriptionsRepository,
+    UserQuickAccessRepository,
+    UserQuickAccessService,
+  ],
   controllers: [SubscriptionsController],
-  exports: [SubscriptionsService, TypeOrmModule, SubscriptionsPlanRepository],
+  exports: [SubscriptionsService, TypeOrmModule, SubscriptionsPlanRepository, UserSubscriptionsRepository],
 })
 export class SubscriptionsModule {}