Исправления и улучшения пользовательского опыта

src/api/v_0.1.0/client/client-activities-api.ts

@@ -71,6 +71,7 @@ class ClientActivitiesApi {
             name: z.string(),
           }),
         ),
+        validators: z.array(actTypes.ActValidator),
 
         validatedPes: z.array(
           z.object({
@@ -131,12 +132,25 @@ class ClientActivitiesApi {
       actReg: z.discriminatedUnion("role", [
         actTypes.ActivityRegWithFields.extend({
           role: z.literal("owner"),
-          peMembers: z
-            .array(
-              PeMemberWithIdentityShema.extend({
-                isPaid: z.boolean(),
-              }),
-            )
+          pe: z
+            .object({
+              peId: z.string().uuid(),
+              peTypeCode: z.string(),
+              peTypeName: z.string(),
+              name: z.string(),
+              members: z.array(
+                PeMemberWithIdentityShema.extend({
+                  isPaid: z.boolean(),
+                }),
+              ),
+            })
+            .optional(),
+          user: z
+            .object({
+              userId: z.string().uuid(),
+              isChild: z.boolean(),
+              identity: z.string(),
+            })
             .optional(),
         }),
         actTypes.ActivityReg.extend({ role: z.literal("member") }),
@@ -222,6 +236,34 @@ class ClientActivitiesApi {
       code: z.enum(["success"]),
     }),
   };
+
+  GET_ActWithActValidators = {
+    req: {
+      params: z.object({
+        activityCode: z.string(),
+      }),
+    },
+    res: z.object({
+      code: z.enum(["success"]),
+      actPeValidators: z.object({
+        activityId: z.string().uuid(),
+        code: z.string(),
+        publicName: z.string(),
+        eventInstId: z.string().uuid(),
+        categoryId: z.string().uuid().nullable(),
+        categoryCode: z.string(),
+        validators: z.array(actTypes.ActValidator),
+        peTypes: z.array(
+          z.object({
+            peTypeId: z.string().uuid(),
+            code: z.string(),
+            name: z.string(),
+          }),
+        ),
+        isUserReg: z.boolean(),
+      }),
+    }),
+  };
 }
 
 export const clientActivitiesApi = new ClientActivitiesApi();

src/api/v_0.1.0/client/client-pe-api.ts

@@ -269,7 +269,7 @@ class ClientPartEntitiesApi {
     }),
   };
 
-  POST_AcceptInvite = {
+  POST_SendInvite = {
     req: {
       params: z.object({
         peInviteUuid: z.string().uuid(),
@@ -293,7 +293,10 @@ class ClientPartEntitiesApi {
         code: z.literal("peMemberAlreadyExists"),
       }),
       z.object({
-        code: z.literal("peMemberInviteAlreadyExists"),
+        code: z.literal("peMemberInvitePending"),
+      }),
+      z.object({
+        code: z.literal("peMemberInviteRejected"),
       }),
       z.object({
         code: z.literal("inviteExpired"),

src/api/v_0.1.0/client/client-users-api.ts

@@ -68,6 +68,7 @@ class ClientUsersApi {
     },
     res: z.object({
       code: z.enum(["success"]),
+      childId: z.string().uuid(),
     }),
   };
 

src/api/v_0.1.0/types/act-types.ts

@@ -74,6 +74,7 @@ class ActTypes {
 
   ActivityReg = z.object({
     activityRegId: z.string().uuid(),
+    activityRegNumber: z.string(),
     activityId: z.string().uuid(),
     activityCode: z.string(),
     activityPublicName: z.string(),

src/db/db-schema.ts

@@ -157,7 +157,7 @@ const DbSchema = {
       actValidatorId: z.string().uuid(),
       code: z.string(),
       name: z.string(),
-      description: z.string(),
+      note: z.string(),
       isPeValidator: z.boolean(),
     },
     actRegValidators: {
@@ -166,6 +166,7 @@ const DbSchema = {
       value: z.string().nullable(),
       value2: z.string().nullable(),
       errorMessage: z.string().nullable(),
+      description: z.string().nullable(),
     },
 
     activities: {

src/modules/client/activities/c-act-controller.ts

@@ -25,6 +25,7 @@ import { cActService } from "./c-act-service.js";
 import { validatePeForAct } from "./validators/act-pe-validators.js";
 import { generateRandomNumber } from "#utils/other-utils.js";
 import { PeMemberWithIdentityShema } from "#api/v_0.1.0/types/pe-types.js";
+import { cUsersService } from "../users/c-users-service.js";
 
 class ClientActivitiesController {
   async getEventActivities(
@@ -285,12 +286,34 @@ class ClientActivitiesController {
           isUserReg: actRegData.isUserReg,
           peTypes: actRegData.peTypes,
           fields: actRegData.fields,
+          validators: actRegData.validators,
           validatedPes: validatedPes,
         },
       },
     );
   }
 
+  async getActWithActValidators(req: Request, res: Response) {
+    const { activityCode } =
+      api.client.activities.GET_ActWithActValidators.req.params.parse(
+        req.params,
+      );
+
+    const actPeValidators =
+      await cActService.getActWithActValidators(activityCode);
+    if (!actPeValidators)
+      throw ApiError.BadRequest("actNotFound", "Данные мероприятия не найдены");
+
+    RouterUtils.validAndSendResponse(
+      api.client.activities.GET_ActWithActValidators.res,
+      res,
+      {
+        code: "success",
+        actPeValidators: actPeValidators,
+      },
+    );
+  }
+
   async registerToAct(req: Request, res: Response) {
     const { fields, peId } =
       api.client.activities.POST_RegisterToAct.req.body.parse(
@@ -491,13 +514,37 @@ class ClientActivitiesController {
           "Регистрация на мероприятии не найдена",
         );
 
-      let peMembers:
-        | (z.infer<typeof PeMemberWithIdentityShema> & { isPaid: boolean })[]
+      let pe:
+        | {
+            peId: string;
+            peTypeCode: string;
+            peTypeName: string;
+            name: string;
+            members: (z.infer<typeof PeMemberWithIdentityShema> & {
+              isPaid: boolean;
+            })[];
+          }
+        | undefined = undefined;
+      let user:
+        | {
+            userId: string;
+            isChild: boolean;
+            identity: string;
+          }
         | undefined = undefined;
 
       if (r.peId) {
-        const m = [...(await cPeService.getPeMembersWithIdentity(r.peId))];
-        peMembers = await Promise.all(
+        const _pe = await cPeService.getPeForMember(r.peId);
+        if (!_pe)
+          throw ApiError.BadRequest(
+            "peNotFound",
+            "Сущность участия не найдена",
+          );
+
+        const m = [
+          ...(await cPeService.getActivePeMembersWithIdentity(r.peId)),
+        ];
+        const peMembers = await Promise.all(
           m.map(async (m) => ({
             ...m,
             // TODO: слишком много операций, проще одним запросом вместо getPeMembersWithIdentity
@@ -507,11 +554,27 @@ class ClientActivitiesController {
             }),
           })),
         );
+        pe = {
+          ..._pe,
+          members: peMembers,
+        };
+      } else if (r.isUserReg && r.userId) {
+        const _user = await cUsersService.getUserWithIdentity(r.userId);
+        if (!_user)
+          throw ApiError.BadRequest("userNotFound", "Пользователь не найден");
+
+        user = _user;
+      } else {
+        throw ApiError.BadRequest(
+          "actRegNotFound",
+          "Регистрация на мероприятии не найдена",
+        );
       }
 
       actReg = {
         ...r,
-        peMembers,
+        pe,
+        user,
         role,
       };
     } else {

src/modules/client/activities/c-act-router.ts

@@ -55,3 +55,8 @@ router.get(
   "/:activityCode",
   RouterUtils.asyncHandler(clientActController.getActivity),
 );
+
+router.get(
+  "/:activityCode/withActValidators",
+  RouterUtils.asyncHandler(clientActController.getActWithActValidators),
+);

src/modules/client/activities/c-act-service.ts

@@ -67,6 +67,7 @@ class CActService {
     const actRegsOwner = await selPool.any(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -93,6 +94,7 @@ class CActService {
     )`
       select
         ar.activity_reg_id "activityRegId",
+        ar.number "activityRegNumber",
         ar.activity_id "activityId",
         ar.activity_code "activityCode",
         ar.activity_public_name "activityPublicName",
@@ -115,6 +117,7 @@ class CActService {
     const actRegsMember = await selPool.any(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -141,6 +144,7 @@ class CActService {
     )`
       select
         ar.activity_reg_id "activityRegId",
+        ar.number "activityRegNumber",
         ar.activity_id "activityId",
         ar.activity_code "activityCode",
         ar.activity_public_name "activityPublicName",
@@ -167,6 +171,7 @@ class CActService {
     const actRegsChildrenMember = await selPool.any(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -193,6 +198,7 @@ class CActService {
     )`
 select distinct -- DISTINCT нужен для удаления дубликатов, если несколько детей соответствуют условию
   ar.activity_reg_id "activityRegId",
+  ar.number "activityRegNumber",
   ar.activity_id "activityId",
   ar.activity_code "activityCode",
   ar.activity_public_name "activityPublicName",
@@ -227,6 +233,7 @@ where
     const actReg = await selPool.maybeOne(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -260,6 +267,7 @@ where
     )`
       select
         ar.activity_reg_id "activityRegId",
+        ar.number "activityRegNumber",
         ar.activity_id "activityId",
         ar.activity_code "activityCode",
         ar.activity_public_name "activityPublicName",
@@ -284,6 +292,7 @@ where
     const actReg = await selPool.maybeOne(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -310,6 +319,7 @@ where
     )`
       select
         ar.activity_reg_id "activityRegId",
+        ar.number "activityRegNumber",
         ar.activity_id "activityId",
         ar.activity_code "activityCode",
         ar.activity_public_name "activityPublicName",
@@ -729,6 +739,7 @@ where
     return selPool.maybeOne(sql.type(
       z.object({
         activityRegId: DbSchema.act.activityRegs.activityRegId,
+        activityRegNumber: DbSchema.act.activityRegs.number,
         activityId: DbSchema.act.activityRegs.activityId,
         activityCode: DbSchema.act.activities.code,
         activityPublicName: DbSchema.act.activities.publicName,
@@ -762,6 +773,7 @@ where
     )`
       select
         ar.activity_reg_id "activityRegId",
+        ar.number "activityRegNumber",
         ar.activity_id "activityId",
         ar.activity_code "activityCode",
         ar.activity_public_name "activityPublicName",
@@ -942,6 +954,42 @@ where
       `);
     }
   }
+
+  async getActWithActValidators(activityCode: string) {
+    return await selPool.maybeOne(sql.type(
+      z.object({
+        activityId: DbSchema.act.activities.activityId,
+        code: DbSchema.act.activities.code,
+        publicName: DbSchema.act.activities.publicName,
+        eventInstId: DbSchema.act.activities.eventInstId,
+        categoryId: DbSchema.act.activities.categoryId,
+        categoryCode: DbSchema.act.activityCategories.code,
+        validators: z.array(apiTypes.activities.ActValidator),
+        peTypes: z.array(
+          z.object({
+            peTypeId: DbSchema.act.peTypes.peTypeId,
+            code: DbSchema.act.peTypes.code,
+            name: DbSchema.act.peTypes.name,
+          }),
+        ),
+        isUserReg: DbSchema.act.activities.isUserReg,
+      }),
+    )`
+            select
+              a.activity_id "activityId",
+              a.code,
+              a.public_name "publicName",
+              a.event_inst_id "eventInstId",
+              a.category_id "categoryId",
+              a.category_code "categoryCode",
+              a.validators,
+              a.pe_types "peTypes",
+              a.is_user_reg "isUserReg"
+            from
+              act.act_with_validators a
+            where a.code = ${activityCode}
+          `);
+  }
 }
 
 export const cActService = new CActService();

src/modules/client/activities/participant-entities/c-pe-controller.ts

@@ -400,7 +400,7 @@ class ClientPeController {
     // валделец
     if (isOwner) {
       const pe = await cPeService.getPeWithValues(peId);
-      const members = await cPeService.getPeMembersWithIdentity(peId);
+      const members = await cPeService.getActivePeMembersWithIdentity(peId);
       const invites = await cPeService.getInvites(peId);
       const peMembersRequests = await cPeService.getPeMembersRequests(peId);
 
@@ -564,21 +564,12 @@ class ClientPeController {
       req.params,
     );
 
-    const user = sessionService.getUserFromReq(req);
-
     const invite = await cPeService.getInviteInfo(peInviteUuid);
     if (!invite)
       throw ApiError.BadRequest("inviteNotFound", "Приглашение не найдено");
 
-    const request = await cPeService.checkPeMemberInvite({
-      peInviteId: invite.peInviteId,
-      userId: user.userId,
-    });
-
     if (dayjs(invite.expirationDate).isBefore(dayjs()))
       throw ApiError.BadRequest("inviteExpired", "Приглашение истекло");
-    if (request)
-      throw ApiError.BadRequest("requestAlreadyExists", "Запрос уже отправлен");
 
     RouterUtils.validAndSendResponse(api.client.pe.GET_InviteInfo.res, res, {
       code: "success",
@@ -586,12 +577,12 @@ class ClientPeController {
     });
   }
 
-  async acceptInvite(req: Request, res: Response) {
+  async sendInvite(req: Request, res: Response) {
     const user = sessionService.getUserFromReq(req);
-    const { peInviteUuid } = api.client.pe.POST_AcceptInvite.req.params.parse(
+    const { peInviteUuid } = api.client.pe.POST_SendInvite.req.params.parse(
       req.params,
     );
-    const { childId } = api.client.pe.POST_AcceptInvite.req.query.parse(
+    const { childId } = api.client.pe.POST_SendInvite.req.query.parse(
       req.query,
     );
 
@@ -611,7 +602,7 @@ class ClientPeController {
     // приглашение не найдено
     if (!invite) {
       RouterUtils.validAndSendResponse(
-        api.client.pe.POST_AcceptInvite.res,
+        api.client.pe.POST_SendInvite.res,
         res,
         {
           code: "inviteNotFound",
@@ -621,10 +612,16 @@ class ClientPeController {
       return;
     }
 
-    const pe = await selPool.maybeOne(sql.unsafe`
+    const pe = await selPool.maybeOne(sql.type(
+      z.object({
+        peId: DbSchema.act.partEntities.peId,
+        maxMembers: DbSchema.act.peTypes.maxMembers,
+        membersCount: z.number().int().nullable(),
+      }),
+    )`
       select
-        pe.pe_id,
-        pt.max_members,
+        pe.pe_id "peId",
+        pt.max_members "maxMembers" ,
         members."membersCount"
       from
         act.part_entities pe
@@ -653,10 +650,12 @@ class ClientPeController {
     // лимит превышен
     if (
       (invite.limitVal && invite.countVal >= invite.limitVal) ||
-      (pe.maxMembers !== null && pe.membersCount >= pe.maxMembers)
+      (pe.maxMembers !== null &&
+        pe.membersCount &&
+        pe.membersCount >= pe.maxMembers)
     ) {
       RouterUtils.validAndSendResponse(
-        api.client.pe.POST_AcceptInvite.res,
+        api.client.pe.POST_SendInvite.res,
         res,
         {
           code: "inviteLimitExceeded",
@@ -672,7 +671,7 @@ class ClientPeController {
       dayjs(invite.expirationDate).isBefore(dayjs())
     ) {
       RouterUtils.validAndSendResponse(
-        api.client.pe.POST_AcceptInvite.res,
+        api.client.pe.POST_SendInvite.res,
         res,
         {
           code: "inviteExpired",
@@ -682,15 +681,14 @@ class ClientPeController {
       return;
     }
 
-    // TODO: много лишних данных
     // участник уже в pe
-    const peMembers = await cPeService.getPeMembersWithFields(invite.peId);
-    const isFound = peMembers.find(
-      (m) => m.userId === (childId || user.userId),
-    );
-    if (isFound) {
+    const peMember = await cPeService.checkPeMemberForInvite({
+      peId: invite.peId,
+      userId: childId || user.userId,
+    });
+    if (peMember && peMember.isActive) {
       RouterUtils.validAndSendResponse(
-        api.client.pe.POST_AcceptInvite.res,
+        api.client.pe.POST_SendInvite.res,
         res,
         {
           code: "peMemberAlreadyExists",
@@ -701,22 +699,36 @@ class ClientPeController {
     }
 
     // запрос уже отправлен
-    const isPending = await cPeService.checkPeMemberInvite({
-      peInviteId: invite.peInviteId,
+    const foundedInvite = await cPeService.getPeMemberInvite({
+      peId: pe.peId,
       userId: childId || user.userId,
     });
-    if (isPending) {
-      RouterUtils.validAndSendResponse(
-        api.client.pe.POST_AcceptInvite.res,
-        res,
-        {
-          code: "peMemberInviteAlreadyExists",
-        },
-        400,
-      );
-      return;
+    if (foundedInvite) {
+      if (foundedInvite.status === "PENDING") {
+        RouterUtils.validAndSendResponse(
+          api.client.pe.POST_SendInvite.res,
+          res,
+          {
+            code: "peMemberInvitePending",
+          },
+          400,
+        );
+        return;
+      }
+      if (foundedInvite.status === "REJECTED") {
+        RouterUtils.validAndSendResponse(
+          api.client.pe.POST_SendInvite.res,
+          res,
+          {
+            code: "peMemberInviteRejected",
+          },
+          400,
+        );
+        return;
+      }
     }
 
+    // TODO: зпменить везде где проверка с || на ??
     await updPool.transaction(async (t) => {
       const id = v7();
       await t.query(sql.unsafe`
@@ -735,7 +747,7 @@ class ClientPeController {
     `);
     });
 
-    RouterUtils.validAndSendResponse(api.client.pe.POST_AcceptInvite.res, res, {
+    RouterUtils.validAndSendResponse(api.client.pe.POST_SendInvite.res, res, {
       code: "success",
       peId: invite.peId,
     });
@@ -766,9 +778,11 @@ class ClientPeController {
         if (pe.ownerId !== user.userId) throw ApiError.ForbiddenError();
 
         // участник уже в pe
-        const peMembers = await cPeService.getPeMembersWithFields(pe.peId);
-        const isFound = peMembers.find((m) => m.userId === request.userId);
-        if (isFound)
+        const peMember = await cPeService.checkPeMemberForInvite({
+          peId: pe.peId,
+          userId: request.userId,
+        });
+        if (peMember && peMember.isActive)
           throw ApiError.BadRequest(
             "memberAlreadyInPe",
             "Участник уже добавлен",
@@ -784,12 +798,23 @@ class ClientPeController {
         `);
 
         if (r.status === "ACCEPTED") {
-          await t.query(sql.unsafe`
+          if (!peMember) {
+            await t.query(sql.unsafe`
             insert into act.pe_members
               (pe_id, user_id)
             values
               (${pe.peId}, ${request.userId})
           `);
+          } else {
+            await t.query(sql.unsafe`
+              update act.pe_members
+              set
+                is_active = true
+              where
+                pe_id = ${pe.peId} and
+                user_id = ${request.userId}
+              `);
+          }
         }
       }
     });

src/modules/client/activities/participant-entities/c-pe-router.ts

@@ -68,8 +68,8 @@ router.get(
 );
 
 router.post(
-  "/invite/:peInviteUuid/accept",
-  RouterUtils.asyncHandler(clientPeController.acceptInvite),
+  "/invite/:peInviteUuid/send",
+  RouterUtils.asyncHandler(clientPeController.sendInvite),
 );
 
 router.delete(

src/modules/client/activities/participant-entities/c-pe-service.ts

@@ -400,21 +400,25 @@ class CPeService {
     `);
   }
 
-  async checkPeMemberInvite({
-    peInviteId,
-    userId,
-  }: {
-    peInviteId: string;
-    userId: string;
-  }) {
-    return await selPool.exists(sql.unsafe`
+  async getPeMemberInvite({ peId, userId }: { peId: string; userId: string }) {
+    return await selPool.maybeOne(sql.type(
+      z.object({
+        peInviteId: DbSchema.act.peInvites.peInviteId,
+        status: DbSchema.act.peMembersRequests.status,
+      }),
+    )`
       select
-        1
+        i.pe_invite_id "peInviteId",
+        r.status
       from
         act.pe_members_requests r
+      join act.pe_invites i on
+        i.pe_invite_id = r.pe_invite_id
       where
-        r.pe_invite_id = ${peInviteId}
+        i.pe_id = ${peId}
         and r.user_id = ${userId}
+      order by r.updated_at desc
+      limit 1
     `);
   }
 
@@ -465,7 +469,7 @@ class CPeService {
     }
   }
 
-  async getPeMembersWithIdentity(peId: string) {
+  async getActivePeMembersWithIdentity(peId: string) {
     return await selPool.any(sql.type(
       z.object({
         peMemberId: DbSchema.act.peMembers.peMemberId,
@@ -487,6 +491,30 @@ class CPeService {
     `);
   }
 
+  async checkPeMemberForInvite({
+    peId,
+    userId,
+  }: {
+    peId: string;
+    userId: string;
+  }) {
+    return await selPool.maybeOne(sql.type(
+      z.object({
+        peMemberId: DbSchema.act.peMembers.peMemberId,
+        isActive: DbSchema.act.peMembers.isActive,
+      }),
+    )`
+      select
+        pm.pe_member_id "peMemberId",
+        pm.is_active "isActive"
+      from
+        act.pe_members pm
+      where
+        pm.pe_id = ${peId} and
+        pm.user_id = ${userId}
+    `);
+  }
+
   async getPeMember(peMemberId: string) {
     return await selPool.maybeOne(sql.type(
       z.object({

src/modules/client/users/c-users-service.ts

@@ -107,6 +107,27 @@ class CUsersService {
     );
   }
 
+  async getUserWithIdentity(userId: string) {
+    return await selPool.maybeOne(sql.type(
+      z.object({
+        userId: DbSchema.usr.users.userId,
+        isChild: DbSchema.usr.users.isChild,
+        identity: z.string(),
+      }),
+    )`
+      select 
+        ui.user_id as "userId",
+        u.is_child as "isChild",
+        ui.identity as "identity"
+      from
+        usr.users u
+        left join ev.users_identity ui on
+          ui.user_id = u.user_id
+      where
+        u.user_id = ${userId}
+      `);
+  }
+
   async getChildrens(parentId: string) {
     return await selPool.any(sql.type(
       z.object({

src/modules/client/users/children-controller.ts

@@ -17,7 +17,7 @@ class ChildrenController {
 
     const event = await sessionService.getCurrentEventFromReq(req);
     const files = req.files;
-    const user = await sessionService.getUserFromReq(req);
+    const user = sessionService.getUserFromReq(req);
 
     // поля пользователя
     const userData = await cUsersService.getUserEventFieldsWithValidators(
@@ -58,19 +58,19 @@ class ChildrenController {
 
     const validatedFields = validationResult.checkedfields;
     // вставляем в базу и сохраняем файлы
-    const userId = uuidv7();
+    const childId = uuidv7();
     await updPool.transaction(async (tr) => {
       await tr.query(
         sql.unsafe`
               insert into usr.users 
                 (user_id, is_child, parent_id) 
               values 
-                (${userId}, true, ${user.userId})`,
+                (${childId}, true, ${user.userId})`,
       );
 
       await cCustomFieldsValidateService.saveCustomFieldValuesInTransaction({
         tr,
-        parentId: userId,
+        parentId: childId,
         action: "userProfile",
         inputFields: validatedFields,
         files,
@@ -80,6 +80,7 @@ class ChildrenController {
 
     RouterUtils.validAndSendResponse(api.client.users.POST_Child.res, res, {
       code: "success",
+      childId: childId,
     });
   }