Changeset 40

Show
Ignore:
Timestamp:
03/08/07 15:57:12 (2 years ago)
Author:
inz
Message:

Depend on dbus-glib 0.61 to get "aa{sv}" working.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • blog-service/trunk/bs-manager.c

    r35 r40  
    66 
    77#include "bs-manager.h" 
     8#include "blog.h" 
     9 
     10typedef struct _BsManagerPrivate BsManagerPrivate; 
     11struct _BsManagerPrivate { 
     12        GHashTable *blogs; 
     13}; 
     14#define BS_MANAGER_GET_PRIVATE(obj) \ 
     15        (G_TYPE_INSTANCE_GET_PRIVATE ((obj), \ 
     16                                      BS_TYPE_MANAGER, BsManagerPrivate)); 
    817 
    918static void bs_manager_init(BsManager *manager); 
    1019static void bs_manager_class_init(BsManagerClass *klass); 
     20static void bs_manager_finalize(GObject *object); 
     21static void _g_value_free(gpointer pointer); 
    1122 
    1223static gboolean bs_manager_get_blogs(BsManager *manager, 
    1324                const gchar **fields, 
    14                 GHashTable ***return_values, 
     25                GPtrArray **return_values, 
    1526                GError **error); 
    1627static gboolean bs_manager_get_blog_posts(BsManager *manager, 
    1728                const gchar *blog_id, 
    1829                const gchar **fields, 
    19                 GHashTable ***return_values, 
     30                GPtrArray **return_values, 
    2031                GError **error); 
    2132static gboolean bs_manager_get_blog_categories(BsManager *manager, 
     
    3243                GHashTable *fields, 
    3344                gboolean *status, 
    34                 GError **error); 
     45                DBusGMethodInvocation *context); 
     46static gboolean bs_manager_blog_edit_post(BsManager *manager, 
     47                const gchar *blog_id, 
     48                const gchar *post_id, 
     49                GHashTable *fields, 
     50                gboolean *status, 
     51                DBusGMethodInvocation *context); 
    3552 
    3653#include "bs-manager.inc" 
     54 
     55struct GetBlogClosure { 
     56        GPtrArray *array; 
     57        const gchar **fields; 
     58}; 
     59 
     60static void _bs_manager_populate_blogs(gpointer key, 
     61                gpointer value, 
     62                gpointer closure) 
     63{ 
     64        struct GetBlogClosure *clo = closure; 
     65        Blog *blog = value; 
     66        guint i; 
     67        GHashTable *return_blog = g_hash_table_new_full(g_str_hash, 
     68                        g_str_equal, 
     69                        g_free, 
     70                        _g_value_free); 
     71        for (i = 0; clo->fields[i]; i++) { 
     72                GValue *val = NULL; 
     73                if (!strcmp(clo->fields[i], "id")) { 
     74                        val = g_value_init(g_new0(GValue, 1), G_TYPE_STRING); 
     75                        g_value_set_string(val, key); 
     76                } else if (!strcmp(clo->fields[i], "name")) { 
     77                        val = g_value_init(g_new0(GValue, 1), G_TYPE_STRING); 
     78                        g_value_set_string(val, blog->name); 
     79                } else if (!strcmp(clo->fields[i], "categories")) { 
     80                        guint i = g_slist_length(blog->categories); 
     81                        GSList *iter; 
     82                        gchar **cats = g_new0(gchar *, i); 
     83                        i = 0; 
     84                        for (iter = blog->categories; iter; 
     85                                        iter = iter->next) { 
     86                                BlogCategory *cat = iter->data; 
     87                                cats[i] = g_strdup(cat->id); 
     88                                i++; 
     89                        } 
     90                        val = g_value_init(g_new0(GValue, 1), 
     91                                        G_TYPE_STRV); 
     92                        g_value_take_boxed(val, cats); 
     93                } 
     94                if (val) { 
     95                        g_hash_table_replace(return_blog, 
     96                                        g_strdup(clo->fields[i]), 
     97                                        val); 
     98                } 
     99        } 
     100        g_ptr_array_add(clo->array, return_blog); 
     101} 
    37102 
    38103static gboolean bs_manager_get_blogs(BsManager *manager, 
    39104                const gchar **fields, 
    40                 GHashTable ***return_values, 
     105                GPtrArray **return_values,  
    41106                GError **error) 
    42107{ 
     108        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     109        struct GetBlogClosure clo; 
     110 
     111        clo.array = g_ptr_array_new(); 
     112        clo.fields = fields; 
     113        g_hash_table_foreach(priv->blogs, _bs_manager_populate_blogs, &clo); 
     114 
     115        *return_values = clo.array; 
     116 
    43117        return TRUE; 
    44118} 
     119 
    45120static gboolean bs_manager_get_blog_posts(BsManager *manager, 
    46121                const gchar *blog_id, 
    47122                const gchar **fields, 
    48                 GHashTable ***return_values, 
     123                GPtrArray **return_values,  
    49124                GError **error) 
    50125{ 
    51         if (strcmp(blog_id, "blog")) { 
     126        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     127        GSList *iter; 
     128        Blog *blog; 
     129 
     130        if (!(blog = g_hash_table_lookup(priv->blogs, blog_id))) { 
    52131                *error = g_error_new(g_quark_from_string("blog-service"), 
    53132                                404, 
     
    56135                return FALSE; 
    57136        } 
    58         *return_values = g_new0(GHashTable *, 2); 
    59         (*return_values)[0] = g_hash_table_new_full(g_str_hash, 
    60                                                     g_str_equal, 
    61                                                     NULL, 
    62                                                     NULL); 
    63         (*return_values)[1] = NULL; 
     137 
     138        *return_values = g_ptr_array_new(); 
     139        for (iter = blog->posts; iter; iter = iter->next) 
     140        { 
     141                BlogPost *post = iter->data; 
     142                GHashTable *return_post = g_hash_table_new_full(g_str_hash, 
     143                                g_str_equal, 
     144                                g_free, 
     145                                _g_value_free); 
     146                guint i; 
     147                for (i = 0; fields[i]; i++) { 
     148                        GValue *val = NULL; 
     149                        if (!strcmp(fields[i], "postid")) { 
     150                                val = g_value_init(g_new0(GValue, 1), 
     151                                                G_TYPE_STRING); 
     152                                g_value_set_string(val, post->id); 
     153                        } else if (!strcmp(fields[i], "title")) { 
     154                                val = g_value_init(g_new0(GValue, 1), 
     155                                                G_TYPE_STRING); 
     156                                g_value_set_string(val, post->title); 
     157                        } else if (!strcmp(fields[i], "description")) { 
     158                                val = g_value_init(g_new0(GValue, 1), 
     159                                                G_TYPE_STRING); 
     160                                g_value_set_string(val, post->content); 
     161                        } else if (!strcmp(fields[i], "categories") || 
     162                                        !strcmp(fields[i], "category")) { 
     163                                guint i = g_slist_length(post->categories); 
     164                                GSList *iter; 
     165                                gchar **cats = g_new0(gchar *, i); 
     166                                i = 0; 
     167                                for (iter = post->categories; iter; 
     168                                                iter = iter->next) { 
     169                                        BlogCategory *cat = iter->data; 
     170                                        cats[i] = g_strdup(cat->id); 
     171                                        i++; 
     172                                } 
     173                                val = g_value_init(g_new0(GValue, 1), 
     174                                                G_TYPE_STRV); 
     175                                g_value_take_boxed(val, cats); 
     176                        } else { 
     177                                GSList *fld_iter; 
     178                                for (fld_iter = post->extra_fields; 
     179                                                fld_iter; 
     180                                                fld_iter = fld_iter->next) { 
     181                                        BlogParameter *prm = fld_iter->data; 
     182                                        if (!strcmp(fields[i], prm->name)) { 
     183                                                val = g_new0(GValue, 1); 
     184                                                g_value_copy(&prm->value, 
     185                                                                val); 
     186                                                break; 
     187                                        } 
     188                                } 
     189                        } 
     190                        if (val) { 
     191                                g_hash_table_replace(return_post, 
     192                                                g_strdup(fields[i]), 
     193                                                val); 
     194                        } 
     195                } 
     196                g_ptr_array_add(*return_values, return_post); 
     197        } 
    64198 
    65199        return TRUE; 
     
    70204                GError **error) 
    71205{ 
    72         if (strcmp(blog_id, "blog")) { 
     206        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     207        GSList *iter; 
     208        Blog *blog; 
     209        guint i; 
     210 
     211        if (!(blog = g_hash_table_lookup(priv->blogs, blog_id))) { 
    73212                *error = g_error_new(g_quark_from_string("blog-service"), 
    74213                                404, 
     
    77216                return FALSE; 
    78217        } 
    79         *categories = g_new0(gchar *, 2); 
    80         (*categories)[0] = g_strdup("category"); 
    81         (*categories)[1] = NULL; 
     218 
     219        i = g_slist_length(blog->categories); 
     220        *categories = g_new0(gchar *, i); 
     221        i = 0; 
     222        for (iter = blog->categories; iter; 
     223                        iter = iter->next) { 
     224                BlogCategory *cat = iter->data; 
     225                (*categories)[i] = g_strdup(cat->id); 
     226                i++; 
     227        } 
    82228        return TRUE; 
    83229} 
     230 
    84231static gboolean bs_manager_blog_create_category(BsManager *manager, 
    85232                const gchar *blog_id, 
     
    88235                GError **error) 
    89236{ 
    90         if (strcmp(blog_id, "blog")) { 
    91                 *error = g_error_new(g_quark_from_string("blog-service"), 
     237        *error = g_error_new(g_quark_from_string("blog-service"), 
     238                        501, 
     239                        "Method not implemented." 
     240                        ); 
     241        return FALSE; 
     242
     243 
     244struct CreatePostClosure { 
     245        BlogPost *post; 
     246        Blog *blog; 
     247        DBusGMethodInvocation *context; 
     248        gboolean publish; 
     249}; 
     250 
     251static void _bs_manager_posted(Blog *blog, BlogPost *post, gboolean status, 
     252                const BlogPluginError *error, gpointer user_data) 
     253
     254        struct CreatePostClosure *clo = user_data; 
     255 
     256        (void)blog; 
     257 
     258        if (error) { 
     259                GError *gerror = g_error_new( 
     260                                g_quark_from_string("blog-service"), 
     261                                error->error_code, 
     262                                "%s", 
     263                                error->error_string); 
     264                dbus_g_method_return_error(clo->context, gerror); 
     265                blog_post_free(post); 
     266        } 
     267        dbus_g_method_return(clo->context, status); 
     268 
     269        if (!status) { 
     270                blog_post_free(post); 
     271        } 
     272
     273 
     274static void _bs_manager_populate_post(gpointer key, 
     275                gpointer value, 
     276                gpointer closure) 
     277
     278        struct CreatePostClosure *clo = closure; 
     279 
     280        if (!strcmp(key, "title")) { 
     281                if (clo->post->title)  
     282                        g_free(clo->post->title); 
     283                clo->post->title = g_value_dup_string(value); 
     284        } else if (!strcmp(key, "description")) { 
     285                if (clo->post->content) 
     286                        g_free(clo->post->content); 
     287                clo->post->content = g_value_dup_string(value); 
     288        } else if (!strcmp(key, "publish")) { 
     289                clo->publish = g_value_get_boolean(value); 
     290        } else if (!strcmp(key, "categories") || 
     291                        !strcmp(key, "category")) { 
     292                gchar **cats = g_value_get_boxed(value); 
     293                GSList *iter; 
     294                guint i; 
     295                if (clo->post->categories) 
     296                        g_slist_free(clo->post->categories); 
     297                clo->post->categories = NULL; 
     298                for (i = 0; cats[i]; i++) { 
     299                        for (iter = clo->blog->categories; 
     300                                        iter; 
     301                                        iter = iter->next) { 
     302                                BlogCategory *cat = iter->data; 
     303                                if (!strcmp(cat->id, cats[i])) { 
     304                                        clo->post->categories = g_slist_append( 
     305                                                        clo->post->categories, 
     306                                                        cat); 
     307                                        break; 
     308                                } 
     309                        } 
     310                } 
     311        } else { 
     312                GSList *iter; 
     313                for (iter = clo->post->extra_fields; iter; iter = iter->next) 
     314                { 
     315                        BlogParameter *parm = iter->data; 
     316                        if (!strcmp(parm->name, key)) { 
     317                                g_value_unset(&parm->value); 
     318                                g_value_copy(value, &parm->value); 
     319                        } 
     320                } 
     321                if (!iter) { 
     322                        BlogParameter *parm = g_new0(BlogParameter, 1); 
     323                        parm->name = g_strdup(key); 
     324                        g_value_copy(value, &parm->value); 
     325                        clo->post->extra_fields = g_slist_append( 
     326                                        clo->post->extra_fields, 
     327                                        parm); 
     328                } 
     329        } 
     330
     331 
     332static gboolean bs_manager_blog_create_post(BsManager *manager, 
     333                const gchar *blog_id, 
     334                GHashTable *fields, 
     335                gboolean *status, 
     336                DBusGMethodInvocation *context) 
     337
     338        GError *error; 
     339        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     340        Blog *blog; 
     341        struct CreatePostClosure clo; 
     342 
     343        if (!(blog = g_hash_table_lookup(priv->blogs, blog_id))) { 
     344                error = g_error_new(g_quark_from_string("blog-service"), 
    92345                                404, 
    93346                                "No such blog." 
    94347                                ); 
    95                 return FALSE; 
    96         } 
     348                dbus_g_method_return_error(context, error); 
     349                return FALSE; 
     350        } 
     351 
     352        clo.post = g_new0(BlogPost, 1); 
     353        clo.blog = blog; 
     354        clo.publish = TRUE; 
     355 
     356        g_hash_table_foreach(fields, _bs_manager_populate_post, &clo); 
     357 
     358        if (!clo.post->title || !clo.post->content) { 
     359                error = g_error_new(g_quark_from_string("blog-service"), 
     360                                412, 
     361                                "No title or content." 
     362                                ); 
     363                blog_post_free(clo.post); 
     364                dbus_g_method_return_error(context, error); 
     365                return FALSE; 
     366        } 
     367 
     368        blog->plugin->newPost(blog, 
     369                        clo.post, 
     370                        clo.publish, 
     371                        _bs_manager_posted, 
     372                        &clo); 
     373 
    97374        *status = FALSE; 
    98375        return TRUE; 
    99376} 
    100 static gboolean bs_manager_blog_create_post(BsManager *manager, 
    101                 const gchar *blog_id, 
     377 
     378static gboolean bs_manager_blog_edit_post(BsManager *manager, 
     379                const gchar *blog_id, 
     380                const gchar *post_id, 
    102381                GHashTable *fields, 
    103382                gboolean *status, 
    104                 GError **error) 
    105 
    106         if (strcmp(blog_id, "blog")) { 
    107                 *error = g_error_new(g_quark_from_string("blog-service"), 
     383                DBusGMethodInvocation *context) 
     384
     385        GError *error; 
     386        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     387        Blog *blog; 
     388        GSList *iter; 
     389        struct CreatePostClosure clo; 
     390 
     391        if (!(clo.blog = g_hash_table_lookup(priv->blogs, blog_id))) { 
     392                error = g_error_new(g_quark_from_string("blog-service"), 
    108393                                404, 
    109394                                "No such blog." 
    110395                                ); 
    111                 return FALSE; 
    112         } 
     396                dbus_g_method_return_error(context, error); 
     397                return FALSE; 
     398        } 
     399 
     400        for (iter = clo.blog->posts; iter; iter = iter->next) { 
     401                BlogPost *post = iter->data; 
     402 
     403                if (!strcmp(post->id, post_id)) { 
     404                        clo.post = post; 
     405                        break; 
     406                } 
     407        } 
     408 
     409        if (!(clo.blog = g_hash_table_lookup(priv->blogs, blog_id))) { 
     410                error = g_error_new(g_quark_from_string("blog-service"), 
     411                                404, 
     412                                "No such post." 
     413                                ); 
     414                dbus_g_method_return_error(context, error); 
     415                return FALSE; 
     416        } 
     417 
     418        clo.publish = TRUE; 
     419 
     420        g_hash_table_foreach(fields, _bs_manager_populate_post, &clo); 
     421 
     422        if (!clo.post->title || !clo.post->content) { 
     423                error = g_error_new(g_quark_from_string("blog-service"), 
     424                                412, 
     425                                "No title or content." 
     426                                ); 
     427                blog_post_free(clo.post); 
     428                dbus_g_method_return_error(context, error); 
     429                return FALSE; 
     430        } 
     431 
     432        blog->plugin->editPost(blog, 
     433                        clo.post, 
     434                        clo.publish, 
     435                        _bs_manager_posted, 
     436                        &clo); 
     437 
    113438        *status = FALSE; 
    114439        return TRUE; 
     
    147472static void bs_manager_init(BsManager *manager) 
    148473{ 
     474        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     475        priv->blogs = g_hash_table_new_full(g_str_hash, g_str_equal, 
     476                        g_free, (GDestroyNotify)blog_unref); 
    149477} 
    150478 
    151479static void bs_manager_class_init(BsManagerClass *klass) 
    152480{ 
     481        GObjectClass *obj_class = G_OBJECT_CLASS(klass); 
     482 
     483        obj_class->finalize = bs_manager_finalize; 
     484        g_type_class_add_private(klass, sizeof(BsManagerPrivate)); 
     485} 
     486 
     487static void bs_manager_finalize(GObject *object) 
     488{ 
     489        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(object); 
     490        g_hash_table_destroy(priv->blogs); 
    153491} 
    154492 
     
    157495        return (BsManager *)g_object_new(BS_TYPE_MANAGER, NULL); 
    158496} 
     497 
     498void bs_manager_add_blog(BsManager *manager, const gchar *name, Blog *blog) 
     499{ 
     500        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     501 
     502        g_hash_table_replace(priv->blogs, g_strdup(name), blog_ref(blog)); 
     503} 
     504void bs_manager_drop_blog(BsManager *manager, const gchar *name) 
     505{ 
     506        BsManagerPrivate *priv = BS_MANAGER_GET_PRIVATE(manager); 
     507 
     508        g_hash_table_remove(priv->blogs, name); 
     509} 
     510 
     511static void _g_value_free(gpointer pointer) 
     512{ 
     513        g_value_unset(pointer); 
     514        g_free(pointer); 
     515} 
  • blog-service/trunk/bs-manager.h

    r35 r40  
    33 
    44#include <glib.h> 
     5#include "blog.h" 
    56 
    67#define BS_TYPE_MANAGER (bs_manager_get_type()) 
     
    2526GType bs_manager_get_type(void); 
    2627BsManager *bs_manager_new(void); 
     28void bs_manager_add_blog(BsManager *manager, const gchar *name, Blog *blog); 
     29void bs_manager_drop_blog(BsManager *manager, const gchar *name); 
    2730 
    2831#endif 
  • blog-service/trunk/debian/control

    r35 r40  
    33Priority: optional 
    44Maintainer: Santtu Lakkala <ext-santtu.1.lakkala@nokia.com> 
    5 Build-Depends: debhelper (>= 4.0.0), libglib2.0-dev, libdbus-glib-1-dev 
     5Build-Depends: debhelper (>= 4.0.0), libglib2.0-dev, libdbus-glib-1-dev (>= 0.61) 
    66Standards-Version: 3.6.0 
    77