← Back to branch summary

~ubuntu-branches/ubuntu/utopic/almanah/utopic-proposed

« back to all changes in this revision

Viewing changes to src/storage-manager.c

  • Committer: Package Import Robot
  • Author(s): Angel Abad
  • Date: 2013-09-20 17:22:17 UTC
  • mfrom: (1.3.5) (10.1.6 experimental)
  • Revision ID: package-import@ubuntu.com-20130920172217-m0ihvom627502smz
Tags: 0.10.8-2
http://bugs.debian.org/722029
Upload to unstable (Closes: #722029)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/storage-manager.c
59
59
        SIGNAL_ENTRY_ADDED,
60
60
        SIGNAL_ENTRY_MODIFIED,
61
61
        SIGNAL_ENTRY_REMOVED,
 
62
        SIGNAL_ENTRY_TAG_ADDED,
 
63
        SIGNAL_ENTRY_TAG_REMOVED,
62
64
        LAST_SIGNAL
63
65
};
64
66
 
120
122
                                                                      0, NULL, NULL,
121
123
                                                                      g_cclosure_marshal_VOID__BOXED,
122
124
                                                                      G_TYPE_NONE, 1, G_TYPE_DATE);
 
125
        storage_manager_signals[SIGNAL_ENTRY_TAG_ADDED] = g_signal_new ("entry-tag-added",
 
126
                                                                        G_TYPE_FROM_CLASS (klass),
 
127
                                                                        G_SIGNAL_RUN_LAST,
 
128
                                                                        0, NULL, NULL,
 
129
                                                                        almanah_marshal_VOID__OBJECT_STRING,
 
130
                                                                        G_TYPE_NONE, 2, ALMANAH_TYPE_ENTRY, G_TYPE_STRING);
 
131
        storage_manager_signals[SIGNAL_ENTRY_TAG_REMOVED] = g_signal_new ("entry-tag-removed",
 
132
                                                                          G_TYPE_FROM_CLASS (klass),
 
133
                                                                          G_SIGNAL_RUN_LAST,
 
134
                                                                          0, NULL, NULL,
 
135
                                                                          almanah_marshal_VOID__OBJECT_STRING,
 
136
                                                                          G_TYPE_NONE, 2, ALMANAH_TYPE_ENTRY, G_TYPE_STRING);
123
137
}
124
138
 
125
139
static void
230
244
                "ALTER TABLE entries ADD COLUMN edited_month INTEGER", /* added in 0.8.0 */
231
245
                "ALTER TABLE entries ADD COLUMN edited_day INTEGER", /* added in 0.8.0 */
232
246
                "ALTER TABLE entries ADD COLUMN version INTEGER DEFAULT 1", /* added in 0.8.0 */
 
247
                "CREATE TABLE IF NOT EXISTS entry_tag (year INTEGER, month INTEGER, day INTEGER, tag TEXT)", /* added in 0.10.0 */
 
248
                "CREATE INDEX idx_tag ON entry_tag(tag)", /* added in 0.10.0, for information take a look at: http://www.sqlite.org/queryplanner.html */
233
249
                NULL
234
250
        };
235
251
 
923
939
 
924
940
                /* Prepare the statement. */
925
941
                if (sqlite3_prepare_v2 (self->priv->connection,
926
 
                                        "SELECT content, is_important, day, month, year, edited_day, edited_month, edited_year, version FROM entries "
927
 
                                        "ORDER BY year DESC, month DESC, day DESC", -1,
928
 
                                        (sqlite3_stmt**) &(iter->statement), NULL) != SQLITE_OK) {
 
942
                                        "SELECT e.content, e.is_important, e.day, e.month, e.year, e.edited_day, e.edited_month, e.edited_year, e.version, GROUP_CONCAT(et.tag) AS tags FROM entries AS e "
 
943
                                        "LEFT JOIN entry_tag AS et ON (e.day=et.day AND e.month=et.month AND e.year=et.year) "
 
944
                                        "GROUP BY e.year, e.month, e.day "
 
945
                                        "ORDER BY e.year DESC, e.month DESC, e.day DESC", -1,
 
946
                                        (sqlite3_stmt**) &(iter->statement), NULL) != SQLITE_OK) {
929
947
                        return NULL;
930
948
                }
931
949
 
