IPost/routes/api/post.js

import sharp from "sharp";
import {writeFile} from "fs";

const image_types = {
    "png":true,
    "jpg":true,
    "jpeg":true,
    "webp":true,
    "jfif":true
}

export const setup = function (router, con, server) {
    const PIDS = {}; //[pid]: true/"already_used"

    function isNotNull(a) {
        return typeof a !== "undefined" && a !== null
    }

    function createPID(){
        let pid = server.genstring(10); //collision chance is low enough, but we'll check anyways
        while (PIDS[pid] != undefined) {
            pid = server.genstring(10);
            console.log(5, "pid collision");
        }
        PIDS[pid] = true;
        setTimeout(function() {
            PIDS[pid] = undefined;
        }, 40000);
        return pid
    }

    router.get("/api/pid",  function (req, res) {
        res.set("Access-Control-Allow-Origin", "*");
        res.json({ "pid": createPID() });
    });

    function validateMessage(message) {
        if (!message) {
            throw {
                statusCode: 410,
                message: "no message to post"
            }
        }
        if ((typeof message) !== "string") {
            throw {
                statusCode: 411,
                message: "no message to post"
            }
        }
        if (message.length > 1000) {
            throw {
                statusCode: 416,
                message: "message too long"
            }
        }
        message = encodeURIComponent(message.trim());
        if (message.length > 3000) {
            throw {
                statusCode: 417,
                message: "message too long"
            }
        }
        if (!message) {
            throw {
                statusCode: 418,
                message: "no message to post"
            }
        } //backup check
        return message
    }

    function validatePID(pid) {
        if (!pid || typeof pid !== "string") {
            throw {
                statusCode: 412,
                message: "no pid given"
            }
        }
        if (pid.length !== 10 || PIDS[pid]!==true) {
            throw {
                statusCode: 413,
                message: "invalid pid given"
            }
        }
        PIDS[req.body.pid] = "already_used";
    }

    function validateReplyID(rid) {
        let reply_id;
        if (!rid || rid < 0) {
            reply_id = 0
        }
        if(typeof rid === "string") {
            reply_id = parseInt(reply_id,10)
            if(isNaN(reply_id)) {
                throw {
                    statusCode: 414,
                    message: "no valid reply id given"
                }
            }
        }
        if (typeof reply_id !== "number") {
            throw {
                statusCode: 415,
                message: "no valid reply id given"
            } //backup case
        }
        return reply_id
    }

    function validateReceiver(rec) {
        let receiver = encodeURIComponent(rec || "");
        if (receiver == "")
            receiver = "everyone";
        return receiver
    }

    router.post("/api/post",  async (req, res) => {
        try {
          let message   = validateMessage(req.body.message);
          validatePID(req.body.pid);
          let reply_id  = validateReplyID(req.body.reply_id);
          let receiver  = validateReceiver(req.body.receiver);
          validateFiles(req.files);

          let __dirname = server.dirname
          const file_names = ["","","","",""]
          if(isNotNull(req.files)) {
            for(let file_index=0;file_index<5;file_index++) {
              if(isNotNull(req.files[`file_${file_index}`])) {
                let file = req.files[`file_${file_index}`]
                const file_id = server.genstring(20)
                const file_name = `${file_id}/${(file.name.substring(0,25)).replace(/\.[^/.]+$/, "")}`
                let extension = file.name.substring(file.name.lastIndexOf("\.")+1)
                file_names[file_index]=`${file_name}${(extension in image_types && ".webp") || extension}`
                server.ensureExists(`${__dirname}/user_uploads/${file_id}`,undefined,async (err)=>{
                  if(err) {
                    console.error(err)
                    return;
                  }
                  if(extension in image_types) {
                    writeFile(`${__dirname}/user_uploads/${file_name}.webp`,await sharp(file.data).webp({mixed:true,effort:6}).toBuffer(),(err2)=>{
                      if(err2)console.error(err2)
                    })
                    server.ensureExists(`${__dirname}/user_uploads/previews/${file_id}`,undefined,async (error) => {
                      if(error) {
                        console.error(error)
                        return;
                      }
                      writeFile(`${__dirname}/user_uploads/previews/${file_name}.webp`,await sharp(file.data).resize(100,100,{fit: "inside"}).webp({mixed:true,effort:6}).toBuffer(),(error2)=>{
                        if(error2)console.error(error2)
                      })
                    })
                  } else {
                    file.mv(`${__dirname}/user_uploads/${file_name}.${extension}`,(err2)=>{
                       if(err2)console.error(err2)
                    })
                  }
                })
              }
            }
          }

          let sql = `insert into ipost.posts (post_user_name,post_text,post_time,post_receiver_name,post_from_bot,post_reply_id,file_0,file_1,file_2,file_3,file_4) values (?,?,?,?,?,?,?,?,?,?,?); SELECT LAST_INSERT_ID() as ID;`;
          let values = [encodeURIComponent(res.locals.username), message, Date.now(), receiver, res.locals.isbot, reply_id,...file_names];
          con.query(sql, values, function (err, result) {
            if (err){
                res.status(500)
                res.json({"error":"there's been an interal error"})
                console.error(err)
                return;
            }
            let post_obj = {
                post_user_name: encodeURIComponent(res.locals.username),
                post_text: req.body.message,
                post_time: Date.now(),
                post_special_text: "",
                post_receiver_name: req.body.receiver,
                post_from_bot: res.locals.isbot,
                post_reply_id: reply_id,
                user_avatar: res.locals.avatar,
                files: file_names,
                post_id: result[0].ID
            };
            let message = {
                message: "new_post",
                data: post_obj
            };
            let messagestr = JSON.stringify(message);
            //console.log(5,server.wss.clients);       /* DEBUG: Log websocket clients */
            server.wss.clients.forEach(function(ws) {
                //console.log(5,ws); /* DEBUG: Log websocket clients */
                ws.send(messagestr);
            });
            res.json({ "success": "successfully posted message" });
            console.log(5, `posted new message by ${res.locals.username} : ${req.body.message}`);
          });
        } catch (error) {
          res.status(error.statusCode)
          res.json({ "error": error.message, "status": error.statusCode });
        }
    });
    return createPID
};
export default {
    setup
};