9603730238

Committed 20 Jun 2024 08:11PM UTC coverage: 14.83% (-0.2%) from 15.006%

Build # 9603730238

Build Type

Pull #7395

github

Committed by

web-flow

Commit Message

Merge a98f1c8f9 into cb8cc76bb

Pull Request Pull Request #7395: Upgrade Canvas packages to 0.10

Run Details

3695 of 26267 branches covered (14.07%)

Branch coverage included in aggregate %.

75 of 212 new or added lines in 36 files covered. (35.38%)

159 existing lines in 19 files now uncovered.

5073 of 32857 relevant lines covered (15.44%)

5.01 hits per line

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

7.53

/packages/commonwealth/client/scripts/models/Thread.ts

import { ProposalType } from '@hicommonwealth/shared';
import type MinimumProfile from 'models/MinimumProfile';
import { addressToUserProfile, UserProfile } from 'models/MinimumProfile';
import moment, { Moment } from 'moment';
import Comment from './Comment';
import type { IUniqueId } from './interfaces';
import type { ReactionType } from './Reaction';
import Topic from './Topic';
import type { ThreadKind, ThreadStage } from './types';

function getDecodedString(str: string) {
  try {
    return decodeURIComponent(str);
  } catch (err) {
    console.error(`Could not decode str: "${str}"`);
    return str;
  }
}

function processVersionHistory(versionHistory: any[]) {
  let versionHistoryProcessed;
  if (versionHistory) {
    versionHistoryProcessed = versionHistory.map((v) => {
      if (!v) return;
      let history;
      try {
        history = JSON.parse(v);
        history.author =
          typeof history.author === 'string'
            ? JSON.parse(history.author)
            : typeof history.author === 'object'
            ? history.author
            : null;
        history.timestamp = moment(history.timestamp);
      } catch (e) {
        console.log(e);
      }
      return history;
    });
  }
  return versionHistoryProcessed;
}

function emptyStringToNull(input: string) {
  return input === '' ? null : input;
}

function processAssociatedReactions(
  reactions: any[],
  reactionIds: any[],
  reactionType: any[],
  reactionTimestamps: string[],
  reactionWeights: number[],
  addressesReacted: any[],
  reactedProfileName: string[],
  reactedProfileAvatarUrl: string[],
  reactedAddressLastActive: string[],
) {
  const temp = [];
  const tempReactionIds =
    (reactions ? reactions.map((r) => r.id) : reactionIds) || [];
  const tempReactionType =
    (reactions ? reactions.map((r) => r?.type || r?.reaction) : reactionType) ||
    [];
  const tempAddressesReacted =
    (reactions
      ? reactions.map((r) => r?.address || r?.Address?.address)
      : addressesReacted) || [];
  const tempReactionTimestamps =
    (reactions ? reactions.map((r) => r?.updated_at) : reactionTimestamps) ||
    [];

  const tempReactionWeights =
    (reactions
      ? reactions.map((r) => r.calculated_voting_weight)
      : reactionWeights) || [];

  if (
    tempReactionIds.length > 0 &&
    tempReactionIds.length === tempReactionType.length &&
    tempReactionType.length === tempAddressesReacted.length &&
    tempAddressesReacted.length === tempReactionTimestamps.length &&
    tempReactionTimestamps.length === tempReactionWeights.length
  ) {
    for (let i = 0; i < tempReactionIds.length; i++) {
      // @ts-expect-error StrictNullChecks
      temp.push({
        id: tempReactionIds[i],
        type: tempReactionType[i],
        address: tempAddressesReacted[i],
        updated_at: tempReactionTimestamps[i],
        voting_weight: tempReactionWeights[i] || 1,
        reactedProfileName: emptyStringToNull(reactedProfileName?.[i]),
        reactedProfileAvatarUrl: emptyStringToNull(
          reactedProfileAvatarUrl?.[i],
        ),
        reactedAddressLastActive: emptyStringToNull(
          reactedAddressLastActive?.[i],
        ),
      });
    }
  }
  return temp;
}

