A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.
// 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;
}