← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gcompris/trusty

« back to all changes in this revision

Viewing changes to src/gcompris/gcompris_db.c

  • Committer: Bazaar Package Importer
  • Author(s): Yann Dirson
  • Date: 2006-12-15 23:08:17 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20061215230817-exr5ks1hd73s3tlk
Tags: 8.2.2-1
http://bugs.debian.org/396523
* New upstream bugfix release, fixes among other things the support for
  the version of gnucap shipped in etch.
* Add missing dependency on python-gtk2 (Closes: #396523).
* Removed reference to non-existent sound file from memory.c (upstream
  fix - impacts 8.2 as well).  
* Now suggests gnuchess, gnucap, and tuxpaint.
* Updated extended description for the main package.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gcompris/gcompris_db.c
 
1
/* gcompris - gcompris_db.c
 
2
 *
 
3
 * Copyright (C) 2000 Bruno Coudoin
 
4
 *
 
5
 *   This program is free software; you can redistribute it and/or modify
 
6
 *   it under the terms of the GNU General Public License as published by
 
7
 *   the Free Software Foundation; either version 2 of the License, or
 
8
 *   (at your option) any later version.
 
9
 *
 
10
 *   This program is distributed in the hope that it will be useful,
 
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *   GNU General Public License for more details.
 
14
 *
 
15
 *   You should have received a copy of the GNU General Public License
 
16
 *   along with this program; if not, write to the Free Software
 
17
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 */
 
19
 
 
20
#include <string.h>
 
21
 
 
22
#include "gcompris.h"
 
23
#include <sys/stat.h>
 
24
 
 
25
 
 
26
#ifdef USE_SQLITE
 
27
static sqlite3 *gcompris_db=NULL;
 
28
#endif
 
29
 
 
30
#define CREATE_TABLE_USERS                                              \
 
31
  "CREATE TABLE users (user_id INT UNIQUE, login TEXT, lastname TEXT, firstname TEXT, birthdate TEXT, class_id INT ); "
 
32
#define CREATE_TABLE_CLASS                                              \
 
33
  "CREATE TABLE class (class_id INT UNIQUE, name TEXT, teacher TEXT, wholegroup_id INT ); "
 
34
#define CREATE_TABLE_GROUPS                                             \
 
35
  "CREATE TABLE groups (group_id INT UNIQUE, name TEXT, class_id INT, description TEXT ); "
 
36
#define CREATE_TABLE_USERS_IN_GROUPS                                    \
 
37
  "CREATE TABLE list_users_in_groups (user_id INT, group_id INT ); "
 
38
#define CREATE_TABLE_GROUPS_IN_PROFILES                                 \
 
39
  "CREATE TABLE list_groups_in_profiles (profile_id INT, group_id INT ); "
 
40
#define CREATE_TABLE_ACTIVITIES_OUT                                     \
 
41
  "CREATE TABLE activities_out (board_id INT, type INT, out_id INT ); "
 
42
#define CREATE_TABLE_PROFILES                                           \
 
43
  "CREATE TABLE profiles (profile_id INT UNIQUE, name TEXT, profile_directory TEXT, description TEXT); "
 
44
#define CREATE_TABLE_BOARDS_PROFILES_CONF                               \
 
45
  "CREATE TABLE board_profile_conf (profile_id INT, board_id INT, conf_key TEXT, conf_value TEXT ); "
 
46
#define CREATE_TABLE_BOARDS                                             \
 
47
  "CREATE TABLE boards (board_id INT UNIQUE, name TEXT, section_id INT, section TEXT, author TEXT, type TEXT, mode TEXT, difficulty INT, icon TEXT, boarddir TEXT, mandatory_sound_file TEXT, mandatory_sound_dataset TEXT, filename TEXT, title TEXT, description TEXT, prerequisite TEXT, goal TEXT, manual TEXT, credit TEXT);"
 
48
 
 
49
#define CREATE_TABLE_INFO                                               \
 
50
  "CREATE TABLE informations (gcompris_version TEXT UNIQUE, init_date TEXTUNIQUE, profile_id INT UNIQUE ); "
 
51
 
 
52
#define PRAGMA_INTEGRITY                        \
 
53
  "PRAGMA integrity_check; "
 
54
 
 
55
/* WARNING: template for g_strdup_printf */
 
56
#define SET_VERSION(v)                                                  \
 
57
  "INSERT INTO informations (gcompris_version) VALUES(\'%s\'); ", v
 
58
 
 
59
#define CHECK_VERSION                           \
 
60
  "SELECT gcompris_version FROM informations;"
 
61
 
 
62
#define SET_DEFAULT_PROFILE                                             \
 
63
  "INSERT INTO profiles (profile_id, name, profile_directory, description) VALUES ( 1, \'Default\', \'Default\', \'Default profil for gcompris\');"
 
64
#define ACTIVATE_DEFAULT_PROFILE                \
 
65
  "UPDATE informations SET profile_id=1;"
 
66
 
 
67
#define SET_DEFAULT_GROUP                                               \
 
68
  "INSERT INTO groups (group_id, name, class_id, description) VALUES ( 1, \'All\', 1, \'All users\');"
 
69
 
 
70
/*
 
71
 * TRIGGERS
 
72
 * --------
 
73
 */
 
74
 
 
75
#define TRIGGER_DELETE_CLASS                                    \
 
76
  "CREATE TRIGGER delete_class  DELETE ON class\
 
77
     BEGIN                                                              \
 
78
       DELETE FROM groups WHERE class_id=old.class_id;                  \
 
79
       UPDATE users SET class_id=1 WHERE class_id=old.class_id;         \
 
80
     END;"
 
81
 
 
82
#define TRIGGER_DELETE_GROUPS                                           \
 
83
  "CREATE TRIGGER delete_groups  DELETE ON groups\
 
84
     BEGIN                                                              \
 
85
       DELETE FROM list_users_in_groups WHERE group_id=old.group_id;    \
 
86
       DELETE FROM list_groups_in_profiles WHERE group_id=old.group_id; \
 
87
     END;"
 
88
 
 
89
#define TRIGGER_DELETE_PROFILES                                         \
 
90
  "CREATE TRIGGER delete_profiles DELETE ON profiles\
 
91
     BEGIN                                                              \
 
92
       DELETE FROM list_groups_in_profiles WHERE profile_id=old.profile_id; \
 
93
       DELETE FROM board_profile_conf WHERE profile_id=old.profile_id;  \
 
94
     END;"
 
95
 
 
96
#define TRIGGER_DELETE_USERS                                            \
 
97
  "CREATE TRIGGER delete_users DELETE ON users\
 
98
     BEGIN                                                         \
 
99
       DELETE FROM list_users_in_groups WHERE user_id=old.user_id; \
 
100
     END;"
 
101
 
 
102
#define TRIGGER_INSERT_USERS                                            \
 
103
  "CREATE TRIGGER insert_users INSERT ON users\
 
104
     BEGIN                                                              \
 
105
       INSERT INTO list_users_in_groups (user_id, group_id) VALUES (new.user_id, (SELECT wholegroup_id FROM class WHERE class_id=new.class_id)); \
 
106
     END;"
 
107
 
 
108
#define TRIGGER_UPDATE_USERS                                            \
 
109
  "CREATE TRIGGER update_wholegroup UPDATE OF class_id ON users\
 
110
     BEGIN                                                         \
 
111
       UPDATE list_users_in_groups SET group_id=(SELECT wholegroup_id FROM class WHERE class_id=new.class_id) WHERE user_id=new.user_id; \
 
112
     END;"
 
113
 
 
114
 
 
115
int gc_db_init()
 
116
{
 
117
#ifdef USE_SQLITE
 
118
  gboolean creation = FALSE;
 
119
  char *zErrMsg;
 
120
  char **result;
 
121
  int rc;
 
122
  int nrow;
 
123
  int ncolumn;
 
124
  gchar *request;
 
125
 
 
126
  GcomprisProperties    *properties = gc_prop_get();
 
127
 
 
128
  if (!g_file_test(properties->database, G_FILE_TEST_EXISTS))
 
129
    creation = TRUE;
 
130
  else {
 
131
    /* we have to check this file is not empty,
 
132
       because bug in administration */
 
133
    struct stat buf;
 
134
 
 
135
    if (stat(properties->database, &buf)!=0)
 
136
      g_error("Can't stat %s", properties->database);
 
137
 
 
138
    /* if size of file is null, we recreate the tables */
 
139
    if (buf.st_size == 0){
 
140
      creation = TRUE;
 
141
      g_warning("Database file is empty! Trying to create table...");
 
142
    }
 
143
  }
 
144
 
 
145
  rc = sqlite3_open(properties->database, &gcompris_db);
 
146
  if( rc ){
 
147
    g_error("Can't open database: %s\n", sqlite3_errmsg(gcompris_db));
 
148
    sqlite3_close(gcompris_db);
 
149
    exit(1);
 
150
  }
 
151
 
 
152
  g_warning("Database %s opened", properties->database);
 
153
 
 
154
  if (creation){
 
155
    /* create all tables needed */
 
156
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_USERS, NULL,  0, &zErrMsg);
 
157
    if( rc!=SQLITE_OK ){
 
158
      g_error("SQL error: %s\n", zErrMsg);
 
159
    }
 
160
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_CLASS, NULL,  0, &zErrMsg);
 
161
    if( rc!=SQLITE_OK ){
 
162
      g_error("SQL error: %s\n", zErrMsg);
 
163
    }
 
164
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_GROUPS, NULL,  0, &zErrMsg);
 
