bwb add sql_unlocked

Author: 0WAQ

file_controller.cc

@@ -2,7 +2,7 @@
 #include "jwt_controller.h"
 #include <json/json.h>
 #include <stdio.h>
-
+#include "mysql.h"
 #include <chrono>
 #include <iostream>
 #include <stdexcept>
@@ -89,7 +89,9 @@ void saveFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePt
         std::string filename = req_json["filename"].asString();
         std::string content = req_json["content"].asString();
         std::string result = shell_commons(("echo '" + content + "'>" + std::string(pathvar) + "/../root/" + filename).c_str());
-
+        
+        sql_unlocked(filename);
+        
         res->addHeader("Access-Control-Allow-Origin", "*");
         res->setBody("success");
         callback(res);

msg_controller.cc

@@ -77,11 +77,10 @@ void request_processing(const HttpRequestPtr &req, std::function<void(const Http
     res->addHeader("Access-Control-Allow-Origin", "*");
 
     if (jwtVerify(req)) {
-
+        
         std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));
         std::string sender = req->getParameter("username");
         std::string attitude = req->getParameter("info");
-
         sql_process_request(sender, receiver, attitude);
         res->setBody("Success");
     } else {
@@ -106,15 +105,13 @@ void info(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)
     res->addHeader("Access-Control-Allow-Origin", "*");
 
     if (jwtVerify(req)) {
-
         me = jwtDecrypt(req->getHeader("Authorization").substr(7));
         if (req_json["person"].asString() == "") {
             res->setBody(writer.write(get_chat_info(me, "")));
         } else {
             who_send_me = req_json["person"].asString();
             res->setBody(writer.write(get_chat_info(me, who_send_me)));
         }
-        
     } else {
         res->setBody("No Authorization");
     }

mysql.cc

@@ -4,13 +4,39 @@
 #include "jdbc/mysql_driver.h"
 #include "json/json.h"
 
+void sql_unlocked(std::string DeleteName)
+{
+    try
+    {
+        std::string filename = DeleteName;
+
+        // open MySQL
+        sql::mysql::MySQL_Driver *driver = sql::mysql::get_mysql_driver_instance();
+        sql::Connection *con = driver->connect("tcp://8.130.48.157:3306", "root", "abc.123");
+        con->setSchema("flypen");
+
+        sql::Statement *stmt = con->createStatement();
+
+        std::string DeleteQuery = "DELETE FROM file WHERE filename = " + DeleteName;
+
+        int rowsDelete = stmt->executeUpdate(DeleteQuery);
+
+        delete stmt;
+        delete con;
+    }
+    catch (sql::SQLException &e)
+    {
+        std::cerr << "SQL Exception: in sql_unlocked() function" << e.what() << std::endl;
+    }
+}
+
 // relate to chat
-void process(sql::PreparedStatement *readdatament, std::vector<std::string> s, sql::Connection *con)
+void process(sql::PreparedStatement *readDatament, std::vector<std::string> s, sql::Connection *con)
 {
     for (int i = 0; i < 2; i++)
     {
-        readdatament->setString(1, s[i]);
-        sql::ResultSet *resultSet = readdatament->executeQuery();
+        readDatament->setString(1, s[i]);
+        sql::ResultSet *resultSet = readDatament->executeQuery();
         std::string friendlist;
         if (resultSet->next())
         {
@@ -40,8 +66,8 @@ void sql_delete_operation(std::string sender, std::string receiver)
     s.push_back(receiver);
     std::string readdata = "SELECT friends FROM users WHERE username = ?";
 
-    sql::PreparedStatement *readdatament = con->prepareStatement(readdata);
-    process(readdatament, s, con);
+    sql::PreparedStatement *readDatament = con->prepareStatement(readdata);
+    process(readDatament, s, con);
 }
 
 void sql_process_request(std::string sender, std::string receiver, std::string attitude)
@@ -66,7 +92,7 @@ void sql_process_request(std::string sender, std::string receiver, std::string a
         req.erase(pos - 1, sender.length() + 1);
     else if (pos == 0)
         req.erase(pos, sender.length() + 1);
-        
+
     std::string updateQuery = "UPDATE users SET req = ? WHERE username = ?";
     sql::PreparedStatement *updateStatement = con->prepareStatement(updateQuery);
 

mysql.h

@@ -4,6 +4,7 @@
 #include <jdbc/mysql_connection.h>
 #include <json/json.h>
 
+void sql_unlocked(std::string DeleteName);
 void sql_add(std::string username, std::string passwd, int avatar);
 bool sql_check(std::string  , std::string passwd="@DEFAULT@"); 
 void sql_addhistory(std::string,std::string,std::string,std::string);

user_controller.cc

@@ -6,68 +6,88 @@
 #include "jwt_controller.h"
 #include "msg_controller.h"
 using namespace drogon;
+
 typedef std::string (*HandlerFunc)(const Json::Value&);
-void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, HandlerFunc handler){
+
+void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, HandlerFunc handler)
+{
     auto body = req->getBody();
-    Json::Value req_json,res_json;
+
+    Json::Value req_json, res_json;
     Json::Reader reader;
     std::string bodyStr(body);
-    if (!reader.parse(bodyStr, req_json)) {
+
+    if (!reader.parse(bodyStr, req_json)) 
+    {
         callback(HttpResponse::newHttpResponse());
         return;
     }
+
     Json::FastWriter writer;
     std::string msg = handler(req_json);
+
     res_json["msg"] = msg;
-    if (msg.find("Success")!= std::string::npos){
+    if (msg.find("Success")!= std::string::npos)
+    {
         res_json["token"] = jwtGen(req_json);
         res_json["username"] = req_json["username"].asString();
     }
+
     auto output = writer.write(res_json);
     auto res = HttpResponse::newHttpResponse();
+
     res->addHeader("Access-Control-Allow-Origin", "*");
     res->setBody(output);
+
     callback(res);
 }
-std::string sha256(const std::string str){
+
+std::string sha256(const std::string str)
+{
   unsigned char hash[SHA256_DIGEST_LENGTH];
 
   SHA256_CTX sha256;
+
   SHA256_Init(&sha256);
   SHA256_Update(&sha256, str.c_str(), str.size());
   SHA256_Final(hash, &sha256);
 
   std::stringstream ss;
 
-  for(int i = 0; i < SHA256_DIGEST_LENGTH; i++){
-    ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>( hash[i] );
-  }
+  for(int i = 0; i < SHA256_DIGEST_LENGTH; i++)
+    ss << std::hex << std::setw(2) << std::setfill('0') << static_cast<int>(hash[i]);
+  
   return ss.str();
 }
-std::string registerUser(const Json::Value& req_json) {
-    // std::cout<<"Receive Username : "<<req_json["username"].asString()<<std::endl;
-    // std::cout<<"Receive Passwd: "<<req_json["password"].asString()<<std::endl;
-    if (sql_check(req_json["username"].asString())){
+
+std::string registerUser(const Json::Value& req_json)
+ {
+    if (sql_check(req_json["username"].asString()))
+    {
         sql_add(req_json["username"].asString(), sha256(req_json["password"].asString()), req_json["avatar"].asInt());
         return "Sign up Success";
-    }else
-        return "User already exist";
+    }
+    return "User already exist";
 }
-std::string loginUser(const Json::Value& req_json) {
-    if (sql_check(req_json["username"].asString(), sha256(req_json["password"].asString()))){
+
+std::string loginUser(const Json::Value& req_json)
+ {
+    if (sql_check(req_json["username"].asString(), sha256(req_json["password"].asString())))
         return "Login Success";
-    }else
-        return "Login Failed";
+    return "Login Failed";
 }
-void avatar(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
+
+void avatar(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) 
+{
     auto res = HttpResponse::newHttpResponse();
     res->addHeader("Access-Control-Allow-Origin", "*");
-    if (jwtVerify(req)) {
+
+    if (jwtVerify(req)) 
+    {
         std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));
         set_avatar(receiver, stoi(req->getParameter("avatar")));
         res->setBody("Success");
-    } else {
+    } else 
         res->setBody("No Authorization");
-    }
     callback(res);
 }

user_controller.h

@@ -1,8 +1,11 @@
 #ifndef _USER_CONTROLLER_H_
 #define _USER_CONTROLLER_H_
+
 #include <drogon/drogon.h>
 using namespace drogon;
+
 typedef std::string (*HandlerFunc)(const Json::Value&);
+
 void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, HandlerFunc handler);
 std::string registerUser(const Json::Value& req_json);
 std::string loginUser(const Json::Value& req_json);