605 lines
18 KiB
TypeScript
605 lines
18 KiB
TypeScript
import {
|
|
BadRequestException,
|
|
ConflictException,
|
|
ForbiddenException,
|
|
Injectable,
|
|
NotFoundException,
|
|
} from '@nestjs/common';
|
|
import { InjectRepository } from '@nestjs/typeorm';
|
|
import { DataSource, Repository } from 'typeorm';
|
|
import { deleteBusinessCascade } from '../../common/utils/business-cascade.util';
|
|
import { parseHmToMinute } from '../../common/utils/booking-schedule.util';
|
|
import {
|
|
isValidIranMobile,
|
|
normalizeIranMobile,
|
|
} from '../../common/utils/iran-mobile.util';
|
|
import { resolveUniqueSlug, normalizeSlugInput } from '../../common/utils/slug.util';
|
|
import { BusinessAvailabilitySlotEntity } from '../../entities/business-availability-slot.entity';
|
|
import { BusinessCategoryEntity } from '../../entities/business-category.entity';
|
|
import { BusinessEntity } from '../../entities/business.entity';
|
|
import { BookingReviewEntity } from '../../entities/booking-review.entity';
|
|
import { BusinessImageEntity } from '../../entities/business-image.entity';
|
|
import { UserEntity, UserRole } from '../../entities/user.entity';
|
|
import { AuthUser } from '../auth/auth.types';
|
|
import { BusinessImagesService } from './business-images.service';
|
|
import { BusinessLogosService } from './business-logos.service';
|
|
import { AssignBusinessOwnerDto } from './dto/assign-business-owner.dto';
|
|
import { CreateBusinessDto } from './dto/create-business.dto';
|
|
import { SetAvailabilityDto } from './dto/set-availability.dto';
|
|
import { UpdateBusinessDto } from './dto/update-business.dto';
|
|
import { sanitizeBusinessHighlightKeys } from '../../common/constants/business-highlights';
|
|
|
|
type FindAllFilters = {
|
|
categoryId?: string;
|
|
isActive?: boolean;
|
|
};
|
|
|
|
@Injectable()
|
|
export class BusinessesService {
|
|
constructor(
|
|
@InjectRepository(BusinessEntity)
|
|
private readonly repo: Repository<BusinessEntity>,
|
|
@InjectRepository(BusinessAvailabilitySlotEntity)
|
|
private readonly availabilityRepo: Repository<BusinessAvailabilitySlotEntity>,
|
|
@InjectRepository(BusinessCategoryEntity)
|
|
private readonly categoryRepo: Repository<BusinessCategoryEntity>,
|
|
@InjectRepository(BusinessImageEntity)
|
|
private readonly imageRepo: Repository<BusinessImageEntity>,
|
|
@InjectRepository(UserEntity)
|
|
private readonly userRepo: Repository<UserEntity>,
|
|
@InjectRepository(BookingReviewEntity)
|
|
private readonly reviewRepo: Repository<BookingReviewEntity>,
|
|
private readonly dataSource: DataSource,
|
|
private readonly images: BusinessImagesService,
|
|
private readonly logos: BusinessLogosService,
|
|
) {}
|
|
|
|
async findAll(filters: FindAllFilters): Promise<BusinessEntity[]> {
|
|
const query = this.repo
|
|
.createQueryBuilder('business')
|
|
.leftJoinAndSelect('business.category', 'category')
|
|
.orderBy('business.createdAt', 'DESC');
|
|
|
|
if (filters.categoryId) {
|
|
query.andWhere('business.categoryId = :categoryId', {
|
|
categoryId: filters.categoryId,
|
|
});
|
|
}
|
|
|
|
if (typeof filters.isActive === 'boolean') {
|
|
query.andWhere('business.isActive = :isActive', {
|
|
isActive: filters.isActive,
|
|
});
|
|
}
|
|
|
|
const businesses = await query.getMany();
|
|
await this.attachCoverImages(businesses);
|
|
await this.attachReviewStats(businesses);
|
|
return businesses;
|
|
}
|
|
|
|
async findMine(ownerId: string): Promise<BusinessEntity[]> {
|
|
const businesses = await this.repo.find({
|
|
where: { ownerId },
|
|
relations: { category: true, images: true },
|
|
order: { createdAt: 'DESC' },
|
|
});
|
|
for (const business of businesses) {
|
|
business.images = this.sortImages(business.images ?? []);
|
|
}
|
|
return businesses;
|
|
}
|
|
|
|
async findOne(id: string): Promise<BusinessEntity> {
|
|
const business = await this.repo.findOne({
|
|
where: { id },
|
|
relations: { category: true, images: true },
|
|
});
|
|
if (!business) {
|
|
throw new NotFoundException('Business not found');
|
|
}
|
|
business.images = this.sortImages(business.images ?? []);
|
|
await this.attachReviewStats([business]);
|
|
return business;
|
|
}
|
|
|
|
async create(payload: CreateBusinessDto): Promise<BusinessEntity> {
|
|
const explicitSlug = normalizeSlugInput(payload.slug);
|
|
if (explicitSlug) {
|
|
const taken = await this.repo.findOne({ where: { slug: explicitSlug } });
|
|
if (taken) {
|
|
throw new ConflictException('Slug already exists');
|
|
}
|
|
}
|
|
|
|
const slug = await resolveUniqueSlug(
|
|
payload.title,
|
|
async (candidate) => Boolean(await this.repo.findOne({ where: { slug: candidate } })),
|
|
payload.slug,
|
|
'business',
|
|
);
|
|
|
|
await this.ensureCategoryExists(payload.categoryId);
|
|
|
|
const contactPhone = this.normalizeOptionalContactPhone(payload.contactPhone);
|
|
|
|
const entity = this.repo.create({
|
|
title: payload.title,
|
|
slug,
|
|
subtitle: payload.subtitle ?? null,
|
|
categoryId: payload.categoryId,
|
|
description: payload.description ?? null,
|
|
contactPhone,
|
|
address: payload.address ?? null,
|
|
latitude: payload.latitude ?? null,
|
|
longitude: payload.longitude ?? null,
|
|
ownerId: payload.ownerId ?? null,
|
|
isActive: payload.isActive ?? true,
|
|
});
|
|
|
|
const saved = await this.repo.save(entity);
|
|
return this.ensureOwnerFromContactPhone(saved);
|
|
}
|
|
|
|
async update(
|
|
id: string,
|
|
payload: UpdateBusinessDto,
|
|
actor?: AuthUser,
|
|
): Promise<BusinessEntity> {
|
|
const business = await this.findOne(id);
|
|
this.assertCanUpdateBusiness(business, payload, actor);
|
|
|
|
if (payload.slug && payload.slug !== business.slug) {
|
|
const slugTaken = await this.repo.findOne({ where: { slug: payload.slug } });
|
|
if (slugTaken) {
|
|
throw new ConflictException('Slug already exists');
|
|
}
|
|
}
|
|
|
|
if (payload.categoryId && payload.categoryId !== business.categoryId) {
|
|
await this.ensureCategoryExists(payload.categoryId);
|
|
}
|
|
|
|
if (payload.contactPhone !== undefined) {
|
|
payload.contactPhone = this.normalizeOptionalContactPhone(payload.contactPhone);
|
|
}
|
|
|
|
Object.assign(business, payload);
|
|
|
|
if (payload.heroHighlightKeys !== undefined) {
|
|
const sanitized = sanitizeBusinessHighlightKeys(payload.heroHighlightKeys);
|
|
business.heroHighlightKeys = sanitized.length ? sanitized : null;
|
|
}
|
|
|
|
if (business.promoDiscountEnabled) {
|
|
if (
|
|
!business.promoDiscountPercent ||
|
|
business.promoDiscountPercent < 1 ||
|
|
business.promoDiscountPercent > 100
|
|
) {
|
|
throw new BadRequestException(
|
|
'promoDiscountPercent must be between 1 and 100 when discount is enabled',
|
|
);
|
|
}
|
|
const title = business.promoDiscountTitle?.trim();
|
|
if (!title) {
|
|
throw new BadRequestException(
|
|
'promoDiscountTitle is required when discount is enabled',
|
|
);
|
|
}
|
|
business.promoDiscountTitle = title;
|
|
if (
|
|
business.promoDiscountMode !== 'first_booking' &&
|
|
business.promoDiscountMode !== 'always'
|
|
) {
|
|
business.promoDiscountMode = 'first_booking';
|
|
}
|
|
const code = business.promoDiscountCode?.trim();
|
|
if (!code) {
|
|
business.promoDiscountCode = `NEW${business.promoDiscountPercent}`;
|
|
} else {
|
|
business.promoDiscountCode = code.toUpperCase();
|
|
}
|
|
}
|
|
|
|
const saved = await this.repo.save(business);
|
|
return this.ensureOwnerFromContactPhone(saved);
|
|
}
|
|
|
|
async remove(id: string): Promise<void> {
|
|
const business = await this.findOne(id);
|
|
|
|
const imageUrls = await this.images.listUrlsForBusiness(id);
|
|
|
|
await this.dataSource.transaction(async (manager) => {
|
|
await deleteBusinessCascade(manager, id);
|
|
});
|
|
|
|
this.images.deleteFiles(imageUrls);
|
|
this.logos.deleteLogoFiles(business);
|
|
}
|
|
|
|
async getAvailability(businessId: string) {
|
|
await this.findOne(businessId);
|
|
const rows = await this.availabilityRepo.find({
|
|
where: { businessId },
|
|
order: { dayOfWeek: 'ASC', startMinute: 'ASC' },
|
|
});
|
|
return rows.map((row) => ({
|
|
id: row.id,
|
|
dayOfWeek: row.dayOfWeek,
|
|
startTime: this.minuteToHm(row.startMinute),
|
|
endTime: this.minuteToHm(row.endMinute),
|
|
}));
|
|
}
|
|
|
|
async setAvailability(
|
|
businessId: string,
|
|
dto: SetAvailabilityDto,
|
|
actor?: AuthUser,
|
|
) {
|
|
const business = await this.findOne(businessId);
|
|
this.assertCanManageAvailability(business, actor);
|
|
|
|
const entities: BusinessAvailabilitySlotEntity[] = [];
|
|
for (const slot of dto.slots) {
|
|
const startMinute = parseHmToMinute(slot.startTime);
|
|
const endMinute = parseHmToMinute(slot.endTime);
|
|
if (endMinute <= startMinute) {
|
|
throw new BadRequestException('endTime must be after startTime');
|
|
}
|
|
entities.push(
|
|
this.availabilityRepo.create({
|
|
businessId,
|
|
dayOfWeek: slot.dayOfWeek,
|
|
startMinute,
|
|
endMinute,
|
|
}),
|
|
);
|
|
}
|
|
|
|
await this.availabilityRepo.delete({ businessId });
|
|
if (entities.length) {
|
|
await this.availabilityRepo.save(entities);
|
|
}
|
|
return this.getAvailability(businessId);
|
|
}
|
|
|
|
async assignOwner(
|
|
id: string,
|
|
dto: AssignBusinessOwnerDto,
|
|
): Promise<BusinessEntity> {
|
|
const business = await this.findOne(id);
|
|
const mobile = normalizeIranMobile(dto.mobile);
|
|
if (!isValidIranMobile(mobile)) {
|
|
throw new BadRequestException('Invalid mobile number');
|
|
}
|
|
|
|
const defaultName = `مدیر ${business.title}`;
|
|
const resolvedName =
|
|
dto.fullName === undefined
|
|
? undefined
|
|
: dto.fullName?.trim() || defaultName;
|
|
|
|
let user = await this.userRepo.findOne({ where: { mobile } });
|
|
if (!user) {
|
|
user = this.userRepo.create({
|
|
mobile,
|
|
fullName: resolvedName ?? defaultName,
|
|
role: UserRole.BUSINESS_OWNER,
|
|
isActive: true,
|
|
});
|
|
} else {
|
|
if (user.role !== UserRole.ADMIN) {
|
|
user.role = UserRole.BUSINESS_OWNER;
|
|
}
|
|
if (resolvedName !== undefined) {
|
|
user.fullName = resolvedName;
|
|
} else if (!user.fullName?.trim()) {
|
|
user.fullName = defaultName;
|
|
}
|
|
user.isActive = true;
|
|
}
|
|
|
|
const savedUser = await this.userRepo.save(user);
|
|
business.ownerId = savedUser.id;
|
|
if (!business.contactPhone) {
|
|
business.contactPhone = mobile;
|
|
}
|
|
return this.repo.save(business);
|
|
}
|
|
|
|
async backfillMissingOwners(): Promise<{ filled: number; skipped: number }> {
|
|
const withoutOwner = await this.repo
|
|
.createQueryBuilder('business')
|
|
.where('business.ownerId IS NULL')
|
|
.andWhere('business.contactPhone IS NOT NULL')
|
|
.andWhere("business.contactPhone <> ''")
|
|
.getMany();
|
|
|
|
let filled = 0;
|
|
let skipped = 0;
|
|
|
|
for (const business of withoutOwner) {
|
|
const mobile = normalizeIranMobile(business.contactPhone ?? '');
|
|
if (!isValidIranMobile(mobile)) {
|
|
skipped += 1;
|
|
continue;
|
|
}
|
|
const existing = await this.userRepo.findOne({ where: { mobile } });
|
|
await this.assignOwner(business.id, {
|
|
mobile,
|
|
...(existing ? {} : { fullName: `مدیر ${business.title}` }),
|
|
});
|
|
filled += 1;
|
|
}
|
|
|
|
return { filled, skipped };
|
|
}
|
|
|
|
/** Create/attach owner user from contact phone when the business has none yet. */
|
|
private async ensureOwnerFromContactPhone(
|
|
business: BusinessEntity,
|
|
): Promise<BusinessEntity> {
|
|
if (business.ownerId || !business.contactPhone) {
|
|
return business;
|
|
}
|
|
|
|
const mobile = normalizeIranMobile(business.contactPhone);
|
|
if (!isValidIranMobile(mobile)) {
|
|
return business;
|
|
}
|
|
|
|
const existing = await this.userRepo.findOne({ where: { mobile } });
|
|
return this.assignOwner(business.id, {
|
|
mobile,
|
|
...(existing ? {} : { fullName: `مدیر ${business.title}` }),
|
|
});
|
|
}
|
|
|
|
private normalizeOptionalContactPhone(
|
|
value: string | null | undefined,
|
|
): string | null {
|
|
if (value == null) return null;
|
|
const trimmed = String(value).trim();
|
|
if (!trimmed) return null;
|
|
const mobile = normalizeIranMobile(trimmed);
|
|
return isValidIranMobile(mobile) ? mobile : trimmed;
|
|
}
|
|
|
|
private async attachCoverImages(businesses: BusinessEntity[]): Promise<void> {
|
|
if (!businesses.length) {
|
|
return;
|
|
}
|
|
|
|
const ids = businesses.map((b) => b.id);
|
|
const rows = (await this.imageRepo.query(
|
|
`SELECT DISTINCT ON ("businessId") id, "businessId", url, "originalName", "sortOrder", "isCover", "createdAt"
|
|
FROM business_images
|
|
WHERE "businessId" = ANY($1::uuid[])
|
|
ORDER BY "businessId", "isCover" DESC, "sortOrder" ASC`,
|
|
[ids],
|
|
)) as Array<{
|
|
id: string;
|
|
businessId: string;
|
|
url: string;
|
|
originalName: string | null;
|
|
sortOrder: number;
|
|
isCover: boolean;
|
|
createdAt: Date;
|
|
}>;
|
|
|
|
const coverByBusiness = new Map<string, BusinessImageEntity[]>();
|
|
for (const row of rows) {
|
|
coverByBusiness.set(row.businessId, [
|
|
this.imageRepo.create({
|
|
id: row.id,
|
|
businessId: row.businessId,
|
|
url: row.url,
|
|
originalName: row.originalName,
|
|
sortOrder: row.sortOrder,
|
|
isCover: row.isCover,
|
|
createdAt: row.createdAt,
|
|
}),
|
|
]);
|
|
}
|
|
|
|
for (const business of businesses) {
|
|
business.images = coverByBusiness.get(business.id) ?? [];
|
|
}
|
|
}
|
|
|
|
private minuteToHm(minute: number): string {
|
|
const h = Math.floor(minute / 60);
|
|
const m = minute % 60;
|
|
return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
|
|
}
|
|
|
|
async uploadImages(
|
|
id: string,
|
|
files: Express.Multer.File[],
|
|
actor: AuthUser,
|
|
): Promise<BusinessImageEntity[]> {
|
|
const business = await this.findOne(id);
|
|
this.assertCanManageBusiness(business, actor);
|
|
return this.images.upload(id, files);
|
|
}
|
|
|
|
async uploadMyImages(
|
|
files: Express.Multer.File[],
|
|
actor: AuthUser,
|
|
): Promise<BusinessImageEntity[]> {
|
|
const business = await this.requireOwnedBusiness(actor);
|
|
return this.images.upload(business.id, files);
|
|
}
|
|
|
|
async uploadMyLogo(
|
|
variant: 'light' | 'dark',
|
|
file: Express.Multer.File,
|
|
actor: AuthUser,
|
|
): Promise<BusinessEntity> {
|
|
const business = await this.requireOwnedBusiness(actor);
|
|
return this.logos.upload(business.id, variant, file, actor);
|
|
}
|
|
|
|
async removeMyLogo(
|
|
variant: 'light' | 'dark',
|
|
actor: AuthUser,
|
|
): Promise<BusinessEntity> {
|
|
const business = await this.requireOwnedBusiness(actor);
|
|
return this.logos.remove(business.id, variant, actor);
|
|
}
|
|
|
|
async removeImage(
|
|
id: string,
|
|
imageId: string,
|
|
actor: AuthUser,
|
|
): Promise<void> {
|
|
const business = await this.findOne(id);
|
|
this.assertCanManageBusiness(business, actor);
|
|
await this.images.remove(id, imageId);
|
|
}
|
|
|
|
async removeMyImage(imageId: string, actor: AuthUser): Promise<void> {
|
|
const business = await this.requireOwnedBusiness(actor);
|
|
await this.images.remove(business.id, imageId);
|
|
}
|
|
|
|
async setMyCoverImage(
|
|
imageId: string,
|
|
actor: AuthUser,
|
|
): Promise<BusinessImageEntity> {
|
|
const business = await this.requireOwnedBusiness(actor);
|
|
return this.images.setCover(business.id, imageId);
|
|
}
|
|
|
|
private async requireOwnedBusiness(actor: AuthUser): Promise<BusinessEntity> {
|
|
if (actor.role === UserRole.ADMIN) {
|
|
throw new ForbiddenException('Use admin image endpoints for this account');
|
|
}
|
|
if (actor.role !== UserRole.BUSINESS_OWNER) {
|
|
throw new ForbiddenException('Insufficient role');
|
|
}
|
|
|
|
const business = await this.repo.findOne({
|
|
where: { ownerId: actor.id },
|
|
order: { createdAt: 'DESC' },
|
|
});
|
|
if (!business) {
|
|
throw new NotFoundException('No business linked to your account');
|
|
}
|
|
return business;
|
|
}
|
|
|
|
private sortImages(images: BusinessImageEntity[]): BusinessImageEntity[] {
|
|
return [...images].sort((a, b) => {
|
|
if (a.isCover !== b.isCover) {
|
|
return a.isCover ? -1 : 1;
|
|
}
|
|
return a.sortOrder - b.sortOrder;
|
|
});
|
|
}
|
|
|
|
private assertCanManageBusiness(
|
|
business: BusinessEntity,
|
|
actor?: AuthUser,
|
|
): void {
|
|
if (!actor || actor.role === UserRole.ADMIN) {
|
|
return;
|
|
}
|
|
if (
|
|
actor.role !== UserRole.BUSINESS_OWNER ||
|
|
business.ownerId !== actor.id
|
|
) {
|
|
throw new ForbiddenException('You can only manage your own business');
|
|
}
|
|
}
|
|
|
|
private assertCanManageAvailability(
|
|
business: BusinessEntity,
|
|
actor?: AuthUser,
|
|
): void {
|
|
if (!actor || actor.role === UserRole.ADMIN) {
|
|
return;
|
|
}
|
|
if (
|
|
actor.role !== UserRole.BUSINESS_OWNER ||
|
|
business.ownerId !== actor.id
|
|
) {
|
|
throw new ForbiddenException('You can only manage your own business');
|
|
}
|
|
}
|
|
|
|
private async ensureCategoryExists(categoryId: string): Promise<void> {
|
|
const category = await this.categoryRepo.findOne({ where: { id: categoryId } });
|
|
if (!category) {
|
|
throw new NotFoundException('Business category not found');
|
|
}
|
|
}
|
|
|
|
private async attachReviewStats(businesses: BusinessEntity[]): Promise<void> {
|
|
if (!businesses.length) return;
|
|
|
|
const ids = businesses.map((business) => business.id);
|
|
const rows = await this.reviewRepo
|
|
.createQueryBuilder('review')
|
|
.select('review.businessId', 'businessId')
|
|
.addSelect('AVG(review.rating)', 'averageRating')
|
|
.addSelect('COUNT(review.id)', 'reviewCount')
|
|
.where('review.businessId IN (:...ids)', { ids })
|
|
.groupBy('review.businessId')
|
|
.getRawMany<{
|
|
businessId: string;
|
|
averageRating: string;
|
|
reviewCount: string;
|
|
}>();
|
|
|
|
const statsById = new Map(
|
|
rows.map((row) => [
|
|
row.businessId,
|
|
{
|
|
averageRating: Number.parseFloat(row.averageRating),
|
|
reviewCount: Number.parseInt(row.reviewCount, 10),
|
|
},
|
|
]),
|
|
);
|
|
|
|
for (const business of businesses) {
|
|
const stats = statsById.get(business.id);
|
|
(business as BusinessEntity & {
|
|
averageRating?: number | null;
|
|
reviewCount?: number;
|
|
}).averageRating = stats?.averageRating ?? null;
|
|
(business as BusinessEntity & { reviewCount?: number }).reviewCount =
|
|
stats?.reviewCount ?? 0;
|
|
}
|
|
}
|
|
|
|
private assertCanUpdateBusiness(
|
|
business: BusinessEntity,
|
|
payload: UpdateBusinessDto,
|
|
actor?: AuthUser,
|
|
): void {
|
|
if (!actor || actor.role === UserRole.ADMIN) {
|
|
return;
|
|
}
|
|
|
|
if (
|
|
actor.role !== UserRole.BUSINESS_OWNER ||
|
|
business.ownerId !== actor.id
|
|
) {
|
|
throw new ForbiddenException('You can only manage your own business');
|
|
}
|
|
|
|
if (
|
|
payload.ownerId !== undefined ||
|
|
payload.categoryId !== undefined ||
|
|
payload.isActive !== undefined
|
|
) {
|
|
throw new ForbiddenException(
|
|
'Only the super admin can change owner, category, or active status',
|
|
);
|
|
}
|
|
}
|
|
}
|