export interface VersionHistory {
  author?: MinimumProfile & { profile_id: number };
  timestamp: Moment;
  body: string;
}

export interface IThreadCollaborator {
  address: string;
  community_id: string;
  User: { Profiles: UserProfile[] };
}

export type AssociatedReaction = {
  id: number | string;
  type: ReactionType;
  address: string;
  updated_at: string;
  voting_weight: number;
  profile_name?: string;
  avatar_url?: string;
  last_active?: string;
};

type AssociatedContest = {
  id: number;
  thread_id: number;
  content_id: number;
  start_time: string;
  end_time: string;
};

type RecentComment = {
  id: number;
  address: string;
  text: string;
  plainText: string;
  created_at: string;
  updated_at: string;
  marked_as_spam_at?: string;
  deleted_at?: string;
  discord_meta?: string;
  profile_id: number;
  profile_name?: string;
  profile_avatar_url?: string;
  user_id: string;
};

export enum LinkSource {
  Snapshot = 'snapshot',
  Proposal = 'proposal',
  Thread = 'thread',
  Web = 'web',
  Template = 'template',
}

export enum LinkDisplay {
  inline = 'inline',
  sidebar = 'sidebar',
  both = 'both',
}

export type Link = {
  source: LinkSource;
  identifier: string;
  title?: string;
  display?: LinkDisplay;
};

export class Thread implements IUniqueId {
  public readonly author: string;
  public collaborators?: IThreadCollaborator[];
  public readonly authorCommunity: string;
  public readonly title: string;
  public readonly body: string;
  public readonly plaintext: string;
  public pinned: boolean;
  public readonly kind: ThreadKind;
  public stage: ThreadStage;
  public readOnly: boolean;

  public readonly canvasAction: string;
  public readonly canvasSession: string;
  public readonly canvasHash: string;

  // TODO: it is a bit clunky to have a numeric id and a string identifier here
  //  we should remove the number to allow the store to work.
  public readonly identifier: string;
  public readonly id: number;
  public readonly createdAt: Moment;
  public readonly updatedAt: Moment;
  public readonly lastCommentedOn: Moment;
  public archivedAt: Moment | null;
  public topic: Topic;
  public readonly slug = ProposalType.Thread;
  public readonly url: string;
  public readonly versionHistory: VersionHistory[];
  public readonly communityId: string;
  public readonly lastEdited: Moment;

  public markedAsSpamAt: Moment;
  public readonly lockedAt: Moment;

  public readonly hasPoll: boolean;
  public numberOfComments: number;
  public associatedReactions: AssociatedReaction[];
  public associatedContests?: AssociatedContest[];
  public recentComments?: Comment<IUniqueId>[];
  public reactionWeightsSum: number;
  public links: Link[];
  public readonly discord_meta: any;
  public readonly latestActivity: Moment;

  public readonly profile: UserProfile;

  public get uniqueIdentifier() {
    return `${this.slug}_${this.identifier}`;
  }

