9552415325

Committed 17 Jun 2024 05:56PM UTC coverage: 12.837% (-0.008%) from 12.845%

Build # 9552415325

Build Type

Pull #8138

github

Committed by

web-flow

Commit Message

Merge 73589cb8e into ea44a68a7

Pull Request Pull Request #8138: Contest rollover fix

Run Details

3839 of 35372 branches covered (10.85%)

Branch coverage included in aggregate %.

4 of 36 new or added lines in 5 files covered. (11.11%)

4 existing lines in 2 files now uncovered.

5186 of 34935 relevant lines covered (14.84%)

4.79 hits per line

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

4.17

/libs/model/src/policies/ContestWorker.policy.ts

import { events, logger, Policy } from '@hicommonwealth/core';
import { QueryTypes } from 'sequelize';
import { fileURLToPath } from 'url';
import { models } from '../database';
import { contestHelper } from '../services/commonProtocol';
import { buildThreadContentUrl } from '../utils';

const __filename = fileURLToPath(import.meta.url);
const log = logger(__filename);

const inputs = {
  ThreadCreated: events.ThreadCreated,
  ThreadUpvoted: events.ThreadUpvoted,
};

export function ContestWorker(): Policy<typeof inputs> {
  return {
    inputs,
    body: {
      ThreadCreated: async ({ payload }) => {
        if (!payload.topic_id) {
          log.warn('ThreadCreated: payload does not contain topic_id');
          return;
        }

        const { address: userAddress } = (await models.Address.findByPk(
          payload!.address_id,
        ))!;

        const contentUrl = buildThreadContentUrl(
          payload.community_id!,
          payload.id!,
        );

        const activeContestManagers = await models.sequelize.query<{
          contest_address: string;
          url: string;
          private_url: string;
        }>(
          `
            SELECT COALESCE(cn.private_url, cn.url) as url, cm.contest_address
            FROM "Communities" c
            JOIN "ChainNodes" cn ON c.chain_node_id = cn.id
            JOIN "ContestManagers" cm ON cm.community_id = c.id
            JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
            WHERE ct.topic_id = :topic_id
            AND cm.community_id = :community_id
            AND cm.cancelled = false
        `,
          {
            type: QueryTypes.SELECT,
            replacements: {
              topic_id: payload.topic_id!,
              community_id: payload.community_id,
            },
          },
        );

        if (!activeContestManagers?.length) {
          log.warn('ThreadCreated: no contest managers found');
          return;
        }

        const chainNodeUrl = activeContestManagers[0]!.url;

        const addressesToProcess = activeContestManagers.map(
          (c) => c.contest_address,
        );

        log.debug(
          `ThreadCreated: addresses to process: ${JSON.stringify(
            addressesToProcess,
            null,
            2,
          )}`,
        );

        const results = await contestHelper.addContentBatch(
          chainNodeUrl!,
          addressesToProcess,
          userAddress,
          contentUrl,
        );

        const errors = results
          .filter(({ status }) => status === 'rejected')
          .map(
            (result) =>
              (result as PromiseRejectedResult).reason || '<unknown reason>',
          );

        if (errors.length > 0) {
          // TODO: ignore duplicate content error
          throw new Error(
            `addContent failed with errors: ${errors.join(', ')}"`,
          );
        }
      },
      ThreadUpvoted: async ({ payload }) => {
        const { topic_id } = (await models.Thread.findByPk(payload.thread_id!, {
          attributes: ['topic_id'],
        }))!;
        if (!topic_id) {
          log.warn('ThreadUpvoted: thread does not contain topic_id');
          return;
        }

        const { address: userAddress } = (await models.Address.findByPk(
          payload!.address_id,
        ))!;

        const activeContestManagersWithoutVote = await models.sequelize.query<{
          url: string;
          private_url: string;
          contest_address: string;
          content_id: number;
        }>(
          `
            SELECT coalesce(cn.private_url, cn.url) as url, cm.contest_address, added.content_id
            FROM "Communities" c
            JOIN "ChainNodes" cn ON c.chain_node_id = cn.id
            JOIN "ContestManagers" cm ON cm.community_id = c.id
            JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
            JOIN "Contests" co ON cm.contest_address = co.contest_address
            JOIN "ContestActions" added on co.contest_address = added.contest_address
              AND co.contest_id = added.contest_id
              AND added.thread_id = :thread_id
              AND added.action = 'added'
            LEFT JOIN "ContestActions" ca ON co.contest_address = ca.contest_address
              AND co.contest_id = ca.contest_id
              AND ca.thread_id = :thread_id
              AND ca.actor_address = :actor_address
              AND ca.action = 'upvoted'
            WHERE ct.topic_id = :topic_id
            AND cm.community_id = :community_id
            AND cm.cancelled = false
            AND NOW() > co.start_time
            AND ca.action IS NULL;
        `,
          {
            type: QueryTypes.SELECT,
            replacements: {
              thread_id: payload.thread_id!,
              actor_address: userAddress,
              topic_id: topic_id,
              community_id: payload.community_id,
            },
          },
        );

        if (!activeContestManagersWithoutVote?.length) {
          // throw to trigger retry in case the content is pending creation
          throw new Error(
            'ThreadUpvoted: no matching active contests without actions',
          );
        }

        const chainNodeUrl = activeContestManagersWithoutVote[0]!.url;

        log.debug(
          `ThreadUpvoted: contest managers to process: ${JSON.stringify(
            activeContestManagersWithoutVote,
            null,
            2,
          )}`,
        );

        const results = await contestHelper.voteContentBatch(
          chainNodeUrl!,
          userAddress,
          activeContestManagersWithoutVote.map((m) => ({
            contestAddress: m.contest_address,
            contentId: m.content_id.toString(),
          })),
        );

        const errors = results
          .filter(({ status }) => status === 'rejected')
          .map(
            (result) =>
              (result as PromiseRejectedResult).reason || '<unknown reason>',
          );

        if (errors.length > 0) {
          throw new Error(
            `voteContent failed ${errors.length} times: ${errors.join(', ')}"`,
          );
        }
      },
    },
  };
}