945
963
                case SQLITE_ROW: {
946
964
                        GtkTextIter text_iter;
947
965
                        AlmanahEntry *entry = build_entry_from_statement (statement);
 
966
                        const gchar *tags = sqlite3_column_text (statement, 9);
948
967
 
949
968
                        /* Deserialise the entry into our buffer */
950
969
                        gtk_text_buffer_set_text (text_buffer, "", 0);
962
981
                                                          NULL, NULL, NULL) == TRUE) {
963
982
                                /* A match was found! */
964
983
                                return entry;
 
984
                        } else if (tags != NULL && (strstr (tags, search_string) != NULL)) {
 
985
                                /* A match in an entry tag */
 
986
                                return entry;
965
987
                        }
966
988
 
967
989
                        /* Free stuff up and return the next match instead */
1298
1320
{
1299
1321
        return (plain == TRUE) ? self->priv->plain_filename : self->priv->filename;
1300
1322
}
 
1323
 
 
1324
/**
 
1325
 * almanah_storage_manager_entry_add_tag:
 
1326
 * @self: an #AlmanahStorageManager
 
1327
 * @entry: an #AlmanahEntry
 
1328
 * @tag: a string
 
1329
 *
 
1330
 * Append the string in @tag as a tag for the entry @entry. If the @tag is empty or the @entry don't be previuslly saved, returns %FALSE
 
1331
 *
 
1332
 * Return value: %TRUE on success, %FALSE otherwise
 
1333
 */
 
1334
gboolean
 
1335
almanah_storage_manager_entry_add_tag (AlmanahStorageManager *self, AlmanahEntry *entry, const gchar *tag)
 
1336
{
 
1337
        GDate entry_last_edited;
 
1338
        GDate entry_date;
 
1339
        sqlite3_stmt *statement;
 
1340
        gint result_error;
 
1341
 
 
1342
        g_return_val_if_fail (ALMANAH_IS_STORAGE_MANAGER (self), FALSE);
 
1343
        g_return_val_if_fail (ALMANAH_IS_ENTRY (entry), FALSE);
 
1344
        g_return_val_if_fail (g_utf8_strlen (tag, 1) == 1, FALSE);
 
1345
 
 
1346
        almanah_entry_get_date (entry, &entry_date);
 
1347
        if (g_date_valid (&entry_date) != TRUE) {
 
1348
                g_debug ("Invalid entry date");
 
1349
                return FALSE;
 
1350
        }
 
1351
 
 
1352
        /* Don't duplicate tags */
 
1353
        if (almanah_storage_manager_entry_check_tag (self, entry, tag)) {
 
1354
                g_debug ("Duplicated tag now allowed");
 
1355
                return FALSE;
 
1356
        }
 
1357
 
 
1358
        if ((result_error = sqlite3_prepare_v2 (self->priv->connection,
 
1359
                                                "INSERT INTO entry_tag (year, month, day, tag) VALUES (?, ?, ?, ?)",
 
1360
                                                -1, &statement, NULL)) != SQLITE_OK) {
 
1361
                g_debug ("Can't prepare statement. SQLite error code: %d", result_error);
 
1362
                return FALSE;
 
1363
        }
 
1364
 
 
1365
        sqlite3_bind_int (statement, 1, g_date_get_year (&entry_date));
 
1366
        sqlite3_bind_int (statement, 2, g_date_get_month (&entry_date));
 
1367
        sqlite3_bind_int (statement, 3, g_date_get_day (&entry_date));
 
1368
        /* @TODO: STATIC or TRANSIENT */
 
1369
        sqlite3_bind_text (statement, 4, tag, -1, SQLITE_STATIC);
 
1370
 
 
1371
        if (sqlite3_step (statement) != SQLITE_DONE) {
 
1372
                sqlite3_finalize (statement);
 
1373
                g_debug ("Can't save tag");
 
1374
                return FALSE;
 
1375
        }
 
1376
 
 
1377
        sqlite3_finalize (statement);
 
1378
 
 
1379
        g_signal_emit (self, storage_manager_signals[SIGNAL_ENTRY_TAG_ADDED], 0, entry, g_strdup (tag));
 
1380
 
 
1381
        return TRUE;
 
1382
}
 
