void mjson_str2hdf(HDF *node, struct json_object *o)
{
if (!node) return;
char *s = hdf_obj_value(node);
struct json_object *obj;
struct array_list *list;
enum json_type type;
HDF *cnode;
char tok[64];
int i;
char *key; struct json_object *val; struct lh_entry *entry;
obj = o;
if (!obj && s && *s) {
obj = json_tokener_parse(s);
}
if (!obj || obj < 0) return;
type = json_object_get_type(obj);
switch (type) {
case json_type_boolean:
hdf_set_int_value(node, NULL, json_object_get_boolean(obj));
return;
case json_type_int:
hdf_set_int_value(node, NULL, json_object_get_int(obj));
return;
case json_type_double:
sprintf(tok, "%f", json_object_get_double(obj));
hdf_set_value(node, NULL, tok);
return;
case json_type_string:
hdf_set_value(node, NULL, json_object_get_string(obj));
return;
case json_type_array:
list = json_object_get_array(obj);
for (i = 0; i < list->length; i++) {
sprintf(tok, "%d", i);
hdf_get_node(node, tok, &cnode);
mjson_str2hdf(cnode, (struct json_object*)list->array[i]);
}
return;
case json_type_object:
for(entry = json_object_get_object(obj)->head;
(entry ? (key = (char*)entry->k,
val = (struct json_object*)entry->v, entry) : 0);
entry = entry->next) {
hdf_get_node(node, key, &cnode);
mjson_str2hdf(cnode, val);
}
return;
default:
return;
}
}
NEOERR* system_plan_data_get(CGI *cgi, HASH *dbh, HASH *evth, session_t *ses)
{
mdb_conn *db = hash_lookup(dbh, "plan");
STRING str; string_init(&str);
int count, offset;
char *mname;
HDF *node;
NEOERR *err;
MCS_NOT_NULLB(cgi->hdf, db);
MEMBER_CHECK_ADMIN();
SET_DASHBOARD_ACTION(cgi->hdf);
hdf_get_node(cgi->hdf, PRE_OUTPUT, &node);
mdb_pagediv(hdf_get_obj(cgi->hdf, PRE_QUERY),
NULL, &count, &offset, NULL, node);
err = mdb_build_querycond(hdf_get_obj(cgi->hdf, PRE_QUERY),
hdf_get_obj(g_cfg, "Db.QueryCond.system.plan"),
&str, "intime > current_date - 1");
if (err != STATUS_OK) return nerr_pass(err);
MDB_PAGEDIV_SET_N(node, db, "plan", "%s", NULL, str.buf);
MDB_QUERY_RAW(db, "plan", _COL_PLAN_ADMIN,
"%s ORDER BY id DESC LIMIT %d OFFSET %d",
NULL, str.buf, count, offset);
err = mdb_set_rows(cgi->hdf, db, _COL_PLAN_ADMIN, PRE_OUTPUT".rows",
NULL, MDB_FLAG_EMPTY_OK);
if (err != STATUS_OK) return nerr_pass(err);
return STATUS_OK;
}
NEOERR* mcs_get_nodef(HDF *hdf, HDF **rnode, char *fmt, ...)
{
char key[LEN_HDF_KEY];
va_list ap;
va_start(ap, fmt);
vsnprintf(key, sizeof(key), fmt, ap);
va_end(ap);
return hdf_get_node(hdf, key, rnode);
}
int lcs_set_layout_infoa(HDF *hdf, const char *title, anchor_t *crumbs,
anchor_t *g_nav, int navnum)
{
int ret;
NEOERR *err;
int i;
hdf_set_value(hdf, "hdf.loadpaths.0", PATH_FRT_TPL);
hdf_set_value(hdf, PRE_LAYOUT".title", title);
//ret = mcs_set_login_info(hdf);
char key[LEN_ST];
HDF *node;
for (i = 0; i < navnum; i++) {
sprintf(key, "%s.tabs.%d", PRE_LAYOUT, i);
err = hdf_get_node(hdf, key, &node);
if (err != STATUS_OK) {
mtc_err("create %dst node for layout.tabs failure");
continue;
}
if (!strcmp(g_nav[i].name, crumbs[0].name)) {
hdf_set_value(node, "class", "selected");
}
hdf_set_value(node, "href", g_nav[i].href);
hdf_set_value(node, "name", g_nav[i].name);
}
i = -1;
while (strcmp(crumbs[++i].name, "")) {
sprintf(key, "%s.crumbs.%d", PRE_LAYOUT, i);
err = hdf_get_node(hdf, key, &node);
if (err != STATUS_OK) {
mtc_err("create %dst node for layout.crumbs failure");
continue;
}
hdf_set_value(node, "href", crumbs[i].href);
hdf_set_value(node, "name", crumbs[i].name);
}
return ret;
}
Hdf::Hdf(const Hdf *hdf, const char *name) : m_hdf(nullptr), m_dump(nullptr) {
assert(hdf);
assert(name && *name);
m_rawp = hdf->m_rawp;
if (m_rawp) {
m_rawp->inc();
m_path = hdf->getFullPath();
m_name = name;
} else {
assert(hdf->m_hdf);
hdf_get_node(hdf->m_hdf, (char*)name, &m_hdf);
}
}
Hdf::Hdf(const Hdf *hdf, const char *name) : m_hdf(NULL), m_dump(NULL) {
ASSERT(hdf);
ASSERT(name && *name);
m_rawp = hdf->m_rawp;
if (m_rawp) {
m_rawp->inc();
m_path = hdf->getFullPath();
m_name = name;
} else {
ASSERT(hdf->m_hdf);
hdf_get_node(hdf->m_hdf, (char*)name, &m_hdf);
}
}
HDF *Hdf::getRaw() const {
if (m_hdf) return m_hdf;
if (m_rawp == nullptr) {
return nullptr;
}
HDF *ret = nullptr;
std::string fullpath = getFullPath();
if (fullpath.empty()) {
ret = m_rawp->m_hdf;
} else {
hdf_get_node(m_rawp->m_hdf, (char*)fullpath.c_str(), &ret);
}
m_hdf = ret;
return ret;
}
NEOERR* ltpl_parse_file(HASH *dbh, HASH *evth,
void *lib, char *dir, char *name, HASH *outhash)
{
char *tp = NULL, *tpl = NULL, *val = NULL;
HDF *node = NULL, *dhdf = NULL, *child = NULL, *thdf = NULL;
CSPARSE *cs = NULL;
STRING str;
char fname[_POSIX_PATH_MAX], tok[64], *outfile;
NEOERR* (*data_handler)(HDF *hdf, HASH *dbh, HASH *evth);
NEOERR *err;
memset(fname, 0x0, sizeof(fname));
snprintf(fname, sizeof(fname), "%s/%s", dir, name);
err = hdf_init(&node);
if (err != STATUS_OK) return nerr_pass(err);
err = hdf_read_file(node, fname);
if (err != STATUS_OK) return nerr_pass(err);
child = hdf_obj_child(node);
while (child != NULL) {
mtc_dbg("parse node %s", hdf_obj_name(child));
string_init(&str);
val = mcs_obj_attr(child, "merge");
if (val) {
ULIST *list;
string_array_split(&list, val, ",", 10);
ITERATE_MLIST(list) {
snprintf(fname, sizeof(fname), "%s/%s",
dir, neos_strip((char*)list->items[t_rsv_i]));
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_read_file(dhdf, fname);
JUMP_NOK(err, wnext);
err = hdf_copy(child, NULL, dhdf);
JUMP_NOK(err, wnext);
}
uListDestroy(&list, ULIST_FREE);
}
/*
* can't use dataset directly, because we'll destroy the whole node
*/
err = hdf_init(&dhdf);
JUMP_NOK(err, wnext);
err = hdf_get_node(child, PRE_CFG_DATASET, &thdf);
JUMP_NOK(err, wnext);
err = hdf_copy(dhdf, NULL, thdf);
JUMP_NOK(err, wnext);
err = cs_init(&cs, dhdf);
JUMP_NOK(err, wnext);
hdf_set_value(cs->hdf, "hdf.loadpaths.tpl", PATH_TPL);
hdf_set_value(cs->hdf, "hdf.loadpaths.local", dir);
err = cgi_register_strfuncs(cs);
JUMP_NOK(err, wnext);
err = mcs_register_bitop_functions(cs);
JUMP_NOK(err, wnext);
err = mcs_register_mkd_functions(cs);
JUMP_NOK(err, wnext);
err = mcs_register_string_uslice(cs);
JUMP_NOK(err, wnext);
tpl = hdf_get_value(child, PRE_CFG_LAYOUT, "null.html");
snprintf(fname, sizeof(fname), "%s/%s", PATH_TPL, tpl);
err = cs_parse_file(cs, fname);
JUMP_NOK(err, wnext);
if (outhash != NULL) {
/*
* store template for rend stage use
*/
hdf_set_value(cs->hdf, PRE_RESERVE"."PRE_CFG_LAYOUT, tpl);
/*
* strdup the key, baby, because we'll free the hdf later
*/
err = hash_insert(outhash, (void*)strdup(hdf_obj_name(child)), (void*)cs);
JUMP_NOK(err, wnext);
snprintf(tok, sizeof(tok), "%s_hdf", hdf_obj_name(child));
err = hash_insert(outhash, (void*)strdup(tok), (void*)cs->hdf);
JUMP_NOK(err, wnext);
}
if ((outfile = hdf_get_value(child, PRE_CFG_OUTPUT, NULL)) != NULL) {
ltpl_prepare_rend(cs->hdf, tpl);
/*
* get_data
*/
val = hdf_get_value(child, PRE_CFG_DATAER, NULL);
if (val != NULL && lib) {
data_handler = dlsym(lib, val);
if( (tp = dlerror()) != NULL) {
mtc_err("%s", tp);
//continue;
} else {
err = (*data_handler)(cs->hdf, dbh, evth);
TRACE_NOK(err);
}
}
err = cs_render(cs, &str, mcs_strcb);
JUMP_NOK(err, wnext);
/*
* produce output filename
*/
val = mcs_hdf_attr(child, PRE_CFG_OUTPUT, "ftime");
if (val) {
char tm[LEN_TM];
mutil_getdatetime(tm, sizeof(tm), val, 0);
outfile = mstr_repstr(1, outfile, "$ftime$", tm);
}
snprintf(fname, sizeof(fname), PATH_DOC"%s", outfile);
/*
* output file
*/
err = mfile_makesure_dir(fname);
JUMP_NOK(err, wnext);
err = mcs_str2file(str, fname);
JUMP_NOK(err, wnext);
#ifdef DEBUG_HDF
snprintf(fname, sizeof(fname), "%s/hdf.%s",
TC_ROOT, hdf_obj_name(child));
hdf_write_file(child, fname);
#endif
}
wnext:
if (cs != NULL && outhash == NULL)
cs_destroy(&cs);
string_clear(&str);
child = hdf_obj_next(child);
}
if (node != NULL) hdf_destroy(&node);
return STATUS_OK;
}