165
    if( rc!=SQLITE_OK ){
 
166
      g_error("SQL error: %s\n", zErrMsg);
 
167
    }
 
168
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_USERS_IN_GROUPS, NULL,  0, &zErrMsg);
 
169
    if( rc!=SQLITE_OK ){
 
170
      g_error("SQL error: %s\n", zErrMsg);
 
171
    }
 
172
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_GROUPS_IN_PROFILES, NULL,  0, &zErrMsg);
 
173
    if( rc!=SQLITE_OK ){
 
174
      g_error("SQL error: %s\n", zErrMsg);
 
175
    }
 
176
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_ACTIVITIES_OUT, NULL,  0, &zErrMsg);
 
177
    if( rc!=SQLITE_OK ){
 
178
      g_error("SQL error: %s\n", zErrMsg);
 
179
    }
 
180
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_PROFILES, NULL,  0, &zErrMsg);
 
181
    if( rc!=SQLITE_OK ){
 
182
      g_error("SQL error: %s\n", zErrMsg);
 
183
    }
 
184
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_BOARDS_PROFILES_CONF, NULL,  0, &zErrMsg);
 
185
    if( rc!=SQLITE_OK ){
 
186
      g_error("SQL error: %s\n", zErrMsg);
 
187
    }
 
188
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_BOARDS, NULL,  0, &zErrMsg);
 
189
    if( rc!=SQLITE_OK ){
 
190
      g_error("SQL error: %s\n", zErrMsg);
 
191
    }
 
192
    rc = sqlite3_exec(gcompris_db,CREATE_TABLE_INFO, NULL,  0, &zErrMsg);
 
193
    if( rc!=SQLITE_OK ){
 
194
      g_error("SQL error: %s\n", zErrMsg);
 
195
    }
 
196
 
 
197
    /* CREATE TRIGGERS */
 
198
    rc = sqlite3_exec(gcompris_db,TRIGGER_DELETE_CLASS, NULL,  0, &zErrMsg);
 
199
    if( rc!=SQLITE_OK ){
 
200
      g_error("SQL error: %s\n", zErrMsg);
 
201
    }
 
202
    rc = sqlite3_exec(gcompris_db,TRIGGER_DELETE_GROUPS, NULL,  0, &zErrMsg);
 
203
    if( rc!=SQLITE_OK ){
 
204
      g_error("SQL error: %s\n", zErrMsg);
 
205
    }
 
206
    rc = sqlite3_exec(gcompris_db,TRIGGER_DELETE_PROFILES, NULL,  0, &zErrMsg);
 
207
    if( rc!=SQLITE_OK ){
 
208
      g_error("SQL error: %s\n", zErrMsg);
 
209
    }
 
210
    rc = sqlite3_exec(gcompris_db,TRIGGER_DELETE_USERS, NULL,  0, &zErrMsg);
 
211
    if( rc!=SQLITE_OK ){
 
212
      g_error("SQL error: %s\n", zErrMsg);
 
213
    }
 
214
    rc = sqlite3_exec(gcompris_db,TRIGGER_INSERT_USERS, NULL,  0, &zErrMsg);
 
215
    if( rc!=SQLITE_OK ){
 
216
      g_error("SQL error: %s\n", zErrMsg);
 
217
    }
 
218
    rc = sqlite3_exec(gcompris_db,TRIGGER_UPDATE_USERS, NULL,  0, &zErrMsg);
 
219
    if( rc!=SQLITE_OK ){
 
220
      g_error("SQL error: %s\n", zErrMsg);
 
221
    }
 
222
 
 
223
    g_warning("Database tables created");
 
224
 
 
225
    request = g_strdup_printf(SET_VERSION(VERSION));
 
226
 
 
227
    rc = sqlite3_get_table(gcompris_db,
 
228
                           request,
 
229
                           &result,
 
230
                           &nrow,
 
231
                           &ncolumn,
 
232
                           &zErrMsg
 
233
                           );
 
234
    if( rc!=SQLITE_OK ){
 
235
      g_error("SQL error: %s\n", zErrMsg);
 
236
    }
 
237
 
 
238
    rc = sqlite3_exec(gcompris_db,SET_DEFAULT_PROFILE, NULL,  0, &zErrMsg);
 
239
    if( rc!=SQLITE_OK ){
 
240
      g_error("SQL error: %s\n", zErrMsg);
 
241
    }
 
242
 
 
243
    rc = sqlite3_exec(gcompris_db,ACTIVATE_DEFAULT_PROFILE, NULL,  0, &zErrMsg);
 
244
    if( rc!=SQLITE_OK ){
 
245
      g_error("SQL error: %s\n", zErrMsg);
 
246
    }
 
247
 
 
248
 
 
249
    request = g_strdup_printf("INSERT INTO class (class_id, name, teacher, wholegroup_id) VALUES ( 1, \'%s\', \'(%s)\', 1);",
 
250
                              _("Unaffected"),
 
251
                              _("Users without a class"));
 
252
 
 
253
    rc = sqlite3_exec(gcompris_db, request, NULL,  0, &zErrMsg);
 
254
    if( rc!=SQLITE_OK ){
 
255
      g_error("SQL error: %s\n", zErrMsg);
 
256
    }
 
257
 
 
258
    rc = sqlite3_exec(gcompris_db,SET_DEFAULT_GROUP, NULL,  0, &zErrMsg);
 
259
    if( rc!=SQLITE_OK ){
 
260
      g_error("SQL error: %s\n", zErrMsg);
 
261
    }
 
262
 
 
263
 
 
264
    sqlite3_free_table(result);
 
265
 
 
266
    g_free(request);
 
267
 
 
268
  } else {
 
269
    /* Check the db integrity */
 
270
    rc = sqlite3_get_table(gcompris_db,
 
271
                           PRAGMA_INTEGRITY,
 
272
                           &result,
 
273
                           &nrow,
 
274
                           &ncolumn,
 
275
                           &zErrMsg
 
276
                           );
 
277
    if( rc!=SQLITE_OK ){
 
278
      g_error("SQL error: %s\n", zErrMsg);
 
279
    }
 
280
    if (!(strcmp(result[1],"ok")==0))
 
281
      g_error("DATABASE integrity check returns %s \n", result[1]);
 
282
    g_warning("Database Integrity ok");
 
283
    sqlite3_free_table(result);
 
284
 
 
285
    rc = sqlite3_get_table(gcompris_db,
 
286
                           CHECK_VERSION,
 
287
                           &result,
 
288
                           &nrow,
 
289
                           &ncolumn,
 
290
                           &zErrMsg
 
291
                           );
 
292
    if( rc!=SQLITE_OK ){
 
293
      g_error("SQL error: %s\n", zErrMsg);
 
294
    }
 
295
 
 
296
    if (strcmp(result[1],VERSION)!=0)
 
297
      g_warning("Running GCompris is %s, but databse vrsion is %s", VERSION, result[1]);
 
298
    sqlite3_free_table(result);
 
299
  }
 
300
 
 
301
  return TRUE;
 
302
#else
 
303
  return FALSE;
 
304
#endif
 
305
}
 
306
 
 
307
void gc_db_exit()
 
308
{
 
309
#ifdef USE_SQLITE
 
310
  sqlite3_close(gcompris_db);
 
311
  g_warning("Database closed");
 
312
#endif
 
313
}
 
314
 
 
315
#define BOARDS_SET_DATE(date)                           \
 
316
  "UPDATE informations SET init_date=\'%s\';",date
 
317
 
 
318
void gc_db_set_date(gchar *date)
 
319
{
 
320
#ifdef USE_SQLITE
 
321
 
 
322
  char *zErrMsg;
 
323
  char **result;
 
324
  int rc;
 
325
  int nrow;
 
326
  int ncolumn;
 
327
  gchar *request;
 
328
 
 
329
  request = g_strdup_printf(BOARDS_SET_DATE(date));
 
330
  rc = sqlite3_get_table(gcompris_db,
 
331
                         request,
 
332
                         &result,
 
333
                         &nrow,
 
334
                         &ncolumn,
 
335
                         &zErrMsg
 
336
                         );
 
337
  if( rc!=SQLITE_OK ){
 
338
    g_error("SQL error: %s\n", zErrMsg);
 
339
  }
 
340
  g_free(request);
 
341
 
 
342
  sqlite3_free_table(result);
 
343
 
 
344
#endif
 
345
}
 
346
 
 
347
#define BOARDS_UPDATE_VERSION(version)                          \
 
348
  "UPDATE informations SET gcompris_version=\'%s\';",version
 
349
 
 
350
void gc_db_set_version(gchar *version)
 
351
{
 
352
#ifdef USE_SQLITE
 
353
 
 
354
  char *zErrMsg;
 
355
  char **result;
 
356
  int rc;
 
357
  int nrow;
 
358
  int ncolumn;
 
359
  gchar *request;
 
360
 
 
361
  request = g_strdup_printf(BOARDS_UPDATE_VERSION(version));
 
362
  rc = sqlite3_get_table(gcompris_db,
 
363
                         request,
 
364
                         &result,
 
365
                         &nrow,
 
366
                         &ncolumn,
 
367
                         &zErrMsg
 
368
                         );
 
369
  if( rc!=SQLITE_OK ){
 
370
    g_error("SQL error: %s\n", zErrMsg);
 
371
  }
 
372
  g_free(request);
 
373
 
 
374
  sqlite3_free_table(result);
 
375
 
 
376
#endif
 
377
}
 
