mirror of
https://github.com/balzack/databag.git
synced 2025-02-11 19:19:16 +00:00
554 lines
24 KiB
JavaScript
554 lines
24 KiB
JavaScript
import { useState, useRef, useContext } from 'react';
|
|
import { StoreContext } from 'context/StoreContext';
|
|
import { UploadContext } from 'context/UploadContext';
|
|
import { addFlag } from 'api/addFlag';
|
|
import { getCard } from 'api/getCard';
|
|
import { getCards } from 'api/getCards';
|
|
import { getCardProfile } from 'api/getCardProfile';
|
|
import { setCardProfile } from 'api/setCardProfile';
|
|
import { getCardDetail } from 'api/getCardDetail';
|
|
import { getContactProfile } from 'api/getContactProfile';
|
|
import { getContactChannels } from 'api/getContactChannels';
|
|
import { getContactChannelDetail } from 'api/getContactChannelDetail';
|
|
import { getContactChannelSummary } from 'api/getContactChannelSummary';
|
|
import { getCardImageUrl } from 'api/getCardImageUrl';
|
|
import { addCard } from 'api/addCard';
|
|
import { removeCard } from 'api/removeCard';
|
|
import { setCardConnecting, setCardConnected, setCardConfirmed } from 'api/setCardStatus';
|
|
import { getCardOpenMessage } from 'api/getCardOpenMessage';
|
|
import { setCardOpenMessage } from 'api/setCardOpenMessage';
|
|
import { getCardCloseMessage } from 'api/getCardCloseMessage';
|
|
import { setCardCloseMessage } from 'api/setCardCloseMessage';
|
|
import { getContactChannelTopic } from 'api/getContactChannelTopic';
|
|
import { getContactChannelTopics } from 'api/getContactChannelTopics';
|
|
import { getContactChannelTopicAssetUrl } from 'api/getContactChannelTopicAssetUrl';
|
|
import { addContactChannelTopic } from 'api/addContactChannelTopic';
|
|
import { setContactChannelTopicSubject } from 'api/setContactChannelTopicSubject';
|
|
import { removeContactChannel } from 'api/removeContactChannel';
|
|
import { removeContactChannelTopic } from 'api/removeContactChannelTopic';
|
|
import { getContactChannelNotifications } from 'api/getContactChannelNotifications';
|
|
import { setContactChannelNotifications } from 'api/setContactChannelNotifications';
|
|
|
|
export function useCardContext() {
|
|
const [state, setState] = useState({
|
|
offsync: false,
|
|
cards: new Map(),
|
|
viewRevision: null,
|
|
});
|
|
const upload = useContext(UploadContext);
|
|
const access = useRef(null);
|
|
const setRevision = useRef(null);
|
|
const curRevision = useRef(null);
|
|
const cards = useRef(new Map());
|
|
const syncing = useRef(false);
|
|
const store = useContext(StoreContext);
|
|
|
|
const updateState = (value) => {
|
|
setState((s) => ({ ...s, ...value }))
|
|
}
|
|
|
|
const setCardItem = (card) => {
|
|
return {
|
|
cardId: card.id,
|
|
revision: card.revision,
|
|
detailRevision: card.data?.detailRevision,
|
|
profileRevision: card.data?.profileRevision,
|
|
detail: card.data?.cardDetail,
|
|
profile: card.data?.cardProfile,
|
|
notifiedView: card.data?.notifiedView,
|
|
notifiedProfile: card.data?.notifiedProfile,
|
|
notifiedArticle: card.data?.notifiedArticle,
|
|
notifiedChannel: card.data?.notifiedChannel,
|
|
}
|
|
}
|
|
|
|
const setCardField = (cardId, field, value) => {
|
|
const item = cards.current.get(cardId);
|
|
if (item?.card) {
|
|
item.card[field] = value;
|
|
cards.current.set(cardId, { ...item });
|
|
updateState({ cards: cards.current });
|
|
}
|
|
}
|
|
|
|
const setCardChannelItem = (cardChannel) => {
|
|
return {
|
|
channelId: cardChannel.id,
|
|
revision: cardChannel.revision,
|
|
detailRevision: cardChannel.data.detailRevision,
|
|
topicRevision: cardChannel.data.topicRevision,
|
|
detail: cardChannel.data.channelDetail,
|
|
summary: cardChannel.data.channelSummary,
|
|
};
|
|
};
|
|
|
|
const setCardChannelField = (cardId, channelId, field, value, field2, value2) => {
|
|
const card = cards.current.get(cardId);
|
|
if (card) {
|
|
const channel = card.channels.get(channelId);
|
|
if (channel) {
|
|
channel[field] = value;
|
|
if(field2) {
|
|
channel[field2] = value2;
|
|
}
|
|
card.channels.set(channelId, { ...channel });
|
|
cards.current.set(cardId, { ...card });
|
|
updateState({ cards: cards.current });
|
|
}
|
|
}
|
|
};
|
|
|
|
const resyncCard = async (cardId) => {
|
|
if (!syncing.current) {
|
|
syncing.current = true;
|
|
|
|
try {
|
|
const { server, token, guid } = access.current || {};
|
|
const entry = cards.current.get(cardId);
|
|
if (entry?.card?.detail.status === 'connected') {
|
|
const card = await getCard(server, token, cardId);
|
|
const { notifiedView, notifiedProfile, notifiedArticle, notifiedChannel } = card.data || {};
|
|
const cardRevision = { view: notifiedView, profile: notifiedProfile, artcile: notifiedArticle, channel: notifiedChannel };
|
|
await syncCard(server, token, guid, entry, cardRevision);
|
|
await store.actions.clearCardItemOffsync(guid, cardId);
|
|
entry.card.offsync = false;
|
|
|
|
cards.current.set(cardId, entry);
|
|
updateState({ cards: cards.current });
|
|
}
|
|
}
|
|
catch(err) {
|
|
console.log(err);
|
|
}
|
|
syncing.current = false;
|
|
await sync();
|
|
}
|
|
}
|
|
|
|
const sync = async () => {
|
|
if (access.current && !syncing.current && setRevision.current !== curRevision.current) {
|
|
syncing.current = true;
|
|
try {
|
|
const { server, token, guid } = access.current || {};
|
|
const revision = curRevision.current;
|
|
const delta = await getCards(server, token, setRevision.current);
|
|
for (let card of delta) {
|
|
if (card.data) {
|
|
const item = setCardItem(card);
|
|
const entry = cards.current.get(card.id) || { channels: new Map() };
|
|
if (!entry.card) {
|
|
const { cardId, detailRevision, profileRevision } = item;
|
|
const entryCard = { cardId, detailRevision, profileRevision };
|
|
if (item.detail) {
|
|
entryCard.detail = item.detail;
|
|
}
|
|
else {
|
|
entryCard.detail = await getCardDetail(server, token, card.id);
|
|
}
|
|
if (item.profile) {
|
|
entryCard.profile = item.profile;
|
|
}
|
|
else {
|
|
entryCard.profile = await getCardProfile(server, token, card.id);
|
|
}
|
|
await store.actions.setCardItem(guid, entryCard);
|
|
entry.card = entryCard;
|
|
cards.current.set(card.id, entry);
|
|
}
|
|
else {
|
|
const { profileRevision, detailRevision } = entry.card;
|
|
if (item.profileRevision !== profileRevision) {
|
|
if (item.profile) {
|
|
entry.card.profile = item.profile;
|
|
}
|
|
else {
|
|
entry.card.profile = await getCardProfile(server, token, card.id);
|
|
}
|
|
entry.card.profileRevision = item.profileRevision;
|
|
await store.actions.setCardItemProfile(guid, card.id, entry.card.profileRevision, entry.card.profile);
|
|
}
|
|
if (item.detailRevision !== detailRevision) {
|
|
if (item.detail) {
|
|
entry.card.detail = item.detail;
|
|
}
|
|
else {
|
|
entry.card.detail = await getCardDetail(server, token, card.id);
|
|
}
|
|
entry.card.detailRevision = item.detailRevision;
|
|
await store.actions.setCardItemDetail(guid, card.id, entry.card.detailRevision, entry.card.detail);
|
|
}
|
|
}
|
|
if (entry.card.detail?.status === 'connected' && !entry.card.offsync) {
|
|
try {
|
|
const { notifiedView, notifiedProfile, notifiedArticle, notifiedChannel } = item;
|
|
const cardRevision = { view: notifiedView, profile: notifiedProfile, article: notifiedArticle, channel: notifiedChannel };
|
|
await syncCard(server, token, guid, entry, cardRevision);
|
|
}
|
|
catch (err) {
|
|
console.log(err);
|
|
entry.card.offsync = true;
|
|
await store.actions.setCardItemOffsync(guid, card.id);
|
|
}
|
|
}
|
|
cards.current.set(card.id, { ...entry });
|
|
}
|
|
else {
|
|
const entry = cards.current.get(card.id) || { card: {}, channels: new Map() };
|
|
const ids = [];
|
|
entry.channels.forEach((value, key) => {
|
|
ids.push(key);
|
|
});
|
|
for (let i = 0; i < ids.length; i++) {
|
|
await store.actions.clearCardChannelTopicItems(guid, card.id, ids[i]);
|
|
}
|
|
await store.actions.clearCardChannelItems(guid, card.id);
|
|
await store.actions.clearCardItem(guid, card.id);
|
|
cards.current.delete(card.id);
|
|
}
|
|
}
|
|
setRevision.current = revision;
|
|
await store.actions.setCardRevision(guid, revision);
|
|
updateState({ offsync: false, cards: cards.current });
|
|
}
|
|
catch (err) {
|
|
console.log(err);
|
|
syncing.current = false;
|
|
updateState({ offsync: true });
|
|
return;
|
|
}
|
|
|
|
syncing.current = false;
|
|
await sync();
|
|
}
|
|
};
|
|
|
|
const syncCard = async (server, token, guid, entry, cardRevision) => {
|
|
|
|
const { detail, profile, cardId } = entry.card;
|
|
const { notifiedView, notifiedProfile, notifiedArticle, notifiedChannel } = entry.card;
|
|
const cardServer = profile?.node ? profile.node : server;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
|
|
if (entry.card.notifiedProfile !== cardRevision.profile) {
|
|
if (entry.card.profileRevision !== cardRevision.profile) {
|
|
const message = await getContactProfile(cardServer, cardToken);
|
|
await setCardProfile(server, token, cardId, message);
|
|
}
|
|
entry.card.notifiedProfile = cardRevision.profile;
|
|
store.actions.setCardItemNotifiedProfile(guid, cardId, cardRevision.profile);
|
|
}
|
|
|
|
if (entry.card.notifiedView !== cardRevision.view || entry.card.notifiedChannel !== cardRevision.channel) {
|
|
const view = cardRevision.view === entry.card.notifiedView ? entry.card.notifiedView : null;
|
|
const channel = cardRevision.view === entry.card.notifiedView ? entry.card.notifiedChannel : null;
|
|
const delta = await getContactChannels(cardServer, cardToken, view, channel);
|
|
for (let channel of delta) {
|
|
if (channel.data) {
|
|
const channelItem = setCardChannelItem(channel);
|
|
const channelEntry = entry.channels.get(channel.id);
|
|
if (!channelEntry) {
|
|
if (!channelItem.detail) {
|
|
channelItem.detail = await getContactChannelDetail(cardServer, cardToken, channel.id);
|
|
}
|
|
if (!channelItem.summary) {
|
|
channelItem.summary = await getContactChannelSummary(cardServer, cardToken, channel.id);
|
|
}
|
|
await store.actions.setCardChannelItem(guid, cardId, channelItem);
|
|
entry.channels.set(channel.id, { ...channelItem });
|
|
}
|
|
else {
|
|
if (channelItem.detailRevision !== channelEntry.detailRevision) {
|
|
if (channelItem.detail) {
|
|
channelEntry.detail = channelItem.detail;
|
|
}
|
|
else {
|
|
channelEntry.detail = await getContactChannelDetail(cardServer, cardToken, channel.id);
|
|
}
|
|
channelEntry.unsealedDetail = null;
|
|
channelEntry.detailRevision = channelItem.detailRevision;
|
|
await store.actions.setCardChannelItemDetail(guid, cardId, channel.id, channelEntry.detailRevision, channelEntry.detail);
|
|
}
|
|
if (channelItem.topicRevision !== channelEntry.topicRevision) {
|
|
if (channelItem.summary) {
|
|
channelEntry.summary = channelItem.summary;
|
|
}
|
|
else {
|
|
channelEntry.summary = await getContactChannelSummary(cardServer, cardToken, channel.id);
|
|
}
|
|
channelEntry.unsealedSummary = null;
|
|
channelEntry.topicRevision = channelItem.topicRevision;
|
|
await store.actions.setCardChannelItemSummary(guid, cardId, channel.id, channelEntry.topicRevision, channelEntry.summary);
|
|
}
|
|
entry.channels.set(channel.id, { ...channelEntry });
|
|
}
|
|
}
|
|
else {
|
|
await store.actions.clearCardChannelTopicItems(guid, cardId, channel.id);
|
|
await store.actions.clearCardChannelItem(guid, cardId, channel.id);
|
|
entry.channels.delete(channel.id);
|
|
}
|
|
}
|
|
entry.card.notifiedChannel = cardRevision.channel;
|
|
await store.actions.setCardItemNotifiedChannel(guid, cardId, cardRevision.channel);
|
|
entry.card.notifiedView = cardRevision.view;
|
|
await store.actions.setCardItemNotifiedView(guid, cardId, cardRevision.view);
|
|
}
|
|
};
|
|
|
|
const actions = {
|
|
setSession: async (session) => {
|
|
if (access.current || syncing.current) {
|
|
throw new Error('invalid card state');
|
|
}
|
|
access.current = session;
|
|
cards.current = new Map();
|
|
const cardItems = await store.actions.getCardItems(session.guid);
|
|
for(card of cardItems) {
|
|
const entry = { card, channels: new Map() };
|
|
const cardChannelItems = await store.actions.getCardChannelItems(session.guid, card.cardId);
|
|
for (cardChannel of cardChannelItems) {
|
|
entry.channels.set(cardChannel.channelId, cardChannel);
|
|
}
|
|
cards.current.set(card.cardId, entry);
|
|
}
|
|
const status = await store.actions.getCardRequestStatus(session.guid);
|
|
const revision = await store.actions.getCardRevision(session.guid);
|
|
curRevision.current = revision;
|
|
setRevision.current = revision;
|
|
setState({ offsync: false, viewRevision: status?.revision, cards: cards.current });
|
|
},
|
|
clearSession: () => {
|
|
access.current = null;
|
|
},
|
|
setRevision: (revision) => {
|
|
curRevision.current = revision;
|
|
sync();
|
|
},
|
|
addCard: async (message) => {
|
|
const { server, token } = access.current || {};
|
|
return await addCard(server, token, message);
|
|
},
|
|
removeCard: async (cardId) => {
|
|
const { server, token } = access.current || {};
|
|
return await removeCard(server, token, cardId);
|
|
},
|
|
setCardConnecting: async (cardId) => {
|
|
const { server, token } = access.current || {};
|
|
return await setCardConnecting(server, token, cardId);
|
|
},
|
|
setCardConnected: async (cardId, cardToken, revision) => {
|
|
const { server, token } = access.current || {};
|
|
return await setCardConnected(server, token, cardId, cardToken,
|
|
revision.viewRevision, revision.articleRevision,
|
|
revision.channelRevision, revision.profileRevision);
|
|
},
|
|
setCardConfirmed: async (cardId) => {
|
|
const { server, token } = access.current || {};
|
|
return await setCardConfirmed(server, token, cardId);
|
|
},
|
|
getCardOpenMessage: async (cardId) => {
|
|
const { server, token } = access.current || {};
|
|
return await getCardOpenMessage(server, token, cardId);
|
|
},
|
|
setCardOpenMessage: async (server, message) => {
|
|
return await setCardOpenMessage(server, message);
|
|
},
|
|
getCardCloseMessage: async (cardId) => {
|
|
const { server, token } = access.current || {};
|
|
return await getCardCloseMessage(server, token, cardId);
|
|
},
|
|
setCardCloseMessage: async (server, message) => {
|
|
return await setCardCloseMessage(server, message);
|
|
},
|
|
getCardImageUrl: (cardId) => {
|
|
const { profileRevision } = cards.current.get(cardId)?.card || {};
|
|
const { server, token } = access.current || {};
|
|
return getCardImageUrl(server, token, cardId, profileRevision);
|
|
},
|
|
removeChannel: async (cardId, channelId) => {
|
|
const { detail, profile } = cards.current.get(cardId)?.card || {};
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
return await removeContactChannel(profile?.node, cardToken, channelId);
|
|
},
|
|
addTopic: async (cardId, channelId, type, message, files) => {
|
|
const { detail, profile } = cards.current.get(cardId)?.card || {};
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current?.server;
|
|
if (files?.length > 0) {
|
|
const topicId = await addContactChannelTopic(node, cardToken, channelId, null, null, null);
|
|
upload.actions.addTopic(node, cardToken, channelId, topicId, files, async (assets) => {
|
|
const subject = message(assets);
|
|
await setContactChannelTopicSubject(node, cardToken, channelId, topicId, type, subject);
|
|
}, async () => {
|
|
try {
|
|
await removeContactChannelTopic(node, cardToken, channelId, topicId);
|
|
}
|
|
catch (err) {
|
|
console.log(err);
|
|
}
|
|
}, cardId);
|
|
}
|
|
else {
|
|
const subject = message([]);
|
|
await addContactChannelTopic(node, cardToken, channelId, type, subject, []);
|
|
}
|
|
},
|
|
removeTopic: async (cardId, channelId, topicId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await removeContactChannelTopic(node, cardToken, channelId, topicId);
|
|
},
|
|
setTopicSubject: async (cardId, channelId, topicId, type, subject) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await setContactChannelTopicSubject(node, cardToken, channelId, topicId, type, subject);
|
|
},
|
|
getTopicAssetUrl: (cardId, channelId, topicId, assetId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return getContactChannelTopicAssetUrl(node, cardToken, channelId, topicId, assetId);
|
|
},
|
|
getTopics: async (cardId, channelId, revision, count, begin, end) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await getContactChannelTopics(node, cardToken, channelId, revision, count, begin, end);
|
|
},
|
|
getTopic: async (cardId, channelId, topicId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const cardToken = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await getContactChannelTopic(node, cardToken, channelId, topicId);
|
|
},
|
|
setContactRevision: async (cardId, revision) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardRequestStatus(guid, { revision });
|
|
updateState({ viewRevision: revision });
|
|
},
|
|
setChannelReadRevision: async (cardId, channelId, revision) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemReadRevision(guid, cardId, channelId, revision);
|
|
setCardChannelField(cardId, channelId, 'readRevision', revision);
|
|
},
|
|
setChannelSyncRevision: async (cardId, channelId, revision) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemSyncRevision(guid, cardId, channelId, revision);
|
|
setCardChannelField(cardId, channelId, 'syncRevision', revision);
|
|
},
|
|
setChannelTopicMarker: async (cardId, channelId, marker) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemTopicMarker(guid, cardId, channelId, marker);
|
|
setCardChannelField(cardId, channelId, 'topicMarker', marker);
|
|
},
|
|
setChannelMarkerAndSync: async (cardId, channelId, marker, revision) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemMarkerAndSync(guid, cardId, channelId, marker, revision);
|
|
setCardChannelField(cardId, channelId, 'topicMarker', marker, 'syncRevision', revision);
|
|
},
|
|
setCardFlag: async (cardId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardItemBlocked(guid, cardId);
|
|
setCardField(cardId, 'blocked', true);
|
|
},
|
|
clearCardFlag: async (cardId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.clearCardItemBlocked(guid, cardId);
|
|
setCardField(cardId, 'blocked', false);
|
|
},
|
|
setChannelFlag: async (cardId, channelId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemBlocked(guid, cardId, channelId);
|
|
setCardChannelField(cardId, channelId, 'blocked', true);
|
|
},
|
|
clearChannelFlag: async (cardId, channelId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.clearCardChannelItemBlocked(guid, cardId, channelId);
|
|
setCardChannelField(cardId, channelId, 'blocked', false);
|
|
},
|
|
setTopicFlag: async (cardId, channelId, topicId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelTopicBlocked(guid, cardId, channelId, topicId, true);
|
|
},
|
|
clearTopicFlag: async (cardId, channelId, topicId) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelTopicBlocked(guid, cardId, channelId, topicId, false);
|
|
},
|
|
getFlaggedTopics: async () => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.getCardChannelTopicBlocked(guid);
|
|
},
|
|
addChannelAlert: async (cardId, channelId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await addFlag(node, profile?.guid, channelId);
|
|
},
|
|
addTopicAlert: async (cardId, channelId, topicId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await addFlag(node, profile?.guid, channelId, topicId);
|
|
},
|
|
getChannelNotifications: async (cardId, channelId) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const token = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await getContactChannelNotifications(node, token, channelId);
|
|
},
|
|
setChannelNotifications: async (cardId, channelId, notify) => {
|
|
const { detail, profile } = (cards.current.get(cardId) || {}).card;
|
|
const token = `${profile?.guid}.${detail?.token}`;
|
|
const node = profile?.node ? profile.node : access.current.server;
|
|
return await setContactChannelNotifications(node, token, channelId, notify);
|
|
},
|
|
getTopicItems: async (cardId, channelId) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.getCardChannelTopicItems(guid, cardId, channelId);
|
|
},
|
|
getTopicItemsId: async (cardId, channelId) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.getCardChannelTopicItemsId(guid, cardId, channelId);
|
|
},
|
|
getTopicItemsById: async (cardId, channelId, topics) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.getCardChannelTopicItemsById(guid, cardId, channelId, topics);
|
|
},
|
|
setTopicItem: async (cardId, channelId, topicId, topic) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.setCardChannelTopicItem(guid, cardId, channelId, topicId, topic);
|
|
},
|
|
clearTopicItem: async (cardId, channelId, topicId) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.clearCardChannelTopicItem(guid, cardId, channelId, topicId);
|
|
},
|
|
clearTopicItems: async (cardId, channelId) => {
|
|
const { guid } = access.current || {};
|
|
return await store.actions.clearCardChannelTopicItems(guid, cardId, channelId);
|
|
},
|
|
setUnsealedChannelSubject: async (cardId, channelId, revision, unsealed) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemUnsealedDetail(guid, cardId, channelId, revision, unsealed);
|
|
setCardChannelField(cardId, channelId, 'unsealedDetail', unsealed);
|
|
},
|
|
setUnsealedChannelSummary: async (cardId, channelId, revision, unsealed) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelItemUnsealedSummary(guid, cardId, channelId, revision, unsealed);
|
|
setCardChannelField(cardId, channelId, 'unsealedSummary', unsealed);
|
|
},
|
|
setUnsealedTopicSubject: async (cardId, channelId, topicId, revision, unsealed) => {
|
|
const { guid } = access.current || {};
|
|
await store.actions.setCardChannelTopicItemUnsealedDetail(guid, cardId, channelId, topicId, revision, unsealed);
|
|
},
|
|
resync: async () => {
|
|
await sync();
|
|
},
|
|
resyncCard: async (cardId) => {
|
|
await resyncCard(cardId);
|
|
},
|
|
}
|
|
|
|
return { state, actions }
|
|
}
|
|
|