10251670939

Committed 05 Aug 2024 03:28PM UTC coverage: 0.43% (-15.3%) from 15.718%

Build # 10251670939

Build Type

Pull #8737

github

Committed by

web-flow

Commit Message

Merge 464be02f6 into b66db558a

Pull Request Pull Request #8737: Fixed upgrade roles form to display all addresses

Run Details

69 of 14007 branches covered (0.49%)

Branch coverage included in aggregate %.

0 of 11 new or added lines in 1 file covered. (0.0%)

3203 existing lines in 290 files now uncovered.

110 of 27655 relevant lines covered (0.4%)

0.01 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/packages/commonwealth/server/routes/groups/update_group_handler.ts

import { AppError } from '@hicommonwealth/core';
import { GroupAttributes, models } from '@hicommonwealth/model';
import { GroupMetadata } from '@hicommonwealth/schemas';
import { Requirement } from '@hicommonwealth/shared';
import z from 'zod';
import { ServerControllers } from '../../routing/router';
import { success, type TypedRequest, type TypedResponse } from '../../types';

type UpdateGroupParams = { id: string };
type UpdateGroupBody = {
  metadata: z.infer<typeof GroupMetadata>;
  requirements: Requirement[];
  topics?: number[];
};
type UpdateGroupResponse = GroupAttributes;

export const updateGroupHandler = async (
  controllers: ServerControllers,
  // @ts-expect-error StrictNullChecks
  req: TypedRequest<UpdateGroupBody, null, UpdateGroupParams>,
  res: TypedResponse<UpdateGroupResponse>,
) => {
  const { user, address } = req;

  const schema = z.object({
    params: z.object({
      id: z.coerce.number(),
    }),
    body: z.object({
      metadata: z
        .object({
          name: z.string(),
          description: z.string(),
          required_requirements: z.number().optional(),
        })
        .optional(),
      requirements: z.array(z.any()).min(1), // validated in controller
      topics: z.array(z.number()).optional(),
      allowList: z.array(z.number()).default([]),
    }),
  });
  const validationResult = schema.safeParse(req);
  if (validationResult.success === false) {
    throw new AppError(JSON.stringify(validationResult.error));
  }
  const {
    params: { id: groupId },
    body: { metadata, requirements, topics, allowList },
  } = validationResult.data;

  // @ts-expect-error StrictNullChecks
  const { metadata: oldGroupMetadata } = await models.Group.findByPk(groupId, {
    attributes: ['metadata'],
  });

  const [group, analyticsOptions] = await controllers.groups.updateGroup({
    // @ts-expect-error StrictNullChecks
    user,
    // @ts-expect-error StrictNullChecks
    address,
    groupId,
    metadata: metadata as Required<typeof metadata>,
    requirements,
    topics,
    allowList,
  });

  // refresh memberships in background if requirements or
  // required requirements updated
  if (
    requirements?.length > 0 ||
    group.metadata.required_requirements !==
      oldGroupMetadata.required_requirements
  ) {
    controllers.groups
      .refreshCommunityMemberships({
        communityId: group.community_id,
        groupId: group.id,
      })
      .catch(console.error);
  }

  controllers.analytics.track(analyticsOptions, req).catch(console.error);

  return success(res, group);
};

1	import { AppError } from '@hicommonwealth/core';
2	import { GroupAttributes, models } from '@hicommonwealth/model';
3	import { GroupMetadata } from '@hicommonwealth/schemas';
4	import { Requirement } from '@hicommonwealth/shared';
5	import z from 'zod';
6	import { ServerControllers } from '../../routing/router';
7	import { success, type TypedRequest, type TypedResponse } from '../../types';
8
9	type UpdateGroupParams = { id: string };
10	type UpdateGroupBody = {
11	metadata: z.infer<typeof GroupMetadata>;
12	requirements: Requirement[];
13	topics?: number[];
14	};
15	type UpdateGroupResponse = GroupAttributes;
16
UNCOV 17	export const updateGroupHandler = async (	×
18	controllers: ServerControllers,
19	// @ts-expect-error StrictNullChecks
20	req: TypedRequest<UpdateGroupBody, null, UpdateGroupParams>,
21	res: TypedResponse<UpdateGroupResponse>,
22	) => {
23	const { user, address } = req;	×
24
25	const schema = z.object({	×
26	params: z.object({
27	id: z.coerce.number(),
28	}),
29	body: z.object({
30	metadata: z
31	.object({
32	name: z.string(),
33	description: z.string(),
34	required_requirements: z.number().optional(),
35	})
36	.optional(),
37	requirements: z.array(z.any()).min(1), // validated in controller
38	topics: z.array(z.number()).optional(),
39	allowList: z.array(z.number()).default([]),
40	}),
41	});
42	const validationResult = schema.safeParse(req);	×
43	if (validationResult.success === false) {	×
44	throw new AppError(JSON.stringify(validationResult.error));	×
45	}
46	const {
47	params: { id: groupId },
48	body: { metadata, requirements, topics, allowList },
49	} = validationResult.data;	×
50
51	// @ts-expect-error StrictNullChecks
52	const { metadata: oldGroupMetadata } = await models.Group.findByPk(groupId, {	×
53	attributes: ['metadata'],
54	});
55
56	const [group, analyticsOptions] = await controllers.groups.updateGroup({	×
57	// @ts-expect-error StrictNullChecks
58	user,
59	// @ts-expect-error StrictNullChecks
60	address,
61	groupId,
62	metadata: metadata as Required<typeof metadata>,
63	requirements,
64	topics,
65	allowList,
66	});
67
68	// refresh memberships in background if requirements or
69	// required requirements updated
70	if (	×
71	requirements?.length > 0 \|\|	×
72	group.metadata.required_requirements !==
73	oldGroupMetadata.required_requirements
74	) {
75	controllers.groups	×
76	.refreshCommunityMemberships({
77	communityId: group.community_id,
78	groupId: group.id,
79	})
80	.catch(console.error);
81	}
82
83	controllers.analytics.track(analyticsOptions, req).catch(console.error);	×
84
85	return success(res, group);	×
86	};

hicommonwealth / commonwealth / 10251670939

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous