@purpleschool/gptbot 0.12.45 → 0.12.47

package/api/controllers/http/team-account.ts

@@ -20,6 +20,7 @@ export const TEAM_ACCOUNT_ROUTES = {
     GET_STATISTICS_OVERVIEW: 'statistics/overview',
     GET_STATISTICS_BY_MONTH: 'statistics/by-month',
     CREATE_MANUAL_SUBSCRIPTION: 'manual/subscription',
+    CREATE_MANUAL_SUBSCRIPTION_UPGRADE: 'manual/subscription/upgrade',
     CREATE_MANUAL_PRODUCT: 'manual/product',
     CREATE_INVOICE_PAYMENT: 'invoice-payment',
     ADMIN_FIND_BY_NAME: 'admin/find',

package/api/routes.ts

@@ -211,6 +211,7 @@ export const REST_API = {
         CANCEL_TRIAL_SUBSCRIPTION: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CANCEL_TRIAL_SUBSCRIPTION}`,
         GET_BALANCE: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.GET_BALANCE}`,
         CREATE_MANUAL_SUBSCRIPTION: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_SUBSCRIPTION}`,
+        CREATE_MANUAL_SUBSCRIPTION_UPGRADE: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_SUBSCRIPTION_UPGRADE}`,
         CREATE_MANUAL_PRODUCT: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_PRODUCT}`,
         CREATE_INVOICE_PAYMENT: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_INVOICE_PAYMENT}`,
         ADMIN_FIND_BY_NAME: `${ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.ADMIN_FIND_BY_NAME}`,

package/build/api/controllers/http/team-account.js

@@ -22,6 +22,7 @@ exports.TEAM_ACCOUNT_ROUTES = {
     GET_STATISTICS_OVERVIEW: 'statistics/overview',
     GET_STATISTICS_BY_MONTH: 'statistics/by-month',
     CREATE_MANUAL_SUBSCRIPTION: 'manual/subscription',
+    CREATE_MANUAL_SUBSCRIPTION_UPGRADE: 'manual/subscription/upgrade',
     CREATE_MANUAL_PRODUCT: 'manual/product',
     CREATE_INVOICE_PAYMENT: 'invoice-payment',
     ADMIN_FIND_BY_NAME: 'admin/find',

package/build/api/routes.js

@@ -207,6 +207,7 @@ exports.REST_API = {
         CANCEL_TRIAL_SUBSCRIPTION: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CANCEL_TRIAL_SUBSCRIPTION}`,
         GET_BALANCE: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.GET_BALANCE}`,
         CREATE_MANUAL_SUBSCRIPTION: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_SUBSCRIPTION}`,
+        CREATE_MANUAL_SUBSCRIPTION_UPGRADE: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_SUBSCRIPTION_UPGRADE}`,
         CREATE_MANUAL_PRODUCT: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_MANUAL_PRODUCT}`,
         CREATE_INVOICE_PAYMENT: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.CREATE_INVOICE_PAYMENT}`,
         ADMIN_FIND_BY_NAME: `${exports.ROOT}/${CONTROLLERS.TEAM_ACCOUNT_CONTROLLER}/${CONTROLLERS.TEAM_ACCOUNT_ROUTES.ADMIN_FIND_BY_NAME}`,

package/build/commands/subscription/get-available-upgrades.command.js

@@ -2,12 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetAvailableUpgradesCommand = void 0;
 const zod_1 = require("zod");
