525 lines
14 KiB
TypeScript
525 lines
14 KiB
TypeScript
import config from "../config.json";
|
|
import {
|
|
Customer,
|
|
CustomerBranch,
|
|
ProductGroup,
|
|
QuotationStatus,
|
|
RequestWorkStatus,
|
|
User,
|
|
} from "@prisma/client";
|
|
import { Controller, Get, Query, Request, Route, Security, Tags } from "tsoa";
|
|
import prisma from "../db";
|
|
import { createPermCondition } from "../services/permission";
|
|
import { RequestWithUser } from "../interfaces/user";
|
|
import { PaymentStatus } from "../generated/kysely/types";
|
|
import { precisionRound } from "../utils/arithmetic";
|
|
import dayjs from "dayjs";
|
|
import { json2csv } from "json-2-csv";
|
|
|
|
const permissionCondCompany = createPermCondition((_) => true);
|
|
|
|
const VAT_DEFAULT = config.vat;
|
|
|
|
@Route("/api/v1/report")
|
|
@Security("keycloak")
|
|
@Tags("Report")
|
|
export class StatsController extends Controller {
|
|
@Get("quotation/download")
|
|
async downloadQuotationReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
this.setHeader("Content-Type", "text/csv");
|
|
return json2csv(await this.quotationReport(req, limit, startDate, endDate), {
|
|
useDateIso8601Format: true,
|
|
});
|
|
}
|
|
|
|
@Get("quotation")
|
|
async quotationReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
const record = await prisma.quotation.findMany({
|
|
select: {
|
|
code: true,
|
|
quotationStatus: true,
|
|
createdAt: true,
|
|
updatedAt: true,
|
|
},
|
|
where: {
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: limit,
|
|
});
|
|
|
|
return record.map((v) => ({
|
|
document: "quotation",
|
|
code: v.code,
|
|
status: v.quotationStatus,
|
|
createdAt: v.createdAt,
|
|
updatedAt: v.updatedAt,
|
|
}));
|
|
}
|
|
|
|
@Get("invoice/download")
|
|
async downloadInvoiceReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
this.setHeader("Content-Type", "text/csv");
|
|
return json2csv(await this.invoiceReport(req, limit, startDate, endDate), {
|
|
useDateIso8601Format: true,
|
|
});
|
|
}
|
|
|
|
@Get("invoice")
|
|
async invoiceReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
const record = await prisma.invoice.findMany({
|
|
select: {
|
|
code: true,
|
|
payment: {
|
|
select: {
|
|
paymentStatus: true,
|
|
},
|
|
},
|
|
amount: true,
|
|
createdAt: true,
|
|
},
|
|
where: {
|
|
quotation: {
|
|
isDebitNote: false,
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
},
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: limit,
|
|
});
|
|
|
|
return record.map((v) => ({
|
|
document: "invoice",
|
|
code: v.code,
|
|
status: v.payment?.paymentStatus,
|
|
amount: v.amount,
|
|
createdAt: v.createdAt,
|
|
}));
|
|
}
|
|
|
|
@Get("receipt/download")
|
|
async downloadReceiptReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
this.setHeader("Content-Type", "text/csv");
|
|
return json2csv(await this.receiptReport(req, limit, startDate, endDate), {
|
|
useDateIso8601Format: true,
|
|
});
|
|
}
|
|
|
|
@Get("receipt")
|
|
async receiptReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
const record = await prisma.payment.findMany({
|
|
select: {
|
|
code: true,
|
|
paymentStatus: true,
|
|
createdAt: true,
|
|
},
|
|
where: {
|
|
paymentStatus: PaymentStatus.PaymentSuccess,
|
|
invoice: {
|
|
quotation: {
|
|
isDebitNote: false,
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
},
|
|
},
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
},
|
|
orderBy: { createdAt: "desc" },
|
|
take: limit,
|
|
});
|
|
|
|
return record.map((v) => ({
|
|
document: "receipt",
|
|
code: v.code,
|
|
status: v.paymentStatus,
|
|
createdAt: v.createdAt,
|
|
}));
|
|
}
|
|
|
|
@Get("product/download")
|
|
async downloadProductReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
this.setHeader("Content-Type", "text/csv");
|
|
return json2csv(await this.productReport(req, limit, startDate, endDate), {
|
|
useDateIso8601Format: true,
|
|
});
|
|
}
|
|
|
|
@Get("product")
|
|
async productReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
return await prisma.$transaction(async (tx) => {
|
|
const record = await tx.product.findMany({
|
|
select: {
|
|
id: true,
|
|
code: true,
|
|
name: true,
|
|
createdAt: true,
|
|
updatedAt: true,
|
|
quotationProductServiceList: {
|
|
include: { quotation: true },
|
|
},
|
|
_count: {
|
|
select: {
|
|
quotationProductServiceList: {
|
|
where: {
|
|
quotation: {
|
|
quotationStatus: {
|
|
in: [
|
|
QuotationStatus.PaymentInProcess,
|
|
QuotationStatus.PaymentSuccess,
|
|
QuotationStatus.ProcessComplete,
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
where: {
|
|
quotationProductServiceList: {
|
|
some: {
|
|
quotation: { createdAt: { gte: startDate, lte: endDate } },
|
|
},
|
|
},
|
|
productGroup: { registeredBranch: { OR: permissionCondCompany(req.user) } },
|
|
},
|
|
orderBy: {
|
|
quotationProductServiceList: { _count: "desc" },
|
|
},
|
|
take: limit,
|
|
});
|
|
|
|
const doing = await tx.quotationProductServiceList.groupBy({
|
|
_count: true,
|
|
by: "productId",
|
|
where: {
|
|
quotation: {
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
},
|
|
productId: { in: record.map((v) => v.id) },
|
|
requestWork: {
|
|
some: {
|
|
stepStatus: {
|
|
some: {
|
|
workStatus: {
|
|
in: [
|
|
RequestWorkStatus.Pending,
|
|
RequestWorkStatus.InProgress,
|
|
RequestWorkStatus.Validate,
|
|
RequestWorkStatus.Completed,
|
|
RequestWorkStatus.Ended,
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
});
|
|
|
|
const order = await tx.quotationProductServiceList.groupBy({
|
|
_count: true,
|
|
by: "productId",
|
|
where: {
|
|
quotation: {
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
},
|
|
productId: { in: record.map((v) => v.id) },
|
|
},
|
|
});
|
|
|
|
return record.map((v) => ({
|
|
document: "product",
|
|
code: v.code,
|
|
name: v.name,
|
|
sale: v._count.quotationProductServiceList,
|
|
did: doing.find((item) => item.productId === v.id)?._count || 0,
|
|
order: order.find((item) => item.productId === v.id)?._count || 0,
|
|
createdAt: v.createdAt,
|
|
updatedAt: v.updatedAt,
|
|
}));
|
|
});
|
|
}
|
|
|
|
@Get("sale")
|
|
async saleReport(
|
|
@Request() req: RequestWithUser,
|
|
@Query() limit?: number,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
const list = await prisma.quotationProductServiceList.findMany({
|
|
include: {
|
|
quotation: {
|
|
include: {
|
|
createdBy: true,
|
|
customerBranch: {
|
|
include: { customer: true },
|
|
},
|
|
},
|
|
},
|
|
product: {
|
|
include: {
|
|
productGroup: true,
|
|
},
|
|
},
|
|
},
|
|
where: {
|
|
quotation: {
|
|
isDebitNote: false,
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
quotationStatus: {
|
|
in: [
|
|
QuotationStatus.PaymentInProcess,
|
|
QuotationStatus.PaymentSuccess,
|
|
QuotationStatus.ProcessComplete,
|
|
],
|
|
},
|
|
},
|
|
},
|
|
take: limit,
|
|
});
|
|
|
|
return list.reduce<{
|
|
byProductGroup: (ProductGroup & { _count: number })[];
|
|
bySale: (User & { _count: number })[];
|
|
byCustomer: ((CustomerBranch & { customer: Customer }) & { _count: number })[];
|
|
}>(
|
|
(a, c) => {
|
|
{
|
|
const found = a.byProductGroup.find((v) => v.id === c.product.productGroupId);
|
|
if (found) {
|
|
found._count++;
|
|
} else {
|
|
a.byProductGroup.push({ ...c.product.productGroup, _count: 1 });
|
|
}
|
|
}
|
|
|
|
{
|
|
const found = a.bySale.find((v) => v.id === c.quotation.createdByUserId);
|
|
if (found) {
|
|
found._count++;
|
|
} else {
|
|
if (c.quotation.createdBy) {
|
|
a.bySale.push({ ...c.quotation.createdBy, _count: 1 });
|
|
}
|
|
}
|
|
}
|
|
|
|
{
|
|
const found = a.byCustomer.find((v) => v.id === c.quotation.customerBranchId);
|
|
if (found) {
|
|
found._count++;
|
|
} else {
|
|
a.byCustomer.push({ ...c.quotation.customerBranch, _count: 1 });
|
|
}
|
|
}
|
|
|
|
return a;
|
|
},
|
|
{ byProductGroup: [], bySale: [], byCustomer: [] },
|
|
);
|
|
}
|
|
|
|
@Get("profit")
|
|
async profit(
|
|
@Request() req: RequestWithUser,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
const record = await prisma.quotationProductServiceList.findMany({
|
|
include: {
|
|
work: {
|
|
include: {
|
|
productOnWork: {
|
|
select: { stepCount: true, productId: true },
|
|
},
|
|
},
|
|
},
|
|
product: {
|
|
select: {
|
|
agentPrice: true,
|
|
agentPriceCalcVat: true,
|
|
agentPriceVatIncluded: true,
|
|
serviceCharge: true,
|
|
serviceChargeCalcVat: true,
|
|
serviceChargeVatIncluded: true,
|
|
price: true,
|
|
calcVat: true,
|
|
vatIncluded: true,
|
|
},
|
|
},
|
|
requestWork: {
|
|
include: {
|
|
stepStatus: true,
|
|
creditNote: true,
|
|
},
|
|
},
|
|
quotation: {
|
|
select: {
|
|
agentPrice: true,
|
|
creditNote: true,
|
|
},
|
|
},
|
|
},
|
|
where: {
|
|
quotation: {
|
|
quotationStatus: {
|
|
in: [
|
|
QuotationStatus.PaymentInProcess,
|
|
QuotationStatus.PaymentSuccess,
|
|
QuotationStatus.ProcessComplete,
|
|
],
|
|
},
|
|
registeredBranch: {
|
|
OR: permissionCondCompany(req.user),
|
|
},
|
|
createdAt: { gte: startDate, lte: endDate },
|
|
},
|
|
},
|
|
});
|
|
|
|
const data = record.map((v) => {
|
|
const originalPrice = v.product.serviceCharge;
|
|
const productExpenses = precisionRound(
|
|
originalPrice + (v.product.serviceChargeVatIncluded ? 0 : originalPrice * VAT_DEFAULT),
|
|
);
|
|
const finalPrice = v.pricePerUnit * v.amount * (1 + config.vat);
|
|
|
|
return v.requestWork.map((w) => {
|
|
const creditNote = w.creditNote;
|
|
const roundCount = v.work?.productOnWork.find((p) => p.productId)?.stepCount || 1;
|
|
const successCount = w.stepStatus.filter(
|
|
(s) => s.workStatus !== RequestWorkStatus.Canceled,
|
|
).length;
|
|
|
|
const income = creditNote
|
|
? precisionRound(productExpenses * successCount)
|
|
: precisionRound(finalPrice);
|
|
const expenses = creditNote
|
|
? precisionRound(productExpenses * successCount)
|
|
: precisionRound(productExpenses * roundCount);
|
|
const netProfit = creditNote ? 0 : precisionRound(finalPrice - expenses);
|
|
|
|
return {
|
|
income,
|
|
expenses,
|
|
netProfit,
|
|
};
|
|
});
|
|
});
|
|
|
|
return data.flat().reduce(
|
|
(a, c) => {
|
|
a.income += c.income;
|
|
a.expenses += c.expenses;
|
|
a.netProfit += c.netProfit;
|
|
return a;
|
|
},
|
|
{ income: 0, expenses: 0, netProfit: 0 },
|
|
);
|
|
}
|
|
|
|
@Get("payment")
|
|
async invoice(
|
|
@Request() req: RequestWithUser,
|
|
@Query() startDate?: Date,
|
|
@Query() endDate?: Date,
|
|
) {
|
|
if (!startDate && !endDate) {
|
|
startDate = dayjs(new Date()).subtract(12, "months").startOf("month").toDate();
|
|
endDate = dayjs(new Date()).endOf("months").toDate();
|
|
}
|
|
|
|
if (!startDate && endDate) {
|
|
startDate = dayjs(endDate).subtract(12, "months").startOf("month").toDate();
|
|
}
|
|
|
|
if (startDate && !endDate) {
|
|
endDate = dayjs(new Date()).endOf("month").toDate();
|
|
}
|
|
|
|
const data = await prisma.$transaction(async (tx) => {
|
|
const months: Date[] = [];
|
|
|
|
while (startDate! < endDate!) {
|
|
months.push(startDate!);
|
|
startDate = dayjs(startDate).startOf("month").add(1, "month").toDate();
|
|
}
|
|
|
|
return await Promise.all(
|
|
months.map(async (v) => {
|
|
const date = dayjs(v);
|
|
return {
|
|
month: date.format("MM"),
|
|
year: date.format("YYYY"),
|
|
data: await tx.payment
|
|
.groupBy({
|
|
_sum: { amount: true },
|
|
where: {
|
|
createdAt: { gte: v, lte: date.endOf("month").toDate() },
|
|
invoice: {
|
|
quotation: {
|
|
registeredBranch: { OR: permissionCondCompany(req.user) },
|
|
},
|
|
},
|
|
},
|
|
by: "paymentStatus",
|
|
})
|
|
.then((v) =>
|
|
v.reduce<Partial<Record<(typeof v)[number]["paymentStatus"], number>>>((a, c) => {
|
|
a[c.paymentStatus] = c._sum.amount || 0;
|
|
return a;
|
|
}, {}),
|
|
),
|
|
};
|
|
}),
|
|
);
|
|
});
|
|
return data;
|
|
}
|
|
}
|