jp.db.schemas 2.2.0 → 2.2.2

package/dist/schemas/users_achievement.schema.d.ts

@@ -0,0 +1,115 @@
+import { Document, HydratedDocument } from 'mongoose';
+export type UsersAchievementDocument = HydratedDocument<UsersAchievement>;
+export declare class UsersAchievement {
+    readonly usersAchievementId: string;
+    date: Date;
+    userId: string;
+    userName: string;
+    achievementId: string;
+    achievementTitle: string;
+    achievementCode: string;
+    achievementPrize: number;
+    game: string;
+}
+export declare const UsersAchievementSchema: import("mongoose").Schema<UsersAchievement, import("mongoose").Model<UsersAchievement, any, any, any, (Document<unknown, any, UsersAchievement, any, import("mongoose").DefaultSchemaOptions> & UsersAchievement & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}) | (Document<unknown, any, UsersAchievement, any, import("mongoose").DefaultSchemaOptions> & UsersAchievement & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}), any, UsersAchievement>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    readonly usersAchievementId?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    date?: import("mongoose").SchemaDefinitionProperty<Date, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    userId?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    userName?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    achievementId?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    achievementTitle?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    achievementCode?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    achievementPrize?: import("mongoose").SchemaDefinitionProperty<number, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    game?: import("mongoose").SchemaDefinitionProperty<string, UsersAchievement, Document<unknown, {}, UsersAchievement, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersAchievement & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+}, UsersAchievement>;
+//# sourceMappingURL=users_achievement.schema.d.ts.map

package/dist/schemas/users_achievement.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users_achievement.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/users_achievement.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,MAAM,wBAAwB,GAAG,gBAAgB,CAAC,gBAAgB,CAAC,CAAC;AAE1E,qBACa,gBAAgB;IAMzB,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IAGpC,IAAI,EAAE,IAAI,CAAC;IAGX,MAAM,EAAE,MAAM,CAAC;IAGf,QAAQ,EAAE,MAAM,CAAC;IAGjB,aAAa,EAAE,MAAM,CAAC;IAGtB,gBAAgB,EAAE,MAAM,CAAC;IAGzB,eAAe,EAAE,MAAM,CAAC;IAGxB,gBAAgB,EAAE,MAAM,CAAC;IAGzB,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAAiD,CAAC"}

package/dist/schemas/users_achievement.schema.js

@@ -0,0 +1,61 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersAchievementSchema = exports.UsersAchievement = void 0;
+const mongoose_1 = require("@nestjs/mongoose");
+let UsersAchievement = class UsersAchievement {
+};
+exports.UsersAchievement = UsersAchievement;
+__decorate([
+    (0, mongoose_1.Virtual)({
+        get: function () {
+            return this._id.toString();
+        },
+    }),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "usersAchievementId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)({ default: new Date() }),
+    __metadata("design:type", Date)
+], UsersAchievement.prototype, "date", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "userId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "userName", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "achievementId", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "achievementTitle", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "achievementCode", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", Number)
+], UsersAchievement.prototype, "achievementPrize", void 0);
+__decorate([
+    (0, mongoose_1.Prop)(),
+    __metadata("design:type", String)
+], UsersAchievement.prototype, "game", void 0);
+exports.UsersAchievement = UsersAchievement = __decorate([
+    (0, mongoose_1.Schema)({ collection: 'users_achievements' })
+], UsersAchievement);
+exports.UsersAchievementSchema = mongoose_1.SchemaFactory.createForClass(UsersAchievement);
+//# sourceMappingURL=users_achievement.schema.js.map

package/dist/schemas/users_achievement.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"users_achievement.schema.js","sourceRoot":"","sources":["../../src/schemas/users_achievement.schema.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwE;AAMjE,IAAM,gBAAgB,GAAtB,MAAM,gBAAgB;CA+B5B,CAAA;AA/BY,4CAAgB;AAMhB;IALR,IAAA,kBAAO,EAAC;QACL,GAAG,EAAE;YACD,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;KACJ,CAAC;;4DACkC;AAGpC;IADC,IAAA,eAAI,EAAC,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC;8BACxB,IAAI;8CAAC;AAGX;IADC,IAAA,eAAI,GAAE;;gDACQ;AAGf;IADC,IAAA,eAAI,GAAE;;kDACU;AAGjB;IADC,IAAA,eAAI,GAAE;;uDACe;AAGtB;IADC,IAAA,eAAI,GAAE;;0DACkB;AAGzB;IADC,IAAA,eAAI,GAAE;;yDACiB;AAGxB;IADC,IAAA,eAAI,GAAE;;0DACkB;AAGzB;IADC,IAAA,eAAI,GAAE;;8CACM;2BA9BJ,gBAAgB;IAD5B,IAAA,iBAAM,EAAC,EAAE,UAAU,EAAE,oBAAoB,EAAE,CAAC;GAChC,gBAAgB,CA+B5B;AAEY,QAAA,sBAAsB,GAAG,wBAAa,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC"}

