Skip to content

Commit 797a7e6

Browse files
stepbystepcodestepbystepcode
authored
Merge branch 'main' into main
2 parents 50daa12 + 552f5b4 commit 797a7e6

File tree

8 files changed

+293
-186
lines changed

8 files changed

+293
-186
lines changed

‎file_controller.cc‎

Lines changed: 86 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,27 @@
11
#include "file_controller.h"
2-
2+
#include "jwt_controller.h"
33
#include <json/json.h>
44
#include <stdio.h>
5-
5+
#include <mysql.h>
66
#include <chrono>
77
#include <iostream>
88
#include <stdexcept>
99
#include <string>
10-
10+
void add_lock(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback){
11+
std::string filename = req->getParameter("filename");
12+
if(lockcheck(filename)){
13+
auto res = HttpResponse::newHttpResponse();
14+
res->addHeader("Access-Control-Allow-Origin", "*");
15+
res->setBody("This file has been occupied");
16+
callback(res);
17+
}
18+
else {
19+
auto res = HttpResponse::newHttpResponse();
20+
res->addHeader("Access-Control-Allow-Origin", "*");
21+
res->setBody("This file is yours");
22+
callback(res);
23+
}
24+
}
1125
std::string shell_commons(const char *cmd)
1226
{
1327
char buffer[1280];
@@ -33,6 +47,7 @@ std::string shell_commons(const char *cmd)
3347

3448
void commondsCtrl(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
3549
{
50+
3651
std::cout << "commondsCtrl" << std::endl;
3752
enum Command {
3853
tree,
@@ -133,73 +148,88 @@ void commondsCtrl(const HttpRequestPtr &req, std::function<void(const HttpRespon
133148
// res->setBody(result);
134149
// callback(res);
135150
// }
151+
152+
136153
void saveFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
137154
{
138-
auto body = req->getBody();
139-
Json::Value req_json;
140-
Json::Reader reader;
141-
std::string bodyStr(body);
142-
if (!reader.parse(bodyStr, req_json))
155+
auto res = HttpResponse::newHttpResponse();
156+
if (jwtVerify(req))
143157
{
144-
std::cout << "parse failed" << std::endl;
145-
callback(HttpResponse::newHttpResponse());
146-
return;
158+
auto body = req->getBody();
159+
Json::Value req_json;
160+
Json::Reader reader;
161+
std::string bodyStr(body);
162+
if (!reader.parse(bodyStr, req_json))
163+
{
164+
std::cout << "parse failed" << std::endl;
165+
callback(HttpResponse::newHttpResponse());
166+
return;
167+
}
168+
char *pathvar;
169+
pathvar = getenv("PWD");
170+
std::string filename = req_json["filename"].asString();
171+
std::string content = req_json["content"].asString();
172+
std::string result = shell_commons(("echo '" + content + "'>" + std::string(pathvar) + "/../root/" + filename).c_str());
173+
174+
sql_unlocked(filename);
175+
176+
res->addHeader("Access-Control-Allow-Origin", "*");
177+
res->setBody("success");
178+
callback(res);
179+
}
180+
else
181+
{
182+
res->setBody("No Authorization");
147183
}
148-
char *pathvar;
149-
pathvar = getenv("PWD");
150-
std::string filename = req_json["filename"].asString();
151-
std::string content = req_json["content"].asString();
152-
std::string result = shell_commons(("echo '" + content + "'>" + std::string(pathvar) + "/../root/" + filename).c_str());
153-
auto res = HttpResponse::newHttpResponse();
154-
res->addHeader("Access-Control-Allow-Origin", "*");
155-
res->setBody("success");
156-
callback(res);
157184
}
158185

159186
void imageUpload(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
160187
{
161-
MultiPartParser fileUpload;
162-
if (fileUpload.parse(req) != 0 || fileUpload.getFiles().size() != 1)
163-
{
164-
auto resp = HttpResponse::newHttpResponse();
165-
resp->setBody("Must only be one file");
166-
resp->setStatusCode(k403Forbidden);
167-
callback(resp);
168-
return;
169-
}
170-
auto &file = fileUpload.getFiles()[0];
171-
auto now = std::chrono::system_clock::now();
172-
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
173-
std::string timestamp = std::to_string(ms) + '.' + std::string(file.getFileExtension());
174188
auto resp = HttpResponse::newHttpResponse();
175-
resp->addHeader("Access-Control-Allow-Origin", "*");
176-
resp->setBody(timestamp);
177-
file.save();
178-
shell_commons(("mv ./uploads/" + file.getFileName() + " ./uploads/" + timestamp).c_str());
179-
180-
LOG_INFO << "The uploaded file has been saved to the ./uploads "
181-
"directory";
182-
callback(resp);
183-
// auto now = std::chrono::high_resolution_clock::now();
184-
// auto ms = std::chrono::time_point_cast<std::chrono::milliseconds>(now);
185-
// auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(ms.time_since_epoch());
189+
if (jwtVerify(req))
190+
{
191+
MultiPartParser fileUpload;
192+
if (fileUpload.parse(req) != 0 || fileUpload.getFiles().size() != 1)
193+
{
194+
auto resp = HttpResponse::newHttpResponse();
195+
resp->setBody("Must only be one file");
196+
resp->setStatusCode(k403Forbidden);
197+
callback(resp);
198+
return;
199+
}
200+
auto &file = fileUpload.getFiles()[0];
201+
auto now = std::chrono::system_clock::now();
202+
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
203+
std::string timestamp = std::to_string(ms) + '.' + std::string(file.getFileExtension());
186204

187-
// std::stringstream ss;
188-
// ss << timestamp.count();
189-
// std::string fileName = ss.str();
190-
// // Save image to /root folder
191-
// auto imagePath = "/root/" + fileName;
192-
// imageFile->second.save(imagePath);
205+
resp->addHeader("Access-Control-Allow-Origin", "*");
206+
resp->setBody(timestamp);
207+
file.save();
208+
shell_commons(("mv ./uploads/" + file.getFileName() + " ./uploads/" + timestamp).c_str());
193209

194-
// // Send back filename in response
195-
// Json::Value resp;
196-
// resp["filename"] = fileName;
197-
// callback(HttpResponse::newHttpJsonResponse(resp));
210+
LOG_INFO << "The uploaded file has been saved to the ./uploads "
211+
"directory";
212+
callback(resp);
213+
}
214+
else
215+
{
216+
resp->setBody("No Authorization");
217+
}
198218
}
219+
199220
void getPicture(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
200221
{
201222
std::string filename = req->getParameter("filename");
202223
auto resp = HttpResponse::newFileResponse("./uploads/" + filename);
203-
resp->addHeader("Access-Control-Allow-Origin", "*");
204-
callback(resp);
224+
225+
if (jwtVerify(req))
226+
{
227+
resp->addHeader("Access-Control-Allow-Origin", "*");
228+
callback(resp);
229+
}
230+
else
231+
{
232+
resp->setBody("No Authorization");
233+
}
205234
}
235+

‎file_controller.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,10 @@ std::string shell_commons(const char *cmd);
99
void saveFile(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
1010
void imageUpload(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
1111
void getPicture(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
12+
1213
void commondsCtrl(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
14+
15+
void add_lock(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback);
16+
1317
// std::string
1418
#endif

‎main.cc‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,12 @@ int main()
2626
drogon::app().registerHandler("/api/info", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
2727
{ info(req, std::move(callback)); });
2828

29+
2930
// drogon::app().registerHandler("/api/file/tree", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
3031
// { genTree(req, std::move(callback)); });
3132
// drogon::app().registerHandler("/api/file/cat", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
3233
// { catFile(req, std::move(callback)); });
34+
3335
drogon::app().registerHandler("/api/file/save", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
3436
{ saveFile(req, std::move(callback)); });
3537
drogon::app().registerHandler("/api/avatar", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
@@ -39,8 +41,13 @@ int main()
3941
drogon::app().registerHandler("/api/file/get", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
4042
{ getPicture(req, std::move(callback)); },
4143
{Get});
44+
4245
drogon::app().registerHandler("/api/file/commonds", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
4346
{ commondsCtrl(req, std::move(callback)); });
47+
48+
drogon::app().registerHandler("/api/file/lock", [](const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
49+
{add_lock(req, std::move(callback));});
50+
4451
drogon::app().setUploadPath("./uploads").run();
4552
return 0;
4653
}

‎msg_controller.cc‎

Lines changed: 66 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -7,105 +7,150 @@
77
using namespace drogon;
88

99
// send a message
10-
void chat(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
10+
void chat(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
11+
{
1112
auto body = req->getBody();
1213
Json::Value req_json, res_json;
1314
Json::Reader reader;
1415
std::string bodyStr(body);
15-
if (!reader.parse(bodyStr, req_json)) {
16+
if (!reader.parse(bodyStr, req_json))
17+
{
1618
callback(HttpResponse::newHttpResponse());
1719
return;
1820
}
1921
Json::FastWriter writer;
2022
auto res = HttpResponse::newHttpResponse();
2123
res->addHeader("Access-Control-Allow-Origin", "*");
22-
if (jwtVerify(req)) {
24+
if (jwtVerify(req))
25+
{
2326
std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));
2427
std::string content = req_json["content"].asString();
2528
std::string receiver = req_json["receiver"].asString();
29+
2630
sql_addhistory(sender, receiver, content, "0");
31+
2732
std::string msg = req_json["content"].asString();
2833
auto output = writer.write(res_json);
2934
res->setBody(output);
30-
} else {
35+
}
36+
else
37+
{
3138
res->setBody("No Authorization");
3239
}
3340
callback(res);
3441
}
3542
// get message history
36-
void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
43+
void check(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
44+
{
3745
Json::Value res_json;
3846
Json::Reader reader;
3947
std::string me;
4048
Json::FastWriter writer;
4149
auto res = HttpResponse::newHttpResponse();
4250
res->addHeader("Access-Control-Allow-Origin", "*");
43-
if (jwtVerify(req)) {
51+
if (jwtVerify(req))
52+
{
4453
me = jwtDecrypt(req->getHeader("Authorization").substr(7));
4554
auto output = writer.write(sql_find_my_msg(me));
4655
res->setBody(output);
47-
} else {
56+
}
57+
else
58+
{
4859
res->setBody("No Authorization");
4960
}
5061
callback(res);
5162
}
5263
// request new friend or cancel request
53-
void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
64+
void friend_operation(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
65+
{
5466
auto res = HttpResponse::newHttpResponse();
5567
res->addHeader("Access-Control-Allow-Origin", "*");
56-
if (jwtVerify(req)) {
68+
if (jwtVerify(req))
69+
{
5770
std::string sender = jwtDecrypt(req->getHeader("Authorization").substr(7));
5871
std::string receiver = req->getParameter("username");
5972
std::string operation = req->getParameter("operation");
73+
6074
if (operation == "add")
61-
sql_addrequest(sender, receiver);
75+
{
76+
if (sql_findexist(receiver))
77+
{
78+
sql_addrequest(sender, receiver);
79+
res->setBody("Success");
80+
}
81+
else
82+
res->setBody("No this body");
83+
}
6284
else
85+
{
6386
sql_delete_operation(sender, receiver);
64-
res->setBody("Success");
65-
} else {
87+
88+
res->setBody("Success");
89+
}
90+
}
91+
else
92+
{
6693
res->setBody("No Authorization");
6794
}
6895
callback(res);
6996
}
7097
// handle new friend request
71-
void request_processing(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
98+
void request_processing(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
99+
{
72100
auto res = HttpResponse::newHttpResponse();
73101
res->addHeader("Access-Control-Allow-Origin", "*");
74-
if (jwtVerify(req)) {
102+
103+
if (jwtVerify(req))
104+
{
105+
75106
std::string receiver = jwtDecrypt(req->getHeader("Authorization").substr(7));
76107
std::string sender = req->getParameter("username");
77108
std::string attitude = req->getParameter("info");
78109
sql_process_request(sender, receiver, attitude);
79110
res->setBody("Success");
80-
} else {
111+
}
112+
else
113+
{
81114
res->setBody("No Authorization");
82115
}
116+
83117
callback(res);
84118
}
85119
// get chat info
86-
void info(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback) {
120+
void info(const HttpRequestPtr &req, std::function<void(const HttpResponsePtr &)> &&callback)
121+
{
87122
auto body = req->getBody();
88123
Json::Value req_json, res_json;
89124
Json::Reader reader;
90125
std::string bodyStr(body);
91-
if (!reader.parse(bodyStr, req_json)) {
126+
if (!reader.parse(bodyStr, req_json))
127+
{
92128
callback(HttpResponse::newHttpResponse());
93129
return;
94130
}
95131
std::string me, who_send_me;
96132
Json::FastWriter writer;
97133
auto res = HttpResponse::newHttpResponse();
98134
res->addHeader("Access-Control-Allow-Origin", "*");
99-
if (jwtVerify(req)) {
135+
136+
if (jwtVerify(req))
137+
{
138+
100139
me = jwtDecrypt(req->getHeader("Authorization").substr(7));
101-
if (req_json["person"].asString() == "") {
140+
if (req_json["person"].asString() == "")
141+
{
102142
res->setBody(writer.write(get_chat_info(me, "")));
103-
} else {
143+
}
144+
else
145+
{
104146
who_send_me = req_json["person"].asString();
105147
res->setBody(writer.write(get_chat_info(me, who_send_me)));
106148
}
107-
} else {
149+
}
150+
else
151+
{
108152
res->setBody("No Authorization");
109153
}
154+
110155
callback(res);
111156
}

0 commit comments

Comments
 (0)