/*
* run_context_push
*
* Add a new run context level below @context, running @stmt to create a data model
*/
static RunContext *
run_context_push_with_stmt (GdaReportEngine *engine, RunContext *context, GdaConnection *cnc,
GdaStatement *stmt, const gchar *stmt_name, GError **error)
{
GdaDataModel *model;
GdaSet *plist;
GdaStatement *lstmt;
lstmt = rewrite_statement (engine, context, stmt, error);
if (!lstmt)
return NULL;
g_assert (cnc);
if (!gda_statement_get_parameters (lstmt, &plist, error)) {
g_object_unref (lstmt);
return NULL;
}
if (plist && !assign_parameters_values (engine, context, plist, error)) {
g_object_unref (plist);
g_object_unref (lstmt);
return NULL;
}
model = gda_connection_statement_execute_select (cnc, lstmt, plist, error);
if (plist)
g_object_unref (plist);
g_object_unref (lstmt);
if (!model)
return NULL;
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (stmt_name), g_free);
/* add a parameter for the number of rows, attached to model */
GdaHolder *param;
GValue *value;
gchar *name;
param = gda_holder_new (G_TYPE_INT);
value = gda_value_new (G_TYPE_INT);
g_value_set_int (value, gda_data_model_get_n_rows (model));
if (! gda_holder_set_value (param, value, error)) {
g_object_unref (param);
gda_value_free (value);
return NULL;
}
gda_value_free (value);
name = g_strdup_printf ("%s|?nrows", stmt_name);
g_object_set_data_full (G_OBJECT (model), name, param, g_object_unref);
g_free (name);
/* create a new RunContext */
RunContext *ctx;
ctx = g_new0 (RunContext, 1);
ctx->stmt = NULL;
ctx->cnc = cnc;
ctx->parent = context;
ctx->model = model;
ctx->iter = gda_data_model_create_iter (model);
/*g_print (">>>> PUSH CONTEXT %p\n", ctx);*/
return ctx;
}
gboolean
wmud_db_load_exits(GSList **exits, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading exits");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT room_id, direction, other_side FROM room_exits",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudExit *room_exit;
room_exit = g_new0(wmudExit, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
room_exit->source_room_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
room_exit->direction_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 2);
room_exit->destination_room_id = g_value_get_int(val);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded exit %d =%d=> %d",
room_exit->source_room_id,
room_exit->direction_id,
room_exit->destination_room_id);
*exits = g_slist_prepend(*exits, room_exit);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
static void
gda_data_access_wrapper_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaDataAccessWrapper *model;
model = GDA_DATA_ACCESS_WRAPPER (object);
if (model->priv) {
switch (param_id) {
case PROP_MODEL: {
GdaDataModel *mod = g_value_get_object (value);
if (mod) {
g_return_if_fail (GDA_IS_DATA_MODEL (mod));
model->priv->model_access_flags = gda_data_model_get_access_flags (mod);
if (model->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_RANDOM) {
g_signal_connect (G_OBJECT (mod), "row-inserted",
G_CALLBACK (model_row_inserted_cb), model);
g_signal_connect (G_OBJECT (mod), "row-updated",
G_CALLBACK (model_row_updated_cb), model);
g_signal_connect (G_OBJECT (mod), "row-removed",
G_CALLBACK (model_row_removed_cb), model);
g_signal_connect (G_OBJECT (mod), "reset",
G_CALLBACK (model_reset_cb), model);
}
else {
model->priv->iter = gda_data_model_create_iter (mod);
g_return_if_fail (model->priv->iter);
g_object_set (model->priv->iter, "validate-changes", FALSE,
NULL);
g_signal_connect (G_OBJECT (model->priv->iter), "row-changed",
G_CALLBACK (iter_row_changed_cb), model);
g_signal_connect (G_OBJECT (model->priv->iter), "end-of-data",
G_CALLBACK (iter_end_of_data_cb), model);
model->priv->iter_row = -1; /* because model->priv->iter is invalid */
model->priv->rows = g_hash_table_new_full (g_int_hash, g_int_equal,
g_free,
(GDestroyNotify) g_object_unref);
}
if (model->priv->model)
g_object_unref (model->priv->model);
model->priv->model = mod;
g_object_ref (mod);
compute_columns (model);
}
break;
}
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
}
}
gboolean
wmud_db_load_planet_planes(GSList **planet_planes, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loading planet<->plane associations");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT planet_id, plane_id FROM planet_planes",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudPlanetPlaneAssoc *planet_plane;
planet_plane = g_new0(wmudPlanetPlaneAssoc, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
planet_plane->planet_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
planet_plane->plane_id = g_value_get_int(val);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded planet-plane association %d <> %d",
planet_plane->planet_id,
planet_plane->plane_id);
*planet_planes = g_slist_prepend(*planet_planes, planet_plane);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
static GdaDataModelIter *
cloud_selector_get_data_set (GdauiDataSelector *iface)
{
GdauiCloud *cloud;
cloud = GDAUI_CLOUD (iface);
if (! cloud->priv->iter && cloud->priv->model) {
cloud->priv->iter = gda_data_model_create_iter (cloud->priv->model);
sync_iter_with_selection (cloud);
}
return cloud->priv->iter;
}
gboolean
wmud_db_load_areas(GSList **areas, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading areas");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, name FROM areas",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudArea *area;
area = g_new0(wmudArea, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
area->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
area->name = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loaded area _%s_", area->name);
*areas = g_slist_prepend(*areas, area);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
SymbolDBEngineIterator *
symbol_db_engine_iterator_new (GdaDataModel *model,
const GHashTable *sym_type_conversion_hash,
const gchar *prj_directory)
{
SymbolDBEngineIterator *dbi;
SymbolDBEngineIteratorPriv *priv;
g_return_val_if_fail (model != NULL, NULL);
dbi = g_object_new (SYMBOL_TYPE_DB_ENGINE_ITERATOR, NULL);
priv = dbi->priv;
priv->data_model = model;
priv->data_iter = gda_data_model_create_iter (model);
/* because gda_data_model_get_n_rows () could be cpu-intensive, we'll
* proxy this value, e.g. it's calculated if it is really needed */
priv->total_rows = -1;
/* to avoid calling everytime this function when we want to use the IteratorNode,
* just do it now.
*/
if (symbol_db_engine_iterator_first (dbi) == FALSE)
{
g_warning ("symbol_db_engine_iterator_new (): cannot set iter to first row");
}
/* set the data_iter on the base class */
symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (dbi),
priv->data_iter);
symbol_db_engine_iterator_node_set_conversion_hash (SYMBOL_DB_ENGINE_ITERATOR_NODE (dbi),
sym_type_conversion_hash);
symbol_db_engine_iterator_node_set_prj_directory (SYMBOL_DB_ENGINE_ITERATOR_NODE (dbi),
prj_directory);
return dbi;
}
static GSList *
gda_tree_mgr_select_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSelect *mgr = GDA_TREE_MGR_SELECT (manager);
GdaDataModel *model;
GSList *list = NULL;
if (!mgr->priv->cnc) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!mgr->priv->stmt) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No SELECT statement specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (node && mgr->priv->non_bound_params) {
/* looking for values in @node's attributes */
GSList *nbplist;
for (nbplist = mgr->priv->non_bound_params; nbplist; nbplist = nbplist->next) {
const GValue *cvalue;
GdaHolder *holder = (GdaHolder*) nbplist->data;
cvalue = gda_tree_node_fetch_attribute (node, gda_holder_get_id (holder));
if (cvalue) {
if (!gda_holder_set_value (holder, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
}
else {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
_("No value specified for parameter '%s'"), gda_holder_get_id (holder));
if (out_error)
*out_error = TRUE;
return NULL;
}
}
}
model = gda_connection_statement_execute_select (mgr->priv->cnc, mgr->priv->stmt, mgr->priv->priv_params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode = NULL;
const GValue *cvalue;
GSList *iholders;
for (iholders = GDA_SET (iter)->holders; iholders; iholders = iholders->next) {
GdaHolder *holder = (GdaHolder*) iholders->data;
if (!gda_holder_is_valid (holder) || !(cvalue = gda_holder_get_value (holder))) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get iterator's value"));
return NULL;
}
if (!snode) {
gchar *str = gda_value_stringify (cvalue);
snode = gda_tree_manager_create_node (manager, node, str);
g_free (str);
list = g_slist_prepend (list, snode);
}
gda_tree_node_set_node_attribute (snode, g_strdup (gda_holder_get_id (holder)), cvalue, g_free);
}
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static GSList *
gda_tree_mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrColumns *mgr = GDA_TREE_MGR_COLUMNS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
GdaTreeMgrColumnsPrivate *priv = gda_tree_mgr_columns_get_instance_private (mgr);
if (!priv->cnc && !priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (priv->mstore)
store = priv->mstore;
else
store = gda_connection_get_meta_store (priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
/* create statements if necessary */
if (!priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT column_name FROM _columns WHERE "
"table_schema= ##schema::string AND "
"table_name= ##table_name::string "
"ORDER BY ordinal_position", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!gda_statement_get_parameters (stmt, &(priv->params), error)) {
if (out_error)
*out_error = TRUE;
g_object_unref (stmt);
return NULL;
}
priv->stmt = stmt;
}
gboolean schema_specified = FALSE;
gboolean table_specified = FALSE;
if (priv->schema) {
schema_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "schema",
priv->schema));
}
if (priv->table_name) {
table_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "table_name",
priv->table_name));
}
if (!schema_specified && node) {
/* looking for a schema in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "schema");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "schema");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
schema_specified = TRUE;
}
}
if (!table_specified && node) {
/* looking for a table in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "table_name");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "table_name");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
table_specified = TRUE;
}
}
if (!schema_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No schema specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!table_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No table specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
model = gda_connection_statement_execute_select (scnc, priv->stmt, priv->params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_free_full (list, (GDestroyNotify) g_object_unref);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get column name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "column_name", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static gboolean
test_iter (GdaConnection *cnc)
{
gboolean retval = FALSE;
GdaDataModel *model1, *model2;
GdaDataModelIter *iter;
model1 = ui_tests_common_get_products_2cols (cnc, TRUE);
model2 = ui_tests_common_get_products (cnc, FALSE);
iter = gda_data_model_create_iter (model1);
const gchar *col_ids[] = {"ref", "category", NULL};
const gchar *col_types[] = {"string", "int", NULL};
const gchar *col_values[] = {"1", "14", NULL};
g_assert (gda_data_model_iter_move_next (iter));
dump_iter (iter);
if (!compare_iter (iter, 0, col_ids, col_types, col_values)) {
g_print ("Error, step1\n");
goto out;
}
g_object_set (iter, "data-model", model2, NULL);
dump_iter (iter);
if (!compare_iter (iter, -1, NULL, NULL, NULL)) {
g_print ("Error, step2\n");
goto out;
}
const gchar *col_ids3[] = {"ref", "category", "name", "price", "wh_stored", NULL};
const gchar *col_types3[] = {"string", "int", "string", "gdouble", "int", NULL};
const gchar *col_values3[] = {"1", "14", "ACADEMY ACADEMY", "25.990000", "0", NULL};
g_assert (gda_data_model_iter_move_next (iter));
dump_iter (iter);
if (!compare_iter (iter, 0, col_ids3, col_types3, col_values3)) {
g_print ("Error, step3\n");
goto out;
}
g_object_set (iter, "data-model", model1, NULL);
dump_iter (iter);
if (!compare_iter (iter, -1, NULL, NULL, NULL)) {
g_print ("Error, step2\n");
goto out;
}
g_assert (gda_data_model_iter_move_next (iter));
dump_iter (iter);
if (!compare_iter (iter, 0, col_ids, col_types, col_values)) {
g_print ("Error, step3\n");
goto out;
}
retval = TRUE;
out:
g_object_unref (model1);
g_object_unref (model2);
g_object_unref (iter);
return retval;
}
static GSList *
gda_tree_mgr_schemas_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSchemas *mgr = GDA_TREE_MGR_SCHEMAS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
if (!mgr->priv->cnc && !mgr->priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (mgr->priv->mstore)
store = mgr->priv->mstore;
else
store = gda_connection_get_meta_store (mgr->priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
if (!mgr->priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT schema_name FROM _schemata "
"WHERE schema_internal = FALSE OR schema_name LIKE 'info%' "
"ORDER BY schema_name DESC", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
mgr->priv->stmt = stmt;
}
model = gda_connection_statement_execute_select (scnc, mgr->priv->stmt, NULL, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get schema name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "schema", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
/**
* wmud_db_load_players:
* @err: a GError to put error messages in it
*
* Loads all player records from the database
*/
gboolean
wmud_db_load_players(GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res;
GdaDataModelIter *iter;
GError *local_err = NULL;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading players");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, login, password, email FROM players",
NULL,
NULL);
/* TODO: error checking! */
if ((res = gda_connection_statement_execute_select(
dbh,
sth,
NULL,
&local_err)) == NULL) {
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_CRITICAL,
"Unable to load players: %s",
local_err->message);
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_SELECT_ERROR,
"SELECT error: %s",
local_err->message);
return FALSE;
}
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
WmudPlayer *player;
player = wmud_player_new();
val = gda_data_model_iter_get_value_at(iter, 0);
wmud_player_set_id(player, g_value_get_int(val));
val = gda_data_model_iter_get_value_at(iter, 1);
wmud_player_set_player_name(player, g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
wmud_player_set_cpassword(player, g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 3);
wmud_player_set_email(player, g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded player _%s_",
wmud_player_get_player_name(player));
players = g_slist_prepend(players, player);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Finished loading players");
return TRUE;
}
gboolean
wmud_db_load_menu(GSList **menu_items, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading menu items");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, menuchar, need_active_char, placement, display_text, fnctn FROM menu ORDER BY placement",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudMenu *menu_item;
menu_item = g_new0(wmudMenu, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
menu_item->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
menu_item->menuchar = *(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
menu_item->need_active_char = g_value_get_boolean(val);
val = gda_data_model_iter_get_value_at(iter, 3);
menu_item->placement = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 4);
menu_item->text = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 5);
menu_item->func = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded menu item %d: %s(%c)",
menu_item->id, menu_item->text,
menu_item->menuchar);
*menu_items = g_slist_prepend(*menu_items, menu_item);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
gboolean
wmud_db_load_rooms(GSList **rooms, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading rooms");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, area, name, distant_description, close_description FROM rooms",
NULL,
NULL);
res = gda_connection_statement_execute_select(dbh, sth, NULL, NULL);
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudRoom *room;
room = g_new0(wmudRoom, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
room->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
room->area_id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 2);
room->name = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 3);
room->distant_description = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 4);
room->close_description = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded room %d/_%s_",
room->area_id,
room->name);
*rooms = g_slist_prepend(*rooms, room);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
gboolean
wmud_db_load_directions(GSList **directions, GError **err)
{
GdaStatement *sth = NULL;
GdaDataModel *res = NULL;
GdaDataModelIter *iter;
GError *local_err = NULL;
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Loading directions");
if (dbh == NULL) {
if (err) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_NOINIT,
"Database backend not initialized");
}
return FALSE;
}
sth = gda_sql_parser_parse_string(
parser,
"SELECT id, short_name, name FROM directions",
NULL,
NULL);
if ((res = gda_connection_statement_execute_select(
dbh, sth,
NULL, &local_err)) == NULL) {
g_set_error(err,
WMUD_DB_ERROR, WMUD_DB_ERROR_SELECT_ERROR,
"Unable to load directions: %s",
local_err->message);
return FALSE;
}
iter = gda_data_model_create_iter(res);
gda_data_model_iter_move_next(iter);
while (gda_data_model_iter_is_valid(iter)) {
const GValue *val;
wmudDirection *dir;
dir = g_new0(wmudDirection, 1);
val = gda_data_model_iter_get_value_at(iter, 0);
dir->id = g_value_get_int(val);
val = gda_data_model_iter_get_value_at(iter, 1);
dir->short_name = g_strdup(g_value_get_string(val));
val = gda_data_model_iter_get_value_at(iter, 2);
dir->name = g_strdup(g_value_get_string(val));
g_log(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG,
"Loaded direction _%s_",
dir->name);
*directions = g_slist_prepend(*directions, dir);
gda_data_model_iter_move_next(iter);
}
g_object_unref(iter);
g_object_unref(sth);
return TRUE;
}
static gboolean
server_api_get_info_sensors (GPtrArray ** p_rsensors, GPtrArray ** p_unrsensors, GHashTable ** p_hash)
{
gboolean result = FALSE;
GPtrArray *r_array = NULL;
GPtrArray *unr_array = NULL;
GdaDataModel *data_model = NULL;
GdaDataModelIter *iter = NULL;
GHashTable *hash = NULL;
GError *error = NULL;
const GValue *v_av_uuid;
const GValue *v_name;
const GValue *v_internal_uuid;
*p_rsensors = *p_unrsensors = NULL;
*p_hash = NULL;
do
{
if ((r_array = g_ptr_array_new_with_free_func (g_free)) == NULL)
break;
if ((unr_array = g_ptr_array_new_with_free_func (g_free)) == NULL)
break;
if ((hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free)) == NULL)
{
g_message ("%s: Can't create object", __FUNCTION__);
break;
}
if ((data_model =
sim_database_execute_single_command (ossim.dbossim,
"SELECT s.name as SENSOR_NAME, HEX(s.id) AS SENSOR_TABLE_UUID, UCASE(HEX(cl.id)) AS SYSTEM_UUID FROM sensor s, system cl WHERE (s.ip=cl.vpn_ip OR s.ip=cl.admin_ip);")) == NULL)
{
g_message ("Query error in server_api_get_info_sensors");
break;
}
if ((iter = gda_data_model_create_iter (data_model)) == NULL)
{
g_message ("%s: Can't create data iterator", __FUNCTION__);
break;
}
result = TRUE;
while (gda_data_model_iter_move_next (iter))
{
if ((v_name = gda_data_model_iter_get_value_at_e (iter, 0, &error)) == NULL || !G_VALUE_HOLDS_STRING (v_name))
{
result = FALSE;
break;
}
if ((v_internal_uuid = gda_data_model_iter_get_value_at_e (iter, 1, &error)) == NULL || !G_VALUE_HOLDS_STRING (v_internal_uuid))
{
result = FALSE;
break;
}
if ((v_av_uuid = gda_data_model_iter_get_value_at_e (iter, 2, &error)) == NULL || !G_VALUE_HOLDS_STRING (v_av_uuid))
{
result = FALSE;
break;
}
if (strcmp ("(null)", g_value_get_string (v_name)) == 0)
{
g_ptr_array_add (unr_array, g_strdup (g_value_get_string (v_av_uuid)));
}
else
{
g_ptr_array_add (r_array, g_strdup (g_value_get_string (v_av_uuid)));
}
/* Insert the data in the hash table indexed by IP, we need it for the connected sensors */
/* XXX verify the next case: New sensor detected, but without av uuid */
g_hash_table_insert (hash, g_strdup (g_value_get_string (v_internal_uuid)), g_strdup (g_value_get_string (v_av_uuid)));
}
if (!result)
break;
result = TRUE;
}
while (0);
/* Clean up */
if (result == FALSE)
{
if (r_array != NULL)
g_ptr_array_unref (r_array);
if (unr_array != NULL)
g_ptr_array_unref (unr_array);
if (hash != NULL)
g_hash_table_destroy (hash);
}
else
{
*p_rsensors = r_array;
*p_unrsensors = unr_array;
*p_hash = hash;
}
if (iter != NULL)
g_object_unref (iter);
if (data_model != NULL)
g_object_unref (data_model);
if (error != NULL)
g_error_free (error);
return result;
}