package/dist/schemas/users_balance.schema.d.ts

@@ -0,0 +1,95 @@
+import { Document, HydratedDocument } from 'mongoose';
+export type UsersBalanceDocument = HydratedDocument<UsersBalance>;
+export declare class UsersBalance {
+    readonly usersBalanceId: string;
+    date: Date;
+    userId: string;
+    userName: string;
+    amount: number;
+    reason: string;
+    game: string;
+}
+export declare const UsersBalanceSchema: import("mongoose").Schema<UsersBalance, import("mongoose").Model<UsersBalance, any, any, any, (Document<unknown, any, UsersBalance, any, import("mongoose").DefaultSchemaOptions> & UsersBalance & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}) | (Document<unknown, any, UsersBalance, any, import("mongoose").DefaultSchemaOptions> & UsersBalance & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}), any, UsersBalance>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, UsersBalance, Document<unknown, {}, UsersBalance, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    readonly usersBalanceId?: import("mongoose").SchemaDefinitionProperty<string, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    date?: import("mongoose").SchemaDefinitionProperty<Date, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    userId?: import("mongoose").SchemaDefinitionProperty<string, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    userName?: import("mongoose").SchemaDefinitionProperty<string, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    amount?: import("mongoose").SchemaDefinitionProperty<number, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    reason?: import("mongoose").SchemaDefinitionProperty<string, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+    game?: import("mongoose").SchemaDefinitionProperty<string, UsersBalance, Document<unknown, {}, UsersBalance, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<UsersBalance & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }>;
+}, UsersBalance>;
+//# sourceMappingURL=users_balance.schema.d.ts.map

package/dist/schemas/users_balance.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users_balance.schema.d.ts","sourceRoot":"","sources":["../../src/schemas/users_balance.schema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEtD,MAAM,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,YAAY,CAAC,CAAC;AAElE,qBACa,YAAY;IAMrB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAGhC,IAAI,EAAE,IAAI,CAAC;IAGX,MAAM,EAAE,MAAM,CAAC;IAGf,QAAQ,EAAE,MAAM,CAAC;IAGjB,MAAM,EAAE,MAAM,CAAC;IAGf,MAAM,EAAE,MAAM,CAAC;IAGf,IAAI,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA6C,CAAC"}

package/dist/schemas/{balance_history.schema.js → users_balance.schema.js}

@@ -9,11 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BalanceHistorySchema = exports.BalanceHistory = void 0;
+exports.UsersBalanceSchema = exports.UsersBalance = void 0;
 const mongoose_1 = require("@nestjs/mongoose");
-let BalanceHistory = class BalanceHistory {
+let UsersBalance = class UsersBalance {
 };
-exports.BalanceHistory = BalanceHistory;
+exports.UsersBalance = UsersBalance;
 __decorate([
     (0, mongoose_1.Virtual)({
         get: function () {
@@ -21,37 +21,33 @@ __decorate([
         },
     }),
     __metadata("design:type", String)
-], BalanceHistory.prototype, "balanceHistoryId", void 0);
+], UsersBalance.prototype, "usersBalanceId", void 0);
 __decorate([
-    (0, mongoose_1.Prop)(),
+    (0, mongoose_1.Prop)({ default: new Date() }),
     __metadata("design:type", Date)
-], BalanceHistory.prototype, "date", void 0);
+], UsersBalance.prototype, "date", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], BalanceHistory.prototype, "gameType", void 0);
+], UsersBalance.prototype, "userId", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], BalanceHistory.prototype, "roomId", void 0);
+], UsersBalance.prototype, "userName", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
-    __metadata("design:type", String)
-], BalanceHistory.prototype, "gameId", void 0);
+    __metadata("design:type", Number)
+], UsersBalance.prototype, "amount", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
     __metadata("design:type", String)
