948b6460d9
Diferencia 1.3.1 -> 1.3.3 del codigo de la APK oficial aplicada a tres bandas encima de la rama: karma en el perfil, salas con directo, fotos selladas, visibilidad de menciones, telefono por stream en Android y las traducciones nuevas. Sin dependencias nuevas. OasisMobile.css sigue siendo el del fork; del oficial solo se traen al final las reglas de las piezas nuevas (karma, directo a pantalla completa, salas en vivo, graphos).
491 lines
24 KiB
JavaScript
491 lines
24 KiB
JavaScript
const pull = require('../server/node_modules/pull-stream');
|
|
const { getConfig } = require('../configs/config-manager.js');
|
|
const logLimit = getConfig().ssbLogStream?.limit || 1000;
|
|
const tribeLogLimit = Math.max(logLimit, 100000);
|
|
const { readTyped } = require('./typed_log');
|
|
const longText = require('../backend/long_text');
|
|
const { versionGroups } = require('../backend/dedupe');
|
|
const TRIBE_LOG_TYPES = ['tribe', 'tribe-msg', 'tribe-keys-distrib', 'tribe-invite-msg', 'tribe-invite-tombstone', 'tribe-open-invite-tombstone', 'tombstone', 'contact'];
|
|
|
|
const VALID_CONTENT_TYPES = ['event', 'task', 'report', 'votation', 'forum', 'forum-reply', 'market', 'job', 'project', 'media', 'feed'];
|
|
const categories = require('../backend/opinion_categories');
|
|
const VALID_STATUSES = ['OPEN', 'CLOSED', 'IN-PROGRESS'];
|
|
const VALID_PRIORITIES = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
|
|
const EXPOSURE_TYPE = 'tribeExposure';
|
|
const REACH_LEVELS = ['tribe', 'oasis', 'clearnet'];
|
|
const REACH_RANK = { tribe: 0, oasis: 1, clearnet: 2 };
|
|
const SNAPSHOT_FIELDS = ['contentType', 'title', 'description', 'status', 'date', 'location', 'price', 'salary', 'priority', 'options', 'category', 'tags', 'image', 'mediaType', 'license', 'url', 'deadline', 'goal', 'dates', 'lat', 'lng', 'markers', 'createdAt', 'updatedAt'];
|
|
const snapshotOf = (item, replies = []) => {
|
|
const out = {};
|
|
for (const f of SNAPSHOT_FIELDS) {
|
|
const v = item[f];
|
|
if (v === undefined || v === null || v === '' || (Array.isArray(v) && !v.length)) continue;
|
|
out[f] = v;
|
|
}
|
|
out.author = item.author;
|
|
if (item.contentType === 'forum') out.replies = (replies || []).map(r => ({ author: r.author, description: r.description || '', createdAt: r.createdAt || null }));
|
|
return out;
|
|
};
|
|
|
|
module.exports = ({ cooler, tribeCrypto, tribesModel }) => {
|
|
let ssb;
|
|
const openSsb = async () => { if (!ssb) ssb = await cooler.open(); return ssb; };
|
|
|
|
const readLog = async () => {
|
|
const client = await openSsb();
|
|
return readTyped(client, TRIBE_LOG_TYPES, { limit: tribeLogLimit });
|
|
};
|
|
|
|
const fingerprintsForRoot = (rootId) => {
|
|
const fps = new Set();
|
|
for (const k of tribeCrypto.getKeys(rootId)) fps.add(tribeCrypto.fingerprint(k));
|
|
return fps;
|
|
};
|
|
|
|
const wrapAndPublishContent = async (rootId, body) => {
|
|
const client = await openSsb();
|
|
const key = tribeCrypto.getKey(rootId);
|
|
if (!key) throw new Error('Missing tribe key for ' + rootId);
|
|
const envelope = tribeCrypto.wrapMsg(body, key);
|
|
return new Promise((resolve, reject) =>
|
|
client.publish(envelope, (err, r) => err ? reject(err) : resolve(r))
|
|
);
|
|
};
|
|
|
|
const publishContent = async (rootId, body) => {
|
|
const publishChunk = (c) => wrapAndPublishContent(rootId, { k: longText.CHUNK_TYPE, rootId, text: c.text, index: c.index, total: c.total, group: c.group });
|
|
const sealed = await longText.chunkContent(body, 'description', { maxBytes: longText.CONTENT_BYTES.sealed, extra: { rootId }, publish: publishChunk });
|
|
return wrapAndPublishContent(rootId, sealed);
|
|
};
|
|
|
|
const decodeContentMsgs = async (msgs, opts) => {
|
|
const fpIdx = tribeCrypto.buildFingerprintIndex();
|
|
const targetRootId = opts && opts.rootId ? opts.rootId : null;
|
|
const wantType = opts && opts.contentType ? opts.contentType : null;
|
|
const allowedFps = targetRootId ? fingerprintsForRoot(targetRootId) : null;
|
|
|
|
const content = new Map();
|
|
const chunks = new Map();
|
|
const tombRequests = [];
|
|
const collabMsgs = [];
|
|
|
|
for (const m of msgs) {
|
|
const c = m.value && m.value.content;
|
|
if (!c) continue;
|
|
if (!tribeCrypto.isTribeMsg(c)) continue;
|
|
if (allowedFps && !allowedFps.has(c.fp)) continue;
|
|
|
|
const r = tribeCrypto.unwrapMsg(c, fpIdx);
|
|
if (!r || !r.body) continue;
|
|
const b = r.body;
|
|
|
|
if (b.k === 'tombstone') {
|
|
tombRequests.push({ target: b.target, author: m.value.author });
|
|
continue;
|
|
}
|
|
if (b.k === longText.CHUNK_TYPE) {
|
|
const ch = longText.chunkOf(m.value.author, b);
|
|
if (ch) chunks.set(m.key, ch);
|
|
continue;
|
|
}
|
|
if (b.k === 'tc-collab') {
|
|
collabMsgs.push({ sub: b.sub, target: b.target, author: m.value.author, ts: m.value.timestamp || 0, seq: m.value.sequence || 0, option: b.option, on: b.on, category: b.category });
|
|
continue;
|
|
}
|
|
if (b.k !== 'tribe-content') continue;
|
|
content.set(m.key, { author: m.value.author, body: b, ts: m.value.timestamp, seq: m.value.sequence || 0 });
|
|
}
|
|
|
|
if (targetRootId && tribesModel && typeof tribesModel.departures === 'function') {
|
|
const gone = await tribesModel.departures(targetRootId).catch(() => new Map());
|
|
const afterLeaving = (author, ts, seq) => {
|
|
const d = gone.get(author);
|
|
return !!d && ((d.seq !== undefined && seq > d.seq) || (d.ts !== undefined && (Number(ts) || 0) > d.ts));
|
|
};
|
|
for (const [key, node] of [...content]) if (afterLeaving(node.author, node.ts, node.seq)) content.delete(key);
|
|
for (let i = collabMsgs.length - 1; i >= 0; i--) if (afterLeaving(collabMsgs[i].author, collabMsgs[i].ts, collabMsgs[i].seq)) collabMsgs.splice(i, 1);
|
|
}
|
|
|
|
const vg = versionGroups([...content].map(([key, node]) => ({ key, author: node.author, seq: node.seq, ts: node.ts, replaces: typeof node.body.replaces === 'string' ? node.body.replaces : null, claimedAuthor: typeof node.body.author === 'string' ? node.body.author : null })));
|
|
|
|
const tombstoned = new Set();
|
|
for (const t of tombRequests) { const orig = content.get(t.target); if (orig && t.author === orig.author) tombstoned.add(t.target); }
|
|
|
|
const collabByRoot = new Map();
|
|
const getCB = (root) => { if (!collabByRoot.has(root)) collabByRoot.set(root, { vote: new Map(), attend: new Map(), assign: new Map(), refeed: new Set(), opinion: new Map() }); return collabByRoot.get(root); };
|
|
for (const cm of collabMsgs) {
|
|
if (!content.has(cm.target)) continue;
|
|
const a = getCB(vg.rootOf(cm.target));
|
|
if (cm.sub === 'vote' && Number.isInteger(cm.option)) { if (!a.vote.has(cm.author)) a.vote.set(cm.author, cm.option); }
|
|
else if (cm.sub === 'attend') { const p = a.attend.get(cm.author); if (!p || cm.ts >= p.ts) a.attend.set(cm.author, { on: cm.on !== false, ts: cm.ts }); }
|
|
else if (cm.sub === 'assign') { const p = a.assign.get(cm.author); if (!p || cm.ts >= p.ts) a.assign.set(cm.author, { on: cm.on !== false, ts: cm.ts }); }
|
|
else if (cm.sub === 'refeed') { a.refeed.add(cm.author); }
|
|
else if (cm.sub === 'opinion' && cm.category) { if (!a.opinion.has(cm.author)) a.opinion.set(cm.author, cm.category); }
|
|
}
|
|
|
|
const items = new Map();
|
|
const tipOf = new Map();
|
|
const EMPTY = { vote: new Map(), attend: new Map(), assign: new Map(), refeed: new Set(), opinion: new Map() };
|
|
|
|
for (const root of vg.roots) {
|
|
const contentTip = vg.tipOf(root);
|
|
const tipNode = content.get(contentTip);
|
|
if (!tipNode) continue;
|
|
const body = tipNode.body;
|
|
const lb = tipNode.body;
|
|
const a = collabByRoot.get(root) || EMPTY;
|
|
|
|
const item = { id: contentTip, ...body, description: longText.joinText(body.description, body.chunks, longText.lookupIn(chunks), tipNode.author), author: tipNode.author, _ts: tipNode.ts, originId: root };
|
|
|
|
const voteAuthors = new Set(); const votes = {};
|
|
const legacyVotes = lb.votes && typeof lb.votes === 'object' ? lb.votes : {};
|
|
for (const k of Object.keys(legacyVotes)) { const arr = Array.isArray(legacyVotes[k]) ? legacyVotes[k] : []; for (const au of arr) if (!voteAuthors.has(au)) { voteAuthors.add(au); (votes[k] = votes[k] || []).push(au); } }
|
|
for (const [au, opt] of a.vote) if (!voteAuthors.has(au)) { voteAuthors.add(au); const k = String(opt); (votes[k] = votes[k] || []).push(au); }
|
|
item.votes = votes;
|
|
|
|
const att = new Set(Array.isArray(lb.attendees) ? lb.attendees : []);
|
|
for (const [au, st] of a.attend) { if (st.on) att.add(au); else att.delete(au); }
|
|
item.attendees = [...att];
|
|
|
|
const asg = new Set(Array.isArray(lb.assignees) ? lb.assignees : []);
|
|
for (const [au, st] of a.assign) { if (st.on) asg.add(au); else asg.delete(au); }
|
|
item.assignees = [...asg];
|
|
|
|
const rf = new Set(Array.isArray(lb.refeeds_inhabitants) ? lb.refeeds_inhabitants : []);
|
|
for (const au of a.refeed) rf.add(au);
|
|
item.refeeds_inhabitants = [...rf]; item.refeeds = rf.size;
|
|
|
|
const opInh = new Set(Array.isArray(lb.opinions_inhabitants) ? lb.opinions_inhabitants : []);
|
|
const opinions = { ...(lb.opinions && typeof lb.opinions === 'object' ? lb.opinions : {}) };
|
|
for (const [au, cat] of a.opinion) if (!opInh.has(au)) { opInh.add(au); opinions[cat] = (opinions[cat] || 0) + 1; }
|
|
item.opinions_inhabitants = [...opInh]; item.opinions = opinions;
|
|
|
|
for (const k of (vg.groups.get(root) || [root])) tipOf.set(k, contentTip);
|
|
|
|
if (tombstoned.has(contentTip)) continue;
|
|
if (targetRootId && body.rootId !== targetRootId) continue;
|
|
if (wantType && body.contentType !== wantType) continue;
|
|
items.set(contentTip, item);
|
|
}
|
|
|
|
return { items, tipOf, tombstoned };
|
|
};
|
|
|
|
const chainIsPublic = async (tribeId) => {
|
|
let cur;
|
|
try { cur = await tribesModel.getTribeById(tribeId); } catch (_) { return false; }
|
|
const seen = new Set();
|
|
while (cur) {
|
|
if (cur.isAnonymous) return false;
|
|
if (!cur.parentTribeId) return true;
|
|
if (seen.has(cur.parentTribeId)) return false;
|
|
seen.add(cur.parentTribeId);
|
|
try { cur = await tribesModel.getTribeById(cur.parentTribeId); } catch (_) { return false; }
|
|
}
|
|
return false;
|
|
};
|
|
|
|
return {
|
|
chainIsPublic,
|
|
|
|
async create(tribeId, contentType, data) {
|
|
if (!VALID_CONTENT_TYPES.includes(contentType)) throw new Error('Invalid content type');
|
|
if (data.status && !VALID_STATUSES.includes(data.status)) throw new Error('Invalid status. Must be OPEN, CLOSED, or IN-PROGRESS');
|
|
if (data.priority && !VALID_PRIORITIES.includes(data.priority)) throw new Error('Invalid priority. Must be LOW, MEDIUM, HIGH, or CRITICAL');
|
|
|
|
const client = await openSsb();
|
|
const rootId = await tribesModel.getRootId(tribeId);
|
|
const now = new Date().toISOString();
|
|
const body = {
|
|
k: 'tribe-content',
|
|
rootId,
|
|
contentType,
|
|
replaces: null,
|
|
title: data.title || '',
|
|
description: data.description || '',
|
|
status: data.status || 'OPEN',
|
|
date: data.date || null,
|
|
location: data.location || null,
|
|
price: data.price || null,
|
|
salary: data.salary || null,
|
|
priority: data.priority || null,
|
|
assignees: data.assignees || [],
|
|
options: data.options || [],
|
|
votes: data.votes || {},
|
|
category: data.category || null,
|
|
parentId: data.parentId || null,
|
|
tags: data.tags || [],
|
|
image: data.image || null,
|
|
mediaType: data.mediaType || null,
|
|
...(data.license ? { license: data.license } : {}),
|
|
url: data.url || null,
|
|
attendees: data.attendees || [],
|
|
deadline: data.deadline || null,
|
|
goal: data.goal || null,
|
|
funded: data.funded || 0,
|
|
refeeds: data.refeeds || 0,
|
|
refeeds_inhabitants: data.refeeds_inhabitants || [],
|
|
opinions: data.opinions || {},
|
|
opinions_inhabitants: data.opinions_inhabitants || [],
|
|
author: client.id,
|
|
createdAt: now,
|
|
updatedAt: now
|
|
};
|
|
return publishContent(rootId, body);
|
|
},
|
|
|
|
async update(contentId, data, existing) {
|
|
if (!existing) existing = await this.getById(contentId);
|
|
if (!existing) throw new Error('Content not found');
|
|
if (data.status && !VALID_STATUSES.includes(data.status)) throw new Error('Invalid status. Must be OPEN, CLOSED, or IN-PROGRESS');
|
|
if (data.priority && !VALID_PRIORITIES.includes(data.priority)) throw new Error('Invalid priority. Must be LOW, MEDIUM, HIGH, or CRITICAL');
|
|
|
|
const rootId = existing.rootId || (await tribesModel.getRootId(existing.tribeId || existing.rootId));
|
|
const now = new Date().toISOString();
|
|
const body = {
|
|
k: 'tribe-content',
|
|
rootId,
|
|
contentType: existing.contentType,
|
|
replaces: existing.id || contentId,
|
|
title: data.title !== undefined ? data.title : existing.title,
|
|
description: data.description !== undefined ? data.description : existing.description,
|
|
status: data.status !== undefined ? data.status : existing.status,
|
|
date: data.date !== undefined ? data.date : existing.date,
|
|
location: data.location !== undefined ? data.location : existing.location,
|
|
price: data.price !== undefined ? data.price : existing.price,
|
|
salary: data.salary !== undefined ? data.salary : existing.salary,
|
|
priority: data.priority !== undefined ? data.priority : existing.priority,
|
|
assignees: data.assignees !== undefined ? data.assignees : existing.assignees,
|
|
options: data.options !== undefined ? data.options : existing.options,
|
|
votes: data.votes !== undefined ? data.votes : existing.votes,
|
|
category: data.category !== undefined ? data.category : existing.category,
|
|
parentId: data.parentId !== undefined ? data.parentId : existing.parentId,
|
|
tags: data.tags !== undefined ? data.tags : existing.tags,
|
|
image: data.image !== undefined ? data.image : existing.image,
|
|
mediaType: data.mediaType !== undefined ? data.mediaType : existing.mediaType,
|
|
...((data.license !== undefined ? data.license : existing.license) ? { license: data.license !== undefined ? data.license : existing.license } : {}),
|
|
url: data.url !== undefined ? data.url : existing.url,
|
|
attendees: data.attendees !== undefined ? data.attendees : existing.attendees,
|
|
deadline: data.deadline !== undefined ? data.deadline : existing.deadline,
|
|
goal: data.goal !== undefined ? data.goal : existing.goal,
|
|
funded: data.funded !== undefined ? data.funded : existing.funded,
|
|
refeeds: data.refeeds !== undefined ? data.refeeds : existing.refeeds,
|
|
refeeds_inhabitants: data.refeeds_inhabitants !== undefined ? data.refeeds_inhabitants : existing.refeeds_inhabitants,
|
|
opinions: data.opinions !== undefined ? data.opinions : existing.opinions,
|
|
opinions_inhabitants: data.opinions_inhabitants !== undefined ? data.opinions_inhabitants : existing.opinions_inhabitants,
|
|
author: existing.author,
|
|
createdAt: existing.createdAt,
|
|
updatedAt: now
|
|
};
|
|
return publishContent(rootId, body);
|
|
},
|
|
|
|
async deleteById(contentId) {
|
|
const existing = await this.getById(contentId);
|
|
if (!existing) throw new Error('Content not found');
|
|
const rootId = existing.rootId || (await tribesModel.getRootId(existing.tribeId || existing.rootId));
|
|
const client = await openSsb();
|
|
const body = {
|
|
k: 'tombstone',
|
|
rootId,
|
|
target: existing.id || contentId,
|
|
author: client.id,
|
|
deletedAt: new Date().toISOString()
|
|
};
|
|
return wrapAndPublishContent(rootId, body);
|
|
},
|
|
|
|
async getById(contentId) {
|
|
const msgs = await readLog();
|
|
const { items, tipOf } = await decodeContentMsgs(msgs, {});
|
|
const tip = tipOf.get(contentId) || contentId;
|
|
return items.get(tip) || null;
|
|
},
|
|
|
|
async listByTribe(tribeId, contentType, filter) {
|
|
const rootId = await tribesModel.getRootId(tribeId).catch(() => tribeId);
|
|
const msgs = await readLog();
|
|
const { items } = await decodeContentMsgs(msgs, { rootId, contentType });
|
|
|
|
let result = [...items.values()];
|
|
if (filter === 'open') result = result.filter(i => i.status === 'OPEN');
|
|
else if (filter === 'closed') result = result.filter(i => i.status === 'CLOSED');
|
|
else if (filter === 'in-progress') result = result.filter(i => i.status === 'IN-PROGRESS');
|
|
|
|
return result.sort((a, b) => {
|
|
const ta = Date.parse(a.updatedAt || a.createdAt) || a._ts || 0;
|
|
const tb = Date.parse(b.updatedAt || b.createdAt) || b._ts || 0;
|
|
return tb - ta;
|
|
});
|
|
},
|
|
|
|
async toggleAttendee(contentId) {
|
|
const client = await openSsb();
|
|
const userId = client.id;
|
|
const item = await this.getById(contentId);
|
|
if (!item) throw new Error('Content not found');
|
|
const on = !(Array.isArray(item.attendees) && item.attendees.includes(userId));
|
|
return wrapAndPublishContent(item.rootId, { k: 'tc-collab', sub: 'attend', rootId: item.rootId, target: item.id, on });
|
|
},
|
|
|
|
async toggleAssignee(contentId) {
|
|
const client = await openSsb();
|
|
const userId = client.id;
|
|
const item = await this.getById(contentId);
|
|
if (!item) throw new Error('Content not found');
|
|
const on = !(Array.isArray(item.assignees) && item.assignees.includes(userId));
|
|
return wrapAndPublishContent(item.rootId, { k: 'tc-collab', sub: 'assign', rootId: item.rootId, target: item.id, on });
|
|
},
|
|
|
|
async updateStatus(contentId, status) {
|
|
if (!VALID_STATUSES.includes(status)) throw new Error('Invalid status. Must be OPEN, CLOSED, or IN-PROGRESS');
|
|
return this.update(contentId, { status });
|
|
},
|
|
|
|
async castVote(votationId, optionIndex) {
|
|
const client = await openSsb();
|
|
const userId = client.id;
|
|
const item = await this.getById(votationId);
|
|
if (!item) throw new Error('Votation not found');
|
|
if (item.status === 'CLOSED') throw new Error('Votation is closed');
|
|
const options = item.options || [];
|
|
if (!Number.isInteger(optionIndex) || optionIndex < 0 || optionIndex >= options.length) {
|
|
throw new Error('Invalid option index');
|
|
}
|
|
const votes = item.votes || {};
|
|
for (const key of Object.keys(votes)) {
|
|
const arr = Array.isArray(votes[key]) ? votes[key] : [];
|
|
if (arr.includes(userId)) throw new Error('Already voted');
|
|
}
|
|
return wrapAndPublishContent(item.rootId, { k: 'tc-collab', sub: 'vote', rootId: item.rootId, target: item.id, option: optionIndex });
|
|
},
|
|
|
|
async toggleRefeed(contentId) {
|
|
const client = await openSsb();
|
|
const userId = client.id;
|
|
const item = await this.getById(contentId);
|
|
if (!item) throw new Error('Content not found');
|
|
if (Array.isArray(item.refeeds_inhabitants) && item.refeeds_inhabitants.includes(userId)) return item;
|
|
return wrapAndPublishContent(item.rootId, { k: 'tc-collab', sub: 'refeed', rootId: item.rootId, target: item.id });
|
|
},
|
|
|
|
async castOpinion(contentId, category) {
|
|
if (!categories.includes(category)) throw new Error('Invalid opinion category');
|
|
const client = await openSsb();
|
|
const userId = client.id;
|
|
const item = await this.getById(contentId);
|
|
if (!item) throw new Error('Content not found');
|
|
if (Array.isArray(item.opinions_inhabitants) && item.opinions_inhabitants.includes(userId)) throw new Error('Already voted');
|
|
return wrapAndPublishContent(item.rootId, { k: 'tc-collab', sub: 'opinion', rootId: item.rootId, target: item.id, category });
|
|
},
|
|
|
|
reachLevels: REACH_LEVELS,
|
|
|
|
async publishExposure(item, level, replies = []) {
|
|
if (!REACH_LEVELS.includes(level)) throw new Error('Invalid level');
|
|
if (!item || !item.rootId) throw new Error('Content not found');
|
|
const client = await openSsb();
|
|
const publish = (c) => new Promise((resolve, reject) => client.publish(c, (err, r) => err ? reject(err) : resolve(r)));
|
|
const content = {
|
|
type: EXPOSURE_TYPE,
|
|
tribeId: item.rootId,
|
|
origin: item.originId || item.id,
|
|
contentType: item.contentType,
|
|
level,
|
|
item: null,
|
|
at: new Date().toISOString()
|
|
};
|
|
if (level !== 'tribe') {
|
|
const { replies: snapReplies, ...snapshot } = snapshotOf(item, replies);
|
|
const budget = longText.CONTENT_BYTES.plain - longText.contentBytes(content);
|
|
const sealed = await longText.chunkContent(snapshot, 'description', { maxBytes: budget, publish });
|
|
if (Array.isArray(snapReplies)) {
|
|
sealed.replies = snapReplies.slice();
|
|
while (sealed.replies.length && longText.contentBytes({ ...content, item: sealed }) > longText.CONTENT_BYTES.plain) sealed.replies.pop();
|
|
}
|
|
content.item = sealed;
|
|
}
|
|
return publish(content);
|
|
},
|
|
|
|
async exposureState({ ignorePrivacy = false } = {}) {
|
|
const client = await openSsb();
|
|
const msgs = await readTyped(client, [EXPOSURE_TYPE, longText.CHUNK_TYPE], { limit: tribeLogLimit });
|
|
const lookup = longText.lookupIn(longText.indexChunks(msgs));
|
|
const byOrigin = new Map();
|
|
for (const m of msgs) {
|
|
const c = m && m.value && m.value.content;
|
|
if (!c || c.type !== EXPOSURE_TYPE || typeof c.origin !== 'string' || typeof c.tribeId !== 'string' || !REACH_LEVELS.includes(c.level)) continue;
|
|
if (!byOrigin.has(c.origin)) byOrigin.set(c.origin, []);
|
|
byOrigin.get(c.origin).push({ by: m.value.author, ts: Number(m.value.timestamp) || 0, c });
|
|
}
|
|
const memberCache = new Map();
|
|
const isMember = async (author, tribeId) => {
|
|
const k = `${tribeId}|${author}`;
|
|
if (!memberCache.has(k)) memberCache.set(k, await tribesModel.isTribeMember(author, tribeId).catch(() => false));
|
|
return memberCache.get(k);
|
|
};
|
|
const everCache = new Map();
|
|
const wasMember = async (author, tribeId) => {
|
|
const k = `${tribeId}|${author}`;
|
|
if (!everCache.has(k)) everCache.set(k, await tribesModel.wasEverMember(author, tribeId).catch(() => false));
|
|
return everCache.get(k);
|
|
};
|
|
const privacyCache = new Map();
|
|
const isPrivate = async (tribeId) => {
|
|
if (!privacyCache.has(tribeId)) privacyCache.set(tribeId, !(await chainIsPublic(tribeId)));
|
|
return privacyCache.get(tribeId);
|
|
};
|
|
const state = new Map();
|
|
for (const [origin, list] of byOrigin) {
|
|
list.sort((a, b) => (b.ts - a.ts) || (REACH_RANK[a.c.level] - REACH_RANK[b.c.level]));
|
|
let chosen = null;
|
|
for (const e of list) {
|
|
if (await isMember(e.by, e.c.tribeId)) { chosen = e; break; }
|
|
if (e.c.level === 'tribe' && await wasMember(e.by, e.c.tribeId)) { chosen = e; break; }
|
|
}
|
|
if (!chosen) continue;
|
|
const priv = await isPrivate(chosen.c.tribeId);
|
|
const level = !ignorePrivacy && priv ? 'tribe' : chosen.c.level;
|
|
state.set(origin, { origin, tribeId: chosen.c.tribeId, contentType: chosen.c.contentType, level, item: level === 'tribe' || !chosen.c.item ? null : longText.resolveField(chosen.c.item, 'description', chosen.by, lookup), by: chosen.by, ts: chosen.ts });
|
|
}
|
|
return state;
|
|
},
|
|
|
|
async levelOf(item, state = null) {
|
|
const st = state || await this.exposureState();
|
|
const e = st.get(item && (item.originId || item.id));
|
|
return e ? e.level : 'tribe';
|
|
},
|
|
|
|
async listExposed(tribeId, contentType = null, minLevel = 'oasis', state = null) {
|
|
const rootId = await tribesModel.getRootId(tribeId).catch(() => tribeId);
|
|
const st = state || await this.exposureState();
|
|
const out = [];
|
|
for (const e of st.values()) {
|
|
if (e.tribeId !== rootId || !e.item || REACH_RANK[e.level] < REACH_RANK[minLevel]) continue;
|
|
const base = { ...e.item, id: e.origin, originId: e.origin, rootId, reach: e.level, exposedBy: e.by, _ts: e.ts, attendees: [], assignees: [], votes: {}, opinions: {}, opinions_inhabitants: [], refeeds: 0, refeeds_inhabitants: [] };
|
|
if (contentType === 'forum-reply') {
|
|
if (e.item.contentType !== 'forum') continue;
|
|
(e.item.replies || []).forEach((r, i) => out.push({ id: `${e.origin}:${i}`, originId: `${e.origin}:${i}`, rootId, contentType: 'forum-reply', parentId: e.origin, description: r.description, author: r.author, createdAt: r.createdAt, reach: e.level, attendees: [], assignees: [], votes: {}, opinions: {}, opinions_inhabitants: [], refeeds_inhabitants: [] }));
|
|
continue;
|
|
}
|
|
if (contentType && e.item.contentType !== contentType) continue;
|
|
out.push(base);
|
|
}
|
|
return out.sort((a, b) => (Date.parse(b.updatedAt || b.createdAt) || b._ts || 0) - (Date.parse(a.updatedAt || a.createdAt) || a._ts || 0));
|
|
},
|
|
|
|
async getThread(forumId) {
|
|
const msgs = await readLog();
|
|
const { items } = await decodeContentMsgs(msgs, {});
|
|
const all = [...items.values()];
|
|
const parent = all.find(i => i.id === forumId);
|
|
if (!parent) return { parent: null, replies: [] };
|
|
const replies = all
|
|
.filter(i => i.parentId === forumId && i.contentType === 'forum-reply')
|
|
.sort((a, b) => (Date.parse(a.createdAt) || 0) - (Date.parse(b.createdAt) || 0));
|
|
return { parent, replies };
|
|
}
|
|
};
|
|
};
|