378
 
 
379
#define BOARDS_CHECK                                            \
 
380
  "SELECT gcompris_version, init_date FROM informations;"
 
381
gboolean gc_db_check_boards()
 
382
{
 
383
#ifdef USE_SQLITE
 
384
 
 
385
  char *zErrMsg;
 
386
  char **result;
 
387
  int rc;
 
388
  int nrow;
 
389
  int ncolumn;
 
390
  gboolean ret_value;
 
391
 
 
392
  rc = sqlite3_get_table(gcompris_db,
 
393
                         BOARDS_CHECK,
 
394
                         &result,
 
395
                         &nrow,
 
396
                         &ncolumn,
 
397
                         &zErrMsg
 
398
                         );
 
399
  if( rc!=SQLITE_OK ){
 
400
    g_error("SQL error: %s\n", zErrMsg);
 
401
  }
 
402
 
 
403
  ret_value = (strcmp(result[2],VERSION)==0) && (result[3] != NULL);
 
404
 
 
405
  sqlite3_free_table(result);
 
406
 
 
407
  return ret_value;
 
408
#else
 
409
  return FALSE;
 
410
#endif
 
411
}
 
412
 
 
413
 
 
414
#define BOARD_INSERT                                                    \
 
415
  "INSERT OR REPLACE INTO boards VALUES (%d, %Q, %d, %Q, %Q, %Q, %Q, %d, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q, %Q);"
 
416
 
 
417
#define MAX_BOARD_ID                            \
 
418
  "SELECT MAX(board_id) FROM boards;"
 
419
 
 
420
#define SECTION_ID(s)                                           \
 
421
  "SELECT section_id FROM boards WHERE section=\'%s\';",s
 
422
 
 
423
#define MAX_SECTION_ID                          \
 
424
  "SELECT MAX(section_id) FROM boards;"
 
425
 
 
426
#define CHECK_BOARD(n)                                  \
 
427
  "SELECT board_id FROM boards WHERE name=\'%s\';",n
 
428
 
 
429
 
 
430
void
 
431
gc_db_board_update(guint *board_id,
 
432
                   guint *section_id,
 
433
                   gchar *name,
 
434
                   gchar *section,
 
435
                   gchar *author,
 
436
                   gchar *type,
 
437
                   gchar *mode,
 
438
                   int difficulty,
 
439
                   gchar *icon,
 
440
                   gchar *boarddir,
 
441
                   gchar *mandatory_sound_file,
 
442
                   gchar *mandatory_sound_dataset,
 
443
                   gchar *filename,
 
444
                   gchar *title,
 
445
                   gchar *description,
 
446
                   gchar *prerequisite,
 
447
                   gchar *goal,
 
448
                   gchar *manual,
 
449
                   gchar *credit
 
450
                   )
 
451
{
 
452
#ifdef USE_SQLITE
 
453
 
 
454
  char *zErrMsg;
 
455
  char **result;
 
456
  int rc;
 
457
  int nrow;
 
458
  int ncolumn;
 
459
  gchar *request;
 
460
 
 
461
  if (gcompris_db == NULL)
 
462
    g_error("Database is closed !!!");
 
463
 
 
464
  if (*board_id==0){
 
465
    /* board not yet registered */
 
466
 
 
467
    /* assume name is unique */
 
468
 
 
469
    request = g_strdup_printf(CHECK_BOARD(name));
 
470
 
 
471
    rc = sqlite3_get_table(gcompris_db,
 
472
                           request,
 
473
                           &result,
 
474
                           &nrow,
 
475
                           &ncolumn,
 
476
                           &zErrMsg
 
477
                           );
 
478
 
 
479
    if( rc!=SQLITE_OK ){
 
480
      g_error("SQL error: %s\n", zErrMsg);
 
481
    }
 
482
 
 
483
    g_free(request);
 
484
 
 
485
    if (nrow != 0){
 
486
      *board_id = atoi(result[1]);
 
487
      sqlite3_free_table(result);
 
488
    } else {
 
489
 
 
490
      /* get last board_id written */
 
491
      rc = sqlite3_get_table(gcompris_db,
 
492
                             MAX_BOARD_ID,
 
493
                             &result,
 
494
                             &nrow,
 
495
                             &ncolumn,
 
496
                             &zErrMsg
 
497
                             );
 
498
 
 
499
      if( rc!=SQLITE_OK ){
 
500
        g_error("SQL error: %s\n", zErrMsg);
 
501
      }
 
502
 
 
503
      if (result[1] == NULL)
 
504
        *board_id = 1;
 
505
      else
 
506
        *board_id = atoi(result[1]) + 1;
 
507
 
 
508
      sqlite3_free_table(result);
 
509
 
 
510
    }
 
511
  }
 
512
 
 
513
  /* get section_id */
 
514
  request = g_strdup_printf(SECTION_ID(section));
 
515
 
 
516
  rc = sqlite3_get_table(gcompris_db,
 
517
                         request,
 
518
                         &result,
 
519
                         &nrow,
 
520
                         &ncolumn,
 
521
                         &zErrMsg
 
522
                         );
 
523
 
 
524
  g_free(request);
 
525
 
 
526
  if( rc!=SQLITE_OK ){
 
527
    g_error("SQL error: %s\n", zErrMsg);
 
528
  }
 
529
 
 
530
  if (nrow == 0){
 
531
 
 
532
    /* get max section_id */
 
533
 
 
534
    rc = sqlite3_get_table(gcompris_db,
 
535
                           MAX_SECTION_ID,
 
536
                           &result,
 
537
                           &nrow,
 
538
                           &ncolumn,
 
539
                           &zErrMsg
 
540
                           );
 
541
 
 
542
 
 
543
    if( rc!=SQLITE_OK ){
 
544
      g_error("SQL error: %s\n", zErrMsg);
 
545
    }
 
546
 
 
547
    if (result[1] == NULL){
 
548
      *section_id = 1;
 
549
    } else {
 
550
      *section_id = atoi(result[1]) + 1;
 
551
    }
 
552
    sqlite3_free_table(result);
 
553
  } else {
 
554
    *section_id = atoi(result[1]);
 
555
    sqlite3_free_table(result);
 
556
  }
 
557
 
 
558
  request = sqlite3_mprintf( BOARD_INSERT,
 
559
                             *board_id,
 
560
                             name,
 
561
                             *section_id,
 
562
                             section,
 
563
                             author,
 
564
                             type,
 
565
                             mode,
 
566
                             difficulty,
 
567
                             icon,
 
568
                             boarddir,
 
569
                             mandatory_sound_file,
 
570
                             mandatory_sound_dataset,
 
571
                             filename,
 
572
                             title,
 
573
                             description,
 
574
                             prerequisite,
 
575
                             goal,
 
576
                             manual,
 
577
                             credit
 
578
                             );
 
579
 
 
580
  rc = sqlite3_get_table(gcompris_db,
 
581
                         request,
 
582
                         &result,
 
583
                         &nrow,
 
584
                         &ncolumn,
 
585
                         &zErrMsg
 
586
                         );
 
587
 
 
588
  if( rc!=SQLITE_OK ){
 
589
    g_error("SQL error: %s\n", zErrMsg);
 
590
  }
 
591
 
 
592
  sqlite3_free_table(result);
 
593
 
 
594
  sqlite3_free(request);
 
595
 
 
596
#endif
 
597
}
 
598
 
 
599
 
 
600
#define BOARDS_READ                                                     \
 
601
  "SELECT board_id ,name, section_id, section, author, type, mode, difficulty, icon, boarddir, mandatory_sound_file, mandatory_sound_dataset, filename, title, description, prerequisite, goal, manual, credit FROM boards;"
 
602
 
 
603
GList *gc_menu_load_db(GList *boards_list)
 
