9571404177

Committed 18 Jun 2024 08:00PM UTC coverage: 8.371% (-6.8%) from 15.134%

Build # 9571404177

Build Type

Pull #8179

github

Committed by

web-flow

Commit Message

Merge 578888906 into f876fb111

Pull Request Pull Request #8179: Picasso migration + proxy fixes + community renaming fixes

Run Details

1925 of 24434 branches covered (7.88%)

Branch coverage included in aggregate %.

0 of 14 new or added lines in 7 files covered. (0.0%)

2012 existing lines in 233 files now uncovered.

2991 of 34292 relevant lines covered (8.72%)

2.08 hits per line

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

0.0

/packages/commonwealth/server/controllers/server_profiles_methods/search_profiles.ts

import { Op, QueryTypes } from 'sequelize';
import { TypedPaginatedResult } from 'server/types';

import { CommunityInstance } from '@hicommonwealth/model';
import { buildPaginatedResponse } from '@hicommonwealth/schemas';
import _ from 'lodash';
import { PaginationSqlOptions, buildPaginationSql } from '../../util/queries';
import { RoleInstanceWithPermission, findAllRoles } from '../../util/roles';
import { ServerProfilesController } from '../server_profiles_controller';

export const Errors = {};

export type SearchProfilesOptions = {
  community: CommunityInstance;
  search: string;
  includeRoles?: boolean;
  limit?: number;
  page?: number;
  orderBy?: string;
  orderDirection?: 'ASC' | 'DESC';
  includeGroupIds?: boolean;
  includeCount?: boolean;
};

type Profile = {
  id: number;
  user_id: string;
  profile_name: string;
  avatar_url: string;
  addresses: {
    id: number;
    community_id: string;
    address: string;
  }[];
  roles?: any[];
  group_ids: number[];
};
export type SearchProfilesResult = TypedPaginatedResult<Profile>;

export async function __searchProfiles(
  this: ServerProfilesController,
  {
    community,
    search,
    includeRoles,
    limit,
    page,
    orderBy,
    orderDirection,
    includeCount,
  }: SearchProfilesOptions,
): Promise<SearchProfilesResult> {
  let sortOptions: PaginationSqlOptions = {
    // @ts-expect-error StrictNullChecks
    limit: Math.min(limit, 100) || 10,
    page: page || 1,
    orderDirection,
    nullsLast: true,
  };
  switch (orderBy) {
    case 'created_at':
      sortOptions = {
        ...sortOptions,
        orderBy: `"Profiles".created_at`,
      };
      break;
    case 'profile_name':
      sortOptions = {
        ...sortOptions,
        orderBy: `"Profiles".profile_name`,
      };
      break;
    default:
      sortOptions = {
        ...sortOptions,
        orderBy: `last_active`,
      };
  }

  const { sql: paginationSort, bind: paginationBind } =
    buildPaginationSql(sortOptions);

  const bind: any = {
    searchTerm: `%${search}%`,
    ...paginationBind,
  };
  if (community) {
    bind.community_id = community.id;
  }

  const communityWhere = bind.community_id
    ? `"Addresses".community_id = $community_id AND`
    : '';

  const sqlWithoutPagination = `
    SELECT
      "Profiles".id,
      "Profiles".user_id,
      "Profiles".profile_name,
      "Profiles".avatar_url,
      "Profiles".created_at,
      array_agg("Addresses".id) as address_ids,
      array_agg("Addresses".community_id) as community_ids,
      array_agg("Addresses".address) as addresses,
      MAX("Addresses".last_active) as last_active
    FROM
      "Profiles"
    JOIN
      "Addresses" ON "Profiles".user_id = "Addresses".user_id
    WHERE
      ${communityWhere}
      (
        "Profiles".profile_name ILIKE '%' || $searchTerm || '%'
        OR
        "Addresses".address ILIKE '%' || $searchTerm || '%'
      )
    GROUP BY
      "Profiles".id
  `;

  const [results, [{ count }]]: [any[], any[]] = await Promise.all([
    // get profiles and aggregate all addresses for each profile
    this.models.sequelize.query(`${sqlWithoutPagination} ${paginationSort}`, {
      bind,
      type: QueryTypes.SELECT,
    }),
    !includeCount
      ? [{ count: 0 }]
      : this.models.sequelize.query(
          `SELECT COUNT(*) FROM ( ${sqlWithoutPagination} ) as count`,
          {
            bind,
            type: QueryTypes.SELECT,
          },
        ),
  ]);

  const totalResults = parseInt(count, 10);

  const profilesWithAddresses: Profile[] = results.map((profile: any) => {
    return {
      id: profile.id,
      user_id: profile.user_id,
      profile_name: profile.profile_name,
      avatar_url: profile.avatar_url,
      addresses: profile.address_ids.map((unused1, i) => ({
        id: profile.address_ids[i],
        community_id: profile.community_ids[i],
        address: profile.addresses[i],
      })),
      roles: [],
      group_ids: [],
    };
  });

  if (includeRoles) {
    const profileAddressIds = profilesWithAddresses.reduce((acc, p) => {
      const ids = p.addresses.map((addr) => addr.id);
      return [...acc, ...ids];
    }, []);

    const roles = await findAllRoles(
      this.models,
      {
        where: {
          address_id: {
            [Op.in]: _.uniq(profileAddressIds),
          },
        },
      },
      community?.id,
      ['member', 'moderator', 'admin'],
    );

    const addressIdRoles: Record<number, RoleInstanceWithPermission[]> = {};
    for (const role of roles) {
      const attributes = role.toJSON();
      addressIdRoles[attributes.address_id] = [];
      addressIdRoles[attributes.address_id].push(role);
    }

    // add roles to associated profiles in response
    for (const profile of profilesWithAddresses) {
      for (const address of profile.addresses) {
        const addressRoles = addressIdRoles[address.id] || [];
        for (const role of addressRoles) {
          // @ts-expect-error StrictNullChecks
          profile.roles.push(role.toJSON());
        }
      }
    }
  }

  return buildPaginatedResponse(profilesWithAddresses, totalResults, bind);
}