1383
 
 
1384
/**
 
1385
 * almanah_storage_manager_entry_remove_tag:
 
1386
 * @self: an #AlmanahStorageManager
 
1387
 * @entry: an #AlmanahEntry
 
1388
 * @tag: a string with the tag to be removed
 
1389
 *
 
1390
 * Remove the tag with the given string in @tag as a tag for the entry @entry.
 
1391
 *
 
1392
 * Return value: %TRUE on success, %FALSE otherwise
 
1393
 */
 
1394
gboolean
 
1395
almanah_storage_manager_entry_remove_tag (AlmanahStorageManager *self, AlmanahEntry *entry, const gchar *tag)
 
1396
{
 
1397
        GDate date;
 
1398
        gboolean result;
 
1399
 
 
1400
        g_return_val_if_fail (ALMANAH_IS_STORAGE_MANAGER (self), FALSE);
 
1401
        g_return_val_if_fail (ALMANAH_IS_ENTRY (entry), FALSE);
 
1402
        g_return_val_if_fail (g_utf8_strlen (tag, 1) == 1, FALSE);
 
1403
 
 
1404
        almanah_entry_get_date (entry, &date);
 
1405
 
 
1406
        result = simple_query (self, "DELETE FROM entry_tag WHERE year = %u AND month = %u AND day = %u AND tag = '%s'", NULL,
 
1407
                               g_date_get_year (&date),
 
1408
                               g_date_get_month (&date),
 
1409
                               g_date_get_day (&date),
 
1410
                               tag);
 
1411
 
 
1412
        if (result)
 
1413
                g_signal_emit (self, storage_manager_signals[SIGNAL_ENTRY_TAG_REMOVED], 0, entry, tag);
 
1414
 
 
1415
        return result;
 
1416
}
 
1417
 
 
1418
/**
 
1419
 * almanah_storage_manager_entry_get_tags:
 
1420
 * @self: an #AlmanahStorageManager
 
1421
 * @entry: an #AlmanahEntry
 
1422
 *
 
1423
 * Gets the tags added to an entry by the user from the database.
 
1424
 */
 
1425
GList *
 
1426
almanah_storage_manager_entry_get_tags (AlmanahStorageManager *self, AlmanahEntry *entry)
 
1427
{
 
1428
        GList *tags = NULL;
 
1429
        GDate date;
 
1430
        sqlite3_stmt *statement;
 
1431
        gint result;
 
1432
 
 
1433
        g_return_val_if_fail (ALMANAH_IS_STORAGE_MANAGER (self), FALSE);
 
1434
        g_return_val_if_fail (ALMANAH_IS_ENTRY (entry), FALSE);
 
1435
 
 
1436
        almanah_entry_get_date (entry, &date);
 
1437
        if (g_date_valid (&date) != TRUE) {
 
1438
                g_debug ("Invalid entry date");
 
1439
                return NULL;
 
1440
        }
 
1441
 
 
1442
        if (sqlite3_prepare_v2 (self->priv->connection,
 
1443
                                "SELECT DISTINCT tag FROM entry_tag WHERE year = ? AND month = ? AND day = ?",
 
1444
                                -1, &statement, NULL) != SQLITE_OK) {
 
1445
                g_debug ("Can't prepare statement");
 
1446
                return NULL;
 
1447
        }
 
1448
 
 
1449
        sqlite3_bind_int (statement, 1, g_date_get_year (&date));
 
1450
        sqlite3_bind_int (statement, 2, g_date_get_month (&date));
 
1451
        sqlite3_bind_int (statement, 3, g_date_get_day (&date));
 
1452
 
 
1453
        while ((result = sqlite3_step (statement)) == SQLITE_ROW) {
 
1454
                tags = g_list_append (tags, g_strdup (sqlite3_column_text (statement, 0)));
 
1455
        }
 
1456
 
 
1457
        sqlite3_finalize (statement);
 
1458
 
 
1459
        if (result != SQLITE_DONE) {
 
1460
                g_debug ("Error querying for tags from database: %s", sqlite3_errmsg (self->priv->connection));
 
1461
                g_free (tags);
 
1462
                tags = NULL;
 
1463
        }
 
1464
 
 
1465
        return tags;
 
1466
}
 