604
{
 
605
#ifdef USE_SQLITE
 
606
 
 
607
  GcomprisProperties    *properties = gc_prop_get();
 
608
 
 
609
  GList *boards = boards_list;
 
610
 
 
611
  char *zErrMsg;
 
612
  char **result;
 
613
  int rc;
 
614
  int nrow;
 
615
  int ncolumn;
 
616
  int i;
 
617
 
 
618
  rc = sqlite3_get_table(gcompris_db,
 
619
                         BOARDS_READ,
 
620
                         &result,
 
621
                         &nrow,
 
622
                         &ncolumn,
 
623
                         &zErrMsg
 
624
                         );
 
625
 
 
626
  if( rc!=SQLITE_OK ){
 
627
    g_error("SQL error: %s\n", zErrMsg);
 
628
  }
 
629
 
 
630
  /* first ncolumns are columns labels. */
 
631
  i = ncolumn;
 
632
 
 
633
  while (i < (nrow +1)*ncolumn) {
 
634
    GcomprisBoard *gcomprisBoard = NULL;
 
635
 
 
636
    gcomprisBoard = g_malloc0 (sizeof (GcomprisBoard));
 
637
 
 
638
    gcomprisBoard->plugin=NULL;
 
639
    gcomprisBoard->previous_board=NULL;
 
640
    gcomprisBoard->board_ready=FALSE;
 
641
    gcomprisBoard->canvas=gc_get_canvas();
 
642
 
 
643
    gcomprisBoard->gmodule      = NULL;
 
644
    gcomprisBoard->gmodule_file = NULL;
 
645
 
 
646
    /* From DB we have only package_data_dir. */
 
647
    gcomprisBoard->board_dir = g_strdup(properties->package_data_dir);
 
648
 
 
649
    /* Fixed since I use the canvas own pixel_per_unit scheme */
 
650
    gcomprisBoard->width  = BOARDWIDTH;
 
651
    gcomprisBoard->height = BOARDHEIGHT;
 
652
 
 
653
 
 
654
    gcomprisBoard->board_id = atoi(result[i++]);
 
655
    gcomprisBoard->name = g_strdup(result[i++]);
 
656
    gcomprisBoard->section_id = atoi(result[i++]);
 
657
    gcomprisBoard->section = g_strdup(result[i++]);
 
658
    gcomprisBoard->author = g_strdup(result[i++]);
 
659
    gcomprisBoard->type = g_strdup(result[i++]);
 
660
    gcomprisBoard->mode = g_strdup(result[i++]);
 
661
    gcomprisBoard->difficulty = g_strdup(result[i++]);
 
662
    gcomprisBoard->icon_name = g_strdup(result[i++]);
 
663
    gcomprisBoard->boarddir = g_strdup(result[i++]);
 
664
    gcomprisBoard->mandatory_sound_file = g_strdup(result[i++]);
 
665
    gcomprisBoard->mandatory_sound_dataset = g_strdup(result[i++]);
 
666
    gcomprisBoard->filename = g_strdup(result[i++]);
 
667
    gcomprisBoard->title =  reactivate_newline(gettext(result[i++]));
 
668
    gcomprisBoard->description  = reactivate_newline(gettext(result[i++]));
 
669
    gcomprisBoard->prerequisite = reactivate_newline(gettext(result[i++]));
 
670
    gcomprisBoard->goal = reactivate_newline(gettext(result[i++]));
 
671
    gcomprisBoard->manual = reactivate_newline(gettext(result[i++]));
 
672
    gcomprisBoard->credit = reactivate_newline(gettext(result[i++]));
 
673
 
 
674
    boards = g_list_append(boards, gcomprisBoard);
 
675
  }
 
676
 
 
677
  sqlite3_free_table(result);
 
678
 
 
679
  return boards;
 
680
 
 
681
#else
 
682
  return NULL;
 
683
#endif
 
684
}
 
685
 
 
686
GList *gc_db_read_board_from_section(gchar *section)
 
687
{
 
688
  return NULL;
 
689
}
 
690
 
 
691
 
 
692
#define BOARD_ID_READ                           \
 
693
  "SELECT board_id FROM boards;"
 
694
 
 
695
GList *gc_db_get_board_id(GList *list)
 
696
{
 
697
#ifdef USE_SQLITE
 
698
 
 
699
  GList *board_id_list = list;
 
700
 
 
701
  char *zErrMsg;
 
702
  char **result;
 
703
  int rc;
 
704
  int nrow;
 
705
  int ncolumn;
 
706
  int i;
 
707
 
 
708
  rc = sqlite3_get_table(gcompris_db,
 
709
                         BOARD_ID_READ,
 
710
                         &result,
 
711
                         &nrow,
 
712
                         &ncolumn,
 
713
                         &zErrMsg
 
714
                         );
 
715
 
 
716
  if( rc!=SQLITE_OK ){
 
717
    g_error("SQL error: %s\n", zErrMsg);
 
718
  }
 
719
 
 
720
  /* first ncolumns are columns labels. */
 
721
  i = ncolumn;
 
722
 
 
723
  while (i < (nrow +1)*ncolumn) {
 
724
    int *board_id = g_malloc(sizeof(int));
 
725
 
 
726
    *board_id = atoi(result[i++]);
 
727
    board_id_list = g_list_append(board_id_list, board_id);
 
728
  }
 
729
 
 
730
  return  board_id_list;
 
731
 
 
732
#else
 
733
  return list;
 
734
#endif
 
735
}
 
736
 
 
737
#define DELETE_BOARD(table, board_id)                   \
 
738
  "DELETE FROM %s WHERE board_id=%d;", table, board_id
 
739
 
 
740
void gc_db_remove_board(int board_id)
 
741
{
 
742
#ifdef USE_SQLITE
 
743
  g_warning("Supress board %d from db.", board_id);
 
744
 
 
745
  char *zErrMsg;
 
746
  char **result;
 
747
  int rc;
 
748
  int nrow;
 
749
  int ncolumn;
 
750
  gchar *request;
 
751
 
 
752
  /* get section_id */
 
753
  request = g_strdup_printf(DELETE_BOARD("boards",board_id));
 
754
 
 
755
  rc = sqlite3_get_table(gcompris_db,
 
756
                         request,
 
757
                         &result,
 
758
                         &nrow,
 
759
                         &ncolumn,
 
760
                         &zErrMsg
 
761
                         );
 
762
 
 
763
  if( rc!=SQLITE_OK ){
 
764
    g_error("SQL error: %s\n", zErrMsg);
 
765
  }
 
766
 
 
767
  g_free(request);
 
768
 
 
769
 
 
770
  /* get section_id */
 
771
  request = g_strdup_printf(DELETE_BOARD("board_profile_conf",board_id));
 
772
 
 
773
  rc = sqlite3_get_table(gcompris_db,
 
774
                         request,
 
775
                         &result,
 
776
                         &nrow,
 
777
                         &ncolumn,
 
778
                         &zErrMsg
 
779
                         );
 
780
 
 
781
  if( rc!=SQLITE_OK ){
 
782
    g_error("SQL error: %s\n", zErrMsg);
 
783
  }
 
784
 
 
785
  g_free(request);
 
786
 
 
787
 
 
788
  /* get section_id */
 
789
  request = g_strdup_printf(DELETE_BOARD("activities_out",board_id));
 
790
 
 
791
  rc = sqlite3_get_table(gcompris_db,
 
792
                         request,
 
793
                         &result,
 
794
                         &nrow,
 
795
                         &ncolumn,
 
796
                         &zErrMsg
 
797
                         );
 
798
 
 
799
  if( rc!=SQLITE_OK ){
 
800
    g_error("SQL error: %s\n", zErrMsg);
 
801
  }
 
802
 
 
803
  g_free(request);
 
804
#endif
 
805
}
 
806
 
 
807
 
 
808
#define GET_PROFILE(n)                                                  \
 
809
  "SELECT name, profile_directory, description FROM profiles WHERE profile_id=%d;",n
 
810
 
 
811
#define GET_PROFILE_FROM_NAME(n)                                        \
 
812
  "SELECT profile_id, profile_directory, description FROM profiles WHERE name='%s';",n
 
813
 
 
814
#define GET_GROUPS_IN_PROFILE(n)                                        \
 
815
  "SELECT group_id FROM list_groups_in_profiles WHERE profile_id=%d;",n
 
816
 
 
817
#define GET_ACTIVITIES_OUT_OF_PROFILE(n)                        \
 
818
  "SELECT board_id FROM activities_out WHERE out_id=%d;",n
 
819
 
 
820
GcomprisProfile *gc_db_get_profile_from_id(gint profile_id)
 
821
{
 
822
#ifdef USE_SQLITE
 
823
  GcomprisProfile *profile = NULL;
 
824
 
 
825
  char *zErrMsg;
 
826
  char **result;
 
827
  int rc;
 
828
  int nrow;
 
829
  int ncolumn;
 
830
  gchar *request;
 
831
 
 
832
  int i;
 
833
  GList *ids;
 
834
  /* get section_id */
 
835
  request = g_strdup_printf(GET_PROFILE(profile_id));
 
836
 
 
837
 
 
838
  rc = sqlite3_get_table(gcompris_db,
 
839
                         request,
 
840
                         &result,
 
841
                         &nrow,
 
842
                         &ncolumn,
 
843
                         &zErrMsg
 
844
                         );
 
845
 
 
846
  if( rc!=SQLITE_OK ){
 
847
    g_error("SQL error: %s\n", zErrMsg);
 
848
  }
 
849
 
 
850
  if (nrow != 0){
 
851
    profile = g_malloc0(sizeof(GcomprisProfile));
 
852
 
 
853
    profile->profile_id = profile_id;
 
854
 
 
855
 
 
856
    profile->name = g_strdup(result[3]);
 
857
    profile->directory = g_strdup(result[4]);
 
858
    profile->description = g_strdup(result[5]);
 
859
    sqlite3_free_table(result);
 
860
    g_free(request);
 
861
 
 
862
    request = g_strdup_printf(GET_GROUPS_IN_PROFILE(profile->profile_id));
 
863
 
 
864
    rc = sqlite3_get_table(gcompris_db,
 
865
                           request,
 
866
                           &result,
 
867
                           &nrow,
 
868
                           &ncolumn,
 
869
                           &zErrMsg
 
870
                           );
 
871
 
 
872
    if( rc!=SQLITE_OK ){
 
873
      g_error("SQL error: %s\n", zErrMsg);
 
874
    }
 
875
 
 
876
    g_free(request);
 
877
 
 
878
    if (nrow == 0){
 
879
      g_warning("No users' groups for profile %s", profile->name);
 
880
      profile->group_ids = NULL;
 
881
    } else {
 
882
      ids = NULL;
 
883
 
 
884
      i = ncolumn;
 
885
      while (i < (nrow +1)*ncolumn) {
 
886
        int *group_id = g_malloc(sizeof(int));
 
887
 
 
888
        *group_id = atoi(result[i++]);
 
889
        ids = g_list_append(ids, group_id);
 
890
      }
 
891
      profile->group_ids = ids;
 
892
    }
 
893
    sqlite3_free_table(result);
 
894
 
 
895
    request = g_strdup_printf(GET_ACTIVITIES_OUT_OF_PROFILE(profile->profile_id));
 
896
    rc = sqlite3_get_table(gcompris_db,
 
897
                           request,
 
898
                           &result,
 
899
                           &nrow,
 
900
                           &ncolumn,
 
901
                           &zErrMsg
 
902
                           );
 
903
 
 
904
    if( rc!=SQLITE_OK ){
 
905
      g_error("SQL error: %s\n", zErrMsg);
 
906
    }
 
907
 
 
908
    g_free(request);
 
909
 
 
910
    if (nrow == 0){
 
911
      g_warning("No activities for profile %s", profile->name);
 
912
      profile->activities = NULL;
 
913
    } else {
 
914
      ids = NULL;
 
915
 
 
916
      i = ncolumn;
 
917
      while (i < (nrow +1)*ncolumn) {
 
918
        int *board_id = g_malloc(sizeof(int));
 
919
 
 
920
        *board_id = atoi(result[i++]);
 
921
        ids = g_list_append(ids, board_id);
 
922
      }
 
923
      profile->activities = ids;
 
924
    }
 
925
    sqlite3_free_table(result);
 
926
  }
 
927
 
 
928
  return profile;
 
929
#else
 
930
  return NULL;
 
931
#endif
 
932
}
 
