horacio/turnosxpress
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implement rating summary service methods and integrate rating display components into the organization header and pending ratings page

Browse Source
This commit is contained in:
Horacio Daniel Ros
2026-07-22 12:13:50 -03:00
parent 383a5bc6b4
commit da3c3abb52
27 changed files with 1334 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/src/Models/Ratings/Ratings.Adapter.Mongoose.ts
+115 -1
View File
@@ -1,10 +1,33 @@
import { Document, Model, Schema, Types, model, models } from "mongoose";
import { FindRatingsParams, IRating, IRatingsAdapter, RATING_COMMENT_MAX_LENGTH, RatingTargetType } from "./Ratings.Interface";
import getAvatar from "../../helpers/getAvatar";
import { joinStrings } from "../../helpers/String";
import {
FindRatingsParams,
IRating,
IRatingsAdapter,
RATING_COMMENT_MAX_LENGTH,
RatingTargetSummaryParams,
RatingTargetSummaryResult,
RatingTargetReviewItem,
RatingTargetReviewsParams,
RatingTargetType,
} from "./Ratings.Interface";
export interface IRatingDocument extends Omit<IRating, "id">, Document {
_id: Types.ObjectId;
}
type RatingReviewDocument = IRatingDocument & {
userId?: {
_id: Types.ObjectId;
firstName?: string;
lastName?: string;
avatar?: string;
};
};
const GENERIC_REVIEW_AUTHOR = "Cliente verificado";
export class RatingsAdapterMongoose implements IRatingsAdapter {
schema: Schema;
ratingsList: Model<IRatingDocument>;
@@ -44,6 +67,97 @@ export class RatingsAdapterMongoose implements IRatingsAdapter {
return rating ? this.mapRating(rating) : null;
}
public async count(filters: FindRatingsParams): Promise<number> {
return this.ratingsList.countDocuments(filters).exec();
}
public async summaryByTarget(filters: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult> {
const [summary] = await this.ratingsList
.aggregate<{ averageScore: number; totalCount: number }>([
{
$match: {
targetType: filters.targetType,
targetId: new Types.ObjectId(filters.targetId),
},
},
{
$group: {
_id: null,
averageScore: { $avg: "$score" },
totalCount: { $sum: 1 },
},
},
])
.exec();
return {
averageScore: summary?.averageScore || 0,
totalCount: summary?.totalCount || 0,
};
}
public async summaryByTargets(filters: { targetType: RatingTargetType; targetIds: string[] }): Promise<RatingTargetSummaryResult> {
const targetIds = filters.targetIds.filter((targetId) => Types.ObjectId.isValid(targetId));
if (targetIds.length === 0) {
return { averageScore: 0, totalCount: 0 };
}
const [summary] = await this.ratingsList
.aggregate<{ averageScore: number; totalCount: number }>([
{
$match: {
targetType: filters.targetType,
targetId: { $in: targetIds.map((targetId) => new Types.ObjectId(targetId)) },
},
},
{
$group: {
_id: null,
averageScore: { $avg: "$score" },
totalCount: { $sum: 1 },
},
},
])
.exec();
return {
averageScore: summary?.averageScore || 0,
totalCount: summary?.totalCount || 0,
};
}
public async reviewsByTarget(filters: RatingTargetReviewsParams): Promise<RatingTargetReviewItem[]> {
const ratings = await this.ratingsList
.find({
targetType: filters.targetType,
targetId: new Types.ObjectId(filters.targetId),
comment: { $regex: /\S/ },
})
.sort({ createdAt: -1 })
.limit(filters.limit || 20)
.select("score comment createdAt userId")
.populate("userId", "firstName lastName avatar")
.exec();
return (ratings as unknown as RatingReviewDocument[]).map((rating) => {
const user = rating.userId;
const displayName = user ? joinStrings([user.firstName, user.lastName], " ") : "";
const authorName = displayName || GENERIC_REVIEW_AUTHOR;
return {
id: rating._id.toString(),
score: rating.score,
comment: rating.comment || "",
createdAt: rating.createdAt,
author: {
displayName: authorName,
avatarUrl: user ? getAvatar(user._id.toString(), user.avatar, "") : "",
},
};
});
}
private mapRating(rating: IRatingDocument): IRating {
return {
id: rating._id.toString(),
server/src/Models/Ratings/Ratings.Interface.ts
+45
View File
@@ -30,6 +30,43 @@ export type PendingRatingsByUserParams = {
sessionUser: string;
};
export type CountRatingsByUserParams = {
sessionUser: string;
};
export type CountRatingsByUserResult = {
count: number;
};
export type ProfessionalRatingSummaryByUserParams = {
sessionUser: string;
};
export type RatingTargetSummaryParams = {
targetType: RatingTargetType;
targetId: string;
};
export type RatingTargetSummaryResult = {
averageScore: number;
totalCount: number;
};
export type RatingTargetReviewsParams = RatingTargetSummaryParams & {
limit?: number;
};
export type RatingTargetReviewItem = {
id: string;
score: number;
comment: string;
createdAt: Date;
author: {
displayName: string;
avatarUrl: string;
};
};
export interface IRating {
id?: string;
appointmentId: string;
@@ -61,10 +98,18 @@ export interface IRatingsAdapter {
create(data: Omit<IRating, "id" | "createdAt" | "updatedAt">): Promise<IRating>;
find(filters: FindRatingsParams): Promise<IRating[]>;
findOne(filters: FindRatingsParams): Promise<IRating | null>;
count(filters: FindRatingsParams): Promise<number>;
summaryByTarget(filters: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult>;
summaryByTargets(filters: { targetType: RatingTargetType; targetIds: string[] }): Promise<RatingTargetSummaryResult>;
reviewsByTarget(filters: RatingTargetReviewsParams): Promise<RatingTargetReviewItem[]>;
}
export interface IRatingsManager {
ratings: IRatingsAdapter;
createRating(data: CreateRatingParams): Promise<IRating>;
pendingByUser(data: PendingRatingsByUserParams): Promise<PendingRatingItem[]>;
countByUser(data: CountRatingsByUserParams): Promise<CountRatingsByUserResult>;
professionalSummaryByUser(data: ProfessionalRatingSummaryByUserParams): Promise<RatingTargetSummaryResult>;
summaryByTarget(data: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult>;
reviewsByTarget(data: RatingTargetReviewsParams): Promise<RatingTargetReviewItem[]>;
}
server/src/Models/Ratings/Ratings.ts
+54
View File
@@ -9,16 +9,24 @@ import ServicesManager from "../Services/Service";
import UsersManager from "../Users/Users";
import { RatingsAdapterMongoose } from "./Ratings.Adapter.Mongoose";
import {
CountRatingsByUserParams,
CountRatingsByUserResult,
CreateRatingParams,
IRating,
IRatingsManager,
PendingRatingItem,
PendingRatingsByUserParams,
ProfessionalRatingSummaryByUserParams,
RATING_COMMENT_MAX_LENGTH,
RatingTargetSummaryParams,
RatingTargetSummaryResult,
RatingTargetReviewItem,
RatingTargetReviewsParams,
RatingTargetType,
} from "./Ratings.Interface";
const PENDING_RATINGS_APPOINTMENT_LIMIT = 50;
const TARGET_REVIEWS_LIMIT = 20;
class RatingsManager implements IRatingsManager {
ratings: RatingsAdapterMongoose;
@@ -180,6 +188,52 @@ class RatingsManager implements IRatingsManager {
return pendingItems;
}
public async countByUser(data: CountRatingsByUserParams): Promise<CountRatingsByUserResult> {
await this.validateSessionUser(data.sessionUser);
return {
count: await this.ratings.count({ userId: data.sessionUser }),
};
}
public async professionalSummaryByUser(data: ProfessionalRatingSummaryByUserParams): Promise<RatingTargetSummaryResult> {
await this.validateSessionUser(data.sessionUser);
const employees = await EmployeesList.employees.find({
userId: data.sessionUser,
removed: { $ne: true },
} as any);
const employeeIds = employees.map((employee) => String(employee.id));
return this.ratings.summaryByTargets({
targetType: RatingTargetType.EMPLOYEE,
targetIds: employeeIds,
});
}
public async summaryByTarget(data: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult> {
this.validateTargetType(data.targetType);
if (!Types.ObjectId.isValid(data.targetId)) {
throw new Error("No se ha proporcionado un objetivo válido.");
}
return this.ratings.summaryByTarget(data);
}
public async reviewsByTarget(data: RatingTargetReviewsParams): Promise<RatingTargetReviewItem[]> {
this.validateTargetType(data.targetType);
if (!Types.ObjectId.isValid(data.targetId)) {
throw new Error("No se ha proporcionado un objetivo válido.");
}
return this.ratings.reviewsByTarget({
...data,
limit: Math.min(Math.max(data.limit || TARGET_REVIEWS_LIMIT, 1), TARGET_REVIEWS_LIMIT),
});
}
private async validateSessionUser(sessionUser: string): Promise<void> {
const user = await UsersManager.users.findOne({ _id: sessionUser });
server/src/api/Ratings/Ratings.Controller.ts
+96 -3
View File
@@ -1,13 +1,24 @@
import { Body, Controller, Middlewares, Post, Response, Route, SuccessResponse } from "tsoa";
import { ApiVoidResult } from "../../Models/Api.VoidResult.type";
import { CreateRatingParams, PendingRatingItem, PendingRatingsByUserParams } from "../../Models/Ratings/Ratings.Interface";
import {
CountRatingsByUserParams,
CountRatingsByUserResult,
CreateRatingParams,
PendingRatingItem,
PendingRatingsByUserParams,
ProfessionalRatingSummaryByUserParams,
RatingTargetReviewItem,
RatingTargetReviewsParams,
RatingTargetSummaryParams,
RatingTargetSummaryResult,
} from "../../Models/Ratings/Ratings.Interface";
import { ApiValidationError } from "../../Models/Server.Error.model";
import { authenticateMiddleware } from "../../middleware/authentication";
import { rateLimiter } from "../../middleware/ratelimiter";
import { ratingRateLimiter } from "../../middleware/ratelimiter";
import { RatingsService } from "./Ratings.Service";
@Route("ratings/create")
@Middlewares([rateLimiter, authenticateMiddleware])
@Middlewares([ratingRateLimiter, authenticateMiddleware])
export class CreateRatingController extends Controller {
@Response<ApiValidationError>(500, "Ha ocurrido un error")
@SuccessResponse(200, "Calificación creada con éxito")
@@ -45,3 +56,85 @@ export class PendingRatingsByUserController extends Controller {
}
}
}
@Route("ratings/count-by-user")
@Middlewares([authenticateMiddleware])
export class CountRatingsByUserController extends Controller {
@Response<ApiValidationError>(500, "Ha ocurrido un error")
@SuccessResponse(200, "Busqueda completada con exito")
@Post()
public async countByUser(
@Body() requestBody: CountRatingsByUserParams
): Promise<CountRatingsByUserResult | ApiValidationError> {
try {
const ratingsCount = await new RatingsService().countByUser(requestBody);
this.setStatus(200);
return ratingsCount;
} catch (e) {
const errorOccurred: Error = e as Error;
this.setStatus(500);
return new ApiValidationError(500, errorOccurred.message);
}
}
}
@Route("ratings/professional-summary-by-user")
@Middlewares([authenticateMiddleware])
export class ProfessionalRatingSummaryByUserController extends Controller {
@Response<ApiValidationError>(500, "Ha ocurrido un error")
@SuccessResponse(200, "Busqueda completada con exito")
@Post()
public async professionalSummaryByUser(
@Body() requestBody: ProfessionalRatingSummaryByUserParams
): Promise<RatingTargetSummaryResult | ApiValidationError> {
try {
const ratingSummary = await new RatingsService().professionalSummaryByUser(requestBody);
this.setStatus(200);
return ratingSummary;
} catch (e) {
const errorOccurred: Error = e as Error;
this.setStatus(500);
return new ApiValidationError(500, errorOccurred.message);
}
}
}
@Route("ratings/target-summary")
export class RatingTargetSummaryController extends Controller {
@Response<ApiValidationError>(500, "Ha ocurrido un error")
@SuccessResponse(200, "Busqueda completada con exito")
@Post()
public async summaryByTarget(
@Body() requestBody: RatingTargetSummaryParams
): Promise<RatingTargetSummaryResult | ApiValidationError> {
try {
const ratingSummary = await new RatingsService().summaryByTarget(requestBody);
this.setStatus(200);
return ratingSummary;
} catch (e) {
const errorOccurred: Error = e as Error;
this.setStatus(500);
return new ApiValidationError(500, errorOccurred.message);
}
}
}
@Route("ratings/target-reviews")
export class RatingTargetReviewsController extends Controller {
@Response<ApiValidationError>(500, "Ha ocurrido un error")
@SuccessResponse(200, "Busqueda completada con exito")
@Post()
public async reviewsByTarget(
@Body() requestBody: RatingTargetReviewsParams
): Promise<RatingTargetReviewItem[] | ApiValidationError> {
try {
const ratingReviews = await new RatingsService().reviewsByTarget(requestBody);
this.setStatus(200);
return ratingReviews;
} catch (e) {
const errorOccurred: Error = e as Error;
this.setStatus(500);
return new ApiValidationError(500, errorOccurred.message);
}
}
}
server/src/api/Ratings/Ratings.Service.ts
+33 -1
View File
@@ -1,6 +1,18 @@
import { connect } from "mongoose";
import RatingsList from "../../Models/Ratings/Ratings";
import { CreateRatingParams, IRating, PendingRatingItem, PendingRatingsByUserParams } from "../../Models/Ratings/Ratings.Interface";
import {
CountRatingsByUserParams,
CountRatingsByUserResult,
CreateRatingParams,
IRating,
PendingRatingItem,
PendingRatingsByUserParams,
ProfessionalRatingSummaryByUserParams,
RatingTargetSummaryParams,
RatingTargetSummaryResult,
RatingTargetReviewItem,
RatingTargetReviewsParams,
} from "../../Models/Ratings/Ratings.Interface";
export class RatingsService {
public async createRating(data: CreateRatingParams): Promise<IRating> {
@@ -12,4 +24,24 @@ export class RatingsService {
await connect(`${process.env.DATABASE_CONNECTION}`);
return await RatingsList.pendingByUser(data);
}
public async countByUser(data: CountRatingsByUserParams): Promise<CountRatingsByUserResult> {
await connect(`${process.env.DATABASE_CONNECTION}`);
return await RatingsList.countByUser(data);
}
public async professionalSummaryByUser(data: ProfessionalRatingSummaryByUserParams): Promise<RatingTargetSummaryResult> {
await connect(`${process.env.DATABASE_CONNECTION}`);
return await RatingsList.professionalSummaryByUser(data);
}
public async summaryByTarget(data: RatingTargetSummaryParams): Promise<RatingTargetSummaryResult> {
await connect(`${process.env.DATABASE_CONNECTION}`);
return await RatingsList.summaryByTarget(data);
}
public async reviewsByTarget(data: RatingTargetReviewsParams): Promise<RatingTargetReviewItem[]> {
await connect(`${process.env.DATABASE_CONNECTION}`);
return await RatingsList.reviewsByTarget(data);
}
}
server/src/middleware/ratelimiter.ts
+34
View File
@@ -2,6 +2,10 @@ import { Request, Response, NextFunction } from "express";
import { ApiValidationError } from "../Models/Server.Error.model";
const ipLastRequest = new Map<string, number>();
const ratingIpRequests = new Map<string, number[]>();
const RATING_RATE_LIMIT_WINDOW_MS = 60000;
const RATING_RATE_LIMIT_MAX_REQUESTS = 20;
// Limpia las IPs cada hora
setInterval(() => {
@@ -10,6 +14,14 @@ setInterval(() => {
ipLastRequest.forEach((time, ip) => {
if (now - time > timeLimit) ipLastRequest.delete(ip);
});
ratingIpRequests.forEach((times, ip) => {
const recentTimes = times.filter((time) => now - time <= RATING_RATE_LIMIT_WINDOW_MS);
if (recentTimes.length === 0) {
ratingIpRequests.delete(ip);
return;
}
ratingIpRequests.set(ip, recentTimes);
});
}, 3600000);
export async function rateLimiter(
@@ -31,3 +43,25 @@ export async function rateLimiter(
ipLastRequest.set(ip, currentTime);
next();
}
export async function ratingRateLimiter(
request: Request,
response: Response,
next: NextFunction
): Promise<void | Response | ApiValidationError> {
const ip = request.ip;
const currentTime = Date.now();
const windowStart = currentTime - RATING_RATE_LIMIT_WINDOW_MS;
const recentRequests = (ratingIpRequests.get(ip) || []).filter((time) => time > windowStart);
if (recentRequests.length >= RATING_RATE_LIMIT_MAX_REQUESTS) {
response
.status(429)
.json(new ApiValidationError(429, "Demasiadas solicitudes. Por favor espere!"));
return;
}
recentRequests.push(currentTime);
ratingIpRequests.set(ip, recentRequests);
next();
}