getItems and getUserItems

Moralis General
#1

Hi, I’m getting getItems and getUserItems errors with the clone rarible repo. I am currently using the <script src="https://cdn.jsdelivr.net/npm/web3@latest/dist/web3.min.js"></script> <script src="https://unpkg.com/[email protected]/dist/moralis.js"></script> library and SDK main.js file is `serverUrl = “https://j8wrzs2mjz2r.usemoralis.com:2053/server”
appId = “DI8laz6e0ls2psrkcMCkNQhjLV3BC98IUWX4ZMRl”
Moralis.start({ serverUrl, appId});

const TOKEN_CONTRACT_ADDRESS = “0x41B23c17053a67AAB87C458cf7A8F588E48DEF6E”;
const MARKETPLACE_CONTRACT_ADDRESS = “0x2d7Fc09Cb3D7d39A340Ee89054493f46b8B932C6”;

init = async () => {
hideElement(userItemsSection);
window.web3 = await Moralis.enableWeb3();
const web3 = new Web3(Moralis.provider);
window.tokenContract = new web3.eth.Contract(tokenContractAbi, TOKEN_CONTRACT_ADDRESS);
window.marketplaceContract = new web3.eth.Contract(marketplaceContractAbi, MARKETPLACE_CONTRACT_ADDRESS);

initUser();
loadItems();

const soldItemsQuery = new Moralis.Query('SoldItems');
const soldItemsSubscription = await soldItemsQuery.subscribe();
soldItemsSubscription.on("create", onItemSold);

const itemsAddedQuery = new Moralis.Query('ItemsForSale');
const itemsAddedSubscription = await itemsAddedQuery.subscribe();
itemsAddedSubscription.on("create", onItemAdded);

}

onItemSold = async (item) => {
const listing = document.getElementById(item-${item.attributes.uid});
if (listing){
listing.parentNode.removeChild(listing);
}

user = await Moralis.User.current();
if (user){
    const params = {uid: `${item.attributes.uid}`};
    const soldItem = await Moralis.Cloud.run('getItem', params);
    if (soldItem){
        if (user.get('accounts').includes(item.attributes.buyer)){
            getAndRenderItemData(soldItem, renderUserItem);
        }

        const userItemListing = document.getElementById(`user-item-${item.tokenObjectId}`);
        if (userItemListing) userItemListing.parentNode.removeChild(userItemListing);
      
    }

}

}

onItemAdded = async (item) => {
const params = {uid: ${item.attributes.uid}};
const addedItem = await Moralis.Cloud.run(‘getItem’, params);
if (addedItem){
user = await Moralis.User.current();
if (user){
if (user.get(‘accounts’).includes(addedItem.ownerOf)){
const userItemListing = document.getElementById(user-item-${item.tokenObjectId});
if (userItemListing) userItemListing.parentNode.removeChild(userItemListing);

            getAndRenderItemData(addedItem, renderUserItem);
            return;
        }
    }
    getAndRenderItemData(addedItem, renderItem);
}

}

initUser = async () => {
if (await Moralis.User.current()){
hideElement(userConnectButton);
showElement(userProfileButton);
showElement(openCreateItemButton);
showElement(openUserItemsButton);
loadUserItems();
}else{
//window.location.pathname = “/transferNft”;
showElement(userConnectButton);
hideElement(userProfileButton);
hideElement(openCreateItemButton);
hideElement(openUserItemsButton);
}
}

login = async () => {
try {
await Moralis.Web3.authenticate();
initUser();
} catch (error) {
alert(error)
}
}

logout = async () => {
await Moralis.User.logOut();
hideElement(userInfo);
initUser();
}

openUserInfo = async () => {
user = await Moralis.User.current();
if (user){
const email = user.get(‘email’);
if(email){
userEmailField.value = email;
}else{
userEmailField.value = “”;
}

    userUsernameField.value = user.get('username');

    const userAvatar = user.get('avatar');
    if(userAvatar){
        userAvatarImg.src = userAvatar.url();
        showElement(userAvatarImg);
    }else{
        hideElement(userAvatarImg);
    }

    $('#userInfo').modal('show');
}else{
    login();
}

}

saveUserInfo = async () => {
user.set(‘email’, userEmailField.value);
user.set(‘username’, userUsernameField.value);

if (userAvatarFile.files.length > 0) {
    const avatar = new Moralis.File("avatar1.jpg", userAvatarFile.files[0]);
    user.set('avatar', avatar);
}

await user.save();
alert("User info saved successfully!");
openUserInfo();

}

createItem = async () => {

if (createItemFile.files.length == 0){
    alert("Please select a file!");
    return;
} else if (createItemNameField.value.length == 0){
    alert("Please give the item a name!");
    return;
}

const nftFile = new Moralis.File("nftFile.jpg",createItemFile.files[0]);
await nftFile.saveIPFS();

const nftFilePath = nftFile.ipfs();

const metadata = {
    name: createItemNameField.value,
    description: createItemDescriptionField.value,
    image: nftFilePath,
};

const nftFileMetadataFile = new Moralis.File("metadata.json", {base64 : btoa(JSON.stringify(metadata))});
await nftFileMetadataFile.saveIPFS();

const nftFileMetadataFilePath = nftFileMetadataFile.ipfs();
console.log(nftFileMetadataFilePath);

const nftId = await mintNft(nftFileMetadataFilePath);

user = await Moralis.User.current();
const userAddress = user.get('ethAddress');

switch(createItemStatusField.value){
    case "0":
        return;
    case "1":
        await ensureMarketplaceIsApproved(nftId, TOKEN_CONTRACT_ADDRESS);
        await marketplaceContract.methods.addItemToMarket(nftId, TOKEN_CONTRACT_ADDRESS, createItemPriceField.value).send({from: userAddress });
        break;
    case "2":
        alert("Not yet supported!");
        return;
}

}

mintNft = async (metadataUrl) => {
const receipt = await tokenContract.methods.createItem(metadataUrl).send({from: ethereum.selectedAddress});
console.log(receipt);
return receipt.events.Transfer.returnValues.tokenId;
}

openUserItems = async () => {
user = await Moralis.User.current();
if (user){
$(’#userItems’).modal(‘show’);
}else{
login();
}
}

loadUserItems = async () => {
const ownedItems = await Moralis.Cloud.run(“getUserItems”);
ownedItems.forEach(item => {
const userItemListing = document.getElementById(user-item-${item.tokenObjectId});
if (userItemListing) return;
getAndRenderItemData(item, renderUserItem);
});
}

loadItems = async () => {
const items = await Moralis.Cloud.run(“getItems”);
user = await Moralis.User.current();
items.forEach(item => {
if (user){
if (user.attributes.accounts.includes(item.ownerOf)){
const userItemListing = document.getElementById(user-item-${item.tokenObjectId});
if (userItemListing) userItemListing.parentNode.removeChild(userItemListing);
getAndRenderItemData(item, renderUserItem);
return;
}
}
getAndRenderItemData(item, renderItem);
});
}

initTemplate = (id) => {
const template = document.getElementById(id);
template.id = “”;
template.parentNode.removeChild(template);
return template;
}

renderUserItem = async (item) => {
const userItemListing = document.getElementById(user-item-${item.tokenObjectId});
if (userItemListing) return;

const userItem = userItemTemplate.cloneNode(true);
userItem.getElementsByTagName("img")[0].src = item.image;

userItem.getElementsByTagName("img")[0].alt = item.name;
userItem.getElementsByTagName("h5")[0].innerText = item.name;

userItem.getElementsByTagName("p")[0].innerText = item.description; 
userItem.getElementsByTagName("input")[0].value = item.askingPrice ?? 1;
userItem.getElementsByTagName("input")[0].disabled = item.askingPrice > 0;
userItem.getElementsByTagName("button")[0].disabled = item.askingPrice > 0;
userItem.getElementsByTagName("button")[0].onclick = async () => {
    user = await Moralis.User.current();
    if (!user){
        login();
        return;
    }
    await ensureMarketplaceIsApproved(item.tokenId, item.tokenAddress);
    await marketplaceContract.methods.addItemToMarket(item.tokenId, item.tokenAddress, userItem.getElementsByTagName("input")[0].value).send({from: user.get('ethAddress') });
};
userItem.id = `user-item-${item.tokenObjectId}`
userItems.appendChild(userItem);

}

renderItem = (item) => {
const itemForSale = marketplaceItemTemplate.cloneNode(true);
if (item.sellerAvatar){
itemForSale.getElementsByTagName(“img”)[0].src = item.sellerAvatar.url();
itemForSale.getElementsByTagName(“img”)[0].alt = item.sellerUsername;

}

itemForSale.getElementsByTagName("img")[1].src = item.image;
itemForSale.getElementsByTagName("img")[1].alt = item.name;
itemForSale.getElementsByTagName("h5")[0].innerText = item.name;
itemForSale.getElementsByTagName("p")[0].innerText = item.description;

itemForSale.getElementsByTagName("button")[0].innerText = `Buy for ${item.askingPrice}`;
itemForSale.getElementsByTagName("button")[0].onclick = () => buyItem(item);
itemForSale.id = `item-${item.uid}`;
itemsForSale.appendChild(itemForSale);

}

getAndRenderItemData = (item, renderFunction) => {

fetch(item.tokenUri)
.then(response => response.json())
.then(data => {
    item.name = data.name;
    item.description = data.description;
    item.image = data.image;
    renderFunction(item);
})

}

ensureMarketplaceIsApproved = async (tokenId, tokenAddress) => {
user = await Moralis.User.current();
const userAddress = user.get(‘ethAddress’);
const contract = new web3.eth.Contract(tokenContractAbi, tokenAddress);
const approvedAddress = await contract.methods.getApproved(tokenId).call({from: userAddress});
if (approvedAddress != MARKETPLACE_CONTRACT_ADDRESS){
await contract.methods.approve(MARKETPLACE_CONTRACT_ADDRESS,tokenId).send({from: userAddress});
}
}

buyItem = async (item) => {
user = await Moralis.User.current();
if (!user){
login();
return;
}
await marketplaceContract.methods.buyItem(item.uid).send({from: user.get(‘ethAddress’), value: item.askingPrice});
}

hideElement = (element) => element.style.display = “none”;
showElement = (element) => element.style.display = “block”;

// Navbar
const userConnectButton = document.getElementById(“btnConnect”);
userConnectButton.onclick = login;

const userProfileButton = document.getElementById(“btnUserInfo”);
userProfileButton.onclick = openUserInfo;

const openCreateItemButton = document.getElementById(“btnOpenCreateItem”);
openCreateItemButton.onclick = () => $(’#createItem’).modal(‘show’);

// User profile
const userInfo = document.getElementById(“userInfo”);
const userUsernameField = document.getElementById(“txtUsername”);
const userEmailField = document.getElementById(“txtEmail”);
const userAvatarImg = document.getElementById(“imgAvatar”);
const userAvatarFile = document.getElementById(“fileAvatar”);

document.getElementById(“btnCloseUserInfo”).onclick = () => hideElement(userInfo);
document.getElementById(“btnLogout”).onclick = logout;
document.getElementById(“btnSaveUserInfo”).onclick = saveUserInfo;

// Item creation
const createItemForm = document.getElementById(“createItem”);

const createItemNameField = document.getElementById(“txtCreateItemName”);
const createItemDescriptionField = document.getElementById(“txtCreateItemDescription”);
const createItemPriceField = document.getElementById(“numCreateItemPrice”);
const createItemStatusField = document.getElementById(“selectCreateItemStatus”);
const createItemFile = document.getElementById(“fileCreateItemFile”);
document.getElementById(“btnCloseCreateItem”).onclick = () => hideElement(createItemForm);
document.getElementById(“btnCreateItem”).onclick = createItem;

// User items
const userItemsSection = document.getElementById(“userItems”);
const userItems = document.getElementById(“userItemsList”);
document.getElementById(“btnCloseUserItems”).onclick = () => hideElement(userItemsSection);
const openUserItemsButton = document.getElementById(“btnMyItems”);
openUserItemsButton.onclick = openUserItems;

const userItemTemplate = initTemplate(“itemTemplate”);
const marketplaceItemTemplate = initTemplate(“marketplaceItemTemplate”);

// Items for sale
const itemsForSale = document.getElementById(“itemsForSale”);

init();just updated theserverUrl = “https://j8wrzs2mjz2r.usemoralis.com:2053/server”
appId = “DI8laz6e0ls2psrkcMCkNQhjLV3BC98IUWX4ZMRl”
Moralis.start({ serverUrl, appId});andwindow.web3 = await Moralis.enableWeb3();
const web3 = new Web3(Moralis.provider);`