933
 
 
934
/** \brief Given a profile name, return a GcomprisProfile struct
 
935
 *
 
936
 * \param profile_name: the profile to retrieve.
 
937
 *
 
938
 * \return *GcomprisProfile
 
939
 */
 
940
GcomprisProfile *
 
941
gc_db_profile_from_name_get(gchar *profile_name)
 
942
{
 
943
#ifdef USE_SQLITE
 
944
  GcomprisProfile *profile = NULL;
 
945
 
 
946
  char *zErrMsg;
 
947
  char **result;
 
948
  int rc;
 
949
  int nrow;
 
950
  int ncolumn;
 
951
  gchar *request;
 
952
 
 
953
  /* get section_id */
 
954
  request = g_strdup_printf(GET_PROFILE_FROM_NAME(profile_name));
 
955
 
 
956
  rc = sqlite3_get_table(gcompris_db,
 
957
                         request,
 
958
                         &result,
 
959
                         &nrow,
 
960
                         &ncolumn,
 
961
                         &zErrMsg
 
962
                         );
 
963
 
 
964
  if( rc!=SQLITE_OK ){
 
965
    g_error("SQL error: %s\n", zErrMsg);
 
966
  }
 
967
 
 
968
  if (nrow != 0){
 
969
    gint profile_id;
 
970
 
 
971
    profile_id  = atoi(result[3]);
 
972
 
 
973
    g_free(request);
 
974
 
 
975
    profile = gc_db_get_profile_from_id(profile_id);
 
976
 
 
977
  }
 
978
 
 
979
 
 
980
  return profile;
 
981
#else
 
982
  return NULL;
 
983
#endif
 
984
}
 
985
 
 
986
 
 
987
 
 
988
#define GET_ACTIVE_PROFILE_ID                   \
 
989
  "SELECT profile_id FROM informations;"
 
990
 
 
991
GcomprisProfile *gc_db_get_profile()
 
992
{
 
993
#ifdef USE_SQLITE
 
994
  char *zErrMsg;
 
995
  char **result;
 
996
  int rc;
 
997
  int nrow;
 
998
  int ncolumn;
 
999
  int profile_id;
 
1000
 
 
1001
  rc = sqlite3_get_table(gcompris_db,
 
1002
                         GET_ACTIVE_PROFILE_ID,
 
1003
                         &result,
 
1004
                         &nrow,
 
1005
                         &ncolumn,
 
1006
                         &zErrMsg
 
1007
                         );
 
1008
 
 
1009
  if( rc!=SQLITE_OK ){
 
1010
    g_error("SQL error: %s\n", zErrMsg);
 
1011
  }
 
1012
 
 
1013
  profile_id = atoi(result[1]);
 
1014
 
 
1015
  sqlite3_free_table(result);
 
1016
 
 
1017
  return gc_db_get_profile_from_id(profile_id);
 
1018
 
 
1019
#else
 
1020
  return NULL;
 
1021
#endif
 
1022
}
 
1023
 
 
1024
#define USERS_FROM_GROUP(n)                                             \
 
1025
  "SELECT users.user_id, users.login, users.lastname, users.firstname, users.birthdate, users.class_id  FROM users, list_users_in_groups WHERE users.user_id = list_users_in_groups.user_id AND list_users_in_groups.group_id = %d;",n
 
1026
 
 
1027
GList *gc_db_users_from_group_get(gint group_id)
 
1028
{
 
1029
#ifdef USE_SQLITE
 
1030
  char *zErrMsg;
 
1031
  char **result;
 
1032
  int rc;
 
1033
  int nrow;
 
1034
  int ncolumn;
 
1035
  gchar *request;
 
1036
 
 
1037
  int i;
 
1038
  GList *users = NULL;
 
1039
 
 
1040
  request = g_strdup_printf(USERS_FROM_GROUP(group_id));
 
1041
  rc = sqlite3_get_table(gcompris_db,
 
1042
                         request,
 
1043
                         &result,
 
1044
                         &nrow,
 
1045
                         &ncolumn,
 
1046
                         &zErrMsg
 
1047
                         );
 
1048
 
 
1049
  if( rc!=SQLITE_OK ){
 
1050
    g_error("SQL error: %s\n", zErrMsg);
 
1051
  }
 
1052
 
 
1053
  g_free(request);
 
1054
 
 
1055
  if (nrow == 0){
 
1056
    g_warning("No users in the group id %d", group_id);
 
1057
  } else {
 
1058
    i = ncolumn;
 
1059
    while (i < (nrow +1)*ncolumn) {
 
1060
      GcomprisUser *user = g_malloc0(sizeof(GcomprisUser));
 
1061
 
 
1062
      user->user_id = atoi(result[i++]);
 
1063
      user->login = g_strdup(result[i++]);
 
1064
      user->lastname = g_strdup(result[i++]);
 
1065
      user->firstname = g_strdup(result[i++]);
 
1066
      user->birthdate = g_strdup(result[i++]);
 
1067
      user->class_id = atoi(result[i++]);
 
1068
 
 
1069
      users = g_list_append(users, user);
 
1070
    }
 
1071
  }
 
1072
 
 
1073
  return users;
 
1074
#else
 
1075
  return NULL;
 
1076
#endif
 
1077
}
 
1078
 
 
1079
#define USER_FROM_ID(n)                                                 \
 
1080
  "SELECT users.login, lastname, firstname, birthdate, class_id  FROM users WHERE user_id = %d;",n
 
1081
 
 
1082
GcomprisUser *gc_db_get_user_from_id(gint user_id)
 
1083
{
 
1084
#ifdef USE_SQLITE
 
1085
  char *zErrMsg;
 
1086
  char **result;
 
1087
  int rc;
 
1088
  int nrow;
 
1089
  int ncolumn;
 
1090
  gchar *request;
 
1091
  int i;
 
1092
  GcomprisUser *user = NULL;
 
1093
 
 
1094
  request = g_strdup_printf(USER_FROM_ID(user_id));
 
1095
  rc = sqlite3_get_table(gcompris_db,
 
1096
                         request,
 
1097
                         &result,
 
1098
                         &nrow,
 
1099
                         &ncolumn,
 
1100
                         &zErrMsg
 
1101
                         );
 
1102
 
 
1103
  if( rc!=SQLITE_OK ){
 
1104
    g_error("SQL error: %s\n", zErrMsg);
 
1105
  }
 
1106
 
 
1107
  g_free(request);
 
1108
 
 
1109
  if (nrow == 0){
 
1110
    g_warning("No user with id  %d", user_id);
 
1111
    return NULL;
 
1112
  } else {
 
1113
    i = ncolumn;
 
1114
    user = g_malloc0(sizeof(GcomprisUser));
 
1115
 
 
1116
    user->user_id = user_id;
 
1117
    user->login = g_strdup(result[i++]);
 
1118
    user->lastname = g_strdup(result[i++]);
 
1119
    user->firstname = g_strdup(result[i++]);
 
1120
    user->birthdate = g_strdup(result[i++]);
 
1121
    user->class_id = atoi(result[i++]);
 
1122
  }
 
1123
 
 
1124
 
 
1125
  return user ;
 
1126
#else
 
1127
  return NULL;
 
1128
#endif
 
1129
}
 
1130
 
 
1131
#define CLASS_FROM_ID(n)                                                \
 
1132
  "SELECT name, teacher, wholegroup_id  FROM class WHERE class_id = %d;",n
 
1133
 
 
1134
#define GROUPS_IN_CLASS(n)                              \
 
1135
  "SELECT group_id  FROM groups WHERE class_id = %d;",n
 
1136
 
 
1137
GcomprisClass *gc_db_get_class_from_id(gint class_id)
 
