//
// A GET of the dealer resource produces a list of existing tables.
//
void BlackJackDealer::handle_get(http_request message)
{
ucout << message.to_string() << endl;
auto paths = http::uri::split_path(http::uri::decode(message.relative_uri().path()));
if (paths.empty())
{
message.reply(status_codes::OK, TablesAsJSON(U("Available Tables"), s_tables));
return;
}
utility::string_t wtable_id = paths[0];
const utility::string_t table_id = wtable_id;
// Get information on a specific table.
auto found = s_tables.find(table_id);
if (found == s_tables.end())
{
message.reply(status_codes::NotFound);
}
else
{
message.reply(status_codes::OK, found->second->AsJSON());
}
};
http_response www_server::on_request(const http_request &req) {
http_response resp;
// we are support only HTTP GET method
if (req.get_method() != http_method::get) {
resp.set_status(http_error::method_not_allowed);
resp.set_allow(http_method::get);
resp.set_content("The POST requests are not supported yet.");
return resp;
}
// obtain the name of the file requested
url u(req.get_path_info());
u.normalize(root_dir);
// load file content to the server response
try {
ifstream in(u.path.c_str());
// if file can't be open, throw an error
if (!in)
throw dbp::exception(string("File not found: ") + u.path);
// set file content type
resp.set_content_type(mime(u.path));
// load file
resp.add_content(in);
}
catch (dbp::exception &e) {
// return error message
resp.set_status(http_error::not_found);
resp.set_content(e.what());
}
return resp;
}
// Handler to process HTTP::GET requests.
// Replies to the request with data.
void CasaLens::handle_get(http_request message)
{
auto path = message.relative_uri().path();
auto content_data = m_htmlcontentmap.find(path);
if (content_data == m_htmlcontentmap.end())
{
message.reply(status_codes::NotFound, U("Path not found")).then(std::bind(&handle_error, std::placeholders::_1));
return;
}
auto file_name = std::get<0>(content_data->second);
auto content_type = std::get<1>(content_data->second);
concurrency::streams::fstream::open_istream(file_name, std::ios::in).then([=](concurrency::streams::istream is)
{
message.reply(status_codes::OK, is, content_type).then(std::bind(&handle_error, std::placeholders::_1));
}).then([=](pplx::task<void>& t)
{
try
{
t.get();
}
catch(...)
{
// opening the file (open_istream) failed.
// Reply with an error.
message.reply(status_codes::InternalError).then(std::bind(&handle_error, std::placeholders::_1));
}
});
}
void FoldersService::render_DELETE(const http_request& req, http_response** res)
{
if (req.get_user()=="a" && req.get_pass()=="a")
{
string strid = req.get_arg("id");
CUUID id = CUUID::Parse(strid);
HisDevFolder* folder = dynamic_cast<HisDevFolder*>(root->GetFolder()->Find(id));
if (folder!=NULL)
{
HisDevFolder* parentfolder = dynamic_cast<HisDevFolder*>(folder->GetParent());
parentfolder->Remove(id);
delete(folder);
root->Save();
*res = new http_string_response("", 200, "application/json");
return;
}
}
else
{
string message = "Autentication error";
*res = new http_string_response(message.c_str(), 401, "application/json");
return;
}
*res = new http_string_response("", 403, "application/json");
}
void details::http_listener_impl::handle_request(http_request msg)
{
// Specific method handler takes priority over general.
const method &mtd = msg.method();
if(m_supported_methods.count(mtd))
{
m_supported_methods[mtd](msg);
}
else if(mtd == methods::OPTIONS)
{
handle_options(msg);
}
else if(mtd == methods::TRCE)
{
handle_trace(msg);
}
else if(m_all_requests != nullptr)
{
m_all_requests(msg);
}
else
{
// Method is not supported.
// Send back a list of supported methods to the client.
http_response response(status_codes::MethodNotAllowed);
response.headers().add(U("Allow"), get_supported_methods());
msg.reply(response);
}
}
void ModbusService::render_GET(const http_request& req, http_response** res)
{
//api/modbus/holdings/{connectorname}/{devaddress}/{baseaddress}/{count}
string connectorName = req.get_arg("connectorname");
string strDevAddress = req.get_arg("devaddress");
string strBaseAddress = req.get_arg("baseaddress");
string strCount = req.get_arg("value");
int devAddress = Converter::stoi(strDevAddress);
int baseAddress = Converter::stoi(strBaseAddress);
int count = Converter::stoi(strCount);
Document document;
StringBuffer buffer;
PrettyWriter<StringBuffer> wr(buffer);
Value jsonvalue;
IModbus* modbus = mm->Find(connectorName);
if (modbus!=NULL)
{
uint16_t* target = new uint16_t[count];
if (modbus->getHoldings(devAddress,baseAddress,count,target))
{
document.SetArray();
for(int i=0;i<count;i++)
{
Value jsonvalue;
jsonvalue.SetUint(target[i]);
document.PushBack(jsonvalue, document.GetAllocator());
}
}
else
{
document.SetObject();
jsonvalue.SetObject();
jsonvalue.SetString("Error",document.GetAllocator());
document.AddMember("Result",jsonvalue,document.GetAllocator());
jsonvalue.SetString("Modbus getHoldings failed",document.GetAllocator());
document.AddMember("Message",jsonvalue,document.GetAllocator());
}
delete[] target;
target = NULL;
}
else
{
document.SetObject();
jsonvalue.SetString("Error",document.GetAllocator());
document.AddMember("Result",jsonvalue,document.GetAllocator());
jsonvalue.SetString("Connector not found",document.GetAllocator());
document.AddMember("Message",jsonvalue,document.GetAllocator());
}
document.Accept(wr);
std::string json = buffer.GetString();
*res = new http_response(http_response_builder(json, 200,"application/json").string_response());
}
void
RestEngineUri::handle_delete(http_request request)
{
std::cout << request.method() << " : " << request.absolute_uri().path() << std::endl;
http_response response(status_codes::OK);
std::string resultstr("Not Supported");
std::pair<bool, std::string> result {true, std::string()};
make_response(response, resultstr, result);
request.reply(response);
}
pplx::task<http_response> client::http_client::request(http_request request, pplx::cancellation_token token)
{
if(!request.headers().has(header_names::user_agent))
{
request.headers().add(header_names::user_agent, USERAGENT);
}
request._set_base_uri(base_uri());
request._set_cancellation_token(token);
return m_pipeline->propagate(request);
}
void RDService::handle_get(http_request message)
{
std::cout << "GET request got" << std::endl;
web::uri reqUri = message.relative_uri();
wcout << "Query:" << reqUri.query() << endl << reqUri.resource().to_string() << endl;
utility::string_t queryStr = reqUri.query();
auto path = reqUri.path();
vector<utility::string_t> queryList = splitStringByAnd(queryStr);
wstring conditions = U("");
if (queryList.size() > 0)
{
conditions += queryList[0];
}
for (size_t i = 1; i < queryList.size(); i++)
{
conditions += U(" AND ") + queryList[i];
}
string finalCondition(conditions.begin(), conditions.end());
vector<Vehicle> dbResult = DbHelper::getInstance()->getVehicleList((char *)finalCondition.c_str());
string table = "";
auto path2 = message.relative_uri().path();
string reply;
for (int i = 0; i < dbResult.size(); i++)
{
Vehicle v = dbResult[i];
string tr = "";
tr += v.Registration + "#";
tr += to_string(v.Make) + "#";
tr += "" + v.Model + "#";
tr += "" + v.Owner + "#";
table += tr;
}
utility::string_t replyText(table.begin(), table.end());
message.reply(status_codes::OK, replyText).then([](pplx::task<void> t) { handle_error(t); });
}
int operator() (const http_request& request, http_response* response)
{
char buf[256] = {0};
std::string resp_body;
std::vector<pid_t>::iterator it;
std::string path_str;
time_t time_now;
///只允许get方法
http_request::request_method method = request.get_method();
if (method != http_request::rGet)
goto err;
///只允许请求/
path_str =request.get_path();
if (path_str != "/")
return -1;
if (request.get_request_head("Connection") == std::string("close")) {
response->add_header("Connection", "close");
response->set_close_conn(true);
}
snprintf(buf, sizeof(buf), "uid: %d \r\n", process_info::uid());
resp_body = buf + process_info::username() + "\r\n" +
process_info::hostname() + "\r\n" + "\r\n";
for (it = m_pid_vec_.begin(); it != m_pid_vec_.end(); ++it) {
resp_body += process_info::get_proc_status(*it) + "\r\n";
snprintf(buf, sizeof(buf), "opend Files: %d \r\n\r\n", process_info::get_opened_files(*it));
resp_body += buf;
}
response->set_status_code(http_response::k200Ok);
response->set_status_str("OK");
response->add_header("Content-Type", "text/plain");
response->add_header("Server", "async_serv");
response->add_header("Connection", "keep-alive");
::time(&time_now);
::strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S GMT", ::gmtime(&time_now));
response->add_header("Date", buf);
response->set_body(resp_body);
return 0;
err:
return default_404_response(request, response);
}
void
RestRollupsUri::handle_post(http_request request)
{
std::cout << request.method() << " : " << request.absolute_uri().path() << std::endl;
int rc = 0;
std::string resultstr;
std::pair<bool, std::string> result {true, std::string()};
char json[1024];
// extract json from request
snprintf(json, sizeof(json), "%s", request.extract_string(true).get().c_str());
std::cout << "JSON:\n" << json << std::endl;
rapidjson::Document document;
if (document.Parse(json).HasParseError())
{
rc = 1;
resultstr += "document invalid";
}
rapidjson::SchemaValidator validator(*_schema);
if (!document.Accept(validator)) {
rc = 1;
resultstr += get_schema_validation_error(&validator);
}
rapidjson::Value::MemberIterator name = document.FindMember("name");
rapidjson::Value::MemberIterator nocsv = document.FindMember("nocsv");
rapidjson::Value::MemberIterator quantity = document.FindMember("quantity");
rapidjson::Value::MemberIterator maxdroop = document.FindMember("maxDroop");
rapidjson::Value::MemberIterator maxsdroop_validation = document.FindMember("maxDroopMaxtoMinIOPSSection");
// Execute Ivy Engine command
if (rc == 0)
{
std::unique_lock<std::mutex> u_lk(goStatementMutex);
std::pair<int, std::string>
rslt = m_s.create_rollup(name->value.GetString(),
(nocsv != document.MemberEnd() ? nocsv->value.GetBool() : false),
false /* have_quantity_validation */,
(maxsdroop_validation != document.MemberEnd() ? maxsdroop_validation->value.GetBool() : false),
(quantity != document.MemberEnd() ? quantity->value.GetInt() : 1),
(maxdroop != document.MemberEnd() ? maxdroop->value.GetDouble() : 6.95323e-310));
}
http_response response(status_codes::OK);
make_response(response, resultstr, result);
request.reply(response);
}
void
RestRollupsUri::handle_get(http_request request)
{
std::cout << request.method() << " : " << request.absolute_uri().path() << std::endl;
http_response response(status_codes::OK);
std::string resultstr("Not Supported");
std::pair<bool, std::string> result {true, std::string()};
resultstr = m_s.show_rollup_structure();
make_response(response, resultstr, result);
request.reply(response);
return;
}
// Respond to HTTP::POST messages
// Post data will contain the postal code or location string.
// Aggregate location data from different services and reply to the POST request.
void CasaLens::handle_post(http_request message)
{
auto path = message.relative_uri().path();
if (0 == path.compare(U("/")))
{
message.extract_string()
.then([=](const utility::string_t& location) { get_data(message, location); })
.then([](pplx::task<void> t) { handle_error(t); });
}
else
{
message.reply(status_codes::NotFound, U("Path not found")).then([](pplx::task<void> t) { handle_error(t); });
}
}
// Respond to HTTP::POST messages
// Post data will contain the postal code or location string.
// Aggregate location data from different services and reply to the POST request.
void CasaLens::handle_post(http_request message)
{
auto path = message.relative_uri().path();
if (0 == path.compare(U("/")))
{
message.extract_string().then([=](const utility::string_t& location)
{
get_data(message, location);
}).then(std::bind(&handle_error, std::placeholders::_1));
}
else
{
message.reply(status_codes::NotFound, U("Path not found")).then(std::bind(&handle_error, std::placeholders::_1));
}
}
void ModbusService::render_PUT(const http_request& req, http_response** res)
{
string connectorName = req.get_arg("connectorname");
string strDevAddress = req.get_arg("devaddress");
string strBaseAddress = req.get_arg("baseaddress");
string strValue = req.get_arg("value");
int devAddress = Converter::stoi(strDevAddress);
int baseAddress = Converter::stoi(strBaseAddress);
int value = Converter::stoi(strValue);
Document document;
StringBuffer buffer;
PrettyWriter<StringBuffer> wr(buffer);
document.SetObject();
Value jsonvalue;
IModbus* modbus = mm->Find(connectorName);
if (modbus!=NULL)
{
if (modbus->setHolding(devAddress,baseAddress,value))
{
jsonvalue.SetString("OK",document.GetAllocator());
document.AddMember("Result",jsonvalue,document.GetAllocator());
}
else
{
jsonvalue.SetString("Error",document.GetAllocator());
document.AddMember("Result",jsonvalue,document.GetAllocator());
jsonvalue.SetString("Modbus setHolding failed",document.GetAllocator());
document.AddMember("Message",jsonvalue,document.GetAllocator());
}
}
else
{
jsonvalue.SetString("Error",document.GetAllocator());
document.AddMember("Result",jsonvalue,document.GetAllocator());
jsonvalue.SetString("Connector not found",document.GetAllocator());
document.AddMember("Message",jsonvalue,document.GetAllocator());
}
document.Accept(wr);
std::string json = buffer.GetString();
*res = new http_response(http_response_builder(json, 200,"application/json").string_response());
}
void MyListener::handle_get(http_request message)
{
web::uri req_uri = message.request_uri();
utility::string_t req_query = req_uri.query();
auto req_split_query = web::uri::split_query(req_query);
//utility::string_t params;
std::string error;
for (auto it = req_split_query.begin(); it != req_split_query.end(); ++it)
{
//params += (*it).first + utility::conversions::to_string_t(": ") + (*it).second + utility::conversions::to_string_t("\n");
// ***** Проверка логина *****
if (utility::conversions::to_utf8string((*it).first) == "login")
{
std::string login = utility::conversions::to_utf8string((*it).second);
for (auto iter = login.begin(); iter != login.end(); ++iter)
{
if (!(*iter >= 'a' && *iter <= 'z'))
error += "Error in login. Unacceptable symbols\n";
}
}
// ***** Проверка пароля *****
if (utility::conversions::to_utf8string((*it).first) == "password")
{
std::string pass = utility::conversions::to_utf8string((*it).second);
if (pass.length() < 8)
error += "Error in password. Insufficient password length\n";
for (auto iter = pass.begin(); iter != pass.end(); ++iter)
{
//if (!isdigit(*iter) && !isalpha(*iter) && !ispunct(*iter))
if (!(*iter >= 33 && *iter <= 126))
{
error += "Error in password. Unacceptable symbols\n";
}
}
}
}
if (error == "")
message.reply(status_codes::OK, "OK");// "OK\n" + utility::conversions::to_utf8string(params));
else
message.reply(status_codes::BadRequest, error);// + '\n' + utility::conversions::to_utf8string(params));
////message.reply(status_codes::OK, params);
}
void RootResource::render(const http_request &request, http_response **response) {
// Execute the appropriate handler function depending on the path or return a 404
std::string path = request.get_path();
std::string method = request.get_method();
if (this->paths.find(path) != this->paths.end()) {
// Found path - do we have an entry for the HTTP method being used?
if (this->paths[path].find(method) != this->paths[path].end()) {
// Found method so execute it and return
// Sorry - this is dirty!
(this->*(this->paths[path][method]))(request, response);
return;
}
}
// If we fall through to here then we didn't find anything - return 404
*response = new http_response(http_response_builder("Not Found", 404).string_response());
}
//using the render method you are able to catch each type of request you receive
void cat_resource::render(const http_request& req, http_response** res)
{
string file = req.get_arg("file");
cout << "file: " << file << endl;
//it is possible to send a response initializing an http_string_response
//that reads the content to send in response from a string.
*res = new http_response(http_response_builder(file, 200).file_response());
}
void CasaLens::fetch_data(http_request message, const std::wstring& postal_code, const std::wstring& location)
{
json::value resp_data;
try
{
m_rwlock.lock_read();
resp_data = m_data[postal_code];
m_rwlock.unlock();
if (resp_data.is_null())
{
std::vector<pplx::task<json::value>> tasks;
tasks.push_back(get_events(postal_code));
tasks.push_back(get_weather(postal_code));
tasks.push_back(get_pictures(location, U("4")));
tasks.push_back(get_movies(postal_code));
pplx::when_all(tasks.begin(), tasks.end()).wait();
resp_data = json::value::object();
for (auto& iter : tasks)
{
auto jval = iter.get();
auto key = jval.as_object().begin()->first;
resp_data[key] = jval.as_object().begin()->second;
}
m_rwlock.lock();
m_data[postal_code] = resp_data;
m_rwlock.unlock();
}
// Reply with the aggregated JSON data
message.reply(status_codes::OK, resp_data).then([](pplx::task<void> t) { handle_error(t); });
}
catch (...)
{
message.reply(status_codes::InternalError).then([](pplx::task<void> t) { handle_error(t); });
}
}
void
RestRollupsUri::handle_put(http_request request)
{
std::cout << request.method() << " : " << request.absolute_uri().path() << std::endl;
int rc = 0;
std::string resultstr;
std::pair<bool, std::string> result {true, std::string()};
char json[1024];
// extract json from request
snprintf(json, sizeof(json), "%s", request.extract_string(true).get().c_str());
std::cout << "JSON:\n" << json << std::endl;
rapidjson::Document document;
if (document.Parse(json).HasParseError())
{
rc = 1;
resultstr += "document invalid";
}
rapidjson::SchemaValidator validator(*_schema);
if (!document.Accept(validator)) {
rc = 1;
resultstr += get_schema_validation_error(&validator);
}
rapidjson::Value::MemberIterator name = document.FindMember("name");
rapidjson::Value::MemberIterator parameters = document.FindMember("parameters");
// Execute Ivy Engine command
if (rc == 0)
{
std::unique_lock<std::mutex> u_lk(goStatementMutex);
std::pair<int, std::string>
rslt = m_s.edit_rollup(name->value.GetString(), parameters->value.GetString());
}
http_response response(status_codes::OK);
make_response(response, resultstr, result);
request.reply(response);
}
void BlackJackDealer::word_article_get(http_request message)
{
// message.method()
auto r_uri = message.request_uri();
uri_builder uri_b(r_uri);
string s_q = uri_b.query();
// stringstream ss;
// auto json = dictHandler->PrefixMatch();
// json.serialize(ss);
// auto str = ss.str();
UrlParameter url_par(s_q);
string s_res;
dictHandler->FindArticle(url_par.value, s_res);
cout << s_res << endl;
QString qt_str = QString::fromStdString(s_res);
QDomDocument qdoc;
qdoc.setContent(qt_str);
QDomNode child = qdoc.firstChild();
QString body_str;
QTextStream stream(&body_str);
child.save(stream, QDomNode::CDATASectionNode /* = 4 */);
s_res = body_str.toUtf8().constData();;
http_response http_resp(status_codes::OK);
// http_resp.set_body(s_res);
http_resp.set_body(s_res);
http_resp.headers().add("Access-Control-Allow-Origin", "*");
http_resp.headers().add("Content-Type","application/json");
message.reply(http_resp);
}
void MetaCDNReceiver::handle_register(http_request message) {
/*
-when a new CDN joins, it has to register itself to Meta Server
JSON Format
Request
{
"Type": 0, //0=for cdn, 1=for fss
"IP": "1.1.1.1:4000", //the sender CDN's IP address + port(listening to incoming requests)
"Lat": 23.00, //the sender CDN's location
"Lng": 148.12
}
Response
{
"CdnId": 1 //the assigned id for the cdn
}
*/
try {
int assignedId = -1;
if(message.headers().content_type()==U("application/json")) {
cout << endl << "---------------"<< endl;
cout << message.to_string() << endl <<endl;
json::value jsonObj = message.extract_json().get();
if(jsonObj.at(U("Type")).as_integer() == 0) {
string ipAddr = utility::conversions::to_utf8string(jsonObj.at(U("IP")).as_string());
//TODO: validate ip address
Address cdnAddr(make_pair(jsonObj.at(U("Lat")).as_double(), jsonObj.at(U("Lng")).as_double()), ipAddr);
assignedId = m_meta->registerCdn(cdnAddr);
json::value respFinal = json::value::object();
respFinal[U("CdnId")] = json::value::number(assignedId);
message.reply(assignedId!=-1? status_codes::OK : status_codes::NotFound, respFinal);
} else if(jsonObj.at(U("Type")).as_integer() == 1){
string ipAddr = utility::conversions::to_utf8string(jsonObj.at(U("IP")).as_string());
//TODO: validate ip address
Address fssAddr(make_pair(jsonObj.at(U("Lat")).as_double(), jsonObj.at(U("Lng")).as_double()), ipAddr);
m_meta->setFssAddr(fssAddr);
message.reply(status_codes::OK, "FSS registration complete");
} else {
message.reply(status_codes::Forbidden, U("Invalid type"));
}
} else {
message.reply(status_codes::Forbidden, U("Json object is required"));
}
} catch(json::json_exception &e) {
message.reply(status_codes::Forbidden, U("Invalid json object"));
return;
}
}
void server_respond(http_server::pipe_t &pipe, const http_request &request, bool is_tls)
{
auto m = response_map.find(request.method_str()); // is it GET, POST, etc...?
if (m != response_map.end())
{
auto e = m->second.find(request.get_url_field(UF_PATH));
if (e != m->second.end())
{
e->second->call(pipe, request);
return;
}
}
anon_log("returning 404 for \"" << request.method_str() << " " << request.get_url_field(UF_PATH) << "\"");
http_response response;
response.add_header("Content-Type", "text/plain");
response << "404 - not found\n";
response << request.get_url_field(UF_PATH) << "\n";
pipe.respond(response);
}
void MetaCDNReceiver::handle_delete(http_request message) {
/*
Use cases:
1. when CDN deletes a file from itself to store some other file because of its limited capacity
JSON Format
Request
{
"FileName": "a.txt",
"CdnId" : 2
}
Response: status OK or Forbidden (no json object included)
*/
try {
int result;
if(message.headers().content_type()==U("application/json")) {
cout << endl << "---------------"<< endl;
cout << message.to_string() << endl <<endl;
json::value jsonObj = message.extract_json().get();
int cdnId = jsonObj.at(U("CdnId")).as_integer();
string fileName = utility::conversions::to_utf8string(jsonObj.at(U("FileName")).as_string());
result = m_meta->deleteCdnFromMetaEntry(fileName, cdnId);
message.reply(status_codes::OK, result==0? U("Deleted successfully") : U("Delete failed"));
} else {
message.reply(status_codes::Forbidden, U("Json object is required"));
}
} catch(json::json_exception &e) {
message.reply(status_codes::Forbidden, U("Invalid json object"));
return;
}
}
//using the render method you are able to catch each type of request you receive
void hello_world_resource::render(const http_request& req, http_response** res)
{
//it is possible to store data inside the resource object that can be altered
//through the requests
std::cout << "Data was: " << data << std::endl;
std::string datapar = req.get_arg("data");
set_some_data(datapar == "" ? "no data passed!!!" : datapar);
std::cout << "Now data is:" << data << std::endl;
//it is possible to send a response initializing an http_string_response
//that reads the content to send in response from a string.
*res = new http_response(http_response_builder("Hello World!!!", 200).string_response());
}
HTTPRequest(http_request& request)
: request(request)
{
// store all argument keys as lower case to be ensure we support any spelling
auto& f = std::use_facet<std::ctype<utility::char_t>>(std::locale());
map<string_t, string_t> srcArguments = uri::split_query(uri::decode(request.request_uri().query()));
for (const auto& srcArg : srcArguments)
{
string_t key = srcArg.first;
f.tolower(&key[0], &key[0] + key.size());
arguments[string(key.begin(), key.end())] = string(srcArg.second.begin(), srcArg.second.end());
}
}
//
// A POST of the dealer resource creates a new table and returns a resource for
// that table.
//
void BlackJackDealer::handle_post(http_request message)
{
ucout << message.to_string() << endl;
auto paths = uri::split_path(uri::decode(message.relative_uri().path()));
if (paths.empty())
{
utility::ostringstream_t nextIdString;
nextIdString << nextId;
std::shared_ptr<DealerTable> tbl = std::make_shared<DealerTable>(nextId, 8, 6);
s_tables[nextIdString.str()] = tbl;
nextId += 1;
message.reply(status_codes::OK, BJPutResponse(ST_PlaceBet, tbl->AsJSON()).AsJSON());
return;
}
utility::string_t wtable_id = paths[0];
const utility::string_t table_id = wtable_id;
// Join an existing table.
auto found = s_tables.find(table_id);
if (found == s_tables.end())
{
message.reply(status_codes::NotFound);
return;
}
auto table = std::static_pointer_cast<DealerTable>(found->second);
if ( table->Players.size() < table->Capacity )
{
std::map<utility::string_t, utility::string_t> query = uri::split_query(uri::decode(message.request_uri().query()));
auto cntEntry = query.find(QUERY_NAME);
if (cntEntry != query.end() && !cntEntry->second.empty())
{
table->AddPlayer(Player(cntEntry->second));
message.reply(status_codes::OK, BJPutResponse(ST_PlaceBet, table->AsJSON()).AsJSON());
}
else
{
message.reply(status_codes::Forbidden, U("Player name is required in query"));
}
}
else
{
utility::ostringstream_t os;
os << U("Table ") << table->Id << U(" is full");
message.reply(status_codes::Forbidden, os.str());
}
};
void FoldersService::render_PUT(const http_request& req, http_response** res)
{
if (req.get_user()=="a" && req.get_pass()=="a")
{
string strid = req.get_arg("id");
string content = req.get_content();
if (UpdateFolder(strid,content))
{
*res = new http_string_response("", 200, "application/json");
return;
}
}
else
{
string message = "Autentication error";
*res = new http_string_response(message.c_str(), 401, "application/json");
return;
}
*res = new http_string_response("", 403, "application/json");
}
void BlackJackDealer::handle_get(http_request message)
{
// UrlParameters pars(message.request_uri());
auto q_str = message.request_uri().query();
UrlParameter url_par(q_str);
stringstream ss;
auto json = dictHandler->PrefixMatch(url_par.value);
json.serialize(ss);
auto str = ss.str();
http_response http_resp(status_codes::OK);
http_resp.set_body(str);
http_resp.headers().add("Access-Control-Allow-Origin", "*");
http_resp.headers().add("Content-Type","application/json");
message.reply(http_resp);
}
void FoldersService::render_GET(const http_request& req, http_response** res)
{
Document respjsondoc;
respjsondoc.SetArray();
string strid = req.get_arg("id");
HisDevFolder* folder = root->GetFolder();
string path = req.get_path();
if(!strid.empty())
{
CUUID id = CUUID::Parse(strid);
folder = dynamic_cast<HisDevFolder*>(folder->Find(id));
}
if (path.find("/api/folders")!=string::npos)
{
if (folder!=NULL)
{
FoldersToJson(folder,respjsondoc);
}
}
else if (path.find("/api/folder")!=string::npos)
{
if (folder!=NULL)
{
FolderToJson(folder,respjsondoc);
}
}
StringBuffer buffer;
PrettyWriter<StringBuffer> wr(buffer);
respjsondoc.Accept(wr);
std::string json = buffer.GetString();
*res = new http_string_response(json, 200, "application/json");
}
