401 lines
17 KiB
C++
401 lines
17 KiB
C++
#include "Application.h"
|
|
#include "Database/Session.h"
|
|
#include "DateTime.h"
|
|
#include "HttpSession.h"
|
|
#include "IoContext.h"
|
|
#include "Nng/SocketAisoWrapper.h"
|
|
#include "ServiceLogic.h"
|
|
#include "ServiceManager.h"
|
|
#include "SystemUsage.h"
|
|
#include "WeChatContext/CorporationContext.h"
|
|
#include <Wt/Dbo/Json.h>
|
|
#include <boost/json/object.hpp>
|
|
#include <boost/json/serialize.hpp>
|
|
#include <boost/stacktrace.hpp>
|
|
|
|
constexpr auto IpcUrl = "ipc:///tmp/nng_ipc_server";
|
|
|
|
static std::vector<std::string> urlFilter = {
|
|
"/",
|
|
"/search",
|
|
"/LoginPage",
|
|
"/MessageBoard",
|
|
"/我的笔记",
|
|
"/我的笔记/",
|
|
"/我的博客",
|
|
};
|
|
|
|
Application::Application(const std::string &path)
|
|
: ApplicationSettings(path), m_router{std::make_shared<boost::urls::router<RequestHandler>>()} {
|
|
|
|
// clang-format off
|
|
m_router->insert("/{path*}",[this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
boost::urls::url_view view(request.target());
|
|
auto target = view.path();
|
|
LOG(info) << target;
|
|
if (target.find("..") != boost::beast::string_view::npos) {
|
|
session.reply(ServiceLogic::badRequest(request, "Illegal request-target"));
|
|
return;
|
|
}
|
|
std::string path = ResponseUtility::pathCat(getDocumentRoot(), target);
|
|
if (target.back() == '/') path.append("index.html");
|
|
if (std::filesystem::is_directory(path)) path.append("/index.html");
|
|
boost::beast::error_code ec;
|
|
http::file_body::value_type body;
|
|
body.open(path.c_str(), boost::beast::file_mode::scan, ec);
|
|
if (ec == boost::beast::errc::no_such_file_or_directory) {
|
|
std::ostringstream oss;
|
|
oss << "The resource '" << target << "' was not found.";
|
|
LOG(error) << oss.str();
|
|
session.errorReply(request, http::status::not_found, oss.str());
|
|
return;
|
|
} else if (ec) {
|
|
session.reply(ServiceLogic::serverError(request, ec.message()));
|
|
return;
|
|
}
|
|
auto const size = body.size();
|
|
http::response<http::file_body> res{std::piecewise_construct, std::make_tuple(std::move(body)),
|
|
std::make_tuple(http::status::ok, request.version())};
|
|
res.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
res.set(http::field::content_type, ResponseUtility::mimeType(path));
|
|
res.content_length(size);
|
|
res.keep_alive(request.keep_alive());
|
|
session.reply(std::move(res));
|
|
});
|
|
|
|
m_router->insert("/wechat/{session*}",[this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
ServiceLogic::onWechat(shared_from_this(), request,
|
|
[&session](auto &&response) { session.reply(std::move(response)); });
|
|
});
|
|
|
|
m_router->insert("/api/v1/tasklist", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
auto database = Database::session();
|
|
Tasks tasks = database->find<Task>();
|
|
std::ostringstream oss;
|
|
Wt::Dbo::jsonSerialize(tasks, oss);
|
|
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = oss.str();
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
|
|
m_router->insert("/api/v1/task/add", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) mutable {
|
|
using namespace boost::beast;
|
|
using namespace std::chrono;
|
|
LOG(info) << "add task: " << request.body();
|
|
auto rootJson = boost::json::parse(request.body());
|
|
auto &root = rootJson.as_object();
|
|
|
|
std::string content;
|
|
if (root.contains("content")) {
|
|
content = root.at("content").as_string();
|
|
}
|
|
auto database = Database::session();;
|
|
auto task = std::make_unique<Task>();
|
|
task->createTime = system_clock::time_point(seconds(root.at("createTime").as_int64()));
|
|
task->content = content;
|
|
task->comment = std::string(root.at("comment").as_string());
|
|
auto t = database->add(std::move(task));
|
|
Wt::Dbo::ptr<Task> parent = database->find<Task>("where id=?").bind(root.at("parentId").as_int64());
|
|
if (parent) {
|
|
parent.modify()->children.insert(t);
|
|
}
|
|
boost::json::object reply;
|
|
reply["status"] = 0;
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = boost::json::serialize(reply);
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
|
|
m_router->insert("/api/v1/task/delete/{id}", [this](HttpSession &session, const Request &request,const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
LOG(info) << "delete task: " << matches.at("id");
|
|
auto database = Database::session();;
|
|
Wt::Dbo::ptr<Task> joe = database->find<Task>().where("id = ?").bind(std::stoi(matches.at("id")));
|
|
int status = -1;
|
|
if (joe) {
|
|
joe.remove();
|
|
status = 0;
|
|
}
|
|
boost::json::object reply;
|
|
reply["status"] = status;
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = boost::json::serialize(reply);
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
|
|
m_router->insert("/trigger-ci.hook", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
LOG(info) << "webhook: " << request;
|
|
session.reply(ServiceLogic::make_200<boost::beast::http::string_body>(request, "Main page\n", "text/html"));
|
|
});
|
|
|
|
m_router->insert("/notify", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
auto corp = Amass::Singleton<CorporationContext>::instance();
|
|
corp->notify(request);
|
|
session.reply(
|
|
ServiceLogic::make_200<boost::beast::http::string_body>(request, "notify successed.\n", "text/html"));
|
|
});
|
|
|
|
m_router->insert("/api/v1/visit_analysis", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
auto rootJson = boost::json::parse(request.body());
|
|
auto &root = rootJson.as_object();
|
|
std::string url;
|
|
if (root.contains("url")) {
|
|
url = root["url"].as_string();
|
|
}
|
|
auto database = Database::session();
|
|
if (std::filesystem::exists("amass_blog" + url) && url.find("/我的博客/page") != 0) {
|
|
if (url.size() > 1 && url.back() == '/') {
|
|
url.pop_back();
|
|
}
|
|
Wt::Dbo::Transaction transaction(*database);
|
|
auto record = std::make_unique<VisitorRecord>();
|
|
record->time = std::chrono::system_clock::now();
|
|
record->url = url;
|
|
if (root.contains("visitor_uuid")) {
|
|
record->visitorUuid = root["visitor_uuid"].as_string();
|
|
}
|
|
std::string userAgent;
|
|
if (root.contains("user_agent")) {
|
|
record->userAgent = root["user_agent"].as_string();
|
|
}
|
|
database->add(std::move(record));
|
|
}
|
|
Wt::Dbo::Transaction transaction(*database);
|
|
boost::json::object reply;
|
|
reply["page_view_count"] = database->query<int>("SELECT COUNT(*) FROM visitor_record WHERE url = ?").bind(std::string(url));
|
|
reply["unique_visitor_count"] = database->query<int>("SELECT COUNT(DISTINCT visitor_uuid) FROM visitor_record WHERE url = ?").bind(std::string(url));
|
|
reply["site_page_view_count"] = database->query<int>("SELECT COUNT(*) FROM visitor_record");
|
|
reply["site_unique_visitor_count"] = database->query<int>("SELECT COUNT(DISTINCT visitor_uuid) FROM visitor_record");
|
|
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = boost::json::serialize(reply);
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
|
|
m_router->insert("/api/v1/most_viewed_urls", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
int size = 5;
|
|
std::error_code error;
|
|
if (!request.body().empty()) {
|
|
auto rootJson = boost::json::parse(request.body(), error);
|
|
if (error) {
|
|
LOG(info) << "<" << request.body() << "> parse json error: " << error.message();
|
|
} else {
|
|
auto &root = rootJson.as_object();
|
|
if (root.contains("size")) {
|
|
size = root.at("size").as_int64();
|
|
}
|
|
}
|
|
}
|
|
auto database = Database::session();
|
|
Wt::Dbo::Transaction transaction(*database);
|
|
Wt::Dbo::collection<std::tuple<std::string, int>> query = database->query<std::tuple<std::string, int>>("SELECT url, COUNT(*) as count FROM visitor_record GROUP BY url ORDER BY count DESC LIMIT ?").bind(static_cast<int> (size+urlFilter.size()));
|
|
boost::json::array reply;
|
|
int index = 0;
|
|
for (auto &[url, count] : query) {
|
|
if (std::find(urlFilter.cbegin(), urlFilter.cend(),url) != urlFilter.cend()) continue;
|
|
boost::json::object object;
|
|
object["url"] = url;
|
|
object["count"] = count;
|
|
reply.push_back(std::move(object));
|
|
index++;
|
|
if(index>=size)break;
|
|
}
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = boost::json::serialize(reply);
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
|
|
m_router->insert("/api/v1/latest_viewed_urls", [this](HttpSession &session, const Request &request, const boost::urls::matches &matches) {
|
|
using namespace boost::beast;
|
|
using namespace std::chrono;
|
|
int size = 5;
|
|
std::error_code error;
|
|
if (!request.body().empty()) {
|
|
auto rootJson = boost::json::parse(request.body(), error);
|
|
if (error) {
|
|
LOG(info) << "<" << request.body() << "> parse json error: " << error.message();
|
|
} else {
|
|
auto &root = rootJson.as_object();
|
|
if (root.contains("size")) {
|
|
size = root.at("size").as_int64();
|
|
}
|
|
}
|
|
}
|
|
auto database = Database::session();
|
|
Wt::Dbo::Transaction transaction(*database);
|
|
using Reslut = std::tuple<std::string, system_clock::time_point>;
|
|
Wt::Dbo::collection<Reslut> query = database->query<Reslut>("SELECT url, MAX(time) FROM visitor_record GROUP BY url ORDER BY MAX(time) DESC LIMIT ?").bind(static_cast<int> (size+urlFilter.size()));
|
|
boost::json::array reply;
|
|
int index=0;
|
|
for (auto &[url, time] : query) {
|
|
if (std::find(urlFilter.cbegin(), urlFilter.cend(),url) != urlFilter.cend()) continue;
|
|
boost::json::object object;
|
|
object["url"] = url;
|
|
object["time"] = duration_cast<seconds>(time.time_since_epoch()).count();
|
|
reply.push_back(std::move(object));
|
|
index++;
|
|
if(index>=size)break;
|
|
}
|
|
http::response<boost::beast::http::string_body> s{boost::beast::http::status::ok, request.version()};
|
|
s.set(http::field::server, BOOST_BEAST_VERSION_STRING);
|
|
s.set(http::field::content_type, "application/json;charset=UTF-8");
|
|
s.keep_alive(request.keep_alive());
|
|
s.body() = boost::json::serialize(reply);
|
|
s.prepare_payload();
|
|
session.reply(std::move(s));
|
|
});
|
|
// clang-format on
|
|
m_ioContext = Amass::Singleton<IoContext>::instance<Amass::Construct>(getThreads());
|
|
m_timer = std::make_shared<boost::asio::system_timer>(*m_ioContext->ioContext());
|
|
|
|
m_replyer = std::make_shared<Nng::Asio::Socket>(*m_ioContext->ioContext(), Nng::Reply);
|
|
m_replyer->listen(IpcUrl);
|
|
|
|
m_systemUsage = std::make_shared<SystemUsage>(*m_ioContext->ioContext(), getHomeAssistantAccessToken());
|
|
m_systemUsage->start();
|
|
|
|
alarmTask();
|
|
}
|
|
|
|
boost::asio::io_context &Application::ioContext() {
|
|
return *m_ioContext->ioContext();
|
|
}
|
|
|
|
const Application::RequestHandler *Application::find(boost::urls::segments_encoded_view path,
|
|
boost::urls::matches_base &matches) const noexcept {
|
|
const Application::RequestHandler *ret = nullptr;
|
|
try {
|
|
ret = m_router->find(path, matches);
|
|
} catch (const std::exception &e) {
|
|
boost::stacktrace::stacktrace trace = boost::stacktrace::stacktrace::from_current_exception();
|
|
LOG(error) << e.what() << ", trace:\n" << trace;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void Application::insertUrl(std::string_view url, RequestHandler &&handler) {
|
|
m_router->insert(url, std::move(handler));
|
|
}
|
|
|
|
int Application::exec() {
|
|
startAcceptRequest();
|
|
LOG(info) << "application start successful ...";
|
|
startCheckInterval(*m_ioContext->ioContext(), 2);
|
|
m_ioContext->run();
|
|
LOG(info) << "application exit successful ...";
|
|
return m_status;
|
|
}
|
|
|
|
void Application::alarmTask() {
|
|
int hour = 10;
|
|
int minute = 30;
|
|
auto alarmTime = DateTime::currentDateTime();
|
|
alarmTime.setHour(hour);
|
|
alarmTime.setMinute(minute);
|
|
if (std::chrono::system_clock::now() > alarmTime()) {
|
|
alarmTime = alarmTime.tomorrow();
|
|
}
|
|
m_timer->expires_at(alarmTime());
|
|
m_timer->async_wait([this](const boost::system::error_code &error) mutable {
|
|
if (error) {
|
|
LOG(error) << error.message();
|
|
return;
|
|
}
|
|
auto session = Database::session();
|
|
Tasks tasks = session->find<Task>();
|
|
bool founded = false;
|
|
std::string content;
|
|
for (auto &task : tasks) {
|
|
if (founded) break;
|
|
for (auto child : task->children) {
|
|
if (!child->finished) {
|
|
content = child->content;
|
|
founded = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!founded && !task->finished) {
|
|
content = task->content;
|
|
founded = true;
|
|
}
|
|
}
|
|
if (founded) {
|
|
std::ostringstream oss;
|
|
oss << "待完成事项:" << std::endl;
|
|
oss << "==========" << std::endl;
|
|
oss << content << std::endl;
|
|
oss << "==========" << std::endl;
|
|
oss << "每天都要过得充实开心哦~";
|
|
auto manager = Amass::Singleton<ServiceManager>::instance();
|
|
if (manager) manager->sendMessage(NotifyServerChan, oss.str());
|
|
}
|
|
|
|
alarmTask();
|
|
});
|
|
}
|
|
|
|
void Application::startAcceptRequest() {
|
|
m_replyer->asyncReceive([ptr{weak_from_this()}](const boost::system::error_code &error, const Nng::Buffer &buffer) {
|
|
if (error) {
|
|
LOG(error) << error.message();
|
|
}
|
|
LOG(info) << buffer.data();
|
|
if (ptr.expired()) return;
|
|
auto self = ptr.lock();
|
|
auto value = boost::json::parse(buffer.data());
|
|
auto &request = value.as_object();
|
|
if (request.at("command").as_string() == "exit") {
|
|
boost::json::object reply;
|
|
reply["status"] = 0;
|
|
reply["message"] = "will exit.";
|
|
auto txt = boost::json::serialize(reply);
|
|
self->m_replyer->send(txt.data(), txt.size());
|
|
std::raise(SIGUSR1); // 发送自定义信号
|
|
}
|
|
self->startAcceptRequest();
|
|
});
|
|
}
|
|
|
|
void Application::requetExit() {
|
|
LOG(info) << "send exit request to program.";
|
|
Nng::Socket request(Nng::Request);
|
|
request.setOption(Nng::RecvTimeout, std::chrono::milliseconds(2000));
|
|
std::error_code error;
|
|
request.dial(IpcUrl, error);
|
|
if (error) {
|
|
LOG(error) << error.message();
|
|
return;
|
|
}
|
|
|
|
boost::json::object object;
|
|
object["command"] = "exit";
|
|
auto text = boost::json::serialize(object);
|
|
request.send(text.data(), text.size());
|
|
auto buffer = request.recv();
|
|
LOG(info) << buffer.data<char>();
|
|
} |