fix(handlers): roles

This commit is contained in:
Kirill 2023-03-17 20:40:26 +03:00
parent c79e2f705f
commit d5bee1ed19
36 changed files with 2010 additions and 2059 deletions

@ -1,22 +1,22 @@
# Server Options
HTTP_HOST=localhost
HTTP_PORT=8080
# Auth service
AUTH_SERVICE_HOST=http://localhost
AUTH_SERVICE_PORT=8081
# Database Options
DB_HOST=127.0.0.1
DB_PORT=27017
DB_USERNAME=admin
DB_PASSWORD=admin
DB_NAME=admin
# Other
PUBLIC_ACCESS_SECRET_KEY=`-----BEGIN PUBLIC KEY-----
MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgHgnvr7O2tiApjJfid1orFnIGm69
80fZp+Lpbjo+NC/0whMFga2Biw5b1G2Q/B2u0tpO1Fs/E8z7Lv1nYfr5jx2S8x6B
dA4TS2kB9Kf0wn0+7wSlyikHoKhbtzwXHZl17GsyEi6wHnsqNBSauyIWhpha8i+Y
+3GyaOY536H47qyXAgMBAAE=
# Server Options
HTTP_HOST=localhost
HTTP_PORT=8080
# Auth service
AUTH_SERVICE_HOST=http://localhost
AUTH_SERVICE_PORT=8081
# Database Options
DB_HOST=127.0.0.1
DB_PORT=27017
DB_USERNAME=admin
DB_PASSWORD=admin
DB_NAME=admin
# Other
PUBLIC_ACCESS_SECRET_KEY=`-----BEGIN PUBLIC KEY-----
MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgHgnvr7O2tiApjJfid1orFnIGm69
80fZp+Lpbjo+NC/0whMFga2Biw5b1G2Q/B2u0tpO1Fs/E8z7Lv1nYfr5jx2S8x6B
dA4TS2kB9Kf0wn0+7wSlyikHoKhbtzwXHZl17GsyEi6wHnsqNBSauyIWhpha8i+Y
+3GyaOY536H47qyXAgMBAAE=
-----END PUBLIC KEY-----`

@ -1,3 +1,3 @@
# Hub Admin Panel Backend Service
**Вся основная документация расположена в** [**Wiki**](https://penahub.gitlab.yandexcloud.net/pena-services/hub_admin_backend_service/-/wikis/%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)
# Hub Admin Panel Backend Service
**Вся основная документация расположена в** [**Wiki**](https://penahub.gitlab.yandexcloud.net/pena-services/hub_admin_backend_service/-/wikis/%D0%92%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5)

@ -1,14 +1,14 @@
# Настройки сервера:
В папке `./src/constants` лежат два файла конфигурации:
- `configurations.ts`
- `default.ts`
**configurations.ts**
Хранит в себе конфигурации сервиса, загружаемые через `ENV`. В основном хранит в себе данные о подключении к БД и адреса прослушивания запросов сервером.
**default.ts**
Хранит в себе стандартные значения и настройки подключаемых модулей, такие как: `fastify`, `swagger`.
# Настройки сервера:
В папке `./src/constants` лежат два файла конфигурации:
- `configurations.ts`
- `default.ts`
**configurations.ts**
Хранит в себе конфигурации сервиса, загружаемые через `ENV`. В основном хранит в себе данные о подключении к БД и адреса прослушивания запросов сервером.
**default.ts**
Хранит в себе стандартные значения и настройки подключаемых модулей, такие как: `fastify`, `swagger`.

@ -1,38 +1,38 @@
# Swagger:
При запуске сервиса, документацию можно будет изучить по отдельной ссылке, которая выдаётся сервисом
**Ссылка на Swagger документацию**: `<hostname>/swagger`
## Архитектура Swagger документации (Для разработчиков):
```
├── privilege
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── tariff
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── role
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── account
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
```
- Каждая из директорий является названием группы обработчиков (`routes`)
- `index` выдаёт все схемы для генерации документации
- `inputs` содержит в себе все входные данные, требуемые обработчику: _`params`_, _`querystring`_, _`body`_
- `models` хранит в себе все бизнес модели: _`user`_, _`tariff`_, _`role`_
# Swagger:
При запуске сервиса, документацию можно будет изучить по отдельной ссылке, которая выдаётся сервисом
**Ссылка на Swagger документацию**: `<hostname>/swagger`
## Архитектура Swagger документации (Для разработчиков):
```
├── privilege
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── tariff
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── role
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
├── account
│ ├── index.ts
│ ├── inputs.ts
│ ├── models.ts
│ ├── responses.ts
```
- Каждая из директорий является названием группы обработчиков (`routes`)
- `index` выдаёт все схемы для генерации документации
- `inputs` содержит в себе все входные данные, требуемые обработчику: _`params`_, _`querystring`_, _`body`_
- `models` хранит в себе все бизнес модели: _`user`_, _`tariff`_, _`role`_

@ -1,23 +1,23 @@
import cors from "@fastify/cors";
import cookie from "@fastify/cookie";
import jwt from "@fastify/jwt";
import swagger from "@fastify/swagger";
import swaggerUI from "@fastify/swagger-ui";
import printRoutes from "@/plugins/print-routes";
import { DEFAULT } from "@/constants/default";
import type { FastifyInstance } from "fastify";
import type { PluginsOptions } from "@/types/configuration/plugins-options";
export const registerFastifyPlugins = (fastify: FastifyInstance, options: PluginsOptions) => {
fastify.register(cors, options.cors);
fastify.register(cookie, options.cookie);
fastify.register(jwt, options.jwt);
fastify.register(swagger, DEFAULT.swaggerOptions);
fastify.register(swaggerUI, DEFAULT.swaggerUIOptions);
fastify.register(printRoutes);
return fastify;
};
import cors from "@fastify/cors";
import cookie from "@fastify/cookie";
import jwt from "@fastify/jwt";
import swagger from "@fastify/swagger";
import swaggerUI from "@fastify/swagger-ui";
import printRoutes from "@/plugins/print-routes";
import { DEFAULT } from "@/constants/default";
import type { FastifyInstance } from "fastify";
import type { PluginsOptions } from "@/types/configuration/plugins-options";
export const registerFastifyPlugins = (fastify: FastifyInstance, options: PluginsOptions) => {
fastify.register(cors, options.cors);
fastify.register(cookie, options.cookie);
fastify.register(jwt, options.jwt);
fastify.register(swagger, DEFAULT.swaggerOptions);
fastify.register(swaggerUI, DEFAULT.swaggerUIOptions);
fastify.register(printRoutes);
return fastify;
};

@ -1,46 +1,46 @@
import type { FastifyServerOptions } from "fastify";
import type { FastifyDynamicSwaggerOptions } from "@fastify/swagger";
import type { FastifySwaggerUiOptions } from "@fastify/swagger-ui";
type Default = {
readonly fastifyOptions: FastifyServerOptions;
readonly swaggerOptions: FastifyDynamicSwaggerOptions;
readonly swaggerUIOptions: FastifySwaggerUiOptions;
};
export const DEFAULT: Default = {
fastifyOptions: {
logger: true,
ajv: {
customOptions: { removeAdditional: "failing" },
},
bodyLimit: 30 * 1024 * 1024,
},
swaggerOptions: {
openapi: {
info: {
title: "Hub Admin Backend",
description: "Тестирование сервиса админ панели хаба",
version: "0.1.0",
},
components: {
securitySchemes: {
bearer: {
description: "Authorization header token, sample: Bearer <token>",
type: "http",
bearerFormat: "JWT",
scheme: "bearer",
},
},
},
},
hideUntagged: true,
},
swaggerUIOptions: {
routePrefix: "/swagger",
uiConfig: {
docExpansion: "full",
deepLinking: false,
},
},
};
import type { FastifyServerOptions } from "fastify";
import type { FastifyDynamicSwaggerOptions } from "@fastify/swagger";
import type { FastifySwaggerUiOptions } from "@fastify/swagger-ui";
type Default = {
readonly fastifyOptions: FastifyServerOptions;
readonly swaggerOptions: FastifyDynamicSwaggerOptions;
readonly swaggerUIOptions: FastifySwaggerUiOptions;
};
export const DEFAULT: Default = {
fastifyOptions: {
logger: true,
ajv: {
customOptions: { removeAdditional: "failing" },
},
bodyLimit: 30 * 1024 * 1024,
},
swaggerOptions: {
openapi: {
info: {
title: "Hub Admin Backend",
description: "Тестирование сервиса админ панели хаба",
version: "0.1.0",
},
components: {
securitySchemes: {
bearer: {
description: "Authorization header token, sample: Bearer <token>",
type: "http",
bearerFormat: "JWT",
scheme: "bearer",
},
},
},
},
hideUntagged: true,
},
swaggerUIOptions: {
routePrefix: "/swagger",
uiConfig: {
docExpansion: "full",
deepLinking: false,
},
},
};

@ -1,137 +1,137 @@
import { Types } from "mongoose";
import { AccountModel } from "@/models/account.model";
import { RoleModel } from "@/models/role.model";
import { getUser } from "@/clients/auth";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import type { FastifyReply, FastifyRequest } from "fastify";
import type { GetAccountRequest, SetAccountRoleRequest } from "./types";
export const getAllAccounts = async () => AccountModel.find({}).lean();
export const createAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOne({ userId: request.user.id }).lean();
if (account) {
reply.status(409);
return new Error("account already exist");
}
const user = await getUser({ id: request.user.id });
if (!user) {
reply.status(404);
return new Error("user not found");
}
const createdAccount = new AccountModel({
userId: user._id,
});
return createdAccount.save();
};
export const getAccount = async (request: GetAccountRequest, reply: FastifyReply) => {
const [getAccountRequestParams, error] = validateEmptyFields(request.params || {}, ["userId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(getAccountRequestParams.userId)) {
reply.status(400);
return new Error("invalid user id");
}
return AccountModel.findOne({ userId: getAccountRequestParams.userId }).lean();
};
export const setAccountRole = async (request: SetAccountRoleRequest, reply: FastifyReply) => {
const [setAccountRoleBody, error] = validateEmptyFields(request.body || {}, ["userId", "role"]);
if (error) {
reply.status(400);
return error;
}
const role = await RoleModel.findOne({ name: setAccountRoleBody.role }).lean();
if (!role) {
reply.status(404);
return new Error("role not found");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: setAccountRoleBody.userId },
{ $set: { role: role.name } }
);
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const removeAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: request.user.id },
{ $set: { isDeleted: true, deletedAt: new Date() } }
).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const deleteAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findByIdAndDelete({ userId: request.user.id }).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const restoreAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: request.user.id },
{ $set: { isDeleted: false } }
).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
import { Types } from "mongoose";
import { AccountModel } from "@/models/account.model";
import { RoleModel } from "@/models/role.model";
import { getUser } from "@/clients/auth";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import type { FastifyReply, FastifyRequest } from "fastify";
import type { GetAccountRequest, SetAccountRoleRequest } from "./types";
export const getAllAccounts = async () => AccountModel.find({}).lean();
export const createAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOne({ userId: request.user.id }).lean();
if (account) {
reply.status(409);
return new Error("account already exist");
}
const user = await getUser({ id: request.user.id });
if (!user) {
reply.status(404);
return new Error("user not found");
}
const createdAccount = new AccountModel({
userId: user._id,
});
return createdAccount.save();
};
export const getAccount = async (request: GetAccountRequest, reply: FastifyReply) => {
const [getAccountRequestParams, error] = validateEmptyFields(request.params || {}, ["userId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(getAccountRequestParams.userId)) {
reply.status(400);
return new Error("invalid user id");
}
return AccountModel.findOne({ userId: getAccountRequestParams.userId }).lean();
};
export const setAccountRole = async (request: SetAccountRoleRequest, reply: FastifyReply) => {
const [setAccountRoleBody, error] = validateEmptyFields(request.body || {}, ["userId", "role"]);
if (error) {
reply.status(400);
return error;
}
const role = await RoleModel.findOne({ name: setAccountRoleBody.role }).lean();
if (!role) {
reply.status(404);
return new Error("role not found");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: setAccountRoleBody.userId },
{ $set: { role: role.name } }
);
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const removeAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: request.user.id },
{ $set: { isDeleted: true, deletedAt: new Date() } }
).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const deleteAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findByIdAndDelete({ userId: request.user.id }).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};
export const restoreAccount = async (request: FastifyRequest, reply: FastifyReply) => {
if (!Types.ObjectId.isValid(request.user.id)) {
reply.status(400);
return new Error("invalid user id");
}
const account = await AccountModel.findOneAndUpdate(
{ userId: request.user.id },
{ $set: { isDeleted: false } }
).lean();
if (!account) {
reply.status(404);
return new Error("account not found");
}
return account;
};

@ -1,14 +1,14 @@
import type { FastifyRequest } from "fastify";
export type GetAccountRequest = FastifyRequest<{
Params?: {
userId?: string;
};
}>;
export type SetAccountRoleRequest = FastifyRequest<{
Body: {
userId?: string;
role?: string;
};
}>;
import type { FastifyRequest } from "fastify";
export type GetAccountRequest = FastifyRequest<{
Params?: {
userId?: string;
};
}>;
export type SetAccountRoleRequest = FastifyRequest<{
Body: {
userId?: string;
role?: string;
};
}>;

@ -1,28 +1,28 @@
import type { Privilege } from "@/types/models/privilege.type";
import type { RawPrivilege } from "./types";
export const validatePrivilege = (privilege: RawPrivilege): Error | null => {
const typeValues: typeof privilege.type[] = ["count", "day", "full"];
if (!typeValues.includes(privilege.type)) {
return new Error("invalid <type> value");
}
if (isNaN(Number(privilege.price))) {
return new Error("price must be a number");
}
return null;
};
export const convertPrivilegiesToMap = (privilegies: Privilege[]) => {
return privilegies.reduce<Record<string, Privilege[]>>((accamulator, privilege) => {
if (!accamulator[privilege.serviceKey]) {
accamulator[privilege.serviceKey] = [];
}
accamulator[privilege.serviceKey].push(privilege);
return accamulator;
}, {});
};
import type { Privilege } from "@/types/models/privilege.type";
import type { RawPrivilege } from "./types";
export const validatePrivilege = (privilege: RawPrivilege): Error | null => {
const typeValues: typeof privilege.type[] = ["count", "day", "full"];
if (!typeValues.includes(privilege.type)) {
return new Error("invalid <type> value");
}
if (isNaN(Number(privilege.price))) {
return new Error("price must be a number");
}
return null;
};
export const convertPrivilegiesToMap = (privilegies: Privilege[]) => {
return privilegies.reduce<Record<string, Privilege[]>>((accamulator, privilege) => {
if (!accamulator[privilege.serviceKey]) {
accamulator[privilege.serviceKey] = [];
}
accamulator[privilege.serviceKey].push(privilege);
return accamulator;
}, {});
};

@ -1,329 +1,280 @@
import { Types } from "mongoose";
import { PrivilegeModel } from "@/models/privilege.model";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import { convertPrivilegiesToMap, validatePrivilege } from "./helpers";
import type { FastifyReply } from "fastify";
import type {
GetServicePrivilegiesRequest,
RegisterPrivilegeRequest,
GetPrivilegeRequest,
RegisterPrivilegiesRequest,
RemovePrivilegeRequest,
} from "./types";
export const registerPrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
if (!requestBody.privilegies.length) {
reply.status(400);
return new Error("empty privilege array");
}
for (const rawPrivilege of requestBody.privilegies) {
const errorInvalid = validatePrivilege(rawPrivilege);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
}
const updatePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
await PrivilegeModel.updateOne(
{ privilegeId: privilege.privilegeId },
{
$set: {
name: privilege.name,
privilegeId: privilege.privilegeId,
serviceKey: privilege.serviceKey,
description: privilege.description,
type: privilege.type,
value: privilege.value,
price: privilege.price,
isDeleted: false,
createdAt: new Date(),
},
},
{ upsert: true }
).lean();
return privilege;
});
return Promise.all(updatePrivilegeRequests);
};
export const registerPrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(
request.body || {},
["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
false
);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
const errorInvalid = validatePrivilege(requestBody);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId }).lean();
if (privilege) {
reply.status(409);
return new Error("privilege already exist");
}
const newPrivilege = new PrivilegeModel({
name: requestBody.name,
privilegeId: requestBody.privilegeId,
serviceKey: requestBody.serviceKey,
description: requestBody.description,
type: requestBody.type,
value: requestBody.value,
price: requestBody.price,
});
return newPrivilege.save();
};
export const getAllPrivilegies = async () => PrivilegeModel.find({ isDeleted: false }).lean();
export const getAllPrivilegiesMap = async () => {
const privilegies = await PrivilegeModel.find({ isDeleted: false }).lean();
if (!privilegies.length) {
return {};
}
return convertPrivilegiesToMap(privilegies);
};
export const getServicePrivilegies = async (request: GetServicePrivilegiesRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["serviceKey"]);
if (error) {
reply.status(400);
return error;
}
return PrivilegeModel.find({ serviceKey: requestParams.serviceKey, isDeleted: false }).lean();
};
export const getPrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(requestParams.privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestParams.privilegeId, isDeleted: false }).lean();
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const replacePrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(
request.body || {},
["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
false
);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
const errorInvalid = validatePrivilege(requestBody);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId });
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
await privilege.replaceOne({
name: requestBody.name,
privilegeId: requestBody.privilegeId,
serviceKey: requestBody.serviceKey,
description: requestBody.description,
type: requestBody.type,
value: requestBody.value,
price: requestBody.price,
updatedAt: new Date(),
});
return Promise.all(replacePrivilegeRequests);
};
export const removePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate(
{ privilegeId },
{ $set: { isDeleted: true, deletedAt: new Date() } }
);
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const restorePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate({ privilegeId }, { $set: { isDeleted: false } });
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const replacePrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
if (!requestBody.privilegies.length) {
reply.status(400);
return new Error("empty privilege array");
}
for (const rawPrivilege of requestBody.privilegies) {
const errorInvalid = validatePrivilege(rawPrivilege);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
}
const replacePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
await PrivilegeModel.replaceOne(
{ privilegeId: privilege.privilegeId },
{
name: privilege.name,
privilegeId: privilege.privilegeId,
serviceKey: privilege.serviceKey,
description: privilege.description,
type: privilege.type,
value: privilege.value,
price: privilege.price,
updatedAt: new Date(),
isDeleted: false,
}
).lean();
return privilege;
});
return Promise.all(replacePrivilegeRequests);
};
export const removePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate(
{ privilegeId },
{ $set: { isDeleted: true, deletedAt: new Date() } }
);
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const restorePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate({ privilegeId }, { $set: { isDeleted: false } });
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
import { Types } from "mongoose";
import { PrivilegeModel } from "@/models/privilege.model";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import { convertPrivilegiesToMap, validatePrivilege } from "./helpers";
import type { FastifyReply } from "fastify";
import type {
GetServicePrivilegiesRequest,
RegisterPrivilegeRequest,
GetPrivilegeRequest,
RegisterPrivilegiesRequest,
RemovePrivilegeRequest,
} from "./types";
export const registerPrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
if (!requestBody.privilegies.length) {
reply.status(400);
return new Error("empty privilege array");
}
for (const rawPrivilege of requestBody.privilegies) {
const errorInvalid = validatePrivilege(rawPrivilege);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
}
const updatePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
await PrivilegeModel.updateOne(
{ privilegeId: privilege.privilegeId },
{
$set: {
name: privilege.name,
privilegeId: privilege.privilegeId,
serviceKey: privilege.serviceKey,
description: privilege.description,
type: privilege.type,
value: privilege.value,
price: privilege.price,
isDeleted: false,
createdAt: new Date(),
},
},
{ upsert: true }
).lean();
return privilege;
});
return Promise.all(updatePrivilegeRequests);
};
export const registerPrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(
request.body || {},
["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
false
);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
const errorInvalid = validatePrivilege(requestBody);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId }).lean();
if (privilege) {
reply.status(409);
return new Error("privilege already exist");
}
const newPrivilege = new PrivilegeModel({
name: requestBody.name,
privilegeId: requestBody.privilegeId,
serviceKey: requestBody.serviceKey,
description: requestBody.description,
type: requestBody.type,
value: requestBody.value,
price: requestBody.price,
});
return newPrivilege.save();
};
export const getAllPrivilegies = async () => PrivilegeModel.find({ isDeleted: false }).lean();
export const getAllPrivilegiesMap = async () => {
const privilegies = await PrivilegeModel.find({ isDeleted: false }).lean();
if (!privilegies.length) {
return {};
}
return convertPrivilegiesToMap(privilegies);
};
export const getServicePrivilegies = async (request: GetServicePrivilegiesRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["serviceKey"]);
if (error) {
reply.status(400);
return error;
}
return PrivilegeModel.find({ serviceKey: requestParams.serviceKey, isDeleted: false }).lean();
};
export const getPrivilege = async (request: GetPrivilegeRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(requestParams.privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestParams.privilegeId, isDeleted: false }).lean();
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const replacePrivilege = async (request: RegisterPrivilegeRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(
request.body || {},
["name", "privilegeId", "serviceKey", "type", "description", "price", "value"],
false
);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
const errorInvalid = validatePrivilege(requestBody);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
const privilege = await PrivilegeModel.findOne({ privilegeId: requestBody.privilegeId });
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
await privilege.replaceOne({
name: requestBody.name,
privilegeId: requestBody.privilegeId,
serviceKey: requestBody.serviceKey,
description: requestBody.description,
type: requestBody.type,
value: requestBody.value,
price: requestBody.price,
updatedAt: new Date(),
});
return privilege;
};
export const removePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate(
{ privilegeId },
{ $set: { isDeleted: true, deletedAt: new Date() } }
);
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};
export const replacePrivilegies = async (request: RegisterPrivilegiesRequest, reply: FastifyReply) => {
const [requestBody, errorEmpty] = validateEmptyFields(request.body || {}, ["privilegies"]);
if (errorEmpty) {
reply.status(400);
return errorEmpty;
}
if (!requestBody.privilegies.length) {
reply.status(400);
return new Error("empty privilege array");
}
for (const rawPrivilege of requestBody.privilegies) {
const errorInvalid = validatePrivilege(rawPrivilege);
if (errorInvalid) {
reply.status(400);
return errorInvalid;
}
}
const replacePrivilegeRequests = requestBody.privilegies.map(async (privilege) => {
await PrivilegeModel.replaceOne(
{ privilegeId: privilege.privilegeId },
{
name: privilege.name,
privilegeId: privilege.privilegeId,
serviceKey: privilege.serviceKey,
description: privilege.description,
type: privilege.type,
value: privilege.value,
price: privilege.price,
updatedAt: new Date(),
isDeleted: false,
}
).lean();
return privilege;
});
return Promise.all(replacePrivilegeRequests);
};
export const restorePrivilege = async (request: RemovePrivilegeRequest, reply: FastifyReply) => {
const [{ privilegeId }, error] = validateEmptyFields(request.body || {}, ["privilegeId"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(400);
return new Error("invalid id");
}
const privilege = await PrivilegeModel.findOneAndUpdate({ privilegeId }, { $set: { isDeleted: false } });
if (!privilege) {
reply.status(404);
return new Error("privilege not found");
}
return privilege;
};

@ -1,39 +1,39 @@
import type { FastifyRequest } from "fastify";
export type RawPrivilege = {
name?: string;
privilegeId?: string;
serviceKey?: string;
description?: string;
type?: string;
value?: string;
price?: number;
};
export type RegisterPrivilegeRequest = FastifyRequest<{
Body?: RawPrivilege;
}>;
export type RegisterPrivilegiesRequest = FastifyRequest<{
Body?: {
privilegies?: RawPrivilege[];
};
}>;
export type GetServicePrivilegiesRequest = FastifyRequest<{
Params?: {
serviceKey?: string;
};
}>;
export type GetPrivilegeRequest = FastifyRequest<{
Params?: {
privilegeId?: string;
};
}>;
export type RemovePrivilegeRequest = FastifyRequest<{
Body?: {
privilegeId?: string;
};
}>;
import type { FastifyRequest } from "fastify";
export type RawPrivilege = {
name?: string;
privilegeId?: string;
serviceKey?: string;
description?: string;
type?: string;
value?: string;
price?: number;
};
export type RegisterPrivilegeRequest = FastifyRequest<{
Body?: RawPrivilege;
}>;
export type RegisterPrivilegiesRequest = FastifyRequest<{
Body?: {
privilegies?: RawPrivilege[];
};
}>;
export type GetServicePrivilegiesRequest = FastifyRequest<{
Params?: {
serviceKey?: string;
};
}>;
export type GetPrivilegeRequest = FastifyRequest<{
Params?: {
privilegeId?: string;
};
}>;
export type RemovePrivilegeRequest = FastifyRequest<{
Body?: {
privilegeId?: string;
};
}>;

@ -1,22 +1,22 @@
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import type { TariffMessage } from "@/types/messages/tariff-message.type";
import type { ObjectWithRequiredFields } from "@/types/object-with-required-fields";
export const validateTariff = (tariff?: TariffMessage): [ObjectWithRequiredFields<TariffMessage>, Error | null] => {
const [validatedTariff, errorEmpty] = validateEmptyFields(
tariff || {},
["isCustom", "name", "price", "privilegieIDArray"],
false
);
if (errorEmpty) {
return [validatedTariff, errorEmpty];
}
if (isNaN(Number(validatedTariff.price))) {
return [validatedTariff, new Error("invalid 'price' value")];
}
return [validatedTariff, null];
};
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import type { TariffMessage } from "@/types/messages/tariff-message.type";
import type { ObjectWithRequiredFields } from "@/types/object-with-required-fields";
export const validateTariff = (tariff?: TariffMessage): [ObjectWithRequiredFields<TariffMessage>, Error | null] => {
const [validatedTariff, errorEmpty] = validateEmptyFields(
tariff || {},
["isCustom", "name", "price", "privilegieIDArray"],
false
);
if (errorEmpty) {
return [validatedTariff, errorEmpty];
}
if (isNaN(Number(validatedTariff.price))) {
return [validatedTariff, new Error("invalid 'price' value")];
}
return [validatedTariff, null];
};

@ -1,200 +1,200 @@
import { Types } from "mongoose";
import { TariffModel } from "@/models/tariff.model";
import { PrivilegeModel } from "@/models/privilege.model";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import { validateTariff } from "./helpers";
import type { FastifyReply } from "fastify";
import type { Privilege } from "@/types/models/privilege.type";
import type { CreateTariffRequest, GetTariffRequest, ReplaceTariffRequest, RemoveTariffRequest } from "./types";
export const getTariffs = async () => TariffModel.find({}).lean();
export const getTariff = async (request: GetTariffRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(requestParams.id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findById(requestParams.id).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const createTariff = async (request: CreateTariffRequest, reply: FastifyReply) => {
const [requestBody, error] = validateTariff(request.body);
if (error) {
reply.status(400);
return error;
}
for (const privilegeId of requestBody.privilegieIDArray) {
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(404);
return new Error(`privilege id <${privilegeId}> invalid`);
}
}
const privilegies = await PrivilegeModel.find({ privilegeId: requestBody.privilegieIDArray }).lean();
const privilegiesMap = requestBody.privilegieIDArray.reduce<Record<string, Privilege>>((accamulator, privilegeId) => {
const findedPrivilege = privilegies.find((privilege) => privilege.privilegeId === privilegeId);
if (!findedPrivilege) {
return accamulator;
}
accamulator[privilegeId] = findedPrivilege;
return accamulator;
}, {});
const newTariff = new TariffModel({
name: requestBody.name,
price: requestBody.price,
isCustom: requestBody.isCustom,
privilegies: privilegiesMap,
});
await newTariff.save();
return newTariff;
};
export const replaceTariff = async (request: ReplaceTariffRequest, reply: FastifyReply) => {
const [requestBody, error] = validateTariff(request.body || {});
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(request.params?.id || "")) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findById(request.params?.id);
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
for (const privilegeId of requestBody.privilegieIDArray) {
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(404);
return new Error(`privilege id <${privilegeId}> invalid`);
}
}
const privilegies = await PrivilegeModel.find({ privilegeId: requestBody.privilegieIDArray }).lean();
const privilegiesMap = requestBody.privilegieIDArray.reduce<Record<string, Privilege>>((accamulator, privilegeId) => {
const findedPrivilege = privilegies.find((privilege) => privilege.privilegeId === privilegeId);
if (!findedPrivilege) {
return accamulator;
}
accamulator[privilegeId] = findedPrivilege;
return accamulator;
}, {});
await tariff.replaceOne({
name: requestBody.name,
price: requestBody.price,
isCustom: requestBody.isCustom,
privilegies: privilegiesMap,
});
return tariff;
};
export const removeTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndUpdate(id, {
$set: { isDeleted: true, deletedAt: new Date() },
}).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const deleteTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndDelete(id).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const restoreTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndUpdate(id, { $set: { isDeleted: false } }).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
import { Types } from "mongoose";
import { TariffModel } from "@/models/tariff.model";
import { PrivilegeModel } from "@/models/privilege.model";
import { validateEmptyFields } from "@/utils/validate-empty-fields";
import { validateTariff } from "./helpers";
import type { FastifyReply } from "fastify";
import type { Privilege } from "@/types/models/privilege.type";
import type { CreateTariffRequest, GetTariffRequest, ReplaceTariffRequest, RemoveTariffRequest } from "./types";
export const getTariffs = async () => TariffModel.find({}).lean();
export const getTariff = async (request: GetTariffRequest, reply: FastifyReply) => {
const [requestParams, error] = validateEmptyFields(request.params || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(requestParams.id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findById(requestParams.id).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const createTariff = async (request: CreateTariffRequest, reply: FastifyReply) => {
const [requestBody, error] = validateTariff(request.body);
if (error) {
reply.status(400);
return error;
}
for (const privilegeId of requestBody.privilegieIDArray) {
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(404);
return new Error(`privilege id <${privilegeId}> invalid`);
}
}
const privilegies = await PrivilegeModel.find({ privilegeId: requestBody.privilegieIDArray }).lean();
const privilegiesMap = requestBody.privilegieIDArray.reduce<Record<string, Privilege>>((accamulator, privilegeId) => {
const findedPrivilege = privilegies.find((privilege) => privilege.privilegeId === privilegeId);
if (!findedPrivilege) {
return accamulator;
}
accamulator[privilegeId] = findedPrivilege;
return accamulator;
}, {});
const newTariff = new TariffModel({
name: requestBody.name,
price: requestBody.price,
isCustom: requestBody.isCustom,
privilegies: privilegiesMap,
});
await newTariff.save();
return newTariff;
};
export const replaceTariff = async (request: ReplaceTariffRequest, reply: FastifyReply) => {
const [requestBody, error] = validateTariff(request.body || {});
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(request.params?.id || "")) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findById(request.params?.id);
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
for (const privilegeId of requestBody.privilegieIDArray) {
if (!Types.ObjectId.isValid(privilegeId)) {
reply.status(404);
return new Error(`privilege id <${privilegeId}> invalid`);
}
}
const privilegies = await PrivilegeModel.find({ privilegeId: requestBody.privilegieIDArray }).lean();
const privilegiesMap = requestBody.privilegieIDArray.reduce<Record<string, Privilege>>((accamulator, privilegeId) => {
const findedPrivilege = privilegies.find((privilege) => privilege.privilegeId === privilegeId);
if (!findedPrivilege) {
return accamulator;
}
accamulator[privilegeId] = findedPrivilege;
return accamulator;
}, {});
await tariff.replaceOne({
name: requestBody.name,
price: requestBody.price,
isCustom: requestBody.isCustom,
privilegies: privilegiesMap,
});
return tariff;
};
export const removeTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndUpdate(id, {
$set: { isDeleted: true, deletedAt: new Date() },
}).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const deleteTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndDelete(id).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};
export const restoreTariff = async (request: RemoveTariffRequest, reply: FastifyReply) => {
const [{ id }, error] = validateEmptyFields(request.body || {}, ["id"]);
if (error) {
reply.status(400);
return error;
}
if (!Types.ObjectId.isValid(id)) {
reply.status(400);
return new Error("invalid id");
}
const tariff = await TariffModel.findByIdAndUpdate(id, { $set: { isDeleted: false } }).lean();
if (!tariff) {
reply.status(404);
return new Error("tariff not found");
}
return tariff;
};

@ -1,23 +1,23 @@
import type { FastifyRequest } from "fastify";
import type { TariffMessage } from "@/types/messages/tariff-message.type";
export type GetTariffRequest = FastifyRequest<{
Params?: {
id?: string;
};
}>;
export type RemoveTariffRequest = FastifyRequest<{
Body?: {
id?: string;
};
}>;
export type CreateTariffRequest = FastifyRequest<{
Body?: TariffMessage;
}>;
export type ReplaceTariffRequest = FastifyRequest<{
Body?: TariffMessage;
Params?: { id?: string };
}>;
import type { FastifyRequest } from "fastify";
import type { TariffMessage } from "@/types/messages/tariff-message.type";
export type GetTariffRequest = FastifyRequest<{
Params?: {
id?: string;
};
}>;
export type RemoveTariffRequest = FastifyRequest<{
Body?: {
id?: string;
};
}>;
export type CreateTariffRequest = FastifyRequest<{
Body?: TariffMessage;
}>;
export type ReplaceTariffRequest = FastifyRequest<{
Body?: TariffMessage;
Params?: { id?: string };
}>;

@ -1,32 +1,32 @@
import { Router } from "@/server/router";
import {
createAccount,
getAccount,
setAccountRole,
getAllAccounts,
deleteAccount,
removeAccount,
restoreAccount,
} from "@/handlers/account";
import { verifyUser } from "@/handlers/auth/middleware";
import {
createAccountSchema,
getAccountSchema,
setAccountRoleSchema,
getAccountsSchema,
removeAccountSchema,
restoreAccountSchema,
deleteAccountSchema,
} from "@/swagger/account";
export const setAccountRoutes = (router: Router): void => {
router.get("/", getAllAccounts, { schema: getAccountsSchema });
router.get("/:userId", getAccount, { schema: getAccountSchema });
router.post("/", createAccount, { preHandler: [verifyUser], schema: createAccountSchema });
router.post("/restore", restoreAccount, { preHandler: [verifyUser], schema: restoreAccountSchema });
router.patch("/role", setAccountRole, { preHandler: [verifyUser], schema: setAccountRoleSchema });
router.delete("/", removeAccount, { preHandler: [verifyUser], schema: removeAccountSchema });
router.delete("/delete", deleteAccount, { preHandler: [verifyUser], schema: deleteAccountSchema });
};
import { Router } from "@/server/router";
import {
createAccount,
getAccount,
setAccountRole,
getAllAccounts,
deleteAccount,
removeAccount,
restoreAccount,
} from "@/handlers/account";
import { verifyUser } from "@/handlers/auth/middleware";
import {
createAccountSchema,
getAccountSchema,
setAccountRoleSchema,
getAccountsSchema,
removeAccountSchema,
restoreAccountSchema,
deleteAccountSchema,
} from "@/swagger/account";
export const setAccountRoutes = (router: Router): void => {
router.get("/", getAllAccounts, { schema: getAccountsSchema });
router.get("/:userId", getAccount, { schema: getAccountSchema });
router.post("/", createAccount, { preHandler: [verifyUser], schema: createAccountSchema });
router.post("/restore", restoreAccount, { preHandler: [verifyUser], schema: restoreAccountSchema });
router.patch("/role", setAccountRole, { preHandler: [verifyUser], schema: setAccountRoleSchema });
router.delete("/", removeAccount, { preHandler: [verifyUser], schema: removeAccountSchema });
router.delete("/delete", deleteAccount, { preHandler: [verifyUser], schema: deleteAccountSchema });
};

@ -1,40 +1,40 @@
import { Router } from "@/server/router";
import {
registerPrivilege,
getAllPrivilegies,
getAllPrivilegiesMap,
getPrivilege,
getServicePrivilegies,
replacePrivilege,
registerPrivilegies,
removePrivilege,
replacePrivilegies,
restorePrivilege,
} from "@/handlers/privilege";
import {
getPrivilegiesSchema,
getPrivilegiesMapSchema,
getPrivilegeSchema,
getServicePrivilegiesSchema,
registerPrivilegeSchema,
registerPrivilegiesSchema,
replacePrivilegeSchema,
replacePrivilegiesSchema,
removePrivilegeSchema,
restorePrivilegeSchema,
} from "@/swagger/privilege";
export const setPrivilegeRoutes = (router: Router): void => {
router.get("/", getAllPrivilegies, { schema: getPrivilegiesSchema });
router.get("/service", getAllPrivilegiesMap, { schema: getPrivilegiesMapSchema });
router.get("/:privilegeId", getPrivilege, { schema: getPrivilegeSchema });
router.get("/service/:serviceKey", getServicePrivilegies, { schema: getServicePrivilegiesSchema });
router.post("/", registerPrivilege, { schema: registerPrivilegeSchema });
router.post("/many", registerPrivilegies, { schema: registerPrivilegiesSchema });
router.post("/restore/", restorePrivilege, { schema: restorePrivilegeSchema });
router.put("/", replacePrivilege, { schema: replacePrivilegeSchema });
router.put("/many", replacePrivilegies, { schema: replacePrivilegiesSchema });
router.delete("/", removePrivilege, { schema: removePrivilegeSchema });
};
import { Router } from "@/server/router";
import {
registerPrivilege,
getAllPrivilegies,
getAllPrivilegiesMap,
getPrivilege,
getServicePrivilegies,
replacePrivilege,
registerPrivilegies,
removePrivilege,
replacePrivilegies,
restorePrivilege,
} from "@/handlers/privilege";
import {
getPrivilegiesSchema,
getPrivilegiesMapSchema,
getPrivilegeSchema,
getServicePrivilegiesSchema,
registerPrivilegeSchema,
registerPrivilegiesSchema,
replacePrivilegeSchema,
replacePrivilegiesSchema,
removePrivilegeSchema,
restorePrivilegeSchema,
} from "@/swagger/privilege";
export const setPrivilegeRoutes = (router: Router): void => {
router.get("/", getAllPrivilegies, { schema: getPrivilegiesSchema });
router.get("/service", getAllPrivilegiesMap, { schema: getPrivilegiesMapSchema });
router.get("/:privilegeId", getPrivilege, { schema: getPrivilegeSchema });
router.get("/service/:serviceKey", getServicePrivilegies, { schema: getServicePrivilegiesSchema });
router.post("/", registerPrivilege, { schema: registerPrivilegeSchema });
router.post("/many", registerPrivilegies, { schema: registerPrivilegiesSchema });
router.post("/restore/", restorePrivilege, { schema: restorePrivilegeSchema });
router.put("/", replacePrivilege, { schema: replacePrivilegeSchema });
router.put("/many", replacePrivilegies, { schema: replacePrivilegiesSchema });
router.delete("/", removePrivilege, { schema: removePrivilegeSchema });
};

@ -1,32 +1,32 @@
import { Router } from "@/server/router";
import {
createTariff,
replaceTariff,
getTariff,
getTariffs,
removeTariff,
restoreTariff,
deleteTariff,
} from "@/handlers/tariff";
import { verifyUser } from "@/handlers/auth/middleware";
import {
getTariffSchema,
getTariffsSchema,
createTariffsSchema,
replaceTariffsSchema,
removeTariffsSchema,
restoreTariffsSchema,
deleteTariffsSchema,
} from "@/swagger/tariff";
export const setTariffRoutes = (router: Router): void => {
router.get("/", getTariffs, { schema: getTariffsSchema });
router.get("/:id", getTariff, { schema: getTariffSchema });
router.post("/", createTariff, { preHandler: [verifyUser], schema: createTariffsSchema });
router.post("/restore", restoreTariff, { preHandler: [verifyUser], schema: restoreTariffsSchema });
router.put("/:id", replaceTariff, { preHandler: [verifyUser], schema: replaceTariffsSchema });
router.delete("/", removeTariff, { preHandler: [verifyUser], schema: removeTariffsSchema });
router.delete("/delete", deleteTariff, { preHandler: [verifyUser], schema: deleteTariffsSchema });
};
import { Router } from "@/server/router";
import {
createTariff,
replaceTariff,
getTariff,
getTariffs,
removeTariff,
restoreTariff,
deleteTariff,
} from "@/handlers/tariff";
import { verifyUser } from "@/handlers/auth/middleware";
import {
getTariffSchema,
getTariffsSchema,
createTariffsSchema,
replaceTariffsSchema,
removeTariffsSchema,
restoreTariffsSchema,
deleteTariffsSchema,
} from "@/swagger/tariff";
export const setTariffRoutes = (router: Router): void => {
router.get("/", getTariffs, { schema: getTariffsSchema });
router.get("/:id", getTariff, { schema: getTariffSchema });
router.post("/", createTariff, { preHandler: [verifyUser], schema: createTariffsSchema });
router.post("/restore", restoreTariff, { preHandler: [verifyUser], schema: restoreTariffsSchema });
router.put("/:id", replaceTariff, { preHandler: [verifyUser], schema: replaceTariffsSchema });
router.delete("/", removeTariff, { preHandler: [verifyUser], schema: removeTariffsSchema });
router.delete("/delete", deleteTariff, { preHandler: [verifyUser], schema: deleteTariffsSchema });
};

@ -1,61 +1,61 @@
import fastify, { FastifyInstance } from "fastify";
import { connect as mongoConnect } from "mongoose";
import { Router } from "./router";
import { registerFastifyPlugins } from "@/configuration/register-fastify-plugins";
import { combineRoutes } from "@/configuration/combine-routes";
import { constituteMongoURI } from "@/configuration/constitute-mongo-uri";
import { DEFAULT } from "@/constants/default";
import type { PluginsOptions } from "@/types/configuration/plugins-options";
import type { DatabaseOptions } from "@/types/configuration/database-options";
type ServerOptions = {
port?: number;
host?: string;
backlog?: number;
};
type ServerArgs = {
serverOptions?: ServerOptions;
pluginsOptions?: PluginsOptions;
databaseOptions?: DatabaseOptions;
};
export class Server {
private fastify: FastifyInstance;
private serverOptions?: ServerOptions;
private databaseOptions?: DatabaseOptions;
/**
* Настройка сервера
* @param {ServerOptions} serverOptions объект настроек сервера.
* @param {DatabaseOptions} databaseOptions объект настроек подключения к базе данных.
* @param {PluginsOptions} pluginsOptions объект настроек плагинов fastify.
*/
constructor({ serverOptions, databaseOptions, pluginsOptions }: ServerArgs) {
this.serverOptions = serverOptions;
this.databaseOptions = databaseOptions;
this.fastify = fastify(DEFAULT.fastifyOptions);
if (pluginsOptions) {
registerFastifyPlugins(this.fastify, pluginsOptions);
}
combineRoutes(new Router(this.fastify));
}
public start = async () => {
const fasticyConnection = this.fastify.listen(this.serverOptions);
const databaseConnection = this.databaseOptions ? mongoConnect(constituteMongoURI(this.databaseOptions)) : null;
await Promise.all([databaseConnection, fasticyConnection])
.then(() => {
this.fastify.swagger();
console.info(`server started on ${this.serverOptions?.host}:${this.serverOptions?.port}`);
})
.catch((reason) => console.error(reason));
};
}
import fastify, { FastifyInstance } from "fastify";
import { connect as mongoConnect } from "mongoose";
import { Router } from "./router";
import { registerFastifyPlugins } from "@/configuration/register-fastify-plugins";
import { combineRoutes } from "@/configuration/combine-routes";
import { constituteMongoURI } from "@/configuration/constitute-mongo-uri";
import { DEFAULT } from "@/constants/default";
import type { PluginsOptions } from "@/types/configuration/plugins-options";
import type { DatabaseOptions } from "@/types/configuration/database-options";
type ServerOptions = {
port?: number;
host?: string;
backlog?: number;
};
type ServerArgs = {
serverOptions?: ServerOptions;
pluginsOptions?: PluginsOptions;
databaseOptions?: DatabaseOptions;
};
export class Server {
private fastify: FastifyInstance;
private serverOptions?: ServerOptions;
private databaseOptions?: DatabaseOptions;
/**
* Настройка сервера
* @param {ServerOptions} serverOptions объект настроек сервера.
* @param {DatabaseOptions} databaseOptions объект настроек подключения к базе данных.
* @param {PluginsOptions} pluginsOptions объект настроек плагинов fastify.
*/
constructor({ serverOptions, databaseOptions, pluginsOptions }: ServerArgs) {
this.serverOptions = serverOptions;
this.databaseOptions = databaseOptions;
this.fastify = fastify(DEFAULT.fastifyOptions);
if (pluginsOptions) {
registerFastifyPlugins(this.fastify, pluginsOptions);
}
combineRoutes(new Router(this.fastify));
}
public start = async () => {
const fasticyConnection = this.fastify.listen(this.serverOptions);
const databaseConnection = this.databaseOptions ? mongoConnect(constituteMongoURI(this.databaseOptions)) : null;
await Promise.all([databaseConnection, fasticyConnection])
.then(() => {
this.fastify.swagger();
console.info(`server started on ${this.serverOptions?.host}:${this.serverOptions?.port}`);
})
.catch((reason) => console.error(reason));
};
}

@ -1,77 +1,77 @@
import type {
FastifyInstance,
RouteHandlerMethod,
RawRequestDefaultExpression,
RawReplyDefaultExpression,
RouteShorthandOptions,
FastifyPluginOptions,
RawServerDefault,
RouteGenericInterface,
} from "fastify";
type HandlerMethod<T extends RouteGenericInterface> = RouteHandlerMethod<
RawServerDefault,
RawRequestDefaultExpression<RawServerDefault>,
RawReplyDefaultExpression<RawServerDefault>,
T
>;
export class Router {
private fastifyInstance: FastifyInstance;
constructor(fastifyInstance: FastifyInstance) {
this.fastifyInstance = fastifyInstance;
}
public group = (path: string, combineRoutes: (router: Router) => void) => {
this.fastifyInstance.register(
(server: FastifyInstance, opts: FastifyPluginOptions, done: () => void) => {
const router = new Router(server);
combineRoutes(router);
done();
},
{ prefix: path }
);
};
public get = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.get(path, options, handler);
};
public post = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.post(path, options, handler);
};
public put = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.put(path, options, handler);
};
public patch = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.patch(path, options, handler);
};
public delete = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.delete(path, options, handler);
};
}
import type {
FastifyInstance,
RouteHandlerMethod,
RawRequestDefaultExpression,
RawReplyDefaultExpression,
RouteShorthandOptions,
FastifyPluginOptions,
RawServerDefault,
RouteGenericInterface,
} from "fastify";
type HandlerMethod<T extends RouteGenericInterface> = RouteHandlerMethod<
RawServerDefault,
RawRequestDefaultExpression<RawServerDefault>,
RawReplyDefaultExpression<RawServerDefault>,
T
>;
export class Router {
private fastifyInstance: FastifyInstance;
constructor(fastifyInstance: FastifyInstance) {
this.fastifyInstance = fastifyInstance;
}
public group = (path: string, combineRoutes: (router: Router) => void) => {
this.fastifyInstance.register(
(server: FastifyInstance, opts: FastifyPluginOptions, done: () => void) => {
const router = new Router(server);
combineRoutes(router);
done();
},
{ prefix: path }
);
};
public get = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.get(path, options, handler);
};
public post = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.post(path, options, handler);
};
public put = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.put(path, options, handler);
};
public patch = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.patch(path, options, handler);
};
public delete = <T extends RouteGenericInterface>(
path: string,
handler: HandlerMethod<T>,
options: RouteShorthandOptions = {}
) => {
this.fastifyInstance.delete(path, options, handler);
};
}

@ -1,64 +1,64 @@
import { getAccountParams, setAccountRoleBody } from "./inputs";
import {
getAccountResponse,
createAccountResponse,
setAccountRoleResponse,
getAccountsResponse,
removeRoleResponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getAccountsSchema: SwaggerSchema = {
summary: "Получение информации об аккаунтах",
description: "Получение всех аккаунтов из БД",
tags: ["account"],
response: getAccountsResponse,
};
export const getAccountSchema: SwaggerSchema = {
summary: "Получение информации об аккаунте",
description: "Получение аккаунта по ID",
tags: ["account"],
params: getAccountParams,
response: getAccountResponse,
};
export const createAccountSchema: SwaggerSchema = {
summary: "Создание аккаунта",
tags: ["account"],
response: createAccountResponse,
security: [{ bearer: [] }],
};
export const setAccountRoleSchema: SwaggerSchema = {
summary: "Присвоение роли пользователя",
tags: ["account"],
body: setAccountRoleBody,
response: setAccountRoleResponse,
security: [{ bearer: [] }],
};
export const removeAccountSchema: SwaggerSchema = {
summary: "Удаление аккаунта",
description: "Помечает аккаунт удалённым, но не удаляет его из БД",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};
export const deleteAccountSchema: SwaggerSchema = {
summary: "Удаление аккаунта",
description: "Удаляет аккаунт из БД окончательно",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};
export const restoreAccountSchema: SwaggerSchema = {
summary: "Восстановление аккаунта",
description: "Восстанавливает аккаунт, который не был удалён окончательно",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};
import { getAccountParams, setAccountRoleBody } from "./inputs";
import {
getAccountResponse,
createAccountResponse,
setAccountRoleResponse,
getAccountsResponse,
removeRoleResponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getAccountsSchema: SwaggerSchema = {
summary: "Получение информации об аккаунтах",
description: "Получение всех аккаунтов из БД",
tags: ["account"],
response: getAccountsResponse,
};
export const getAccountSchema: SwaggerSchema = {
summary: "Получение информации об аккаунте",
description: "Получение аккаунта по ID",
tags: ["account"],
params: getAccountParams,
response: getAccountResponse,
};
export const createAccountSchema: SwaggerSchema = {
summary: "Создание аккаунта",
tags: ["account"],
response: createAccountResponse,
security: [{ bearer: [] }],
};
export const setAccountRoleSchema: SwaggerSchema = {
summary: "Присвоение роли пользователя",
tags: ["account"],
body: setAccountRoleBody,
response: setAccountRoleResponse,
security: [{ bearer: [] }],
};
export const removeAccountSchema: SwaggerSchema = {
summary: "Удаление аккаунта",
description: "Помечает аккаунт удалённым, но не удаляет его из БД",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};
export const deleteAccountSchema: SwaggerSchema = {
summary: "Удаление аккаунта",
description: "Удаляет аккаунт из БД окончательно",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};
export const restoreAccountSchema: SwaggerSchema = {
summary: "Восстановление аккаунта",
description: "Восстанавливает аккаунт, который не был удалён окончательно",
tags: ["account"],
response: removeRoleResponse,
security: [{ bearer: [] }],
};

@ -1,27 +1,27 @@
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAccountParams: SwaggerMessage = {
type: "object",
required: ["userId"],
properties: {
userId: {
type: "string",
description: "ID пользователя",
},
},
};
export const setAccountRoleBody: SwaggerMessage = {
type: "object",
required: ["userId", "role"],
properties: {
userId: {
type: "string",
description: "ID пользователя",
},
role: {
type: "string",
description: "название роли",
},
},
};
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAccountParams: SwaggerMessage = {
type: "object",
required: ["userId"],
properties: {
userId: {
type: "string",
description: "ID пользователя",
},
},
};
export const setAccountRoleBody: SwaggerMessage = {
type: "object",
required: ["userId", "role"],
properties: {
userId: {
type: "string",
description: "ID пользователя",
},
role: {
type: "string",
description: "название роли",
},
},
};

@ -1,49 +1,49 @@
import type { SwaggerMessage } from "@/types/swagger.type";
export const account: SwaggerMessage = {
description: "Аккаунт",
type: "object",
properties: {
_id: { type: "string" },
userId: { type: "string" },
nickname: { type: "string" },
avatar: { type: "string" },
role: { type: "string" },
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: [
{
_id: "807f1f77bcf81cd799439011",
userId: "507f1f77bcf86cd799439011",
nickname: "Ivanov Ivan Ivanovich",
avatar: "/media/avatar/default-avatar.jpg",
role: "user",
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
{
_id: "807f1f77bcf81cd799439011",
userId: "507f1f77bcf86cd799439011",
nickname: "Ivanov Ivan Ivanovich",
avatar: "/media/avatar/default-avatar.jpg",
role: "user",
isDeleted: true,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2019-04-14T15:32:15Z",
deletedAt: "2021-08-17T13:23:44Z",
},
],
};
import type { SwaggerMessage } from "@/types/swagger.type";
export const account: SwaggerMessage = {
description: "Аккаунт",
type: "object",
properties: {
_id: { type: "string" },
userId: { type: "string" },
nickname: { type: "string" },
avatar: { type: "string" },
role: { type: "string" },
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: [
{
_id: "807f1f77bcf81cd799439011",
userId: "507f1f77bcf86cd799439011",
nickname: "Ivanov Ivan Ivanovich",
avatar: "/media/avatar/default-avatar.jpg",
role: "user",
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
{
_id: "807f1f77bcf81cd799439011",
userId: "507f1f77bcf86cd799439011",
nickname: "Ivanov Ivan Ivanovich",
avatar: "/media/avatar/default-avatar.jpg",
role: "user",
isDeleted: true,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2019-04-14T15:32:15Z",
deletedAt: "2021-08-17T13:23:44Z",
},
],
};

@ -1,40 +1,40 @@
import { swaggerError } from "@/utils/swagger-error";
import { account } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAccountsResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив аккаунтов",
items: account,
},
};
export const getAccountResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
};
export const createAccountResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
409: swaggerError(409, "account already exist"),
};
export const setAccountRoleResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
};
export const removeRoleResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
};
import { swaggerError } from "@/utils/swagger-error";
import { account } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAccountsResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив аккаунтов",
items: account,
},
};
export const getAccountResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
};
export const createAccountResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
409: swaggerError(409, "account already exist"),
};
export const setAccountRoleResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
};
export const removeRoleResponse: Record<string, SwaggerMessage> = {
200: account,
400: swaggerError(400, "invalid user id"),
401: swaggerError(401, "invalid token"),
404: swaggerError(404, "user not found"),
};

@ -1,84 +1,84 @@
import { privilegeBody, registerPrivilegiesBody, getPrivilegeParams, getServicePrivilegiesParams } from "./inputs";
import {
getPrivilegeReponse,
getPrivilegiesReponse,
getAllPrivilegiesMapReponse,
getAllPrivilegiesReponse,
registerPrivilegeResponse,
replacePrivilegeResponse,
registerPrivilegiesResponse,
replacePrivilegiesResponse,
removePrivilegeResponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getPrivilegiesSchema: SwaggerSchema = {
summary: "Получение всех привелегий",
description: "Получение всех привелегий в виде массива",
tags: ["privilege"],
response: getAllPrivilegiesReponse,
};
export const getPrivilegiesMapSchema: SwaggerSchema = {
summary: "Получение всех привелегий",
description: "Получение всех привелегий в виде объекта ключ-значение, где ключём является serviceKey",
tags: ["privilege"],
response: getAllPrivilegiesMapReponse,
};
export const getPrivilegeSchema: SwaggerSchema = {
summary: "Получение привилегии по ID",
tags: ["privilege"],
params: getPrivilegeParams,
response: getPrivilegeReponse,
};
export const getServicePrivilegiesSchema: SwaggerSchema = {
summary: "Получение привилегий сервиса",
tags: ["privilege"],
params: getServicePrivilegiesParams,
response: getPrivilegiesReponse,
};
export const registerPrivilegeSchema: SwaggerSchema = {
summary: "Регистрация привелегии сервиса",
tags: ["privilege"],
body: privilegeBody,
response: registerPrivilegeResponse,
};
export const registerPrivilegiesSchema: SwaggerSchema = {
summary: "Регистрация привелегий сервиса",
tags: ["privilege"],
body: registerPrivilegiesBody,
response: registerPrivilegiesResponse,
};
export const replacePrivilegeSchema: SwaggerSchema = {
summary: "Замена привилегии сервиса",
tags: ["privilege"],
body: privilegeBody,
response: replacePrivilegeResponse,
};
export const replacePrivilegiesSchema: SwaggerSchema = {
summary: "Замена привилегий сервиса",
tags: ["privilege"],
body: registerPrivilegiesBody,
response: replacePrivilegiesResponse,
};
export const removePrivilegeSchema: SwaggerSchema = {
summary: "Удаление привелегии",
tags: ["privilege"],
body: getPrivilegeParams,
response: removePrivilegeResponse,
};
export const restorePrivilegeSchema: SwaggerSchema = {
summary: "Восстановление привилегии",
tags: ["privilege"],
body: getPrivilegeParams,
response: removePrivilegeResponse,
};
import { privilegeBody, registerPrivilegiesBody, getPrivilegeParams, getServicePrivilegiesParams } from "./inputs";
import {
getPrivilegeReponse,
getPrivilegiesReponse,
getAllPrivilegiesMapReponse,
getAllPrivilegiesReponse,
registerPrivilegeResponse,
replacePrivilegeResponse,
registerPrivilegiesResponse,
replacePrivilegiesResponse,
removePrivilegeResponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getPrivilegiesSchema: SwaggerSchema = {
summary: "Получение всех привелегий",
description: "Получение всех привелегий в виде массива",
tags: ["privilege"],
response: getAllPrivilegiesReponse,
};
export const getPrivilegiesMapSchema: SwaggerSchema = {
summary: "Получение всех привелегий",
description: "Получение всех привелегий в виде объекта ключ-значение, где ключём является serviceKey",
tags: ["privilege"],
response: getAllPrivilegiesMapReponse,
};
export const getPrivilegeSchema: SwaggerSchema = {
summary: "Получение привилегии по ID",
tags: ["privilege"],
params: getPrivilegeParams,
response: getPrivilegeReponse,
};
export const getServicePrivilegiesSchema: SwaggerSchema = {
summary: "Получение привилегий сервиса",
tags: ["privilege"],
params: getServicePrivilegiesParams,
response: getPrivilegiesReponse,
};
export const registerPrivilegeSchema: SwaggerSchema = {
summary: "Регистрация привелегии сервиса",
tags: ["privilege"],
body: privilegeBody,
response: registerPrivilegeResponse,
};
export const registerPrivilegiesSchema: SwaggerSchema = {
summary: "Регистрация привелегий сервиса",
tags: ["privilege"],
body: registerPrivilegiesBody,
response: registerPrivilegiesResponse,
};
export const replacePrivilegeSchema: SwaggerSchema = {
summary: "Замена привилегии сервиса",
tags: ["privilege"],
body: privilegeBody,
response: replacePrivilegeResponse,
};
export const replacePrivilegiesSchema: SwaggerSchema = {
summary: "Замена привилегий сервиса",
tags: ["privilege"],
body: registerPrivilegiesBody,
response: replacePrivilegiesResponse,
};
export const removePrivilegeSchema: SwaggerSchema = {
summary: "Удаление привелегии",
tags: ["privilege"],
body: getPrivilegeParams,
response: removePrivilegeResponse,
};
export const restorePrivilegeSchema: SwaggerSchema = {
summary: "Восстановление привилегии",
tags: ["privilege"],
body: getPrivilegeParams,
response: removePrivilegeResponse,
};

@ -1,62 +1,62 @@
import type { SwaggerMessage } from "@/types/swagger.type";
export const privilegeBody: SwaggerMessage = {
type: "object",
required: ["name", "privilegeId", "serviceKey", "description", "type", "value", "price"],
properties: {
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
},
examples: [
{
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
],
};
export const privilegiesBody: SwaggerMessage = {
type: "array",
items: privilegeBody,
};
export const registerPrivilegiesBody: SwaggerMessage = {
type: "object",
properties: {
privilegies: privilegiesBody,
},
};
export const getPrivilegeParams: SwaggerMessage = {
type: "object",
required: ["privilegeId"],
properties: {
privilegeId: {
type: "string",
description: "ID привилегии (privilegeId)",
},
},
examples: [{ privilegeId: "507f1f77bcf86cd799439011" }],
};
export const getServicePrivilegiesParams: SwaggerMessage = {
type: "object",
required: ["serviceKey"],
properties: {
serviceKey: {
type: "string",
description: "Ключ сервиса",
},
},
examples: [{ serviceKey: "docx-templater-service" }],
};
import type { SwaggerMessage } from "@/types/swagger.type";
export const privilegeBody: SwaggerMessage = {
type: "object",
required: ["name", "privilegeId", "serviceKey", "description", "type", "value", "price"],
properties: {
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
},
examples: [
{
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
],
};
export const privilegiesBody: SwaggerMessage = {
type: "array",
items: privilegeBody,
};
export const registerPrivilegiesBody: SwaggerMessage = {
type: "object",
properties: {
privilegies: privilegiesBody,
},
};
export const getPrivilegeParams: SwaggerMessage = {
type: "object",
required: ["privilegeId"],
properties: {
privilegeId: {
type: "string",
description: "ID привилегии (privilegeId)",
},
},
examples: [{ privilegeId: "507f1f77bcf86cd799439011" }],
};
export const getServicePrivilegiesParams: SwaggerMessage = {
type: "object",
required: ["serviceKey"],
properties: {
serviceKey: {
type: "string",
description: "Ключ сервиса",
},
},
examples: [{ serviceKey: "docx-templater-service" }],
};

@ -1,46 +1,46 @@
import type { SwaggerMessage, SwaggerValueType } from "@/types/swagger.type";
const privilegeExamples: SwaggerValueType[] = [
{
_id: "207f1f67bcf86cd799439011",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
];
export const privilege: SwaggerMessage = {
type: "object",
description: "Привилегия",
properties: {
_id: { type: "string" },
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: privilegeExamples,
};
import type { SwaggerMessage, SwaggerValueType } from "@/types/swagger.type";
const privilegeExamples: SwaggerValueType[] = [
{
_id: "207f1f67bcf86cd799439011",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
];
export const privilege: SwaggerMessage = {
type: "object",
description: "Привилегия",
properties: {
_id: { type: "string" },
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: privilegeExamples,
};

@ -1,95 +1,95 @@
import { swaggerError } from "@/utils/swagger-error";
import { privilege } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAllPrivilegiesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Привилегии",
items: privilege,
},
};
export const getAllPrivilegiesMapReponse: Record<string, SwaggerMessage> = {
200: {
type: "object",
description: "Привилегии",
properties: {
additionalProperties: {
type: "array",
description: "Привилегии",
items: privilege,
},
},
additionalProperties: true,
example: {
"docx-templater-service": [
{
_id: "63a7b01f1f4117cf861d6d1e",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
updatedAt: "2022-12-25T02:47:52.405Z",
isDeleted: false,
createdAt: "2022-12-25T02:47:52.406Z",
},
],
},
},
};
export const getPrivilegiesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
};
export const getPrivilegeReponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "privilege not found"),
};
export const registerPrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "price must be a number"),
409: swaggerError(409, "privilege already exist"),
};
export const registerPrivilegiesResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
400: swaggerError(400, "price must be a number"),
};
export const replacePrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid 'type' value"),
404: swaggerError(404, "privilege not found"),
};
export const replacePrivilegiesResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
400: swaggerError(400, "invalid 'type' value"),
};
export const removePrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "privilege not found"),
};
import { swaggerError } from "@/utils/swagger-error";
import { privilege } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getAllPrivilegiesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Привилегии",
items: privilege,
},
};
export const getAllPrivilegiesMapReponse: Record<string, SwaggerMessage> = {
200: {
type: "object",
description: "Привилегии",
properties: {
additionalProperties: {
type: "array",
description: "Привилегии",
items: privilege,
},
},
additionalProperties: true,
example: {
"docx-templater-service": [
{
_id: "63a7b01f1f4117cf861d6d1e",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
updatedAt: "2022-12-25T02:47:52.405Z",
isDeleted: false,
createdAt: "2022-12-25T02:47:52.406Z",
},
],
},
},
};
export const getPrivilegiesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
};
export const getPrivilegeReponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "privilege not found"),
};
export const registerPrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "price must be a number"),
409: swaggerError(409, "privilege already exist"),
};
export const registerPrivilegiesResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
400: swaggerError(400, "price must be a number"),
};
export const replacePrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid 'type' value"),
404: swaggerError(404, "privilege not found"),
};
export const replacePrivilegiesResponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив привилегий",
items: privilege,
},
400: swaggerError(400, "invalid 'type' value"),
};
export const removePrivilegeResponse: Record<string, SwaggerMessage> = {
200: privilege,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "privilege not found"),
};

@ -1,32 +1,32 @@
import type { SwaggerMessage } from "@/types/swagger.type";
export const role: SwaggerMessage = {
type: "object",
description: "Роль",
properties: {
_id: { type: "string" },
name: { type: "string" },
permissions: {
type: "object",
additionalProperties: { type: "boolean" },
},
},
examples: [
{
_id: "638388e120c70c17eb123d37",
name: "user",
permissions: {
read: true,
write: false,
},
},
{
_id: "638388f720c70c17eb123d3a",
name: "admin",
permissions: {
read: true,
write: true,
},
},
],
};
import type { SwaggerMessage } from "@/types/swagger.type";
export const role: SwaggerMessage = {
type: "object",
description: "Роль",
properties: {
_id: { type: "string" },
name: { type: "string" },
permissions: {
type: "object",
additionalProperties: { type: "boolean" },
},
},
examples: [
{
_id: "638388e120c70c17eb123d37",
name: "user",
permissions: {
read: true,
write: false,
},
},
{
_id: "638388f720c70c17eb123d3a",
name: "admin",
permissions: {
read: true,
write: true,
},
},
],
};

@ -1,51 +1,51 @@
import { swaggerError } from "@/utils/swagger-error";
import { role } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getRolesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив ролей",
items: role,
},
};
export const getRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "query is empty"),
404: swaggerError(404, "role not found"),
};
export const createRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "field <name> is empty"),
409: swaggerError(409, "role already exist"),
};
export const restoreRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role by id not found"),
409: swaggerError(409, "role not removed"),
};
export const updateRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "either name or permissions must be filled"),
404: swaggerError(404, "role not found"),
};
export const removeRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role by id not found"),
409: swaggerError(409, "role already deleted"),
};
export const deleteRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role not found"),
};
import { swaggerError } from "@/utils/swagger-error";
import { role } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getRolesReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив ролей",
items: role,
},
};
export const getRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "query is empty"),
404: swaggerError(404, "role not found"),
};
export const createRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "field <name> is empty"),
409: swaggerError(409, "role already exist"),
};
export const restoreRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role by id not found"),
409: swaggerError(409, "role not removed"),
};
export const updateRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "either name or permissions must be filled"),
404: swaggerError(404, "role not found"),
};
export const removeRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role by id not found"),
409: swaggerError(409, "role already deleted"),
};
export const deleteRoleReponse: Record<string, SwaggerMessage> = {
200: role,
400: swaggerError(400, "wrong id"),
404: swaggerError(404, "role not found"),
};

@ -1,66 +1,66 @@
import { getTariffParams, tariffBody, replaceTariffParams } from "./inputs";
import {
getTariffReponse,
getTariffsReponse,
createTariffReponse,
replaceTariffReponse,
removeTariffReponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getTariffSchema: SwaggerSchema = {
summary: "Получение тарифа",
tags: ["tariff"],
params: getTariffParams,
response: getTariffReponse,
};
export const getTariffsSchema: SwaggerSchema = {
summary: "Получение списка тарифов",
tags: ["tariff"],
response: getTariffsReponse,
};
export const createTariffsSchema: SwaggerSchema = {
summary: "Создание тарифа",
tags: ["tariff"],
body: tariffBody,
security: [{ bearer: [] }],
response: createTariffReponse,
};
export const replaceTariffsSchema: SwaggerSchema = {
summary: "Замена тарифа",
tags: ["tariff"],
params: replaceTariffParams,
body: tariffBody,
security: [{ bearer: [] }],
response: replaceTariffReponse,
};
export const removeTariffsSchema: SwaggerSchema = {
summary: "Удаление тарифа",
description: "Помечает тариф удалённым, но не удаляет его из БД",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};
export const deleteTariffsSchema: SwaggerSchema = {
summary: "Удаление тарифа",
description: "Удаляет тариф из БД окончательно",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};
export const restoreTariffsSchema: SwaggerSchema = {
summary: "Восстановление тарифа",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};
import { getTariffParams, tariffBody, replaceTariffParams } from "./inputs";
import {
getTariffReponse,
getTariffsReponse,
createTariffReponse,
replaceTariffReponse,
removeTariffReponse,
} from "./responses";
import type { SwaggerSchema } from "@/types/swagger.type";
export const getTariffSchema: SwaggerSchema = {
summary: "Получение тарифа",
tags: ["tariff"],
params: getTariffParams,
response: getTariffReponse,
};
export const getTariffsSchema: SwaggerSchema = {
summary: "Получение списка тарифов",
tags: ["tariff"],
response: getTariffsReponse,
};
export const createTariffsSchema: SwaggerSchema = {
summary: "Создание тарифа",
tags: ["tariff"],
body: tariffBody,
security: [{ bearer: [] }],
response: createTariffReponse,
};
export const replaceTariffsSchema: SwaggerSchema = {
summary: "Замена тарифа",
tags: ["tariff"],
params: replaceTariffParams,
body: tariffBody,
security: [{ bearer: [] }],
response: replaceTariffReponse,
};
export const removeTariffsSchema: SwaggerSchema = {
summary: "Удаление тарифа",
description: "Помечает тариф удалённым, но не удаляет его из БД",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};
export const deleteTariffsSchema: SwaggerSchema = {
summary: "Удаление тарифа",
description: "Удаляет тариф из БД окончательно",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};
export const restoreTariffsSchema: SwaggerSchema = {
summary: "Восстановление тарифа",
tags: ["tariff"],
body: getTariffParams,
security: [{ bearer: [] }],
response: removeTariffReponse,
};

@ -1,48 +1,48 @@
import type { SwaggerMessage } from "@/types/swagger.type";
export const getTariffParams: SwaggerMessage = {
type: "object",
required: ["id"],
properties: {
id: {
type: "string",
description: "ID тарифа",
},
},
examples: [{ id: "507f1f77bcf86cd799439011" }],
};
export const tariffBody: SwaggerMessage = {
type: "object",
description: "Тариф",
required: ["name", "price", "isCustom", "privilegieIDArray"],
properties: {
name: { type: "string" },
price: { type: "number" },
isCustom: { type: "boolean" },
privilegieIDArray: {
type: "array",
items: { type: "string" },
},
},
examples: [
{
name: "Использование сервисов",
price: 14000,
isCustom: false,
privilegieIDArray: ["507f1f77bcf86cd799439011"],
},
],
};
export const replaceTariffParams: SwaggerMessage = {
type: "object",
required: ["id"],
properties: {
id: {
type: "string",
description: "ID тарифа",
},
},
examples: [{ id: "63a7d47ba24613f98562bafa" }],
};
import type { SwaggerMessage } from "@/types/swagger.type";
export const getTariffParams: SwaggerMessage = {
type: "object",
required: ["id"],
properties: {
id: {
type: "string",
description: "ID тарифа",
},
},
examples: [{ id: "507f1f77bcf86cd799439011" }],
};
export const tariffBody: SwaggerMessage = {
type: "object",
description: "Тариф",
required: ["name", "price", "isCustom", "privilegieIDArray"],
properties: {
name: { type: "string" },
price: { type: "number" },
isCustom: { type: "boolean" },
privilegieIDArray: {
type: "array",
items: { type: "string" },
},
},
examples: [
{
name: "Использование сервисов",
price: 14000,
isCustom: false,
privilegieIDArray: ["507f1f77bcf86cd799439011"],
},
],
};
export const replaceTariffParams: SwaggerMessage = {
type: "object",
required: ["id"],
properties: {
id: {
type: "string",
description: "ID тарифа",
},
},
examples: [{ id: "63a7d47ba24613f98562bafa" }],
};

@ -1,97 +1,97 @@
import type { SwaggerMessage } from "@/types/swagger.type";
const privilege: SwaggerMessage = {
type: "object",
description: "Привилегия",
properties: {
_id: { type: "string" },
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
},
examples: [
{
_id: "507f1f77bcf86cd799439011",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования сервиса генерации шаблонов",
type: "count",
value: "200",
price: 12300,
},
],
};
export const tariff: SwaggerMessage = {
type: "object",
description: "Тариф",
properties: {
_id: { type: "string" },
name: { type: "string" },
price: { type: "number" },
isCustom: { type: "boolean" },
privilegies: {
type: "object",
additionalProperties: privilege,
},
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: [
{
name: "Использование сервисов",
price: 14000,
isCustom: false,
privilegies: {
"507f1f77bcf86cd799439011": {
name: "507f1f77bcf86cd799439011",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
},
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
{
name: "user",
price: 14000,
isCustom: false,
privilegies: {
"507f1f77bcf86cd799439011": {
name: "507f1f77bcf86cd799439011",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
},
isDeleted: true,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2019-04-14T15:32:15Z",
deletedAt: "2021-08-17T13:23:44Z",
},
],
};
import type { SwaggerMessage } from "@/types/swagger.type";
const privilege: SwaggerMessage = {
type: "object",
description: "Привилегия",
properties: {
_id: { type: "string" },
name: { type: "string" },
privilegeId: { type: "string" },
serviceKey: { type: "string" },
description: { type: "string" },
type: { type: "string" },
value: { type: "string" },
price: { type: "number" },
},
examples: [
{
_id: "507f1f77bcf86cd799439011",
name: "Количество попыток использования",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования сервиса генерации шаблонов",
type: "count",
value: "200",
price: 12300,
},
],
};
export const tariff: SwaggerMessage = {
type: "object",
description: "Тариф",
properties: {
_id: { type: "string" },
name: { type: "string" },
price: { type: "number" },
isCustom: { type: "boolean" },
privilegies: {
type: "object",
additionalProperties: privilege,
},
isDeleted: { type: "boolean" },
createdAt: {
type: "string",
format: "date-time",
},
updatedAt: {
type: "string",
format: "date-time",
},
deletedAt: {
type: "string",
format: "date-time",
},
},
examples: [
{
name: "Использование сервисов",
price: 14000,
isCustom: false,
privilegies: {
"507f1f77bcf86cd799439011": {
name: "507f1f77bcf86cd799439011",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
},
isDeleted: false,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2017-07-21T17:32:28Z",
},
{
name: "user",
price: 14000,
isCustom: false,
privilegies: {
"507f1f77bcf86cd799439011": {
name: "507f1f77bcf86cd799439011",
privilegeId: "507f1f77bcf86cd799439011",
serviceKey: "docx-templater-service",
description: "Количество попыток использования",
type: "count",
value: "200",
price: 12300,
},
},
isDeleted: true,
createdAt: "2017-07-21T17:32:28Z",
updatedAt: "2019-04-14T15:32:15Z",
deletedAt: "2021-08-17T13:23:44Z",
},
],
};

@ -1,40 +1,40 @@
import { swaggerError } from "@/utils/swagger-error";
import { tariff } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "tariff not found"),
};
export const getTariffsReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив тарифов",
items: tariff,
},
};
export const createTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid 'price' value"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "privilege with id <privilegeId> not found"),
};
export const replaceTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "tariff not found"),
};
export const removeTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "tariff not found"),
};
import { swaggerError } from "@/utils/swagger-error";
import { tariff } from "./models";
import type { SwaggerMessage } from "@/types/swagger.type";
export const getTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
404: swaggerError(404, "tariff not found"),
};
export const getTariffsReponse: Record<string, SwaggerMessage> = {
200: {
type: "array",
description: "Массив тарифов",
items: tariff,
},
};
export const createTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid 'price' value"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "privilege with id <privilegeId> not found"),
};
export const replaceTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "tariff not found"),
};
export const removeTariffReponse: Record<string, SwaggerMessage> = {
200: tariff,
400: swaggerError(400, "invalid id"),
401: swaggerError(400, "invalid user id"),
404: swaggerError(404, "tariff not found"),
};

@ -1,9 +1,9 @@
import type { Eloquent } from "../models/eloquent.type";
import type { Tariff } from "../models/tariff.type";
import type { ObjectWithPossibleFields } from "../object-with-possible-fields";
export type TariffMessage = ObjectWithPossibleFields<
Omit<Tariff, keyof Eloquent | "privilegies"> & {
privilegieIDArray: string[];
}
>;
import type { Eloquent } from "../models/eloquent.type";
import type { Tariff } from "../models/tariff.type";
import type { ObjectWithPossibleFields } from "../object-with-possible-fields";
export type TariffMessage = ObjectWithPossibleFields<
Omit<Tariff, keyof Eloquent | "privilegies"> & {
privilegieIDArray: string[];
}
>;

@ -1,50 +1,50 @@
import type { FastifySchema } from "fastify";
export type SwaggerValueType =
| string
| number
| boolean
| null
| SwaggerValueType[]
| { [key: string]: SwaggerValueType };
type SwaggerMediaType = "object" | "string" | "integer" | "boolean" | "array" | "number";
type SwaggerMediaFormat =
| "binary"
| "base64"
| "uuid"
| "email"
| "date"
| "date-time"
| "password"
| "byte"
| "uri"
| "hostname"
| "ipv4"
| "ipv6";
export type SwaggerMessage = {
type?: SwaggerMediaType;
description?: string;
format?: SwaggerMediaFormat;
pattern?: string;
nullable?: boolean;
uniqueItems?: boolean;
writeOnly?: boolean;
readOnly?: boolean;
items?: SwaggerMessage;
additionalProperties?: SwaggerMessage | boolean;
properties?: Record<string, SwaggerMessage | Record<string, SwaggerValueType>>;
examples?: SwaggerValueType[];
example?: SwaggerValueType;
required?: string[];
oneOf?: SwaggerMessage[];
allOf?: SwaggerMessage[];
};
export type SwaggerSchema = FastifySchema & {
params?: SwaggerMessage;
body?: SwaggerMessage;
querystring?: SwaggerMessage;
response?: Record<number, SwaggerMessage>;
};
import type { FastifySchema } from "fastify";
export type SwaggerValueType =
| string
| number
| boolean
| null
| SwaggerValueType[]
| { [key: string]: SwaggerValueType };
type SwaggerMediaType = "object" | "string" | "integer" | "boolean" | "array" | "number";
type SwaggerMediaFormat =
| "binary"
| "base64"
| "uuid"
| "email"
| "date"
| "date-time"
| "password"
| "byte"
| "uri"
| "hostname"
| "ipv4"
| "ipv6";
export type SwaggerMessage = {
type?: SwaggerMediaType;
description?: string;
format?: SwaggerMediaFormat;
pattern?: string;
nullable?: boolean;
uniqueItems?: boolean;
writeOnly?: boolean;
readOnly?: boolean;
items?: SwaggerMessage;
additionalProperties?: SwaggerMessage | boolean;
properties?: Record<string, SwaggerMessage | Record<string, SwaggerValueType>>;
examples?: SwaggerValueType[];
example?: SwaggerValueType;
required?: string[];
oneOf?: SwaggerMessage[];
allOf?: SwaggerMessage[];
};
export type SwaggerSchema = FastifySchema & {
params?: SwaggerMessage;
body?: SwaggerMessage;
querystring?: SwaggerMessage;
response?: Record<number, SwaggerMessage>;
};

@ -1,20 +1,20 @@
import type { SwaggerMessage } from "@/types/swagger.type";
const STATUS_CODE_MAP: Record<number, string> = {
400: "Bad Request",
401: "Unauthorized",
404: "Not Found",
409: "Conflict",
500: "Internal Server Error",
};
export const swaggerError = (code: number, message: string): SwaggerMessage => ({
type: "object",
description: STATUS_CODE_MAP[code],
properties: {
statusCode: { type: "integer" },
error: { type: "string" },
message: { type: "string" },
},
examples: [{ statusCode: code, error: STATUS_CODE_MAP[code], message: message }],
});
import type { SwaggerMessage } from "@/types/swagger.type";
const STATUS_CODE_MAP: Record<number, string> = {
400: "Bad Request",
401: "Unauthorized",
404: "Not Found",
409: "Conflict",
500: "Internal Server Error",
};
export const swaggerError = (code: number, message: string): SwaggerMessage => ({
type: "object",
description: STATUS_CODE_MAP[code],
properties: {
statusCode: { type: "integer" },
error: { type: "string" },
message: { type: "string" },
},
examples: [{ statusCode: code, error: STATUS_CODE_MAP[code], message: message }],
});