apis init

.gitignore

@@ -1 +1,2 @@
 node_modules
+dist

package.json

@@ -19,6 +19,9 @@
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
     "test:e2e": "jest --config ./test/jest-e2e.json"
   },
+  "prisma": {
+    "seed": "ts-node prisma/seed.ts"
+  },
   "dependencies": {
     "@nestjs/common": "^10.0.0",
     "@nestjs/core": "^10.0.0",

prisma/migrations/20230921053937_wallet_user_id_uniq/migration.sql

@@ -0,0 +1,8 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[userId]` on the table `wallets` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- CreateIndex
+CREATE UNIQUE INDEX "wallets_userId_key" ON "wallets"("userId");

prisma/migrations/20230921071650_transaction_type/migration.sql

@@ -0,0 +1,12 @@
+/*
+  Warnings:
+
+  - Added the required column `type` to the `transactions` table without a default value. This is not possible if the table is not empty.
+
+*/
+-- CreateEnum
+CREATE TYPE "TransactionType" AS ENUM ('purchase', 'creditRequest', 'settlement');
+
+-- AlterTable
+ALTER TABLE "transactions" ADD COLUMN     "type" "TransactionType" NOT NULL,
+ALTER COLUMN "description" DROP NOT NULL;

prisma/schema.prisma

@@ -22,9 +22,16 @@ enum WalletStatus {
   frozen
 }
 
+enum TransactionType {
+  purchase
+  creditRequest
+  settlement
+}
+
+
 model wallets {
   walletId   Int  @id @default(autoincrement())
-  userId     Int    
+  userId     Int    @unique
   type       WalletType
   status     WalletStatus
   credits    Int
@@ -39,7 +46,8 @@ model transactions {
   fromId          Int  
   toId            Int
   credits         Int
-  description     String
+  type            TransactionType
+  description     String?
   createdAt       DateTime  @default(now())
   from            wallets @relation("FromTransaction", fields:[fromId], references:[walletId])
   to              wallets @relation("ToTransaction", fields:[toId], references:[walletId])

prisma/seed.ts

@@ -0,0 +1,23 @@
+import { PrismaClient, TransactionType, WalletStatus, WalletType } from '@prisma/client'
+const prisma = new PrismaClient()
+async function main() {
+  const wallet = await prisma.transactions.create({
+    data: {
+      credits: 15,
+      fromId: 6, 
+      toId: 10,
+      type: TransactionType.settlement,
+
+    }
+  })
+  console.log({ wallet })
+}
+main()
+  .then(async () => {
+    await prisma.$disconnect()
+  })
+  .catch(async (e) => {
+    console.error(e)
+    await prisma.$disconnect()
+    process.exit(1)
+  })

src/admin/admin.controller.ts

@@ -1,4 +1,112 @@
-import { Controller } from '@nestjs/common';
+import { Body, Controller, Get, Param, ParseIntPipe, Post, UnauthorizedException } from '@nestjs/common';
+import { AdminService } from './admin.service';
+import { TransactionService } from 'src/transactions/transactions.service';
+import { UserService } from 'src/user/user.service';
+import { TransactionType, WalletType } from '@prisma/client';
+import { ProviderService } from 'src/provider/provider.service';
 
 @Controller('admin')
-export class AdminController {}
+export class AdminController {
+    constructor(
+        private transactionService: TransactionService,
+        private userService: UserService,
+        private adminService: AdminService,
+        private providerService: ProviderService
+    ) {}
+
+    @Get("/:adminId/transactions/users")
+    // get all transactions of all users
+    async getAllUsersTransactions(
+        @Param("adminId", ParseIntPipe) adminId: number
+    ) {
+        // check admin
+        await this.adminService.getAdminWallet(adminId);
+
+        // fetch transactions
+        const transactions = await this.transactionService.fetchAllUsersTransactions();
+        return transactions;
+    }
+
+    @Get("/:adminId/transactions/users/:userId")
+    // get all transactions of a particular user
+    async getUserTransactions(
+        @Param("adminId", ParseIntPipe) adminId: number,
+        @Param("userId", ParseIntPipe) userId: number
+    ) {
+        // check admin
+        await this.adminService.getAdminWallet(adminId);
+
+        // check user
+        await this.userService.getUserWallet(userId);
+
+        // fetch transactions
+        const transactions = await this.transactionService.fetchTransactionsOfOneSystemActor(userId);
+        return transactions;
+    }
+
+    @Get("/:adminId/transactions/providers")
+    // get all transactions between all providers and admins
+    async getAllAdminProvidersTransactions(
+        @Param("adminId", ParseIntPipe) adminId: number
+    ) {
+        // check admin
+        await this.adminService.getAdminWallet(adminId);
+
+        // fetch transactions
+        const transactions = await this.transactionService.fetchAllAdminProviderTransactions();
+        return transactions;
+    }
+
+    @Get("/:adminId/transactions/providers/:providerId")
+    // get all transactions of a particular provider
+    async getProviderTransactions(
+        @Param("adminId", ParseIntPipe) adminId: number,
+        @Param("providerId", ParseIntPipe) providerId: number
+    ) {
+        // check admin
+        await this.adminService.getAdminWallet(adminId);
+
+        // check provider
+        await this.providerService.getProviderWallet(providerId);
+
+        // fetch transactions
+        const transactions = await this.transactionService.fetchTransactionsOfOneSystemActor(providerId);
+        return transactions;
+    }
+
+    @Post("/:adminId/add-credits")
+    // add credits to a user's wallet
+    async addCredits(
+        @Param("adminId", ParseIntPipe) adminId: number,
+        @Body("userId") userId: number,
+        @Body("credits") credits: number
+    ) { 
+        // check admin
+        const adminWallet = await this.adminService.getAdminWallet(adminId);
+
+        // update wallet
+        const userWallet = await this.userService.addCreditsToUser(userId, credits);
+
+        // create transaction
+        await this.transactionService.createTransaction(credits, adminWallet.walletId, userWallet.walletId, TransactionType.creditRequest);
+        return userWallet.credits;
+    }
+
+    @Post("/:adminId/reduce-credits")
+    // reduce credits from a user's wallet
+    async reduceCredits(
+        @Param("adminId", ParseIntPipe) adminId: number,
+        @Body("userId") userId: number,
+        @Body("credits") credits: number
+    ) {
+        // check admin
+        const adminWallet = await this.adminService.getAdminWallet(adminId);
+
+        // update wallet
+        const userWallet = await this.userService.reduceUserCredits(userId, credits);
+
+        // create transaction
+        await this.transactionService.createTransaction(credits, userWallet.walletId, adminWallet.walletId, TransactionType.creditRequest);
+        return userWallet.credits;
+    }
+}

src/admin/admin.module.ts

@@ -1,9 +1,13 @@
 import { Module } from '@nestjs/common';
 import { AdminController } from './admin.controller';
 import { AdminService } from './admin.service';
+import { TransactionService } from 'src/transactions/transactions.service';
+import { WalletService } from 'src/wallet/wallet.service';
+import { UserService } from 'src/user/user.service';
+import { ProviderService } from 'src/provider/provider.service';
 
 @Module({
   controllers: [AdminController],
-  providers: [AdminService]
+  providers: [AdminService, TransactionService, WalletService, UserService, ProviderService]
 })
 export class AdminModule {}

src/admin/admin.service.ts

@@ -1,4 +1,25 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, NotFoundException, UnauthorizedException } from '@nestjs/common';
+import { WalletType } from '@prisma/client';
+import { prisma } from 'src/main';
+import { WalletService } from 'src/wallet/wallet.service';
 
 @Injectable()
-export class AdminService {}
+export class AdminService {
+    constructor(
+        private walletService: WalletService,
+    ) {}
+
+    async getAdminWallet(adminId: number) {
+        // get admin wallet
+        const adminWallet = await this.walletService.fetchWallet(adminId);
+        if(adminWallet == null) {
+            throw new NotFoundException;
+        }
+
+        // check admin
+        if(adminWallet.type != WalletType.admin) {
+            throw new UnauthorizedException;
+        }
+        return adminWallet;
+    }
+}

src/main.ts

@@ -1,8 +1,19 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
   await app.listen(3000);
 }
-bootstrap();
+bootstrap()
+  .then(async () => {
+    await prisma.$disconnect()
+  })
+  .catch(async (e) => {
+    console.error(e)
+    await prisma.$disconnect()
+    process.exit(1)
+  })

src/provider/provider.controller.ts

@@ -1,4 +1,24 @@
-import { Controller } from '@nestjs/common';
+import { Controller, Get, Param, ParseIntPipe } from '@nestjs/common';
+import { TransactionService } from 'src/transactions/transactions.service';
+import { ProviderService } from './provider.service';
 
-@Controller('provider')
-export class ProviderController {}
+@Controller('providers')
+export class ProviderController {
+    constructor(
+        private transactionService: TransactionService,
+        private providerService: ProviderService
+    ) {}
+
+    @Get("/:providerId/transactions")
+    // get all transactions of a particular provider
+    async getProviderTransactions(
+        @Param("providerId", ParseIntPipe) providerId: number,
+    ) {
+        // check provider
+        await this.providerService.getProviderWallet(providerId);
+
+        // fetch transactions
+        const transactions = await this.transactionService.fetchTransactionsOfOneSystemActor(providerId);
+        return transactions;
+    }
+}

src/provider/provider.module.ts

@@ -1,9 +1,11 @@
 import { Module } from '@nestjs/common';
 import { ProviderController } from './provider.controller';
 import { ProviderService } from './provider.service';
+import { TransactionService } from 'src/transactions/transactions.service';
+import { WalletService } from 'src/wallet/wallet.service';
 
 @Module({
   controllers: [ProviderController],
-  providers: [ProviderService]
+  providers: [ProviderService, TransactionService, WalletService]
 })
 export class ProviderModule {}

src/provider/provider.service.ts

@@ -1,4 +1,35 @@
-import { Injectable } from '@nestjs/common';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { WalletType } from '@prisma/client';
+import { WalletService } from 'src/wallet/wallet.service';
 
 @Injectable()
-export class ProviderService {}
+export class ProviderService {
+    constructor(
+        private walletService: WalletService,
+    ) {}
+
+    async getProviderWallet(providerId: number) {
+        // get provider wallet
+        const providerWallet = await this.walletService.fetchWallet(providerId)
+        if(providerWallet == null) {
+            throw new NotFoundException;
+        }
+
+        // check provider
+        if(providerWallet.type != WalletType.provider) {
+            throw new BadRequestException;
+        }
+        return providerWallet;
+    }
+
+    async addCreditsToProvider(providerId: number, credits: number) {
+
+        // check provider
+        let providerWallet = await this.getProviderWallet(providerId)
+
+        // update provider wallet
+        providerWallet = await this.walletService.updateWalletCredits(providerId, providerWallet.credits + credits);
+        return providerWallet;
+    }
+
+}