-], BalanceHistory.prototype, "reason", void 0);
-__decorate([
-    (0, mongoose_1.Prop)(),
-    __metadata("design:type", Number)
-], BalanceHistory.prototype, "balance", void 0);
+], UsersBalance.prototype, "reason", void 0);
 __decorate([
     (0, mongoose_1.Prop)(),
-    __metadata("design:type", Number)
-], BalanceHistory.prototype, "balanceAdding", void 0);
-exports.BalanceHistory = BalanceHistory = __decorate([
-    (0, mongoose_1.Schema)({ collection: 'balance_history' })
-], BalanceHistory);
-exports.BalanceHistorySchema = mongoose_1.SchemaFactory.createForClass(BalanceHistory);
-//# sourceMappingURL=balance_history.schema.js.map
+    __metadata("design:type", String)
+], UsersBalance.prototype, "game", void 0);
+exports.UsersBalance = UsersBalance = __decorate([
+    (0, mongoose_1.Schema)({ collection: 'users_balances' })
+], UsersBalance);
+exports.UsersBalanceSchema = mongoose_1.SchemaFactory.createForClass(UsersBalance);
+//# sourceMappingURL=users_balance.schema.js.map

package/dist/schemas/users_balance.schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"users_balance.schema.js","sourceRoot":"","sources":["../../src/schemas/users_balance.schema.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,+CAAwE;AAMjE,IAAM,YAAY,GAAlB,MAAM,YAAY;CAyBxB,CAAA;AAzBY,oCAAY;AAMZ;IALR,IAAA,kBAAO,EAAC;QACL,GAAG,EAAE;YACD,OAAO,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;QAC/B,CAAC;KACJ,CAAC;;oDAC8B;AAGhC;IADC,IAAA,eAAI,EAAC,EAAE,OAAO,EAAE,IAAI,IAAI,EAAE,EAAE,CAAC;8BACxB,IAAI;0CAAC;AAGX;IADC,IAAA,eAAI,GAAE;;4CACQ;AAGf;IADC,IAAA,eAAI,GAAE;;8CACU;AAGjB;IADC,IAAA,eAAI,GAAE;;4CACQ;AAGf;IADC,IAAA,eAAI,GAAE;;4CACQ;AAGf;IADC,IAAA,eAAI,GAAE;;0CACM;uBAxBJ,YAAY;IADxB,IAAA,iBAAM,EAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,CAAC;GAC5B,YAAY,CAyBxB;AAEY,QAAA,kBAAkB,GAAG,wBAAa,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jp.db.schemas",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -53,8 +53,6 @@ import { Menu, MenuSchema } from './schemas/menu.schema';
 import type { MenuDocument } from './schemas/menu.schema';
 import { GameResult, GameResultSchema } from './schemas/game_result.schema';
 import type { GameResultDocument } from './schemas/game_result.schema';
-import { BalanceHistory, BalanceHistorySchema } from './schemas/balance_history.schema';
-import type { BalanceHistoryDocument } from './schemas/balance_history.schema';
 import { SimpleRoom, SimpleRoomSchema } from './schemas/simple_rooms.schema';
 import type { SimpleRoomDocument } from './schemas/simple_rooms.schema';
 import { TournamentOneTableRoom, TournamentOneTableRoomSchema, } from './schemas/tournament_one_table_rooms.schema';
@@ -74,6 +72,10 @@ import type { ActivityLogDocument } from './schemas/activity_log.schema';
 import type { IActivityLogUserLogin } from './models/activity-log-user-login.interface';
 import { SettingsOption, SettingsOptionSchema } from './schemas/settings_option.schema';
 import type { SettingsOptionDocument } from './schemas/settings_option.schema';
+import { UsersAchievement, UsersAchievementSchema } from './schemas/users_achievement.schema';
+import type { UsersAchievementDocument } from './schemas/users_achievement.schema';
+import { UsersBalance, UsersBalanceSchema } from './schemas/users_balance.schema';
+import type { UsersBalanceDocument } from './schemas/users_balance.schema';
 
 import {
     AdminRepository,
@@ -96,7 +98,6 @@ import {
     SettingRepository,
     RoomsRepository,
     GameResultRepository,
-    BalanceHistoryRepository,
     SimpleRoomsRepository,
     TournamentOneTableRoomsRepository,
     TournamentManyTablesRoomsRepository,
@@ -104,6 +105,8 @@ import {
     AchievementRepository,
     PurchaseRepository,
     SettingsOptionsRepository,
+    UsersAchievementsRepository,
+    UsersBalancesRepository,
 } from './repositories'
 
 export type {
@@ -138,12 +141,13 @@ export type {
     FriendDocument,
     DailyBonusDocument,
     GameResultDocument,
-    BalanceHistoryDocument,
     SimpleRoomDocument,
     TournamentOneTableRoomDocument,
     TournamentManyTablesRoomDocument,
     ActivityLogDocument,
     SettingsOptionDocument,
+    UsersAchievementDocument,
+    UsersBalanceDocument,
 }
 
 export {
@@ -210,8 +214,6 @@ export {
     FriendSchema,
     GameResult,
     GameResultSchema,
-    BalanceHistory,
-    BalanceHistorySchema,
     SimpleRoom,
     SimpleRoomSchema,
     TournamentOneTableRoom,
@@ -223,6 +225,10 @@ export {
     IActivityLogUserLogin,
     SettingsOption,
     SettingsOptionSchema,
+    UsersAchievement,
+    UsersAchievementSchema,
+    UsersBalance,
+    UsersBalanceSchema,
 }
 
 export {
@@ -246,7 +252,6 @@ export {
     SettingRepository,
     RoomsRepository,
     GameResultRepository,
-    BalanceHistoryRepository,
     SimpleRoomsRepository,
     TournamentOneTableRoomsRepository,
     TournamentManyTablesRoomsRepository,
@@ -254,4 +259,6 @@ export {
     AchievementRepository,
     PurchaseRepository,
     SettingsOptionsRepository,
+    UsersBalancesRepository,
+    UsersAchievementsRepository,
 }

package/src/models/account-type.enum.ts

@@ -0,0 +1,8 @@
+export enum AccountTypeEnum {
+  VK = 'VK',
+  OK = 'OK',
+  YA = 'YA',
+  FB = 'FB',
+  GOOGLE = 'GOOGLE',
+  GUEST = 'GUEST',
+}

package/src/models/users-balance-reason.enum.ts

@@ -0,0 +1,8 @@
+export enum UsersBalanceReasonEnum {
+    REGISTER = 'REGISTER',
+    DAILY_BONUS = 'DAILY_BONUS',
+    SHOP_PURCHASE = 'SHOP_PURCHASE',
+    SIMPLE_ROOM_RESULT = 'SIMPLE_ROOM_RESULT',
+    ONE_TABLE_TOURNAMENT_RESULT = 'ONE_TABLE_TOURNAMENT_RESULT',
+    MANY_TABLES_TOURNAMENT_RESULT = 'MANY_TABLES_TOURNAMENT_RESULT',
+} 

package/src/repositories/index.ts

@@ -18,7 +18,6 @@ import { WelcomeRepository } from './welcome.repository';
 import { DailyBonusRepository } from './daily-bonus.repository';
 import { RoomsRepository } from './rooms.repository';
 import { GameResultRepository } from './game-result.repository';
-import { BalanceHistoryRepository } from './balance-history.repository';
 import { SimpleRoomsRepository } from './simple-rooms.repository';
 import { TournamentOneTableRoomsRepository } from './tournament-one-table-rooms.repository';
 import { TournamentManyTablesRoomsRepository } from './tournament-many-tables-rooms.repository';
@@ -26,6 +25,8 @@ import { ActivityLogRepository } from './activity-log.repository';
 import { AchievementRepository } from './achievement.repository';
 import { PurchaseRepository } from './purchase.repository';
 import { SettingsOptionsRepository } from './settings-options.repository';
+import { UsersBalancesRepository } from './users-balances.repository';
+import { UsersAchievementsRepository } from './users-achievements.repository';
 
 export {
     AdminRepository,
@@ -48,7 +49,6 @@ export {
     DailyBonusRepository,
     RoomsRepository,
     GameResultRepository,
-    BalanceHistoryRepository,
     SimpleRoomsRepository,
     TournamentOneTableRoomsRepository,
     TournamentManyTablesRoomsRepository,
@@ -56,4 +56,6 @@ export {
     AchievementRepository,
     PurchaseRepository,
     SettingsOptionsRepository,
+    UsersBalancesRepository,
+    UsersAchievementsRepository
 }

package/src/repositories/settings-options.repository.ts

@@ -10,11 +10,9 @@ export class SettingsOptionsRepository {
     constructor (@InjectModel(SettingsOption.name) private settingOptionsModel: Model<SettingsOptionDocument>) {
     }
 
-    async findSettingsOptions (channel: string, game: string): Promise<Array<SettingsOption> | null> {
+    async findSettingsOptions (): Promise<Array<SettingsOption> | null> {
         return this.settingOptionsModel
-            .find({
-                channels: getChannelRegExpFilter(channel),
-            })
+            .find()
             .exec();
     }
 }

package/src/repositories/users-achievements.repository.ts

@@ -0,0 +1,43 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { UsersAchievement, UsersAchievementDocument } from '..';
+
+@Injectable()
+export class UsersAchievementsRepository {
+    constructor(@InjectModel(UsersAchievement.name) private usersAchievementModel: Model<UsersAchievementDocument>) {
+    }
+
+    async findAchivementsByUserId (userId: string): Promise<Array<UsersAchievement>> {
+        return this.usersAchievementModel
+            .find({ userId })
+            .exec();
+    }
+
+    async findAchivementsByUserIdAndAchievementCode (userId: string, achievementCode: string): Promise<Array<UsersAchievement>> {
+        return this.usersAchievementModel
+            .find({ userId, achievementCode })
+            .exec();
+    }
+
+    async addUsersAchievement (
+        userId: string,
+        userName: string,
+        achievementId: string,
+        achievementTitle: string,
+        achievementCode: string,
+        achievementPrize: number,
+        game: string,
+    ): Promise<UsersAchievement> {
+        return this.usersAchievementModel.create({
+            userId,
+            userName,
+            achievementId,
+            achievementTitle,
+            achievementCode,
+            achievementPrize,
+            game,
+        });
+    }
+}

package/src/repositories/users-balances.repository.ts

@@ -0,0 +1,28 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+
+import { UsersBalance, UsersBalanceDocument } from '..';
+import { UsersBalanceReasonEnum } from '../models/users-balance-reason.enum';
+
+@Injectable()
+export class UsersBalancesRepository {
+    constructor(@InjectModel(UsersBalance.name) private usersBalanceModel: Model<UsersBalanceDocument>) {
+    }
+
+    async addUsersBalanceByRegister (userId: string, userName: string, amount: number, game: string): Promise<UsersBalance> {
+        return this.createUsersBalance({ userId, userName, amount, reason: UsersBalanceReasonEnum.REGISTER, game })
+    }
+
+    async addUsersBalanceByDailyBonus (userId: string, userName: string, amount: number, game: string): Promise<UsersBalance> {
+        return this.createUsersBalance({ userId, userName, amount, reason: UsersBalanceReasonEnum.DAILY_BONUS, game })
+    }
+
+    async addUsersBalanceByShopPurchase (userId: string, userName: string, amount: number, game: string): Promise<UsersBalance> {
+        return this.createUsersBalance({ userId, userName, amount, reason: UsersBalanceReasonEnum.SHOP_PURCHASE, game })
+    }
+
+    async createUsersBalance (usersBalance: Partial<UsersBalance>): Promise<UsersBalance> {
+        return this.usersBalanceModel.create(usersBalance);
+    }
+}

package/src/repositories/users.repository.ts

@@ -141,11 +141,4 @@ export class UsersRepository {
             { new: true },
         ).exec();
     }
-
-    async addAchievement(userId: string, achievementCode: string): Promise<void> {
-        await this.userModel.findByIdAndUpdate(
-            userId,
-            { $push: { achievements: achievementCode } })
-            .exec();
-    }
 }

package/src/repositories/welcome.repository.ts

@@ -10,9 +10,9 @@ export class WelcomeRepository {
     constructor (@InjectModel(Welcome.name) private welcomeModel: Model<WelcomeDocument>) {
     }
 
-    async findWelcome (gameType: string): Promise<Welcome | null> {
+    async findWelcome (game: string): Promise<Welcome | null> {
         return this.welcomeModel
-            .findOne({ gameType })
+            .findOne({ game })
             .exec();
     }
 }

package/src/schemas/setting.schema.ts

@@ -15,6 +15,15 @@ export class Setting {
     @Prop()
     position: number;
 
+    @Prop()
+    code: string;
+
+    @Prop()
+    type: string;
+
+    @Prop()
+    modalType?: string;
+
     @Prop()
     title: string;
 

package/src/schemas/settings_option.schema.ts

@@ -32,6 +32,12 @@ export class SettingsOption {
 
     @Prop()
     productId?: string;
+
+    @Prop()
+    premium?: boolean;
+
+    @Prop()
+    platformAvatar?: boolean;
 }
 
 export const SettingsOptionSchema = SchemaFactory.createForClass(SettingsOption);