init

cards/cards.controller.js

@@ -0,0 +1,134 @@
+const CardModel = require('../cards/cards.model');
+const Activity = require("../activity/activity.model");
+const config = require('../config');
+
+exports.AddCard = async(req, res) => 
+{
+    var tid = req.body.tid;
+    var type = req.body.type;
+    var team = req.body.team;
+    var rarity = req.body.rarity || "";
+    var mana = req.body.mana || 0;
+    var attack = req.body.attack || 0;
+    var hp = req.body.hp || 0;
+    var cost = req.body.cost || 1;
+    var packs = req.body.packs || [];
+
+    if(!tid || typeof tid !== "string")
+        return res.status(400).send({error: "Invalid parameters"});
+
+    if(!type || typeof type !== "string")
+        return res.status(400).send({error: "Invalid parameters"});
+
+    if(!team || typeof team !== "string")
+        return res.status(400).send({error: "Invalid parameters"});
+
+    if(!rarity || typeof rarity !== "string")
+        return res.status(400).send({error: "Invalid parameters"});
+
+    if(!Number.isInteger(mana) || !Number.isInteger(attack) || !Number.isInteger(hp) || !Number.isInteger(cost))
+        return res.status(400).send({ error: "Invalid parameters" });
+
+    if(packs && !Array.isArray(packs))
+        return res.status(400).send({error: "Invalid parameters"});
+
+    var data = {
+        tid: tid,
+        type: type,
+        team: team,
+        rarity: rarity,
+        mana: mana,
+        attack: attack,
+        hp: hp,
+        cost: cost,
+        packs: packs,
+    }
+
+    //Update or create
+    var card = await CardModel.get(tid);
+    if(card)
+        card = await CardModel.update(card, data);
+    else
+        card = await CardModel.create(data);
+
+    if(!card)
+        return res.status(500).send({error: "Error updating card"});
+
+    return res.status(200).send(data);
+};
+
+exports.AddCardList = async(req, res) => 
+{
+    var cards = req.body.cards;
+    if(!Array.isArray(cards))
+        return res.status(400).send({error: "Invalid parameters"});
+
+    var ocards = [];
+    for(var i=0; i<cards.length; i++)
+    {
+        var card = cards[i];
+        if(card && card.tid && card.type && card.team)
+        {
+            var data = {
+                tid: card.tid,
+                type: card.type,
+                team: card.team,
+                rarity: card.rarity || "",
+                mana: card.mana || 0,
+                attack: card.attack || 0,
+                hp: card.hp || 0,
+                cost: card.cost || 0,
+                packs: card.packs || [],
+            }
+
+            var ccard = await CardModel.get(card.tid);
+            if(ccard)
+                ccard = await CardModel.update(ccard, data);
+            else
+                ccard = await CardModel.create(data);
+
+            ocards.push(ccard);
+        }
+    }
+
+    return res.status(200).send(ocards);
+};
+
+exports.DeleteCard = async(req, res) => 
+{
+    CardModel.remove(req.params.tid);
+    return res.status(204).send({});
+};
+
+exports.DeleteAll = async(req, res) => 
+{
+    CardModel.removeAll();
+    return res.status(204).send({});
+};
+
+exports.GetCard = async(req, res) => 
+{
+    var tid = req.params.tid;
+
+    if(!tid)
+        return res.status(400).send({error: "Invalid parameters"});
+
+    var card = await CardModel.get(tid);
+    if(!card)
+        return res.status(404).send({error: "Card not found: " + tid});
+
+    return res.status(200).send(card.toObj());
+};
+
+exports.GetAll = async(req, res) => 
+{
+    var cards = await CardModel.getAll();
+
+    for(var i=0; i<cards.length; i++){
+        cards[i] = cards[i].toObj();
+    }
+
+    return res.status(200).send(cards);
+};
+
+

cards/cards.model.js

@@ -0,0 +1,111 @@
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const cardsSchema = new Schema({
+
+    tid: { type: String, index: true, unique: true, default: "" },
+    type: { type: String, default: "" },
+    team: { type: String, default: "" },
+    rarity: {type: String, default: ""},
+    mana: {type: Number, default: 0},
+    attack: {type: Number, default: 0},
+    hp: {type: Number, default: 0},
+    cost: {type: Number, default: 0},
+
+    packs: [{type: String}],  //Card is available in those packs
+});
+
+cardsSchema.methods.toObj = function() {
+    var card = this.toObject();
+    delete card.__v;
+    delete card._id;
+    return card;
+};
+
+const Card = mongoose.model('Cards', cardsSchema);
+
+exports.get = async(tid) => {
+    try{
+        var card = await Card.findOne({tid: tid});
+        return card;
+    }
+    catch{
+        return null;
+    }
+};
+
+exports.getAll = async(filter) => {
+
+    try{
+        filter = filter || {};
+        var cards = await Card.find(filter);
+        return cards || [];
+    }
+    catch{
+        return [];
+    }
+};
+
+exports.getByPack = async(packId, filter) => {
+
+    try{
+        filter = filter || {};
+        if(packId)
+        {
+            filter.packs = {$in:[packId]};
+        }
+        var cards = await Card.find(filter);
+        return cards || [];
+    }
+    catch{
+        return [];
+    }
+};
+
+exports.create = async(data) => {
+    try{
+        var card = new Card(data);
+        return await card.save();
+    }
+    catch{
+        return null;
+    }
+};
+
+exports.update = async(card, data) => {
+
+    try{
+        if(!card) return null;
+
+        for (let i in data) {
+            card[i] = data[i];
+            card.markModified(i);
+        }
+
+        var updated = await card.save();
+        return updated;
+    }
+    catch{
+        return null;
+    }
+};
+
+exports.remove = async(tid) => {
+    try{
+        var result = await Card.deleteOne({tid: tid});
+        return result && result.deletedCount > 0;
+    }
+    catch{
+        return false;
+    }
+};
+
+exports.removeAll = async() => {
+    try{
+        var result = await Card.deleteMany({});
+        return result && result.deletedCount > 0;
+    }
+    catch{
+        return false;
+    }
+};

