476 lines
15 KiB
TypeScript
476 lines
15 KiB
TypeScript
import { Inject, Injectable } from '@nestjs/common'
|
|
import { OrderStatus, Prisma, Role, ServiceStatus } from '@prisma/client'
|
|
import { Pothos, PothosRef, PothosSchema, SchemaBuilderToken } from '@smatch-corp/nestjs-pothos'
|
|
import { CenterSchema } from 'src/Center/center.schema'
|
|
import { Builder } from 'src/Graphql/graphql.builder'
|
|
import { OrderSchema } from 'src/Order/order.schema'
|
|
import { PrismaService } from 'src/Prisma/prisma.service'
|
|
import { ServiceSchema } from 'src/Service/service.schema'
|
|
import { DateTimeUtils } from 'src/common/utils/datetime.utils'
|
|
@Injectable()
|
|
export class AnalyticSchema extends PothosSchema {
|
|
constructor(
|
|
@Inject(SchemaBuilderToken) private readonly builder: Builder,
|
|
private readonly prisma: PrismaService,
|
|
private readonly serviceSchema: ServiceSchema,
|
|
private readonly centerSchema: CenterSchema,
|
|
private readonly orderSchema: OrderSchema,
|
|
) {
|
|
super()
|
|
}
|
|
|
|
@PothosRef()
|
|
customerAnalytic() {
|
|
return this.builder.simpleObject('CustomerAnalytic', {
|
|
description: 'A customer analytic in the system.',
|
|
fields: (t) => ({
|
|
userId: t.string({
|
|
description: 'The ID of the user.',
|
|
}),
|
|
activeServiceCount: t.int({
|
|
description: 'The number of active services.',
|
|
}),
|
|
totalServiceCount: t.int({
|
|
description: 'The total number of services.',
|
|
}),
|
|
totalSpent: t.float({
|
|
description: 'The total amount spent.',
|
|
}),
|
|
updatedAt: t.field({
|
|
type: 'DateTime',
|
|
description: 'The date the analytic was last updated.',
|
|
}),
|
|
}),
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
mentorAnalytic() {
|
|
return this.builder.simpleObject('MentorAnalytic', {
|
|
description: 'A mentor analytic in the system.',
|
|
fields: (t) => ({
|
|
userId: t.string({
|
|
description: 'The ID of the mentor.',
|
|
}),
|
|
}),
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
centerAnalytic() {
|
|
return this.builder.simpleObject('CenterAnalytic', {
|
|
description: 'A center analytic in the system.',
|
|
fields: (t) => ({
|
|
centerId: t.string({
|
|
description: 'The ID of the center.',
|
|
}),
|
|
activeMentorCount: t.int({
|
|
description: 'The number of active mentors.',
|
|
}),
|
|
activeServiceCount: t.int({
|
|
description: 'The number of active services.',
|
|
}),
|
|
totalServiceCount: t.int({
|
|
description: 'The total number of services.',
|
|
}),
|
|
revenue: t.int({
|
|
description: 'The total revenue.',
|
|
}),
|
|
rating: t.float({
|
|
description: 'The average rating.',
|
|
nullable: true,
|
|
}),
|
|
updatedAt: t.field({
|
|
type: 'DateTime',
|
|
description: 'The date the analytic was last updated.',
|
|
}),
|
|
}),
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
platformAnalytic() {
|
|
return this.builder.simpleObject('PlatformAnalytic', {
|
|
description: 'A platform analytic in the system.',
|
|
fields: (t) => ({
|
|
topServices: t.field({
|
|
type: [this.serviceSchema.service()],
|
|
description: 'The top services by revenue.',
|
|
}),
|
|
topCenters: t.field({
|
|
type: [this.centerSchema.center()],
|
|
description: 'The top centers by revenue.',
|
|
}),
|
|
pendingRefunds: t.field({
|
|
type: [this.orderSchema.order()],
|
|
description: 'The pending refunds.',
|
|
}),
|
|
activeCenterCount: t.int({
|
|
description: 'The number of active centers.',
|
|
}),
|
|
totalCenterCount: t.int({
|
|
description: 'The total number of centers.',
|
|
}),
|
|
totalUserCount: t.int({
|
|
description: 'The total number of users.',
|
|
}),
|
|
activeMentorCount: t.int({
|
|
description: 'The number of active mentors.',
|
|
}),
|
|
totalMentorCount: t.int({
|
|
description: 'The total number of mentors.',
|
|
}),
|
|
totalServiceCount: t.int({
|
|
description: 'The total number of services.',
|
|
}),
|
|
totalWorkshopCount: t.int({
|
|
description: 'The total number of workshops.',
|
|
}),
|
|
revenue: t.int({
|
|
description: 'The total revenue.',
|
|
}),
|
|
approvedServiceCount: t.int({
|
|
description: 'The number of approved services.',
|
|
}),
|
|
rejectedServiceCount: t.int({
|
|
description: 'The number of rejected services.',
|
|
}),
|
|
updatedAt: t.field({
|
|
type: 'DateTime',
|
|
description: 'The date the analytic was last updated.',
|
|
}),
|
|
}),
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
timeframes() {
|
|
return this.builder.enumType('Timeframe', {
|
|
values: ['day', 'week', 'month', 'year'],
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
serviceSortBy() {
|
|
return this.builder.enumType('ServiceSortBy', {
|
|
values: ['order', 'rating'],
|
|
})
|
|
}
|
|
|
|
@PothosRef()
|
|
centerSortBy() {
|
|
return this.builder.enumType('CenterSortBy', {
|
|
values: ['revenue', 'rating', 'services'],
|
|
})
|
|
}
|
|
|
|
@Pothos()
|
|
init(): void {
|
|
this.builder.queryFields((t) => ({
|
|
customerAnalytic: t.field({
|
|
type: this.customerAnalytic(),
|
|
description: 'Retrieve a single customer analytic.',
|
|
resolve: async (_parent, _args, ctx, _info) => {
|
|
if (!ctx.me) {
|
|
throw new Error('Unauthorized')
|
|
}
|
|
if (ctx.me.role !== Role.CUSTOMER) {
|
|
throw new Error('Only customers can access this data')
|
|
}
|
|
// calculate analytic
|
|
const activeServiceCount = await this.prisma.order.count({
|
|
where: {
|
|
userId: ctx.me.id,
|
|
status: OrderStatus.PAID,
|
|
schedule: {
|
|
dates: {
|
|
some: {
|
|
end: {
|
|
gte: DateTimeUtils.now().toJSDate(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
const totalServiceCount = await this.prisma.order.count({
|
|
where: {
|
|
userId: ctx.me.id,
|
|
},
|
|
})
|
|
const totalSpent = await this.prisma.order.aggregate({
|
|
where: {
|
|
userId: ctx.me.id,
|
|
status: OrderStatus.PAID,
|
|
},
|
|
_sum: {
|
|
total: true,
|
|
},
|
|
})
|
|
return {
|
|
userId: ctx.me.id,
|
|
activeServiceCount: activeServiceCount,
|
|
totalServiceCount: totalServiceCount,
|
|
totalSpent: totalSpent._sum.total,
|
|
updatedAt: DateTimeUtils.now(),
|
|
}
|
|
},
|
|
}),
|
|
mentorAnalytic: t.field({
|
|
type: this.mentorAnalytic(),
|
|
description: 'Retrieve a single mentor analytic.',
|
|
resolve: async (_parent, _args, ctx, _info) => {
|
|
if (!ctx.me) {
|
|
throw new Error('Unauthorized')
|
|
}
|
|
if (ctx.me.role !== Role.CENTER_MENTOR) {
|
|
throw new Error('Only center mentors can access this data')
|
|
}
|
|
// calculate analytic
|
|
return {
|
|
userId: ctx.me.id,
|
|
}
|
|
},
|
|
}),
|
|
centerAnalytic: t.field({
|
|
type: this.centerAnalytic(),
|
|
description: 'Retrieve a single center analytic.',
|
|
resolve: async (_parent, _args, ctx, _info) => {
|
|
if (!ctx.me) {
|
|
throw new Error('Unauthorized')
|
|
}
|
|
if (ctx.me.role !== Role.CENTER_OWNER) {
|
|
throw new Error('Only center owners can access this data')
|
|
}
|
|
// get center by owner id
|
|
const center = await this.prisma.center.findUnique({
|
|
where: {
|
|
centerOwnerId: ctx.me.id,
|
|
},
|
|
})
|
|
if (!center) {
|
|
throw new Error('Center not found')
|
|
}
|
|
// calculate analytic
|
|
|
|
// active mentor include center owner
|
|
const activeMentorCount = await this.prisma.user.count({
|
|
where: {
|
|
center: {
|
|
centerOwnerId: ctx.me.id,
|
|
},
|
|
banned: false,
|
|
},
|
|
})
|
|
|
|
const activeServiceCount = await this.prisma.service.count({
|
|
where: {
|
|
centerId: center.id,
|
|
status: ServiceStatus.APPROVED,
|
|
},
|
|
})
|
|
const totalServiceCount = await this.prisma.service.count({
|
|
where: {
|
|
centerId: center.id,
|
|
},
|
|
})
|
|
// calculate revenue from orders of services in the center and factor in commission percentage
|
|
// query all orders of services in the center and calculate actual revenue of each order
|
|
// then sum up the revenue
|
|
let revenue = 0
|
|
const orders = await this.prisma.order.findMany({
|
|
where: {
|
|
service: { centerId: center.id },
|
|
status: OrderStatus.PAID,
|
|
},
|
|
})
|
|
for (const order of orders) {
|
|
const service = await this.prisma.service.findUnique({
|
|
where: { id: order.serviceId },
|
|
})
|
|
if (!service) {
|
|
continue
|
|
}
|
|
const commission = service.commission
|
|
const actualRevenue = (order.total || 0) - (order.total || 0) * commission
|
|
revenue += actualRevenue
|
|
}
|
|
return {
|
|
centerId: center.id,
|
|
activeMentorCount: activeMentorCount,
|
|
activeServiceCount: activeServiceCount,
|
|
totalServiceCount: totalServiceCount,
|
|
revenue: revenue,
|
|
updatedAt: DateTimeUtils.now(),
|
|
}
|
|
},
|
|
}),
|
|
platformAnalytic: t.field({
|
|
type: this.platformAnalytic(),
|
|
args: {
|
|
take: t.arg({
|
|
type: 'Int',
|
|
description: 'The number of services to take.',
|
|
required: true,
|
|
}),
|
|
serviceSortBy: t.arg({
|
|
type: this.serviceSortBy(),
|
|
description: 'The field to sort by.',
|
|
required: true,
|
|
}),
|
|
centerSortBy: t.arg({
|
|
type: this.centerSortBy(),
|
|
description: 'The field to sort by.',
|
|
required: true,
|
|
}),
|
|
timeframes: t.arg({
|
|
type: this.timeframes(),
|
|
description: 'The frame of time Eg day, week, month, year.',
|
|
required: true,
|
|
}),
|
|
},
|
|
description: 'Retrieve a single platform analytic.',
|
|
resolve: async (_parent, args, ctx, _info) => {
|
|
if (!ctx.me) {
|
|
throw new Error('Unauthorized')
|
|
}
|
|
if (ctx.me.role !== Role.ADMIN && ctx.me.role !== Role.MODERATOR) {
|
|
throw new Error('Only admins and moderators can access this data')
|
|
}
|
|
// calculate analytic for services sorted by args.serviceSortBy and args.timeframes
|
|
const topServices = await this.prisma.service.findMany({
|
|
where: {
|
|
status: ServiceStatus.APPROVED,
|
|
},
|
|
orderBy: {
|
|
[args.serviceSortBy]: {
|
|
_count: Prisma.SortOrder.desc,
|
|
},
|
|
},
|
|
take: args.take,
|
|
})
|
|
// get top centers by args.centerSortBy
|
|
const topCenters = await this.prisma.center.findMany({
|
|
orderBy: {
|
|
[args.centerSortBy]: {
|
|
_count: Prisma.SortOrder.desc,
|
|
},
|
|
},
|
|
take: args.take,
|
|
})
|
|
// get pending refunds
|
|
const pendingRefunds = await this.prisma.order.findMany({
|
|
where: {
|
|
status: OrderStatus.PENDING_REFUND,
|
|
},
|
|
})
|
|
// get active center count by center owner not banned and have schedule with dates in the future
|
|
const activeCenterCount = await this.prisma.center.count({
|
|
where: {
|
|
centerOwner: {
|
|
banned: false,
|
|
},
|
|
centerMentors: {
|
|
some: {
|
|
managedService: {
|
|
some: {
|
|
schedule: {
|
|
some: {
|
|
dates: {
|
|
some: {
|
|
end: {
|
|
gte: DateTimeUtils.now().toJSDate(),
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
})
|
|
// get total center count
|
|
const totalCenterCount = await this.prisma.center.count()
|
|
// get total user count
|
|
const totalUserCount = await this.prisma.user.count()
|
|
// get active mentor count
|
|
const activeMentorCount = await this.prisma.user.count({
|
|
where: {
|
|
role: Role.CENTER_MENTOR,
|
|
banned: false,
|
|
},
|
|
})
|
|
// get total mentor count
|
|
const totalMentorCount = await this.prisma.user.count({
|
|
where: {
|
|
role: Role.CENTER_MENTOR,
|
|
},
|
|
})
|
|
// get approved service count
|
|
const approvedServiceCount = await this.prisma.service.count({
|
|
where: {
|
|
status: ServiceStatus.APPROVED,
|
|
},
|
|
})
|
|
// get rejected service count
|
|
const rejectedServiceCount = await this.prisma.service.count({
|
|
where: {
|
|
status: ServiceStatus.REJECTED,
|
|
},
|
|
})
|
|
// get total workshop count
|
|
const totalWorkshopCount = await this.prisma.workshop.count()
|
|
// get total order count
|
|
const totalOrderCount = await this.prisma.order.count()
|
|
// get total service count
|
|
const totalServiceCount = await this.prisma.service.count()
|
|
// get revenue
|
|
let revenue = 0
|
|
// query all orders of services in all centers in the past args.timeframes and calculate actual revenue of each order by convert commission percentage to float
|
|
// convert args.timeframes to number of days
|
|
const timeframes = DateTimeUtils.subtractDaysFromTimeframe(args.timeframes)
|
|
const orders = await this.prisma.order.findMany({
|
|
where: {
|
|
status: OrderStatus.PAID,
|
|
createdAt: {
|
|
gte: timeframes.toJSDate(),
|
|
},
|
|
},
|
|
})
|
|
for (const order of orders) {
|
|
const service = await this.prisma.service.findUnique({
|
|
where: { id: order.serviceId },
|
|
})
|
|
if (!service) {
|
|
continue
|
|
}
|
|
const commission = service.commission
|
|
const actualRevenue = (order.total || 0) - (order.total || 0) * commission
|
|
revenue += actualRevenue
|
|
}
|
|
// return analytic
|
|
return {
|
|
topServices: topServices,
|
|
topCenters: topCenters,
|
|
pendingRefunds: pendingRefunds,
|
|
activeCenterCount: activeCenterCount,
|
|
totalCenterCount: totalCenterCount,
|
|
totalUserCount: totalUserCount,
|
|
activeMentorCount: activeMentorCount,
|
|
totalMentorCount: totalMentorCount,
|
|
revenue: revenue,
|
|
approvedServiceCount: approvedServiceCount,
|
|
rejectedServiceCount: rejectedServiceCount,
|
|
totalWorkshopCount: totalWorkshopCount,
|
|
totalOrderCount: totalOrderCount,
|
|
totalServiceCount: totalServiceCount,
|
|
updatedAt: DateTimeUtils.now(),
|
|
}
|
|
},
|
|
}),
|
|
}))
|
|
}
|
|
}
|