However, I’m unable to find any problems on my side I just see errors with the SDK, `Uncaught (in promise) Error: Invalid function: “getItems”
_construct https://unpkg.com/moralis@latest/dist/moralis.js:29705
Wrapper https://unpkg.com/moralis@latest/dist/moralis.js:30055
_createSuper https://unpkg.com/moralis@latest/dist/moralis.js:12208
ParseError https://unpkg.com/moralis@latest/dist/moralis.js:12259
handleError https://unpkg.com/moralis@latest/dist/moralis.js:25849
promise callbackrequest https://unpkg.com/moralis@latest/dist/moralis.js:25839
run https://unpkg.com/moralis@latest/dist/moralis.js:457
run https://unpkg.com/moralis@latest/dist/moralis.js:383
loadItems http://127.0.0.1:8887/main.js:225
init http://127.0.0.1:8887/main.js:32
async http://127.0.0.1:8887/main.js:377
moralis.js:29705:21

​`
Not else what else can be done, I feel stuck with this problem. I would appreciate any help, thanks.

#2

did you add that getItems function in cloud code?

#3

Yes It’s the same as the one in the repo, `Moralis.Cloud.define(“getUserItems”, async (request) => {

const query = new Moralis.Query("EthNFTTokenOwners");
query.equalTo("contract_type", "ERC721");
query.containedIn("owner_of", request.user.attributes.accounts);
const queryResults = await query.find();
const results = [];
for (let i = 0; i < queryResults.length; ++i) {
  results.push({
    "tokenObjectId": queryResults[i].id,
    "tokenId": queryResults[i].attributes.token_id,
    "tokenAddress": queryResults[i].attributes.token_address,
    "symbol": queryResults[i].attributes.symbol,
    "tokenUri": queryResults[i].attributes.token_uri,
  });
}
return results;

});

Moralis.Cloud.beforeSave(“ItemsForSale”, async (request) => {

const query = new Moralis.Query("EthNFTTokenOwners");
query.equalTo("token_address", request.object.get('tokenAddress'));
query.equalTo("token_id", request.object.get('tokenId'));
const object = await query.first();
if (object){
    const owner = object.attributes.owner_of;
  const userQuery = new Moralis.Query(Moralis.User);
    userQuery.equalTo("accounts", owner);
  const userObject = await userQuery.first({useMasterKey:true});
  if (userObject){
      request.object.set('user', userObject);
  }
  request.object.set('token', object);
}

});

Moralis.Cloud.beforeSave(“SoldItems”, async (request) => {

const query = new Moralis.Query("ItemsForSale");
query.equalTo("uid", request.object.get('uid'));
const item = await query.first();
if (item){
  request.object.set('item', item);
  item.set('isSold', true);
  await item.save();
  

  const userQuery = new Moralis.Query(Moralis.User);
    userQuery.equalTo("accounts", request.object.get('buyer'));
  const userObject = await userQuery.first({useMasterKey:true});
  if (userObject){
      request.object.set('user', userObject);
  }
}

});

Moralis.Cloud.define(“getItems”, async (request) => {

const query = new Moralis.Query("ItemsForSale");
query.notEqualTo("isSold", true);
query.select("uid","askingPrice","tokenAddress","tokenId", "token.token_uri", "token.symbol","token.owner_of","token.id", "user.avatar","user.username");

const queryResults = await query.find({useMasterKey:true});
const results = [];

for (let i = 0; i < queryResults.length; ++i) {

  if (!queryResults[i].attributes.token || !queryResults[i].attributes.user) continue;

  results.push({
    "uid": queryResults[i].attributes.uid,
    "tokenId": queryResults[i].attributes.tokenId,
    "tokenAddress": queryResults[i].attributes.tokenAddress,
    "askingPrice": queryResults[i].attributes.askingPrice,

    "symbol": queryResults[i].attributes.token.attributes.symbol,
    "tokenUri": queryResults[i].attributes.token.attributes.token_uri,
    "ownerOf": queryResults[i].attributes.token.attributes.owner_of,
    "tokenObjectId": queryResults[i].attributes.token.id,
    
    "sellerUsername": queryResults[i].attributes.user.attributes.username,
    "sellerAvatar": queryResults[i].attributes.user.attributes.avatar,
  });
}

return results;

});

Moralis.Cloud.define(“getItem”, async (request) => {

const query = new Moralis.Query("ItemsForSale");
query.equalTo("uid", request.params.uid);
query.select("uid","askingPrice","tokenAddress","tokenId", "token.token_uri", "token.symbol","token.owner_of","token.id","user.avatar","user.username");

const queryResult = await query.first({useMasterKey:true});
if (!queryResult) return;
return {
    "uid": queryResult.attributes.uid,
    "tokenId": queryResult.attributes.tokenId,
    "tokenAddress": queryResult.attributes.tokenAddress,
    "askingPrice": queryResult.attributes.askingPrice,

    "symbol": queryResult.attributes.token.attributes.symbol,
    "tokenUri": queryResult.attributes.token.attributes.token_uri,
    "ownerOf": queryResult.attributes.token.attributes.owner_of,
    "tokenObjectId": queryResult.attributes.token.id,

    "sellerUsername": queryResult.attributes.user.attributes.username,
    "sellerAvatar": queryResult.attributes.user.attributes.avatar,
  };

});`

#4

Deleted cookies, and reinstalled metamask. Seems to be working now