1	import { Op, QueryTypes } from 'sequelize';
2	import { TypedPaginatedResult } from 'server/types';
3
4	import { CommunityInstance } from '@hicommonwealth/model';
5	import { buildPaginatedResponse } from '@hicommonwealth/schemas';
6	import _ from 'lodash';
7	import { PaginationSqlOptions, buildPaginationSql } from '../../util/queries';
8	import { RoleInstanceWithPermission, findAllRoles } from '../../util/roles';
9	import { ServerProfilesController } from '../server_profiles_controller';
10
UNCOV 11	export const Errors = {};	×
12
13	export type SearchProfilesOptions = {
14	community: CommunityInstance;
15	search: string;
16	includeRoles?: boolean;
17	limit?: number;
18	page?: number;
19	orderBy?: string;
20	orderDirection?: 'ASC' \| 'DESC';
21	includeGroupIds?: boolean;
22	includeCount?: boolean;
23	};
24
25	type Profile = {
26	id: number;
27	user_id: string;
28	profile_name: string;
29	avatar_url: string;
30	addresses: {
31	id: number;
32	community_id: string;
33	address: string;
34	}[];
35	roles?: any[];
36	group_ids: number[];
37	};
38	export type SearchProfilesResult = TypedPaginatedResult<Profile>;
39
40	export async function __searchProfiles(
41	this: ServerProfilesController,
42	{
43	community,
44	search,
45	includeRoles,
46	limit,
47	page,
48	orderBy,
49	orderDirection,
50	includeCount,
51	}: SearchProfilesOptions,
52	): Promise<SearchProfilesResult> {
53	let sortOptions: PaginationSqlOptions = {	×
54	// @ts-expect-error StrictNullChecks
55	limit: Math.min(limit, 100) \|\| 10,	×
56	page: page \|\| 1,	×
57	orderDirection,
58	nullsLast: true,
59	};
60	switch (orderBy) {	×
61	case 'created_at':
62	sortOptions = {	×
63	...sortOptions,
64	orderBy: `"Profiles".created_at`,
65	};
66	break;	×
67	case 'profile_name':
68	sortOptions = {	×
69	...sortOptions,
70	orderBy: `"Profiles".profile_name`,
71	};
72	break;	×
73	default:
74	sortOptions = {	×
75	...sortOptions,
76	orderBy: `last_active`,
77	};
78	}
79
80	const { sql: paginationSort, bind: paginationBind } =
81	buildPaginationSql(sortOptions);	×
82
83	const bind: any = {	×
84	searchTerm: `%${search}%`,
85	...paginationBind,
86	};
87	if (community) {	×
88	bind.community_id = community.id;	×
89	}
90
91	const communityWhere = bind.community_id	×
92	? `"Addresses".community_id = $community_id AND`
93	: '';
94
95	const sqlWithoutPagination = `	×
96	SELECT
97	"Profiles".id,
98	"Profiles".user_id,
99	"Profiles".profile_name,
100	"Profiles".avatar_url,
101	"Profiles".created_at,
102	array_agg("Addresses".id) as address_ids,
103	array_agg("Addresses".community_id) as community_ids,
104	array_agg("Addresses".address) as addresses,
105	MAX("Addresses".last_active) as last_active
106	FROM
107	"Profiles"
108	JOIN
109	"Addresses" ON "Profiles".user_id = "Addresses".user_id
110	WHERE
111	${communityWhere}
112	(
113	"Profiles".profile_name ILIKE '%' \|\| $searchTerm \|\| '%'
114	OR
115	"Addresses".address ILIKE '%' \|\| $searchTerm \|\| '%'
116	)
117	GROUP BY
118	"Profiles".id
119	`;
120
121	const [results, [{ count }]]: [any[], any[]] = await Promise.all([	×
122	// get profiles and aggregate all addresses for each profile
123	this.models.sequelize.query(`${sqlWithoutPagination} ${paginationSort}`, {
124	bind,
125	type: QueryTypes.SELECT,
126	}),
127	!includeCount	×
128	? [{ count: 0 }]
129	: this.models.sequelize.query(
130	`SELECT COUNT(*) FROM ( ${sqlWithoutPagination} ) as count`,
131	{
132	bind,
133	type: QueryTypes.SELECT,
134	},
135	),
136	]);
137
138	const totalResults = parseInt(count, 10);	×
139
140	const profilesWithAddresses: Profile[] = results.map((profile: any) => {	×
141	return {	×
142	id: profile.id,
143	user_id: profile.user_id,
144	profile_name: profile.profile_name,
145	avatar_url: profile.avatar_url,
146	addresses: profile.address_ids.map((unused1, i) => ({	×
147	id: profile.address_ids[i],
148	community_id: profile.community_ids[i],
149	address: profile.addresses[i],
150	})),
151	roles: [],
152	group_ids: [],
153	};
154	});
155
156	if (includeRoles) {	×
157	const profileAddressIds = profilesWithAddresses.reduce((acc, p) => {	×
158	const ids = p.addresses.map((addr) => addr.id);	×
159	return [...acc, ...ids];	×
160	}, []);
161
162	const roles = await findAllRoles(	×
163	this.models,
164	{
165	where: {
166	address_id: {
167	[Op.in]: _.uniq(profileAddressIds),
168	},
169	},
170	},
171	community?.id,
172	['member', 'moderator', 'admin'],
173	);
174
175	const addressIdRoles: Record<number, RoleInstanceWithPermission[]> = {};	×
176	for (const role of roles) {	×
177	const attributes = role.toJSON();	×
178	addressIdRoles[attributes.address_id] = [];	×
179	addressIdRoles[attributes.address_id].push(role);	×
180	}
181
182	// add roles to associated profiles in response
183	for (const profile of profilesWithAddresses) {	×
184	for (const address of profile.addresses) {	×
185	const addressRoles = addressIdRoles[address.id] \|\| [];	×
186	for (const role of addressRoles) {	×
187	// @ts-expect-error StrictNullChecks
188	profile.roles.push(role.toJSON());	×
189	}
190	}
191	}
192	}
193
194	return buildPaginatedResponse(profilesWithAddresses, totalResults, bind);	×
195	}

hicommonwealth / commonwealth / 9571404177

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