js/feedlist.js

   1 let _infscroll_disable = 0;
   2 let _infscroll_request_sent = 0;
   3
   4 let _search_query = false;
   5 let _viewfeed_last = 0;
   6 let _viewfeed_timeout = false;
   7
   8 let counters_last_request = 0;
   9 let _counters_prev = [];
  10
  11 function resetCounterCache() {
  12         _counters_prev = [];
  13 }
  14
  15 function loadMoreHeadlines() {
  16         console.log("loadMoreHeadlines");
  17
  18         let offset = 0;
  19
  20         const view_mode = document.forms["main_toolbar_form"].view_mode.value;
  21         const unread_in_buffer = $$("#headlines-frame > div[id*=RROW][class*=Unread]").length;
  22         const num_all = $$("#headlines-frame > div[id*=RROW]").length;
  23         const num_unread = getFeedUnread(getActiveFeedId(), activeFeedIsCat());
  24
  25         // TODO implement marked & published
  26
  27         if (view_mode == "marked") {
  28                 console.warn("loadMoreHeadlines: marked is not implemented, falling back.");
  29                 offset = num_all;
  30         } else if (view_mode == "published") {
  31                 console.warn("loadMoreHeadlines: published is not implemented, falling back.");
  32                 offset = num_all;
  33         } else if (view_mode == "unread") {
  34                 offset = unread_in_buffer;
  35         } else if (_search_query) {
  36                 offset = num_all;
  37         } else if (view_mode == "adaptive" && !(getActiveFeedId() == -1 && !activeFeedIsCat())) {
  38                 // ^ starred feed shows both unread & read articles in adaptive mode
  39                 offset = num_unread > 0 ? unread_in_buffer : num_all;
  40         } else {
  41                 offset = num_all;
  42         }
  43
  44         console.log("offset: " + offset);
  45
  46         viewfeed({feed: getActiveFeedId(), is_cat: activeFeedIsCat(), offset: offset, infscroll_req: true});
  47
  48 }
  49
  50 function cleanup_memory(root) {
  51         const dijits = dojo.query("[widgetid]", dijit.byId(root).domNode).map(dijit.byNode);
  52
  53         dijits.each(function (d) {
  54                 dojo.destroy(d.domNode);
  55         });
  56
  57         $$("#" + root + " *").each(function (i) {
  58                 i.parentNode ? i.parentNode.removeChild(i) : true;
  59         });
  60 }
  61
  62 function viewfeed(params) {
  63         const feed = params.feed;
  64         let is_cat = params.is_cat;
  65         let offset = params.offset;
  66         let background = params.background;
  67         let infscroll_req = params.infscroll_req;
  68         const can_wait = params.can_wait;
  69         const viewfeed_debug = params.viewfeed_debug;
  70         const method = params.method;
  71
  72         if (is_cat == undefined)
  73                 is_cat = false;
  74         else
  75                 is_cat = !!is_cat;
  76
  77         if (offset == undefined) offset = 0;
  78         if (background == undefined) background = false;
  79         if (infscroll_req == undefined) infscroll_req = false;
  80
  81         last_requested_article = 0;
  82
  83         if (feed != getActiveFeedId() || activeFeedIsCat() != is_cat) {
  84                 if (!background && _search_query) _search_query = false;
  85         }
  86
  87         if (!background) {
  88                 _viewfeed_last = get_timestamp();
  89
  90                 if (getActiveFeedId() != feed || !infscroll_req) {
  91                         setActiveArticleId(0);
  92                         _infscroll_disable = 0;
  93
  94                         cleanup_memory("headlines-frame");
  95                         _headlines_scroll_offset = 0;
  96                 }
  97
  98                 if (infscroll_req) {
  99                         const timestamp = get_timestamp();
 100
 101                         if (_infscroll_request_sent && _infscroll_request_sent + 30 > timestamp) {
 102                                 //console.log("infscroll request in progress, aborting");
 103                                 return;
 104                         }
 105
 106                         _infscroll_request_sent = timestamp;
 107                 }
 108         }
 109
 110         Form.enable("main_toolbar_form");
 111
 112         const toolbar_query = Form.serialize("main_toolbar_form");
 113
 114         let query = "?op=feeds&method=view&feed=" + param_escape(feed) + "&" +
 115                 toolbar_query;
 116
 117         if (method) query += "&m=" + param_escape(method);
 118
 119         if (offset > 0) {
 120                 if (current_first_id) {
 121                         query = query + "&fid=" + param_escape(current_first_id);
 122                 }
 123         }
 124
 125         if (!background) {
 126                 if (_search_query) {
 127                         query = query + "&" + _search_query;
 128                         //_search_query = false;
 129                 }
 130
 131                 if (offset != 0) {
 132                         query = query + "&skip=" + offset;
 133
 134                         // to prevent duplicate feed titles when showing grouped vfeeds
 135                         if (vgroup_last_feed) {
 136                                 query = query + "&vgrlf=" + param_escape(vgroup_last_feed);
 137                         }
 138                 } else if (!is_cat && feed == getActiveFeedId() && !params.method) {
 139                                 query = query + "&m=ForceUpdate";
 140                         }
 141
 142                 Form.enable("main_toolbar_form");
 143
 144                 if (!setFeedExpandoIcon(feed, is_cat,
 145                         (is_cat) ? 'images/indicator_tiny.gif' : 'images/indicator_white.gif'))
 146                                 notify_progress("Loading, please wait...", true);
 147         }
 148
 149         query += "&cat=" + is_cat;
 150
 151         console.log(query);
 152
 153         if (can_wait && _viewfeed_timeout) {
 154                 setFeedExpandoIcon(getActiveFeedId(), activeFeedIsCat(), 'images/blank_icon.gif');
 155                 clearTimeout(_viewfeed_timeout);
 156         }
 157
 158         setActiveFeedId(feed, is_cat);
 159
 160         if (viewfeed_debug) {
 161                 window.open("backend.php" + query + "&debug=1&csrf_token=" + getInitParam("csrf_token"));
 162         }
 163
 164         const timeout_ms = can_wait ? 250 : 0;
 165         _viewfeed_timeout = setTimeout(function() {
 166
 167                 new Ajax.Request("backend.php", {
 168                         parameters: query,
 169                         onComplete: function(transport) {
 170                                 try {
 171                                         setFeedExpandoIcon(feed, is_cat, 'images/blank_icon.gif');
 172                                         headlines_callback2(transport, offset, background, infscroll_req);
 173                                         PluginHost.run(PluginHost.HOOK_FEED_LOADED, [feed, is_cat]);
 174                                 } catch (e) {
 175                                         exception_error(e);
 176                                 }
 177                         } });
 178         }, timeout_ms); // Wait 250ms
 179
 180 }
 181
 182 function feedlist_init() {
 183         console.log("in feedlist init");
 184
 185         loading_set_progress(50);
 186
 187         document.onkeydown = hotkey_handler;
 188         setTimeout(hotkey_prefix_timeout, 5*1000);
 189
 190         if (!getActiveFeedId()) {
 191                 viewfeed({feed: -3});
 192         } else {
 193                 viewfeed({feed: getActiveFeedId(), is_cat: activeFeedIsCat()});
 194         }
 195
 196         hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 197
 198         if (getInitParam("is_default_pw")) {
 199                 console.warn("user password is at default value");
 200
 201                 const dialog = new dijit.Dialog({
 202                         title: __("Your password is at default value"),
 203                         href: "backend.php?op=dlg&method=defaultpasswordwarning",
 204                         id: 'infoBox',
 205                         style: "width: 600px",
 206                         onCancel: function() {
 207                                 return true;
 208                         },
 209                         onExecute: function() {
 210                                 return true;
 211                         },
 212                         onClose: function() {
 213                                 return true;
 214                         }
 215                 });
 216
 217                 dialog.show();
 218         }
 219
 220         // bw_limit disables timeout() so we request initial counters separately
 221     if (getInitParam("bw_limit") == "1") {
 222                 request_counters(true);
 223     } else {
 224         setTimeout(timeout, 250);
 225     }
 226 }
 227
 228
 229 function request_counters(force) {
 230         const date = new Date();
 231         const timestamp = Math.round(date.getTime() / 1000);
 232
 233         if (force || timestamp - counters_last_request > 5) {
 234                 console.log("scheduling request of counters...");
 235
 236                 counters_last_request = timestamp;
 237
 238                 let query = "?op=rpc&method=getAllCounters&seq=" + next_seq();
 239
 240                 if (!force)
 241                         query = query + "&last_article_id=" + getInitParam("last_article_id");
 242
 243                 console.log(query);
 244
 245                 new Ajax.Request("backend.php", {
 246                         parameters: query,
 247                         onComplete: function(transport) {
 248                                 handle_rpc_json(transport);
 249                         } });
 250
 251         } else {
 252                 console.log("request_counters: rate limit reached: " + (timestamp - counters_last_request));
 253         }
 254 }
 255
 256 // NOTE: this implementation is incomplete
 257 // for general objects but good enough for counters
 258 // http://adripofjavascript.com/blog/drips/object-equality-in-javascript.html
 259 function counter_is_equal(a, b) {
 260         // Create arrays of property names
 261         const aProps = Object.getOwnPropertyNames(a);
 262         const bProps = Object.getOwnPropertyNames(b);
 263
 264         // If number of properties is different,
 265         // objects are not equivalent
 266         if (aProps.length != bProps.length) {
 267                 return false;
 268         }
 269
 270         for (let i = 0; i < aProps.length; i++) {
 271                 const propName = aProps[i];
 272
 273                 // If values of same property are not equal,
 274                 // objects are not equivalent
 275                 if (a[propName] !== b[propName]) {
 276                         return false;
 277                 }
 278         }
 279
 280         // If we made it this far, objects
 281         // are considered equivalent
 282         return true;
 283 }
 284
 285
 286 function parse_counters(elems) {
 287         for (let l = 0; l < elems.length; l++) {
 288
 289                 if (_counters_prev[l] && counter_is_equal(elems[l], _counters_prev[l])) {
 290                         continue;
 291                 }
 292
 293                 const id = elems[l].id;
 294                 const kind = elems[l].kind;
 295                 const ctr = parseInt(elems[l].counter);
 296                 const error = elems[l].error;
 297                 const has_img = elems[l].has_img;
 298                 const updated = elems[l].updated;
 299                 const auxctr = parseInt(elems[l].auxcounter);
 300
 301                 if (id == "global-unread") {
 302                         global_unread = ctr;
 303                         updateTitle();
 304                         continue;
 305                 }
 306
 307                 if (id == "subscribed-feeds") {
 308                         /* feeds_found = ctr; */
 309                         continue;
 310                 }
 311
 312                 /*if (getFeedUnread(id, (kind == "cat")) != ctr ||
 313                                 (kind == "cat")) {
 314                 }*/
 315
 316                 setFeedUnread(id, (kind == "cat"), ctr);
 317                 setFeedValue(id, (kind == "cat"), 'auxcounter', auxctr);
 318
 319                 if (kind != "cat") {
 320                         setFeedValue(id, false, 'error', error);
 321                         setFeedValue(id, false, 'updated', updated);
 322
 323                         if (id > 0) {
 324                                 if (has_img) {
 325                                         setFeedIcon(id, false,
 326                                                 getInitParam("icons_url") + "/" + id + ".ico?" + has_img);
 327                                 } else {
 328                                         setFeedIcon(id, false, 'images/blank_icon.gif');
 329                                 }
 330                         }
 331                 }
 332         }
 333
 334         hideOrShowFeeds(getInitParam("hide_read_feeds") == 1);
 335
 336         _counters_prev = elems;
 337 }
 338
 339 function getFeedUnread(feed, is_cat) {
 340         try {
 341                 const tree = dijit.byId("feedTree");
 342
 343                 if (tree && tree.model)
 344                         return tree.model.getFeedUnread(feed, is_cat);
 345
 346         } catch (e) {
 347                 //
 348         }
 349
 350         return -1;
 351 }
 352
 353 function getFeedCategory(feed) {
 354         try {
 355                 const tree = dijit.byId("feedTree");
 356
 357                 if (tree && tree.model)
 358                         return tree.getFeedCategory(feed);
 359
 360         } catch (e) {
 361                 //
 362         }
 363
 364         return false;
 365 }
 366
 367 function hideOrShowFeeds(hide) {
 368         const tree = dijit.byId("feedTree");
 369
 370         if (tree)
 371                 return tree.hideRead(hide, getInitParam("hide_read_shows_special"));
 372 }
 373
 374 function getFeedName(feed, is_cat) {
 375
 376         if (isNaN(feed)) return feed; // it's a tag
 377
 378         const tree = dijit.byId("feedTree");
 379
 380         if (tree && tree.model)
 381                 return tree.model.getFeedValue(feed, is_cat, 'name');
 382 }
 383
 384 function getFeedValue(feed, is_cat, key) {
 385         try {
 386                 const tree = dijit.byId("feedTree");
 387
 388                 if (tree && tree.model)
 389                         return tree.model.getFeedValue(feed, is_cat, key);
 390
 391         } catch (e) {
 392                 //
 393         }
 394         return '';
 395 }
 396
 397 function setFeedUnread(feed, is_cat, unread) {
 398         const tree = dijit.byId("feedTree");
 399
 400         if (tree && tree.model)
 401                 return tree.model.setFeedUnread(feed, is_cat, unread);
 402 }
 403
 404 function setFeedValue(feed, is_cat, key, value) {
 405         try {
 406                 const tree = dijit.byId("feedTree");
 407
 408                 if (tree && tree.model)
 409                         return tree.model.setFeedValue(feed, is_cat, key, value);
 410
 411         } catch (e) {
 412                 //
 413         }
 414 }
 415
 416 function selectFeed(feed, is_cat) {
 417         const tree = dijit.byId("feedTree");
 418
 419         if (tree) return tree.selectFeed(feed, is_cat);
 420 }
 421
 422 function setFeedIcon(feed, is_cat, src) {
 423         const tree = dijit.byId("feedTree");
 424
 425         if (tree) return tree.setFeedIcon(feed, is_cat, src);
 426 }
 427
 428 function setFeedExpandoIcon(feed, is_cat, src) {
 429         const tree = dijit.byId("feedTree");
 430
 431         if (tree) return tree.setFeedExpandoIcon(feed, is_cat, src);
 432
 433         return false;
 434 }
 435
 436 function getNextUnreadFeed(feed, is_cat) {
 437         const tree = dijit.byId("feedTree");
 438         const nuf = tree.model.getNextUnreadFeed(feed, is_cat);
 439
 440         if (nuf)
 441                 return tree.model.store.getValue(nuf, 'bare_id');
 442 }
 443
 444 function catchupCurrentFeed(mode) {
 445         catchupFeed(getActiveFeedId(), activeFeedIsCat(), mode);
 446 }
 447
 448 function catchupFeedInGroup(id) {
 449         const title = getFeedName(id);
 450
 451         const str = __("Mark all articles in %s as read?").replace("%s", title);
 452
 453         if (getInitParam("confirm_feed_catchup") != 1 || confirm(str)) {
 454
 455                 const rows = $$("#headlines-frame > div[id*=RROW][data-orig-feed-id='"+id+"']");
 456
 457                 if (rows.length > 0) {
 458
 459                         rows.each(function (row) {
 460                                 row.removeClassName("Unread");
 461
 462                                 if (row.getAttribute("data-article-id") != getActiveArticleId()) {
 463                                         new Effect.Fade(row, {duration: 0.5});
 464                                 }
 465
 466                         });
 467
 468                         const feedTitles = $$("#headlines-frame > div[class='cdmFeedTitle']");
 469
 470                         for (let i = 0; i < feedTitles.length; i++) {
 471                                 if (feedTitles[i].getAttribute("data-feed-id") == id) {
 472
 473                                         if (i < feedTitles.length - 1) {
 474                                                 new Effect.Fade(feedTitles[i], {duration: 0.5});
 475                                         }
 476
 477                                         break;
 478                                 }
 479                         }
 480
 481                         updateFloatingTitle(true);
 482                 }
 483
 484                 const catchup_query = "?op=rpc&method=catchupFeed&feed_id=" +
 485                                 id + "&is_cat=false";
 486
 487                 console.log(catchup_query);
 488
 489                 notify_progress("Loading, please wait...", true);
 490
 491                 new Ajax.Request("backend.php", {
 492                         parameters: catchup_query,
 493                         onComplete: function (transport) {
 494                                 handle_rpc_json(transport);
 495                         }
 496                 } );
 497
 498                 //return viewCurrentFeed('MarkAllReadGR:' + id);
 499         }
 500 }
 501
 502 function catchupFeed(feed, is_cat, mode) {
 503         if (is_cat == undefined) is_cat = false;
 504
 505         let str = false;
 506
 507         switch (mode) {
 508         case "1day":
 509                 str = __("Mark %w in %s older than 1 day as read?");
 510                 break;
 511         case "1week":
 512                 str = __("Mark %w in %s older than 1 week as read?");
 513                 break;
 514         case "2week":
 515                 str = __("Mark %w in %s older than 2 weeks as read?");
 516                 break;
 517         default:
 518                 str = __("Mark %w in %s as read?");
 519         }
 520
 521         const mark_what = last_search_query && last_search_query[0] ? __("search results") : __("all articles");
 522         const fn = getFeedName(feed, is_cat);
 523
 524         str = str.replace("%s", fn)
 525                 .replace("%w", mark_what);
 526
 527         if (getInitParam("confirm_feed_catchup") == 1 && !confirm(str)) {
 528                 return;
 529         }
 530
 531         const catchup_query = {op: 'rpc', method: 'catchupFeed', feed_id: feed,
 532                 is_cat: is_cat, mode: mode, search_query: last_search_query[0],
 533                 search_lang: last_search_query[1]};
 534
 535         console.log(catchup_query);
 536
 537         notify_progress("Loading, please wait...", true);
 538
 539         new Ajax.Request("backend.php", {
 540                 parameters: catchup_query,
 541                 onComplete: function(transport) {
 542                                 handle_rpc_json(transport);
 543
 544                                 const show_next_feed = getInitParam("on_catchup_show_next_feed") == "1";
 545
 546                                 if (show_next_feed) {
 547                                         const nuf = getNextUnreadFeed(feed, is_cat);
 548
 549                                         if (nuf) {
 550                                                 viewfeed({feed: nuf, is_cat: is_cat});
 551                                         }
 552                                 } else if (feed == getActiveFeedId() && is_cat == activeFeedIsCat()) {
 553                                                 viewCurrentFeed();
 554                                         }
 555
 556                                 notify("");
 557                         } });
 558
 559 }
 560
 561 function decrementFeedCounter(feed, is_cat) {
 562         let ctr = getFeedUnread(feed, is_cat);
 563
 564         if (ctr > 0) {
 565                 setFeedUnread(feed, is_cat, ctr - 1);
 566                 global_unread = global_unread - 1;
 567                 updateTitle();
 568
 569                 if (!is_cat) {
 570                         const cat = parseInt(getFeedCategory(feed));
 571
 572                         if (!isNaN(cat)) {
 573                                 ctr = getFeedUnread(cat, true);
 574
 575                                 if (ctr > 0) {
 576                                         setFeedUnread(cat, true, ctr - 1);
 577                                 }
 578                         }
 579                 }
 580         }
 581
 582 }
 583
 584