1488 lines
58 KiB
JavaScript
1488 lines
58 KiB
JavaScript
|
|
const isEncryptedTestMode = false
|
|
const encryptedCardIdentifierPrefix = "card-MAC"
|
|
let isUpdateCard = false
|
|
let existingDecryptedCardData = {}
|
|
let existingEncryptedCardIdentifier = {}
|
|
let cardMinterName = {}
|
|
let existingCardMinterNames = []
|
|
let isTopic = false
|
|
let attemptLoadAdminDataCount = 0
|
|
let adminMemberCount = 0
|
|
let adminPublicKeys = []
|
|
// let kickTransactions = []
|
|
// let banTransactions = []
|
|
let adminBoardState = {
|
|
kickedCards: new Set(), // store identifiers
|
|
bannedCards: new Set(), // likewise
|
|
hiddenList: new Set(), // user-hidden
|
|
// ... we can add other things to state if needed...
|
|
}
|
|
|
|
const loadAdminBoardState = () => {
|
|
// Load from localStorage if available
|
|
const rawState = localStorage.getItem('adminBoardState')
|
|
if (rawState) {
|
|
try {
|
|
const parsed = JSON.parse(rawState);
|
|
// Make sure bannedCards and kickedCards are sets
|
|
return {
|
|
bannedCards: new Set(parsed.bannedCards ?? []),
|
|
kickedCards: new Set(parsed.kickedCards ?? []),
|
|
hiddenList: new Set(parsed.hiddenList ?? []),
|
|
// ... any other fields
|
|
};
|
|
} catch (e) {
|
|
console.warn("Failed to parse adminBoardState from storage:", e)
|
|
}
|
|
}
|
|
// If nothing found or parse error, return a default
|
|
return {
|
|
bannedCards: new Set(),
|
|
kickedCards: new Set(),
|
|
hiddenList: new Set(),
|
|
}
|
|
}
|
|
|
|
// Saving the state back into localStorage as needed:
|
|
const saveAdminBoardState = () => {
|
|
const stateToSave = {
|
|
bannedCards: Array.from(adminBoardState.bannedCards),
|
|
kickedCards: Array.from(adminBoardState.kickedCards),
|
|
hiddenList: Array.from(adminBoardState.hiddenList),
|
|
}
|
|
localStorage.setItem('adminBoardState', JSON.stringify(stateToSave))
|
|
}
|
|
|
|
console.log("Attempting to load AdminBoard.js")
|
|
|
|
const loadAdminBoardPage = async () => {
|
|
// Clear existing content on the page
|
|
const bodyChildren = document.body.children
|
|
|
|
for (let i = bodyChildren.length - 1; i >= 0; i--) {
|
|
const child = bodyChildren[i];
|
|
if (!child.classList.contains("menu")) {
|
|
child.remove()
|
|
}
|
|
}
|
|
|
|
// Add the "Minter Board" content
|
|
const mainContent = document.createElement("div")
|
|
mainContent.innerHTML = `
|
|
<div class="minter-board-main" style="padding: 20px; text-align: center;">
|
|
<h1 style="color: lightblue;">AdminBoard</h1>
|
|
<p style="font-size: 1.25em;"> The Admin Board is an encrypted card publishing board to keep track of minter data for the Minter Admins. Any Admin may publish a card, and related data, make comments on existing cards, and vote on existing card data in support or not of the name on the card. It is essentially a 'project management' tool to assist the Minter Admins in keeping track of the data related to minters they are adding/removing from the minter group. </p>
|
|
<p> More functionality will be added over time. One of the first features will be the ability to output the existing card data 'decisions', to a json formatted list in order to allow crowetic to run his script easily until the final Mintership proposal changes are completed, and the MINTER group is transferred to 'null'.</p>
|
|
<button id="publish-card-button" class="publish-card-button" style="margin: 20px; padding: 10px;">Publish Encrypted Card</button>
|
|
<button id="refresh-cards-button" class="refresh-cards-button" style="padding: 10px;">Refresh Cards</button>
|
|
<select id="sort-select" style="margin-left: 10px; padding: 5px; font-size: 1.25rem; color:rgb(70, 106, 105); background-color: black;">
|
|
<option value="newest" selected>Sort by Date</option>
|
|
<option value="name">Sort by Name</option>
|
|
<option value="recent-comments">Newest Comments</option>
|
|
<option value="least-votes">Least Votes</option>
|
|
<option value="most-votes">Most Votes</option>
|
|
</select>
|
|
<select id="time-range-select" style="margin-left: 10px; padding: 5px; font-size: 1.25rem; color: white; background-color: black;">
|
|
<option value="0">Show All</option>
|
|
<option value="1">Last 1 day</option>
|
|
<option value="7">Last 7 days</option>
|
|
<option value="30" selected>Last 30 days</option>
|
|
<option value="90">Last 90 days</option>
|
|
</select>
|
|
<div class="show-card-checkbox" style="margin-top: 1em;">
|
|
<input type="checkbox" id="admin-show-hidden-checkbox" name="adminHidden" />
|
|
<label for="admin-show-hidden-checkbox">Show User-Hidden Cards?</label>
|
|
<input type="checkbox" id="admin-show-kicked-banned-checkbox" name="kickedBanned" />
|
|
<label for="admin-show-kicked-banned-checkbox">Show Kicked / Banned Cards?</label>
|
|
</div>
|
|
<div id="encrypted-cards-container" class="cards-container" style="margin-top: 20px;"></div>
|
|
<div id="publish-card-view" class="publish-card-view" style="display: none; text-align: left; padding: 20px;">
|
|
<form id="publish-card-form" class="publish-card-form">
|
|
<h3>Create or Update an Admin Card</h3>
|
|
<div class="publish-card-checkbox" style="margin-top: 1em;">
|
|
<input type="checkbox" id="topic-checkbox" name="topicMode" />
|
|
<label for="topic-checkbox">Is this a Topic instead of a Minter?</label>
|
|
</div>
|
|
<label for="minter-name-input">Input TOPIC or NAME:</label>
|
|
<input type="text" id="minter-name-input" maxlength="100" placeholder="input NAME or TOPIC" required>
|
|
<label for="card-header">Header:</label>
|
|
<input type="text" id="card-header" maxlength="100" placeholder="Explain main point/issue" required>
|
|
<label for="card-content">Content:</label>
|
|
<textarea id="card-content" placeholder="Enter any information you like... CHECK THE TOPIC CHECKBOX if you do not want to publish a NAME card. NAME cards are verified and can only be one per name. Links are displayed in in-app pop-up." required></textarea>
|
|
<label for="card-links">Links (qortal://...):</label>
|
|
<div id="links-container">
|
|
<input type="text" class="card-link" placeholder="Enter QDN link">
|
|
</div>
|
|
<button type="button" id="add-link-button">Add Another Link</button>
|
|
<button type="submit" id="submit-publish-button">Publish Card</button>
|
|
<button type="button" id="cancel-publish-button">Cancel</button>
|
|
</form>
|
|
</div>
|
|
</div>
|
|
`
|
|
|
|
document.body.appendChild(mainContent)
|
|
const publishCardButton = document.getElementById("publish-card-button")
|
|
|
|
if (publishCardButton) {
|
|
publishCardButton.addEventListener("click", async () => {
|
|
const publishCardView = document.getElementById("publish-card-view")
|
|
publishCardView.style.display = "flex"
|
|
document.getElementById("encrypted-cards-container").style.display = "none"
|
|
})
|
|
}
|
|
const refreshCardsButton = document.getElementById("refresh-cards-button")
|
|
|
|
if (refreshCardsButton) {
|
|
refreshCardsButton.addEventListener("click", async () => {
|
|
const encryptedCardsContainer = document.getElementById("encrypted-cards-container")
|
|
encryptedCardsContainer.innerHTML = "<p>Refreshing cards...</p>"
|
|
await fetchAllEncryptedCards(true)
|
|
})
|
|
}
|
|
const cancelPublishButton = document.getElementById("cancel-publish-button")
|
|
|
|
if (cancelPublishButton) {
|
|
cancelPublishButton.addEventListener("click", async () => {
|
|
const encryptedCardsContainer = document.getElementById("encrypted-cards-container")
|
|
encryptedCardsContainer.style.display = "flex"; // Restore visibility
|
|
const publishCardView = document.getElementById("publish-card-view")
|
|
publishCardView.style.display = "none"; // Hide the publish form
|
|
})
|
|
}
|
|
const addLinkButton = document.getElementById("add-link-button")
|
|
|
|
if (addLinkButton) {
|
|
addLinkButton.addEventListener("click", async () => {
|
|
const linksContainer = document.getElementById("links-container")
|
|
const newLinkInput = document.createElement("input")
|
|
newLinkInput.type = "text"
|
|
newLinkInput.className = "card-link"
|
|
newLinkInput.placeholder = "Enter QDN link"
|
|
linksContainer.appendChild(newLinkInput)
|
|
})
|
|
}
|
|
|
|
const showKickedBannedCheckbox = document.getElementById('admin-show-kicked-banned-checkbox')
|
|
|
|
if (showKickedBannedCheckbox) {
|
|
showKickedBannedCheckbox.addEventListener('change', async (event) => {
|
|
await fetchAllEncryptedCards(true);
|
|
})
|
|
}
|
|
|
|
const showHiddenCardsCheckbox = document.getElementById('admin-show-hidden-checkbox')
|
|
if (showHiddenCardsCheckbox) {
|
|
showHiddenCardsCheckbox.addEventListener('change', async (event) => {
|
|
await fetchAllEncryptedCards(true)
|
|
})
|
|
}
|
|
|
|
|
|
document.getElementById("publish-card-form").addEventListener("submit", async (event) => {
|
|
event.preventDefault()
|
|
const isTopicChecked = document.getElementById("topic-checkbox").checked
|
|
// Pass that boolean to publishEncryptedCard
|
|
await publishEncryptedCard(isTopicChecked)
|
|
})
|
|
|
|
document.getElementById("sort-select").addEventListener("change", async () => {
|
|
// Re-load the cards whenever user chooses a new sort option.
|
|
await fetchAllEncryptedCards()
|
|
})
|
|
|
|
createScrollToTopButton()
|
|
// await fetchAndValidateAllAdminCards()
|
|
await updateOrSaveAdminGroupsDataLocally()
|
|
await fetchAllEncryptedCards()
|
|
}
|
|
|
|
// const fetchAllKicKBanTxData = async () => {
|
|
// const kickTxType = "GROUP_KICK"
|
|
// const banTxType = "GROUP_BAN"
|
|
|
|
// // Helper function to filter transactions
|
|
// const filterTransactions = (rawTransactions) => {
|
|
// // Group transactions by member
|
|
// const memberTxMap = rawTransactions.reduce((map, tx) => {
|
|
// if (!map[tx.member]) {
|
|
// map[tx.member] = []
|
|
// }
|
|
// map[tx.member].push(tx)
|
|
// return map
|
|
// }, {})
|
|
|
|
// // Filter out members with both pending and non-pending transactions
|
|
// return Object.values(memberTxMap)
|
|
// .filter(txs => txs.every(tx => tx.approvalStatus !== 'PENDING'))
|
|
// .flat()
|
|
// // .filter((txs) => !(txs.some(tx => tx.approvalStatus === 'PENDING') &&
|
|
// // txs.some(tx => tx.approvalStatus !== 'PENDING')))
|
|
// // .flat()
|
|
// }
|
|
|
|
// // Fetch ban transactions
|
|
// const rawBanTransactions = await searchTransactions({
|
|
// txTypes: [banTxType],
|
|
// address: '',
|
|
// confirmationStatus: 'CONFIRMED',
|
|
// limit: 0,
|
|
// reverse: true,
|
|
// offset: 0,
|
|
// startBlock: 1990000,
|
|
// blockLimit: 0,
|
|
// txGroupId: 0,
|
|
// })
|
|
|
|
// // Filter transactions for bans
|
|
// banTransactions = filterTransactions(rawBanTransactions)
|
|
// console.warn('banTxData (filtered):', banTransactions)
|
|
|
|
// // Fetch kick transactions
|
|
// const rawKickTransactions = await searchTransactions({
|
|
// txTypes: [kickTxType],
|
|
// address: '',
|
|
// confirmationStatus: 'CONFIRMED',
|
|
// limit: 0,
|
|
// reverse: true,
|
|
// offset: 0,
|
|
// startBlock: 1990000,
|
|
// blockLimit: 0,
|
|
// txGroupId: 0,
|
|
// })
|
|
|
|
// // Filter transactions for kicks
|
|
// kickTransactions = filterTransactions(rawKickTransactions)
|
|
// console.warn('kickTxData (filtered):', kickTransactions)
|
|
// }
|
|
|
|
|
|
// Example: fetch and save admin public keys and count
|
|
const updateOrSaveAdminGroupsDataLocally = async () => {
|
|
try {
|
|
// Fetch the array of admin public keys
|
|
const verifiedAdminPublicKeys = await fetchAdminGroupsMembersPublicKeys()
|
|
|
|
// Build an object containing the count and the array
|
|
const adminData = {
|
|
keysCount: verifiedAdminPublicKeys.length,
|
|
publicKeys: verifiedAdminPublicKeys
|
|
}
|
|
|
|
adminPublicKeys = verifiedAdminPublicKeys
|
|
|
|
// Stringify and save to localStorage
|
|
localStorage.setItem('savedAdminData', JSON.stringify(adminData))
|
|
|
|
console.log('Admin public keys saved locally:', adminData)
|
|
} catch (error) {
|
|
console.error('Error fetching/storing admin public keys:', error)
|
|
attemptLoadAdminDataCount++
|
|
}
|
|
}
|
|
|
|
const loadOrFetchAdminGroupsData = async () => {
|
|
try {
|
|
// Pull the JSON from localStorage
|
|
const storedData = localStorage.getItem('savedAdminData')
|
|
|
|
if (!storedData && attemptLoadAdminDataCount <= 3) {
|
|
console.log('No saved admin public keys found in local storage. Fetching...')
|
|
await updateOrSaveAdminGroupsDataLocally()
|
|
attemptLoadAdminDataCount++
|
|
return null
|
|
}
|
|
// Parse the JSON, then store the global variables.
|
|
const parsedData = JSON.parse(storedData)
|
|
|
|
adminMemberCount = parsedData.keysCount
|
|
adminPublicKeys = parsedData.publicKeys
|
|
|
|
console.log(typeof adminPublicKeys); // Should be "object"
|
|
console.log(Array.isArray(adminPublicKeys))
|
|
|
|
console.log(`Loaded admins 'keysCount'=${adminMemberCount}, publicKeys=`, adminPublicKeys)
|
|
attemptLoadAdminDataCount = 0
|
|
|
|
return parsedData // and return { adminMemberCount, adminKeys } to the caller
|
|
} catch (error) {
|
|
console.error('Error loading/parsing saved admin public keys:', error)
|
|
return null
|
|
}
|
|
}
|
|
|
|
const extractEncryptedCardsMinterName = (cardIdentifier) => {
|
|
const parts = cardIdentifier.split('-')
|
|
// Ensure the format has at least 3 parts
|
|
if (parts.length < 3) {
|
|
throw new Error('Invalid identifier format')
|
|
}
|
|
|
|
if (parts.slice(2, -1).join('-') === 'TOPIC') {
|
|
console.log(`TOPIC found in identifier: ${cardIdentifier} - not including in duplicatesList`)
|
|
return
|
|
}
|
|
// Extract minterName (everything from the second part to the second-to-last part)
|
|
const minterName = parts.slice(2, -1).join('-')
|
|
// Return the extracted minterName
|
|
return minterName
|
|
}
|
|
|
|
const fetchAllEncryptedCards = async (isRefresh = false) => {
|
|
const encryptedCardsContainer = document.getElementById("encrypted-cards-container")
|
|
encryptedCardsContainer.innerHTML = "<p>Loading cards...</p>"
|
|
|
|
let afterTime = null
|
|
const timeRangeSelect = document.getElementById("time-range-select")
|
|
if (timeRangeSelect) {
|
|
const days = parseInt(timeRangeSelect.value, 10)
|
|
if (days > 0) {
|
|
const now = Date.now()
|
|
const dayMs = 24 * 60 * 60 * 1000
|
|
afterTime = now - days * dayMs // e.g. last X days
|
|
console.log(`afterTime for last ${days} days = ${new Date(afterTime).toLocaleString()}`)
|
|
}
|
|
}
|
|
|
|
try {
|
|
const response = await searchSimple('MAIL_PRIVATE', `${encryptedCardIdentifierPrefix}`, '', 0, 0, '', false, true, afterTime)
|
|
|
|
if (!response || !Array.isArray(response) || response.length === 0) {
|
|
encryptedCardsContainer.innerHTML = "<p>No cards found.</p>"
|
|
return
|
|
}
|
|
|
|
// Validate and decrypt cards asynchronously
|
|
const validatedCards = await Promise.all(
|
|
response.map(async (card) => {
|
|
try {
|
|
// Validate the card identifier
|
|
const isValid = await validateEncryptedCardIdentifier(card)
|
|
if (!isValid) return null
|
|
|
|
// Fetch and decrypt the card data
|
|
const cardDataResponse = await qortalRequest({
|
|
action: "FETCH_QDN_RESOURCE",
|
|
name: card.name,
|
|
service: "MAIL_PRIVATE",
|
|
identifier: card.identifier,
|
|
encoding: "base64",
|
|
})
|
|
|
|
if (!cardDataResponse) return null
|
|
|
|
const decryptedCardData = await decryptAndParseObject(cardDataResponse)
|
|
|
|
// Skip cards without polls
|
|
if (!decryptedCardData.poll) return null
|
|
|
|
return { card, decryptedCardData }
|
|
} catch (error) {
|
|
console.warn(`Error processing card ${card.identifier}:`, error)
|
|
return null
|
|
}
|
|
})
|
|
)
|
|
|
|
// Filter out invalid or skipped cards
|
|
const validCardsWithData = validatedCards.filter((entry) => entry !== null)
|
|
|
|
if (validCardsWithData.length === 0) {
|
|
encryptedCardsContainer.innerHTML = "<p>No valid cards found.</p>"
|
|
return
|
|
}
|
|
|
|
// Combine `processCards` logic: Deduplicate cards by identifier and keep latest timestamp
|
|
const latestCardsMap = new Map()
|
|
|
|
validCardsWithData.forEach(({ card, decryptedCardData }) => {
|
|
const timestamp = card.created || 0
|
|
const existingCard = latestCardsMap.get(card.identifier)
|
|
|
|
if (!existingCard || timestamp < (existingCard.card.updated || existingCard.card.created || 0)) {
|
|
latestCardsMap.set(card.identifier, { card, decryptedCardData })
|
|
}
|
|
|
|
})
|
|
|
|
const uniqueValidCards = Array.from(latestCardsMap.values())
|
|
|
|
// Map to track the most recent card per minterName
|
|
const mostRecentCardsMap = new Map()
|
|
|
|
uniqueValidCards.forEach(({ card, decryptedCardData }) => {
|
|
const obtainedMinterName = decryptedCardData.minterName
|
|
// Only check for cards that are NOT topic-based cards
|
|
if ((!decryptedCardData.isTopic) || decryptedCardData.isTopic === 'false') {
|
|
|
|
if (obtainedMinterName) {
|
|
const existingEntry = mostRecentCardsMap.get(obtainedMinterName)
|
|
|
|
if (!existingEntry) {
|
|
mostRecentCardsMap.set(obtainedMinterName, { card, decryptedCardData })
|
|
}
|
|
}
|
|
} else {
|
|
console.log(`topic card detected, skipping most recent by name mapping...`)
|
|
// We still need to add the topic-based cards to the map, as it will be utilized in the next step
|
|
mostRecentCardsMap.set(obtainedMinterName, {card, decryptedCardData})
|
|
}
|
|
})
|
|
|
|
// Convert the map into an array of final cards
|
|
const finalCards = Array.from(mostRecentCardsMap.values())
|
|
|
|
let selectedSort = 'newest'
|
|
const sortSelect = document.getElementById('sort-select')
|
|
if (sortSelect) {
|
|
selectedSort = sortSelect.value
|
|
}
|
|
|
|
if (selectedSort === 'name') {
|
|
// Sort alphabetically by the minter's name
|
|
finalCards.sort((a, b) => {
|
|
const nameA = a.decryptedCardData.minterName?.toLowerCase() || ''
|
|
const nameB = b.decryptedCardData.minterName?.toLowerCase() || ''
|
|
return nameA.localeCompare(nameB)
|
|
})
|
|
} else if (selectedSort === 'recent-comments') {
|
|
// We need each card's newest comment timestamp for sorting
|
|
for (let card of finalCards) {
|
|
card.newestCommentTimestamp = await getNewestAdminCommentTimestamp(card.card.identifier)
|
|
}
|
|
// Then sort descending by newest comment
|
|
finalCards.sort((a, b) =>
|
|
(b.newestCommentTimestamp || 0) - (a.newestCommentTimestamp || 0)
|
|
)
|
|
} else if (selectedSort === 'least-votes') {
|
|
// TODO: Add the logic to sort by LEAST total ADMIN votes, then totalYesWeight
|
|
const minterGroupMembers = await fetchMinterGroupMembers()
|
|
const minterAdmins = await fetchMinterGroupAdmins()
|
|
for (const finalCard of finalCards) {
|
|
try {
|
|
const pollName = finalCard.decryptedCardData.poll
|
|
// If card or poll is missing, default to zero
|
|
if (!pollName) {
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
continue
|
|
}
|
|
const pollResults = await fetchPollResults(pollName)
|
|
if (!pollResults || pollResults.error) {
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
continue
|
|
}
|
|
// Pull only the adminYes/adminNo/totalYesWeight from processPollData
|
|
const {
|
|
adminYes,
|
|
adminNo,
|
|
totalYesWeight
|
|
} = await processPollData(
|
|
pollResults,
|
|
minterGroupMembers,
|
|
minterAdmins,
|
|
finalCard.decryptedCardData.creator,
|
|
finalCard.card.identifier
|
|
)
|
|
finalCard._adminTotalVotes = adminYes + adminNo
|
|
finalCard._yesWeight = totalYesWeight
|
|
} catch (error) {
|
|
console.warn(`Error fetching or processing poll for card ${finalCard.card.identifier}:`, error)
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
}
|
|
}
|
|
// Sort ascending by (adminYes + adminNo), then descending by totalYesWeight
|
|
finalCards.sort((a, b) => {
|
|
const diffAdminTotal = a._adminTotalVotes - b._adminTotalVotes
|
|
if (diffAdminTotal !== 0) return diffAdminTotal
|
|
// If there's a tie, show the card with higher yesWeight first
|
|
return b._yesWeight - a._yesWeight
|
|
})
|
|
} else if (selectedSort === 'most-votes') {
|
|
// TODO: Add the logic to sort by MOST total ADMIN votes, then totalYesWeight
|
|
const minterGroupMembers = await fetchMinterGroupMembers()
|
|
const minterAdmins = await fetchMinterGroupAdmins()
|
|
for (const finalCard of finalCards) {
|
|
try {
|
|
const pollName = finalCard.decryptedCardData.poll
|
|
if (!pollName) {
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
continue
|
|
}
|
|
const pollResults = await fetchPollResults(pollName)
|
|
if (!pollResults || pollResults.error) {
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
continue
|
|
}
|
|
const {
|
|
adminYes,
|
|
adminNo,
|
|
totalYesWeight
|
|
} = await processPollData(
|
|
pollResults,
|
|
minterGroupMembers,
|
|
minterAdmins,
|
|
finalCard.decryptedCardData.creator,
|
|
finalCard.card.identifier
|
|
)
|
|
finalCard._adminTotalVotes = adminYes + adminNo
|
|
finalCard._yesWeight = totalYesWeight
|
|
} catch (error) {
|
|
console.warn(`Error fetching or processing poll for card ${finalCard.card.identifier}:`, error)
|
|
finalCard._adminTotalVotes = 0
|
|
finalCard._yesWeight = 0
|
|
}
|
|
}
|
|
// Sort descending by (adminYes + adminNo), then descending by totalYesWeight
|
|
finalCards.sort((a, b) => {
|
|
const diffAdminTotal = b._adminTotalVotes - a._adminTotalVotes
|
|
if (diffAdminTotal !== 0) return diffAdminTotal
|
|
return b._yesWeight - a._yesWeight
|
|
})
|
|
} else {
|
|
// Sort cards by timestamp (most recent first)
|
|
finalCards.sort((a, b) => {
|
|
const timestampA = a.card.updated || a.card.created || 0
|
|
const timestampB = b.card.updated || b.card.created || 0
|
|
return timestampB - timestampA;
|
|
})
|
|
}
|
|
|
|
encryptedCardsContainer.innerHTML = ""
|
|
|
|
const finalVisualFilterCards = finalCards.filter(({card}) => {
|
|
const showKickedBanned = document.getElementById('admin-show-kicked-banned-checkbox')?.checked ?? false
|
|
const showHiddenAdminCards = document.getElementById('admin-show-hidden-checkbox')?.checked ?? false
|
|
|
|
if (!showKickedBanned){
|
|
if (adminBoardState.bannedCards.has(card.identifier)) {
|
|
return false // skip
|
|
}
|
|
|
|
if (adminBoardState.kickedCards.has(card.identifier)) {
|
|
return false // skip
|
|
}
|
|
}
|
|
|
|
if (!showHiddenAdminCards) {
|
|
if (adminBoardState.hiddenList.has(card.identifier)) {
|
|
return false // skip
|
|
}
|
|
}
|
|
|
|
return true
|
|
})
|
|
console.warn(`sharing current adminBoardState...`,adminBoardState)
|
|
// Display skeleton cards immediately
|
|
finalVisualFilterCards.forEach(({ card }) => {
|
|
const skeletonHTML = createSkeletonCardHTML(card.identifier)
|
|
encryptedCardsContainer.insertAdjacentHTML("beforeend", skeletonHTML)
|
|
})
|
|
|
|
// Fetch poll results and update each card
|
|
await Promise.all(
|
|
finalVisualFilterCards.map(async ({ card, decryptedCardData }) => {
|
|
try {
|
|
// Validate poll publisher keys
|
|
const encryptedCardPollPublisherPublicKey = await getPollPublisherPublicKey(decryptedCardData.poll)
|
|
const encryptedCardPublisherPublicKey = await getPublicKeyByName(card.name)
|
|
|
|
if (encryptedCardPollPublisherPublicKey !== encryptedCardPublisherPublicKey) {
|
|
console.warn(`QuickMythril cardPollHijack attack detected! Skipping card: ${card.identifier}`)
|
|
removeSkeleton(card.identifier)
|
|
return
|
|
}
|
|
|
|
// Fetch poll results
|
|
const pollResults = await fetchPollResults(decryptedCardData.poll)
|
|
|
|
if (pollResults?.error) {
|
|
console.warn(`Skipping card with failed poll results: ${card.identifier}`)
|
|
removeSkeleton(card.identifier);
|
|
return;
|
|
}
|
|
|
|
const encryptedCommentCount = await getEncryptedCommentCount(card.identifier)
|
|
|
|
// Generate final card HTML
|
|
const finalCardHTML = await createEncryptedCardHTML(
|
|
decryptedCardData,
|
|
pollResults,
|
|
card.identifier,
|
|
encryptedCommentCount
|
|
)
|
|
if ((!finalCardHTML) || (finalCardHTML === '')){
|
|
removeSkeleton(card.identifier)
|
|
}
|
|
replaceSkeleton(card.identifier, finalCardHTML)
|
|
} catch (error) {
|
|
console.error(`Error finalizing card ${card.identifier}:`, error)
|
|
removeSkeleton(card.identifier)
|
|
}
|
|
})
|
|
)
|
|
} catch (error) {
|
|
console.error("Error loading cards:", error)
|
|
encryptedCardsContainer.innerHTML = "<p>Failed to load cards.</p>"
|
|
}
|
|
}
|
|
|
|
// Function to create a skeleton card
|
|
const createEncryptedSkeletonCardHTML = (cardIdentifier) => {
|
|
return `
|
|
<div id="skeleton-${cardIdentifier}" class="skeleton-card" style="padding: 10px; border: 1px solid gray; margin: 10px 0;">
|
|
<div style="display: flex; align-items: center;">
|
|
<div style="width: 50px; height: 50px; background-color: #ccc; border-radius: 50%;"></div>
|
|
<div style="margin-left: 10px;">
|
|
<div style="width: 120px; height: 20px; background-color: #ccc; margin-bottom: 5px;"></div>
|
|
<div style="width: 80px; height: 15px; background-color: #ddd;"></div>
|
|
</div>
|
|
</div>
|
|
<div style="margin-top: 10px;">
|
|
<div style="width: 100%; height: 40px; background-color: #eee;"></div>
|
|
</div>
|
|
</div>
|
|
`
|
|
}
|
|
|
|
|
|
// Function to check and fech an existing Minter Card if attempting to publish twice ----------------------------------------
|
|
const fetchExistingEncryptedCard = async (minterName, existingIdentifier) => {
|
|
|
|
try{
|
|
const cardDataResponse = await qortalRequest({
|
|
action: "FETCH_QDN_RESOURCE",
|
|
name: minterName,
|
|
service: "MAIL_PRIVATE",
|
|
identifier: existingIdentifier,
|
|
encoding: "base64"
|
|
})
|
|
|
|
const decryptedCardData = await decryptAndParseObject(cardDataResponse)
|
|
console.log("Full card data fetched successfully:", decryptedCardData)
|
|
|
|
return decryptedCardData
|
|
|
|
} catch (error) {
|
|
console.error("Error fetching existing card:", error)
|
|
return null
|
|
}
|
|
}
|
|
|
|
// Validate that a card is indeed a card and not a comment. -------------------------------------
|
|
const validateEncryptedCardIdentifier = async (card) => {
|
|
return (
|
|
typeof card === "object" &&
|
|
card.name &&
|
|
card.service === "MAIL_PRIVATE" &&
|
|
card.identifier && !card.identifier.includes("comment") && !card.identifier.includes("card-MAC-NC-function now() { [native code] }-Y6CmuY") && // Added check for failed name card publish due to identifier issue.
|
|
card.created
|
|
)
|
|
}
|
|
|
|
// Load existing card data passed, into the form for editing -------------------------------------
|
|
const loadEncryptedCardIntoForm = async (decryptedCardData) => {
|
|
if (decryptedCardData) {
|
|
console.log("Loading existing card data:", decryptedCardData)
|
|
document.getElementById("minter-name-input").value = decryptedCardData.minterName
|
|
document.getElementById("card-header").value = decryptedCardData.header
|
|
document.getElementById("card-content").value = decryptedCardData.content
|
|
|
|
const linksContainer = document.getElementById("links-container")
|
|
linksContainer.innerHTML = ""; // Clear previous links
|
|
decryptedCardData.links.forEach(link => {
|
|
const linkInput = document.createElement("input")
|
|
linkInput.type = "text"
|
|
linkInput.className = "card-link"
|
|
linkInput.value = link
|
|
linksContainer.appendChild(linkInput)
|
|
})
|
|
}
|
|
}
|
|
|
|
const validateMinterName = async(minterName) => {
|
|
try {
|
|
const nameInfo = await getNameInfo(minterName)
|
|
const name = nameInfo.name
|
|
if (name) {
|
|
console.log(`name information found, returning:`, name)
|
|
return name
|
|
} else {
|
|
console.warn(`no name information found, this is not a registered name: '${minterName}', Returning null`, name)
|
|
return null
|
|
}
|
|
} catch (error){
|
|
console.error(`extracting name from name info: ${minterName} failed.`, error)
|
|
return null
|
|
}
|
|
}
|
|
|
|
const publishEncryptedCard = async (isTopicModePassed = false) => {
|
|
// If the user wants it to be a topic, we set global isTopic = true, else false
|
|
isTopic = isTopicModePassed || isTopic
|
|
|
|
const minterNameInput = document.getElementById("minter-name-input").value.trim()
|
|
const header = document.getElementById("card-header").value.trim()
|
|
const content = document.getElementById("card-content").value.trim()
|
|
const links = Array.from(document.querySelectorAll(".card-link"))
|
|
.map(input => input.value.trim())
|
|
.filter(link => link.startsWith("qortal://"))
|
|
|
|
// Basic validation
|
|
if (!header || !content) {
|
|
alert("Header and Content are required!")
|
|
return
|
|
}
|
|
|
|
let publishedMinterName = minterNameInput
|
|
|
|
// If not topic mode, validate the user actually entered a valid Minter name
|
|
if (!isTopic) {
|
|
let minterAddress
|
|
publishedMinterName = await validateMinterName(minterNameInput)
|
|
if (!publishedMinterName) {
|
|
try {
|
|
const addressInfo = await getAddressInfo(minterNameInput)
|
|
if (addressInfo) {
|
|
console.warn(`checked minterNameInput and found it to be an address... proceeding accordingly.`)
|
|
minterAddress = addressInfo.address
|
|
publishedMinterName = addressInfo.address
|
|
} else {
|
|
alert(`"${minterNameInput}" doesn't seem to be a valid name or address. Please check or use topic mode.`)
|
|
return
|
|
}
|
|
} catch (error) {
|
|
console.warn(`error checking for address...?`, error)
|
|
alert(`Failed to verify name/address. Please try again, or change to topicMode to publish anything else.`)
|
|
return
|
|
}
|
|
}
|
|
// Also check for existing card if not topic
|
|
if (!isUpdateCard && existingCardMinterNames.some(item => item.minterName === publishedMinterName)) {
|
|
const duplicateCardData = existingCardMinterNames.find(item => item.minterName === publishedMinterName)
|
|
const updateCard = confirm(
|
|
`Minter Name: ${publishedMinterName} already has a card. (NOTE this update functionality is no longer functional, it may or may not come back. Even if you update the card you won't see it. It is suggested to CANCEL and use topic mode.`
|
|
)
|
|
if (updateCard) {
|
|
existingEncryptedCardIdentifier = duplicateCardData.identifier
|
|
isUpdateCard = true
|
|
} else {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
if (!publishedMinterName && minterAddress){
|
|
console.log(`No name was found, but an address was, publishing address in cardData, and using address as name for card.`)
|
|
}
|
|
|
|
// Determine final card identifier
|
|
const currentTimestamp = Date.now()
|
|
const newCardIdentifier = isTopic
|
|
? `${encryptedCardIdentifierPrefix}-TOPIC-${await uid()}`
|
|
: `${encryptedCardIdentifierPrefix}-NC-${currentTimestamp}-${await uid()}`
|
|
|
|
const cardIdentifier = isUpdateCard ? existingEncryptedCardIdentifier : newCardIdentifier
|
|
|
|
// Build cardData
|
|
const pollName = `${cardIdentifier}-poll`
|
|
const cardData = {
|
|
minterName: publishedMinterName,
|
|
header,
|
|
content,
|
|
links,
|
|
creator: userState.accountName,
|
|
timestamp: Date.now(),
|
|
poll: pollName,
|
|
topicMode: isTopic
|
|
}
|
|
|
|
try {
|
|
// Convert to base64 or fallback
|
|
let base64CardData = await objectToBase64(cardData)
|
|
if (!base64CardData) {
|
|
base64CardData = btoa(JSON.stringify(cardData))
|
|
}
|
|
|
|
let verifiedAdminPublicKeys = adminPublicKeys
|
|
|
|
if ((!verifiedAdminPublicKeys) || verifiedAdminPublicKeys.length <= 5 || !Array.isArray(verifiedAdminPublicKeys)) {
|
|
console.log(`adminPublicKeys variable failed check, attempting to load from localStorage`,adminPublicKeys)
|
|
const savedAdminData = localStorage.getItem('savedAdminData')
|
|
const parsedAdminData = JSON.parse(savedAdminData)
|
|
const loadedAdminKeys = parsedAdminData.publicKeys
|
|
|
|
if ((!loadedAdminKeys) || (!Array.isArray(loadedAdminKeys)) || (loadedAdminKeys.length === 0)){
|
|
console.log('loaded admin keys from localStorage failed, falling back to API call...')
|
|
verifiedAdminPublicKeys = await fetchAdminGroupsMembersPublicKeys()
|
|
}
|
|
|
|
verifiedAdminPublicKeys = loadedAdminKeys
|
|
}
|
|
|
|
await qortalRequest({
|
|
action: "PUBLISH_QDN_RESOURCE",
|
|
name: userState.accountName,
|
|
service: "MAIL_PRIVATE",
|
|
identifier: cardIdentifier,
|
|
data64: base64CardData,
|
|
encrypt: true,
|
|
publicKeys: verifiedAdminPublicKeys
|
|
})
|
|
|
|
// Possibly create a poll if it's a brand new card
|
|
if (!isUpdateCard) {
|
|
await qortalRequest({
|
|
action: "CREATE_POLL",
|
|
pollName,
|
|
pollDescription: `Admin Board Poll Published By ${userState.accountName}`,
|
|
pollOptions: ["Yes, No"],
|
|
pollOwnerAddress: userState.accountAddress
|
|
})
|
|
alert("Card and poll published successfully!")
|
|
|
|
} else {
|
|
alert("Card updated successfully! (No poll updates possible currently...)");
|
|
}
|
|
|
|
document.getElementById("publish-card-form").reset()
|
|
document.getElementById("publish-card-view").style.display = "none"
|
|
document.getElementById("encrypted-cards-container").style.display = "flex"
|
|
isTopic = false; // reset global
|
|
} catch (error) {
|
|
console.error("Error publishing card or poll:", error)
|
|
alert("Failed to publish card and poll.")
|
|
}
|
|
}
|
|
|
|
|
|
const getEncryptedCommentCount = async (cardIdentifier) => {
|
|
try {
|
|
const response = await searchSimple('MAIL_PRIVATE', `comment-${cardIdentifier}`, '', 0)
|
|
|
|
return Array.isArray(response) ? response.length : 0
|
|
} catch (error) {
|
|
console.error(`Error fetching comment count for ${cardIdentifier}:`, error)
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Post a comment on a card. ---------------------------------
|
|
const postEncryptedComment = async (cardIdentifier) => {
|
|
const commentInput = document.getElementById(`new-comment-${cardIdentifier}`)
|
|
const commentText = commentInput.value.trim()
|
|
|
|
if (!commentText) {
|
|
alert('Comment cannot be empty!')
|
|
return
|
|
}
|
|
const postTimestamp = Date.now()
|
|
const commentData = {
|
|
content: commentText,
|
|
creator: userState.accountName,
|
|
timestamp: postTimestamp,
|
|
}
|
|
const commentIdentifier = `comment-${cardIdentifier}-${await uid()}`
|
|
|
|
if (!Array.isArray(adminPublicKeys) || (adminPublicKeys.length === 0) || (!adminPublicKeys)) {
|
|
console.log('adminPpublicKeys variable failed checks, calling for admin public keys from API (comment)',adminPublicKeys)
|
|
const verifiedAdminPublicKeys = await fetchAdminGroupsMembersPublicKeys()
|
|
adminPublicKeys = verifiedAdminPublicKeys
|
|
}
|
|
|
|
try {
|
|
const base64CommentData = await objectToBase64(commentData)
|
|
if (!base64CommentData) {
|
|
console.log(`initial base64 object creation with objectToBase64 failed, using btoa...`)
|
|
base64CommentData = btoa(JSON.stringify(commentData))
|
|
}
|
|
|
|
await qortalRequest({
|
|
action: "PUBLISH_QDN_RESOURCE",
|
|
name: userState.accountName,
|
|
service: "MAIL_PRIVATE",
|
|
identifier: commentIdentifier,
|
|
data64: base64CommentData,
|
|
encrypt: true,
|
|
publicKeys: adminPublicKeys
|
|
})
|
|
// alert('Comment posted successfully!')
|
|
commentInput.value = ''
|
|
|
|
} catch (error) {
|
|
console.error('Error posting comment:', error)
|
|
alert('Failed to post comment.')
|
|
}
|
|
}
|
|
|
|
//Fetch the comments for a card with passed card identifier ----------------------------
|
|
const fetchEncryptedComments = async (cardIdentifier) => {
|
|
try {
|
|
const response = await searchSimple('MAIL_PRIVATE', `comment-${cardIdentifier}`, '', 0, 0, '', false)
|
|
if (response) {
|
|
return response
|
|
}
|
|
} catch (error) {
|
|
console.error(`Error fetching comments for ${cardIdentifier}:`, error)
|
|
return []
|
|
}
|
|
}
|
|
|
|
const displayEncryptedComments = async (cardIdentifier) => {
|
|
try {
|
|
const comments = await fetchEncryptedComments(cardIdentifier)
|
|
const commentsContainer = document.getElementById(`comments-container-${cardIdentifier}`)
|
|
|
|
commentsContainer.innerHTML = ''
|
|
|
|
const voterMap = globalVoterMap.get(cardIdentifier) || new Map()
|
|
|
|
const commentHTMLArray = await Promise.all(
|
|
comments.map(async (comment) => {
|
|
try {
|
|
const commentDataResponse = await qortalRequest({
|
|
action: "FETCH_QDN_RESOURCE",
|
|
name: comment.name,
|
|
service: "MAIL_PRIVATE",
|
|
identifier: comment.identifier,
|
|
encoding: "base64",
|
|
})
|
|
|
|
const decryptedCommentData = await decryptAndParseObject(commentDataResponse)
|
|
const timestampCheck = comment.updated || comment.created || 0
|
|
const timestamp = await timestampToHumanReadableDate(timestampCheck)
|
|
|
|
const commenter = decryptedCommentData.creator
|
|
const voterInfo = voterMap.get(commenter)
|
|
|
|
let commentColor = "transparent"
|
|
let adminBadge = ""
|
|
|
|
if (voterInfo) {
|
|
if (voterInfo.voterType === "Admin") {
|
|
// Admin-specific colors
|
|
commentColor = voterInfo.vote === "yes" ? "rgba(25, 175, 25, 0.6)" : "rgba(194, 39, 62, 0.6)" // Light green for yes, light red for no
|
|
const badgeColor = voterInfo.vote === "yes" ? "green" : "red"
|
|
adminBadge = `<span style="color: ${badgeColor}; font-weight: bold; margin-left: 0.5em;">(Admin)</span>`
|
|
} else {
|
|
// Non-admin colors
|
|
commentColor = voterInfo.vote === "yes" ? "rgba(0, 100, 0, 0.3)" : "rgba(100, 0, 0, 0.3)" // Darker green for yes, darker red for no
|
|
}
|
|
}
|
|
|
|
return `
|
|
<div class="comment" style="border: 1px solid gray; margin: 1vh 0; padding: 1vh; background: ${commentColor};">
|
|
<p>
|
|
<strong><u>${decryptedCommentData.creator}</u></strong>
|
|
${adminBadge}
|
|
</p>
|
|
<p>${decryptedCommentData.content}</p>
|
|
<p><i>${timestamp}</i></p>
|
|
</div>
|
|
`
|
|
} catch (err) {
|
|
console.error(`Error processing comment ${comment.identifier}:`, err)
|
|
return null // Skip this comment if it fails
|
|
}
|
|
})
|
|
)
|
|
|
|
// Add all comments to the container
|
|
commentHTMLArray
|
|
.filter((html) => html !== null) // Filter out failed comments
|
|
.forEach((commentHTML) => {
|
|
commentsContainer.insertAdjacentHTML('beforeend', commentHTML)
|
|
})
|
|
} catch (error) {
|
|
console.error(`Error displaying comments (or no comments) for ${cardIdentifier}:`, error)
|
|
}
|
|
}
|
|
|
|
|
|
const toggleEncryptedComments = async (cardIdentifier) => {
|
|
const commentsSection = document.getElementById(`comments-section-${cardIdentifier}`)
|
|
const commentButton = document.getElementById(`comment-button-${cardIdentifier}`)
|
|
|
|
if (!commentsSection || !commentButton) return
|
|
|
|
const count = commentButton.dataset.commentCount;
|
|
const isHidden = (commentsSection.style.display === 'none' || !commentsSection.style.display)
|
|
|
|
if (isHidden) {
|
|
// Show comments
|
|
commentButton.textContent = "LOADING..."
|
|
await displayEncryptedComments(cardIdentifier)
|
|
commentsSection.style.display = 'block'
|
|
// Change the button text to 'HIDE COMMENTS'
|
|
commentButton.textContent = 'HIDE COMMENTS'
|
|
} else {
|
|
// Hide comments
|
|
commentsSection.style.display = 'none'
|
|
commentButton.textContent = `COMMENTS (${count})`
|
|
}
|
|
}
|
|
|
|
const createLinkDisplayModal = async () => {
|
|
const modalHTML = `
|
|
<div id="links-modal" style="display: none; position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0, 0, 0, 0.8); z-index: 1000;">
|
|
<div style="position: relative; margin: 10% auto; width: 95%; height: 80%; background: white; border-radius: 10px; overflow: hidden;">
|
|
<iframe id="links-modalContent" src="" style="width: 100%; height: 100%; border: none;"></iframe>
|
|
<button onclick="closeLinkDisplayModal()" style="position: absolute; top: 10px; right: 10px; background: red; color: white; border: none; padding: 5px 10px; border-radius: 5px;">Close</button>
|
|
</div>
|
|
</div>
|
|
`
|
|
document.body.insertAdjacentHTML('beforeend', modalHTML)
|
|
}
|
|
|
|
// Function to open the modal
|
|
const openLinkDisplayModal = async (link) => {
|
|
const processedLink = await processQortalLinkForRendering(link) // Process the link to replace `qortal://` for rendering in modal
|
|
const modal = document.getElementById('links-modal')
|
|
const modalContent = document.getElementById('links-modalContent')
|
|
modalContent.src = processedLink // Set the iframe source to the link
|
|
modal.style.display = 'block' // Show the modal
|
|
}
|
|
|
|
// Function to close the modal
|
|
const closeLinkDisplayModal = async () => {
|
|
const modal = document.getElementById('links-modal')
|
|
const modalContent = document.getElementById('links-modalContent')
|
|
modal.style.display = 'none' // Hide the modal
|
|
modalContent.src = '' // Clear the iframe source
|
|
}
|
|
|
|
const processQortalLinkForRendering = async (link) => {
|
|
if (link.startsWith('qortal://')) {
|
|
const match = link.match(/^qortal:\/\/([^/]+)(\/.*)?$/)
|
|
if (match) {
|
|
const firstParam = match[1].toUpperCase()
|
|
const remainingPath = match[2] || ""
|
|
const themeColor = window._qdnTheme || 'default' // Fallback to 'default' if undefined
|
|
// Simulating async operation if needed
|
|
await new Promise(resolve => setTimeout(resolve, 10))
|
|
|
|
return `/render/${firstParam}${remainingPath}?theme=${themeColor}`
|
|
}
|
|
}
|
|
return link
|
|
}
|
|
|
|
const checkAndDisplayRemoveActions = async (adminYes, name, cardIdentifier, nameIsActuallyAddress = false) => {
|
|
const latestBlockInfo = await getLatestBlockInfo()
|
|
const isBlockPassed = latestBlockInfo.height >= GROUP_APPROVAL_FEATURE_TRIGGER_HEIGHT
|
|
let minAdminCount
|
|
const minterAdmins = await fetchMinterGroupAdmins()
|
|
|
|
if ((minterAdmins) && (minterAdmins.length === 1)){
|
|
console.warn(`simply a double-check that there is only one MINTER group admin, in which case the group hasn't been transferred to null...keeping default minAdminCount of: ${minAdminCount}`)
|
|
minAdminCount = 9
|
|
} else if ((minterAdmins) && (minterAdmins.length > 1) && isBlockPassed){
|
|
const totalAdmins = minterAdmins.length
|
|
const fortyPercent = totalAdmins * 0.40
|
|
minAdminCount = Math.ceil(fortyPercent)
|
|
console.warn(`this is another check to ensure minterAdmin group has more than 1 admin. IF so we will calculate the 40% needed for GROUP_APPROVAL, that number is: ${minAdminCount}`)
|
|
}
|
|
if (isBlockPassed && (userState.isMinterAdmin || userState.isAdmin)) {
|
|
console.warn(`feature trigger has passed, checking for approval requirements`)
|
|
let address
|
|
if (!nameIsActuallyAddress){
|
|
const nameInfo = await getNameInfo(name)
|
|
address = nameInfo.owner
|
|
} else {
|
|
address = name
|
|
}
|
|
const kickApprovalHtml = await checkGroupApprovalAndCreateButton(address, cardIdentifier, "GROUP_KICK")
|
|
const banApprovalHtml = await checkGroupApprovalAndCreateButton(address, cardIdentifier, "GROUP_BAN")
|
|
|
|
if (kickApprovalHtml) {
|
|
return kickApprovalHtml
|
|
}
|
|
|
|
if (banApprovalHtml) {
|
|
return banApprovalHtml
|
|
}
|
|
}
|
|
|
|
if (adminYes >= minAdminCount && (userState.isMinterAdmin || userState.isAdmin)) {
|
|
const removeButtonHtml = createRemoveButtonHtml(name, cardIdentifier)
|
|
return removeButtonHtml
|
|
} else{
|
|
return ''
|
|
}
|
|
|
|
}
|
|
|
|
const createRemoveButtonHtml = (name, cardIdentifier) => {
|
|
return `
|
|
<div id="remove-button-container-${cardIdentifier}" style="margin-top: 1em;">
|
|
<button onclick="handleKickMinter('${name}')"
|
|
style="padding: 10px; background: rgb(134, 80, 4); color: white; border: none; cursor: pointer; border-radius: 5px;"
|
|
onmouseover="this.style.backgroundColor='rgb(47, 28, 11) '"
|
|
onmouseout="this.style.backgroundColor='rgb(134, 80, 4) '">
|
|
Create KICK Tx
|
|
</button>
|
|
<button onclick="handleBanMinter('${name}')"
|
|
style="padding: 10px; background:rgb(93, 7, 7); color: white; border: none; cursor: pointer; border-radius: 5px;"
|
|
onmouseover="this.style.backgroundColor='rgb(39, 9, 9) '"
|
|
onmouseout="this.style.backgroundColor='rgb(93, 7, 7) '">
|
|
Create BAN Tx
|
|
</button>
|
|
</div>
|
|
`
|
|
}
|
|
|
|
const handleKickMinter = async (minterName) => {
|
|
try {
|
|
isAddress = await getAddressInfo(minterName)
|
|
|
|
// Optional block check
|
|
let txGroupId = 0
|
|
// const { height: currentHeight } = await getLatestBlockInfo()
|
|
const isBlockPassed = await featureTriggerCheck()
|
|
if (isBlockPassed) {
|
|
console.log(`block height above featureTrigger Height, using group approval method...txGroupId 694`)
|
|
txGroupId = 694
|
|
}
|
|
|
|
// Get the minter address from name info
|
|
let minterAddress
|
|
if (!isAddress){
|
|
const minterNameInfo = await getNameInfo(minterName)
|
|
minterAddress = minterNameInfo?.owner
|
|
} else {
|
|
minterAddress = minterName
|
|
}
|
|
|
|
if (!minterAddress) {
|
|
alert(`No valid address found for minter name: ${minterName}, this should NOT have happened, please report to developers...`)
|
|
return
|
|
}
|
|
|
|
const adminPublicKey = await getPublicKeyByName(userState.accountName)
|
|
const reason = 'Kicked by Minter Admins'
|
|
const fee = 0.01
|
|
|
|
const rawKickTransaction = await createGroupKickTransaction(minterAddress, adminPublicKey, 694, minterAddress, reason, txGroupId, fee)
|
|
|
|
const signedKickTransaction = await qortalRequest({
|
|
action: "SIGN_TRANSACTION",
|
|
unsignedBytes: rawKickTransaction
|
|
})
|
|
if (!signedKickTransaction) {
|
|
console.warn(`this only happens if the SIGN_TRANSACTION qortalRequest failed... are you using the legacy UI prior to this qortalRequest being added?`)
|
|
alert(`this only happens if the SIGN_TRANSACTION qortalRequest failed... are you using the legacy UI prior to this qortalRequest being added? Please talk to developers.`)
|
|
return
|
|
}
|
|
|
|
let txToProcess = signedKickTransaction
|
|
|
|
const processKickTx = await processTransaction(txToProcess)
|
|
|
|
if (typeof processKickTx === 'object') {
|
|
console.log("transaction success object:", processKickTx)
|
|
alert(`${minterName} kick successfully issued! Wait for confirmation...Transaction Response: ${JSON.stringify(processKickTx)}`)
|
|
} else {
|
|
console.log("transaction raw text response:", processKickTx)
|
|
alert(`TxResponse: ${JSON.stringify(processKickTx)}`)
|
|
}
|
|
|
|
} catch (error) {
|
|
console.error("Error removing minter:", error)
|
|
alert(`Error:${error}. Please try again.`)
|
|
}
|
|
}
|
|
|
|
const handleBanMinter = async (minterName) => {
|
|
isAddress = await getAddressInfo(minterName)
|
|
try {
|
|
let txGroupId = 0
|
|
// const { height: currentHeight } = await getLatestBlockInfo()
|
|
const isBlockPassed = await featureTriggerCheck()
|
|
if (!isBlockPassed) {
|
|
console.log(`block height is under the removal featureTrigger height, using txGroupId 0`)
|
|
txGroupId = 0
|
|
} else {
|
|
console.log(`featureTrigger block is passed, using txGroupId 694`)
|
|
txGroupId = 694
|
|
}
|
|
let minterAddress
|
|
if (!isAddress) {
|
|
const minterNameInfo = await getNameInfo(minterName)
|
|
const minterAddress = minterNameInfo?.owner
|
|
} else {
|
|
minterAddress = minterName
|
|
}
|
|
|
|
if (!minterAddress) {
|
|
alert(`No valid address found for minter name: ${minterName}, this should NOT have happened, please report to developers...`)
|
|
return
|
|
}
|
|
|
|
const adminPublicKey = await getPublicKeyByName(userState.accountName)
|
|
const reason = 'Banned by Minter Admins'
|
|
const fee = 0.01
|
|
|
|
const rawBanTransaction = await createGroupBanTransaction(minterAddress, adminPublicKey, 694, minterAddress, reason, txGroupId, fee)
|
|
|
|
const signedBanTransaction = await qortalRequest({
|
|
action: "SIGN_TRANSACTION",
|
|
unsignedBytes: rawBanTransaction
|
|
})
|
|
if (!signedBanTransaction) {
|
|
console.warn(`this only happens if the SIGN_TRANSACTION qortalRequest failed... are you using the legacy UI prior to this qortalRequest being added?`)
|
|
alert(`this only happens if the SIGN_TRANSACTION qortalRequest failed... are you using the legacy UI prior to this qortalRequest being added? Please talk to developers.`)
|
|
return
|
|
}
|
|
|
|
let txToProcess = signedBanTransaction
|
|
|
|
const processedTx = await processTransaction(txToProcess)
|
|
|
|
if (typeof processedTx === 'object') {
|
|
console.log("transaction success object:", processedTx)
|
|
alert(`${minterName} BAN successfully issued! Wait for confirmation...Transaction Response: ${JSON.stringify(processedTx)}`)
|
|
} else {
|
|
// fallback string or something
|
|
console.log("transaction raw text response:", processedTx)
|
|
alert(`transaction response:${JSON.stringify(processedTx)}` )
|
|
}
|
|
|
|
} catch (error) {
|
|
console.error("Error removing minter:", error)
|
|
alert(`Error ${error}. Please try again.`)
|
|
}
|
|
}
|
|
|
|
const getNewestAdminCommentTimestamp = async (cardIdentifier) => {
|
|
try {
|
|
const comments = await fetchEncryptedComments(cardIdentifier)
|
|
if (!comments || comments.length === 0) {
|
|
return 0
|
|
}
|
|
const newestTimestamp = comments.reduce((acc, comment) => {
|
|
const cTime = comment.updated || comment.created || 0
|
|
return cTime > acc ? cTime : acc
|
|
}, 0)
|
|
return newestTimestamp
|
|
} catch (err) {
|
|
console.error('Failed to get newest comment timestamp:', err)
|
|
return 0
|
|
}
|
|
}
|
|
|
|
// Create the overall Minter Card HTML -----------------------------------------------
|
|
const createEncryptedCardHTML = async (cardData, pollResults, cardIdentifier, commentCount) => {
|
|
const { minterName, minterAddress = '', header, content, links, creator, timestamp, poll, topicMode } = cardData
|
|
const formattedDate = new Date(timestamp).toLocaleString()
|
|
const minterAvatar = !topicMode ? await getMinterAvatar(minterName) : null
|
|
const creatorAvatar = await getMinterAvatar(creator)
|
|
const linksHTML = links.map((link, index) => `
|
|
<button onclick="openLinkDisplayModal('${link}')">
|
|
${`Link ${index + 1} - ${link}`}
|
|
</button>
|
|
`).join("")
|
|
const showKickedBanned = document.getElementById('admin-show-kicked-banned-checkbox')?.checked ?? false
|
|
const showHiddenAdminCards = document.getElementById('admin-show-hidden-checkbox')?.checked ?? false
|
|
|
|
const isUndefinedUser = (minterName === 'undefined' || minterName === 'null')
|
|
|
|
const hasTopicMode = Object.prototype.hasOwnProperty.call(cardData, 'topicMode')
|
|
|
|
let showTopic = false
|
|
|
|
const { finalKickTxs, pendingKickTxs, finalBanTxs, pendingBanTxs } = await fetchAllKickBanTxData()
|
|
|
|
if (hasTopicMode) {
|
|
const modeVal = cardData.topicMode
|
|
showTopic = (modeVal === true || modeVal === 'true')
|
|
} else {
|
|
if (!isUndefinedUser) {
|
|
showTopic = false
|
|
}
|
|
}
|
|
|
|
let cardColorCode = showTopic ? '#0e1b15' : '#151f28'
|
|
|
|
const minterOrTopicHtml = ((showTopic) || (isUndefinedUser)) ? `
|
|
<div class="support-header"><h5> REGARDING (Topic / Address): </h5></div>
|
|
<h3>${minterName}` :
|
|
`
|
|
<div class="support-header"><h5> REGARDING (Name): </h5></div>
|
|
${minterAvatar}
|
|
<h3>${minterName}`
|
|
|
|
const minterGroupMembers = await fetchMinterGroupMembers()
|
|
const minterAdmins = await fetchMinterGroupAdmins()
|
|
const { adminYes = 0, adminNo = 0, minterYes = 0, minterNo = 0, totalYes = 0, totalNo = 0, totalYesWeight = 0, totalNoWeight = 0, detailsHtml, userVote = null } = await processPollData(pollResults, minterGroupMembers, minterAdmins, creator, cardIdentifier)
|
|
|
|
createModal('links')
|
|
createModal('poll-details')
|
|
|
|
let showRemoveHtml
|
|
let altText = ''
|
|
let penaltyText = ''
|
|
let adjustmentText = ''
|
|
const verifiedName = await validateMinterName(minterName)
|
|
let levelText = '</h3>'
|
|
const addressVerification = await getAddressInfo(minterName)
|
|
const verifiedAddress = addressVerification.address
|
|
|
|
if (verifiedName || verifiedAddress) {
|
|
let accountInfo
|
|
if (!verifiedAddress){
|
|
accountInfo = await getNameInfo(verifiedName)
|
|
}
|
|
|
|
const accountAddress = verifiedAddress ? addressVerification.address : accountInfo.owner
|
|
const addressInfo = verifiedAddress ? addressVerification : await getAddressInfo(accountAddress)
|
|
const minterGroupAddresses = minterGroupMembers.map(m => m.member)
|
|
const adminAddresses = minterAdmins.map(m => m.member)
|
|
const existingAdmin = adminAddresses.includes(accountAddress)
|
|
const existingMinter = minterGroupAddresses.includes(accountAddress)
|
|
|
|
levelText = ` - Level ${addressInfo.level}</h3>`
|
|
console.log(`name is validated, utilizing for removal features...${verifiedName}`)
|
|
penaltyText = addressInfo.blocksMintedPenalty == 0 ? '' : '<p>(has Blocks Penalty)<p>'
|
|
adjustmentText = addressInfo.blocksMintedAdjustment == 0 ? '' : '<p>(has Blocks Adjustment)<p>'
|
|
const removeActionsHtml = verifiedAddress ? await checkAndDisplayRemoveActions(adminYes, verifiedAddress, cardIdentifier, true) : await checkAndDisplayRemoveActions(adminYes, verifiedName, cardIdentifier)
|
|
showRemoveHtml = removeActionsHtml
|
|
|
|
if (userVote === 0) {
|
|
cardColorCode = "rgba(1, 65, 39, 0.41)"; // or any green you want
|
|
} else if (userVote === 1) {
|
|
cardColorCode = "rgba(55, 12, 12, 0.61)"; // or any red you want
|
|
}
|
|
|
|
const confirmedKick = finalKickTxs.some(
|
|
(tx) => tx.groupId === 694 && tx.member === accountAddress
|
|
)
|
|
const pendingKick = pendingKickTxs.some(
|
|
(tx) => tx.groupId === 694 && tx.member === accountAddress
|
|
)
|
|
const confirmedBan = finalBanTxs.some(
|
|
(tx) => tx.groupId === 694 && tx.offender === accountAddress
|
|
)
|
|
const pendingBan = pendingBanTxs.some(
|
|
(tx) => tx.groupId === 694 && tx.offender === accountAddress
|
|
)
|
|
|
|
// If user is definitely admin (finalAdd) and not pending removal
|
|
if (confirmedKick && !pendingKick && !existingMinter) {
|
|
console.warn(`account was already kicked, displaying as such...`)
|
|
cardColorCode = 'rgb(29, 7, 4)'
|
|
altText = `<h4 style="color:rgb(143, 117, 21); margin-bottom: 0.5em;">KICKED From MINTER Group</h4>`
|
|
showRemoveHtml = ''
|
|
if (!adminBoardState.kickedCards.has(cardIdentifier)){
|
|
adminBoardState.kickedCards.add(cardIdentifier)
|
|
}
|
|
if (!showKickedBanned) {
|
|
console.warn(`kick/ban checkbox is unchecked, card is kicked, not displaying...`)
|
|
return ''
|
|
}
|
|
}
|
|
|
|
if (confirmedBan && !pendingBan && !pendingKick && !existingMinter) {
|
|
console.warn(`account was already banned, displaying as such...`)
|
|
cardColorCode = 'rgb(24, 3, 3)'
|
|
altText = `<h4 style="color:rgb(106, 2, 2); margin-bottom: 0.5em;">BANNED From MINTER Group</h4>`
|
|
showRemoveHtml = ''
|
|
if (!adminBoardState.bannedCards.has(cardIdentifier)){
|
|
adminBoardState.bannedCards.add(cardIdentifier)
|
|
}
|
|
if (!showKickedBanned){
|
|
console.warn(`kick/bank checkbox is unchecked, and card is banned, not displaying...`)
|
|
return ''
|
|
}
|
|
}
|
|
|
|
// if (banTransactions.some((banTx) => banTx.groupId === 694 && banTx.offender === accountAddress)){
|
|
// console.warn(`account was already banned, displaying as such...`)
|
|
// cardColorCode = 'rgb(24, 3, 3)'
|
|
// altText = `<h4 style="color:rgb(106, 2, 2); margin-bottom: 0.5em;">BANNED From MINTER Group</h4>`
|
|
// showRemoveHtml = ''
|
|
// if (!adminBoardState.bannedCards.has(cardIdentifier)){
|
|
// adminBoardState.bannedCards.add(cardIdentifier)
|
|
// }
|
|
// if (!showKickedBanned){
|
|
// console.warn(`kick/bank checkbox is unchecked, and card is banned, not displaying...`)
|
|
// return ''
|
|
// }
|
|
// }
|
|
|
|
// if (kickTransactions.some((kickTx) => kickTx.groupId === 694 && kickTx.member === accountAddress)){
|
|
// console.warn(`account was already kicked, displaying as such...`)
|
|
// cardColorCode = 'rgb(29, 7, 4)'
|
|
// altText = `<h4 style="color:rgb(143, 117, 21); margin-bottom: 0.5em;">KICKED From MINTER Group</h4>`
|
|
// showRemoveHtml = ''
|
|
// if (!adminBoardState.kickedCards.has(cardIdentifier)){
|
|
// adminBoardState.kickedCards.add(cardIdentifier)
|
|
// }
|
|
// if (!showKickedBanned) {
|
|
// console.warn(`kick/ban checkbox is unchecked, card is kicked, not displaying...`)
|
|
// return ''
|
|
// }
|
|
// }
|
|
|
|
} else {
|
|
console.log(`name could not be validated, assuming topic card (or some other issue with name validation) for removalActions`)
|
|
showRemoveHtml = ''
|
|
}
|
|
|
|
return `
|
|
<div class="admin-card" style="background-color: ${cardColorCode}">
|
|
<div class="minter-card-header">
|
|
<h2 class="support-header"> Created By: </h2>
|
|
${creatorAvatar}
|
|
<h2>${creator}</h2>
|
|
${minterOrTopicHtml}${levelText}
|
|
<p>${header}</p>
|
|
${penaltyText}${adjustmentText}${altText}
|
|
</div>
|
|
<div class="info">
|
|
${content}
|
|
</div>
|
|
<div class="support-header"><h5>LINKS</h5></div>
|
|
<div class="info-links">
|
|
${linksHTML}
|
|
</div>
|
|
<div class="results-header support-header"><h5>CURRENT RESULTS</h5></div>
|
|
<div class="minter-card-results">
|
|
<button onclick="togglePollDetails('${cardIdentifier}')">Display Poll Details</button>
|
|
<div id="poll-details-${cardIdentifier}" style="display: none;">
|
|
${detailsHtml}
|
|
</div>
|
|
${showRemoveHtml}
|
|
<div class="admin-results">
|
|
<span class="admin-yes">Admin Support: ${adminYes}</span>
|
|
<span class="admin-no">Admin Against: ${adminNo}</span>
|
|
</div>
|
|
<div class="minter-results">
|
|
<span class="minter-yes">Supporting Weight ${totalYesWeight}</span>
|
|
<span class="minter-no">Denial Weight ${totalNoWeight}</span>
|
|
</div>
|
|
</div>
|
|
<div class="support-header"><h5>ACTIONS FOR</h5><h5 style="color: #ffae42;">${minterName}</h5>
|
|
<p style="color: #c7c7c7; font-size: .65rem; margin-top: 1vh">(click COMMENTS button to open/close card comments)</p>
|
|
</div>
|
|
<div class="actions">
|
|
<div class="actions-buttons">
|
|
<button class="yes" onclick="voteYesOnPoll('${poll}')">YES</button>
|
|
<button id="comment-button-${cardIdentifier}" data-comment-count="${commentCount}" class="comment" onclick="toggleEncryptedComments('${cardIdentifier}')">COMMENTS (${commentCount})</button>
|
|
<button class="no" onclick="voteNoOnPoll('${poll}')">NO</button>
|
|
</div>
|
|
</div>
|
|
<div id="comments-section-${cardIdentifier}" class="comments-section" style="display: none; margin-top: 20px;">
|
|
<div id="comments-container-${cardIdentifier}" class="comments-container"></div>
|
|
<textarea id="new-comment-${cardIdentifier}" placeholder="Input your comment..." style="width: 100%; margin-top: 10px;"></textarea>
|
|
<button onclick="postEncryptedComment('${cardIdentifier}')">Post Comment</button>
|
|
</div>
|
|
<p style="font-size: 0.75rem; margin-top: 1vh; color: #4496a1">By: ${creator} - ${formattedDate}</p>
|
|
</div>
|
|
`
|
|
}
|
|
|