mirror of
https://github.com/balzack/databag.git
synced 2025-02-12 11:39:17 +00:00
678 lines
22 KiB
JavaScript
678 lines
22 KiB
JavaScript
import { useState, useEffect, useRef, useContext } from 'react';
|
|
import { StoreContext } from 'context/StoreContext';
|
|
import { UploadContext } from 'context/UploadContext';
|
|
import { CardContext } from 'context/CardContext';
|
|
import { ChannelContext } from 'context/ChannelContext';
|
|
import { ProfileContext } from 'context/ProfileContext';
|
|
import moment from 'moment';
|
|
import CryptoJS from 'crypto-js';
|
|
|
|
export function useConversationContext() {
|
|
const [state, setState] = useState({
|
|
topic: null,
|
|
subject: null,
|
|
logo: null,
|
|
revision: null,
|
|
contacts: [],
|
|
topics: new Map(),
|
|
created: null,
|
|
host: null,
|
|
init: false,
|
|
progress: null,
|
|
cardId: null,
|
|
channelId: null,
|
|
pushEnabled: null,
|
|
locked: false,
|
|
unlocked: false,
|
|
seals: null,
|
|
});
|
|
const store = useContext(StoreContext);
|
|
const upload = useContext(UploadContext);
|
|
const card = useContext(CardContext);
|
|
const channel = useContext(ChannelContext);
|
|
const profile = useContext(ProfileContext);
|
|
const topics = useRef(null);
|
|
const revision = useRef(null);
|
|
const force = useRef(false);
|
|
const more = useRef(false);
|
|
const detailRevision = useRef(0);
|
|
const syncing = useRef(false);
|
|
const conversationId = useRef(null);
|
|
const reset = useRef(false);
|
|
const setView = useRef(0);
|
|
const transfer = useRef(null);
|
|
|
|
const updateState = (value) => {
|
|
setState((s) => ({ ...s, ...value }))
|
|
}
|
|
|
|
useEffect(() => {
|
|
const { cardId, channelId } = state;
|
|
const key = cardId ? `${cardId}:${channelId}` : `:${channelId}`
|
|
const progress = upload.state.progress.get(key);
|
|
if (progress) {
|
|
let count = 0;
|
|
let complete = 0;
|
|
let active = 0;
|
|
let loaded = 0;
|
|
let total = 0;
|
|
let error = false;
|
|
progress.forEach(post => {
|
|
count += post.count;
|
|
complete += (post.index - 1);
|
|
if (post.active) {
|
|
active += 1;
|
|
loaded += post.active.loaded;
|
|
total += post.active.total;
|
|
}
|
|
if (post.error) {
|
|
error = true;
|
|
}
|
|
});
|
|
percent = Math.floor(((((loaded / total) * active) + complete) / count) * 100);
|
|
if (transfer.current == null || error || Math.abs(transfer.current - percent) > 5) {
|
|
updateState({ progress: percent, uploadError: error });
|
|
transfer.current = percent;
|
|
}
|
|
|
|
if (error) {
|
|
setTimeout(() => {
|
|
upload.actions.clearErrors(cardId, channelId);
|
|
updateState({ progress: null, uploadError: false });
|
|
transfer.current = null;
|
|
}, 2000);
|
|
}
|
|
}
|
|
else {
|
|
updateState({ progress: null });
|
|
transfer.current = null;
|
|
}
|
|
}, [upload, state.cardId, state.channelId]);
|
|
|
|
const getTopicItems = async (cardId, channelId) => {
|
|
if (cardId) {
|
|
return await card.actions.getChannelTopicItems(cardId, channelId);
|
|
}
|
|
return await channel.actions.getTopicItems(channelId);
|
|
}
|
|
const setTopicItem = async (cardId, channelId, topic) => {
|
|
if (cardId) {
|
|
return await card.actions.setChannelTopicItem(cardId, channelId, topic);
|
|
}
|
|
return await channel.actions.setTopicItem(channelId, topic);
|
|
}
|
|
const clearTopicItem = async (cardId, channelId, topicId) => {
|
|
if (cardId) {
|
|
return await card.actions.clearChannelTopicItem(cardId, channelId, topicId);
|
|
}
|
|
return await channel.actions.clearTopicItem(channelId, topicId);
|
|
}
|
|
const getTopic = async (cardId, channelId, topicId) => {
|
|
if (cardId) {
|
|
return await card.actions.getChannelTopic(cardId, channelId, topicId);
|
|
}
|
|
return await channel.actions.getTopic(channelId, topicId);
|
|
}
|
|
const getTopics = async (cardId, channelId, revision, begin, end) => {
|
|
if (cardId) {
|
|
return await card.actions.getChannelTopics(cardId, channelId, revision, 16, begin, end);
|
|
}
|
|
return await channel.actions.getTopics(channelId, revision, 16, begin, end)
|
|
}
|
|
const getTopicAssetUrl = (cardId, channelId, assetId) => {
|
|
if (cardId) {
|
|
return card.actions.getChannelTopicAssetUrl(cardId, channelId, topicId, assetId);
|
|
}
|
|
return channel.actions.getTopicAssetUrl(channelId, assetId);
|
|
}
|
|
const addTopic = async (cardId, channelId, message, asssets) => {
|
|
if (cardId) {
|
|
return await card.actions.addChannelTopic(cardId, channelId, message, assetId);
|
|
}
|
|
return await channel.actions.addTopic(channelId, message, assetId);
|
|
}
|
|
const setTopicSubject = async (cardId, channelId, topicId, dataType, data) => {
|
|
if (cardId) {
|
|
return await card.actions.setChannelTopicSubject(cardId, channelId, topicId, dataType, data);
|
|
}
|
|
return await channel.actions.setTopicSubject(channelId, topicId, dataType, data);
|
|
}
|
|
const remove = async (cardId, channelId) => {
|
|
if (cardId) {
|
|
return await card.actions.removeChannel(cardId, channelId);
|
|
}
|
|
return await channel.actions.remove(channelId);
|
|
}
|
|
const removeTopic = async (cardId, channelId, topicId) => {
|
|
if (cardId) {
|
|
return await card.actions.removeChannelTopic(cardId, channelId, topicId);
|
|
}
|
|
return await channel.actions.removeTopic(channelId, topicId);
|
|
}
|
|
const setNotifications = async (cardId, channelId, notify) => {
|
|
if (cardId) {
|
|
return await card.actions.setChannelNotifications(cardId, channelId, notify);
|
|
}
|
|
return await channel.actions.setNotifications(channelId, notify);
|
|
}
|
|
const getNotifications = async (cardId, channelId) => {
|
|
if (cardId) {
|
|
return await card.actions.getChannelNotifications(cardId, channelId);
|
|
}
|
|
return await channel.actions.getNotifications(channelId);
|
|
}
|
|
const setSyncRevision = async (cardId, channelId, revision) => {
|
|
if (cardId) {
|
|
return await card.actions.setSyncRevision(cardId, channelId, revision);
|
|
}
|
|
return await channel.actions.setSyncRevision(channelId, revision);
|
|
}
|
|
const setTopicMarker = async (cardId, channelId, marker) => {
|
|
if (cardId) {
|
|
return await card.actions.setTopicMarker(cardId, channelId, marker);
|
|
}
|
|
return await channel.actions.setTopicMarker(channelId, marker);
|
|
}
|
|
|
|
useEffect(() => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
const channelItem = getChannel(cardId, channelId);
|
|
if (channelItem) {
|
|
setChannel(channelItem);
|
|
}
|
|
}
|
|
}, [card, channel]);
|
|
|
|
const sync = async () => {
|
|
const curView = setView.current;
|
|
if (!syncing.current) {
|
|
if (reset.current) {
|
|
revision.current = null;
|
|
detailRevision.current = null;
|
|
topics.current = null;
|
|
reset.current = false;
|
|
}
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
const channelItem = getChannel(cardId, channelId);
|
|
|
|
if (channelItem && (channelItem.revision !== revision.current || force.current || more.current)) {
|
|
syncing.current = true;
|
|
|
|
try {
|
|
|
|
// sync from server
|
|
let res;
|
|
if (!topics.current) {
|
|
topics.current = new Map();
|
|
const items = await getTopicItems(cardId, channelId);
|
|
items.forEach(item => {
|
|
topics.current.set(item.topicId, item);
|
|
});
|
|
await setChannel(channelItem);
|
|
detailRevision.current = channelItem.detailRevision;
|
|
}
|
|
else if (detailRevision.current != channelItem.detailRevision) {
|
|
await setChannel(channelItem);
|
|
detailRevision.current = channelItem.detailRevision;
|
|
}
|
|
else if (more.current) {
|
|
more.current = false;
|
|
res = await getTopics(cardId, channelId, null, null, channelItem.topicMarker)
|
|
}
|
|
else if (channelItem.topicRevision !== channelItem.syncRevision || force.current) {
|
|
force.current = false;
|
|
res = await getTopics(cardId, channelId, channelItem.syncRevision, channelItem.topicMarker)
|
|
}
|
|
else {
|
|
if (cardId) {
|
|
card.actions.setChannelReadRevision(cardId, channelId, revision.current);
|
|
}
|
|
else {
|
|
channel.actions.setReadRevision(channelId, channelItem.revision);
|
|
}
|
|
revision.current = channelItem.revision;
|
|
}
|
|
|
|
if (res?.topics) {
|
|
for (const topic of res.topics) {
|
|
if (!topic.data) {
|
|
topics.current.delete(topic.id);
|
|
await clearTopicItem(cardId, channelId, topic.id);
|
|
}
|
|
else {
|
|
const cached = topics.current.get(topic.id);
|
|
if (!cached || cached.detailRevision != topic.data.detailRevision) {
|
|
if (!topic.data.topicDetail) {
|
|
const updated = await getTopic(cardId, channelId, topic.id);
|
|
topic.data = updated.data;
|
|
}
|
|
if (!topic.data) {
|
|
topics.current.delete(topic.id);
|
|
await clearTopicItem(cardId, channelId, topic.id);
|
|
}
|
|
else {
|
|
await setTopicItem(cardId, channelId, topic);
|
|
const { id, revision, data } = topic;
|
|
topics.current.set(id, { topicId: id, revision: revision, detailRevision: topic.data.detailRevision, detail: topic.data.topicDetail });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (res?.marker) {
|
|
await setTopicMarker(cardId, channelId, res.marker);
|
|
}
|
|
if (res?.revision) {
|
|
await setSyncRevision(cardId, channelId, res.revision);
|
|
}
|
|
|
|
if (curView == setView.current) {
|
|
updateState({ topics: topics.current, init: true, error: false });
|
|
}
|
|
|
|
syncing.current = false;
|
|
sync();
|
|
}
|
|
catch(err) {
|
|
console.log(err);
|
|
syncing.current = false;
|
|
updateState({ error: true });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
const getCard = (guid) => {
|
|
let contact = null
|
|
card.state.cards.forEach((card, cardId, map) => {
|
|
if (card?.profile?.guid === guid) {
|
|
contact = card;
|
|
}
|
|
});
|
|
return contact;
|
|
}
|
|
|
|
const getChannel = (cardId, channelId) => {
|
|
if (cardId) {
|
|
const entry = card.state.cards.get(cardId);
|
|
return entry?.channels.get(channelId);
|
|
}
|
|
return channel.state.channels.get(channelId);
|
|
}
|
|
|
|
const setChannel = async (item) => {
|
|
let contacts = [];
|
|
let logo = null;
|
|
let topic = null;
|
|
let subject = null;
|
|
let locked = false;
|
|
let unlocked = false;
|
|
let seals = null;
|
|
|
|
let timestamp;
|
|
const date = new Date(item.detail.created * 1000);
|
|
const now = new Date();
|
|
const offset = now.getTime() - date.getTime();
|
|
if(offset < 86400000) {
|
|
timestamp = moment(date).format('h:mma');
|
|
}
|
|
else if (offset < 31449600000) {
|
|
timestamp = moment(date).format('M/DD');
|
|
}
|
|
else {
|
|
timestamp = moment(date).format('M/DD/YYYY');
|
|
}
|
|
|
|
if (!item) {
|
|
updateState({ contacts, logo, subject, topic });
|
|
return;
|
|
}
|
|
|
|
if (item.cardId) {
|
|
contacts.push(card.state.cards.get(item.cardId));
|
|
}
|
|
if (item?.detail?.members) {
|
|
const profileGuid = profile.state.profile.guid;
|
|
item.detail.members.forEach(guid => {
|
|
if (profileGuid !== guid) {
|
|
const contact = getCard(guid);
|
|
contacts.push(contact);
|
|
}
|
|
})
|
|
}
|
|
|
|
if (contacts.length === 0) {
|
|
logo = 'solution';
|
|
}
|
|
else if (contacts.length === 1) {
|
|
if (contacts[0]?.profile?.imageSet) {
|
|
logo = card.actions.getCardLogo(contacts[0].cardId, contacts[0].profileRevision);
|
|
}
|
|
else {
|
|
logo = 'avatar';
|
|
}
|
|
}
|
|
else {
|
|
logo = 'appstore';
|
|
}
|
|
|
|
if (item?.detail?.dataType === 'sealed') {
|
|
locked = true;
|
|
unlocked = item.unsealedDetail != null;
|
|
if (item.unsealedDetail?.subject) {
|
|
topic = item.unsealedDetail.subject;
|
|
subject = topic;
|
|
}
|
|
try {
|
|
seals = JSON.parse(item.detail.data).seals;
|
|
}
|
|
catch (err) {
|
|
console.log(err);
|
|
}
|
|
}
|
|
else {
|
|
if (item?.detail?.data) {
|
|
try {
|
|
topic = JSON.parse(item?.detail?.data).subject;
|
|
subject = topic;
|
|
}
|
|
catch (err) {
|
|
console.log(err);
|
|
}
|
|
}
|
|
}
|
|
if (!subject) {
|
|
if (contacts.length) {
|
|
let names = [];
|
|
for (let contact of contacts) {
|
|
if (contact?.profile?.name) {
|
|
names.push(contact.profile.name);
|
|
}
|
|
else if (contact?.profile?.handle) {
|
|
names.push(contact?.profile?.handle);
|
|
}
|
|
}
|
|
subject = names.join(', ');
|
|
}
|
|
else {
|
|
subject = "Notes";
|
|
}
|
|
}
|
|
|
|
const pushEnabled = await getNotifications(item.cardId, item.channelId);
|
|
|
|
const { enableImage, enableAudio, enableVideo } = item.detail;
|
|
updateState({ topic, subject, logo, contacts, host: item.cardId, created: timestamp,
|
|
enableImage, enableAudio, enableVideo, pushEnabled, locked, unlocked, seals });
|
|
}
|
|
|
|
useEffect(() => {
|
|
sync();
|
|
}, [card, channel]);
|
|
|
|
const actions = {
|
|
setChannel: (selected) => {
|
|
if (selected == null) {
|
|
setView.current++;
|
|
conversationId.current = null;
|
|
reset.current = true;
|
|
updateState({ subject: null, logo: null, locked: true, unlocked: false, contacts: [], topics: new Map() });
|
|
}
|
|
else if (selected.cardId !== conversationId.current?.cardId || selected.channelId !== conversationId.current?.channelId) {
|
|
setView.current++;
|
|
conversationId.current = selected;
|
|
reset.current = true;
|
|
updateState({ subject: null, logo: null, contacts: [], topics: new Map(), init: false,
|
|
cardId: selected.cardId, channelId: selected.channelId });
|
|
sync();
|
|
const { cardId, channelId, revision } = selected;
|
|
if (cardId) {
|
|
card.actions.setChannelReadRevision(cardId, channelId, revision);
|
|
}
|
|
else {
|
|
channel.actions.setReadRevision(channelId, revision);
|
|
}
|
|
}
|
|
},
|
|
getTopicAssetUrl: (topicId, assetId) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
return card.actions.getChannelTopicAssetUrl(cardId, channelId, topicId, assetId);
|
|
}
|
|
else {
|
|
return channel.actions.getTopicAssetUrl(channelId, topicId, assetId);
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
addTopic: async (message, files) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.addChannelTopic(cardId, channelId, message, files);
|
|
}
|
|
else {
|
|
await channel.actions.addTopic(channelId, message, files);
|
|
}
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
},
|
|
addSealedTopic: async (message, sealKey) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.addSealedChannelTopic(cardId, channelId, message, sealKey);
|
|
}
|
|
else {
|
|
await channel.actions.addSealedTopic(channelId, message, sealKey);
|
|
}
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
},
|
|
unsealTopic: async (topicId, sealKey) => {
|
|
try {
|
|
const topic = topics.current.get(topicId);
|
|
const { messageEncrypted, messageIv } = JSON.parse(topic.detail.data);
|
|
const iv = CryptoJS.enc.Hex.parse(messageIv);
|
|
const key = CryptoJS.enc.Hex.parse(sealKey);
|
|
const enc = CryptoJS.enc.Base64.parse(messageEncrypted);
|
|
let cipher = CryptoJS.lib.CipherParams.create({ ciphertext: enc, iv: iv });
|
|
const dec = CryptoJS.AES.decrypt(cipher, key, { iv: iv });
|
|
topic.unsealedDetail = JSON.parse(dec.toString(CryptoJS.enc.Utf8));
|
|
topics.current.set(topicId, { ...topic });
|
|
updateState({ topics: topics.current });
|
|
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.setChannelTopicUnsealedDetail(cardId, channelId, topic.topicId, topic.detailRevision, topic.unsealedDetial);
|
|
}
|
|
else {
|
|
await channel.actions.setTopicUnsealedDetail(channelId, topic.topicId, topic.detailRevision, topic.unsealedDetail);
|
|
}
|
|
}
|
|
catch(err) {
|
|
console.log(err);
|
|
}
|
|
},
|
|
setSubject: async (subject) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
throw new Error("can only set hosted channel subjects");
|
|
}
|
|
await channel.actions.setSubject(channelId, subject);
|
|
}
|
|
},
|
|
setSealedSubject: async (subject, sealKey) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
throw new Error("can only set hosted channel subjects");
|
|
}
|
|
await channel.actions.setSealedSubject(channelId, subject, sealKey);
|
|
}
|
|
},
|
|
remove: async () => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
await remove(cardId, channelId);
|
|
}
|
|
},
|
|
setNotifications: async (notify) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
await setNotifications(cardId, channelId, notify);
|
|
updateState({ pushEnabled: notify });
|
|
}
|
|
},
|
|
removeTopic: async (topicId) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.removeChannelTopic(cardId, channelId, topicId);
|
|
}
|
|
else {
|
|
await channel.actions.removeTopic(channelId, topicId);
|
|
}
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
},
|
|
setTopicSubject: async (topicId, data) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
return await card.actions.setChannelTopicSubject(cardId, channelId, topicId, 'superbasictopic', data);
|
|
}
|
|
else {
|
|
return await channel.actions.setTopicSubject(channelId, topicId, 'superbasictopic', data);
|
|
}
|
|
}
|
|
force.current = true;
|
|
sync();
|
|
},
|
|
setSealedTopicSubject: async (topicId, data, sealKey) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
|
|
const iv = CryptoJS.lib.WordArray.random(128 / 8);
|
|
const key = CryptoJS.enc.Hex.parse(sealKey);
|
|
const encrypted = CryptoJS.AES.encrypt(JSON.stringify({ message: data }), key, { iv: iv });
|
|
const messageEncrypted = encrypted.ciphertext.toString(CryptoJS.enc.Base64)
|
|
const messageIv = iv.toString();
|
|
|
|
if (cardId) {
|
|
return await card.actions.setChannelTopicSubject(cardId, channelId, topicId, 'sealedtopic', { messageEncrypted, messageIv });
|
|
}
|
|
else {
|
|
return await channel.actions.setTopicSubject(channelId, topicId, 'sealedtopic', { messageEncrypted, messageIv });
|
|
}
|
|
|
|
}
|
|
},
|
|
setCard: async (id) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
throw new Error("can only set members on hosted channel");
|
|
}
|
|
await channel.actions.setCard(channelId, id);
|
|
}
|
|
},
|
|
clearCard: async (id) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
throw new Error("can only clear members on hosted channel");
|
|
}
|
|
await channel.actions.clearCard(channelId, id);
|
|
}
|
|
},
|
|
addReport: async () => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
return await card.actions.addChannelReport(cardId, channelId);
|
|
}
|
|
else {
|
|
return await channel.actions.addReport(channelId);
|
|
}
|
|
}
|
|
},
|
|
addTopicReport: async(topicId) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
return await card.actions.addChannelTopicReport(cardId, channelId, topicId);
|
|
}
|
|
else {
|
|
return await channel.actions.addTopicReport(channelId, topicId);
|
|
}
|
|
}
|
|
},
|
|
setBlocked: async () => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.setChannelBlocked(cardId, channelId);
|
|
}
|
|
else {
|
|
await channel.actions.setBlocked(channelId);
|
|
}
|
|
}
|
|
},
|
|
blockTopic: async (topicId) => {
|
|
if (conversationId.current) {
|
|
const { cardId, channelId } = conversationId.current;
|
|
if (cardId) {
|
|
await card.actions.setChannelTopicBlocked(cardId, channelId, topicId);
|
|
}
|
|
else {
|
|
await channel.actions.setTopicBlocked(channelId, topicId);
|
|
}
|
|
const topic = topics.current.get(topicId);
|
|
if (topic) {
|
|
topic.blocked = 1;
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
}
|
|
},
|
|
unblockTopic: async (cardId, channelId, topicId) => {
|
|
if (conversationId.current) {
|
|
if (conversationId.current.cardId == cardId && conversationId.current.channelId == channelId) {
|
|
const topic = topics.current.get(topicId);
|
|
if (topic) {
|
|
topic.blocked = 0;
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
}
|
|
}
|
|
},
|
|
loadMore: () => {
|
|
if (conversationId.current) {
|
|
more.current = true;
|
|
sync();
|
|
}
|
|
},
|
|
resync: () => {
|
|
if (conversationId.current) {
|
|
force.current = true;
|
|
sync();
|
|
}
|
|
},
|
|
}
|
|
|
|
return { state, actions }
|
|
}
|
|
|
|
|