+const constants_1 = require("../../constants");
 const models_1 = require("../../models");
 const subscription_upgrade_schema_1 = require("../../models/subscription-upgrade-schema");
 const subscription_feature_schema_1 = require("../../models/subscription-feature.schema");
 var GetAvailableUpgradesCommand;
 (function (GetAvailableUpgradesCommand) {
     GetAvailableUpgradesCommand.RequestSchema = models_1.SubscriptionSchema.pick({});
+    GetAvailableUpgradesCommand.RequestQuerySchema = zod_1.z.object({
+        billingScope: zod_1.z.nativeEnum(constants_1.BILLING_SCOPE).default(constants_1.BILLING_SCOPE.USER),
+    });
     GetAvailableUpgradesCommand.ResponseSchema = zod_1.z.object({
         features: zod_1.z.record(zod_1.z.string().uuid(), zod_1.z.array(subscription_feature_schema_1.SubscriptionFeatureSchema)),
         subscriptions: zod_1.z.array(subscription_upgrade_schema_1.SubscriptionUpgradeSchema),

package/build/commands/subscription/upgrade-subscription.command.js

@@ -10,6 +10,7 @@ var UpgradeSubscriptionCommand;
         upgradeSubscriptionId: zod_1.z.string().uuid(),
         promocode: zod_1.z.string().optional(),
         provider: zod_1.z.nativeEnum(constants_1.PAYMENT_PROVIDER).optional().default(constants_1.PAYMENT_PROVIDER.CLOUDPAYMENTS),
+        billingScope: zod_1.z.nativeEnum(constants_1.BILLING_SCOPE).default(constants_1.BILLING_SCOPE.USER),
     });
     UpgradeSubscriptionCommand.RequestParamSchema = models_1.UserToSubscriptionSchema.pick({
         uuid: true,

package/build/commands/team-account/create-manual-team-subscription-upgrade.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateManualTeamSubscriptionUpgradeCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../models");
+var CreateManualTeamSubscriptionUpgradeCommand;
+(function (CreateManualTeamSubscriptionUpgradeCommand) {
+    CreateManualTeamSubscriptionUpgradeCommand.RequestSchema = zod_1.z.object({
+        teamAccountId: zod_1.z.string().uuid(),
+        subscriptionId: zod_1.z.string().uuid(),
+        durationMonths: zod_1.z.number().int().min(1).max(36).optional(),
+        upgradeFromSubscriptionId: zod_1.z.string().uuid(),
+    });
+    CreateManualTeamSubscriptionUpgradeCommand.ResponseSchema = zod_1.z.object({
+        data: models_1.TeamToSubscriptionSchema,
+    });
+})(CreateManualTeamSubscriptionUpgradeCommand || (exports.CreateManualTeamSubscriptionUpgradeCommand = CreateManualTeamSubscriptionUpgradeCommand = {}));

package/build/commands/team-account/create-team-account-invoice-payment.command.js

@@ -12,9 +12,13 @@ var CreateTeamAccountInvoicePaymentCommand;
         amount: zod_1.z.number().positive(),
         subscriptionUuid: zod_1.z.string().uuid().optional(),
         productUuid: zod_1.z.string().uuid().optional(),
+        upgradeSubscriptionUuid: zod_1.z.string().uuid().optional(),
     })
-        .refine(({ subscriptionUuid, productUuid }) => Number(Boolean(subscriptionUuid)) + Number(Boolean(productUuid)) === 1, {
-        message: 'Нужно передать ровно один идентификатор: subscriptionUuid или productUuid',
+        .refine(({ subscriptionUuid, productUuid, upgradeSubscriptionUuid }) => Number(Boolean(subscriptionUuid)) +
+        Number(Boolean(productUuid)) +
+        Number(Boolean(upgradeSubscriptionUuid)) ===
+        1, {
+        message: 'Нужно передать ровно один идентификатор: subscriptionUuid, productUuid или upgradeSubscriptionUuid',
     });
     CreateTeamAccountInvoicePaymentCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.object({

package/build/commands/team-account/find-team-accounts-by-name.command.js

@@ -3,12 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FindTeamAccountsByNameCommand = void 0;
 const zod_1 = require("zod");
 const models_1 = require("../../models");
+const constants_1 = require("../../constants");
 var FindTeamAccountsByNameCommand;
 (function (FindTeamAccountsByNameCommand) {
     FindTeamAccountsByNameCommand.RequestSchema = zod_1.z.object({
         name: zod_1.z.string().trim().min(1).optional(),
         limit: zod_1.z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: zod_1.z.coerce.number().int().min(0).default(0).optional(),
+        sortBy: zod_1.z
+            .nativeEnum(constants_1.TEAM_ACCOUNT_ADMIN_SORT_BY)
+            .default(constants_1.TEAM_ACCOUNT_ADMIN_SORT_BY.CREATED_AT)
+            .optional(),
+        sortOrder: zod_1.z.nativeEnum(constants_1.SORT_ORDER).default(constants_1.SORT_ORDER.DESC).optional(),
     });
     FindTeamAccountsByNameCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.array(models_1.TeamAccountWithBalanceSchema),

package/build/commands/team-account/get-invoice-for-payment.command.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetInvoiceForPaymentCommand = void 0;
 const zod_1 = require("zod");
 const models_1 = require("../../models");
+const constants_1 = require("../../constants");
 var GetInvoiceForPaymentCommand;
 (function (GetInvoiceForPaymentCommand) {
     GetInvoiceForPaymentCommand.RequestQuerySchema = zod_1.z.object({
@@ -15,6 +16,11 @@ var GetInvoiceForPaymentCommand;
         dateTo: zod_1.z.coerce.date().optional(),
         limit: zod_1.z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: zod_1.z.coerce.number().int().min(0).default(0).optional(),
+        sortBy: zod_1.z
+            .nativeEnum(constants_1.INVOICE_FOR_PAYMENT_SORT_BY)
+            .default(constants_1.INVOICE_FOR_PAYMENT_SORT_BY.CREATED_AT)
+            .optional(),
+        sortOrder: zod_1.z.nativeEnum(constants_1.SORT_ORDER).default(constants_1.SORT_ORDER.DESC).optional(),
     });
     GetInvoiceForPaymentCommand.ResponseSchema = zod_1.z.object({
         data: zod_1.z.array(models_1.InvoiceForPaymentSchema),

package/build/commands/team-account/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./get-team-account-statistics-overview.command"), exports)
 __exportStar(require("./get-team-account-statistics-by-month.command"), exports);
 __exportStar(require("./get-team-account-balance.command"), exports);
 __exportStar(require("./create-manual-team-subscription.command"), exports);
+__exportStar(require("./create-manual-team-subscription-upgrade.command"), exports);
 __exportStar(require("./create-manual-team-product.command"), exports);
 __exportStar(require("./find-team-accounts-by-name.command"), exports);
 __exportStar(require("./find-team-account-by-uuid.command"), exports);

package/build/commands/team-to-subscription/add-team-to-subscription.command.js

@@ -11,6 +11,7 @@ var AddTeamToSubscriptionCommand;
         cloudPaymentsSubscriptionId: zod_1.z.string().optional(),
         zenpaymentsInvoiceNumber: zod_1.z.string().optional(),
         startDate: zod_1.z.coerce.date().optional(),
+        upgradedFromSubscriptionId: zod_1.z.string().uuid().nullable().optional(),
         downgradedFromTeamSubscriptionId: zod_1.z.string().uuid().nullable().optional(),
         orderId: zod_1.z.string().uuid(),
     });

package/build/commands/team-to-subscription/update-team-to-subscription.command.js

@@ -22,6 +22,7 @@ var UpdateTeamToSubscriptionCommand;
         type: true,
         intervalEndDate: true,
         marks: true,
+        upgradedFromSubscriptionId: true,
         downgradedFromTeamSubscriptionId: true,
         orderId: true,
     }).partial();

package/build/constants/page/enums/page-sort-by.enum.js

@@ -5,4 +5,7 @@ var PAGE_SORT_BY;
 (function (PAGE_SORT_BY) {
     PAGE_SORT_BY["CREATED_AT"] = "createdAt";
     PAGE_SORT_BY["UPDATED_AT"] = "updatedAt";
+    PAGE_SORT_BY["TITLE"] = "title";
+    PAGE_SORT_BY["CATEGORY_NAME"] = "categoryName";
+    PAGE_SORT_BY["CATEGORY_ID"] = "categoryId";
 })(PAGE_SORT_BY || (exports.PAGE_SORT_BY = PAGE_SORT_BY = {}));

package/build/constants/team-account/enums/index.js

@@ -14,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./invoice-for-payment-sort-by.enum"), exports);
 __exportStar(require("./team-account-invite-status.enum"), exports);
+__exportStar(require("./team-account-admin-sort-by.enum"), exports);
 __exportStar(require("./team-account-member-role.enum"), exports);
 __exportStar(require("./team-account-member-status.enum"), exports);
 __exportStar(require("./team-account-operation-type.enum"), exports);

package/build/constants/team-account/enums/invoice-for-payment-sort-by.enum.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVOICE_FOR_PAYMENT_SORT_BY = void 0;
+var INVOICE_FOR_PAYMENT_SORT_BY;
+(function (INVOICE_FOR_PAYMENT_SORT_BY) {
+    INVOICE_FOR_PAYMENT_SORT_BY["INVOICE_NUMBER"] = "invoiceNumber";
+    INVOICE_FOR_PAYMENT_SORT_BY["SUM"] = "sum";
+    INVOICE_FOR_PAYMENT_SORT_BY["CREATED_AT"] = "createdAt";
+    INVOICE_FOR_PAYMENT_SORT_BY["UPDATED_AT"] = "updatedAt";
+    INVOICE_FOR_PAYMENT_SORT_BY["USER_ID"] = "userId";
+    INVOICE_FOR_PAYMENT_SORT_BY["TEAM_ACCOUNT_ID"] = "teamAccountId";
+    INVOICE_FOR_PAYMENT_SORT_BY["ORDER_ID"] = "orderId";
+    INVOICE_FOR_PAYMENT_SORT_BY["PAYMENT_ID"] = "paymentId";
+})(INVOICE_FOR_PAYMENT_SORT_BY || (exports.INVOICE_FOR_PAYMENT_SORT_BY = INVOICE_FOR_PAYMENT_SORT_BY = {}));

package/build/constants/team-account/enums/team-account-admin-sort-by.enum.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TEAM_ACCOUNT_ADMIN_SORT_BY = void 0;
+var TEAM_ACCOUNT_ADMIN_SORT_BY;
+(function (TEAM_ACCOUNT_ADMIN_SORT_BY) {
+    TEAM_ACCOUNT_ADMIN_SORT_BY["NAME"] = "name";
+    TEAM_ACCOUNT_ADMIN_SORT_BY["EMAIL"] = "email";
+    TEAM_ACCOUNT_ADMIN_SORT_BY["CREATED_AT"] = "createdAt";
+    TEAM_ACCOUNT_ADMIN_SORT_BY["UPDATED_AT"] = "updatedAt";
+    TEAM_ACCOUNT_ADMIN_SORT_BY["SUBSCRIPTION_ENDS_AT"] = "subscriptionEndsAt";
+})(TEAM_ACCOUNT_ADMIN_SORT_BY || (exports.TEAM_ACCOUNT_ADMIN_SORT_BY = TEAM_ACCOUNT_ADMIN_SORT_BY = {}));

package/build/models/invoice-for-payment.schema.js

@@ -2,13 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvoiceForPaymentSchema = exports.InvoiceForPaymentPayloadSchema = void 0;
 const zod_1 = require("zod");
-exports.InvoiceForPaymentPayloadSchema = zod_1.z.object({
-    email: zod_1.z.string().email(),
-    name: zod_1.z.string(),
-    inn: zod_1.z.string(),
-    amount: zod_1.z.number(),
-    itemName: zod_1.z.string(),
-});
+exports.InvoiceForPaymentPayloadSchema = zod_1.z.discriminatedUnion('invoiceType', [
+    zod_1.z.object({
+        invoiceType: zod_1.z.literal('purchase'),
+        email: zod_1.z.string().email(),
+        name: zod_1.z.string(),
+        inn: zod_1.z.string(),
+        amount: zod_1.z.number(),
+        itemName: zod_1.z.string(),
+    }),
+    zod_1.z.object({
+        invoiceType: zod_1.z.literal('subscription_upgrade'),
+        email: zod_1.z.string().email(),
+        name: zod_1.z.string(),
+        inn: zod_1.z.string(),
+        amount: zod_1.z.number(),
+        fromSubscriptionName: zod_1.z.string(),
+        toSubscriptionName: zod_1.z.string(),
+        durationMonths: zod_1.z.number(),
+    }),
+]);
 exports.InvoiceForPaymentSchema = zod_1.z.object({
     uuid: zod_1.z.string().uuid(),
     userId: zod_1.z.string().uuid(),

package/build/models/team-account/team-account-with-balance.schema.js

@@ -10,6 +10,15 @@ exports.TeamAccountWithBalanceSchema = team_account_schema_1.TeamAccountSchema.e
         productBalance: zod_1.z.number(),
         carriedOverBalance: zod_1.z.number(),
     }),
+    subscription: zod_1.z.object({
+        isActive: zod_1.z.boolean(),
+        activeUntil: zod_1.z.date().nullable(),
+        planName: zod_1.z.string().nullable(),
+    }),
+    balanceUsage: zod_1.z.object({
+        spent: zod_1.z.number(),
+        total: zod_1.z.number().nullable(),
+    }),
     invoicesCount: zod_1.z.number(),
     membersCount: zod_1.z.number(),
     maxSeats: zod_1.z.number(),

package/build/models/team-account/team-to-subscription.schema.js

@@ -21,6 +21,7 @@ exports.TeamToSubscriptionSchema = zod_1.z.object({
     type: zod_1.z.nativeEnum(constants_1.USER_TO_SUBSCRIPTION_TYPE),
     intervalEndDate: zod_1.z.date().nullable(),
     marks: zod_1.z.array(zod_1.z.nativeEnum(constants_1.USER_TO_SUBSCRIPTION_MARKS)),
+    upgradedFromSubscriptionId: zod_1.z.string().uuid().nullable(),
     downgradedFromTeamSubscriptionId: zod_1.z.string().uuid().nullable(),
     orderId: zod_1.z.string().uuid().nullable(),
     createdAt: zod_1.z.date(),

package/commands/subscription/get-available-upgrades.command.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { BILLING_SCOPE } from '../../constants';
 import { SubscriptionSchema } from '../../models';
 import { SubscriptionUpgradeSchema } from '../../models/subscription-upgrade-schema';
 import { SubscriptionFeatureSchema } from '../../models/subscription-feature.schema';
@@ -8,6 +9,12 @@ export namespace GetAvailableUpgradesCommand {
 
     export type Request = z.infer<typeof RequestSchema>;
 
+    export const RequestQuerySchema = z.object({
+        billingScope: z.nativeEnum(BILLING_SCOPE).default(BILLING_SCOPE.USER),
+    });
+
+    export type RequestQuery = z.infer<typeof RequestQuerySchema>;
+
     export const ResponseSchema = z.object({
         features: z.record(z.string().uuid(), z.array(SubscriptionFeatureSchema)),
         subscriptions: z.array(SubscriptionUpgradeSchema),

package/commands/subscription/upgrade-subscription.command.ts

@@ -1,12 +1,13 @@
 import { z } from 'zod';
 import { UserToSubscriptionSchema } from '../../models';
-import { PAYMENT_PROVIDER } from '../../constants';
+import { BILLING_SCOPE, PAYMENT_PROVIDER } from '../../constants';
 
 export namespace UpgradeSubscriptionCommand {
     export const RequestSchema = z.object({
         upgradeSubscriptionId: z.string().uuid(),
         promocode: z.string().optional(),
         provider: z.nativeEnum(PAYMENT_PROVIDER).optional().default(PAYMENT_PROVIDER.CLOUDPAYMENTS),
+        billingScope: z.nativeEnum(BILLING_SCOPE).default(BILLING_SCOPE.USER),
     });
 
     export const RequestParamSchema = UserToSubscriptionSchema.pick({

package/commands/team-account/create-manual-team-subscription-upgrade.command.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { TeamToSubscriptionSchema } from '../../models';
+
+export namespace CreateManualTeamSubscriptionUpgradeCommand {
+    export const RequestSchema = z.object({
+        teamAccountId: z.string().uuid(),
+        subscriptionId: z.string().uuid(),
+        durationMonths: z.number().int().min(1).max(36).optional(),
+        upgradeFromSubscriptionId: z.string().uuid(),
+    });
+
+    export type Request = z.infer<typeof RequestSchema>;
+
+    export const ResponseSchema = z.object({
+        data: TeamToSubscriptionSchema,
+    });
+
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/commands/team-account/create-team-account-invoice-payment.command.ts

@@ -9,13 +9,17 @@ export namespace CreateTeamAccountInvoicePaymentCommand {
             amount: z.number().positive(),
             subscriptionUuid: z.string().uuid().optional(),
             productUuid: z.string().uuid().optional(),
+            upgradeSubscriptionUuid: z.string().uuid().optional(),
         })
         .refine(
-            ({ subscriptionUuid, productUuid }) =>
-                Number(Boolean(subscriptionUuid)) + Number(Boolean(productUuid)) === 1,
+            ({ subscriptionUuid, productUuid, upgradeSubscriptionUuid }) =>
+                Number(Boolean(subscriptionUuid)) +
+                    Number(Boolean(productUuid)) +
+                    Number(Boolean(upgradeSubscriptionUuid)) ===
+                1,
             {
                 message:
-                    'Нужно передать ровно один идентификатор: subscriptionUuid или productUuid',
+                    'Нужно передать ровно один идентификатор: subscriptionUuid, productUuid или upgradeSubscriptionUuid',
             },
         );
 

package/commands/team-account/find-team-accounts-by-name.command.ts

@@ -1,11 +1,17 @@
 import { z } from 'zod';
 import { TeamAccountWithBalanceSchema } from '../../models';
+import { SORT_ORDER, TEAM_ACCOUNT_ADMIN_SORT_BY } from '../../constants';
 
 export namespace FindTeamAccountsByNameCommand {
     export const RequestSchema = z.object({
         name: z.string().trim().min(1).optional(),
         limit: z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: z.coerce.number().int().min(0).default(0).optional(),
+        sortBy: z
+            .nativeEnum(TEAM_ACCOUNT_ADMIN_SORT_BY)
+            .default(TEAM_ACCOUNT_ADMIN_SORT_BY.CREATED_AT)
+            .optional(),
+        sortOrder: z.nativeEnum(SORT_ORDER).default(SORT_ORDER.DESC).optional(),
     });
 
     export type Request = z.infer<typeof RequestSchema>;

package/commands/team-account/get-invoice-for-payment.command.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { InvoiceForPaymentSchema } from '../../models';
+import { INVOICE_FOR_PAYMENT_SORT_BY, SORT_ORDER } from '../../constants';
 
 export namespace GetInvoiceForPaymentCommand {
     export const RequestQuerySchema = z.object({
@@ -12,6 +13,11 @@ export namespace GetInvoiceForPaymentCommand {
         dateTo: z.coerce.date().optional(),
         limit: z.coerce.number().int().min(1).max(100).default(20).optional(),
         offset: z.coerce.number().int().min(0).default(0).optional(),
+        sortBy: z
+            .nativeEnum(INVOICE_FOR_PAYMENT_SORT_BY)
+            .default(INVOICE_FOR_PAYMENT_SORT_BY.CREATED_AT)
+            .optional(),
+        sortOrder: z.nativeEnum(SORT_ORDER).default(SORT_ORDER.DESC).optional(),
     });
 
     export type RequestQuery = z.infer<typeof RequestQuerySchema>;

package/commands/team-account/index.ts

@@ -20,6 +20,7 @@ export * from './get-team-account-statistics-overview.command';
 export * from './get-team-account-statistics-by-month.command';
 export * from './get-team-account-balance.command';
 export * from './create-manual-team-subscription.command';
+export * from './create-manual-team-subscription-upgrade.command';
 export * from './create-manual-team-product.command';
 export * from './find-team-accounts-by-name.command';
 export * from './find-team-account-by-uuid.command';

package/commands/team-to-subscription/add-team-to-subscription.command.ts

@@ -8,6 +8,7 @@ export namespace AddTeamToSubscriptionCommand {
         cloudPaymentsSubscriptionId: z.string().optional(),
         zenpaymentsInvoiceNumber: z.string().optional(),
         startDate: z.coerce.date().optional(),
+        upgradedFromSubscriptionId: z.string().uuid().nullable().optional(),
         downgradedFromTeamSubscriptionId: z.string().uuid().nullable().optional(),
         orderId: z.string().uuid(),
     });

package/commands/team-to-subscription/update-team-to-subscription.command.ts

@@ -22,6 +22,7 @@ export namespace UpdateTeamToSubscriptionCommand {
         type: true,
         intervalEndDate: true,
         marks: true,
+        upgradedFromSubscriptionId: true,
         downgradedFromTeamSubscriptionId: true,
         orderId: true,
     }).partial();

package/constants/page/enums/page-sort-by.enum.ts

@@ -1,4 +1,7 @@
 export enum PAGE_SORT_BY {
     CREATED_AT = 'createdAt',
     UPDATED_AT = 'updatedAt',
+    TITLE = 'title',
+    CATEGORY_NAME = 'categoryName',
+    CATEGORY_ID = 'categoryId',
 }

package/constants/team-account/enums/index.ts

@@ -1,4 +1,6 @@
+export * from './invoice-for-payment-sort-by.enum';
 export * from './team-account-invite-status.enum';
+export * from './team-account-admin-sort-by.enum';
 export * from './team-account-member-role.enum';
 export * from './team-account-member-status.enum';
 export * from './team-account-operation-type.enum';

package/constants/team-account/enums/invoice-for-payment-sort-by.enum.ts

@@ -0,0 +1,10 @@
+export enum INVOICE_FOR_PAYMENT_SORT_BY {
+    INVOICE_NUMBER = 'invoiceNumber',
+    SUM = 'sum',
+    CREATED_AT = 'createdAt',
+    UPDATED_AT = 'updatedAt',
+    USER_ID = 'userId',
+    TEAM_ACCOUNT_ID = 'teamAccountId',
+    ORDER_ID = 'orderId',
+    PAYMENT_ID = 'paymentId',
+}

package/constants/team-account/enums/team-account-admin-sort-by.enum.ts

@@ -0,0 +1,7 @@
+export enum TEAM_ACCOUNT_ADMIN_SORT_BY {
+    NAME = 'name',
+    EMAIL = 'email',
+    CREATED_AT = 'createdAt',
+    UPDATED_AT = 'updatedAt',
+    SUBSCRIPTION_ENDS_AT = 'subscriptionEndsAt',
+}

package/models/invoice-for-payment.schema.ts

@@ -1,12 +1,25 @@
 import { z } from 'zod';
 
-export const InvoiceForPaymentPayloadSchema = z.object({
-    email: z.string().email(),
-    name: z.string(),
-    inn: z.string(),
-    amount: z.number(),
-    itemName: z.string(),
-});
+export const InvoiceForPaymentPayloadSchema = z.discriminatedUnion('invoiceType', [
+    z.object({
+        invoiceType: z.literal('purchase'),
+        email: z.string().email(),
+        name: z.string(),
+        inn: z.string(),
+        amount: z.number(),
+        itemName: z.string(),
+    }),
+    z.object({
+        invoiceType: z.literal('subscription_upgrade'),
+        email: z.string().email(),
+        name: z.string(),
+        inn: z.string(),
+        amount: z.number(),
+        fromSubscriptionName: z.string(),
+        toSubscriptionName: z.string(),
+        durationMonths: z.number(),
+    }),
+]);
 
 export const InvoiceForPaymentSchema = z.object({
     uuid: z.string().uuid(),

package/models/team-account/team-account-with-balance.schema.ts

@@ -8,6 +8,15 @@ export const TeamAccountWithBalanceSchema = TeamAccountSchema.extend({
         productBalance: z.number(),
         carriedOverBalance: z.number(),
     }),
+    subscription: z.object({
+        isActive: z.boolean(),
+        activeUntil: z.date().nullable(),
+        planName: z.string().nullable(),
+    }),
+    balanceUsage: z.object({
+        spent: z.number(),
+        total: z.number().nullable(),
+    }),
     invoicesCount: z.number(),
     membersCount: z.number(),
     maxSeats: z.number(),

package/models/team-account/team-to-subscription.schema.ts

@@ -23,6 +23,7 @@ export const TeamToSubscriptionSchema = z.object({
     type: z.nativeEnum(USER_TO_SUBSCRIPTION_TYPE),
     intervalEndDate: z.date().nullable(),
     marks: z.array(z.nativeEnum(USER_TO_SUBSCRIPTION_MARKS)),
+    upgradedFromSubscriptionId: z.string().uuid().nullable(),
     downgradedFromTeamSubscriptionId: z.string().uuid().nullable(),
     orderId: z.string().uuid().nullable(),
     createdAt: z.date(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@purpleschool/gptbot",
-  "version": "0.12.45",
+  "version": "0.12.47",
   "description": "",
   "main": "build/index.js",
   "types": "build/index.d.ts",