9567018201

Committed 18 Jun 2024 02:32PM UTC coverage: 15.137%. Remained the same

Build # 9567018201

Build Type

Pull #8170

github

Committed by

web-flow

Commit Message

Merge 7150298b6 into a9b530a5c

Pull Request Pull Request #8170: One-off contest fixes

Run Details

3748 of 24315 branches covered (15.41%)

Branch coverage included in aggregate %.

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

31 existing lines in 3 files now uncovered.

5184 of 34692 relevant lines covered (14.94%)

4.82 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
            JOIN (
                SELECT contest_address, MAX(contest_id) AS max_contest_id, MAX(end_time) as end_time
                FROM "Contests"
                GROUP BY contest_address
            ) co ON cm.contest_address = co.contest_address
            WHERE ct.topic_id = :topic_id
            AND cm.community_id = :community_id
            AND cm.cancelled = false
            AND (
              cm.interval = 0 AND NOW() < co.end_time
              OR
              cm.interval > 0
            )
        `,
          {
            type: QueryTypes.SELECT,
            replacements: {
              topic_id: payload.topic_id!,
              community_id: payload.community_id,
            },
          },
        );

        if (!activeContestManagers?.length) {
          log.warn('ThreadCreated: no matching 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 (
              cm.interval = 0 AND NOW() < co.end_time
              OR
              cm.interval > 0
            )
            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
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	JOIN (
47	SELECT contest_address, MAX(contest_id) AS max_contest_id, MAX(end_time) as end_time
48	FROM "Contests"
49	GROUP BY contest_address
50	) co ON cm.contest_address = co.contest_address
51	WHERE ct.topic_id = :topic_id
52	AND cm.community_id = :community_id
53	AND cm.cancelled = false
54	AND (
55	cm.interval = 0 AND NOW() < co.end_time
56	OR
57	cm.interval > 0
58	)
59	`,
60	{
61	type: QueryTypes.SELECT,
62	replacements: {
63	topic_id: payload.topic_id!,
64	community_id: payload.community_id,
65	},
66	},
67	);
68
69	if (!activeContestManagers?.length) {	×
NEW 70	log.warn('ThreadCreated: no matching contest managers found');	×
71	return;	×
72	}
73
74	const chainNodeUrl = activeContestManagers[0]!.url;	×
75
76	const addressesToProcess = activeContestManagers.map(	×
77	(c) => c.contest_address,	×
78	);
79
80	log.debug(	×
81	`ThreadCreated: addresses to process: ${JSON.stringify(
82	addressesToProcess,
83	null,
84	2,
85	)}`,
86	);
87
88	const results = await contestHelper.addContentBatch(	×
89	chainNodeUrl!,
90	addressesToProcess,
91	userAddress,
92	contentUrl,
93	);
94
95	const errors = results	×
96	.filter(({ status }) => status === 'rejected')	×
97	.map(
98	(result) =>
99	(result as PromiseRejectedResult).reason \|\| '<unknown reason>',	×
100	);
101
102	if (errors.length > 0) {	×
103	// TODO: ignore duplicate content error
104	throw new Error(	×
105	`addContent failed with errors: ${errors.join(', ')}"`,
106	);
107	}
108	},
109	ThreadUpvoted: async ({ payload }) => {
110	const { topic_id } = (await models.Thread.findByPk(payload.thread_id!, {	×
111	attributes: ['topic_id'],
112	}))!;
113	if (!topic_id) {	×
114	log.warn('ThreadUpvoted: thread does not contain topic_id');	×
115	return;	×
116	}
117
118	const { address: userAddress } = (await models.Address.findByPk(	×
119	payload!.address_id,
120	))!;
121
122	const activeContestManagersWithoutVote = await models.sequelize.query<{	×
123	url: string;
124	private_url: string;
125	contest_address: string;
126	content_id: number;
127	}>(
128	`
129	SELECT coalesce(cn.private_url, cn.url) as url, cm.contest_address, added.content_id
130	FROM "Communities" c
131	JOIN "ChainNodes" cn ON c.chain_node_id = cn.id
132	JOIN "ContestManagers" cm ON cm.community_id = c.id
133	JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
134	JOIN "Contests" co ON cm.contest_address = co.contest_address
135	JOIN "ContestActions" added on co.contest_address = added.contest_address
136	AND co.contest_id = added.contest_id
137	AND added.thread_id = :thread_id
138	AND added.action = 'added'
139	LEFT JOIN "ContestActions" ca ON co.contest_address = ca.contest_address
140	AND co.contest_id = ca.contest_id
141	AND ca.thread_id = :thread_id
142	AND ca.actor_address = :actor_address
143	AND ca.action = 'upvoted'
144	WHERE ct.topic_id = :topic_id
145	AND cm.community_id = :community_id
146	AND cm.cancelled = false
147	AND (
148	cm.interval = 0 AND NOW() < co.end_time
149	OR
150	cm.interval > 0
151	)
152	AND ca.action IS NULL;
153	`,
154	{
155	type: QueryTypes.SELECT,
156	replacements: {
157	thread_id: payload.thread_id!,
158	actor_address: userAddress,
159	topic_id: topic_id,
160	community_id: payload.community_id,
161	},
162	},
163	);
164
165	if (!activeContestManagersWithoutVote?.length) {	×
166	// throw to trigger retry in case the content is pending creation
167	throw new Error(	×
168	'ThreadUpvoted: no matching active contests without actions',
169	);
170	}
171
172	const chainNodeUrl = activeContestManagersWithoutVote[0]!.url;	×
173
174	log.debug(	×
175	`ThreadUpvoted: contest managers to process: ${JSON.stringify(
176	activeContestManagersWithoutVote,
177	null,
178	2,
179	)}`,
180	);
181
182	const results = await contestHelper.voteContentBatch(	×
183	chainNodeUrl!,
184	userAddress,
185	activeContestManagersWithoutVote.map((m) => ({	×
186	contestAddress: m.contest_address,
187	contentId: m.content_id.toString(),
188	})),
189	);
190
191	const errors = results	×
192	.filter(({ status }) => status === 'rejected')	×
193	.map(
194	(result) =>
195	(result as PromiseRejectedResult).reason \|\| '<unknown reason>',	×
196	);
197
198	if (errors.length > 0) {	×
199	throw new Error(	×
200	`voteContent failed ${errors.length} times: ${errors.join(', ')}"`,
201	);
202	}
203	},
204	},
205	};
206	}

hicommonwealth / commonwealth / 9567018201

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