Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
8.5 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import {Config} from '@app/api/Config';
import type {UserRow} from '@app/api/database/types/UserTypes';
import {getCachedInstancePremiumMode} from '@app/api/limits/InstancePremiumModeCache';
import type {User} from '@app/api/models/User';
import {isEnforcementReasonCode} from '@fluxer/constants/src/EnforcementReasons';
import {
	DELETED_USER_DISCRIMINATOR,
	DELETED_USER_GLOBAL_NAME,
	DELETED_USER_USERNAME,
	PREMIUM_GRACE_PERIOD_DAYS,
	PREMIUM_PAYMENT_RECOVERY_GRACE_DAYS,
	PremiumFlags,
	ProfileFieldPrivacyFlags,
	UserFlags,
	type UserPremiumType,
	UserPremiumTypes,
} from '@fluxer/constants/src/UserConstants';
import {MS_PER_DAY} from '@fluxer/date_utils/src/DateConstants';
import {snowflakeToDate} from '@fluxer/snowflake/src/Snowflake';

export function isSsoUserWithoutPassword(user: Pick<User, 'traits' | 'passwordHash'>): boolean {
	return user.passwordHash === null && user.traits.has('sso');
}

export function isSsoLinkedUser(user: Pick<User, 'traits'>): boolean {
	return user.traits.has('sso');
}

export function isEnforcementDeletion(user: Pick<User, 'enforcementDecisionId' | 'deletionReasonCode'>): boolean {
	return user.enforcementDecisionId !== null || isEnforcementReasonCode(user.deletionReasonCode);
}

export function isAccountClosed(user: Pick<User, 'flags' | 'deletionStartedAt'>): boolean {
	return (user.flags & UserFlags.DELETED) !== 0n || user.deletionStartedAt != null;
}

export function isDeletionComplete(user: Pick<User, 'flags' | 'pendingDeletionAt'>): boolean {
	return (user.flags & UserFlags.DELETED) !== 0n && user.pendingDeletionAt === null;
}

const FIELDS_CLEARED_ON_DELETION = [
	'email',
	'email_bounced',
	'password_hash',
	'password_last_changed_at',
	'totp_secret',
	'authenticator_types',
	'avatar_hash',
	'avatar_color',
	'banner_hash',
	'banner_color',
	'bio',
	'pronouns',
	'accent_color',
	'timezone',
	'date_of_birth',
	'locale',
	'premium_flags',
	'hidden_profile_badges',
	'premium_type',
	'premium_since',
	'premium_until',
	'premium_gift_extension_ends_at',
	'premium_will_cancel',
	'premium_billing_cycle',
	'premium_lifetime_sequence',
	'premium_grace_ends_at',
	'stripe_subscription_id',
	'stripe_customer_id',
	'has_ever_purchased',
	'terms_agreed_at',
	'privacy_agreed_at',
	'last_active_at',
	'last_active_ip',
	'acls',
	'traits',
	'first_refund_at',
	'gift_inventory_server_seq',
	'gift_inventory_client_seq',
	'premium_onboarding_dismissed_at',
	'mention_flags',
	'last_voice_activity_sharing_change_at',
] as const satisfies ReadonlyArray<keyof UserRow>;

export function deletedUserIdentity() {
	return {
		username: DELETED_USER_USERNAME,
		discriminator: DELETED_USER_DISCRIMINATOR,
		global_name: DELETED_USER_GLOBAL_NAME,
		email_verified: false,
		timezone_privacy_flags: ProfileFieldPrivacyFlags.EVERYONE,
		flags: UserFlags.DELETED,
	} satisfies Partial<UserRow>;
}

export function personalFieldsToClear(row: UserRow): Partial<UserRow> {
	const patch: Partial<UserRow> = {};
	for (const field of FIELDS_CLEARED_ON_DELETION) {
		const value = row[field];
		if (!value || (value instanceof Set && value.size === 0)) continue;
		patch[field] = null;
	}
	return patch;
}

export function isTemporarilyBanned(user: Pick<User, 'flags' | 'tempBannedUntil'>, now = Date.now()): boolean {
	return (
		(user.flags & UserFlags.DISABLED) !== 0n && user.tempBannedUntil != null && user.tempBannedUntil.getTime() > now
	);
}

export function isAccountDisabled(user: Pick<User, 'flags' | 'tempBannedUntil'>, now = Date.now()): boolean {
	if ((user.flags & UserFlags.DISABLED) === 0n) return false;
	return user.tempBannedUntil == null || user.tempBannedUntil.getTime() > now;
}

export function isHeldByDecision(
	user: Pick<User, 'flags' | 'deletionStartedAt' | 'tempBannedUntil' | 'enforcementDecisionId'>,
): boolean {
	return user.enforcementDecisionId !== null && isSignInRefused(user);
}

export function isSignInRefused(user: Pick<User, 'flags' | 'deletionStartedAt' | 'tempBannedUntil'>): boolean {
	return isAccountClosed(user) || isTemporarilyBanned(user);
}

export function canOwnerRunBots(owner: Pick<User, 'flags' | 'deletionStartedAt' | 'tempBannedUntil'>): boolean {
	return !isAccountClosed(owner) && !isAccountDisabled(owner);
}

export function isContentHidden(user: Pick<User, 'contentHiddenSince'>, messageId: bigint): boolean {
	return user.contentHiddenSince !== null && snowflakeToDate(messageId) >= user.contentHiddenSince;
}