cards/cards.routes.js

@@ -0,0 +1,42 @@
+const CardController = require('./cards.controller');
+const AuthTool = require('../authorization/auth.tool');
+const config = require('../config');
+
+const ADMIN = config.permissions.ADMIN; //Highest permision, can read and write all users
+const SERVER = config.permissions.SERVER; //Higher permission, can read all users
+const USER = config.permissions.USER; //Lowest permision, can only do things on same user
+
+exports.route = function (app) {
+
+    app.get('/cards/:tid', [
+        CardController.GetCard
+    ]);
+
+    app.get('/cards', [
+        CardController.GetAll
+    ]);
+
+    app.post('/cards/add', [
+        AuthTool.isValidJWT,
+        AuthTool.isPermissionLevel(ADMIN),
+        CardController.AddCard
+    ]);
+
+    app.post('/cards/add/list', [
+        AuthTool.isValidJWT,
+        AuthTool.isPermissionLevel(ADMIN),
+        CardController.AddCardList
+    ]);
+
+    app.delete("/cards/:tid", [
+        AuthTool.isValidJWT,
+        AuthTool.isPermissionLevel(ADMIN),
+        CardController.DeleteCard
+    ]);
+
+    app.delete("/cards", [
+        AuthTool.isValidJWT,
+        AuthTool.isPermissionLevel(ADMIN),
+        CardController.DeleteAll
+    ]);
+};

cards/cards.tool.js

@@ -0,0 +1,111 @@
+const config = require('../config.js');
+const crypto = require('crypto');
+const CardModel = require('../cards/cards.model');
+
+const CardTool = {};
+
+CardTool.getPackCards = async(pack) =>
+{
+    var pack_cards = await CardModel.getByPack(pack.tid);
+
+    var cards = [];
+    for(var i=0; i<pack.cards; i++)
+    {
+        if(pack.random)
+        {
+            //Randomized set
+            var rarity_tid = CardTool.getRandomRarity(pack, i==0);
+            var variant_tid = CardTool.getRandomVariant(pack);
+            var rarity_cards = CardTool.getCardArray(pack_cards, rarity_tid);
+            var card = CardTool.getRandomCard(rarity_cards);
+            if(card)
+            {
+                var cardQ = {tid: card.tid, variant: variant_tid, quantity: 1};
+                cards.push(cardQ);
+            }
+        }
+        else if(i < pack_cards.length)
+        {
+            //Fixed set
+            var card = pack_cards[i];
+            var variant_tid = CardTool.getRandomVariant(pack);
+			var cardQ = {tid: card.tid, variant: variant_tid, quantity: 1};
+            cards.push(cardQ);
+        }
+    }
+    return cards;
+};
+
+CardTool.getRandomRarity = (pack, is_first) =>
+{
+    var rarities = is_first ? pack.rarities_1st : pack.rarities;
+    if(!rarities || rarities.length == 0)
+        return ""; //Any rarity
+
+    var total = 0;
+    for(var rarity of rarities) {
+        total += rarity.value;
+    }
+
+    var rvalue = Math.floor(Math.random()*total);
+
+    for(var i=0; i<rarities.length; i++)
+    {
+        var rarity = rarities[i];
+        if(rvalue < rarity.value)
+        {
+            return rarity.tid;
+        }
+        rvalue -= rarity.value;
+    }
+    return "";
+};
+
+CardTool.getRandomVariant = (pack) =>
+{
+    var variants = pack.variants;
+    if(!variants || variants.length == 0)
+        return "";
+
+    var total = 0;
+    for(var variant of variants) {
+        total += variant.value;
+    }
+
+    var rvalue = Math.floor(Math.random()*total);
+
+    for(var i=0; i<variants.length; i++)
+    {
+        var variant = variants[i];
+        if(rvalue < variant.value)
+        {
+            return variant.tid; 
+        }
+        rvalue -= variant.value;
+    }
+    return "";
+};
+
+CardTool.getCardArray = (all_cards, rarity) =>
+{
+    var valid_cards = [];
+    for(var i=0; i<all_cards.length; i++)
+    {
+        var card = all_cards[i];
+        if(!rarity || card.rarity == rarity)
+            valid_cards.push(card);
+    }
+    return valid_cards;
+}
+
+CardTool.getRandomCard = (all_cards, suffix) =>
+{
+    if(all_cards.length > 0)
+    {
+        var card = all_cards[Math.floor(Math.random()*all_cards.length)];
+        return card;
+    }
+    return null;
+};
+
+module.exports = CardTool;