ahasani/psp_api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
ahasani194
2026-02-04 13:49:07 +03:30
parent 5fd6611aca
commit de14d531e1
222 changed files with 7053 additions and 57956 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/pos/dto/update-pos.dto.ts
-21
View File
@@ -1,21 +0,0 @@
import { ApiPropertyOptional } from '@nestjs/swagger'
import { Type } from 'class-transformer'
import { IsBoolean, IsOptional, IsString } from 'class-validator'
export class UpdateInventoryDto {
@ApiPropertyOptional()
@IsOptional()
@IsString()
name?: string
@ApiPropertyOptional()
@IsOptional()
@IsString()
location?: string
@ApiPropertyOptional()
@IsOptional()
@Type(() => Boolean)
@IsBoolean()
isActive?: boolean
}
src/modules/pos/orders/dto/create-order-item.dto.ts
-37
View File
@@ -1,37 +0,0 @@
import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger'
import { Type } from 'class-transformer'
import { ArrayMinSize, IsInt, IsNumber, IsOptional, IsString } from 'class-validator'
export class CreateOrderDto {
@ApiPropertyOptional()
@IsOptional()
@IsInt()
@Type(() => Number)
customerId?: number
@ApiPropertyOptional()
@IsOptional()
@IsString()
description?: string
@ApiProperty()
@ArrayMinSize(1)
items: CreateOrderItemDto[]
}
export class CreateOrderItemDto {
@ApiProperty()
@IsInt()
@Type(() => Number)
productId: number
@ApiProperty()
@IsNumber()
@Type(() => Number)
count: number
@ApiProperty()
@IsNumber()
@Type(() => Number)
unitPrice: number
}
src/modules/pos/orders/orders.controller.ts
-44
View File
@@ -1,44 +0,0 @@
import { Body, Controller, Get, Param, Post } from '@nestjs/common'
import { OrderStatus } from '../../../generated/prisma/enums'
import { CreateOrderDto } from './dto/create-order-item.dto'
import { PosOrdersService } from './orders.service'
@Controller('pos/:posId/orders')
export class PosOrdersController {
constructor(private readonly posOrdersService: PosOrdersService) {}
@Get('')
get(@Param('posId') posId: string) {
return this.posOrdersService.getOrders(Number(posId))
}
@Get('/held')
getHeld(@Param('posId') posId: string) {
return this.posOrdersService.getOrders(Number(posId), OrderStatus.PENDING)
}
@Post('')
async createOrder(@Param('posId') posId: string, @Body() dto: CreateOrderDto) {
return this.posOrdersService.createOrder(Number(posId), dto)
}
@Get('/:orderId')
getOrderDetails(@Param('posId') posId: string, @Param('orderId') orderId: string) {
return this.posOrdersService.getOrderDetails(Number(posId), Number(orderId))
}
@Post('/:orderId/reject')
async rejectOrder(@Param('posId') posId: string, @Param('orderId') orderId: string) {
return this.posOrdersService.rejectOrder(Number(posId), Number(orderId))
}
@Post('/:orderId/done')
async completeOrder(@Param('posId') posId: string, @Param('orderId') orderId: string) {
return this.posOrdersService.completeOrder(Number(posId), Number(orderId))
}
@Post('/:orderId/cancel')
async cancelOrder(@Param('posId') posId: string, @Param('orderId') orderId: string) {
return this.posOrdersService.cancelOrder(Number(posId), Number(orderId))
}
}
src/modules/pos/orders/orders.module.ts
-13
View File
@@ -1,13 +0,0 @@
import { Module } from '@nestjs/common'
import { PrismaModule } from '../../../prisma/prisma.module'
import { SalesInvoicesModule } from '../../sales-invoices/sales-invoices.module'
import { PosOrdersController } from './orders.controller'
import { PosOrdersService } from './orders.service'
import { PosOrdersWorkflow } from './orders.workflow'
@Module({
imports: [PrismaModule, SalesInvoicesModule],
controllers: [PosOrdersController],
providers: [PosOrdersService, PosOrdersWorkflow],
})
export class PosOrdersModule {}
src/modules/pos/orders/orders.service.ts
-145
View File
@@ -1,145 +0,0 @@
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from '../../../common/response/response-mapper'
import { Prisma } from '../../../generated/prisma/client'
import { OrderStatus } from '../../../generated/prisma/enums'
import { OrderCreateInput } from '../../../generated/prisma/models'
import { PrismaService } from '../../../prisma/prisma.service'
import { CreateOrderDto } from './dto/create-order-item.dto'
import { PosOrdersWorkflow } from './orders.workflow'
@Injectable()
export class PosOrdersService {
constructor(
private prisma: PrismaService,
private posWorkflow: PosOrdersWorkflow,
) {}
async createOrder(posId: number, data: CreateOrderDto) {
const { customerId, items, ...rest } = data
const lastCode = await this.prisma.order
.findFirst({
where: { posAccountId: posId },
orderBy: { orderNumber: 'desc' },
select: { orderNumber: true },
})
.then(si => si?.orderNumber || '0')
const newCode = String(Number(lastCode) + 1)
const totalAmount = data.items.reduce(
(acc, item) => acc + item.count * item.unitPrice,
0,
)
const preparedOrder: OrderCreateInput = {
...rest,
orderNumber: newCode,
posAccount: { connect: { id: posId } },
customer: customerId ? { connect: { id: customerId } } : undefined,
totalAmount,
orderItems: {
create: items.map(item => ({
product: { connect: { id: Number(item.productId) } },
quantity: item.count,
unitPrice: item.unitPrice,
totalAmount: item.count * item.unitPrice,
})),
},
}
const item = await this.prisma.$transaction(async tx => {
const order = await tx.order.create({ data: preparedOrder })
await this.posWorkflow.onCreateOrder(tx, order.id, posId)
})
return ResponseMapper.create(item)
}
async createAndConfirmOrder(posId: number, data: CreateOrderDto) {}
async rejectOrder(posAccountId: number, orderId: number) {
const item = await this.prisma.$transaction(async tx => {
const order = await tx.order.update({
where: { id: orderId, posAccountId },
data: { status: OrderStatus.REJECTED },
})
await this.posWorkflow.onRejectOrder(tx, orderId)
return order
})
return ResponseMapper.single(item)
}
async completeOrder(posAccountId: number, orderId: number) {
const item = await this.prisma.$transaction(async tx => {
const order = await tx.order.update({
where: { id: orderId, posAccountId },
data: { status: OrderStatus.DONE },
})
await this.posWorkflow.onConfirmOrder(tx, orderId)
return order
})
return ResponseMapper.single(item)
}
async cancelOrder(posAccountId: number, orderId: number) {
const item = await this.prisma.$transaction(async tx => {
const order = await tx.order.update({
where: { id: orderId, posAccountId },
data: { status: OrderStatus.CANCELED },
})
await this.posWorkflow.onCancelOrder(tx, orderId)
return order
})
return ResponseMapper.single(item)
}
async getOrders(posId: number, status?: OrderStatus) {
const where: Prisma.OrderWhereInput = {
posAccountId: posId,
status,
}
if (status) {
where.status = status
}
const items = await this.prisma.order.findMany({
where,
include: {
customer: {
select: {
id: true,
firstName: true,
lastName: true,
},
},
orderItems: {
include: {
product: true,
},
},
},
orderBy: { createdAt: 'desc' },
})
return ResponseMapper.list(items)
}
async getOrderDetails(posAccountId: number, orderId: number) {
const item = await this.prisma.order.findUniqueOrThrow({
where: { id: orderId, posAccountId },
include: {
customer: {
select: {
id: true,
firstName: true,
lastName: true,
},
},
orderItems: {
include: {
product: true,
},
},
},
})
return ResponseMapper.single(item)
}
}
src/modules/pos/orders/orders.workflow.ts
-87
View File
@@ -1,87 +0,0 @@
import { Injectable } from '@nestjs/common'
import { Prisma } from '../../../generated/prisma/client'
import { SalesInvoicesWorkflow } from '../../sales-invoices/sales-invoices.workflow'
@Injectable()
export class PosOrdersWorkflow {
constructor(private salesInvoicesWorkflow: SalesInvoicesWorkflow) {}
async onCreateOrder(tx: Prisma.TransactionClient, orderId: number, posId: number) {
const { inventoryId } = await tx.posAccount.findUniqueOrThrow({
where: { id: posId },
select: { inventoryId: true },
})
const orderItems = await tx.orderItem.findMany({
where: { orderId },
select: {
product: true,
quantity: true,
},
})
await tx.stockReservation.createMany({
data: orderItems.map(item => ({
orderId,
productId: item.product.id,
quantity: item.quantity,
inventoryId,
})),
})
}
async onRejectOrder(tx: Prisma.TransactionClient, orderId: number) {
const orderItemIds = await tx.orderItem
.findMany({
where: { orderId },
select: {
productId: true,
},
})
.then(items => items.map(i => i.productId))
await tx.stockReservation.deleteMany({
where: {
orderId,
productId: { in: orderItemIds },
},
})
}
async onConfirmOrder(tx: Prisma.TransactionClient, orderId: number) {
const orderItems = await tx.orderItem.findMany({
where: { orderId },
select: {
product: true,
quantity: true,
},
})
await tx.stockReservation.deleteMany({
where: {
orderId,
productId: { in: orderItems.map(i => i.product.id) },
},
})
await this.salesInvoicesWorkflow.onCreateByOrder(tx, orderId)
}
async onCancelOrder(tx: Prisma.TransactionClient, orderId: number) {
const orderItemIds = await tx.orderItem
.findMany({
where: { orderId },
select: {
productId: true,
},
})
.then(items => items.map(i => i.productId))
await tx.stockReservation.deleteMany({
where: {
orderId,
productId: { in: orderItemIds },
},
})
}
}
src/modules/pos/pos.controller.ts
-34
View File
@@ -1,34 +0,0 @@
import { Controller, Get, Param, Query } from '@nestjs/common'
import { PosService } from './pos.service'
@Controller('pos')
export class PosController {
constructor(private readonly posService: PosService) {}
@Get('/:posId')
getInfo(@Param('posId') posId: string) {
return this.posService.getInfo(Number(posId))
}
@Get('/:posId/stock')
async getStock(
@Param('posId') posId: string,
@Query('isAvailable') isAvailable?: string,
@Query('page') page?: string,
@Query('pageSize') pageSize?: string,
@Query('q') q?: string,
) {
const options = {
isAvailable: isAvailable ? isAvailable === 'true' : undefined,
page: page ? Number(page) : undefined,
pageSize: pageSize ? Number(pageSize) : undefined,
q,
}
return this.posService.getStock(Number(posId), options)
}
@Get('/:posId/product-categories')
async getProductCategories(@Param('posId') posId: string) {
return this.posService.getProductCategories(Number(posId))
}
}
src/modules/pos/pos.module.ts
-12
View File
@@ -1,12 +0,0 @@
import { Module } from '@nestjs/common'
import { PrismaModule } from '../../prisma/prisma.module'
import { PosOrdersModule } from './orders/orders.module'
import { PosController } from './pos.controller'
import { PosService } from './pos.service'
@Module({
imports: [PrismaModule, PosOrdersModule],
controllers: [PosController],
providers: [PosService],
})
export class PosModule {}
src/modules/pos/pos.service.ts
-154
View File
@@ -1,154 +0,0 @@
import { Injectable } from '@nestjs/common'
import { ResponseMapper } from '../../common/response/response-mapper'
import { PrismaService } from '../../prisma/prisma.service'
@Injectable()
export class PosService {
constructor(private prisma: PrismaService) {}
async getInfo(posId: number) {
const info = await this.prisma.posAccount.findUniqueOrThrow({
where: { id: posId },
include: {
inventoryBankAccount: {
include: {
bankAccount: {
select: {
id: true,
name: true,
accountNumber: true,
branch: {
select: {
id: true,
name: true,
bank: { select: { id: true, name: true } },
},
},
},
},
inventory: {
select: { id: true, name: true },
},
},
},
},
})
const { inventoryBankAccount, ...rest } = info
return ResponseMapper.single({
...rest,
bankAccount: inventoryBankAccount?.bankAccount,
inventory: inventoryBankAccount?.inventory,
})
}
async getStock(
posId: number,
options: {
isAvailable?: boolean
page?: number
pageSize?: number
q?: string
productIds?: number[]
} = {},
) {
const { isAvailable, page = 1, pageSize = 50, q, productIds } = options
const pos = await this.prisma.posAccount.findUniqueOrThrow({
where: { id: posId },
select: { inventoryId: true },
})
const inventoryId = pos.inventoryId
let sql = `
SELECT sb.productId, sb.quantity - COALESCE(SUM(sr.quantity), 0) as availableQuantity, p.id, p.name, p.sku, p.description, p.salePrice, p.categoryId
FROM Stock_Balance sb
LEFT JOIN Stock_Reservations sr ON sb.productId = sr.productId AND sb.inventoryId = sr.inventoryId
LEFT JOIN Products p ON sb.productId = p.id
WHERE sb.inventoryId = ?
`
const params: any[] = [inventoryId]
if (productIds && productIds.length > 0) {
sql += ` AND sb.productId IN (${productIds.map(() => '?').join(',')})`
params.push(...productIds)
}
if (q) {
sql += ` AND (p.name LIKE ? OR p.sku LIKE ?)`
params.push(`%${q}%`, `%${q}%`)
}
sql += ` GROUP BY sb.productId`
if (isAvailable !== undefined) {
sql += isAvailable
? ` HAVING availableQuantity > 0`
: ` HAVING availableQuantity <= 0`
}
sql += ` ORDER BY sb.quantity DESC`
const items = await this.prisma.$queryRawUnsafe(sql, ...params)
const mapped = (items as any[]).map(item => ({
id: item.productId,
quantity: Number(item.availableQuantity),
product: {
id: item.id,
name: item.name,
sku: item.sku,
description: item.description,
salePrice: item.salePrice,
categoryId: item.categoryId,
},
}))
const count = mapped.length
const paginated = mapped.slice((page - 1) * pageSize, page * pageSize)
return ResponseMapper.paginate(paginated, count, page, pageSize)
}
async getProductCategories(posId: number) {
const pos = await this.prisma.posAccount.findUniqueOrThrow({
where: { id: posId },
select: { inventoryId: true },
})
const inventoryId = pos.inventoryId
const balances = await this.prisma.stockBalance.findMany({
where: { inventoryId },
select: {
product: { select: { id: true, category: { select: { id: true, name: true } } } },
quantity: true,
},
})
const map = new Map<
number,
{ id: number; name: string; totalQuantity: number; productCount: number }
>()
for (const b of balances) {
const product = b.product
const cat = product?.category
if (!cat) continue // skip products without category
const existing = map.get(cat.id)
if (existing) {
existing.totalQuantity += Number(b.quantity)
existing.productCount += 1
} else {
map.set(cat.id, {
id: cat.id,
name: cat.name,
totalQuantity: Number(b.quantity),
productCount: 1,
})
}
}
const categories = Array.from(map.values())
return ResponseMapper.list(categories)
}
}