Open-ILS/web/js/ui/default/staff/cat/services/record.js

   1 /**
   2  * Simple directive for rending the HTML view of a MARC record.
   3  *
   4  * <eg-record-html record-id="myRecordIdScopeVariable"></eg-record-id>
   5  * OR
   6  * <eg-record-html marc-xml="myMarcXmlVariable"></eg-record-html>
   7  *
   8  * The value of myRecordIdScopeVariable is watched internally and the
   9  * record is updated to match.
  10  */
  11 angular.module('egCoreMod')
  12
  13 .directive('egRecordHtml', function() {
  14     return {
  15         restrict : 'AE',
  16         scope : {
  17             recordId : '=',
  18             marcXml  : '@',
  19         },
  20         link : function(scope, element, attrs) {
  21             scope.element = angular.element(element);
  22
  23             // kill refs to destroyed DOM elements
  24             element.bind("$destroy", function() {
  25                 delete scope.element;
  26             });
  27         },
  28         controller :
  29                    ['$scope','egCore',
  30             function($scope , egCore) {
  31
  32                 function loadRecordHtml() {
  33                     egCore.net.request(
  34                         'open-ils.search',
  35                         'open-ils.search.biblio.record.html',
  36                         $scope.recordId,
  37                         false,
  38                         $scope.marcXml
  39                     ).then(function(html) {
  40                         if (!html) return;
  41
  42                         // Remove those pesky non-i8n labels / actions.
  43                         // Note: for printing, use the browser print page
  44                         // option.  The end result is the same.
  45                         html = html.replace(
  46                             /<button onclick="window.print(.*?)<\/button>/,'');
  47                         html = html.replace(/<title>(.*?)<\/title>/,'');
  48
  49                         // remove reference to nonexistant CSS file
  50                         html = html.replace(/<link(.*?)\/>/,'');
  51
  52                         $scope.element.html(html);
  53                     });
  54                 }
  55
  56                 $scope.$watch('recordId',
  57                     function(newVal, oldVal) {
  58                         if (newVal && newVal !== oldVal) {
  59                             loadRecordHtml();
  60                         }
  61                     }
  62                 );
  63                 $scope.$watch('marcXml',
  64                     function(newVal, oldVal) {
  65                         if (newVal && newVal !== oldVal) {
  66                             loadRecordHtml();
  67                         }
  68                     }
  69                 );
  70
  71                 if ($scope.recordId || $scope.marcXml)
  72                     loadRecordHtml();
  73             }
  74         ]
  75     }
  76 })
  77
  78 .directive('egRecordBreaker', function() {
  79     return {
  80         restrict : 'AE',
  81         template : '<pre>{{breaker}}</pre>',
  82         scope : {
  83             recordId : '=',
  84             marcXml  : '=',
  85         },
  86         link : function(scope, element, attrs) {
  87             scope.element = angular.element(element);
  88
  89             // kill refs to destroyed DOM elements
  90             element.bind("$destroy", function() {
  91                 delete scope.element;
  92             });
  93         },
  94         controller :
  95                    ['$scope','egCore',
  96             function($scope , egCore) {
  97
  98                 function loadRecordBreaker() {
  99                     var xml;
 100                     if ($scope.marcXml) {
 101                         $scope.breaker = new MARC21.Record({ marcxml : $scope.marcXml }).toBreaker();
 102                     } else {
 103                         egCore.pcrud.retrieve('bre', $scope.recordId)
 104                         .then(function(rec) {
 105                             $scope.breaker = new MARC21.Record({ marcxml : rec.marc() }).toBreaker();
 106                         });
 107                     }
 108                 }
 109
 110                 $scope.$watch('recordId',
 111                     function(newVal, oldVal) {
 112                         if (newVal && newVal !== oldVal) {
 113                             loadRecordBreaker();
 114                         }
 115                     }
 116                 );
 117                 $scope.$watch('marcXml',
 118                     function(newVal, oldVal) {
 119                         if (newVal && newVal !== oldVal) {
 120                             loadRecordBreaker();
 121                         }
 122                     }
 123                 );
 124
 125                 if ($scope.recordId || $scope.marcXml)
 126                     loadRecordBreaker();
 127             }
 128         ]
 129     }
 130 })
 131
 132 /*
 133  * A record='foo' attribute is required as a storage location of the
 134  * retrieved record
 135  */
 136 .directive('egRecordSummary', function() {
 137     return {
 138         restrict : 'AE',
 139         scope : {
 140             recordId : '=',
 141             record : '=',
 142             noMarcLink : '@'
 143         },
 144         templateUrl : './cat/share/t_record_summary',
 145         controller :
 146                    ['$scope','egCore','$sce',
 147             function($scope , egCore , $sce) {
 148
 149                 function loadRecord() {
 150                     egCore.pcrud.retrieve('bre', $scope.recordId, {
 151                         flesh : 1,
 152                         flesh_fields : {
 153                             bre : ['creator','editor']
 154                         }
 155                     }).then(function(rec) {
 156                         rec.owner(egCore.org.get(rec.owner()));
 157                         $scope.record = rec;
 158                     });
 159                     egCore.net.request(
 160                         'open-ils.search',
 161                         'open-ils.search.biblio.record.mods_slim.retrieve.authoritative',
 162                         $scope.recordId
 163                     ).then(function(mvr) {
 164                         $scope.mvr = mvr;
 165                     });
 166                     $scope.bib_cn = null;
 167                     $scope.bib_cn_tooltip = '';
 168                     var label_class = 1;
 169                     if (egCore.env.aous)
 170                         label_class = egCore.env.aous['cat.default_classification_scheme'] || 1;
 171                     egCore.net.request(
 172                         'open-ils.cat',
 173                         'open-ils.cat.biblio.record.marc_cn.retrieve',
 174                         $scope.recordId,
 175                         label_class
 176                     ).then(function(cn_array) {
 177                         var tooltip = '';
 178                         if (cn_array.length > 0) {
 179                             for (var field in cn_array[0]) {
 180                                 $scope.bib_cn = cn_array[0][field];
 181                             }
 182                             for (var i in cn_array) {
 183                                 for (var field in cn_array[i]) {
 184                                     tooltip +=
 185                                         field + ' : ' + cn_array[i][field] + '<br>';
 186                                 }
 187                             }
 188                             $scope.bib_cn_tooltip = $sce.trustAsHtml(tooltip);
 189                         }
 190                     });
 191                 }
 192
 193                 $scope.$watch('recordId',
 194                     function(newVal, oldVal) {
 195                         if (newVal && newVal !== oldVal) {
 196                             loadRecord();
 197                         }
 198                     }
 199                 );
 200
 201
 202                 if ($scope.recordId)
 203                     loadRecord();
 204
 205                 $scope.toggle_expand_summary = function() {
 206                     if ($scope.collapseRecordSummary) {
 207                         $scope.collapseRecordSummary = false;
 208                         egCore.hatch.removeItem('eg.cat.record.summary.collapse');
 209                     } else {
 210                         $scope.collapseRecordSummary = true;
 211                         egCore.hatch.setItem('eg.cat.record.summary.collapse', true);
 212                     }
 213                 }
 214
 215                 $scope.collapse_summary = function() {
 216                     return $scope.collapseRecordSummary;
 217                 }
 218
 219                 egCore.hatch.getItem('eg.cat.record.summary.collapse')
 220                 .then(function(val) {$scope.collapseRecordSummary = Boolean(val)});
 221
 222             }
 223         ]
 224     }
 225 })
 226
 227 /**
 228  * Utility functions for translating bib record display fields into
 229  * various formats / structures.
 230  *
 231  * Note that 'mwde' objects (which are proper IDL objects) only contain
 232  * the prescribed fields from the IDL (and database view), while the
 233  * 'mfde' hash-based objects contain all configured display fields,
 234  * including local/custom fields.
 235  */
 236 .factory('egBibDisplay', ['$q', 'egCore', function($q, egCore) {
 237     var service = {};
 238
 239     /**
 240      * Converts JSON-encoded values within a mwde object to Javascript
 241      * native strings, numbers, and arrays.
 242      */
 243     service.mwdeJSONToJS = function(entry) {
 244         angular.forEach(egCore.idl.classes.mwde.fields, function(f) {
 245             if (f.virtual) return;
 246             entry[f.name](JSON.parse(entry[f.name]()));
 247         });
 248     }
 249
 250     /**
 251      * Converts a list of 'mfde' entry objects to a simple key=>value hash.
 252      * Non-multi values are strings or numbers.
 253      * Multi values are arrays of strings or numbers.
 254      */
 255     service.mfdeToHash = function(entries) {
 256         var hash = service.mfdeToMetaHash(entries);
 257         angular.forEach(hash,
 258             function(sub_hash, name) { hash[name] = sub_hash.value });
 259         return hash;
 260     }
 261
 262     /**
 263      * Converts a list of 'mfde' entry objects to a nested hash like so:
 264      * {name => field_name, label => field_label, value => scalar_or_array}
 265      * The scalar_or_array value is a string/number or an array of
 266      * string/numbers
 267      */
 268     service.mfdeToMetaHash = function(entries) {
 269         var hash = {};
 270         angular.forEach(entries, function(entry) {
 271
 272             if (!hash[entry.name()]) {
 273                 hash[entry.name()] = {
 274                     name : entry.name(),
 275                     label : entry.label(),
 276                     multi : entry.multi() == 't',
 277                     value : entry.multi() == 't' ? [] : null
 278                 }
 279             }
 280
 281             if (entry.multi() == 't') {
 282                 hash[entry.name()].value.push(entry.value());
 283             } else {
 284                 hash[entry.name()].value = entry.value();
 285             }
 286         });
 287
 288         return hash;
 289     }
 290
 291     return service;
 292 }])