1	import { events, logger, Policy } from '@hicommonwealth/core';
2	import { QueryTypes } from 'sequelize';
3	import { fileURLToPath } from 'url';
4	import { models } from '../database';
5	import { contestHelper } from '../services/commonProtocol';
6	import { buildThreadContentUrl } from '../utils';
7
8	const __filename = fileURLToPath(import.meta.url);	12✔
9	const log = logger(__filename);	12✔
10
11	const inputs = {	12✔
12	ThreadCreated: events.ThreadCreated,
13	ThreadUpvoted: events.ThreadUpvoted,
14	};
15
16	export function ContestWorker(): Policy<typeof inputs> {
17	return {	×
18	inputs,
19	body: {
20	ThreadCreated: async ({ payload }) => {
21	if (!payload.topic_id) {	×
22	log.warn('ThreadCreated: payload does not contain topic_id');	×
23	return;	×
24	}
25
26	const { address: userAddress } = (await models.Address.findByPk(	×
27	payload!.address_id,
28	))!;
29
30	const contentUrl = buildThreadContentUrl(	×
31	payload.community_id!,
32	payload.id!,
33	);
34
NEW 35	const activeContestManagers = await models.sequelize.query<{	×
36	contest_address: string;
37	url: string;
38	private_url: string;
39	}>(
40	`
41	SELECT COALESCE(cn.private_url, cn.url) as url, cm.contest_address
42	FROM "Communities" c
43	JOIN "ChainNodes" cn ON c.chain_node_id = cn.id
44	JOIN "ContestManagers" cm ON cm.community_id = c.id
45	JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
46	WHERE ct.topic_id = :topic_id
47	AND cm.community_id = :community_id
48	AND cm.cancelled = false
49	`,
50	{
51	type: QueryTypes.SELECT,
52	replacements: {
53	topic_id: payload.topic_id!,
54	community_id: payload.community_id,
55	},
56	},
57	);
58
NEW 59	if (!activeContestManagers?.length) {	×
NEW 60	log.warn('ThreadCreated: no contest managers found');	×
UNCOV 61	return;	×
62	}
63
NEW 64	const chainNodeUrl = activeContestManagers[0]!.url;	×
65
NEW 66	const addressesToProcess = activeContestManagers.map(	×
67	(c) => c.contest_address,	×
68	);
69
NEW 70	log.debug(	×
71	`ThreadCreated: addresses to process: ${JSON.stringify(
72	addressesToProcess,
73	null,
74	2,
75	)}`,
76	);
77
UNCOV 78	const results = await contestHelper.addContentBatch(	×
79	chainNodeUrl!,
80	addressesToProcess,
81	userAddress,
82	contentUrl,
83	);
84
85	const errors = results	×
86	.filter(({ status }) => status === 'rejected')	×
87	.map(
88	(result) =>
89	(result as PromiseRejectedResult).reason \|\| '<unknown reason>',	×
90	);
91
92	if (errors.length > 0) {	×
93	// TODO: ignore duplicate content error
UNCOV 94	throw new Error(	×
95	`addContent failed with errors: ${errors.join(', ')}"`,
96	);
97	}
98	},
99	ThreadUpvoted: async ({ payload }) => {
100	const { topic_id } = (await models.Thread.findByPk(payload.thread_id!, {	×
101	attributes: ['topic_id'],
102	}))!;
103	if (!topic_id) {	×
104	log.warn('ThreadUpvoted: thread does not contain topic_id');	×
105	return;	×
106	}
107
108	const { address: userAddress } = (await models.Address.findByPk(	×
109	payload!.address_id,
110	))!;
111
NEW 112	const activeContestManagersWithoutVote = await models.sequelize.query<{	×
113	url: string;
114	private_url: string;
115	contest_address: string;
116	content_id: number;
117	}>(
118	`
119	SELECT coalesce(cn.private_url, cn.url) as url, cm.contest_address, added.content_id
120	FROM "Communities" c
121	JOIN "ChainNodes" cn ON c.chain_node_id = cn.id
122	JOIN "ContestManagers" cm ON cm.community_id = c.id
123	JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
124	JOIN "Contests" co ON cm.contest_address = co.contest_address
125	JOIN "ContestActions" added on co.contest_address = added.contest_address
126	AND co.contest_id = added.contest_id
127	AND added.thread_id = :thread_id
128	AND added.action = 'added'
129	LEFT JOIN "ContestActions" ca ON co.contest_address = ca.contest_address
130	AND co.contest_id = ca.contest_id
131	AND ca.thread_id = :thread_id
132	AND ca.actor_address = :actor_address
133	AND ca.action = 'upvoted'
134	WHERE ct.topic_id = :topic_id
135	AND cm.community_id = :community_id
136	AND cm.cancelled = false
137	AND NOW() > co.start_time
138	AND ca.action IS NULL;
139	`,
140	{
141	type: QueryTypes.SELECT,
142	replacements: {
143	thread_id: payload.thread_id!,
144	actor_address: userAddress,
145	topic_id: topic_id,
146	community_id: payload.community_id,
147	},
148	},
149	);
150
NEW 151	if (!activeContestManagersWithoutVote?.length) {	×
152	// throw to trigger retry in case the content is pending creation
153	throw new Error(	×
154	'ThreadUpvoted: no matching active contests without actions',
155	);
156	}
157
NEW 158	const chainNodeUrl = activeContestManagersWithoutVote[0]!.url;	×
159
160	log.debug(	×
161	`ThreadUpvoted: contest managers to process: ${JSON.stringify(
162	activeContestManagersWithoutVote,
163	null,
164	2,
165	)}`,
166	);
167
168	const results = await contestHelper.voteContentBatch(	×
169	chainNodeUrl!,
170	userAddress,
NEW 171	activeContestManagersWithoutVote.map((m) => ({	×
172	contestAddress: m.contest_address,
173	contentId: m.content_id.toString(),
174	})),
175	);
176
177	const errors = results	×
178	.filter(({ status }) => status === 'rejected')	×
179	.map(
180	(result) =>
181	(result as PromiseRejectedResult).reason \|\| '<unknown reason>',	×
182	);
183
184	if (errors.length > 0) {	×
185	throw new Error(	×
186	`voteContent failed ${errors.length} times: ${errors.join(', ')}"`,
187	);
188	}
189	},
190	},
191	};
192	}

hicommonwealth / commonwealth / 9552415325

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