X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fblogview_renderer.c;h=0a0510a295af2128adbfdfdc070e5115f4618fd3;hb=3cf89d4ed1bf883353080ec945a28c0022461a4b;hp=1a18297f07ec035bfbbfb4ede8c688936e5ba72d;hpb=a066e10a45c321c47a9a06bd309651039833cf2a;p=citadel.git diff --git a/webcit/blogview_renderer.c b/webcit/blogview_renderer.c index 1a18297f0..0a0510a29 100644 --- a/webcit/blogview_renderer.c +++ b/webcit/blogview_renderer.c @@ -1,44 +1,158 @@ /* * Blog view renderer module for WebCit * - * Copyright (c) 1996-2010 by the citadel.org team + * Copyright (c) 1996-2012 by the citadel.org team * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 3 of the License, or - * (at your option) any later version. + * This program is open source software. You can redistribute it and/or + * modify it under the terms of the GNU General Public License, version 3. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include "webcit.h" #include "webserver.h" -#include "groupdav.h" +#include "dav.h" -/* - * Data which gets passed around between the various functions in this module - * - */ +CtxType CTX_BLOGPOST = CTX_NONE; -struct blogpost { - long msgnum; - int id; - int refs; - int comment_count; -}; +typedef struct __BLOG { + HashList *BLOGPOSTS; + long p; + int gotonext; + StrBuf *Charset; + StrBuf *Buf; +} BLOG; -struct blogview { - struct blogpost *msgs; /* Array of msgnums for messages we are displaying */ +/* + * Array type for a blog post. The first message is the post; the rest are comments + */ +typedef struct _blogpost { + int top_level_id; + long *msgs; /* Array of msgnums for messages we are displaying */ int num_msgs; /* Number of msgnums stored in 'msgs' */ int alloc_msgs; /* Currently allocated size of array */ -}; + int unread_oments; +}blogpost; + + +/* + * XML sitemap generator -- go through the message list for a Blog room + */ +void sitemap_do_blog(void) { + wcsession *WCC = WC; + blogpost oneBP; + int num_msgs = 0; + int i; + SharedMessageStatus Stat; + message_summary *Msg = NULL; + StrBuf *Buf = NewStrBuf(); + StrBuf *FoundCharset = NewStrBuf(); + WCTemplputParams SubTP; + + memset(&Stat, 0, sizeof Stat); + memset(&oneBP, 0, sizeof(blogpost)); + memset(&SubTP, 0, sizeof(WCTemplputParams)); + StackContext(NULL, &SubTP, &oneBP, CTX_BLOGPOST, 0, NULL); + + Stat.maxload = INT_MAX; + Stat.lowest_found = (-1); + Stat.highest_found = (-1); + num_msgs = load_msg_ptrs("MSGS ALL", NULL, &Stat, NULL); + if (num_msgs < 1) return; + + for (i=0; isumm); + if (Msg != NULL) { + ReadOneMessageSummary(Msg, FoundCharset, Buf); + /* Show only top level posts, not comments */ + if ((Msg->reply_inreplyto_hash != 0) && (Msg->reply_references_hash == 0)) { + oneBP.top_level_id = Msg->reply_inreplyto_hash; + DoTemplate(HKEY("view_blog_sitemap"), WCC->WBuf, &SubTP); + } + } + } + UnStackContext(&SubTP); + FreeStrBuf(&Buf); + FreeStrBuf(&FoundCharset); +} + + + +/* + * Generate a permalink for a post + * (Call with NULL arguments to make this function wcprintf() the permalink + * instead of writing it to the template) + */ +void tmplput_blog_toplevel_id(StrBuf *Target, WCTemplputParams *TP) { + blogpost *bp = (blogpost*) CTX(CTX_BLOGPOST); + char buf[SIZ]; + snprintf(buf, SIZ, "%d", bp->top_level_id); + StrBufAppendTemplateStr(Target, TP, buf, 0); +} + +void tmplput_blog_comment_count(StrBuf *Target, WCTemplputParams *TP) { + blogpost *bp = (blogpost*) CTX(CTX_BLOGPOST); + char buf[SIZ]; + snprintf(buf, SIZ, "%d", bp->num_msgs -1); + StrBufAppendTemplateStr(Target, TP, buf, 0); +} +void tmplput_blog_comment_unread_count(StrBuf *Target, WCTemplputParams *TP) { + blogpost *bp = (blogpost*) CTX(CTX_BLOGPOST); + char buf[SIZ]; + snprintf(buf, SIZ, "%d", bp->unread_oments); + StrBufAppendTemplateStr(Target, TP, buf, 0); +} + + + +/* + * Render a single blog post and (optionally) its comments + */ +void blogpost_render(blogpost *bp, int with_comments) +{ + wcsession *WCC = WC; + WCTemplputParams SubTP; + const StrBuf *Mime; + int i; + + memset(&SubTP, 0, sizeof(WCTemplputParams)); + StackContext(NULL, &SubTP, bp, CTX_BLOGPOST, 0, NULL); + + /* Always show the top level post, unless we somehow ended up with an empty list */ + if (bp->num_msgs > 0) { + read_message(WC->WBuf, HKEY("view_blog_post"), bp->msgs[0], NULL, &Mime); + } + + if (with_comments) { + /* Show any existing comments, then offer the comment box */ + DoTemplate(HKEY("view_blog_show_commentlink"), WCC->WBuf, &SubTP); + + for (i=1; inum_msgs; ++i) { + read_message(WC->WBuf, HKEY("view_blog_comment"), bp->msgs[i], NULL, &Mime); + } + DoTemplate(HKEY("view_blog_comment_box"), WCC->WBuf, &SubTP); + } + + else { + /* Show only the number of comments */ + DoTemplate(HKEY("view_blog_show_no_comments"), WCC->WBuf, &SubTP); + } + UnStackContext(&SubTP); +} + + +/* + * Destructor for "blogpost" + */ +void blogpost_destroy(blogpost *bp) { + if (bp->alloc_msgs > 0) { + free(bp->msgs); + } + free(bp); +} /* @@ -48,11 +162,19 @@ int blogview_GetParamsGetServerCall(SharedMessageStatus *Stat, void **ViewSpecific, long oper, char *cmd, - long len) + long len, + char *filter, + long flen) { - struct blogview *BLOG = malloc(sizeof(struct blogview)); - memset(BLOG, 0, sizeof(struct blogview)); - *ViewSpecific = BLOG; + BLOG *BL = (BLOG*) malloc(sizeof(BLOG)); + BL->BLOGPOSTS = NewHash(1, lFlathash); + + /* are we looking for a specific post? */ + BL->p = lbstr("p"); + BL->gotonext = havebstr("gotonext"); + BL->Charset = NewStrBuf(); + BL->Buf = NewStrBuf(); + *ViewSpecific = BL; Stat->startmsg = (-1); /* not used here */ Stat->sortit = 1; /* not used here */ @@ -61,7 +183,8 @@ int blogview_GetParamsGetServerCall(SharedMessageStatus *Stat, /* perform a "read all" call to fetch the message list -- we'll cut it down later */ rlid[2].cmd(cmd, len); - + if (BL->gotonext) + Stat->load_seen = 1; return 200; } @@ -75,119 +198,200 @@ int blogview_LoadMsgFromServer(SharedMessageStatus *Stat, int is_new, int i) { - struct blogview *BLOG = (struct blogview *) *ViewSpecific; + BLOG *BL = (BLOG*) *ViewSpecific; + blogpost *bp = NULL; + + ReadOneMessageSummary(Msg, BL->Charset, BL->Buf); - if (BLOG->alloc_msgs == 0) { - BLOG->alloc_msgs = 1000; - BLOG->msgs = malloc(BLOG->alloc_msgs * sizeof(struct blogpost)); - memset(BLOG->msgs, 0, (BLOG->alloc_msgs * sizeof(struct blogpost)) ); + /* Stop processing if the viewer is only interested in a single post and + * that message ID is neither the id nor the refs. + */ + if ((BL->p != 0) && + (BL->p != Msg->reply_inreplyto_hash) && + (BL->p != Msg->reply_references_hash)) { + return 200; } - /* Check our buffer size */ - if (BLOG->num_msgs >= BLOG->alloc_msgs) { - BLOG->alloc_msgs *= 2; - BLOG->msgs = realloc(BLOG->msgs, (BLOG->alloc_msgs * sizeof(long))); - memset(&BLOG->msgs[BLOG->num_msgs], 0, ((BLOG->alloc_msgs - BLOG->num_msgs) * sizeof(long)) ); + /* + * Add our little bundle of blogworthy wonderfulness to the hash table + */ + if (Msg->reply_references_hash == 0) { + bp = malloc(sizeof(blogpost)); + if (!bp) return(200); + memset(bp, 0, sizeof (blogpost)); + bp->top_level_id = Msg->reply_inreplyto_hash; + Put(BL->BLOGPOSTS, + (const char *)&Msg->reply_inreplyto_hash, + sizeof(Msg->reply_inreplyto_hash), + bp, + (DeleteHashDataFunc)blogpost_destroy); + } + else { + GetHash(BL->BLOGPOSTS, + (const char *)&Msg->reply_references_hash, + sizeof(Msg->reply_references_hash), + (void *)&bp); } - BLOG->msgs[BLOG->num_msgs++].msgnum = Msg->msgnum; - BLOG->msgs[BLOG->num_msgs].id = 0; - BLOG->msgs[BLOG->num_msgs].refs = 0; - BLOG->msgs[BLOG->num_msgs].comment_count = 0; + /* + * Now we have a 'blogpost' to which we can add a message. It's either the + * blog post itself or a comment attached to it; either way, the code is the same from + * this point onward. + */ + if (bp != NULL) { + if (bp->alloc_msgs == 0) { + bp->alloc_msgs = 1000; + bp->msgs = malloc(bp->alloc_msgs * sizeof(long)); + memset(bp->msgs, 0, (bp->alloc_msgs * sizeof(long)) ); + } + if (bp->num_msgs >= bp->alloc_msgs) { + bp->alloc_msgs *= 2; + bp->msgs = realloc(bp->msgs, (bp->alloc_msgs * sizeof(long))); + memset(&bp->msgs[bp->num_msgs], 0, + ((bp->alloc_msgs - bp->num_msgs) * sizeof(long)) ); + } + bp->msgs[bp->num_msgs++] = Msg->msgnum; + if ((Msg->Flags & MSGFLAG_READ) != 0) { + bp->unread_oments++; + } + } + else { + syslog(LOG_DEBUG, "** comment %ld is unparented", Msg->msgnum); + } return 200; } - /* - * Sort a list of 'struct blogpost' objects by newest-to-oldest msgnum. + * Sort a list of 'struct blogpost' pointers by newest-to-oldest msgnum. + * With big thanks to whoever wrote http://www.c.happycodings.com/Sorting_Searching/code14.html */ -int blogview_sortfunc(const void *s1, const void *s2) { - struct blogpost *l1 = (struct blogpost *)(s1); - struct blogpost *l2 = (struct blogpost *)(s2); +static int blogview_sortfunc(const void *a, const void *b) { + blogpost * const *one = a; + blogpost * const *two = b; - if (l1->msgnum > l2->msgnum) return(-1); - if (l1->msgnum < l2->msgnum) return(+1); + if ( (*one)->msgs[0] > (*two)->msgs[0] ) return(-1); + if ( (*one)->msgs[0] < (*two)->msgs[0] ) return(+1); return(0); } - /* - * Given a 'struct blogpost' containing a msgnum, populate the id - * and refs fields by fetching them from the Citadel server + * All blogpost entries are now in the hash list. + * Sort them, select the desired range, and render what we want to see. */ -void blogview_learn_thread_references(struct blogpost *bp) +int blogview_render(SharedMessageStatus *Stat, void **ViewSpecific, long oper) { - StrBuf *Buf; - Buf = NewStrBuf(); - serv_printf("MSG0 %ld|1", bp->msgnum); /* top level citadel headers only */ - StrBuf_ServGetln(Buf); - if (GetServerStatus(Buf, NULL) == 1) { - while (StrBuf_ServGetln(Buf), strcmp(ChrPtr(Buf), "000")) { - if (!strncasecmp(ChrPtr(Buf), "msgn=", 5)) { - StrBufCutLeft(Buf, 5); - bp->id = HashLittle(ChrPtr(Buf), StrLength(Buf)); - } - else if (!strncasecmp(ChrPtr(Buf), "wefw=", 5)) { - StrBufCutLeft(Buf, 5); /* trim the field name */ - StrBufCutAt(Buf, 0, "|"); /* trim all but the first thread ref */ - bp->refs = HashLittle(ChrPtr(Buf), StrLength(Buf)); + wcsession *WCC = WC; + BLOG *BL = (BLOG*) *ViewSpecific; + HashPos *it; + const char *Key; + void *Data; + long len; + int i; + blogpost **blogposts = NULL; + int num_blogposts = 0; + int num_blogposts_alloc = 0; + int with_comments = 0; + int firstp = 0; + int maxp = 0; + WCTemplputParams SubTP; + blogpost oneBP; + + memset(&SubTP, 0, sizeof(WCTemplputParams)); + memset(&oneBP, 0, sizeof(blogpost)); + + /* Comments are shown if we are only viewing a single blog post */ + with_comments = (BL->p != 0); + + firstp = ibstr("firstp"); /* start reading at... */ + maxp = ibstr("maxp"); /* max posts to show... */ + if (maxp < 1) maxp = 5; /* default; move somewhere else? */ + putlbstr("maxp", maxp); + + it = GetNewHashPos(BL->BLOGPOSTS, 0); + + if ((BL->gotonext) && (BL->p == 0)) { + /* did we come here via gotonext? lets find out whether + * this blog has just one blogpost with new comments just display + * this one. + */ + blogpost *unread_bp = NULL; + int unread_count = 0; + while (GetNextHashPos(BL->BLOGPOSTS, it, &len, &Key, &Data)) { + blogpost *one_bp = (blogpost *) Data; + if (one_bp->unread_oments > 0) { + unread_bp = one_bp; + unread_count++; } } - } - FreeStrBuf(&Buf); -} - - + if (unread_count == 1) { + blogpost_render(unread_bp, 1); + DeleteHashPos(&it); + return 0; + } -int blogview_render(SharedMessageStatus *Stat, void **ViewSpecific, long oper) -{ - struct blogview *BLOG = (struct blogview *) *ViewSpecific; - int i; - - /* Pass #1 - sort */ - if (Stat->nummsgs > 0) { - lprintf(9, "sorting %d messages\n", BLOG->num_msgs); - qsort(BLOG->msgs, (size_t)(BLOG->num_msgs), sizeof(struct blogpost), blogview_sortfunc); + RewindHashPos(BL->BLOGPOSTS, it, 0); } - /* Pass #2 - learn thread references */ - lprintf(9, "learning thread references\n"); - for (i=0; (inum_msgs); ++i) { - if (BLOG->msgs[i].msgnum > 0L) { - blogview_learn_thread_references(&BLOG->msgs[i]); + /* Iterate through the hash list and copy the data pointers into an array */ + while (GetNextHashPos(BL->BLOGPOSTS, it, &len, &Key, &Data)) { + if (num_blogposts >= num_blogposts_alloc) { + if (num_blogposts_alloc == 0) { + num_blogposts_alloc = 100; + } + else { + num_blogposts_alloc *= 2; + } + blogposts = realloc(blogposts, (num_blogposts_alloc * sizeof (blogpost *))); } + blogposts[num_blogposts++] = (blogpost *) Data; } + DeleteHashPos(&it); - /* Pass #3 - turn it into a thread tree */ - /* FIXME implement this */ - - /* Pass #4 - render - * This will require several different modes: - * * Top level - * * Single story permalink - * * Comments - * * etc + /* Now we have our array. It is ONLY an array of pointers. The objects to + * which they point are still owned by the hash list. */ - for (i=0; (inum_msgs); ++i) { - if (BLOG->msgs[i].msgnum > 0L) { - if (BLOG->msgs[i].refs == 0) { - wc_printf(""); + if (num_blogposts > 0) { + int start_here = 0; + /* Sort newest-to-oldest */ + qsort(blogposts, num_blogposts, sizeof(void *), blogview_sortfunc); + + /* allow the user to select a starting point in the list */ + for (i=0; itop_level_id == firstp) { + start_here = i; } - wc_printf("Message %d, #%ld, id %d, refs %d", - i, - BLOG->msgs[i].msgnum, - BLOG->msgs[i].id, - BLOG->msgs[i].refs - ); - if (BLOG->msgs[i].refs == 0) { - wc_printf(""); + } + + /* FIXME -- allow the user (or a default setting) to select a maximum number of posts to display */ + + /* Now go through the list and render what we've got */ + for (i=start_here; i 0) && (i == start_here)) { + int j = i - maxp; + if (j < 0) j = 0; + + StackContext(NULL, &SubTP, &blogposts[j], CTX_BLOGPOST, 0, NULL); + DoTemplate(HKEY("view_blog_post_start"), WCC->WBuf, &SubTP); + UnStackContext(&SubTP); + } + if (i < (start_here + maxp)) { + blogpost_render(blogposts[i], with_comments); + } + else if (i == (start_here + maxp)) { + StackContext(NULL, &SubTP, &blogposts[i], CTX_BLOGPOST, 0, NULL); + DoTemplate(HKEY("view_blog_post_stop"), WCC->WBuf, &SubTP); + UnStackContext(&SubTP); } - wc_printf("
\n"); } + + /* Done. We are only freeing the array of pointers; the data itself + * will be freed along with the hash list. + */ + free(blogposts); } return(0); @@ -196,13 +400,12 @@ int blogview_render(SharedMessageStatus *Stat, void **ViewSpecific, long oper) int blogview_Cleanup(void **ViewSpecific) { - struct blogview *BLOG = (struct blogview *) *ViewSpecific; - - if (BLOG->alloc_msgs != 0) { - free(BLOG->msgs); - } - free(BLOG); + BLOG *BL = (BLOG*) *ViewSpecific; + FreeStrBuf(&BL->Buf); + FreeStrBuf(&BL->Charset); + DeleteHash(&BL->BLOGPOSTS); + free(BL); wDumpContent(1); return 0; } @@ -212,13 +415,20 @@ void InitModule_BLOGVIEWRENDERERS (void) { + RegisterCTX(CTX_BLOGPOST); + RegisterReadLoopHandlerset( VIEW_BLOG, blogview_GetParamsGetServerCall, NULL, + NULL, NULL, blogview_LoadMsgFromServer, blogview_render, blogview_Cleanup ); + + RegisterNamespace("BLOG:TOPLEVEL:MSGID", 0, 0, tmplput_blog_toplevel_id, NULL, CTX_BLOGPOST); + RegisterNamespace("BLOG:COMMENTS:COUNT", 0, 0, tmplput_blog_comment_count, NULL, CTX_BLOGPOST); + RegisterNamespace("BLOG:COMMENTS:UNREAD:COUNT", 0, 0, tmplput_blog_comment_unread_count, NULL, CTX_BLOGPOST); }