nftria/cloud-func.js at main · Sermanbilotil/nftria · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
import Moralis from "moralis";


Moralis.Cloud.define("getUserItems", async (request) => {

    const query = new Moralis.Query("PolygonNFTOwners");
    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("PolygonNFTOwners");
    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,
    };
});
Moralis.Cloud.define("fetchMyVotes", async(request) => {
    const objectId = "8AiPsNBBcYXPIDkdgJp8QMv4"; //input your value here
    const query = new Moralis.Query("MyObjects");

    query.equalTo("objectId", objectId);
    const queryResult = await query.first({ useMasterKey: true });
    const voters = queryResult.get("voters");

    let values = [];
    voters.forEach((element) => {
        values.push(element.someValue);
    });

    return values;
});