1145 أسطر
38 KiB
TypeScript
1145 أسطر
38 KiB
TypeScript
import { BadRequestException, ForbiddenException, Injectable, Logger, NotFoundException } from '@nestjs/common';
|
|
import { extname } from 'path';
|
|
import { Types } from 'mongoose';
|
|
import { ModerationStatus } from '../../common/enums/moderation-status.enum';
|
|
import { PostType } from '../../common/enums/post-type.enum';
|
|
import { PostVisibility } from '../../common/enums/post-visibility.enum';
|
|
import { buildPaginatedResponse } from '../../common/utils/pagination.util';
|
|
import { resolveMongoSortDirection } from '../../common/utils/sort.util';
|
|
import {
|
|
generateWaveformPeaksFromBuffer,
|
|
generateWaveformPeaksFromSeed,
|
|
normalizeWaveformPeaks,
|
|
} from '../../common/utils/waveform.util';
|
|
import { FeedVersionService } from '../../infrastructure/cache/feed-version.service';
|
|
import { ManagedStorageService } from '../../infrastructure/storage/managed-storage.service';
|
|
import {
|
|
UploadedVideoFile,
|
|
VideoProcessingService,
|
|
} from '../../infrastructure/storage/video-processing.service';
|
|
import { NotificationsService } from '../notifications/notifications.service';
|
|
import { AuditService } from '../audit/audit.service';
|
|
import { UsersRepository } from '../users/users.repository';
|
|
import { AdminPostQueryDto } from './dto/admin-post-query.dto';
|
|
import { CreateReelDto } from './dto/create-reel.dto';
|
|
import { CreatePostDto } from './dto/create-post.dto';
|
|
import { PostQueryDto } from './dto/post-query.dto';
|
|
import { ReelQueryDto } from './dto/reel-query.dto';
|
|
import { UpdatePostDto } from './dto/update-post.dto';
|
|
import { PostDocument } from './schemas/post.schema';
|
|
import { PostsRepository } from './posts.repository';
|
|
|
|
type PostMediaMetadataInput = Pick<
|
|
CreatePostDto,
|
|
| 'durationSeconds'
|
|
| 'thumbnailUrl'
|
|
| 'style'
|
|
| 'maqam'
|
|
| 'rhythmSignature'
|
|
| 'waveformPeaks'
|
|
>;
|
|
|
|
type NormalizedPostMediaMetadata = {
|
|
durationSeconds: number | null;
|
|
thumbnailUrl: string;
|
|
style: string;
|
|
maqam: string;
|
|
rhythmSignature: string;
|
|
waveformPeaks: number[];
|
|
};
|
|
|
|
type SavedVideoUpload = {
|
|
videoUrl: string;
|
|
thumbnailUrl: string;
|
|
};
|
|
|
|
@Injectable()
|
|
export class PostsService {
|
|
private readonly logger = new Logger(PostsService.name);
|
|
|
|
constructor(
|
|
private readonly postsRepository: PostsRepository,
|
|
private readonly usersRepository: UsersRepository,
|
|
private readonly storageService: ManagedStorageService,
|
|
private readonly videoProcessingService: VideoProcessingService,
|
|
private readonly feedVersionService: FeedVersionService,
|
|
private readonly notificationsService: NotificationsService,
|
|
private readonly auditService: AuditService,
|
|
) {}
|
|
|
|
async create(
|
|
userId: string,
|
|
dto: CreatePostDto,
|
|
imageFiles: Array<{ mimetype?: string; size: number; buffer: Buffer; originalname?: string }> = [],
|
|
videoFile?: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
audioFile?: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
): Promise<PostDocument> {
|
|
const inputImageUrls = dto.imageUrls ?? [];
|
|
if (inputImageUrls.length > 10 || imageFiles.length > 10) {
|
|
throw new BadRequestException('Post can contain up to 10 images');
|
|
}
|
|
if (imageFiles.length && inputImageUrls.length) {
|
|
throw new BadRequestException('Provide either imageFiles or imageUrls, not both');
|
|
}
|
|
if (videoFile && audioFile) {
|
|
throw new BadRequestException('Post can contain either images, video, or audio');
|
|
}
|
|
if (videoFile && dto.videoUrl) {
|
|
throw new BadRequestException('Provide either videoFile or videoUrl, not both');
|
|
}
|
|
if (audioFile && dto.audioUrl) {
|
|
throw new BadRequestException('Provide either audioFile or audioUrl, not both');
|
|
}
|
|
if ((videoFile || dto.videoUrl) && (imageFiles.length || inputImageUrls.length)) {
|
|
throw new BadRequestException('Post can contain either images or video, not both');
|
|
}
|
|
if ((audioFile || dto.audioUrl) && (imageFiles.length || inputImageUrls.length)) {
|
|
throw new BadRequestException('Post can contain either images or audio, not both');
|
|
}
|
|
|
|
const uploadedImageUrls = await this.saveImageFiles(imageFiles);
|
|
const savedVideoUpload = videoFile ? await this.saveVideoUpload(videoFile) : null;
|
|
const uploadedVideoUrl = savedVideoUpload?.videoUrl ?? '';
|
|
const uploadedThumbnailUrl = savedVideoUpload?.thumbnailUrl ?? '';
|
|
const uploadedAudioUrl = audioFile ? await this.saveMediaFile('audio', audioFile) : '';
|
|
const finalImageUrls = uploadedImageUrls.length ? uploadedImageUrls : inputImageUrls;
|
|
const finalVideoUrl = uploadedVideoUrl || dto.videoUrl || '';
|
|
const finalAudioUrl = uploadedAudioUrl || dto.audioUrl || '';
|
|
const finalContent = dto.content?.trim() ?? '';
|
|
const taggedUserIds = await this.normalizeTaggedUserIds(dto.taggedUserIds, userId);
|
|
const mentionResolution = await this.resolveMentionTargets(dto.mentionUsernames, finalContent, userId);
|
|
const { location, latitude, longitude } = this.normalizeLocation(dto);
|
|
if (!finalContent && !finalImageUrls.length && !finalVideoUrl && !finalAudioUrl) {
|
|
throw new BadRequestException('Post must contain caption or media');
|
|
}
|
|
|
|
const postType = this.resolvePostType(finalImageUrls, finalVideoUrl, finalAudioUrl);
|
|
const hashtags = this.extractHashtags(finalContent);
|
|
const mediaMetadata = this.normalizeMediaMetadata(dto, postType, undefined, {
|
|
audioSourceBuffer: audioFile?.buffer,
|
|
waveformSeed: finalAudioUrl || finalContent || `${userId}:${Date.now()}`,
|
|
thumbnailUrl: uploadedThumbnailUrl,
|
|
});
|
|
|
|
let post: PostDocument;
|
|
try {
|
|
post = await this.postsRepository.create(userId, {
|
|
content: finalContent,
|
|
imageUrls: finalImageUrls,
|
|
videoUrl: finalVideoUrl,
|
|
audioUrl: finalAudioUrl,
|
|
taggedUserIds,
|
|
mentionUsernames: mentionResolution.mentionUsernames,
|
|
location,
|
|
latitude,
|
|
longitude,
|
|
postType,
|
|
visibility: dto.visibility ?? PostVisibility.PUBLIC,
|
|
hashtags,
|
|
...mediaMetadata,
|
|
});
|
|
} catch (error) {
|
|
await Promise.all([
|
|
...uploadedImageUrls.map((url) => this.deleteManagedPostMedia(url)),
|
|
uploadedVideoUrl ? this.deleteManagedPostMedia(uploadedVideoUrl) : Promise.resolve(),
|
|
uploadedThumbnailUrl ? this.deleteManagedPostMedia(uploadedThumbnailUrl) : Promise.resolve(),
|
|
uploadedAudioUrl ? this.deleteManagedPostMedia(uploadedAudioUrl) : Promise.resolve(),
|
|
]);
|
|
throw error;
|
|
}
|
|
|
|
await this.usersRepository.incrementPostsCount(userId, 1);
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
await this.notifyMentionedUsers(userId, post.id, mentionResolution.mentionedUsers, finalContent);
|
|
return post;
|
|
}
|
|
|
|
async update(
|
|
userId: string,
|
|
postId: string,
|
|
dto: UpdatePostDto,
|
|
imageFiles: Array<{ mimetype?: string; size: number; buffer: Buffer; originalname?: string }> = [],
|
|
videoFile?: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
audioFile?: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
): Promise<PostDocument> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
if (this.extractEntityId(post.authorId) !== userId) {
|
|
throw new ForbiddenException('You can only update your own posts');
|
|
}
|
|
|
|
const inputImageUrls = dto.imageUrls ?? [];
|
|
if (inputImageUrls.length > 10 || imageFiles.length > 10) {
|
|
throw new BadRequestException('Post can contain up to 10 images');
|
|
}
|
|
if (imageFiles.length && inputImageUrls.length) {
|
|
throw new BadRequestException('Provide either imageFiles or imageUrls, not both');
|
|
}
|
|
|
|
if (videoFile && audioFile) {
|
|
throw new BadRequestException('Post can contain either images, video, or audio');
|
|
}
|
|
if (videoFile && dto.videoUrl) {
|
|
throw new BadRequestException('Provide either videoFile or videoUrl, not both');
|
|
}
|
|
if (audioFile && dto.audioUrl) {
|
|
throw new BadRequestException('Provide either audioFile or audioUrl, not both');
|
|
}
|
|
if ((videoFile || dto.videoUrl) && (imageFiles.length || inputImageUrls.length)) {
|
|
throw new BadRequestException('Post can contain either images or video, not both');
|
|
}
|
|
if ((audioFile || dto.audioUrl) && (imageFiles.length || inputImageUrls.length)) {
|
|
throw new BadRequestException('Post can contain either images or audio, not both');
|
|
}
|
|
|
|
const uploadedImageUrls = await this.saveImageFiles(imageFiles);
|
|
const savedVideoUpload = videoFile ? await this.saveVideoUpload(videoFile) : null;
|
|
const uploadedVideoUrl = savedVideoUpload?.videoUrl ?? '';
|
|
const uploadedThumbnailUrl = savedVideoUpload?.thumbnailUrl ?? '';
|
|
const uploadedAudioUrl = audioFile ? await this.saveMediaFile('audio', audioFile) : '';
|
|
const hasImageUpdate = typeof dto.imageUrls !== 'undefined' || imageFiles.length > 0;
|
|
|
|
const hasVideoUpdate = typeof dto.videoUrl !== 'undefined' || !!videoFile;
|
|
const hasAudioUpdate = typeof dto.audioUrl !== 'undefined' || !!audioFile;
|
|
const nextImageUrls = hasImageUpdate
|
|
? imageFiles.length
|
|
? uploadedImageUrls
|
|
: inputImageUrls
|
|
: post.imageUrls ?? [];
|
|
|
|
const nextVideoUrl = hasVideoUpdate
|
|
? videoFile
|
|
? uploadedVideoUrl
|
|
: dto.videoUrl ?? ''
|
|
: post.videoUrl ?? '';
|
|
const nextAudioUrl = hasAudioUpdate
|
|
? audioFile
|
|
? uploadedAudioUrl
|
|
: dto.audioUrl ?? ''
|
|
: post.audioUrl ?? '';
|
|
const nextPostType = this.resolvePostType(nextImageUrls, nextVideoUrl, nextAudioUrl);
|
|
const nextContent = typeof dto.content === 'string' ? dto.content.trim() : post.content ?? '';
|
|
const nextTaggedUserIds =
|
|
typeof dto.taggedUserIds !== 'undefined'
|
|
? await this.normalizeTaggedUserIds(dto.taggedUserIds, userId)
|
|
: (post.taggedUserIds ?? []).map((id: Types.ObjectId | string) => new Types.ObjectId(id.toString()));
|
|
const previousMentionUsernames = this.normalizeMentionUsernames(post.mentionUsernames ?? []);
|
|
const shouldRecomputeMentions =
|
|
typeof dto.content === 'string' || typeof dto.mentionUsernames !== 'undefined';
|
|
const mentionResolution = shouldRecomputeMentions
|
|
? await this.resolveMentionTargets(dto.mentionUsernames, nextContent, userId)
|
|
: {
|
|
mentionUsernames: previousMentionUsernames,
|
|
mentionedUsers: [] as Array<{ id: string; username: string }>,
|
|
};
|
|
const { location: nextLocation, latitude: nextLatitude, longitude: nextLongitude } =
|
|
this.normalizeLocation(dto, {
|
|
location: post.location ?? '',
|
|
latitude: post.latitude ?? null,
|
|
longitude: post.longitude ?? null,
|
|
});
|
|
if (!nextContent && !nextImageUrls.length && !nextVideoUrl && !nextAudioUrl) {
|
|
throw new BadRequestException('Post must contain caption or media');
|
|
}
|
|
const mediaMetadata = this.normalizeMediaMetadata(
|
|
dto,
|
|
nextPostType,
|
|
{
|
|
durationSeconds: post.durationSeconds ?? null,
|
|
thumbnailUrl: uploadedThumbnailUrl || (post.thumbnailUrl ?? ''),
|
|
style: post.style ?? '',
|
|
maqam: post.maqam ?? '',
|
|
rhythmSignature: post.rhythmSignature ?? '',
|
|
waveformPeaks: post.waveformPeaks ?? [],
|
|
},
|
|
{
|
|
audioSourceBuffer: audioFile?.buffer,
|
|
waveformSeed: nextAudioUrl || nextContent || post.id,
|
|
thumbnailUrl: uploadedThumbnailUrl,
|
|
},
|
|
);
|
|
|
|
const payload: Record<string, unknown> = {
|
|
...dto,
|
|
content: nextContent,
|
|
imageUrls: nextImageUrls,
|
|
taggedUserIds: nextTaggedUserIds,
|
|
mentionUsernames: mentionResolution.mentionUsernames,
|
|
location: nextLocation,
|
|
latitude: nextLatitude,
|
|
longitude: nextLongitude,
|
|
postType: nextPostType,
|
|
...mediaMetadata,
|
|
};
|
|
|
|
if (typeof dto.content === 'string') {
|
|
payload.hashtags = this.extractHashtags(nextContent);
|
|
}
|
|
if (hasImageUpdate) {
|
|
payload.hashtags = this.extractHashtags(nextContent);
|
|
}
|
|
|
|
if (hasVideoUpdate && !hasAudioUpdate) {
|
|
payload.audioUrl = '';
|
|
}
|
|
if (hasAudioUpdate && !hasVideoUpdate) {
|
|
payload.videoUrl = '';
|
|
}
|
|
if (hasImageUpdate) {
|
|
payload.videoUrl = '';
|
|
payload.audioUrl = '';
|
|
}
|
|
|
|
if (videoFile) {
|
|
payload.videoUrl = uploadedVideoUrl;
|
|
payload.imageUrls = [];
|
|
payload.audioUrl = '';
|
|
}
|
|
if (audioFile) {
|
|
payload.audioUrl = uploadedAudioUrl;
|
|
payload.imageUrls = [];
|
|
payload.videoUrl = '';
|
|
}
|
|
|
|
let updated: PostDocument | null;
|
|
try {
|
|
updated = await this.postsRepository.updateById(postId, payload as any);
|
|
} catch (error) {
|
|
await Promise.all([
|
|
...uploadedImageUrls.map((url) => this.deleteManagedPostMedia(url)),
|
|
uploadedVideoUrl ? this.deleteManagedPostMedia(uploadedVideoUrl) : Promise.resolve(),
|
|
uploadedThumbnailUrl ? this.deleteManagedPostMedia(uploadedThumbnailUrl) : Promise.resolve(),
|
|
uploadedAudioUrl ? this.deleteManagedPostMedia(uploadedAudioUrl) : Promise.resolve(),
|
|
]);
|
|
throw error;
|
|
}
|
|
if (!updated) {
|
|
await Promise.all([
|
|
...uploadedImageUrls.map((url) => this.deleteManagedPostMedia(url)),
|
|
uploadedVideoUrl ? this.deleteManagedPostMedia(uploadedVideoUrl) : Promise.resolve(),
|
|
uploadedThumbnailUrl ? this.deleteManagedPostMedia(uploadedThumbnailUrl) : Promise.resolve(),
|
|
uploadedAudioUrl ? this.deleteManagedPostMedia(uploadedAudioUrl) : Promise.resolve(),
|
|
]);
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
if (hasVideoUpdate && (post.videoUrl ?? '') !== (updated.videoUrl ?? '')) {
|
|
await this.deleteManagedPostMedia(post.videoUrl ?? '');
|
|
}
|
|
if ((post.thumbnailUrl ?? '') !== (updated.thumbnailUrl ?? '')) {
|
|
await this.deleteManagedPostMedia(post.thumbnailUrl ?? '');
|
|
}
|
|
if (hasAudioUpdate && (post.audioUrl ?? '') !== (updated.audioUrl ?? '')) {
|
|
await this.deleteManagedPostMedia(post.audioUrl ?? '');
|
|
}
|
|
if (hasImageUpdate) {
|
|
const nextImageSet = new Set(updated.imageUrls ?? []);
|
|
await Promise.all(
|
|
(post.imageUrls ?? [])
|
|
.filter((url) => !nextImageSet.has(url))
|
|
.map((url) => this.deleteManagedPostMedia(url)),
|
|
);
|
|
}
|
|
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
if (shouldRecomputeMentions) {
|
|
const previousMentionSet = new Set(previousMentionUsernames);
|
|
const nextMentionedUsers = mentionResolution.mentionedUsers.filter(
|
|
(mentionedUser) => !previousMentionSet.has(mentionedUser.username),
|
|
);
|
|
await this.notifyMentionedUsers(userId, postId, nextMentionedUsers, nextContent);
|
|
}
|
|
return updated;
|
|
}
|
|
|
|
async remove(userId: string, postId: string): Promise<void> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
if (this.extractEntityId(post.authorId) !== userId) {
|
|
throw new ForbiddenException('You can only delete your own posts');
|
|
}
|
|
|
|
await this.postsRepository.deleteById(postId, userId);
|
|
await Promise.all([
|
|
...(post.imageUrls ?? []).map((url) => this.deleteManagedPostMedia(url)),
|
|
this.deleteManagedPostMedia(post.videoUrl ?? ''),
|
|
this.deleteManagedPostMedia(post.audioUrl ?? ''),
|
|
]);
|
|
await this.usersRepository.incrementPostsCount(userId, -1);
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
}
|
|
|
|
async findById(postId: string): Promise<PostDocument> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
return post;
|
|
}
|
|
|
|
async findUserPosts(userId: string, query: PostQueryDto) {
|
|
if (!Types.ObjectId.isValid(userId)) {
|
|
throw new BadRequestException('Invalid user id');
|
|
}
|
|
|
|
const page = query.page ?? 1;
|
|
const limit = query.limit ?? 20;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const filter: Record<string, unknown> = { authorId: new Types.ObjectId(userId) };
|
|
if (query.visibility) {
|
|
filter.visibility = query.visibility;
|
|
}
|
|
if (query.postType) {
|
|
filter.postType = query.postType;
|
|
}
|
|
if (query.q) {
|
|
filter.content = { $regex: query.q.trim(), $options: 'i' };
|
|
}
|
|
if (query.hashtag) {
|
|
filter.hashtags = query.hashtag.trim().replace(/^#+/, '').toLowerCase();
|
|
}
|
|
const direction = resolveMongoSortDirection(query.sortOrder);
|
|
const sortField = query.sortBy ?? 'createdAt';
|
|
const sort = { [sortField]: direction } as Record<string, 1 | -1>;
|
|
|
|
const [items, total] = await Promise.all([
|
|
this.postsRepository.findMany(filter, skip, limit, sort),
|
|
this.postsRepository.count(filter),
|
|
]);
|
|
|
|
return buildPaginatedResponse(items, {
|
|
page,
|
|
limit,
|
|
total,
|
|
offset: skip,
|
|
});
|
|
}
|
|
|
|
async findPlatformPosts(query: AdminPostQueryDto) {
|
|
const page = query.page ?? 1;
|
|
const limit = query.limit ?? 20;
|
|
const skip = (page - 1) * limit;
|
|
const filter: Record<string, unknown> = {};
|
|
|
|
if (query.visibility) {
|
|
filter.visibility = query.visibility;
|
|
}
|
|
if (query.postType) {
|
|
filter.postType = query.postType;
|
|
}
|
|
if (query.authorId) {
|
|
filter.authorId = new Types.ObjectId(query.authorId);
|
|
}
|
|
if (query.q?.trim()) {
|
|
filter.content = { $regex: query.q.trim(), $options: 'i' };
|
|
}
|
|
if (query.hashtag?.trim()) {
|
|
filter.hashtags = query.hashtag.trim().replace(/^#+/, '').toLowerCase();
|
|
}
|
|
if (query.moderationStatus) {
|
|
filter.moderationStatus = query.moderationStatus;
|
|
}
|
|
|
|
const direction = resolveMongoSortDirection(query.sortOrder);
|
|
const sortField = query.sortBy ?? 'createdAt';
|
|
const sort = { [sortField]: direction } as Record<string, 1 | -1>;
|
|
|
|
const [items, total] = await Promise.all([
|
|
this.postsRepository.findManyAdmin(filter, skip, limit, sort),
|
|
this.postsRepository.countAdmin(filter),
|
|
]);
|
|
|
|
return buildPaginatedResponse(items, {
|
|
page,
|
|
limit,
|
|
total,
|
|
offset: skip,
|
|
});
|
|
}
|
|
|
|
async createReel(
|
|
userId: string,
|
|
dto: CreateReelDto,
|
|
videoFile?: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
): Promise<PostDocument> {
|
|
if (!videoFile && !dto.videoUrl) {
|
|
throw new BadRequestException('Reel requires videoFile or videoUrl');
|
|
}
|
|
|
|
if (videoFile && dto.videoUrl) {
|
|
throw new BadRequestException('Provide either videoFile or videoUrl for reel, not both');
|
|
}
|
|
|
|
return this.create(
|
|
userId,
|
|
{
|
|
content: dto.content ?? '',
|
|
videoUrl: dto.videoUrl,
|
|
durationSeconds: dto.durationSeconds,
|
|
thumbnailUrl: dto.thumbnailUrl,
|
|
style: dto.style,
|
|
maqam: dto.maqam,
|
|
rhythmSignature: dto.rhythmSignature,
|
|
mentionUsernames: dto.mentionUsernames,
|
|
visibility: dto.visibility ?? PostVisibility.PUBLIC,
|
|
},
|
|
[],
|
|
videoFile,
|
|
undefined,
|
|
);
|
|
}
|
|
|
|
async findReels(query: ReelQueryDto) {
|
|
const page = query.page ?? 1;
|
|
const limit = query.limit ?? 20;
|
|
const skip = (page - 1) * limit;
|
|
|
|
const filter: Record<string, unknown> = { postType: PostType.VIDEO };
|
|
if (query.visibility) {
|
|
filter.visibility = query.visibility;
|
|
}
|
|
if (query.authorId) {
|
|
filter.authorId = new Types.ObjectId(query.authorId);
|
|
}
|
|
if (query.q) {
|
|
filter.content = { $regex: query.q.trim(), $options: 'i' };
|
|
}
|
|
const direction = resolveMongoSortDirection(query.sortOrder);
|
|
const sortField = query.sortBy ?? 'createdAt';
|
|
const sort = { [sortField]: direction } as Record<string, 1 | -1>;
|
|
|
|
const [items, total] = await Promise.all([
|
|
this.postsRepository.findMany(filter, skip, limit, sort),
|
|
this.postsRepository.count(filter),
|
|
]);
|
|
|
|
return buildPaginatedResponse(items, {
|
|
page,
|
|
limit,
|
|
total,
|
|
offset: skip,
|
|
});
|
|
}
|
|
|
|
async registerView(userId: string, postId: string): Promise<{ success: true; postId: string; viewCount: number }> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
await this.postsRepository.incrementViewCount(postId, 1);
|
|
|
|
return {
|
|
success: true,
|
|
postId,
|
|
viewCount: (post.viewCount ?? 0) + 1,
|
|
};
|
|
}
|
|
|
|
async registerPlay(
|
|
userId: string,
|
|
postId: string,
|
|
): Promise<{ success: true; postId: string; playCount: number }> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
if (post.postType !== PostType.AUDIO && post.postType !== PostType.VIDEO) {
|
|
throw new BadRequestException('play counter is available only for audio or video posts');
|
|
}
|
|
|
|
await this.postsRepository.incrementPlayCount(postId, 1);
|
|
|
|
return {
|
|
success: true,
|
|
postId,
|
|
playCount: (post.playCount ?? 0) + 1,
|
|
};
|
|
}
|
|
|
|
async registerShare(
|
|
userId: string,
|
|
postId: string,
|
|
): Promise<{ success: true; postId: string; shareCount: number }> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
await this.postsRepository.incrementShareCount(postId, 1);
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
|
|
const authorId = this.extractEntityId(post.authorId);
|
|
if (authorId && authorId !== userId) {
|
|
try {
|
|
await this.notificationsService.createShareNotification(userId, authorId, postId, {
|
|
resourceType: 'post',
|
|
previewText: (post.content ?? '').slice(0, 140),
|
|
});
|
|
} catch (error) {
|
|
this.logger.warn(
|
|
`Share notification failed for actor=${userId} recipient=${authorId}: ${
|
|
error instanceof Error ? error.message : 'unknown error'
|
|
}`,
|
|
);
|
|
}
|
|
}
|
|
|
|
return {
|
|
success: true,
|
|
postId,
|
|
shareCount: (post.shareCount ?? 0) + 1,
|
|
};
|
|
}
|
|
|
|
async removeBySuperAdmin(superAdminIdentifier: string, postId: string): Promise<void> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
await this.postsRepository.deleteById(postId, superAdminIdentifier);
|
|
await Promise.all([
|
|
...(post.imageUrls ?? []).map((url) => this.deleteManagedPostMedia(url)),
|
|
this.deleteManagedPostMedia(post.videoUrl ?? ''),
|
|
this.deleteManagedPostMedia(post.audioUrl ?? ''),
|
|
]);
|
|
const authorId = this.extractEntityId(post.authorId);
|
|
if (authorId) {
|
|
await this.usersRepository.incrementPostsCount(authorId, -1);
|
|
}
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
await this.auditService.logSuperAdminAction(
|
|
superAdminIdentifier,
|
|
'post_delete',
|
|
'post',
|
|
postId,
|
|
{ authorId },
|
|
);
|
|
}
|
|
|
|
async updateModerationStatusBySuperAdmin(
|
|
superAdminIdentifier: string,
|
|
postId: string,
|
|
dto: { status: ModerationStatus; reason?: string },
|
|
): Promise<PostDocument> {
|
|
const post = await this.postsRepository.findById(postId);
|
|
if (!post) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
const updated = await this.postsRepository.updateModerationStatus(postId, {
|
|
moderationStatus: dto.status,
|
|
moderationReason: dto.reason?.trim() ?? '',
|
|
});
|
|
if (!updated) {
|
|
throw new NotFoundException('Post not found');
|
|
}
|
|
|
|
await this.feedVersionService.bumpGlobalVersion();
|
|
await this.auditService.logSuperAdminAction(
|
|
superAdminIdentifier,
|
|
'post_moderation_status_update',
|
|
'post',
|
|
postId,
|
|
{
|
|
previousStatus: post.moderationStatus ?? ModerationStatus.ACTIVE,
|
|
nextStatus: dto.status,
|
|
reason: dto.reason?.trim() ?? '',
|
|
},
|
|
);
|
|
|
|
return updated;
|
|
}
|
|
|
|
private resolvePostType(imageUrls: string[] = [], videoUrl?: string, audioUrl?: string): PostType {
|
|
const hasImages = imageUrls.length > 0;
|
|
const hasVideo = !!videoUrl?.trim();
|
|
const hasAudio = !!audioUrl?.trim();
|
|
|
|
if ((hasImages && hasVideo) || (hasImages && hasAudio) || (hasVideo && hasAudio)) {
|
|
throw new BadRequestException('Post can contain either images, video, or audio');
|
|
}
|
|
|
|
if (hasImages) {
|
|
return PostType.IMAGE;
|
|
}
|
|
|
|
if (hasVideo) {
|
|
return PostType.VIDEO;
|
|
}
|
|
|
|
if (hasAudio) {
|
|
return PostType.AUDIO;
|
|
}
|
|
|
|
return PostType.TEXT;
|
|
}
|
|
|
|
private normalizeMediaMetadata(
|
|
dto: PostMediaMetadataInput,
|
|
postType: PostType,
|
|
fallback: NormalizedPostMediaMetadata = {
|
|
durationSeconds: null,
|
|
thumbnailUrl: '',
|
|
style: '',
|
|
maqam: '',
|
|
rhythmSignature: '',
|
|
waveformPeaks: [],
|
|
},
|
|
options: {
|
|
audioSourceBuffer?: Buffer;
|
|
waveformSeed?: string;
|
|
thumbnailUrl?: string;
|
|
} = {},
|
|
): NormalizedPostMediaMetadata {
|
|
const supportsMediaMetadata = postType === PostType.AUDIO || postType === PostType.VIDEO;
|
|
const supportsWaveform = postType === PostType.AUDIO;
|
|
|
|
if (!supportsMediaMetadata) {
|
|
if (this.hasMediaMetadataInput(dto)) {
|
|
throw new BadRequestException('Audio/video metadata is allowed only for audio or video posts');
|
|
}
|
|
return {
|
|
durationSeconds: null,
|
|
thumbnailUrl: '',
|
|
style: '',
|
|
maqam: '',
|
|
rhythmSignature: '',
|
|
waveformPeaks: [],
|
|
};
|
|
}
|
|
|
|
if (!supportsWaveform && typeof dto.waveformPeaks !== 'undefined') {
|
|
throw new BadRequestException('waveformPeaks is allowed only for audio posts');
|
|
}
|
|
|
|
return {
|
|
durationSeconds:
|
|
typeof dto.durationSeconds === 'number' ? dto.durationSeconds : fallback.durationSeconds,
|
|
thumbnailUrl:
|
|
typeof dto.thumbnailUrl === 'string'
|
|
? dto.thumbnailUrl.trim()
|
|
: options.thumbnailUrl || fallback.thumbnailUrl,
|
|
style: typeof dto.style === 'string' ? dto.style.trim() : fallback.style,
|
|
maqam: typeof dto.maqam === 'string' ? dto.maqam.trim() : fallback.maqam,
|
|
rhythmSignature:
|
|
typeof dto.rhythmSignature === 'string'
|
|
? dto.rhythmSignature.trim()
|
|
: fallback.rhythmSignature,
|
|
waveformPeaks: supportsWaveform
|
|
? this.resolveAudioWaveformPeaks(
|
|
Array.isArray(dto.waveformPeaks) ? dto.waveformPeaks : undefined,
|
|
options.audioSourceBuffer,
|
|
options.waveformSeed,
|
|
fallback.waveformPeaks,
|
|
)
|
|
: [],
|
|
};
|
|
}
|
|
|
|
private hasMediaMetadataInput(dto: PostMediaMetadataInput): boolean {
|
|
return (
|
|
typeof dto.durationSeconds === 'number' ||
|
|
typeof dto.thumbnailUrl === 'string' ||
|
|
typeof dto.style === 'string' ||
|
|
typeof dto.maqam === 'string' ||
|
|
typeof dto.rhythmSignature === 'string' ||
|
|
typeof dto.waveformPeaks !== 'undefined'
|
|
);
|
|
}
|
|
|
|
private extractMentions(content: string): string[] {
|
|
const matches = content.match(/@[\p{L}\p{N}_.]+/gu) ?? [];
|
|
const normalized = matches
|
|
.map((item) => item.replace('@', '').trim().toLowerCase())
|
|
.filter(Boolean);
|
|
return Array.from(new Set(normalized)).slice(0, 30);
|
|
}
|
|
|
|
private normalizeMentionUsernames(input: string[] = []): string[] {
|
|
return Array.from(
|
|
new Set(
|
|
input
|
|
.map((username) => username?.trim().replace(/^@+/, '').toLowerCase())
|
|
.filter((username): username is string => !!username),
|
|
),
|
|
);
|
|
}
|
|
|
|
private async resolveMentionTargets(
|
|
explicitMentionUsernames: string[] | undefined,
|
|
content: string,
|
|
authorId: string,
|
|
): Promise<{
|
|
mentionUsernames: string[];
|
|
mentionedUsers: Array<{ id: string; username: string }>;
|
|
}> {
|
|
const mergedMentionUsernames = Array.from(
|
|
new Set([
|
|
...this.extractMentions(content),
|
|
...this.normalizeMentionUsernames(explicitMentionUsernames ?? []),
|
|
]),
|
|
);
|
|
|
|
if (mergedMentionUsernames.length > 30) {
|
|
throw new BadRequestException('You can mention up to 30 users only');
|
|
}
|
|
|
|
if (!mergedMentionUsernames.length) {
|
|
return { mentionUsernames: [], mentionedUsers: [] };
|
|
}
|
|
|
|
const users = await this.usersRepository.findByUsernames(mergedMentionUsernames);
|
|
const userByUsername = new Map(
|
|
users.map((user) => [user.username.toLowerCase(), { id: user.id, username: user.username.toLowerCase() }]),
|
|
);
|
|
|
|
const mentionedUsers = mergedMentionUsernames
|
|
.map((username) => userByUsername.get(username))
|
|
.filter((user): user is { id: string; username: string } => !!user)
|
|
.filter((user) => user.id !== authorId);
|
|
|
|
return {
|
|
mentionUsernames: mentionedUsers.map((user) => user.username),
|
|
mentionedUsers,
|
|
};
|
|
}
|
|
|
|
private extractHashtags(content: string): string[] {
|
|
const matches = content.match(/#[\p{L}\p{N}_]+/gu) ?? [];
|
|
const normalized = matches
|
|
.map((item) => item.replace('#', '').trim().toLowerCase())
|
|
.filter(Boolean);
|
|
|
|
return Array.from(new Set(normalized)).slice(0, 20);
|
|
}
|
|
|
|
private normalizeLocation(
|
|
dto: Pick<CreatePostDto, 'location' | 'latitude' | 'longitude'>,
|
|
fallback: { location: string; latitude: number | null; longitude: number | null } = {
|
|
location: '',
|
|
latitude: null,
|
|
longitude: null,
|
|
},
|
|
): { location: string; latitude: number | null; longitude: number | null } {
|
|
const location = typeof dto.location === 'string' ? dto.location.trim() : fallback.location;
|
|
const latitude = typeof dto.latitude === 'number' ? dto.latitude : fallback.latitude;
|
|
const longitude = typeof dto.longitude === 'number' ? dto.longitude : fallback.longitude;
|
|
|
|
const hasLatitude = typeof latitude === 'number';
|
|
const hasLongitude = typeof longitude === 'number';
|
|
if (hasLatitude !== hasLongitude) {
|
|
throw new BadRequestException('latitude and longitude must be provided together');
|
|
}
|
|
|
|
return { location, latitude, longitude };
|
|
}
|
|
|
|
private async normalizeTaggedUserIds(
|
|
input: string[] | undefined,
|
|
authorId: string,
|
|
): Promise<Types.ObjectId[]> {
|
|
if (!input?.length) {
|
|
return [];
|
|
}
|
|
|
|
const unique = Array.from(
|
|
new Set(
|
|
input
|
|
.map((item) => item?.trim())
|
|
.filter((item): item is string => !!item)
|
|
.filter((item) => item !== authorId),
|
|
),
|
|
);
|
|
|
|
if (unique.length > 20) {
|
|
throw new BadRequestException('You can tag up to 20 users only');
|
|
}
|
|
|
|
if (unique.some((id) => !Types.ObjectId.isValid(id))) {
|
|
throw new BadRequestException('Invalid tagged user id');
|
|
}
|
|
|
|
const rows = await this.usersRepository.findMany(
|
|
{
|
|
_id: { $in: unique.map((id) => new Types.ObjectId(id)) },
|
|
},
|
|
0,
|
|
unique.length,
|
|
);
|
|
|
|
if (rows.length !== unique.length) {
|
|
throw new BadRequestException('One or more tagged users do not exist');
|
|
}
|
|
|
|
return unique.map((id) => new Types.ObjectId(id));
|
|
}
|
|
|
|
private async notifyMentionedUsers(
|
|
actorId: string,
|
|
postId: string,
|
|
mentionedUsers: Array<{ id: string; username: string }>,
|
|
content: string,
|
|
): Promise<void> {
|
|
if (!mentionedUsers.length) {
|
|
return;
|
|
}
|
|
|
|
await Promise.all(
|
|
mentionedUsers.map(async (mentionedUser) => {
|
|
try {
|
|
await this.notificationsService.createMentionNotification(actorId, mentionedUser.id, postId, {
|
|
resourceType: 'post',
|
|
previewText: content.slice(0, 140),
|
|
});
|
|
} catch (error) {
|
|
this.logger.warn(
|
|
`Mention notification failed for actor=${actorId} recipient=${mentionedUser.id}: ${
|
|
error instanceof Error ? error.message : 'unknown error'
|
|
}`,
|
|
);
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
private async saveVideoUpload(file: UploadedVideoFile): Promise<SavedVideoUpload> {
|
|
this.validateMediaFile('video', file);
|
|
const optimized = await this.videoProcessingService.optimizeForPlayback(file);
|
|
const extension = this.validateMediaFile('video', optimized.file);
|
|
|
|
let videoUrl = '';
|
|
let thumbnailUrl = '';
|
|
|
|
try {
|
|
videoUrl = await this.storageService.saveFile({
|
|
folderSegments: ['posts', 'videos'],
|
|
extension,
|
|
buffer: optimized.file.buffer,
|
|
contentType: optimized.file.mimetype,
|
|
fileNamePrefix: 'video',
|
|
});
|
|
|
|
if (optimized.generatedThumbnail) {
|
|
thumbnailUrl = await this.storageService.saveFile({
|
|
folderSegments: ['posts', 'thumbnails'],
|
|
extension: optimized.generatedThumbnail.extension,
|
|
buffer: optimized.generatedThumbnail.buffer,
|
|
contentType: optimized.generatedThumbnail.contentType,
|
|
fileNamePrefix: 'thumbnail',
|
|
});
|
|
}
|
|
|
|
return { videoUrl, thumbnailUrl };
|
|
} catch (error) {
|
|
await Promise.all([
|
|
videoUrl ? this.deleteManagedPostMedia(videoUrl) : Promise.resolve(),
|
|
thumbnailUrl ? this.deleteManagedPostMedia(thumbnailUrl) : Promise.resolve(),
|
|
]);
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private async saveMediaFile(
|
|
mediaType: 'image' | 'video' | 'audio',
|
|
file: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
): Promise<string> {
|
|
const extension = this.validateMediaFile(mediaType, file);
|
|
const folder =
|
|
mediaType === 'image' ? 'images' : mediaType === 'video' ? 'videos' : 'audios';
|
|
return this.storageService.saveFile({
|
|
folderSegments: ['posts', folder],
|
|
extension,
|
|
buffer: file.buffer,
|
|
contentType: file.mimetype,
|
|
fileNamePrefix: mediaType,
|
|
});
|
|
}
|
|
|
|
private validateMediaFile(
|
|
mediaType: 'image' | 'video' | 'audio',
|
|
file: { mimetype?: string; size: number; buffer: Buffer; originalname?: string },
|
|
): string {
|
|
const extension = this.resolveMediaExtension(mediaType, file);
|
|
if (!extension) {
|
|
throw new BadRequestException(
|
|
mediaType === 'image'
|
|
? 'imageFiles must be jpg, jpeg, png, webp, or gif'
|
|
: mediaType === 'video'
|
|
? 'videoFile must be mp4, mov, webm, mkv, or avi'
|
|
: 'audioFile must be mp3, wav, m4a, aac, ogg, or webm',
|
|
);
|
|
}
|
|
|
|
const maxSize =
|
|
mediaType === 'image'
|
|
? 10 * 1024 * 1024
|
|
: mediaType === 'video'
|
|
? 100 * 1024 * 1024
|
|
: 20 * 1024 * 1024;
|
|
if (file.size > maxSize) {
|
|
throw new BadRequestException(
|
|
mediaType === 'image'
|
|
? 'Each image must be 10MB or less'
|
|
: mediaType === 'video'
|
|
? 'videoFile size must be 100MB or less'
|
|
: 'audioFile size must be 20MB or less',
|
|
);
|
|
}
|
|
|
|
return extension;
|
|
}
|
|
|
|
private resolveMediaExtension(
|
|
mediaType: 'image' | 'video' | 'audio',
|
|
file: { mimetype?: string; originalname?: string },
|
|
): string | null {
|
|
const originalExtension = extname(file.originalname ?? '').toLowerCase();
|
|
const imageAllowed = new Set(['.jpg', '.jpeg', '.png', '.webp', '.gif']);
|
|
const videoAllowed = new Set(['.mp4', '.mov', '.webm', '.mkv', '.avi']);
|
|
const audioAllowed = new Set(['.mp3', '.wav', '.m4a', '.aac', '.ogg', '.webm']);
|
|
const allowed =
|
|
mediaType === 'image' ? imageAllowed : mediaType === 'video' ? videoAllowed : audioAllowed;
|
|
|
|
if (allowed.has(originalExtension)) {
|
|
return originalExtension;
|
|
}
|
|
|
|
if (mediaType === 'image') {
|
|
switch (file.mimetype) {
|
|
case 'image/jpeg':
|
|
return '.jpg';
|
|
case 'image/png':
|
|
return '.png';
|
|
case 'image/webp':
|
|
return '.webp';
|
|
case 'image/gif':
|
|
return '.gif';
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
if (mediaType === 'video') {
|
|
switch (file.mimetype) {
|
|
case 'video/mp4':
|
|
return '.mp4';
|
|
case 'video/quicktime':
|
|
return '.mov';
|
|
case 'video/webm':
|
|
return '.webm';
|
|
case 'video/x-matroska':
|
|
return '.mkv';
|
|
case 'video/x-msvideo':
|
|
return '.avi';
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
switch (file.mimetype) {
|
|
case 'audio/mpeg':
|
|
return '.mp3';
|
|
case 'audio/wav':
|
|
case 'audio/x-wav':
|
|
return '.wav';
|
|
case 'audio/mp4':
|
|
case 'audio/x-m4a':
|
|
return '.m4a';
|
|
case 'audio/aac':
|
|
return '.aac';
|
|
case 'audio/ogg':
|
|
return '.ogg';
|
|
case 'audio/webm':
|
|
return '.webm';
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async saveImageFiles(
|
|
files: Array<{ mimetype?: string; size: number; buffer: Buffer; originalname?: string }>,
|
|
): Promise<string[]> {
|
|
if (!files.length) {
|
|
return [];
|
|
}
|
|
if (files.length > 10) {
|
|
throw new BadRequestException('Post can contain up to 10 images');
|
|
}
|
|
|
|
const urls: string[] = [];
|
|
try {
|
|
for (const file of files) {
|
|
urls.push(await this.saveMediaFile('image', file));
|
|
}
|
|
return urls;
|
|
} catch (error) {
|
|
await Promise.all(urls.map((url) => this.deleteManagedPostMedia(url)));
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
private async deleteManagedPostMedia(fileUrl: string): Promise<void> {
|
|
await this.storageService.deleteFile(fileUrl);
|
|
}
|
|
|
|
private resolveAudioWaveformPeaks(
|
|
providedPeaks: number[] | undefined,
|
|
sourceBuffer: Buffer | undefined,
|
|
waveformSeed: string | undefined,
|
|
fallbackPeaks: number[] = [],
|
|
): number[] {
|
|
if (Array.isArray(providedPeaks) && providedPeaks.length) {
|
|
return normalizeWaveformPeaks(providedPeaks);
|
|
}
|
|
|
|
if (sourceBuffer?.length) {
|
|
return generateWaveformPeaksFromBuffer(sourceBuffer);
|
|
}
|
|
|
|
if (fallbackPeaks.length) {
|
|
return normalizeWaveformPeaks(fallbackPeaks);
|
|
}
|
|
|
|
return generateWaveformPeaksFromSeed(waveformSeed ?? 'audio-post');
|
|
}
|
|
|
|
private extractEntityId(value: unknown): string {
|
|
if (!value) {
|
|
return '';
|
|
}
|
|
|
|
if (typeof value === 'string') {
|
|
return value;
|
|
}
|
|
|
|
if (value instanceof Types.ObjectId) {
|
|
return value.toString();
|
|
}
|
|
|
|
if (typeof value === 'object') {
|
|
const candidate = value as { _id?: unknown; id?: unknown };
|
|
if (candidate._id instanceof Types.ObjectId) {
|
|
return candidate._id.toString();
|
|
}
|
|
if (typeof candidate._id === 'string') {
|
|
return candidate._id;
|
|
}
|
|
if (typeof candidate.id === 'string') {
|
|
return candidate.id;
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
}
|