@webitel/api-services 26.8.52 → 26.8.54

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webitel/api-services",
-	"version": "26.8.52",
+	"version": "26.8.54",
 	"private": false,
 	"repository": {
 		"type": "git",

package/src/api/clients/configurations/configurations.ts

@@ -1,4 +1,9 @@
+import {
+	type EngineSystemSetting,
+	EngineSystemSettingName,
+} from '@webitel/api-services/gen/models';
 import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
+import type { UserPasswordRules } from '@webitel/api-services/validations';
 import {
 	CreateSystemSettingBody,
 	getSystemSettingService,
@@ -182,6 +187,25 @@ const getObjectsList = async (params: ApiParams) => {
 	}
 };
 
+const getPasswordRules = async (): Promise<UserPasswordRules> => {
+	const { items } = await getList({
+		name: [
+			EngineSystemSettingName.PasswordRegExp,
+			EngineSystemSettingName.PasswordValidationText,
+		],
+	});
+
+	const findValue = (name: EngineSystemSettingName) =>
+		items.find((item: EngineSystemSetting) => item.name === name)?.value;
+
+	return {
+		passwordRegExp: findValue(EngineSystemSettingName.PasswordRegExp),
+		passwordValidationText: findValue(
+			EngineSystemSettingName.PasswordValidationText,
+		),
+	};
+};
+
 export const ConfigurationsAPI = {
 	getList,
 	get,
@@ -190,4 +214,5 @@ export const ConfigurationsAPI = {
 	delete: deleteItem,
 	getLookup,
 	getObjectsList,
+	getPasswordRules,
 };

package/src/api/clients/users/users.ts

@@ -1,4 +1,7 @@
+import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';
 import deepCopy from 'deep-copy';
+
+import { SearchUsersQueryParams } from '../../../gen-wire';
 import {
 	getDefaultGetListResponse,
 	getDefaultGetParams,
@@ -13,6 +16,7 @@ import {
 	mergeEach,
 	notify,
 	sanitize,
+	sanitizeToWire,
 	snakeToCamel,
 } from '../../transformers';
 import { generatePermissionsApi } from '../_shared/generatePermissionsApi';
@@ -47,17 +51,25 @@ const fieldsToSend = [
 	'forcePasswordChange',
 ];
 
-const getUsersList = async (params: ApiParams) => {
-	const fieldsToSend = [
-		'page',
-		'size',
-		'q',
-		'sort',
-		'fields',
-		'id',
-		'not_user_id',
+const presenceListFields = [
+	'presence.status',
+	'dnd',
+];
+
+const toWireListFields = (fields?: string[]) =>
+	fields && [
+		...new Set(
+			fields.map((field) =>
+				presenceListFields.includes(field) ? 'presence' : field,
+			),
+		),
 	];
 
+const getUsersList = async (params: ApiParams) => {
+	const listFieldsToSend = getShallowFieldsToSendFromZodSchema(
+		SearchUsersQueryParams,
+	);
+
 	const defaultObject = {
 		name: '',
 		status: '',
@@ -69,9 +81,10 @@ const getUsersList = async (params: ApiParams) => {
 		merge(getDefaultGetParams()),
 		(params) => ({
 			...params,
-			q: params.search,
+			q: params.q ?? params.search,
+			fields: toWireListFields(params.fields),
 		}),
-		sanitize(fieldsToSend),
+		sanitizeToWire(listFieldsToSend),
 		camelToSnake(),
 		generateUrl(baseUrl),
 	]);
@@ -308,6 +321,18 @@ const getUsersLookup = (params: Parameters<typeof getUsersList>[0]) =>
 		],
 	});
 
+const generateUserTotpUrl = async ({ id }: DeleteItemParams) => {
+	const url = `${baseUrl}/${id}/2fa`;
+	try {
+		const response = await instance.post(url, {});
+		return applyTransform(response.data, []);
+	} catch (err) {
+		throw applyTransform(err, [
+			notify,
+		]);
+	}
+};
+
 const logoutUser = async ({ id }: DeleteItemParams) => {
 	const url = `${baseUrl}/${id}/logout`;
 	try {
@@ -343,6 +368,7 @@ export const UsersAPI = {
 	delete: deleteUser,
 	getLookup: getUsersLookup,
 	patchUserPresence,
+	generateTotpUrl: generateUserTotpUrl,
 	logoutUser,
 	logoutMultipleUsers,
 

package/src/enums/UserPresenceStatus/UserPresenceStatus.ts

@@ -0,0 +1,9 @@
+export const UserPresenceStatus = {
+	WEB: 'web',
+	SIP: 'sip',
+	DLG: 'dlg',
+	DND: 'dnd',
+} as const;
+
+export type UserPresenceStatus =
+	(typeof UserPresenceStatus)[keyof typeof UserPresenceStatus];

package/src/enums/index.ts

@@ -10,6 +10,7 @@ import { QueueType, QueueTypeName } from './QueueType/QueueType';
 import { RelativeDatetimeValue } from './RelativeDatetimeValue/RelativeDatetimeValue';
 import { TimeBaseScore } from './TimeBaseScore/TimeBaseScore';
 import { TypesResourceStrategy } from './TypesResourceStrategy/TypesResourceStrategy';
+import { UserPresenceStatus } from './UserPresenceStatus/UserPresenceStatus';
 
 export {
 	CallReportingStatus,
@@ -23,4 +24,5 @@ export {
 	RelativeDatetimeValue,
 	TimeBaseScore,
 	TypesResourceStrategy,
+	UserPresenceStatus,
 };

package/src/validations/index.ts

@@ -44,4 +44,5 @@ export * from './sla/sla.validations';
 export * from './slaCondition/slaCondition.validations';
 export * from './typeExtension/typeExtension.validations';
 export * from './types';
+export * from './user/user.validations';
 export * from './variable/variable.validations';

package/src/validations/user/__tests__/user.validations.spec.ts

@@ -0,0 +1,136 @@
+import { getDefaultsFromZodSchema } from '@webitel/api-services/gen/utils';
+import { describe, expect, it } from 'vitest';
+
+import { buildUserSchema, userSchema } from '../user.validations';
+
+const issuePaths = (result: ReturnType<typeof userSchema.safeParse>) =>
+	result.error?.issues.map(({ path }) => path.join('.')) ?? [];
+
+describe('userSchema', () => {
+	it('seeds a new user with the form defaults', () => {
+		expect(getDefaultsFromZodSchema(userSchema, {})).toMatchObject({
+			name: '',
+			username: '',
+			password: '',
+			extension: '',
+			roles: [],
+			license: [],
+			devices: [],
+			device: {},
+			variables: [],
+			forcePasswordChange: false,
+			generateDevice: false,
+		});
+	});
+
+	it('requires name, login and password for a new user', () => {
+		const paths = issuePaths(
+			userSchema.safeParse(getDefaultsFromZodSchema(userSchema, {})),
+		);
+
+		expect(paths).toEqual(
+			expect.arrayContaining([
+				'name',
+				'username',
+				'password',
+			]),
+		);
+	});
+
+	it('does not require password for an existing user', () => {
+		const result = userSchema.safeParse({
+			id: '1',
+			name: 'John',
+			username: 'john',
+		});
+
+		expect(result.success).toBe(true);
+	});
+
+	it('accepts digits-only extension', () => {
+		expect(
+			issuePaths(
+				userSchema.safeParse({
+					id: '1',
+					name: 'John',
+					username: 'john',
+					extension: '12a',
+				}),
+			),
+		).toEqual([
+			'extension',
+		]);
+	});
+
+	it('requires the other half of a filled variable pair', () => {
+		const paths = issuePaths(
+			userSchema.safeParse({
+				id: '1',
+				name: 'John',
+				username: 'john',
+				variables: [
+					{
+						key: 'k',
+						value: '',
+					},
+					{
+						key: '',
+						value: 'v',
+					},
+					{
+						key: '',
+						value: '',
+					},
+				],
+			}),
+		);
+
+		expect(paths).toEqual([
+			'variables.0.value',
+			'variables.1.key',
+		]);
+	});
+});
+
+describe('buildUserSchema', () => {
+	const user = {
+		id: '1',
+		name: 'John',
+		username: 'john',
+	};
+
+	it('checks a filled password against the configured regexp', () => {
+		const schema = buildUserSchema({
+			passwordRegExp: '^\\d+$',
+			passwordValidationText: 'Digits only',
+		});
+
+		const result = schema.safeParse({
+			...user,
+			password: 'abc',
+		});
+
+		expect(result.error?.issues).toEqual([
+			expect.objectContaining({
+				path: [
+					'password',
+				],
+				message: 'Digits only',
+			}),
+		]);
+		expect(
+			schema.safeParse({
+				...user,
+				password: '123',
+			}).success,
+		).toBe(true);
+	});
+
+	it('skips the regexp for an empty password on an existing user', () => {
+		const schema = buildUserSchema({
+			passwordRegExp: '^\\d+$',
+		});
+
+		expect(schema.safeParse(user).success).toBe(true);
+	});
+});

package/src/validations/user/user.validations.ts

@@ -0,0 +1,97 @@
+import type { ApiUser } from '@webitel/api-services/gen/models';
+import { z } from 'zod';
+
+import { i18nIssue } from '../_shared/i18nIssue';
+import { flexibleLookupSchema } from '../_shared/lookup.validations';
+import { variablePairSchema } from '../_shared/variablePair.validations';
+
+const digitsRegex = /^[0-9]*$/;
+
+export const userSchemaBase = z.object({
+	id: z.string().optional(),
+	name: z.string().min(1).default(''),
+	username: z.string().min(1).default(''),
+	password: z.string().optional().default(''),
+	extension: z
+		.string()
+		.optional()
+		.default('')
+		.refine((value) => !value || digitsRegex.test(value), i18nIssue('numeric')),
+	email: z.string().optional().default(''),
+	chatName: z.string().optional().default(''),
+	contact: flexibleLookupSchema.nullish().default({}),
+	roles: z.array(flexibleLookupSchema).optional().default([]),
+	license: z.array(z.any()).optional().default([]),
+	devices: z.array(flexibleLookupSchema).optional().default([]),
+	device: flexibleLookupSchema.nullish().default({}),
+	forcePasswordChange: z.boolean().optional().default(false),
+	generateDevice: z.boolean().optional().default(false),
+	variables: z.array(variablePairSchema).optional().default([]),
+});
+
+export const userSchema = userSchemaBase.superRefine((user, ctx) => {
+	if (!user.id && !user.password) {
+		ctx.addIssue({
+			code: 'custom',
+			path: [
+				'password',
+			],
+			...i18nIssue('required'),
+		});
+	}
+
+	user.variables?.forEach(({ key, value }, index) => {
+		if (value && !key) {
+			ctx.addIssue({
+				code: 'custom',
+				path: [
+					'variables',
+					index,
+					'key',
+				],
+				...i18nIssue('required'),
+			});
+		}
+		if (key && !value) {
+			ctx.addIssue({
+				code: 'custom',
+				path: [
+					'variables',
+					index,
+					'value',
+				],
+				...i18nIssue('required'),
+			});
+		}
+	});
+});
+
+export interface UserPasswordRules {
+	passwordRegExp?: string;
+	passwordValidationText?: string;
+}
+
+export const buildUserSchema = ({
+	passwordRegExp,
+	passwordValidationText,
+}: UserPasswordRules = {}) =>
+	userSchema.superRefine((user, ctx) => {
+		if (!passwordRegExp || !user.password) return;
+		if (new RegExp(passwordRegExp).test(user.password)) return;
+
+		ctx.addIssue({
+			code: 'custom',
+			path: [
+				'password',
+			],
+			...(passwordValidationText
+				? {
+						message: passwordValidationText,
+					}
+				: i18nIssue('isRegExpMatched')),
+		});
+	});
+
+export type UserFormShape = z.input<typeof userSchemaBase>;
+
+export type UserCard = Omit<ApiUser, keyof UserFormShape> & UserFormShape;