  constructor({
    Address,
    title,
    id,
    created_at,
    updated_at,
    topic,
    kind,
    stage,
    version_history,
    community_id,
    read_only,
    body,
    plaintext,
    url,
    pinned,
    collaborators,
    last_edited,
    marked_as_spam_at,
    locked_at,
    archived_at,
    has_poll,
    last_commented_on,
    numberOfComments,
    reactions,
    reactionIds,
    reactionType,
    reactionTimestamps,
    reactionWeights,
    reaction_weights_sum,
    addressesReacted,
    reactedProfileName,
    reactedProfileAvatarUrl,
    reactedAddressLastActive,
    canvasAction,
    canvasSession,
    canvasHash,
    links,
    discord_meta,
    profile_id,
    profile_name,
    avatar_url,
    address_last_active,
    associatedReactions,
    associatedContests,
    recentComments,
  }: {
    marked_as_spam_at: string;
    title: string;
    body?: string;
    id: number;
    kind: ThreadKind;
    stage: ThreadStage;
    community_id: string;
    url?: string;
    pinned?: boolean;
    links?: Link[];
    canvasAction?: string;
    canvasSession?: string;
    canvasHash?: string;
    plaintext?: string;
    collaborators?: any[];
    last_edited: string;
    locked_at: string;
    last_commented_on: string;
    created_at: string;
    updated_at: string;
    archived_at?: string;
    read_only: boolean;
    has_poll: boolean;
    numberOfComments?: number;
    topic: Topic;
    reactions?: any[]; // TODO: fix type
    reactionIds?: any[]; // TODO: fix type
    addressesReacted?: any[]; //TODO: fix type,
    reactedProfileName?: string[];
    reactedProfileAvatarUrl?: string[];
    reactedAddressLastActive?: string[];
    reactionType?: any[]; // TODO: fix type
    reactionTimestamps?: string[];
    reactionWeights?: number[];
    reaction_weights_sum: number;
    version_history: any[]; // TODO: fix type
    Address: any; // TODO: fix type
    discord_meta?: any;
    profile_id: number;
    profile_name: string;
    avatar_url: string;
    address_last_active: string;
    associatedReactions?: AssociatedReaction[];
    associatedContests?: AssociatedContest[];
    recentComments: RecentComment[];
  }) {
    this.author = Address?.address;
    this.title = getDecodedString(title);
    // @ts-expect-error StrictNullChecks
    this.body = getDecodedString(body);
    // @ts-expect-error StrictNullChecks
    this.plaintext = plaintext;
    this.id = id;
    this.identifier = `${id}`;
    this.createdAt = moment(created_at);
    this.updatedAt = moment(updated_at);
    // @ts-expect-error StrictNullChecks
    this.topic = topic?.id ? new Topic({ ...(topic || {}) } as any) : null;
    this.kind = kind;
    this.stage = stage;
    this.authorCommunity = Address?.community_id;
    // @ts-expect-error StrictNullChecks
    this.pinned = pinned;
    // @ts-expect-error StrictNullChecks
    this.url = url;
    this.communityId = community_id;
    this.readOnly = read_only;
    this.collaborators = collaborators || [];
    // @ts-expect-error StrictNullChecks
    this.lastCommentedOn = last_commented_on ? moment(last_commented_on) : null;
    this.hasPoll = has_poll;
    // @ts-expect-error StrictNullChecks
    this.lastEdited = last_edited
      ? moment(last_edited)
      : this.versionHistory && this.versionHistory?.length > 1
      ? this.versionHistory[0].timestamp
      : null;
    // @ts-expect-error StrictNullChecks
    this.markedAsSpamAt = marked_as_spam_at ? moment(marked_as_spam_at) : null;
    this.archivedAt = archived_at ? moment(archived_at) : null;
    // @ts-expect-error StrictNullChecks
    this.lockedAt = locked_at ? moment(locked_at) : null;
    this.numberOfComments = numberOfComments || 0;
    // @ts-expect-error StrictNullChecks
    this.canvasAction = canvasAction;
    // @ts-expect-error StrictNullChecks
    this.canvasSession = canvasSession;
    // @ts-expect-error StrictNullChecks
    this.canvasHash = canvasHash;
    this.links = links || [];
    this.discord_meta = discord_meta;
    this.versionHistory = processVersionHistory(version_history);
    this.reactionWeightsSum = reaction_weights_sum;
    this.associatedReactions =
      associatedReactions ??
      processAssociatedReactions(
        // @ts-expect-error StrictNullChecks
        reactions,
        reactionIds,
        reactionType,
        reactionTimestamps,
        reactionWeights,
        addressesReacted,
        reactedProfileName,
        reactedProfileAvatarUrl,
        reactedAddressLastActive,
      );
    this.associatedContests = associatedContests || [];
    this.recentComments = (recentComments || []).map(
      (rc) =>
        new Comment({
          authorChain: this.authorCommunity,
          community_id: this.authorCommunity,
          id: rc?.id,
          thread_id: id,
          author: rc?.address,
          last_edited: rc?.updated_at ? moment(rc.updated_at) : null,
          created_at: rc?.created_at ? moment(rc?.created_at) : null,
          plaintext: rc?.plainText,
          text: rc?.text,
          Address: {
            address: rc?.address,
            User: {
              Profiles: [
                {
                  id: rc?.profile_id,
                  profile_name: rc?.profile_name,
                  avatar_url: rc?.profile_avatar_url,
                },
              ],
            },
          },
          discord_meta: rc?.discord_meta,
          marked_as_spam_at: rc?.marked_as_spam_at,
          deleted_at: rc?.deleted_at,
          // fallback, we are not using this in display for thread preview
          // and these should not be added here unless needed.
          parent_id: null,
          reactions: [],
          version_history: [],
          reaction_weights_sum: 0,
          canvas_action: null,
          canvas_hash: null,
          canvas_session: null,
        }),
    );
    this.latestActivity = last_commented_on
      ? moment(last_commented_on)
      : moment(created_at);

    if (Address?.User) {
      this.profile = addressToUserProfile(Address);
    } else {
      this.profile = {
        id: profile_id,
        name: profile_name,
        address: Address?.address,
        lastActive: address_last_active,
        avatarUrl: avatar_url ?? undefined,
      };
    }
  }
}

