X-Git-Url: https://code.citadel.org/?a=blobdiff_plain;f=webcit%2Fblogview_renderer.c;h=0a0510a295af2128adbfdfdc070e5115f4618fd3;hb=3cf89d4ed1bf883353080ec945a28c0022461a4b;hp=949fd179a3a90ea4b29061adebb4c5e28b34b523;hpb=2993a1dc1eb0a043c3ebeff83cf6f9cfad8adb93;p=citadel.git diff --git a/webcit/blogview_renderer.c b/webcit/blogview_renderer.c index 949fd179a..0a0510a29 100644 --- a/webcit/blogview_renderer.c +++ b/webcit/blogview_renderer.c @@ -1,91 +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" + +CtxType CTX_BLOGPOST = CTX_NONE; +typedef struct __BLOG { + HashList *BLOGPOSTS; + long p; + int gotonext; + StrBuf *Charset; + StrBuf *Buf; +} BLOG; /* * Array type for a blog post. The first message is the post; the rest are comments */ -struct blogpost { +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); +} + /* - * Destructor for 'struct blogpost' which does the rendering first. - * By rendering from here, we eliminate the need for a separate iterator, although - * we might run into trouble when we get around to displaying newest-to-oldest... + * Render a single blog post and (optionally) its comments */ -void blogpost_render_and_destroy(struct blogpost *bp) { +void blogpost_render(blogpost *bp, int with_comments) +{ + wcsession *WCC = WC; + WCTemplputParams SubTP; const StrBuf *Mime; - int p = 0; int i; - p = atoi(BSTR("p")); /* are we looking for a specific post? */ + memset(&SubTP, 0, sizeof(WCTemplputParams)); + StackContext(NULL, &SubTP, bp, CTX_BLOGPOST, 0, NULL); - if ( ((p == 0) || (p == bp->top_level_id)) && (bp->num_msgs > 0) ) { - /* Show the top level post */ + /* 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 (p == 0) { - /* Show the number of comments */ - wc_printf("top_level_id); - urlescputs(ChrPtr(WC->CurRoom.name)); - wc_printf("#comments\">"); - wc_printf(_("%d comments"), bp->num_msgs - 1); - wc_printf(""); - } - else if (bp->num_msgs < 2) { - wc_printf(_("%d comments"), 0); - } - else { - wc_printf("\n"); - wc_printf(_("%d comments"), bp->num_msgs - 1); - wc_printf("
\n"); - for (i=1; inum_msgs; ++i) { - read_message(WC->WBuf, HKEY("view_blog_comment"), bp->msgs[i], 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); } - - if (bp->alloc_msgs > 0) { - free(bp->msgs); + else { + /* Show only the number of comments */ + DoTemplate(HKEY("view_blog_show_no_comments"), WCC->WBuf, &SubTP); } - free(bp); + UnStackContext(&SubTP); } /* - * Data which gets returned from a call to blogview_learn_thread_references() + * Destructor for "blogpost" */ -struct bltr { - int id; - int refs; -}; +void blogpost_destroy(blogpost *bp) { + if (bp->alloc_msgs > 0) { + free(bp->msgs); + } + free(bp); +} /* @@ -95,10 +162,19 @@ int blogview_GetParamsGetServerCall(SharedMessageStatus *Stat, void **ViewSpecific, long oper, char *cmd, - long len) + long len, + char *filter, + long flen) { - HashList *BLOG = NewHash(1, NULL); - *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 */ @@ -107,43 +183,12 @@ 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; } -/* - * Given a 'struct blogpost' containing a msgnum, populate the id - * and refs fields by fetching them from the Citadel server - */ -struct bltr blogview_learn_thread_references(long msgnum) -{ - StrBuf *Buf; - StrBuf *r; - struct bltr bltr = { 0, 0 } ; - Buf = NewStrBuf(); - r = NewStrBuf(); - serv_printf("MSG0 %ld|1", 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); - bltr.id = HashLittle(ChrPtr(Buf), StrLength(Buf)); - } - else if (!strncasecmp(ChrPtr(Buf), "wefw=", 5)) { - StrBufCutLeft(Buf, 5); /* trim the field name */ - StrBufExtract_token(r, Buf, 0, '|'); - bltr.refs = HashLittle(ChrPtr(r), StrLength(r)); - } - } - } - FreeStrBuf(&Buf); - FreeStrBuf(&r); - return(bltr); -} - - /* * This function is called for every message in the list. */ @@ -153,32 +198,43 @@ int blogview_LoadMsgFromServer(SharedMessageStatus *Stat, int is_new, int i) { - HashList *BLOG = (HashList *) *ViewSpecific; - struct bltr b; - struct blogpost *bp = NULL; + BLOG *BL = (BLOG*) *ViewSpecific; + blogpost *bp = NULL; - b = blogview_learn_thread_references(Msg->msgnum); + ReadOneMessageSummary(Msg, BL->Charset, BL->Buf); - /* FIXME an optimization here -- one we ought to perform -- is to exit this - * function immediately if the viewer is only interested in a single post and - * that message ID is neither the id nor the refs. Actually, that might *be* - * the way to display only a single message (with or without comments). + /* 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; + } - if (b.refs == 0) { - bp = malloc(sizeof(struct blogpost)); + /* + * 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 (struct blogpost)); - bp->top_level_id = b.id; - Put(BLOG, (const char *)&b.id, sizeof(b.id), bp, - (DeleteHashDataFunc)blogpost_render_and_destroy); + 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(BLOG, (const char *)&b.refs , sizeof(b.refs), (void *)&bp); + GetHash(BL->BLOGPOSTS, + (const char *)&Msg->reply_references_hash, + sizeof(Msg->reply_references_hash), + (void *)&bp); } /* - * Now we have a 'struct blogpost' to which we can add a message. It's either the + * 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. */ @@ -195,6 +251,12 @@ int blogview_LoadMsgFromServer(SharedMessageStatus *Stat, ((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; @@ -202,26 +264,135 @@ int blogview_LoadMsgFromServer(SharedMessageStatus *Stat, /* - * 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) { - long *l1 = (long *)(s1); - long *l2 = (long *)(s2); +static int blogview_sortfunc(const void *a, const void *b) { + blogpost * const *one = a; + blogpost * const *two = b; - if (*l1 > *l2) return(-1); - if (*l1 < *l2) return(+1); + if ( (*one)->msgs[0] > (*two)->msgs[0] ) return(-1); + if ( (*one)->msgs[0] < (*two)->msgs[0] ) return(+1); return(0); } +/* + * All blogpost entries are now in the hash list. + * Sort them, select the desired range, and render what we want to see. + */ int blogview_render(SharedMessageStatus *Stat, void **ViewSpecific, long oper) { - /*HashList *BLOG = (HashList *) *ViewSpecific;*/ + 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++; + } + } + if (unread_count == 1) { + blogpost_render(unread_bp, 1); - /* - * No code needed here -- we render during disposition. - * Maybe this is the location where we want to handle pretty permalinks. + DeleteHashPos(&it); + return 0; + } + + RewindHashPos(BL->BLOGPOSTS, it, 0); + } + + /* 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); + + /* 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. */ + 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; + } + } + + /* 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); + } + } + + /* Done. We are only freeing the array of pointers; the data itself + * will be freed along with the hash list. + */ + free(blogposts); + } return(0); } @@ -229,10 +400,12 @@ int blogview_render(SharedMessageStatus *Stat, void **ViewSpecific, long oper) int blogview_Cleanup(void **ViewSpecific) { - HashList *BLOG = (HashList *) *ViewSpecific; - - DeleteHash(&BLOG); + BLOG *BL = (BLOG*) *ViewSpecific; + FreeStrBuf(&BL->Buf); + FreeStrBuf(&BL->Charset); + DeleteHash(&BL->BLOGPOSTS); + free(BL); wDumpContent(1); return 0; } @@ -242,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); }