opac/extras/circ/alt_holds_print.js

   1 dojo.require("dojo.cookie");
   2 dojo.require("dojox.xml.parser");
   3 dojo.require("openils.BibTemplate");
   4 dojo.require("openils.widget.ProgressDialog");
   5
   6 var authtoken;
   7 var cgi;
   8
   9 function do_pull_list() {
  10     progress_dialog.show(true);
  11
  12     var any = false;
  13
  14     fieldmapper.standardRequest(
  15         ['open-ils.circ','open-ils.circ.hold_pull_list.print.stream'],
  16         { async : true,
  17           params: [
  18             authtoken, {
  19               org_id     : cgi.param('o'),
  20               limit      : cgi.param('limit'),
  21               offset     : cgi.param('offset'),
  22               chunk_size : cgi.param('chunk_size'),
  23               sort       : sort_order
  24             }
  25           ],
  26           onresponse : function (r) {
  27             any = true;
  28             dojo.forEach( openils.Util.readResponse(r), function (hold_fm) {
  29
  30                 // hashify the hold
  31                 var hold = hold_fm.toHash(true);
  32                 hold.usr = hold_fm.usr().toHash(true);
  33                 hold.usr.card = hold_fm.usr().card().toHash(true);
  34                 hold.current_copy = hold_fm.current_copy().toHash(true);
  35                 hold.current_copy.location = hold_fm.current_copy().location().toHash(true);
  36                 hold.current_copy.call_number = hold_fm.current_copy().call_number().toHash(true);
  37                 hold.current_copy.call_number.record = hold_fm.current_copy().call_number().record().toHash(true);
  38
  39                 // clone the template's html
  40                 var tr = dojo.clone(
  41                     dojo.query("tr", dojo.byId('template'))[0]
  42                 );
  43                 dojo.query("td:not([type])", tr).forEach(
  44                     function(td) {
  45                         td.innerHTML =
  46                             dojo.string.substitute(td.innerHTML, hold);
  47                     }
  48                 );
  49
  50                 new openils.BibTemplate({
  51                     root : tr,
  52                     xml  : dojox.xml.parser.parse(hold.current_copy.call_number.record.marc),
  53                     delay: false
  54                 });
  55
  56                 dojo.place(tr, "target");
  57             });
  58           },
  59           oncomplete : function () {
  60             progress_dialog.hide();
  61             if (any)
  62                 window.print();
  63             else
  64                 alert(dojo.byId("no_results").innerHTML);
  65           }
  66         }
  67     );
  68 }
  69
  70 function place_by_sortkey(node, container) {
  71     /*Don't use a forEach() or anything like that here. too slow.*/
  72     var sortkey = dojo.attr(node, "sortkey");
  73     for (var i = 0; i < container.childNodes.length; i++) {
  74         var rover = container.childNodes[i];
  75         if (rover.nodeType != 1) continue;
  76         if (dojo.attr(rover, "sortkey") > sortkey) {
  77             dojo.place(node, rover, "before");
  78             return;
  79         }
  80     }
  81     dojo.place(node, container, "last");
  82 }
  83
  84 function hashify_fields(fields) {
  85     var hold  = {
  86         "usr": {},
  87         "current_copy": {
  88             "barcode": fields.barcode,
  89             "call_number": {
  90                 "label": fields.label,
  91                 "record": {"marc": fields.marc}
  92             },
  93             "location": {"name": fields.name}
  94         }
  95     };
  96
  97     if (fields.alias) {
  98         hold.usr.display_name = fields.alias;
  99     } else {
 100         hold.usr.display_name = [
 101             (fields.family_name ? fields.family_name : ""),
 102             (fields.first_given_name ? fields.first_given_name : ""),
 103             (fields.second_given_name ? fields.second_given_name : "")
 104         ].join(" ");
 105     }
 106
 107     ["first_given_name","second_given_name","family_name","alias"].forEach(
 108         function(k) { hold.usr[k] = fields[k]; }
 109     );
 110
 111     return hold;
 112 }
 113
 114 function do_clear_holds() {
 115     progress_dialog.show(true);
 116
 117     var launcher;
 118     fieldmapper.standardRequest(
 119         ["open-ils.circ", "open-ils.circ.hold.clear_shelf.process"], {
 120             "async": true,
 121             "params": [authtoken, cgi.param("o")],
 122             "onresponse": function(r) {
 123                 if (r = openils.Util.readResponse(r)) {
 124                     if (r.cache_key) { /* complete */
 125                         launcher = dojo.byId("clear_holds_launcher");
 126                         launcher.innerHTML = "Re-fetch for Printing"; /* XXX i18n */
 127                         launcher.onclick =
 128                             function() { do_clear_holds_from_cache(r.cache_key); };
 129                         dojo.byId("clear_holds_set_label").innerHTML = r.cache_key;
 130                     } else if (r.maximum) {
 131                         progress_dialog.update(r);
 132                     }
 133                 }
 134             },
 135             "oncomplete": function() {
 136                 progress_dialog.hide();
 137                 if (launcher) launcher.onclick();
 138                 else alert(dojo.byId("no_results").innerHTML);
 139             }
 140         }
 141     );
 142 }
 143
 144 function do_clear_holds_from_cache(cache_key) {
 145     progress_dialog.show(true);
 146
 147     var any = 0;
 148     var target = dojo.byId("target");
 149     dojo.empty(target);
 150     var template = dojo.query("tr", dojo.byId("template"))[0];
 151     fieldmapper.standardRequest(
 152         ["open-ils.circ",
 153             "open-ils.circ.hold.clear_shelf.get_cache"], {
 154             "async": true,
 155             "params": [authtoken, cache_key, cgi.param("chunk_size")],
 156             "onresponse": function(r) {
 157                 dojo.forEach(
 158                     openils.Util.readResponse(r),
 159                     function(resp) {
 160                         if (resp.maximum) {
 161                             progress_dialog.update(resp);
 162                             return;
 163                         }
 164
 165                         var hold = hashify_fields(resp.hold_details);
 166                         hold.action = resp.action;
 167
 168                         var tr = dojo.clone(template);
 169                         any++;
 170
 171                         dojo.query("td:not([type])", tr).forEach(
 172                             function(td) {
 173                                 td.innerHTML =
 174                                     dojo.string.substitute(td.innerHTML, hold);
 175                             }
 176                         );
 177
 178                         new openils.BibTemplate({
 179                             "root": tr,
 180                             "xml": dojox.xml.parser.parse(
 181                                 hold.current_copy.call_number.record.marc
 182                             ),
 183                             "delay": false
 184                         });
 185
 186                         dojo.attr(tr, "sortkey", hold.usr.display_name);
 187                         place_by_sortkey(tr, target);
 188                     }
 189                 );
 190                 progress_dialog.update({"progress": any});
 191             },
 192             "oncomplete": function() {
 193                 progress_dialog.hide();
 194                 if (any)
 195                     window.print();
 196                 else
 197                     alert(dojo.byId("no_results").innerHTML);
 198             }
 199         }
 200     );
 201 }
 202