export default Thread;

1	import { ProposalType } from '@hicommonwealth/shared';
2	import type MinimumProfile from 'models/MinimumProfile';
3	import { addressToUserProfile, UserProfile } from 'models/MinimumProfile';
4	import moment, { Moment } from 'moment';
5	import Comment from './Comment';
6	import type { IUniqueId } from './interfaces';
7	import type { ReactionType } from './Reaction';
8	import Topic from './Topic';
9	import type { ThreadKind, ThreadStage } from './types';
10
11	function getDecodedString(str: string) {
12	try {	×
13	return decodeURIComponent(str);	×
14	} catch (err) {
15	console.error(`Could not decode str: "${str}"`);	×
16	return str;	×
17	}
18	}
19
20	function processVersionHistory(versionHistory: any[]) {
21	let versionHistoryProcessed;
22	if (versionHistory) {	×
23	versionHistoryProcessed = versionHistory.map((v) => {	×
24	if (!v) return;	×
25	let history;
26	try {	×
27	history = JSON.parse(v);	×
28	history.author =	×
29	typeof history.author === 'string'	×
30	? JSON.parse(history.author)
31	: typeof history.author === 'object'	×
32	? history.author
33	: null;
34	history.timestamp = moment(history.timestamp);	×
35	} catch (e) {
36	console.log(e);	×
37	}
38	return history;	×
39	});
40	}
41	return versionHistoryProcessed;	×
42	}
43
44	function emptyStringToNull(input: string) {
45	return input === '' ? null : input;	×
46	}
47
48	function processAssociatedReactions(
49	reactions: any[],
50	reactionIds: any[],
51	reactionType: any[],
52	reactionTimestamps: string[],
53	reactionWeights: number[],
54	addressesReacted: any[],
55	reactedProfileName: string[],
56	reactedProfileAvatarUrl: string[],
57	reactedAddressLastActive: string[],
58	) {
59	const temp = [];	×
60	const tempReactionIds =	×
61	(reactions ? reactions.map((r) => r.id) : reactionIds) \|\| [];	×
62	const tempReactionType =	×
63	(reactions ? reactions.map((r) => r?.type \|\| r?.reaction) : reactionType) \|\|	×
64	[];
65	const tempAddressesReacted =	×
66	(reactions	×
67	? reactions.map((r) => r?.address \|\| r?.Address?.address)	×
68	: addressesReacted) \|\| [];
69	const tempReactionTimestamps =	×
70	(reactions ? reactions.map((r) => r?.updated_at) : reactionTimestamps) \|\|	×
71	[];
72
73	const tempReactionWeights =	×
74	(reactions	×
75	? reactions.map((r) => r.calculated_voting_weight)	×
76	: reactionWeights) \|\| [];
77
78	if (	×
79	tempReactionIds.length > 0 &&	×
80	tempReactionIds.length === tempReactionType.length &&
81	tempReactionType.length === tempAddressesReacted.length &&
82	tempAddressesReacted.length === tempReactionTimestamps.length &&
83	tempReactionTimestamps.length === tempReactionWeights.length
84	) {
85	for (let i = 0; i < tempReactionIds.length; i++) {	×
86	// @ts-expect-error StrictNullChecks
87	temp.push({	×
88	id: tempReactionIds[i],
89	type: tempReactionType[i],
90	address: tempAddressesReacted[i],
91	updated_at: tempReactionTimestamps[i],
92	voting_weight: tempReactionWeights[i] \|\| 1,	×
93	reactedProfileName: emptyStringToNull(reactedProfileName?.[i]),
94	reactedProfileAvatarUrl: emptyStringToNull(
95	reactedProfileAvatarUrl?.[i],
96	),
97	reactedAddressLastActive: emptyStringToNull(
98	reactedAddressLastActive?.[i],
99	),
100	});
101	}
102	}
103	return temp;	×
104	}
105
106	export interface VersionHistory {
107	author?: MinimumProfile & { profile_id: number };
108	timestamp: Moment;
109	body: string;
110	}
111
112	export interface IThreadCollaborator {
113	address: string;
114	community_id: string;
115	User: { Profiles: UserProfile[] };
116	}
117
118	export type AssociatedReaction = {
119	id: number \| string;
120	type: ReactionType;
121	address: string;
122	updated_at: string;
123	voting_weight: number;
124	profile_name?: string;
125	avatar_url?: string;
126	last_active?: string;
127	};
128
129	type AssociatedContest = {
130	id: number;
131	thread_id: number;
132	content_id: number;
133	start_time: string;
134	end_time: string;
135	};
136
137	type RecentComment = {
138	id: number;
139	address: string;
140	text: string;
141	plainText: string;
142	created_at: string;
143	updated_at: string;
144	marked_as_spam_at?: string;
145	deleted_at?: string;
146	discord_meta?: string;
147	profile_id: number;
148	profile_name?: string;
149	profile_avatar_url?: string;
150	user_id: string;
151	};
152
153	export enum LinkSource {	2✔
154	Snapshot = 'snapshot',	2✔
155	Proposal = 'proposal',	2✔
156	Thread = 'thread',	2✔
157	Web = 'web',	2✔
158	Template = 'template',	2✔
159	}
160
161	export enum LinkDisplay {	2✔
162	inline = 'inline',	2✔
163	sidebar = 'sidebar',	2✔
164	both = 'both',	2✔
165	}
166
167	export type Link = {
168	source: LinkSource;
169	identifier: string;
170	title?: string;
171	display?: LinkDisplay;
172	};
173
174	export class Thread implements IUniqueId {
175	public readonly author: string;
176	public collaborators?: IThreadCollaborator[];
177	public readonly authorCommunity: string;
178	public readonly title: string;
179	public readonly body: string;
180	public readonly plaintext: string;
181	public pinned: boolean;
182	public readonly kind: ThreadKind;
183	public stage: ThreadStage;
184	public readOnly: boolean;
185
186	public readonly canvasAction: string;
187	public readonly canvasSession: string;
188	public readonly canvasHash: string;
189
190	// TODO: it is a bit clunky to have a numeric id and a string identifier here
191	// we should remove the number to allow the store to work.
192	public readonly identifier: string;
193	public readonly id: number;
194	public readonly createdAt: Moment;
195	public readonly updatedAt: Moment;
196	public readonly lastCommentedOn: Moment;
197	public archivedAt: Moment \| null;
198	public topic: Topic;
199	public readonly slug = ProposalType.Thread;
200	public readonly url: string;
201	public readonly versionHistory: VersionHistory[];
202	public readonly communityId: string;
203	public readonly lastEdited: Moment;
204
205	public markedAsSpamAt: Moment;
206	public readonly lockedAt: Moment;
207
208	public readonly hasPoll: boolean;
209	public numberOfComments: number;
210	public associatedReactions: AssociatedReaction[];
211	public associatedContests?: AssociatedContest[];
212	public recentComments?: Comment<IUniqueId>[];
213	public reactionWeightsSum: number;
214	public links: Link[];
215	public readonly discord_meta: any;
216	public readonly latestActivity: Moment;
217
218	public readonly profile: UserProfile;
219
220	public get uniqueIdentifier() {
221	return `${this.slug}_${this.identifier}`;
222	}
223
224	constructor({
225	Address,
226	title,
227	id,
228	created_at,
229	updated_at,
230	topic,
231	kind,
232	stage,
233	version_history,
234	community_id,
235	read_only,
236	body,
237	plaintext,
238	url,
239	pinned,
240	collaborators,
241	last_edited,
242	marked_as_spam_at,
243	locked_at,
244	archived_at,
245	has_poll,
246	last_commented_on,
247	numberOfComments,
248	reactions,
249	reactionIds,
250	reactionType,
251	reactionTimestamps,
252	reactionWeights,
253	reaction_weights_sum,
254	addressesReacted,
255	reactedProfileName,
256	reactedProfileAvatarUrl,
257	reactedAddressLastActive,
258	canvasAction,
259	canvasSession,
260	canvasHash,
261	links,
262	discord_meta,
263	profile_id,
264	profile_name,
265	avatar_url,
266	address_last_active,
267	associatedReactions,
268	associatedContests,
269	recentComments,
270	}: {
271	marked_as_spam_at: string;
272	title: string;
273	body?: string;
274	id: number;
275	kind: ThreadKind;
276	stage: ThreadStage;
277	community_id: string;
278	url?: string;
279	pinned?: boolean;
280	links?: Link[];
281	canvasAction?: string;
282	canvasSession?: string;
283	canvasHash?: string;
284	plaintext?: string;
285	collaborators?: any[];
286	last_edited: string;
287	locked_at: string;
288	last_commented_on: string;
289	created_at: string;
290	updated_at: string;
291	archived_at?: string;
292	read_only: boolean;
293	has_poll: boolean;
294	numberOfComments?: number;
295	topic: Topic;
296	reactions?: any[]; // TODO: fix type
297	reactionIds?: any[]; // TODO: fix type
298	addressesReacted?: any[]; //TODO: fix type,
299	reactedProfileName?: string[];
300	reactedProfileAvatarUrl?: string[];
301	reactedAddressLastActive?: string[];
302	reactionType?: any[]; // TODO: fix type
303	reactionTimestamps?: string[];
304	reactionWeights?: number[];
305	reaction_weights_sum: number;
306	version_history: any[]; // TODO: fix type
307	Address: any; // TODO: fix type
308	discord_meta?: any;
309	profile_id: number;
310	profile_name: string;
311	avatar_url: string;
312	address_last_active: string;
313	associatedReactions?: AssociatedReaction[];
314	associatedContests?: AssociatedContest[];
315	recentComments: RecentComment[];
316	}) {
317	this.author = Address?.address;	×
318	this.title = getDecodedString(title);
319	// @ts-expect-error StrictNullChecks
320	this.body = getDecodedString(body);	×
321	// @ts-expect-error StrictNullChecks
322	this.plaintext = plaintext;	×
323	this.id = id;	×
324	this.identifier = `${id}`;
325	this.createdAt = moment(created_at);	×
326	this.updatedAt = moment(updated_at);	×
327	// @ts-expect-error StrictNullChecks
328	this.topic = topic?.id ? new Topic({ ...(topic \|\| {}) } as any) : null;	×
329	this.kind = kind;
330	this.stage = stage;	×
331	this.authorCommunity = Address?.community_id;
332	// @ts-expect-error StrictNullChecks
333	this.pinned = pinned;	×
334	// @ts-expect-error StrictNullChecks
335	this.url = url;	×
336	this.communityId = community_id;
337	this.readOnly = read_only;	×
338	this.collaborators = collaborators \|\| [];	×
339	// @ts-expect-error StrictNullChecks
340	this.lastCommentedOn = last_commented_on ? moment(last_commented_on) : null;	×
341	this.hasPoll = has_poll;
342	// @ts-expect-error StrictNullChecks	×
343	this.lastEdited = last_edited	×
344	? moment(last_edited)
345	: this.versionHistory && this.versionHistory?.length > 1	×
346	? this.versionHistory[0].timestamp	×
347	: null;	×
348	// @ts-expect-error StrictNullChecks
349	this.markedAsSpamAt = marked_as_spam_at ? moment(marked_as_spam_at) : null;	×
350	this.archivedAt = archived_at ? moment(archived_at) : null;	×
351	// @ts-expect-error StrictNullChecks
NEW 352	this.lockedAt = locked_at ? moment(locked_at) : null;	×
353	this.numberOfComments = numberOfComments \|\| 0;	×
354	// @ts-expect-error StrictNullChecks
355	this.canvasAction = canvasAction;	×
356	// @ts-expect-error StrictNullChecks
357	this.canvasSession = canvasSession;	×
358	// @ts-expect-error StrictNullChecks
359	this.canvasHash = canvasHash;	×
360	this.links = links \|\| [];	×
361	this.discord_meta = discord_meta;
362	this.versionHistory = processVersionHistory(version_history);
363	this.reactionWeightsSum = reaction_weights_sum;
364	this.associatedReactions =
365	associatedReactions ??	×
366	processAssociatedReactions(
367	// @ts-expect-error StrictNullChecks
368	reactions,
369	reactionIds,
370	reactionType,
371	reactionTimestamps,
372	reactionWeights,
373	addressesReacted,	×
374	reactedProfileName,	×
375	reactedProfileAvatarUrl,
376	reactedAddressLastActive,
377	);
378	this.associatedContests = associatedContests \|\| [];	×
379	this.recentComments = (recentComments \|\| []).map(	×
380	(rc) =>
381	new Comment({
382	authorChain: this.authorCommunity,	×
383	community_id: this.authorCommunity,	×
384	id: rc?.id,
385	thread_id: id,
386	author: rc?.address,
387	last_edited: rc?.updated_at ? moment(rc.updated_at) : null,	×
388	created_at: rc?.created_at ? moment(rc?.created_at) : null,	×
389	plaintext: rc?.plainText,
390	text: rc?.text,
391	Address: {
392	address: rc?.address,
393	User: {
394	Profiles: [
395	{
396	id: rc?.profile_id,
397	profile_name: rc?.profile_name,
398	avatar_url: rc?.profile_avatar_url,
399	},
400	],
401	},
402	},
403	discord_meta: rc?.discord_meta,
404	marked_as_spam_at: rc?.marked_as_spam_at,
405	deleted_at: rc?.deleted_at,
406	// fallback, we are not using this in display for thread preview
407	// and these should not be added here unless needed.
408	parent_id: null,
409	reactions: [],
410	version_history: [],
411	reaction_weights_sum: 0,	×
412	canvas_action: null,
413	canvas_hash: null,
414	canvas_session: null,
415	}),	×
416	);
417	this.latestActivity = last_commented_on	×
418	? moment(last_commented_on)
419	: moment(created_at);
420
421	if (Address?.User) {	×
422	this.profile = addressToUserProfile(Address);
423	} else {	×
424	this.profile = {
425	id: profile_id,
426	name: profile_name,
427	address: Address?.address,
428	lastActive: address_last_active,
429	avatarUrl: avatar_url ?? undefined,	×
430	};
431	}
432	}
433	}
434
435	export default Thread;

hicommonwealth / commonwealth / 9603730238

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