Handled disabled update items.

7 files changed, 205 insertions, 18 deletions

diff --git a/src/analysis/db/client.c b/src/analysis/db/client.c
index beb30c1..4c525e1 100644
--- a/src/analysis/db/client.c
+++ b/src/analysis/db/client.c
@@ -104,6 +104,12 @@ static bool g_hub_client_start_common(GHubClient *, char *);
 /* Assure l'accueil des nouvelles mises à jour. */
 static void *g_hub_client_update(GHubClient *);
 
+/* Identifie le canal de communication pour envois au serveur. */
+static SSL *g_hub_client_get_ssl_fd(GHubClient *);
+
+/* Marque le canal de communication comme disponible. */
+static void g_hub_client_put_ssl_fd(GHubClient *, SSL *);
+
 
 
 /* Indique le type défini pour une description de client à l'écoute. */
@@ -890,7 +896,7 @@ void g_hub_client_stop(GHubClient *client)
 *                                                                             *
 ******************************************************************************/
 
-SSL *g_hub_client_get_ssl_fd(GHubClient *client)
+static SSL *g_hub_client_get_ssl_fd(GHubClient *client)
 {
     SSL *result;                            /* Canal à retourner           */
 #ifndef NDEBUG
@@ -932,7 +938,7 @@ SSL *g_hub_client_get_ssl_fd(GHubClient *client)
 *                                                                             *
 ******************************************************************************/
 
-void g_hub_client_put_ssl_fd(GHubClient *client, SSL *tls_fd)
+static void g_hub_client_put_ssl_fd(GHubClient *client, SSL *tls_fd)
 {
     g_mutex_unlock(&client->sending_lock);
 
@@ -986,6 +992,63 @@ bool g_hub_client_save(GHubClient *client)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : client = client pour les accès distants à manipuler.         *
+*                item   = élémnent à pousser vers un serveur de collection.   *
+*                                                                             *
+*  Description : Ajoute un élément à la collection d'un serveur.              *
+*                                                                             *
+*  Retour      : true si la commande a bien été envoyée, false sinon.         *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+bool g_hub_client_add_item(GHubClient *client, const GDbItem *item)
+{
+    bool result;                            /* Bilan partiel à remonter    */
+    packed_buffer out_pbuf;                 /* Tampon d'émission           */
+    SSL *tls_fd;                            /* Canal de communication SSL  */
+    DBFeatures feature;                     /* Domaine de fonctionnalité   */
+    GDbCollection *collec;                  /* Collection visée au final   */
+
+    init_packed_buffer(&out_pbuf);
+
+    tls_fd = g_hub_client_get_ssl_fd(client);
+
+    if (tls_fd == NULL)
+        result = false;
+
+    else
+    {
+        feature = g_db_item_get_feature(item);
+
+        collec = find_collection_in_list(client->collections, feature);
+        if (collec == NULL)
+        {
+            result = false;
+            goto bad_item_feature;
+        }
+
+        result = g_db_collection_pack(collec, &out_pbuf, DBA_ADD_ITEM, item);
+
+        if (result)
+            result = ssl_send_packed_buffer(&out_pbuf, tls_fd);
+
+ bad_item_feature:
+
+        g_hub_client_put_ssl_fd(client, tls_fd);
+
+    }
+
+    exit_packed_buffer(&out_pbuf);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : client    = client pour les accès distants à manipuler.      *
 *                timestamp = date du dernier élément à garder comme actif.    *
 *                                                                             *
diff --git a/src/analysis/db/client.h b/src/analysis/db/client.h
index 2915f77..f7f7bcb 100644
--- a/src/analysis/db/client.h
+++ b/src/analysis/db/client.h
@@ -64,15 +64,12 @@ bool g_hub_client_start_remote(GHubClient *, const char *, const char *, bool);
 /* Arrête la connexion à la base de données. */
 void g_hub_client_stop(GHubClient *);
 
-/* Identifie le canal de communication pour envois au serveur. */
-SSL *g_hub_client_get_ssl_fd(GHubClient *);
-
-/* Marque le canal de communication comme disponible. */
-void g_hub_client_put_ssl_fd(GHubClient *, SSL *);
-
 /* Effectue une demande de sauvegarde de l'état courant. */
 bool g_hub_client_save(GHubClient *);
 
+/* Ajoute un élément à la collection d'un serveur. */
+bool g_hub_client_add_item(GHubClient *, const GDbItem *);
+
 /* Active les éléments en amont d'un horodatage donné. */
 bool g_hub_client_set_last_active(GHubClient *, timestamp_t);
 
diff --git a/src/analysis/db/collection.c b/src/analysis/db/collection.c
index 7b2082a..6e877a4 100644
--- a/src/analysis/db/collection.c
+++ b/src/analysis/db/collection.c
@@ -36,6 +36,7 @@
 #include "collection-int.h"
 #include "misc/rlestr.h"
 #include "../../common/extstr.h"
+#include "../../common/sort.h"
 #include "../../glibext/chrysamarshal.h"
 
 
@@ -56,14 +57,8 @@ static void g_db_collection_dispose(GDbCollection *);
 /* Procède à la libération totale de la mémoire. */
 static void g_db_collection_finalize(GDbCollection *);
 
-
-
-#define g_db_collection_find_by_timestamped(c, i) c->count
-
-#define g_db_collection_find_by_timestamp(c, i) c->count
-
-
-
+/* Retrouve l'élément correspondant à un horodatage. */
+size_t g_db_collection_find_by_timestamped(GDbCollection *, const GDbItem *);
 
 /* Ajoute un élément dans la liste des éléments actifs. */
 static void g_db_collection_set_last_item(GDbCollection *, GDbItem *, bool);
@@ -71,6 +66,9 @@ static void g_db_collection_set_last_item(GDbCollection *, GDbItem *, bool);
 /* Retire un élément de la liste des éléments courants. */
 static void g_db_collection_unset_last_item(GDbCollection *, GDbItem *, size_t);
 
+/* Retrouve le premier élément correspondant à un horodatage. */
+size_t g_db_collection_find_by_timestamp(GDbCollection *, timestamp_t);
+
 
 
 /* --------------------- MANIPULATIONS AVEC UNE BASE DE DONNEES --------------------- */
@@ -453,7 +451,7 @@ bool g_db_collection_unpack(GDbCollection *collec, packed_buffer *pbuf, sqlite3
 *                                                                             *
 ******************************************************************************/
 
-bool g_db_collection_pack(GDbCollection *collec, packed_buffer *pbuf, DBAction action, GDbItem *item)
+bool g_db_collection_pack(GDbCollection *collec, packed_buffer *pbuf, DBAction action, const GDbItem *item)
 {
     bool result;                            /* Bilan à retourner           */
 
@@ -617,6 +615,37 @@ GDbItem *g_db_collection_has_key(GDbCollection *collec, ...)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : binary = élément binaire à consulter.                        *
+*                item   = définition de l'élément à retrouver.                *
+*                                                                             *
+*  Description : Retrouve l'élément correspondant à un horodatage.            *
+*                                                                             *
+*  Retour      : Indice valide pour un élément retrouvé, invalide sinon.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_db_collection_find_by_timestamped(GDbCollection *collec, const GDbItem *item)
+{
+    size_t result;                          /* Indice à retourner          */
+    GDbItem **found;                        /* Emplacement de la trouvaille*/
+
+    found = bsearch(&item, collec->items, collec->count, sizeof(GDbItem *),
+                    (__compar_fn_t)g_db_item_cmp_timestamp);
+
+    if (found == NULL)
+        result = collec->count;
+    else
+        result = found - collec->items;
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : collec = ensemble d'éléments à consulter.                    *
 *                item   = élément complet dont un double est à rechercher.    *
 *                                                                             *
@@ -942,6 +971,43 @@ static void g_db_collection_unset_last_item(GDbCollection *collec, GDbItem *item
 *                                                                             *
 *  Paramètres  : binary    = élément binaire à consulter.                     *
 *                timestamp = date du dernier élément à garder comme actif.    *
+*                                                                             *
+*  Description : Retrouve le premier élément correspondant à un horodatage.   *
+*                                                                             *
+*  Retour      : Indice valide pour un élément retrouvé, invalide sinon.      *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+size_t g_db_collection_find_by_timestamp(GDbCollection *collec, timestamp_t timestamp)
+{
+    size_t result;                          /* Indice à retourner          */
+    timestamp_t prev_ts;                    /* Horodatage précédent        */
+
+    bsearch_index(&timestamp, collec->items, collec->count, sizeof(GDbItem *),
+                  (__compar_fn_t)g_db_item_cmp_with_timestamp, &result);
+
+    while (result > 0)
+    {
+        prev_ts = g_db_item_get_timestamp(collec->items[result - 1]);
+
+        if (cmp_timestamp(&prev_ts, &timestamp) != 0)
+            break;
+
+        result--;
+
+    }
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : binary    = élément binaire à consulter.                     *
+*                timestamp = date du dernier élément à garder comme actif.    *
 *                db        = base de données à mettre à jour.                 *
 *                pbuf      = paquet de données où venir inscrire les infos.   *
 *                                                                             *
diff --git a/src/analysis/db/collection.h b/src/analysis/db/collection.h
index 9539229..76d134b 100644
--- a/src/analysis/db/collection.h
+++ b/src/analysis/db/collection.h
@@ -75,7 +75,7 @@ bool _g_db_collection_unpack(GDbCollection *, packed_buffer *, DBAction *, GDbIt
 bool g_db_collection_unpack(GDbCollection *, packed_buffer *, sqlite3 *);
 
 /* Envoie pour traitement une requête réseau pour collection. */
-bool g_db_collection_pack(GDbCollection *, packed_buffer *, DBAction, GDbItem *);
+bool g_db_collection_pack(GDbCollection *, packed_buffer *, DBAction, const GDbItem *);
 
 /* Envoie pour mise à jour tous les éléments courants. */
 bool g_db_collection_pack_all_updates(GDbCollection *, packed_buffer *);
diff --git a/src/analysis/db/item-int.h b/src/analysis/db/item-int.h
index 35fca94..93472c5 100644
--- a/src/analysis/db/item-int.h
+++ b/src/analysis/db/item-int.h
@@ -70,6 +70,7 @@ struct _GDbItem
     GObject parent;                         /* A laisser en premier        */
 
     timestamp_t created;                    /* Date de création            */
+    unsigned long index;                    /* Indice au sein d'un groupe  */
 
     rle_string author;                      /* Utilisateur d'origine       */
 
diff --git a/src/analysis/db/item.c b/src/analysis/db/item.c
index 029b1d6..c880d65 100644
--- a/src/analysis/db/item.c
+++ b/src/analysis/db/item.c
@@ -31,6 +31,7 @@
 
 
 #include "item-int.h"
+#include "../../common/sort.h"
 #include "../../core/params.h"
 
 
@@ -116,6 +117,8 @@ static void g_db_item_class_init(GDbItemClass *klass)
 
 static void g_db_item_init(GDbItem *item)
 {
+    item->index = 0;
+
     set_static_rle_string(&item->author, "");
 
     g_atomic_int_set(&item->atomic_flags, DIF_NONE);
@@ -257,6 +260,57 @@ gboolean g_db_item_cmp_key(const GDbItem *a, const GDbItem *b)
 
 /******************************************************************************
 *                                                                             *
+*  Paramètres  : a = premier élément à analyser.                              *
+*                b = second élément à analyser.                               *
+*                                                                             *
+*  Description : Effectue la comparaison entre deux éléments de collection.   *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int g_db_item_cmp_timestamp(const GDbItem **a, const GDbItem **b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = cmp_timestamp(&(*a)->created, &(*b)->created);
+
+    if (result == 0)
+        result = sort_unsigned_long((*a)->index, (*b)->index);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
+*  Paramètres  : ts = premier élément à analyser.                             *
+*                b  = second élément à analyser.                              *
+*                                                                             *
+*  Description : Effectue la comparaison entre un élément et un horodatage.   *
+*                                                                             *
+*  Retour      : Bilan de la comparaison : -1, 0 ou 1.                        *
+*                                                                             *
+*  Remarques   : -                                                            *
+*                                                                             *
+******************************************************************************/
+
+int g_db_item_cmp_with_timestamp(const timestamp_t *ts, const GDbItem **b)
+{
+    int result;                             /* Bilan à retourner           */
+
+    result = cmp_timestamp(ts, &(*b)->created);
+
+    return result;
+
+}
+
+
+/******************************************************************************
+*                                                                             *
 *  Paramètres  : a    = premier élément à analyser.                           *
 *                b    = second élément à analyser.                            *
 *                with = précise les horodatages à prendre en compte.          *
diff --git a/src/analysis/db/item.h b/src/analysis/db/item.h
index b735fb8..32c296a 100644
--- a/src/analysis/db/item.h
+++ b/src/analysis/db/item.h
@@ -84,6 +84,12 @@ guint g_db_item_hash_key(const GDbItem *);
 gboolean g_db_item_cmp_key(const GDbItem *, const GDbItem *);
 
 /* Effectue la comparaison entre deux éléments de collection. */
+int g_db_item_cmp_timestamp(const GDbItem **, const GDbItem **);
+
+/* Effectue la comparaison entre un élément et un horodatage. */
+int g_db_item_cmp_with_timestamp(const timestamp_t *, const GDbItem **);
+
+/* Effectue la comparaison entre deux éléments de collection. */
 gint g_db_item_cmp(GDbItem *, GDbItem *, bool);
 
 /* Effectue la comparaison entre deux éléments de collection. */