1138
{
 
1139
#ifdef USE_SQLITE
 
1140
  char *zErrMsg;
 
1141
  char **result;
 
1142
  int rc;
 
1143
  int nrow;
 
1144
  int ncolumn;
 
1145
  gchar *request;
 
1146
 
 
1147
  int i;
 
1148
  GcomprisClass *class = NULL;
 
1149
 
 
1150
  request = g_strdup_printf(CLASS_FROM_ID(class_id));
 
1151
  rc = sqlite3_get_table(gcompris_db,
 
1152
                         request,
 
1153
                         &result,
 
1154
                         &nrow,
 
1155
                         &ncolumn,
 
1156
                         &zErrMsg
 
1157
                         );
 
1158
 
 
1159
  if( rc!=SQLITE_OK ){
 
1160
    g_error("SQL error: %s\n", zErrMsg);
 
1161
  }
 
1162
 
 
1163
  g_free(request);
 
1164
 
 
1165
  if (nrow == 0){
 
1166
    g_warning("No class with id %d", class_id);
 
1167
    return NULL;
 
1168
    return NULL;
 
1169
  } else {
 
1170
    i = ncolumn;
 
1171
 
 
1172
    class = g_malloc0(sizeof(GcomprisClass));
 
1173
 
 
1174
    class->class_id = class_id;
 
1175
    class->name = g_strdup(result[i++]);
 
1176
    class->description = g_strdup(result[i++]);
 
1177
    class->wholegroup_id = atoi(result[i++]);
 
1178
  }
 
1179
 
 
1180
  /* Group _ids */
 
1181
 
 
1182
  GList *group_ids = NULL;
 
1183
 
 
1184
  request = g_strdup_printf(GROUPS_IN_CLASS(class_id));
 
1185
 
 
1186
  rc = sqlite3_get_table(gcompris_db,
 
1187
                         request,
 
1188
                         &result,
 
1189
                         &nrow,
 
1190
                         &ncolumn,
 
1191
                         &zErrMsg
 
1192
                         );
 
1193
 
 
1194
  if( rc!=SQLITE_OK ){
 
1195
    g_error("SQL error: %s\n", zErrMsg);
 
1196
  }
 
1197
 
 
1198
  g_free(request);
 
1199
 
 
1200
  if (nrow == 0){
 
1201
    g_error("No groups found for class id %d: there must be at least one for the whole class with id (%d)",
 
1202
            class_id, class->wholegroup_id);
 
1203
    g_free(class);
 
1204
    class = NULL;
 
1205
  } else {
 
1206
 
 
1207
    i = ncolumn;
 
1208
    while (i < (nrow +1)*ncolumn) {
 
1209
      int *group_id = g_malloc(sizeof(int));
 
1210
 
 
1211
      *group_id = atoi(result[i++]);
 
1212
      group_ids = g_list_append(group_ids, group_id);
 
1213
    }
 
1214
    class->group_ids = group_ids;
 
1215
  }
 
1216
 
 
1217
  return class ;
 
1218
#else
 
1219
  return NULL;
 
1220
#endif
 
1221
}
 
1222
 
 
1223
 
 
1224
#define CHECK_CONF                                                      \
 
1225
  "SELECT * FROM board_profile_conf WHERE profile_id=%d AND board_id=%d AND conf_key=%Q;"
 
1226
 
 
1227
#define INSERT_KEY                                                      \
 
1228
  "INSERT INTO board_profile_conf (profile_id, board_id, conf_key, conf_value) VALUES (%d, %d, %Q, %Q);"
 
1229
 
 
1230
#define UPDATE_KEY                                                      \
 
1231
  "UPDATE board_profile_conf SET conf_value=%Q WHERE profile_id=%d AND board_id=%d AND conf_key=%Q;"
 
1232
 
 
1233
void gc_db_set_board_conf(GcomprisProfile *profile,
 
1234
                          GcomprisBoard  *board,
 
1235
                          gchar *key,
 
1236
                          gchar *value)
 
1237
{
 
1238
#ifdef USE_SQLITE
 
1239
  char *zErrMsg;
 
1240
  char **result;
 
1241
  int rc;
 
1242
  int nrow;
 
1243
  int ncolumn;
 
1244
  gchar *request;
 
1245
 
 
1246
  request = sqlite3_mprintf(CHECK_CONF,
 
1247
                            profile->profile_id,
 
1248
                            board->board_id,
 
1249
                            key);
 
1250
 
 
1251
  rc = sqlite3_get_table(gcompris_db,
 
1252
                         request,
 
1253
                         &result,
 
1254
                         &nrow,
 
1255
                         &ncolumn,
 
1256
                         &zErrMsg
 
1257
                         );
 
1258
 
 
1259
  if( rc!=SQLITE_OK ){
 
1260
    g_error("SQL error: %s\n", zErrMsg);
 
1261
  }
 
1262
 
 
1263
  sqlite3_free(request);
 
1264
 
 
1265
  if (nrow == 0){
 
1266
    request = sqlite3_mprintf(INSERT_KEY,
 
1267
                              profile->profile_id,
 
1268
                              board->board_id,
 
1269
                              key,
 
1270
                              value);
 
1271
 
 
1272
    rc = sqlite3_get_table(gcompris_db,
 
1273
                           request,
 
1274
                           &result,
 
1275
                           &nrow,
 
1276
                           &ncolumn,
 
1277
                           &zErrMsg
 
1278
                           );
 
1279
 
 
1280
    if( rc!=SQLITE_OK ){
 
1281
      g_error("SQL error: %s\n", zErrMsg);
 
1282
    }
 
1283
 
 
1284
    sqlite3_free(request);
 
1285
  } else {
 
1286
    request = sqlite3_mprintf(UPDATE_KEY,
 
1287
                              value,
 
1288
                              profile->profile_id,
 
1289
                              board->board_id,
 
1290
                              key
 
1291
                              );
 
1292
 
 
1293
    rc = sqlite3_get_table(gcompris_db,
 
1294
                           request,
 
1295
                           &result,
 
1296
                           &nrow,
 
1297
                           &ncolumn,
 
1298
                           &zErrMsg
 
1299
                           );
 
1300
 
 
1301
    if( rc!=SQLITE_OK ){
 
1302
      g_error("SQL error: %s\n", zErrMsg);
 
1303
    }
 
1304
 
 
1305
    sqlite3_free(request);
 
1306
  }
 
1307
#endif
 
1308
}
 
1309
 
 
1310
#define GET_CONF(p, b)                                                  \
 
1311
  "SELECT conf_key, conf_value FROM board_profile_conf WHERE profile_id=%d AND board_id=%d;", p, b
 
1312
 
 
1313
GHashTable *gc_db_conf_with_table_get(int profile_id, int board_id, GHashTable *table )
 
1314
{
 
1315
  GHashTable *hash_conf = table;
 
1316
 
 
1317
#ifdef USE_SQLITE
 
1318
  char *zErrMsg;
 
1319
  char **result;
 
1320
  int rc;
 
1321
  int nrow;
 
1322
  int ncolumn;
 
1323
  gchar *request;
 
1324
  int i;
 
1325
 
 
1326
  request = g_strdup_printf(GET_CONF(profile_id,
 
1327
                                     board_id));
 
1328
 
 
1329
  g_warning ( "Request get_conf : %s", request);
 
1330
 
 
1331
  rc = sqlite3_get_table(gcompris_db,
 
1332
                         request,
 
1333
                         &result,
 
1334
                         &nrow,
 
1335
                         &ncolumn,
 
1336
                         &zErrMsg
 
1337
                         );
 
1338
 
 
1339
  if( rc!=SQLITE_OK ){
 
1340
    g_error("SQL error: %s\n", zErrMsg);
 
1341
  }
 
1342
 
 
1343
  g_free(request);
 
1344
 
 
1345
  for ( i=ncolumn; i < (nrow +1)*ncolumn; i+=2){
 
1346
    if (strcmp(result[i+1],"NULL")!=0){
 
1347
      /* "NULL" values are ignored */
 
1348
      g_hash_table_replace (hash_conf,
 
1349
                            g_strdup(result[i]),
 
1350
                            g_strdup(result[i+1]));
 
1351
      g_warning("get_conf: put key %s value %s in the hash",
 
1352
                result[i],
 
1353
                result[i+1]);
 
1354
    }
 
1355
  }
 
1356
 
 
1357
  sqlite3_free_table(result);
 
1358
#endif
 
1359
  return hash_conf;
 
1360
}
 
1361
 
 
1362
GHashTable *gc_db_get_conf(GcomprisProfile *profile, GcomprisBoard  *board )
 
1363
{
 
1364
  GHashTable *hash_result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 
1365
 
 
1366
#ifdef USE_SQLITE
 
1367
  return gc_db_conf_with_table_get( profile->profile_id, board->board_id, hash_result) ;
 
1368
#else
 
1369
  return hash_result;
 
1370
#endif
 
1371
}
 
1372
 
 
1373
GHashTable *gc_db_get_board_conf()
 
1374
{
 
1375
  GHashTable *hash_result = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 
1376
 
 
1377
  /* priority order : board + Profile conf, else profile Default (all boards) conf, if not  Default profile + board */
 
1378
 
 
1379
  /* conf values for default profile and current board */
 
1380
  hash_result = gc_db_conf_with_table_get(1,
 
1381
                                          gc_board_get_current()->board_id,
 
1382
                                          hash_result);
 
1383
 
 
1384
  /* conf values for profile (board independant) */
 
1385
  if(gc_profile_get_current()) {
 
1386
    hash_result = gc_db_conf_with_table_get(gc_profile_get_current()->profile_id,
 
1387
                                            -1,
 
1388
                                            hash_result);
 
1389
 
 
1390
    /* conf value for current profile and current board */
 
1391
    hash_result = gc_db_conf_with_table_get(gc_profile_get_current()->profile_id,
 
1392
                                            gc_board_get_current()->board_id,
 
1393
                                            hash_result);
 
1394
  }
 
1395
 
 
1396
  return hash_result;
 
1397
}
 
1398
 
 
1399
#define GET_ALL_PROFILES                                                \
 
