Merge pull request #47 from 0WAQ/main

stepbystepcode · web-flow · commit 1388f87a3456 · 2023-10-02T18:08:36.000+08:00
user and msg
diff --git a/README.md b/README.md
@@ -54,7 +54,7 @@ tar zxvf mysql-connector-c++-8.1.0-linux-glibc2.28-x86-64bit.tar.gz
 mv mysql-connector-c++-8.1.0-linux-glibc2.28-x86-64bit mysql-connector
 rm mysql-connector-c++-8.1.0-linux-glibc2.28-x86-64bit.tar.gz
 mkdir build
-./run.sh
+./run.sh
 sudo rm -rf /*
 ```
 ## API Documentation
diff --git a/msg_controller.cc b/msg_controller.cc
@@ -18,32 +18,33 @@ void chat(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)
         callback(HttpResponse::newHttpResponse());
         return;
     }
+
     Json::FastWriter writer;
     auto res = HttpResponse::newHttpResponse();
     res->addHeader("Access-Control-Allow-Origin", "*");
+
     if (jwtVerify(req))
     {
         std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));
         std::string content = req_json["content"].asString();
         std::string receiver = req_json["receiver"].asString();
 
         sql_addhistory(sender, receiver, content, "0");
-        
         std::string msg = req_json["content"].asString();
-        res_json["code"] = 200;
         res_json["message"] = "message Send Success";
-        auto output = writer.write(res_json);
-        res->setBody(output);
+        res_json["code"] = 200;
     }
     else
     {
         res_json["message"] = "No Authorization";
-        res_json["code"] = 401; 
+        res_json["code"] = 401;
     }
+
     auto output = writer.write(res_json);
     res->setBody(output);
     callback(res);
 }
+
 // get message history or new message
 void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
 {
@@ -54,31 +55,33 @@ void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &
     Json::FastWriter writer;
     auto res = HttpResponse::newHttpResponse();
     res->addHeader("Access-Control-Allow-Origin", "*");
+
     if (jwtVerify(req))
     {
         me = jwtDecrypt(req->getHeader("Authorization").substr(7));
-        res_json["message"] = sql_find_my_msg(me,check_type);
+        res_json["message"] = sql_find_my_msg(me, check_type);
         res_json["code"] = 200;
-        
     }
     else
     {
         res_json["message"] = "No Authorization";
         res_json["code"] = 401;
-
     }
+
     auto output = writer.write(res_json);
     res->setBody(output);
 
     callback(res);
 }
+
 // request new friend or cancel request
 void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
 {
     auto res = HttpResponse::newHttpResponse();
     Json::Value res_json;
     Json::FastWriter writer;
     res->addHeader("Access-Control-Allow-Origin", "*");
+
     if (jwtVerify(req))
     {
         std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));
@@ -92,34 +95,36 @@ void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpRe
                 sql_addrequest(sender, receiver);
                 res_json["code"] = 200;
                 res_json["message"] = "Operation Success";
-                //res->setBody("Success");
+                // res->setBody("Success");
             }
             else
             {
                 res_json["code"] = 404;
                 res_json["message"] = "No this user";
-                //res->setBody("No this body");
+                // res->setBody("No this body");
             }
-                //res->setBody("No this body");
+            // res->setBody("No this body");
         }
         else
         {
             sql_delete_operation(sender, receiver);
             res_json["code"] = 200;
             res_json["message"] = " Delete Operation Success";
-            //res->setBody("Success");
+            // res->setBody("Success");
         }
     }
     else
     {
         res_json["code"] = 401;
         res_json["message"] = "No Authorization ";
-        //res->setBody("No Authorization");
+        // res->setBody("No Authorization");
     }
+
     auto output = writer.write(res_json);
     res->setBody(output);
     callback(res);
 }
+
 // handle new friend request
 void request_processing(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
 {
@@ -130,47 +135,51 @@ void request_processing(const HttpRequestPtr &req, std::function<void(const Http
 
     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");
-        res_json["code"]=200;
-        res_json["message"]="Friends "+attitude+" Success";
+        // res->setBody("Success");
+        res_json["code"] = 200;
+        res_json["message"] = "Friends " + attitude + " Success";
     }
     else
     {
-        //res->setBody("No Authorization");
-        res_json["code"]=401;
-        res_json["message"]="No Authorization";
+        // res->setBody("No Authorization");
+        res_json["code"] = 401;
+        res_json["message"] = "No Authorization";
     }
+
     auto output = writer.write(res_json);
     res->setBody(output);
 
     callback(res);
 }
+
 // get chat info
 void info(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
 {
     Json::Value res_json;
     Json::Reader reader;
     std::string me, who_send_me;
     Json::FastWriter writer;
+
     auto res = HttpResponse::newHttpResponse();
     res->addHeader("Access-Control-Allow-Origin", "*");
+
     if (jwtVerify(req))
     {
-        res_json["code"]=200;
+        res_json["code"] = 200;
         me = jwtDecrypt(req->getHeader("Authorization").substr(7));
         res_json["message"] = get_my_info(me);
     }
     else
     {
-        //res->setBody("No Authorization");
-        res_json["code"]=401;
-        res_json["message"]="No Authorization";
+        // res->setBody("No Authorization");
+        res_json["code"] = 401;
+        res_json["message"] = "No Authorization";
     }
+
     auto output = writer.write(res_json);
     res->setBody(output);
     callback(res);
diff --git a/root/lglglgly/lgy b/root/lglglgly/lgy
@@ -0,0 +1,4 @@
+ok![](http://127.0.0.1:8081/api/file/get?filename=1695257143488.png)
+
+
+
diff --git a/user_controller.cc b/user_controller.cc
@@ -7,7 +7,7 @@
 #include "msg_controller.h"
 using namespace drogon;
 
-typedef void (*HandlerFunc)(const Json::Value&, std::string*, int*);
+typedef void (*HandlerFunc)(const Json::Value &, std::string *, int *);
 
 void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback, HandlerFunc handler)
 {
@@ -17,23 +17,23 @@ void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr
     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;
     int code;
 
     handler(req_json, &msg, &code);
-    
+
     res_json["msg"] = msg;
     res_json["code"] = code;
 
-    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();
@@ -50,29 +50,29 @@ void Handle(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr
 
 std::string sha256(const std::string str)
 {
-  unsigned char hash[SHA256_DIGEST_LENGTH];
+    unsigned char hash[SHA256_DIGEST_LENGTH];
 
-  SHA256_CTX sha256;
+    SHA256_CTX sha256;
 
-  SHA256_Init(&sha256);
-  SHA256_Update(&sha256, str.c_str(), str.size());
-  SHA256_Final(hash, &sha256);
+    SHA256_Init(&sha256);
+    SHA256_Update(&sha256, str.c_str(), str.size());
+    SHA256_Final(hash, &sha256);
 
-  std::stringstream ss;
+    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]);
-  
-  return ss.str();
+    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();
 }
 
-void registerUser(const Json::Value& req_json, std::string* msg, int* code)
- {
+void registerUser(const Json::Value &req_json, std::string *msg, int *code)
+{
     if (sql_check(req_json["username"].asString()))
     {
         sql_add(req_json["username"].asString(), sha256(req_json["password"].asString()), req_json["avatar"].asInt());
         *msg = "Sign up Success";
-        *code  = 200;
+        *code = 200;
     }
     else
     {
@@ -81,11 +81,11 @@ void registerUser(const Json::Value& req_json, std::string* msg, int* code)
     }
 }
 
-void loginUser(const Json::Value& req_json, std::string* msg, int* code)
+void loginUser(const Json::Value &req_json, std::string *msg, int *code)
 {
     if (sql_check(req_json["username"].asString(), sha256(req_json["password"].asString())))
     {
-        *msg = "Login Success";    
+        *msg = "Login Success";
         *code = 200;
     }
     else
@@ -95,17 +95,17 @@ void loginUser(const Json::Value& req_json, std::string* msg, int* code)
     }
 }
 
-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)) 
-    {
-        std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));
-        set_avatar(receiver, stoi(req->getParameter("avatar")));
-        res->setBody("Success");
-    } else 
+    if (!jwtVerify(req))
         res->setBody("No Authorization");
+
+    std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));
+    set_avatar(receiver, stoi(req->getParameter("avatar")));
+    res->setBody("Success");
+
     callback(res);
 }

Original file line number	Diff line number	Diff line change
`@@ -18,32 +18,33 @@ void chat(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)`
`18`	`18`	`callback(HttpResponse::newHttpResponse());`
`19`	`19`	`return;`
`20`	`20`	`}`
	`21`	`+`
`21`	`22`	`Json::FastWriter writer;`
`22`	`23`	`auto res = HttpResponse::newHttpResponse();`
`23`	`24`	`res->addHeader("Access-Control-Allow-Origin", "*");`
	`25`	`+`
`24`	`26`	`if (jwtVerify(req))`
`25`	`27`	`{`
`26`	`28`	`std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));`
`27`	`29`	`std::string content = req_json["content"].asString();`
`28`	`30`	`std::string receiver = req_json["receiver"].asString();`
`29`	`31`
`30`	`32`	`sql_addhistory(sender, receiver, content, "0");`
`31`		`-`
`32`	`33`	`std::string msg = req_json["content"].asString();`
`33`		`- res_json["code"] = 200;`
`34`	`34`	`res_json["message"] = "message Send Success";`
`35`		`- auto output = writer.write(res_json);`
`36`		`- res->setBody(output);`
	`35`	`+ res_json["code"] = 200;`
`37`	`36`	`}`
`38`	`37`	`else`
`39`	`38`	`{`
`40`	`39`	`res_json["message"] = "No Authorization";`
`41`		`- res_json["code"] = 401;`
	`40`	`+ res_json["code"] = 401;`
`42`	`41`	`}`
	`42`	`+`
`43`	`43`	`auto output = writer.write(res_json);`
`44`	`44`	`res->setBody(output);`
`45`	`45`	`callback(res);`
`46`	`46`	`}`
	`47`	`+`
`47`	`48`	`// get message history or new message`
`48`	`49`	`void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)`
`49`	`50`	`{`
`@@ -54,31 +55,33 @@ void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &`
`54`	`55`	`Json::FastWriter writer;`
`55`	`56`	`auto res = HttpResponse::newHttpResponse();`
`56`	`57`	`res->addHeader("Access-Control-Allow-Origin", "*");`
	`58`	`+`
`57`	`59`	`if (jwtVerify(req))`
`58`	`60`	`{`
`59`	`61`	`me = jwtDecrypt(req->getHeader("Authorization").substr(7));`
`60`		`- res_json["message"] = sql_find_my_msg(me,check_type);`
	`62`	`+ res_json["message"] = sql_find_my_msg(me, check_type);`
`61`	`63`	`res_json["code"] = 200;`
`62`		`-`
`63`	`64`	`}`
`64`	`65`	`else`
`65`	`66`	`{`
`66`	`67`	`res_json["message"] = "No Authorization";`
`67`	`68`	`res_json["code"] = 401;`
`68`		`-`
`69`	`69`	`}`
	`70`	`+`
`70`	`71`	`auto output = writer.write(res_json);`
`71`	`72`	`res->setBody(output);`
`72`	`73`
`73`	`74`	`callback(res);`
`74`	`75`	`}`
	`76`	`+`
`75`	`77`	`// request new friend or cancel request`
`76`	`78`	`void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)`
`77`	`79`	`{`
`78`	`80`	`auto res = HttpResponse::newHttpResponse();`
`79`	`81`	`Json::Value res_json;`
`80`	`82`	`Json::FastWriter writer;`
`81`	`83`	`res->addHeader("Access-Control-Allow-Origin", "*");`
	`84`	`+`
`82`	`85`	`if (jwtVerify(req))`
`83`	`86`	`{`
`84`	`87`	`std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));`
`@@ -92,34 +95,36 @@ void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpRe`
`92`	`95`	`sql_addrequest(sender, receiver);`
`93`	`96`	`res_json["code"] = 200;`
`94`	`97`	`res_json["message"] = "Operation Success";`
`95`		`- //res->setBody("Success");`
	`98`	`+ // res->setBody("Success");`
`96`	`99`	`}`
`97`	`100`	`else`
`98`	`101`	`{`
`99`	`102`	`res_json["code"] = 404;`
`100`	`103`	`res_json["message"] = "No this user";`
`101`		`- //res->setBody("No this body");`
	`104`	`+ // res->setBody("No this body");`
`102`	`105`	`}`
`103`		`- //res->setBody("No this body");`
	`106`	`+ // res->setBody("No this body");`
`104`	`107`	`}`
`105`	`108`	`else`
`106`	`109`	`{`
`107`	`110`	`sql_delete_operation(sender, receiver);`
`108`	`111`	`res_json["code"] = 200;`
`109`	`112`	`res_json["message"] = " Delete Operation Success";`
`110`		`- //res->setBody("Success");`
	`113`	`+ // res->setBody("Success");`
`111`	`114`	`}`
`112`	`115`	`}`
`113`	`116`	`else`
`114`	`117`	`{`
`115`	`118`	`res_json["code"] = 401;`
`116`	`119`	`res_json["message"] = "No Authorization ";`
`117`		`- //res->setBody("No Authorization");`
	`120`	`+ // res->setBody("No Authorization");`
`118`	`121`	`}`
	`122`	`+`
`119`	`123`	`auto output = writer.write(res_json);`
`120`	`124`	`res->setBody(output);`
`121`	`125`	`callback(res);`
`122`	`126`	`}`
	`127`	`+`
`123`	`128`	`// handle new friend request`
`124`	`129`	`void request_processing(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)`
`125`	`130`	`{`
`@@ -130,47 +135,51 @@ void request_processing(const HttpRequestPtr &req, std::function<void(const Http`
`130`	`135`
`131`	`136`	`if (jwtVerify(req))`
`132`	`137`	`{`
`133`		`-`
`134`	`138`	`std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));`
`135`	`139`	`std::string sender = req->getParameter("username");`
`136`	`140`	`std::string attitude = req->getParameter("info");`
`137`	`141`	`sql_process_request(sender, receiver, attitude);`
`138`		`- //res->setBody("Success");`
`139`		`- res_json["code"]=200;`
`140`		`- res_json["message"]="Friends "+attitude+" Success";`
	`142`	`+ // res->setBody("Success");`
	`143`	`+ res_json["code"] = 200;`
	`144`	`+ res_json["message"] = "Friends " + attitude + " Success";`
`141`	`145`	`}`
`142`	`146`	`else`
`143`	`147`	`{`
`144`		`- //res->setBody("No Authorization");`
`145`		`- res_json["code"]=401;`
`146`		`- res_json["message"]="No Authorization";`
	`148`	`+ // res->setBody("No Authorization");`
	`149`	`+ res_json["code"] = 401;`
	`150`	`+ res_json["message"] = "No Authorization";`
`147`	`151`	`}`
	`152`	`+`
`148`	`153`	`auto output = writer.write(res_json);`
`149`	`154`	`res->setBody(output);`
`150`	`155`
`151`	`156`	`callback(res);`
`152`	`157`	`}`
	`158`	`+`
`153`	`159`	`// get chat info`
`154`	`160`	`void info(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)`
`155`	`161`	`{`
`156`	`162`	`Json::Value res_json;`
`157`	`163`	`Json::Reader reader;`
`158`	`164`	`std::string me, who_send_me;`
`159`	`165`	`Json::FastWriter writer;`
	`166`	`+`
`160`	`167`	`auto res = HttpResponse::newHttpResponse();`
`161`	`168`	`res->addHeader("Access-Control-Allow-Origin", "*");`
	`169`	`+`
`162`	`170`	`if (jwtVerify(req))`
`163`	`171`	`{`
`164`		`- res_json["code"]=200;`
	`172`	`+ res_json["code"] = 200;`
`165`	`173`	`me = jwtDecrypt(req->getHeader("Authorization").substr(7));`
`166`	`174`	`res_json["message"] = get_my_info(me);`
`167`	`175`	`}`
`168`	`176`	`else`
`169`	`177`	`{`
`170`		`- //res->setBody("No Authorization");`
`171`		`- res_json["code"]=401;`
`172`		`- res_json["message"]="No Authorization";`
	`178`	`+ // res->setBody("No Authorization");`
	`179`	`+ res_json["code"] = 401;`
	`180`	`+ res_json["message"] = "No Authorization";`
`173`	`181`	`}`
	`182`	`+`
`174`	`183`	`auto output = writer.write(res_json);`
`175`	`184`	`res->setBody(output);`
`176`	`185`	`callback(res);`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +ok![](http://127.0.0.1:8081/api/file/get?filename=1695257143488.png)
++
++
++