1467
 
 
1468
/**
 
1469
 * almanah_storage_manager_entry_check_tag:
 
1470
 * @self: an #AlmanahStorageManager
 
1471
 * @entry: an #AlmanahEntry to check into it
 
1472
 * @tag: the tag to be checked
 
1473
 *
 
1474
 * Check if a tag has been added to an entry
 
1475
 *
 
1476
 * Return value: TRUE if the tag already added to the entry, FALSE otherwise
 
1477
 */
 
1478
gboolean
 
1479
almanah_storage_manager_entry_check_tag (AlmanahStorageManager *self, AlmanahEntry *entry, const gchar *tag)
 
1480
{
 
1481
        gboolean result, q_result;
 
1482
        sqlite3_stmt *statement;
 
1483
        GDate date;
 
1484
 
 
1485
        g_return_val_if_fail (ALMANAH_IS_STORAGE_MANAGER (self), FALSE);
 
1486
        g_return_val_if_fail (ALMANAH_IS_ENTRY (entry), FALSE);
 
1487
        g_return_val_if_fail (g_utf8_strlen (tag, 1) == 1, FALSE);
 
1488
 
 
1489
        result = FALSE;
 
1490
 
 
1491
        almanah_entry_get_date (entry, &date);
 
1492
        if (g_date_valid (&date) != TRUE) {
 
1493
                g_debug ("Invalid entry date");
 
1494
                return FALSE;
 
1495
        }
 
1496
 
 
1497
        if (sqlite3_prepare_v2 (self->priv->connection, 
 
1498
                                "SELECT count(1) FROM entry_tag WHERE year = ? AND month = ? AND day = ? AND tag = ?",
 
1499
                                -1, &statement, NULL) != SQLITE_OK) {
 
1500
                g_debug ("Can't prepare statement");
 
1501
                return FALSE;
 
1502
        }
 
1503
 
 
1504
        sqlite3_bind_int (statement, 1, g_date_get_year (&date));
 
1505
        sqlite3_bind_int (statement, 2, g_date_get_month (&date));
 
1506
        sqlite3_bind_int (statement, 3, g_date_get_day (&date));
 
1507
        sqlite3_bind_text (statement, 4, tag, -1, SQLITE_STATIC);
 
1508
 
 
1509
        if ((q_result  = sqlite3_step (statement)) == SQLITE_ROW) {
 
1510
                if (sqlite3_column_int (statement, 0) > 0)
 
1511
                        result = TRUE;
 
1512
        }
 
1513
 
 
1514
        if (q_result != SQLITE_DONE) {
 
1515
                g_debug ("Error querying for a tag from database: %s", sqlite3_errmsg (self->priv->connection));
 
1516
        }
 
1517
 
 
1518
        sqlite3_finalize (statement);
 
1519
 
 
1520
        return result;
 
1521
}
 
1522
 
 
1523
 
 
1524
/**
 
1525
 * almanah_storage_manager_get_tags:
 
1526
 * @self: an #AlmanahStorageManager
 
1527
 *
 
1528
 * Gets all the tags added to entries by the user from the database.
 
1529
 *
 
1530
 * Return value: #GList with all the tags.
 
1531
 */
 
1532
GList *
 
1533
almanah_storage_manager_get_tags (AlmanahStorageManager *self)
 
1534
{
 
1535
        GList *tags = NULL;
 
1536
        sqlite3_stmt *statement;
 
1537
        gint result;
 
1538
 
 
1539
        g_return_val_if_fail (ALMANAH_IS_STORAGE_MANAGER (self), FALSE);
 
1540
 
 
1541
        if ((result = sqlite3_prepare_v2 (self->priv->connection, "SELECT DISTINCT tag FROM entry_tag", -1, &statement, NULL)) != SQLITE_OK) {
 
1542
                g_debug ("Can't prepare statement, error code: %d", result);
 
1543
                return NULL;
 
1544
        }
 
1545
 
 
1546
        while ((result = sqlite3_step (statement)) == SQLITE_ROW) {
 
1547
                tags = g_list_append (tags, g_strdup (sqlite3_column_text (statement, 0)));
 
1548
        }
 
1549
 
 
1550
        sqlite3_finalize (statement);
 
1551
 
 
1552
        if (result != SQLITE_DONE) {
 
1553
                g_debug ("Error querying for tags from database: %s", sqlite3_errmsg (self->priv->connection));
 
1554
                g_free (tags);
 
1555
                tags = NULL;
 
1556
        }
 
1557
 
 
1558
        return tags;
 
1559
}