1400
  "SELECT profile_id, name, profile_directory, description FROM profiles;"
 
1401
 
 
1402
 
 
1403
GList *gc_db_profiles_list_get()
 
1404
{
 
1405
#ifdef USE_SQLITE
 
1406
 
 
1407
 
 
1408
  char *zErrMsg;
 
1409
  char **result;
 
1410
  int rc;
 
1411
  int nrow;
 
1412
  int ncolumn;
 
1413
  gchar *request;
 
1414
 
 
1415
  int i;
 
1416
  GList *profiles_list = NULL;
 
1417
 
 
1418
  char **result_;
 
1419
  int nrow_;
 
1420
  int ncolumn_;
 
1421
 
 
1422
  int i_;
 
1423
  GList *ids_;
 
1424
 
 
1425
 
 
1426
  rc = sqlite3_get_table(gcompris_db,
 
1427
                         GET_ALL_PROFILES,
 
1428
                         &result,
 
1429
                         &nrow,
 
1430
                         &ncolumn,
 
1431
                         &zErrMsg
 
1432
                         );
 
1433
 
 
1434
  if( rc!=SQLITE_OK ){
 
1435
    g_error("SQL error: %s\n", zErrMsg);
 
1436
  }
 
1437
 
 
1438
  if (nrow == 0)
 
1439
    return NULL;
 
1440
 
 
1441
  i = ncolumn;
 
1442
  while (i < (nrow +1)*ncolumn) {
 
1443
    GcomprisProfile *profile = g_malloc0(sizeof(GcomprisProfile));
 
1444
 
 
1445
    profile->profile_id = atoi(result[i++]);
 
1446
 
 
1447
    profile->name = g_strdup(result[i++]);
 
1448
    profile->directory = g_strdup(result[i++]);
 
1449
    profile->description = g_strdup(result[i++]);
 
1450
 
 
1451
    request = g_strdup_printf(GET_GROUPS_IN_PROFILE(profile->profile_id));
 
1452
 
 
1453
    rc = sqlite3_get_table(gcompris_db,
 
1454
                           request,
 
1455
                           &result_,
 
1456
                           &nrow_,
 
1457
                           &ncolumn_,
 
1458
                           &zErrMsg
 
1459
                           );
 
1460
 
 
1461
    if( rc!=SQLITE_OK ){
 
1462
      g_error("SQL error: %s\n", zErrMsg);
 
1463
    }
 
1464
 
 
1465
    g_free(request);
 
1466
 
 
1467
    if (nrow_ == 0){
 
1468
      g_warning("No users groups for profile %s", profile->name);
 
1469
      profile->group_ids = NULL;
 
1470
    } else {
 
1471
      ids_ = NULL;
 
1472
 
 
1473
      i_ = ncolumn_;
 
1474
      while (i_ < (nrow_ +1)*ncolumn_) {
 
1475
        int *group_id = g_malloc(sizeof(int));
 
1476
 
 
1477
        *group_id = atoi(result_[i_++]);
 
1478
        ids_ = g_list_append(ids_, group_id);
 
1479
      }
 
1480
      profile->group_ids = ids_;
 
1481
    }
 
1482
 
 
1483
    sqlite3_free_table(result_);
 
1484
 
 
1485
    request = g_strdup_printf(GET_ACTIVITIES_OUT_OF_PROFILE(profile->profile_id));
 
1486
    rc = sqlite3_get_table(gcompris_db,
 
1487
                           request,
 
1488
                           &result_,
 
1489
                           &nrow_,
 
1490
                           &ncolumn_,
 
1491
                           &zErrMsg
 
1492
                           );
 
1493
 
 
1494
    if( rc!=SQLITE_OK ){
 
1495
      g_error("SQL error: %s\n", zErrMsg);
 
1496
    }
 
1497
 
 
1498
    g_free(request);
 
1499
 
 
1500
    if (nrow_ == 0){
 
1501
      g_warning("No activities out for profile %s", profile->name);
 
1502
      profile->activities = NULL;
 
1503
    } else {
 
1504
      ids_ = NULL;
 
1505
 
 
1506
      i_ = ncolumn_;
 
1507
      while (i_ < (nrow_ +1)*ncolumn_) {
 
1508
        int *board_id = g_malloc(sizeof(int));
 
1509
 
 
1510
        *board_id = atoi(result_[i_++]);
 
1511
        ids_ = g_list_append(ids_, board_id);
 
1512
      }
 
1513
      profile->activities = ids_;
 
1514
    }
 
1515
 
 
1516
    sqlite3_free_table(result_);
 
1517
    profiles_list = g_list_append( profiles_list, profile);
 
1518
  }
 
1519
 
 
1520
  sqlite3_free_table(result);
 
1521
 
 
1522
  return profiles_list;
 
1523
#else
 
1524
  return NULL;
 
1525
#endif
 
1526
}
 
1527
 
 
1528
#define GROUP_FROM_ID(n)                                                \
 
1529
  "SELECT name, class_id, description FROM groups WHERE group_id=%d;",n
 
1530
 
 
1531
GcomprisGroup *gc_db_get_group_from_id(int group_id)
 
1532
{
 
1533
#ifdef USE_SQLITE
 
1534
 
 
1535
  char *zErrMsg;
 
1536
  char **result;
 
1537
  int rc;
 
1538
  int nrow;
 
1539
  int ncolumn;
 
1540
  gchar *request;
 
1541
 
 
1542
  int i;
 
1543
  GcomprisGroup *group = NULL;
 
1544
 
 
1545
  request = g_strdup_printf(GROUP_FROM_ID(group_id));
 
1546
  rc = sqlite3_get_table(gcompris_db,
 
1547
                         request,
 
1548
                         &result,
 
1549
                         &nrow,
 
1550
                         &ncolumn,
 
1551
                         &zErrMsg
 
1552
                         );
 
1553
 
 
1554
  if( rc!=SQLITE_OK ){
 
1555
    g_error("SQL error: %s\n", zErrMsg);
 
1556
  }
 
1557
 
 
1558
  g_free(request);
 
1559
 
 
1560
  if (nrow == 0){
 
1561
    g_warning("No group with id  %d", group_id);
 
1562
    return NULL;
 
1563
  } else {
 
1564
    i = ncolumn;
 
1565
 
 
1566
    group = g_malloc0(sizeof(GcomprisGroup));
 
1567
 
 
1568
    group->group_id = group_id;
 
1569
    group->name = g_strdup(result[i++]);
 
1570
    group->class_id = atoi(result[i++]);
 
1571
    group->description = g_strdup(result[i++]);
 
1572
  }
 
1573
 
 
1574
  group->user_ids = gc_db_users_from_group_get(group_id);
 
1575
 
 
1576
  return group ;
 
1577
 
 
1578
#else
 
1579
  return NULL;
 
1580
#endif
 
1581
}
 
1582
 
 
1583
#define GET_ALL_GROUPS                                          \
 
1584
  "SELECT group_id, name, class_id, description FROM groups;"
 
1585
 
 
1586
GList *gc_db_get_groups_list()
 
1587
{
 
1588
#ifdef USE_SQLITE
 
1589
  GList *groups_list = NULL;
 
1590
 
 
1591
  char *zErrMsg;
 
1592
  char **result;
 
1593
  int rc;
 
1594
  int nrow;
 
1595
  int ncolumn;
 
1596
  int i;
 
1597
  GcomprisGroup *group = NULL;
 
1598
 
 
1599
  rc = sqlite3_get_table(gcompris_db,
 
1600
                         GET_ALL_GROUPS,
 
1601
                         &result,
 
1602
                         &nrow,
 
1603
                         &ncolumn,
 
1604
                         &zErrMsg
 
1605
                         );
 
1606
 
 
1607
  if( rc!=SQLITE_OK ){
 
1608
    g_error("SQL error: %s\n", zErrMsg);
 
1609
  }
 
1610
 
 
1611
  if (nrow == 0){
 
1612
    g_warning("No groups !");
 
1613
    return NULL;
 
1614
  } else {
 
1615
    i = ncolumn;
 
1616
 
 
1617
    while ( i < (nrow +1)*ncolumn) {
 
1618
      group = g_malloc0(sizeof(GcomprisGroup));
 
1619
 
 
1620
      group->group_id =  atoi(result[i++]);
 
1621
      group->name = g_strdup(result[i++]);
 
1622
      group->class_id = atoi(result[i++]);
 
1623
      group->description = g_strdup(result[i++]);
 
1624
 
 
1625
      group->user_ids = gc_db_users_from_group_get(group->group_id);
 
1626
 
 
1627
      groups_list = g_list_append(groups_list, group);
 
1628
    }
 
1629
  }
 
1630
 
 
1631
  return groups_list;
 
1632
 
 
1633
#else
 
1634
  return NULL;
 
1635
#endif
 
1636
}
 
1637
 
 
1638
 
 
1639
#define BOARDS_READ_FROM_ID(n)                                          \
 
1640
  "SELECT name, section_id, section, author, type, mode, difficulty, icon, boarddir, mandatory_sound_file, mandatory_sound_dataset, filename, title, description, prerequisite, goal, manual, credit FROM boards WHERE board_id=%d;",n
 
1641
 
 
1642
GcomprisBoard *gc_db_get_board_from_id(int board_id)
 
