2020-05-19 02:21:01 -04:00
|
|
|
import React, { useEffect, useState, useContext } from "react";
|
|
|
|
|
|
|
|
import AuthContext from "./AuthContext";
|
|
|
|
import DatabaseContext from "./DatabaseContext";
|
|
|
|
|
|
|
|
import { tokens as defaultTokens } from "../tokens";
|
|
|
|
|
|
|
|
const TokenDataContext = React.createContext();
|
|
|
|
|
2020-09-11 02:56:40 -04:00
|
|
|
const cachedTokenMax = 100;
|
|
|
|
|
2020-05-19 02:21:01 -04:00
|
|
|
export function TokenDataProvider({ children }) {
|
|
|
|
const { database } = useContext(DatabaseContext);
|
|
|
|
const { userId } = useContext(AuthContext);
|
|
|
|
|
|
|
|
const [tokens, setTokens] = useState([]);
|
|
|
|
|
|
|
|
useEffect(() => {
|
2020-05-19 05:03:36 -04:00
|
|
|
if (!userId || !database) {
|
2020-05-19 02:21:01 -04:00
|
|
|
return;
|
|
|
|
}
|
2020-05-19 05:03:36 -04:00
|
|
|
function getDefaultTokes() {
|
|
|
|
const defaultTokensWithIds = [];
|
|
|
|
for (let defaultToken of defaultTokens) {
|
|
|
|
defaultTokensWithIds.push({
|
|
|
|
...defaultToken,
|
2020-05-24 01:18:30 -04:00
|
|
|
id: `__default-${defaultToken.name}`,
|
2020-05-19 05:03:36 -04:00
|
|
|
owner: userId,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return defaultTokensWithIds;
|
2020-05-19 02:21:01 -04:00
|
|
|
}
|
|
|
|
|
2020-05-19 05:03:36 -04:00
|
|
|
async function loadTokens() {
|
2020-06-06 21:19:32 -04:00
|
|
|
let storedTokens = [];
|
|
|
|
// Use a cursor instead of toArray to prevent IPC max size error
|
2020-06-06 21:40:14 -04:00
|
|
|
await database.table("tokens").each((token) => storedTokens.push(token));
|
2020-05-19 05:03:36 -04:00
|
|
|
const sortedTokens = storedTokens.sort((a, b) => b.created - a.created);
|
|
|
|
const defaultTokensWithIds = getDefaultTokes();
|
|
|
|
const allTokens = [...sortedTokens, ...defaultTokensWithIds];
|
|
|
|
setTokens(allTokens);
|
|
|
|
}
|
|
|
|
|
|
|
|
loadTokens();
|
|
|
|
}, [userId, database]);
|
|
|
|
|
|
|
|
async function addToken(token) {
|
|
|
|
await database.table("tokens").add(token);
|
|
|
|
setTokens((prevTokens) => [token, ...prevTokens]);
|
2020-09-11 02:56:40 -04:00
|
|
|
if (token.owner !== userId) {
|
|
|
|
await updateCache();
|
|
|
|
}
|
2020-05-19 05:03:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
async function removeToken(id) {
|
|
|
|
await database.table("tokens").delete(id);
|
|
|
|
setTokens((prevTokens) => {
|
|
|
|
const filtered = prevTokens.filter((token) => token.id !== id);
|
|
|
|
return filtered;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
async function updateToken(id, update) {
|
|
|
|
const change = { ...update, lastModified: Date.now() };
|
|
|
|
await database.table("tokens").update(id, change);
|
|
|
|
setTokens((prevTokens) => {
|
|
|
|
const newTokens = [...prevTokens];
|
|
|
|
const i = newTokens.findIndex((token) => token.id === id);
|
|
|
|
if (i > -1) {
|
|
|
|
newTokens[i] = { ...newTokens[i], ...change };
|
|
|
|
}
|
|
|
|
return newTokens;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
async function putToken(token) {
|
2020-05-19 08:15:08 -04:00
|
|
|
await database.table("tokens").put(token);
|
|
|
|
setTokens((prevTokens) => {
|
|
|
|
const newTokens = [...prevTokens];
|
|
|
|
const i = newTokens.findIndex((t) => t.id === token.id);
|
|
|
|
if (i > -1) {
|
|
|
|
newTokens[i] = { ...newTokens[i], ...token };
|
|
|
|
} else {
|
|
|
|
newTokens.unshift(token);
|
|
|
|
}
|
|
|
|
return newTokens;
|
|
|
|
});
|
2020-09-11 02:56:40 -04:00
|
|
|
if (token.owner !== userId) {
|
|
|
|
await updateCache();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Keep up to cachedTokenMax amount of tokens that you don't own
|
|
|
|
* Sorted by when they we're last used
|
|
|
|
*/
|
|
|
|
async function updateCache() {
|
|
|
|
const cachedTokens = await database
|
|
|
|
.table("tokens")
|
|
|
|
.where("owner")
|
|
|
|
.notEqual(userId)
|
|
|
|
.sortBy("lastUsed");
|
|
|
|
if (cachedTokens.length > cachedTokenMax) {
|
|
|
|
const cacheDeleteCount = cachedTokens.length - cachedTokenMax;
|
|
|
|
const idsToDelete = cachedTokens
|
|
|
|
.slice(0, cacheDeleteCount)
|
|
|
|
.map((token) => token.id);
|
|
|
|
database.table("tokens").where("id").anyOf(idsToDelete).delete();
|
|
|
|
setTokens((prevTokens) => {
|
|
|
|
return prevTokens.filter((token) => !idsToDelete.includes(token.id));
|
|
|
|
});
|
|
|
|
}
|
2020-05-19 08:15:08 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
function getToken(tokenId) {
|
|
|
|
return tokens.find((token) => token.id === tokenId);
|
2020-05-19 05:03:36 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
const ownedTokens = tokens.filter((token) => token.owner === userId);
|
|
|
|
|
2020-05-22 06:43:07 -04:00
|
|
|
const tokensById = tokens.reduce((obj, token) => {
|
|
|
|
obj[token.id] = token;
|
|
|
|
return obj;
|
|
|
|
}, {});
|
|
|
|
|
2020-05-19 05:03:36 -04:00
|
|
|
const value = {
|
|
|
|
tokens,
|
|
|
|
ownedTokens,
|
|
|
|
addToken,
|
|
|
|
removeToken,
|
|
|
|
updateToken,
|
|
|
|
putToken,
|
2020-05-19 08:15:08 -04:00
|
|
|
getToken,
|
2020-05-22 06:43:07 -04:00
|
|
|
tokensById,
|
2020-05-19 05:03:36 -04:00
|
|
|
};
|
2020-05-19 02:21:01 -04:00
|
|
|
|
|
|
|
return (
|
|
|
|
<TokenDataContext.Provider value={value}>
|
|
|
|
{children}
|
|
|
|
</TokenDataContext.Provider>
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
export default TokenDataContext;
|