export function isDirectDeliverySuppressed(user: Pick<User, 'isBot' | 'flags'>): boolean {
	return !user.isBot && (user.flags & UserFlags.SPAMMER) === UserFlags.SPAMMER;
}

interface PremiumCheckable {
	isBot: boolean;
	premiumType: number | null;
	premiumUntil: Date | null;
	premiumGiftExtensionEndsAt: Date | null;

	premiumGraceEndsAt: Date | null;
	flags: bigint;
	premiumFlags: number;
}

export const PREMIUM_GRACE_PERIOD_MS = PREMIUM_GRACE_PERIOD_DAYS * MS_PER_DAY;

export function getPremiumPaymentRecoveryGraceMs(billingCycle: string | null | undefined): number {
	const days =
		billingCycle === 'yearly'
			? PREMIUM_PAYMENT_RECOVERY_GRACE_DAYS.yearly
			: PREMIUM_PAYMENT_RECOVERY_GRACE_DAYS.monthly;
	return days * MS_PER_DAY;
}

export function getEffectivePremiumUntil(
	user: Pick<PremiumCheckable, 'premiumUntil' | 'premiumGiftExtensionEndsAt'>,
): Date | null {
	const subUntil = user.premiumUntil?.getTime() ?? null;
	const giftUntil = user.premiumGiftExtensionEndsAt?.getTime() ?? null;
	if (subUntil == null && giftUntil == null) {
		return null;
	}
	const effectiveMs = Math.max(subUntil ?? 0, giftUntil ?? 0);
	return new Date(effectiveMs);
}

export function getPaidPremiumAccessEndsAt(
	user: Pick<PremiumCheckable, 'premiumUntil' | 'premiumGiftExtensionEndsAt' | 'premiumGraceEndsAt'>,
): Date | null {
	const effective = getEffectivePremiumUntil(user);
	if (effective == null) {
		return null;
	}
	const graceEndsMs = user.premiumGraceEndsAt?.getTime() ?? effective.getTime() + PREMIUM_GRACE_PERIOD_MS;
	return new Date(Math.max(effective.getTime(), graceEndsMs));
}

export function checkHasActivePaidPremium(
	user: Pick<PremiumCheckable, 'premiumType' | 'premiumUntil' | 'premiumGiftExtensionEndsAt' | 'premiumGraceEndsAt'>,
): boolean {
	if (user.premiumType == null || user.premiumType <= 0) {
		return false;
	}
	const endsAt = getPaidPremiumAccessEndsAt(user);
	return endsAt == null || Date.now() <= endsAt.getTime();
}

export function checkIsPremium(user: PremiumCheckable): boolean {
	if (Config.instance.selfHosted && getCachedInstancePremiumMode() === 'everyone') {
		return true;
	}
	if (user.isBot) {
		return true;
	}
	if ((user.premiumFlags & PremiumFlags.PERKS_DISABLED) !== 0) {
		return false;
	}
	if ((user.premiumFlags & PremiumFlags.ENABLED_OVERRIDE) !== 0) {
		return true;
	}
	if (checkHasActivePaidPremium(user)) {
		return true;
	}
	return false;
}

export function getBadgePremiumType(
	user: Pick<PremiumCheckable, 'premiumType' | 'premiumFlags'>,
): UserPremiumType | undefined {
	if (user.premiumType != null && user.premiumType !== UserPremiumTypes.NONE) {
		return user.premiumType as UserPremiumType;
	}
	if (
		(user.premiumFlags & (PremiumFlags.ENABLED_OVERRIDE | PremiumFlags.PERKS_DISABLED)) ===
		PremiumFlags.ENABLED_OVERRIDE
	) {
		return UserPremiumTypes.SUBSCRIPTION;
	}
	return undefined;
}

const PREMIUM_CLEAR_FIELDS = [
	'premium_type',
	'premium_since',
	'premium_until',
	'premium_gift_extension_ends_at',
	'premium_will_cancel',
	'premium_billing_cycle',
	'premium_grace_ends_at',
] as const;

type PremiumClearField = (typeof PREMIUM_CLEAR_FIELDS)[number];

export function shouldStripExpiredPremium(user: PremiumCheckable): boolean {
	if ((user.premiumType ?? 0) <= 0) {
		return false;
	}
	return !checkHasActivePaidPremium(user);
}

function mapExpiredPremiumFields<T>(mapper: (field: PremiumClearField) => T): Record<PremiumClearField, T> {
	const result = {} as Record<PremiumClearField, T>;
	for (const field of PREMIUM_CLEAR_FIELDS) {
		result[field] = mapper(field);
	}
	return result;
}

export function createPremiumClearPatch(): Partial<UserRow> {
	return mapExpiredPremiumFields(() => null) as Partial<UserRow>;
}

export function clearPerksSanitizedFlag(premiumFlags: number): number {
	return premiumFlags & ~PremiumFlags.PERKS_SANITIZED;
}

const PROFILE_SUBSTRING_EXEMPT_FLAGS = UserFlags.STAFF;

export function isProfileSubstringExempt(user: Pick<PremiumCheckable, 'flags'>): boolean {
	return (user.flags & PROFILE_SUBSTRING_EXEMPT_FLAGS) !== 0n;
}

export function isBugHunterBotUser(user: Pick<User, 'flags' | 'isBot'>): boolean {
	return user.isBot && (user.flags & UserFlags.BUG_HUNTER) !== 0n;
}