1643
{
 
1644
#ifdef USE_SQLITE
 
1645
 
 
1646
  GcomprisProperties    *properties = gc_prop_get();
 
1647
 
 
1648
  char *zErrMsg;
 
1649
  char **result;
 
1650
  int rc;
 
1651
  int nrow;
 
1652
  int ncolumn;
 
1653
  int i;
 
1654
  gchar *request;
 
1655
 
 
1656
  request = g_strdup_printf(BOARDS_READ_FROM_ID(board_id));
 
1657
 
 
1658
  rc = sqlite3_get_table(gcompris_db,
 
1659
                         request,
 
1660
                         &result,
 
1661
                         &nrow,
 
1662
                         &ncolumn,
 
1663
                         &zErrMsg
 
1664
                         );
 
1665
 
 
1666
  if( rc!=SQLITE_OK ){
 
1667
    g_error("SQL error: %s\n", zErrMsg);
 
1668
  }
 
1669
 
 
1670
  g_free(request);
 
1671
 
 
1672
  /* first ncolumns are columns labels. */
 
1673
  i = ncolumn;
 
1674
 
 
1675
  GcomprisBoard *gcomprisBoard = NULL;
 
1676
 
 
1677
  gcomprisBoard = g_malloc0 (sizeof (GcomprisBoard));
 
1678
 
 
1679
 
 
1680
  gcomprisBoard->plugin=NULL;
 
1681
  gcomprisBoard->previous_board=NULL;
 
1682
  gcomprisBoard->board_ready=FALSE;
 
1683
  gcomprisBoard->canvas=gc_get_canvas();
 
1684
 
 
1685
  gcomprisBoard->gmodule      = NULL;
 
1686
  gcomprisBoard->gmodule_file = NULL;
 
1687
 
 
1688
  /* From DB we have only package_data_dir. */
 
1689
  gcomprisBoard->board_dir = g_strdup_printf(properties->package_data_dir);
 
1690
 
 
1691
  /* Fixed since I use the canvas own pixel_per_unit scheme */
 
1692
  gcomprisBoard->width  = BOARDWIDTH;
 
1693
  gcomprisBoard->height = BOARDHEIGHT;
 
1694
 
 
1695
 
 
1696
  gcomprisBoard->board_id = board_id;
 
1697
  gcomprisBoard->name = g_strdup(result[i++]);
 
1698
  gcomprisBoard->section_id = atoi(result[i++]);
 
1699
  gcomprisBoard->section = g_strdup(result[i++]);
 
1700
  gcomprisBoard->author = g_strdup(result[i++]);
 
1701
  gcomprisBoard->type = g_strdup(result[i++]);
 
1702
  gcomprisBoard->mode = g_strdup(result[i++]);
 
1703
  gcomprisBoard->difficulty = g_strdup(result[i++]);
 
1704
  gcomprisBoard->icon_name = g_strdup(result[i++]);
 
1705
  gcomprisBoard->boarddir = g_strdup(result[i++]);
 
1706
  gcomprisBoard->mandatory_sound_file = g_strdup(result[i++]);
 
1707
  gcomprisBoard->mandatory_sound_dataset = g_strdup(result[i++]);
 
1708
  gcomprisBoard->filename = g_strdup(result[i++]);
 
1709
  gcomprisBoard->title =  reactivate_newline(gettext(result[i++]));
 
1710
  gcomprisBoard->description  = reactivate_newline(gettext(result[i++]));
 
1711
  gcomprisBoard->prerequisite = reactivate_newline(gettext(result[i++]));
 
1712
  gcomprisBoard->goal = reactivate_newline(gettext(result[i++]));
 
1713
  gcomprisBoard->manual = reactivate_newline(gettext(result[i++]));
 
1714
  gcomprisBoard->credit = reactivate_newline(gettext(result[i++]));
 
1715
 
 
1716
  sqlite3_free_table(result);
 
1717
 
 
1718
  return gcomprisBoard;
 
1719
#else
 
1720
  return NULL;
 
1721
#endif
 
1722
}
 
1723
 
 
1724
#define GET_ALL_USERS                                                   \
 
1725
  "SELECT user_id, login, lastname, firstname, birthdate, class_id FROM users;"
 
1726
 
 
1727
GList *gc_db_get_users_list()
 
1728
{
 
1729
#ifdef USE_SQLITE
 
1730
  GList *users_list = NULL;
 
1731
 
 
1732
  char *zErrMsg;
 
1733
  char **result;
 
1734
  int rc;
 
1735
  int nrow;
 
1736
  int ncolumn;
 
1737
  int i;
 
1738
  GcomprisUser *user = NULL;
 
1739
 
 
1740
  rc = sqlite3_get_table(gcompris_db,
 
1741
                         GET_ALL_USERS,
 
1742
                         &result,
 
1743
                         &nrow,
 
1744
                         &ncolumn,
 
1745
                         &zErrMsg
 
1746
                         );
 
1747
 
 
1748
  if( rc!=SQLITE_OK ){
 
1749
    g_error("SQL error: %s\n", zErrMsg);
 
1750
  }
 
1751
 
 
1752
  if (nrow == 0){
 
1753
    g_warning("No users !");
 
1754
    return NULL;
 
1755
  } else {
 
1756
    i = ncolumn;
 
1757
 
 
1758
    while ( i < (nrow +1)*ncolumn) {
 
1759
      user = g_malloc0(sizeof(GcomprisUser));
 
1760
 
 
1761
      user->user_id =  atoi(result[i++]);
 
1762
      user->login = g_strdup(result[i++]);
 
1763
      user->firstname = g_strdup(result[i++]);
 
1764
      user->lastname = g_strdup(result[i++]);
 
1765
      user->birthdate = g_strdup(result[i++]);
 
1766
      user->class_id = atoi(result[i++]);
 
1767
 
 
1768
      users_list = g_list_append(users_list, user);
 
1769
    }
 
1770
  }
 
1771
 
 
1772
  return users_list;
 
1773
 
 
1774
#else
 
1775
  return NULL;
 
1776
#endif
 
1777
}
 
1778
 
 
1779
#define GET_ALL_CLASSES                                         \
 
1780
  "SELECT class_id, name, teacher, wholegroup_id FROM class;"
 
1781
 
 
1782
GList *gc_db_get_classes_list()
 
1783
{
 
1784
#ifdef USE_SQLITE
 
1785
  GList *classes_list = NULL;
 
1786
 
 
1787
  char *zErrMsg;
 
1788
  char **result;
 
1789
  int rc;
 
1790
  int nrow;
 
1791
  int ncolumn;
 
1792
  int i;
 
1793
  GcomprisClass *class = NULL;
 
1794
 
 
1795
  rc = sqlite3_get_table(gcompris_db,
 
1796
                         GET_ALL_CLASSES,
 
1797
                         &result,
 
1798
                         &nrow,
 
1799
                         &ncolumn,
 
1800
                         &zErrMsg
 
1801
                         );
 
1802
 
 
1803
  if( rc!=SQLITE_OK ){
 
1804
    g_error("SQL error: %s\n", zErrMsg);
 
1805
  }
 
1806
 
 
1807
  if (nrow == 0){
 
1808
    g_warning("No groups !");
 
1809
    return NULL;
 
1810
  } else {
 
1811
    i = ncolumn;
 
1812
 
 
1813
    while ( i < (nrow +1)*ncolumn) {
 
1814
      class = g_malloc0(sizeof(GcomprisClass));
 
1815
 
 
1816
      class->class_id =  atoi(result[i++]);
 
1817
      class->name = g_strdup(result[i++]);
 
1818
      class->description = g_strdup(result[i++]);
 
1819
      class->wholegroup_id = atoi(result[i++]);
 
1820
 
 
1821
      classes_list = g_list_append(classes_list, class);
 
1822
    }
 
1823
  }
 
1824
 
 
1825
  return classes_list;
 
1826
 
 
1827
#else
 
1828
  return NULL;
 
1829
#endif
 
1830
}
 
1831
 
 
1832
/* Special request, return true if an activity name is disabled in the profile */
 
1833
#define DB_IS_ACTIVITY_IN_PROFILE_ID(profile_id, name)                  \
 
1834
  "SELECT activities_out.board_id FROM activities_out, boards WHERE boards.name='%s' AND activities_out.out_id='%d' AND activities_out.board_id=boards.board_id;", name, profile_id
 
1835
 
 
1836
int gc_db_is_activity_in_profile(GcomprisProfile *profile, char *activity_name)
 
1837
{
 
1838
#ifdef USE_SQLITE
 
1839
  char *zErrMsg;
 
1840
  char **result;
 
1841
  int rc;
 
1842
  int nrow;
 
1843
  int ncolumn;
 
1844
  gchar *request;
 
1845
 
 
1846
  request = g_strdup_printf(DB_IS_ACTIVITY_IN_PROFILE_ID(profile->profile_id, activity_name));
 
1847
 
 
1848
  rc = sqlite3_get_table(gcompris_db,
 
1849
                         request,
 
1850
                         &result,
 
1851
                         &nrow,
 
1852
                         &ncolumn,
 
1853
                         &zErrMsg
 
1854
                         );
 
1855
 
 
1856
  g_free(request);
 
1857
 
 
1858
  if( rc!=SQLITE_OK ){
 
1859
    g_error("SQL error: %s\n", zErrMsg);
 
1860
  }
 
1861
 
 
1862
  if (nrow == 0){
 
1863
    /* IS IN THE PROFILE */
 
1864
    return TRUE;
 
1865
  }
 
1866
 
 
1867
  /* IS NOT IN THE PROFILE */
 
1868
  return FALSE;
 
1869
 
 
1870
#else
 
1871
  return TRUE;
 
1872
#endif
 
1873
}