mirror of
https://github.com/documenso/documenso.git
synced 2025-11-19 19:21:39 +10:00
333 lines
10 KiB
TypeScript
333 lines
10 KiB
TypeScript
import type { DocumentStatus } from '@prisma/client';
|
|
import { EnvelopeType } from '@prisma/client';
|
|
|
|
import type { DateRange } from '@documenso/lib/types/search-params';
|
|
import { kyselyPrisma, sql } from '@documenso/prisma';
|
|
|
|
export type OrganisationSummary = {
|
|
totalTeams: number;
|
|
totalMembers: number;
|
|
totalDocuments: number;
|
|
activeDocuments: number;
|
|
completedDocuments: number;
|
|
volumeThisPeriod: number;
|
|
volumeAllTime: number;
|
|
};
|
|
|
|
export type OrganisationDetailedInsights = {
|
|
teams: TeamInsights[];
|
|
users: UserInsights[];
|
|
documents: DocumentInsights[];
|
|
totalPages: number;
|
|
summary?: OrganisationSummary;
|
|
};
|
|
|
|
export type TeamInsights = {
|
|
id: number;
|
|
name: string;
|
|
memberCount: number;
|
|
documentCount: number;
|
|
createdAt: Date;
|
|
};
|
|
|
|
export type UserInsights = {
|
|
id: number;
|
|
name: string;
|
|
email: string;
|
|
documentCount: number;
|
|
signedDocumentCount: number;
|
|
createdAt: Date;
|
|
};
|
|
|
|
export type DocumentInsights = {
|
|
id: string;
|
|
title: string;
|
|
status: DocumentStatus;
|
|
teamName: string;
|
|
createdAt: Date;
|
|
completedAt: Date | null;
|
|
};
|
|
|
|
export type GetOrganisationDetailedInsightsOptions = {
|
|
organisationId: string;
|
|
page?: number;
|
|
perPage?: number;
|
|
dateRange?: DateRange;
|
|
view: 'teams' | 'users' | 'documents';
|
|
};
|
|
|
|
export async function getOrganisationDetailedInsights({
|
|
organisationId,
|
|
page = 1,
|
|
perPage = 10,
|
|
dateRange = 'last30days',
|
|
view,
|
|
}: GetOrganisationDetailedInsightsOptions): Promise<OrganisationDetailedInsights> {
|
|
const offset = Math.max(page - 1, 0) * perPage;
|
|
|
|
const now = new Date();
|
|
let createdAtFrom: Date | null = null;
|
|
|
|
switch (dateRange) {
|
|
case 'last30days': {
|
|
createdAtFrom = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
|
|
break;
|
|
}
|
|
case 'last90days': {
|
|
createdAtFrom = new Date(now.getTime() - 90 * 24 * 60 * 60 * 1000);
|
|
break;
|
|
}
|
|
case 'lastYear': {
|
|
createdAtFrom = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
|
|
break;
|
|
}
|
|
case 'allTime':
|
|
default:
|
|
createdAtFrom = null;
|
|
break;
|
|
}
|
|
|
|
const summaryData = await getOrganisationSummary(organisationId, createdAtFrom);
|
|
|
|
const viewData = await (async () => {
|
|
switch (view) {
|
|
case 'teams':
|
|
return await getTeamInsights(organisationId, offset, perPage, createdAtFrom);
|
|
case 'users':
|
|
return await getUserInsights(organisationId, offset, perPage, createdAtFrom);
|
|
case 'documents':
|
|
return await getDocumentInsights(organisationId, offset, perPage, createdAtFrom);
|
|
default:
|
|
throw new Error(`Invalid view: ${view}`);
|
|
}
|
|
})();
|
|
|
|
return {
|
|
...viewData,
|
|
summary: summaryData,
|
|
};
|
|
}
|
|
|
|
async function getTeamInsights(
|
|
organisationId: string,
|
|
offset: number,
|
|
perPage: number,
|
|
createdAtFrom: Date | null,
|
|
): Promise<OrganisationDetailedInsights> {
|
|
const teamsQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Team as t')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.select((eb) => [
|
|
't.id',
|
|
't.name',
|
|
't.createdAt',
|
|
eb
|
|
.selectFrom('TeamGroup as tg')
|
|
.innerJoin('OrganisationGroup as og', 'og.id', 'tg.organisationGroupId')
|
|
.innerJoin('OrganisationGroupMember as ogm', 'ogm.groupId', 'og.id')
|
|
.innerJoin('OrganisationMember as om', 'om.id', 'ogm.organisationMemberId')
|
|
.whereRef('tg.teamId', '=', 't.id')
|
|
.select(sql<number>`count(distinct om."userId")`.as('count'))
|
|
.as('memberCount'),
|
|
eb
|
|
.selectFrom('Envelope as e')
|
|
.whereRef('e.teamId', '=', 't.id')
|
|
.where('e.deletedAt', 'is', null)
|
|
.where('e.type', '=', sql.lit(EnvelopeType.DOCUMENT))
|
|
.$if(!!createdAtFrom, (qb) => qb.where('e.createdAt', '>=', createdAtFrom!))
|
|
.select(sql<number>`count(e.id)`.as('count'))
|
|
.as('documentCount'),
|
|
])
|
|
.orderBy('documentCount', 'desc')
|
|
.limit(perPage)
|
|
.offset(offset);
|
|
|
|
const countQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Team as t')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.select(({ fn }) => [fn.countAll().as('count')]);
|
|
|
|
const [teams, countResult] = await Promise.all([teamsQuery.execute(), countQuery.execute()]);
|
|
const count = Number(countResult[0]?.count || 0);
|
|
|
|
return {
|
|
teams: teams as TeamInsights[],
|
|
users: [],
|
|
documents: [],
|
|
totalPages: Math.ceil(Number(count) / perPage),
|
|
};
|
|
}
|
|
|
|
async function getUserInsights(
|
|
organisationId: string,
|
|
offset: number,
|
|
perPage: number,
|
|
createdAtFrom: Date | null,
|
|
): Promise<OrganisationDetailedInsights> {
|
|
const usersQuery = kyselyPrisma.$kysely
|
|
.selectFrom('OrganisationMember as om')
|
|
.innerJoin('User as u', 'u.id', 'om.userId')
|
|
.where('om.organisationId', '=', organisationId)
|
|
.select((eb) => [
|
|
'u.id',
|
|
'u.name',
|
|
'u.email',
|
|
'u.createdAt',
|
|
eb
|
|
.selectFrom('Envelope as e')
|
|
.innerJoin('Team as t', 't.id', 'e.teamId')
|
|
.whereRef('e.userId', '=', 'u.id')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.where('e.deletedAt', 'is', null)
|
|
.where('e.type', '=', sql.lit(EnvelopeType.DOCUMENT))
|
|
.$if(!!createdAtFrom, (qb) => qb.where('e.createdAt', '>=', createdAtFrom!))
|
|
.select(sql<number>`count(e.id)`.as('count'))
|
|
.as('documentCount'),
|
|
eb
|
|
.selectFrom('Recipient as r')
|
|
.innerJoin('Envelope as e', 'e.id', 'r.envelopeId')
|
|
.innerJoin('Team as t', 't.id', 'e.teamId')
|
|
.whereRef('r.email', '=', 'u.email')
|
|
.where('r.signedAt', 'is not', null)
|
|
.where('t.organisationId', '=', organisationId)
|
|
.where('e.deletedAt', 'is', null)
|
|
.where('e.type', '=', sql.lit(EnvelopeType.DOCUMENT))
|
|
.$if(!!createdAtFrom, (qb) => qb.where('e.createdAt', '>=', createdAtFrom!))
|
|
.select(sql<number>`count(e.id)`.as('count'))
|
|
.as('signedDocumentCount'),
|
|
])
|
|
.orderBy('u.createdAt', 'desc')
|
|
.limit(perPage)
|
|
.offset(offset);
|
|
|
|
const countQuery = kyselyPrisma.$kysely
|
|
.selectFrom('OrganisationMember as om')
|
|
.innerJoin('User as u', 'u.id', 'om.userId')
|
|
.where('om.organisationId', '=', organisationId)
|
|
.select(({ fn }) => [fn.countAll().as('count')]);
|
|
|
|
const [users, countResult] = await Promise.all([usersQuery.execute(), countQuery.execute()]);
|
|
const count = Number(countResult[0]?.count || 0);
|
|
|
|
return {
|
|
teams: [],
|
|
users: users as UserInsights[],
|
|
documents: [],
|
|
totalPages: Math.ceil(Number(count) / perPage),
|
|
};
|
|
}
|
|
|
|
async function getDocumentInsights(
|
|
organisationId: string,
|
|
offset: number,
|
|
perPage: number,
|
|
createdAtFrom: Date | null,
|
|
): Promise<OrganisationDetailedInsights> {
|
|
let documentsQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Envelope as e')
|
|
.innerJoin('Team as t', 'e.teamId', 't.id')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.where('e.deletedAt', 'is', null)
|
|
.where(() => sql`e.type = ${EnvelopeType.DOCUMENT}::"EnvelopeType"`);
|
|
|
|
if (createdAtFrom) {
|
|
documentsQuery = documentsQuery.where('e.createdAt', '>=', createdAtFrom);
|
|
}
|
|
|
|
documentsQuery = documentsQuery
|
|
.select([
|
|
'e.id as id',
|
|
'e.title as title',
|
|
'e.status as status',
|
|
'e.createdAt as createdAt',
|
|
'e.completedAt as completedAt',
|
|
't.name as teamName',
|
|
])
|
|
.orderBy('e.createdAt', 'desc')
|
|
.limit(perPage)
|
|
.offset(offset);
|
|
|
|
let countQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Envelope as e')
|
|
.innerJoin('Team as t', 'e.teamId', 't.id')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.where('e.deletedAt', 'is', null)
|
|
.where(() => sql`e.type = ${EnvelopeType.DOCUMENT}::"EnvelopeType"`);
|
|
|
|
if (createdAtFrom) {
|
|
countQuery = countQuery.where('e.createdAt', '>=', createdAtFrom);
|
|
}
|
|
|
|
countQuery = countQuery.select(({ fn }) => [fn.countAll().as('count')]);
|
|
|
|
const [documents, countResult] = await Promise.all([
|
|
documentsQuery.execute(),
|
|
countQuery.execute(),
|
|
]);
|
|
|
|
const count = Number((countResult[0] as { count: number })?.count || 0);
|
|
|
|
return {
|
|
teams: [],
|
|
users: [],
|
|
documents: documents.map((doc) => ({
|
|
...doc,
|
|
id: String((doc as { id: number }).id),
|
|
})) as DocumentInsights[],
|
|
totalPages: Math.ceil(Number(count) / perPage),
|
|
};
|
|
}
|
|
|
|
async function getOrganisationSummary(
|
|
organisationId: string,
|
|
createdAtFrom: Date | null,
|
|
): Promise<OrganisationSummary> {
|
|
const teamCountQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Team')
|
|
.where('organisationId', '=', organisationId)
|
|
.select(sql<number>`count(id)`.as('count'))
|
|
.executeTakeFirst();
|
|
|
|
const memberCountQuery = kyselyPrisma.$kysely
|
|
.selectFrom('OrganisationMember')
|
|
.where('organisationId', '=', organisationId)
|
|
.select(sql<number>`count(id)`.as('count'))
|
|
.executeTakeFirst();
|
|
|
|
const envelopeStatsQuery = kyselyPrisma.$kysely
|
|
.selectFrom('Envelope as e')
|
|
.innerJoin('Team as t', 't.id', 'e.teamId')
|
|
.where('t.organisationId', '=', organisationId)
|
|
.where('e.deletedAt', 'is', null)
|
|
.where('e.type', '=', sql.lit(EnvelopeType.DOCUMENT))
|
|
.select([
|
|
sql<number>`count(e.id)`.as('totalDocuments'),
|
|
sql<number>`count(case when e.status in ('DRAFT', 'PENDING') then 1 end)`.as(
|
|
'activeDocuments',
|
|
),
|
|
sql<number>`count(case when e.status = 'COMPLETED' then 1 end)`.as('completedDocuments'),
|
|
sql<number>`count(case when e.status = 'COMPLETED' then 1 end)`.as('volumeAllTime'),
|
|
(createdAtFrom
|
|
? sql<number>`count(case when e.status = 'COMPLETED' and e."createdAt" >= ${createdAtFrom} then 1 end)`
|
|
: sql<number>`count(case when e.status = 'COMPLETED' then 1 end)`
|
|
).as('volumeThisPeriod'),
|
|
])
|
|
.executeTakeFirst();
|
|
|
|
const [teamCount, memberCount, envelopeStats] = await Promise.all([
|
|
teamCountQuery,
|
|
memberCountQuery,
|
|
envelopeStatsQuery,
|
|
]);
|
|
|
|
return {
|
|
totalTeams: Number(teamCount?.count || 0),
|
|
totalMembers: Number(memberCount?.count || 0),
|
|
totalDocuments: Number(envelopeStats?.totalDocuments || 0),
|
|
activeDocuments: Number(envelopeStats?.activeDocuments || 0),
|
|
completedDocuments: Number(envelopeStats?.completedDocuments || 0),
|
|
volumeThisPeriod: Number(envelopeStats?.volumeThisPeriod || 0),
|
|
volumeAllTime: Number(envelopeStats?.volumeAllTime || 0),
|
|
};
|
|
}
|