Fix: Adding #username to subscription link option

src/common/utils/templates/replace-templates-values.ts

@@ -25,7 +25,7 @@ export class TemplateEngine {
         return hasReplacement ? result : template;
     }
 
-    static formatWithUser(template: string, user: UserEntity, subPublicDomain: string): string {
+    static formatWithUser(template: string, user: UserEntity, subscriptionLink: string): string {
         return this.replace(template, {
             DAYS_LEFT: Math.max(0, dayjs(user.expireAt).diff(dayjs(), 'day')),
             TRAFFIC_USED: prettyBytesUtil(user.usedTrafficBytes, true, 3),
@@ -35,7 +35,7 @@ export class TemplateEngine {
             USERNAME: user.username,
             EMAIL: user.email || '',
             TELEGRAM_ID: user.telegramId?.toString() || '',
-            SUBSCRIPTION_URL: `https://${subPublicDomain}/${user.shortUuid}`,
+            SUBSCRIPTION_URL: subscriptionLink,
             TAG: user.tag || '',
         });
     }

src/modules/hosts/index.ts

@@ -1,5 +1,5 @@
-export * from './entities/hosts.entity';
 export * from './controllers/hosts.controller';
+export * from './entities/hosts.entity';
 export * from './hosts.module';
 export * from './hosts.service';
 export * from './repositories/hosts.repository';

src/modules/subscription-template/generators/format-hosts.service.ts

@@ -7,12 +7,12 @@ import { QueryBus } from '@nestjs/cqrs';
 
 import {
     HttpUpgradeObject,
+    RawObject,
     StreamSettingsObject,
     TcpObject,
     WebSocketObject,
     xHttpObject,
 } from '@common/helpers/xray-config/interfaces/transport.config';
-import { RawObject } from '@common/helpers/xray-config/interfaces/transport.config';
 import { TemplateEngine } from '@common/utils/templates/replace-templates-values';
 import { resolveInboundAndPublicKey } from '@common/helpers/xray-config';
 import { ICommandResponse } from '@common/types/command-response.type';
@@ -22,6 +22,7 @@ import { SECURITY_LAYERS, USERS_STATUS } from '@libs/contracts/constants';
 
 import { SubscriptionSettingsEntity } from '@modules/subscription-settings/entities/subscription-settings.entity';
 import { GetSubscriptionSettingsQuery } from '@modules/subscription-settings/queries/get-subscription-settings';
+import { resolveSubscriptionUrl } from '@modules/subscription/utils/resolve-subscription-url';
 import { HostWithRawInbound } from '@modules/hosts/entities/host-with-inbound-tag.entity';
 import { UserEntity } from '@modules/users/entities';
 
@@ -49,12 +50,20 @@ export class FormatHostsService {
 
         let specialRemarks: string[] = [];
 
-        if (user.status !== USERS_STATUS.ACTIVE) {
-            const settings = await this.getSubscriptionSettings();
-            if (!settings) {
-                return formattedHosts;
-            }
+        const settings = await this.getSubscriptionSettings();
 
+        if (!settings) {
+            return formattedHosts;
+        }
+
+        const subscriptionUrl = resolveSubscriptionUrl(
+            user.shortUuid,
+            user.username,
+            settings?.addUsernameToBaseSubscription,
+            this.subPublicDomain,
+        );
+
+        if (user.status !== USERS_STATUS.ACTIVE) {
             if (settings.isShowCustomRemarks) {
                 switch (user.status) {
                     case USERS_STATUS.EXPIRED:
@@ -69,7 +78,7 @@ export class FormatHostsService {
                 }
 
                 const templatedRemarks = specialRemarks.map((remark) =>
-                    TemplateEngine.formatWithUser(remark, user, this.subPublicDomain),
+                    TemplateEngine.formatWithUser(remark, user, subscriptionUrl),
                 );
 
                 formattedHosts.push(...this.createFallbackHosts(templatedRemarks));
@@ -109,11 +118,7 @@ export class FormatHostsService {
         const knownRemarks = new Map<string, number>();
 
         for (const inputHost of hosts) {
-            const remark = TemplateEngine.formatWithUser(
-                inputHost.remark,
-                user,
-                this.subPublicDomain,
-            );
+            const remark = TemplateEngine.formatWithUser(inputHost.remark, user, subscriptionUrl);
 
             const currentCount = knownRemarks.get(remark) || 0;
             knownRemarks.set(remark, currentCount + 1);

src/modules/subscription/queries/get-subscription-url/get-subscription-url.handler.ts

@@ -0,0 +1,18 @@
+import { IQueryHandler, QueryHandler } from '@nestjs/cqrs';
+
+import { ICommandResponse } from '@common/types/command-response.type';
+
+import { SubscriptionService } from '@modules/subscription/subscription.service';
+
+import { GetSubscriptionUrlQuery } from './get-subscription-url.query';
+
+@QueryHandler(GetSubscriptionUrlQuery)
+export class GetSubscriptionUrlHandler
+    implements IQueryHandler<GetSubscriptionUrlQuery, ICommandResponse<string>>
+{
+    constructor(private readonly subscriptionService: SubscriptionService) {}
+
+    async execute(query: GetSubscriptionUrlQuery): Promise<ICommandResponse<string>> {
+        return this.subscriptionService.getSubscriptionUrl(query.userShortUuid, query.username);
+    }
+}

src/modules/subscription/queries/get-subscription-url/get-subscription-url.query.ts

@@ -0,0 +1,6 @@
+export class GetSubscriptionUrlQuery {
+    constructor(
+        public readonly userShortUuid: string,
+        public readonly username: string,
+    ) {}
+}

src/modules/subscription/queries/get-subscription-url/index.ts

@@ -0,0 +1,2 @@
+export * from './get-subscription-url.handler';
+export * from './get-subscription-url.query';

src/modules/subscription/queries/get-users-subscription-url/get-users-subscription-url.handler.ts

@@ -0,0 +1,20 @@
+import { IQueryHandler, QueryHandler } from '@nestjs/cqrs';
+
+import { ICommandResponse } from '@common/types/command-response.type';
+
+import { SubscriptionService } from '@modules/subscription/subscription.service';
+
+import { GetUsersSubscriptionUrlQuery } from './get-users-subscription-url.query';
+
+@QueryHandler(GetUsersSubscriptionUrlQuery)
+export class GetUsersSubscriptionUrlHandler
+    implements IQueryHandler<GetUsersSubscriptionUrlQuery, ICommandResponse<Record<string, string>>>
+{
+    constructor(private readonly subscriptionService: SubscriptionService) {}
+
+    async execute(
+        query: GetUsersSubscriptionUrlQuery,
+    ): Promise<ICommandResponse<Record<string, string>>> {
+        return this.subscriptionService.getUsersSubscriptionUrl(query.users);
+    }
+}

src/modules/subscription/queries/get-users-subscription-url/get-users-subscription-url.query.ts

@@ -0,0 +1,5 @@
+import { UserEntity } from '@modules/users/entities';
+
+export class GetUsersSubscriptionUrlQuery {
+    constructor(public readonly users: Pick<UserEntity, 'shortUuid' | 'username'>[]) {}
+}

src/modules/subscription/queries/get-users-subscription-url/index.ts

@@ -0,0 +1,2 @@
+export * from './get-users-subscription-url.handler';
+export * from './get-users-subscription-url.query';

src/modules/subscription/queries/index.ts

@@ -0,0 +1,4 @@
+import { GetUsersSubscriptionUrlHandler } from './get-users-subscription-url';
+import { GetSubscriptionUrlHandler } from './get-subscription-url';
+
+export const QUERIES = [GetSubscriptionUrlHandler, GetUsersSubscriptionUrlHandler];

src/modules/subscription/subscription.module.ts

@@ -4,14 +4,15 @@ import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { CqrsModule } from '@nestjs/cqrs';
 
 import { SubscriptionTemplateModule } from '@modules/subscription-template/subscription-template.module';
+import { QUERIES } from '@modules/subscription/queries';
 
 import { SubscriptionController, SubscriptionsController } from './controllers';
 import { SubscriptionService } from './subscription.service';
 
 @Module({
     imports: [CqrsModule, SubscriptionTemplateModule],
     controllers: [SubscriptionController, SubscriptionsController],
-    providers: [SubscriptionService],
+    providers: [SubscriptionService, ...QUERIES],
     exports: [],
 })
 export class SubscriptionModule implements NestModule {

src/modules/subscription/subscription.service.ts

@@ -37,6 +37,7 @@ import { RenderTemplatesService } from '@modules/subscription-template/render-te
 import { CountUsersDevicesQuery } from '@modules/hwid-user-devices/queries/count-users-devices';
 import { IFormattedHost, IRawHost } from '@modules/subscription-template/generators/interfaces';
 import { GetUsersWithPaginationQuery } from '@modules/users/queries/get-users-with-pagination';
+import { resolveSubscriptionUrl } from '@modules/subscription/utils/resolve-subscription-url';
 import { CheckHwidExistsQuery } from '@modules/hwid-user-devices/queries/check-hwid-exists';
 import { GetUserByUniqueFieldQuery } from '@modules/users/queries/get-user-by-unique-field';
 import { UserEntity } from '@modules/users/entities/user.entity';
@@ -273,6 +274,13 @@ export class SubscriptionService {
                 };
             }
 
+            const subscriptionUrl = resolveSubscriptionUrl(
+                user.response.shortUuid,
+                user.response.username,
+                settingEntity.addUsernameToBaseSubscription,
+                this.subPublicDomain,
+            );
+
             let isHwidLimited: boolean | undefined;
 
             const headers = await this.getUserProfileHeadersInfo(
@@ -332,7 +340,7 @@ export class SubscriptionService {
             return {
                 isOk: true,
                 response: new RawSubscriptionWithHostsResponse({
-                    user: new GetUserResponseModel(user.response, this.subPublicDomain),
+                    user: new GetUserResponseModel(user.response, subscriptionUrl),
                     convertedUserInfo: {
                         daysLeft: dayjs(user.response.expireAt).diff(dayjs(), 'day'),
                         trafficUsed: prettyBytesUtil(user.response.usedTrafficBytes),
@@ -517,10 +525,11 @@ export class SubscriptionService {
         ssConfLinks: Record<string, string>,
         settingEntity: SubscriptionSettingsEntity,
     ): Promise<SubscriptionRawResponse> {
-        const subscriptionUrl = this.resolveSubscriptionUrl(
+        const subscriptionUrl = resolveSubscriptionUrl(
             user.shortUuid,
             user.username,
             settingEntity.addUsernameToBaseSubscription,
+            this.subPublicDomain,
         );
 
         return new SubscriptionRawResponse({
@@ -677,6 +686,58 @@ export class SubscriptionService {
         }
     }
 
+    public async getSubscriptionUrl(
+        userShortUuid: string,
+        username: string,
+    ): Promise<ICommandResponse<string>> {
+        const settingEntity = await this.getCachedSubscriptionSettings();
+
+        if (!settingEntity) {
+            return {
+                isOk: false,
+                ...ERRORS.INTERNAL_SERVER_ERROR,
+            };
+        }
+
+        return {
+            isOk: true,
+            response: resolveSubscriptionUrl(
+                userShortUuid,
+                username,
+                settingEntity.addUsernameToBaseSubscription,
+                this.subPublicDomain,
+            ),
+        };
+    }
+
+    public async getUsersSubscriptionUrl(
+        users: Pick<UserEntity, 'shortUuid' | 'username'>[],
+    ): Promise<ICommandResponse<Record<string, string>>> {
+        const settingEntity = await this.getCachedSubscriptionSettings();
+
+        if (!settingEntity) {
+            return {
+                isOk: false,
+                ...ERRORS.INTERNAL_SERVER_ERROR,
+            };
+        }
+
+        const linksEntries = users.map((user) => [
+            user.shortUuid,
+            resolveSubscriptionUrl(
+                user.shortUuid,
+                user.username,
+                settingEntity.addUsernameToBaseSubscription,
+                this.subPublicDomain,
+            ),
+        ]);
+
+        return {
+            isOk: true,
+            response: Object.fromEntries(linksEntries),
+        };
+    }
+
     private async generateSsConfLinks(
         subscriptionShortUuid: string,
         formattedHosts: IFormattedHost[],
@@ -703,11 +764,18 @@ export class SubscriptionService {
         isHapp: boolean,
         settings: SubscriptionSettingsEntity,
     ): Promise<ISubscriptionHeaders> {
+        const subscriptionLink = resolveSubscriptionUrl(
+            user.shortUuid,
+            user.username,
+            settings.addUsernameToBaseSubscription,
+            this.subPublicDomain,
+        );
+
         const headers: ISubscriptionHeaders = {
             'content-disposition': `attachment; filename=${user.username}`,
             'support-url': settings.supportLink,
             'profile-title': `base64:${Buffer.from(
-                TemplateEngine.formatWithUser(settings.profileTitle, user, this.subPublicDomain),
+                TemplateEngine.formatWithUser(settings.profileTitle, user, subscriptionLink),
             ).toString('base64')}`,
             'profile-update-interval': settings.profileUpdateInterval.toString(),
             'subscription-userinfo': Object.entries(getSubscriptionUserInfo(user))
@@ -717,7 +785,7 @@ export class SubscriptionService {
 
         if (settings.happAnnounce) {
             headers.announce = `base64:${Buffer.from(
-                TemplateEngine.formatWithUser(settings.happAnnounce, user, this.subPublicDomain),
+                TemplateEngine.formatWithUser(settings.happAnnounce, user, subscriptionLink),
             ).toString('base64')}`;
         }
 
@@ -726,11 +794,7 @@ export class SubscriptionService {
         }
 
         if (settings.isProfileWebpageUrlEnabled && !this.hwidDeviceLimitEnabled) {
-            headers['profile-web-page-url'] = this.resolveSubscriptionUrl(
-                user.shortUuid,
-                user.username,
-                settings.addUsernameToBaseSubscription,
-            );
+            headers['profile-web-page-url'] = subscriptionLink;
         }
 
         const refillDate = getSubscriptionRefillDate(user.trafficLimitStrategy);
@@ -740,7 +804,7 @@ export class SubscriptionService {
 
         if (settings.customResponseHeaders) {
             for (const [key, value] of Object.entries(settings.customResponseHeaders)) {
-                headers[key] = TemplateEngine.formatWithUser(value, user, this.subPublicDomain);
+                headers[key] = TemplateEngine.formatWithUser(value, user, subscriptionLink);
             }
         }
 
@@ -946,18 +1010,6 @@ export class SubscriptionService {
         }
     }
 
-    private resolveSubscriptionUrl(
-        shortUuid: string,
-        username: string,
-        addUsernameToBaseSubscription: boolean,
-    ): string {
-        if (addUsernameToBaseSubscription) {
-            return `https://${this.subPublicDomain}/${shortUuid}#${username}`;
-        }
-
-        return `https://${this.subPublicDomain}/${shortUuid}`;
-    }
-
     private async updateAndReportSubscriptionRequest(
         userUuid: string,
         userAgent: string,

src/modules/subscription/utils/resolve-subscription-url.ts

@@ -0,0 +1,12 @@
+export const resolveSubscriptionUrl = (
+    shortUuid: string,
+    username: string,
+    addUsernameToBaseSubscription: boolean,
+    subPublicDomain: string,
+): string => {
+    if (addUsernameToBaseSubscription) {
+        return `https://${subPublicDomain}/${shortUuid}#${username}`;
+    }
+
+    return `https://${subPublicDomain}/${shortUuid}`;
+};