Changeset 28550


Ignore:
Timestamp:
05/27/14 23:47:57 (5 years ago)
Author:
mistic100
Message:

feature 3077 : factorize code for cache/selectize

Location:
trunk/admin/themes/default
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/admin/themes/default/js/LocalStorageCache.js

    r28542 r28550  
    1 /** 
    2  * Base LocalStorage cache 
    3  * 
    4  * @param options {object} 
    5  *    - key (required) identifier of the collection 
    6  *    - serverId (recommended) identifier of the Piwigo instance 
    7  *    - serverKey (required) state of collection server-side 
    8  *    - lifetime (optional) cache lifetime in seconds 
    9  *    - loader (required) function called to fetch data, takes a callback as first argument 
    10  *        which must be called with the loaded date 
    11  */ 
    12 var LocalStorageCache = function(options) { 
    13   this._init(options); 
    14 }; 
    15  
    16 /* 
    17  * Constructor (deported for easy inheritance) 
    18  */ 
    19 LocalStorageCache.prototype._init = function(options) { 
    20   this.key = options.key + '_' + options.serverId; 
    21   this.serverKey = options.serverKey; 
    22   this.lifetime = options.lifetime ? options.lifetime*1000 : 3600*1000; 
    23   this.loader = options.loader; 
    24    
    25   this.storage = window.localStorage; 
    26   this.ready = !!this.storage; 
    27 }; 
    28  
    29 /* 
    30  * Get the cache content 
    31  * @param callback {function} called with the data as first parameter 
    32  */ 
    33 LocalStorageCache.prototype.get = function(callback) { 
    34   var now = new Date().getTime(), 
    35       that = this; 
    36    
    37   if (this.ready && this.storage[this.key] != undefined) { 
    38     var cache = JSON.parse(this.storage[this.key]); 
    39      
    40     if (now - cache.timestamp <= this.lifetime && cache.key == this.serverKey) { 
    41       callback(cache.data); 
    42       return; 
     1(function($, exports) { 
     2  "use strict"; 
     3   
     4  /** 
     5   * Base LocalStorage cache 
     6   * 
     7   * @param options {object} 
     8   *    - key (required) identifier of the collection 
     9   *    - serverId (recommended) identifier of the Piwigo instance 
     10   *    - serverKey (required) state of collection server-side 
     11   *    - lifetime (optional) cache lifetime in seconds 
     12   *    - loader (required) function called to fetch data, takes a callback as first argument 
     13   *        which must be called with the loaded date 
     14   */ 
     15  var LocalStorageCache = function(options) { 
     16    this._init(options); 
     17  }; 
     18 
     19  /* 
     20   * Constructor (deported for easy inheritance) 
     21   */ 
     22  LocalStorageCache.prototype._init = function(options) { 
     23    this.key = options.key + '_' + options.serverId; 
     24    this.serverKey = options.serverKey; 
     25    this.lifetime = options.lifetime ? options.lifetime*1000 : 3600*1000; 
     26    this.loader = options.loader; 
     27     
     28    this.storage = window.localStorage; 
     29    this.ready = !!this.storage; 
     30  }; 
     31 
     32  /* 
     33   * Get the cache content 
     34   * @param callback {function} called with the data as first parameter 
     35   */ 
     36  LocalStorageCache.prototype.get = function(callback) { 
     37    var now = new Date().getTime(), 
     38        that = this; 
     39     
     40    if (this.ready && this.storage[this.key] != undefined) { 
     41      var cache = JSON.parse(this.storage[this.key]); 
     42       
     43      if (now - cache.timestamp <= this.lifetime && cache.key == this.serverKey) { 
     44        callback(cache.data); 
     45        return; 
     46      } 
    4347    } 
    44   } 
    45    
    46   this.loader(function(data) { 
    47     that.set.call(that, data); 
    48     callback(data); 
    49   }); 
    50 }; 
    51  
    52 /* 
    53  * Manually set the cache content 
    54  * @param data {mixed} 
    55  */ 
    56 LocalStorageCache.prototype.set = function(data) { 
    57   if (this.ready) { 
    58     this.storage[this.key] = JSON.stringify({ 
    59       timestamp: new Date().getTime(), 
    60       key: this.serverKey, 
    61       data: data 
    62     }); 
    63   } 
    64 }; 
    65  
    66 /* 
    67  * Manually clear the cache 
    68  */ 
    69 LocalStorageCache.prototype.clear = function() { 
    70   if (this.ready) { 
    71     this.storage.removeItem(this.key); 
    72   } 
    73 }; 
    74  
    75  
    76 /** 
    77  * Special LocalStorage for admin categories list 
    78  * 
    79  * @param options {object} 
    80  *    - serverId (recommended) identifier of the Piwigo instance 
    81  *    - serverKey (required) state of collection server-side 
    82  *    - rootUrl (required) used for WS call 
    83  */ 
    84 var CategoriesCache = function(options) { 
    85   options.key = 'categoriesAdminList'; 
    86    
    87   options.loader = function(callback) { 
    88     jQuery.getJSON(options.rootUrl + 'ws.php?format=json&method=pwg.categories.getAdminList', function(data) { 
    89       callback(data.result.categories); 
    90     }); 
    91   }; 
    92    
    93   this._init(options); 
    94 }; 
    95  
    96 CategoriesCache.prototype = new LocalStorageCache({}); 
    97  
    98 /* 
    99  * Init Selectize with cache content 
    100  * @param $target {jQuery} 
    101  * @param options {object} 
    102  *    - default (optional) default value which will be forced if the select is emptyed 
    103  *    - filter (optional) function called for each select before applying the data 
    104  *      takes two parameters: cache data, options 
    105  *      must return new data 
    106  */ 
    107 CategoriesCache.prototype.selectize = function($target, options) { 
    108   options = options || {}; 
    109  
    110   $target.selectize({ 
    111     valueField: 'id', 
    112     labelField: 'fullname', 
    113     sortField: 'global_rank', 
    114     searchField: ['fullname'], 
    115     plugins: ['remove_button'] 
    116   }); 
    117    
    118   this.get(function(categories) { 
    119     $target.each(function() { 
    120       var data; 
    121       if (options.filter != undefined) { 
    122         data = options.filter.call(this, categories, options); 
    123       } 
    124       else { 
    125         data = categories; 
    126       } 
     48     
     49    this.loader(function(data) { 
     50      that.set.call(that, data); 
     51      callback(data); 
     52    }); 
     53  }; 
     54 
     55  /* 
     56   * Manually set the cache content 
     57   * @param data {mixed} 
     58   */ 
     59  LocalStorageCache.prototype.set = function(data) { 
     60    if (this.ready) { 
     61      this.storage[this.key] = JSON.stringify({ 
     62        timestamp: new Date().getTime(), 
     63        key: this.serverKey, 
     64        data: data 
     65      }); 
     66    } 
     67  }; 
     68 
     69  /* 
     70   * Manually clear the cache 
     71   */ 
     72  LocalStorageCache.prototype.clear = function() { 
     73    if (this.ready) { 
     74      this.storage.removeItem(this.key); 
     75    } 
     76  }; 
     77 
     78   
     79  /** 
     80   * Abstract class containing common initialization code for selectize 
     81   */ 
     82  var AbstractSelectizer = function(){}; 
     83  AbstractSelectizer.prototype = new LocalStorageCache({}); 
     84 
     85  /* 
     86   * Load Selectize with cache content 
     87   * @param $target {jQuery} 
     88   * @param options {object} 
     89   *    - default (optional) default value which will be forced if the select is emptyed 
     90   *    - filter (optional) function called for each select before applying the data 
     91   *      takes two parameters: cache data, options 
     92   *      must return new data 
     93   */ 
     94  AbstractSelectizer.prototype._selectize = function($target, options) { 
     95    this.get(function(data) { 
     96      $target.each(function() { 
     97        var filtered, value; 
     98         
     99        // apply filter function 
     100        if (options.filter != undefined) { 
     101          filtered = options.filter.call(this, data, options); 
     102        } 
     103        else { 
     104          filtered = data; 
     105        } 
     106         
     107        // active creation mode 
     108        if (this.hasAttribute('data-selectize-create')) { 
     109          this.selectize.settings.create = true; 
     110        } 
     111         
     112        // load options 
     113        this.selectize.load(function(callback) { 
     114          if ($.isEmptyObject(this.options)) { 
     115            callback(filtered); 
     116          } 
     117        }); 
     118 
     119        // load items 
     120        if ((value = $(this).data('value'))) { 
     121          $.each(value, $.proxy(function(i, cat) { 
     122            if ($.isNumeric(cat)) 
     123              this.selectize.addItem(cat); 
     124            else 
     125              this.selectize.addItem(cat.id); 
     126          }, this)); 
     127        } 
     128         
     129        if (options.default != undefined) { 
     130          // add default item 
     131          if (this.selectize.getValue() == '') { 
     132            this.selectize.addItem(options.default); 
     133          } 
     134 
     135          // if multiple: prevent item deletion 
     136          if (this.multiple) { 
     137            this.selectize.getItem(options.default).find('.remove').hide(); 
     138             
     139            this.selectize.on('item_remove', function(id) { 
     140              if (id == options.default) { 
     141                this.addItem(id); 
     142                this.getItem(id).find('.remove').hide(); 
     143              } 
     144            }); 
     145          } 
     146          // if single: restore default on blur 
     147          else { 
     148            this.selectize.on('dropdown_close', function() { 
     149              if (this.getValue() == '') { 
     150                this.addItem(options.default); 
     151              } 
     152            }); 
     153          } 
     154        } 
     155      }); 
     156    }); 
     157  }; 
     158 
     159 
     160  /** 
     161   * Special LocalStorage for admin categories list 
     162   * 
     163   * @param options {object} 
     164   *    - serverId (recommended) identifier of the Piwigo instance 
     165   *    - serverKey (required) state of collection server-side 
     166   *    - rootUrl (required) used for WS call 
     167   */ 
     168  var CategoriesCache = function(options) { 
     169    options.key = 'categoriesAdminList'; 
     170     
     171    options.loader = function(callback) { 
     172      $.getJSON(options.rootUrl + 'ws.php?format=json&method=pwg.categories.getAdminList', function(data) { 
     173        callback(data.result.categories); 
     174      }); 
     175    }; 
     176     
     177    this._init(options); 
     178  }; 
     179 
     180  CategoriesCache.prototype = new AbstractSelectizer(); 
     181 
     182  /* 
     183   * Init Selectize with cache content 
     184   * @see AbstractSelectizer._selectize 
     185   */ 
     186  CategoriesCache.prototype.selectize = function($target, options) { 
     187    options = options || {}; 
     188 
     189    $target.selectize({ 
     190      valueField: 'id', 
     191      labelField: 'fullname', 
     192      sortField: 'global_rank', 
     193      searchField: ['fullname'], 
     194      plugins: ['remove_button'] 
     195    }); 
     196     
     197    this._selectize($target, options); 
     198  }; 
     199 
     200 
     201  /** 
     202   * Special LocalStorage for admin tags list 
     203   * 
     204   * @param options {object} 
     205   *    - serverId (recommended) identifier of the Piwigo instance 
     206   *    - serverKey (required) state of collection server-side 
     207   *    - rootUrl (required) used for WS call 
     208   */ 
     209  var TagsCache = function(options) { 
     210    options.key = 'tagsAdminList'; 
     211     
     212    options.loader = function(callback) { 
     213      $.getJSON(options.rootUrl + 'ws.php?format=json&method=pwg.tags.getAdminList', function(data) { 
     214        var tags = data.result.tags; 
     215         
     216        for (var i=0, l=tags.length; i<l; i++) { 
     217          tags[i].id = '~~' + tags[i].id + '~~'; 
     218        } 
     219         
     220        callback(tags); 
     221      }); 
     222    }; 
     223     
     224    this._init(options); 
     225  }; 
     226 
     227  TagsCache.prototype = new AbstractSelectizer(); 
     228 
     229  /* 
     230   * Init Selectize with cache content 
     231   * @see AbstractSelectizer._selectize 
     232   */ 
     233  TagsCache.prototype.selectize = function($target, options) { 
     234    options = options || {}; 
     235 
     236    $target.selectize({ 
     237      valueField: 'id', 
     238      labelField: 'name', 
     239      sortField: 'name', 
     240      searchField: ['name'], 
     241      plugins: ['remove_button'] 
     242    }); 
     243     
     244    this._selectize($target, options); 
     245  }; 
     246   
     247   
     248  /** 
     249   * Special LocalStorage for admin groups list 
     250   * 
     251   * @param options {object} 
     252   *    - serverId (recommended) identifier of the Piwigo instance 
     253   *    - serverKey (required) state of collection server-side 
     254   *    - rootUrl (required) used for WS call 
     255   */ 
     256  var GroupsCache = function(options) { 
     257    options.key = 'groupsAdminList'; 
     258     
     259    options.loader = function(callback) { 
     260      $.getJSON(options.rootUrl + 'ws.php?format=json&method=pwg.groups.getList&per_page=9999', function(data) { 
     261        callback(data.result.groups); 
     262      }); 
     263    }; 
     264     
     265    this._init(options); 
     266  }; 
     267 
     268  GroupsCache.prototype = new AbstractSelectizer(); 
     269 
     270  /* 
     271   * Init Selectize with cache content 
     272   * @see AbstractSelectizer._selectize 
     273   */ 
     274  GroupsCache.prototype.selectize = function($target, options) { 
     275    options = options || {}; 
     276 
     277    $target.selectize({ 
     278      valueField: 'id', 
     279      labelField: 'name', 
     280      sortField: 'name', 
     281      searchField: ['name'], 
     282      plugins: ['remove_button'] 
     283    }); 
     284     
     285    this._selectize($target, options); 
     286  }; 
     287   
     288   
     289  /** 
     290   * Special LocalStorage for admin users list 
     291   * 
     292   * @param options {object} 
     293   *    - serverId (recommended) identifier of the Piwigo instance 
     294   *    - serverKey (required) state of collection server-side 
     295   *    - rootUrl (required) used for WS call 
     296   */ 
     297  var UsersCache = function(options) { 
     298    options.key = 'usersAdminList'; 
     299     
     300    options.loader = function(callback) { 
     301      var users = []; 
    127302       
    128       this.selectize.load(function(callback) { 
    129         callback(data); 
    130       }); 
    131  
    132       if (jQuery(this).data('value')) { 
    133         jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, id) { 
    134           this.selectize.addItem(id); 
    135         }, this)); 
    136       } 
    137        
    138       if (options.default != undefined) { 
    139         if (this.selectize.getValue() == '') { 
    140           this.selectize.addItem(options.default); 
    141         } 
    142  
    143         // if multiple: prevent item deletion 
    144         if (this.multiple) { 
    145           this.selectize.getItem(options.default).find('.remove').hide(); 
     303      // recursive loader 
     304      (function load(page){ 
     305        jQuery.getJSON(options.rootUrl + 'ws.php?format=json&method=pwg.users.getList&display=username&per_page=9999&page='+ page, function(data) { 
     306          users = users.concat(data.result.users); 
    146307           
    147           this.selectize.on('item_remove', function(id) { 
    148             if (id == options.default) { 
    149               this.addItem(id); 
    150               this.getItem(id).find('.remove').hide(); 
    151             } 
    152           }); 
    153         } 
    154         // if single: restore default on blur 
    155         else { 
    156           this.selectize.on('dropdown_close', function() { 
    157             if (this.getValue() == '') { 
    158               this.addItem(options.default); 
    159             } 
    160           }); 
    161         } 
    162       } 
    163     }); 
    164   }); 
    165 }; 
     308          if (data.result.paging.count == data.result.paging.per_page) { 
     309            load(++page); 
     310          } 
     311          else { 
     312            callback(users); 
     313          } 
     314        }); 
     315      }(0)); 
     316    }; 
     317     
     318    this._init(options); 
     319  }; 
     320 
     321  UsersCache.prototype = new AbstractSelectizer(); 
     322 
     323  /* 
     324   * Init Selectize with cache content 
     325   * @see AbstractSelectizer._selectize 
     326   */ 
     327  UsersCache.prototype.selectize = function($target, options) { 
     328    options = options || {}; 
     329 
     330    $target.selectize({ 
     331      valueField: 'id', 
     332      labelField: 'username', 
     333      sortField: 'username', 
     334      searchField: ['username'], 
     335      plugins: ['remove_button'] 
     336    }); 
     337     
     338    this._selectize($target, options); 
     339  }; 
     340   
     341   
     342  /** 
     343   * Expose classes in global scope 
     344   */ 
     345  exports.LocalStorageCache = LocalStorageCache; 
     346  exports.CategoriesCache = CategoriesCache; 
     347  exports.TagsCache = TagsCache; 
     348  exports.GroupsCache = GroupsCache; 
     349  exports.UsersCache = UsersCache; 
     350   
     351}(jQuery, window)); 
  • trunk/admin/themes/default/template/batch_manager_global.tpl

    r28542 r28550  
    6969   
    7070  {* <!-- TAGS --> *} 
    71   var tagsCache = new LocalStorageCache({ 
    72     key: 'tagsAdminList', 
     71  var tagsCache = new TagsCache({ 
    7372    serverKey: '{$CACHE_KEYS.tags}', 
    7473    serverId: '{$CACHE_KEYS._hash}', 
    75  
    76     loader: function(callback) { 
    77       jQuery.getJSON('{$ROOT_URL}ws.php?format=json&method=pwg.tags.getAdminList', function(data) { 
    78         var tags = data.result.tags; 
    79          
    80         for (var i=0, l=tags.length; i<l; i++) { 
    81           tags[i].id = '~~' + tags[i].id + '~~'; 
    82         } 
    83          
    84         callback(tags); 
    85       }); 
    86     } 
    87   }); 
    88    
    89   jQuery('[data-selectize=tags]').selectize({ 
    90     valueField: 'id', 
    91     labelField: 'name', 
    92     searchField: ['name'], 
    93     plugins: ['remove_button'] 
    94   }); 
    95    
    96   jQuery('[data-selectize=tags-create]').selectize({ 
    97     valueField: 'id', 
    98     labelField: 'name', 
    99     searchField: ['name'], 
    100     plugins: ['remove_button'], 
    101     create: true 
    102   }); 
    103    
    104   tagsCache.get(function(tags) { 
    105     jQuery('[data-selectize^=tags]').each(function() { 
    106       this.selectize.load(function(callback) { 
    107         // one select is populated with <option> 
    108         if (jQuery.isEmptyObject(this.options)) { 
    109           callback(tags); 
    110         } 
    111       }); 
    112  
    113       if (jQuery(this).data('value')) { 
    114         jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, tag) { 
    115           this.selectize.addItem(tag.id); 
    116         }, this)); 
    117       } 
    118     }); 
    119   }); 
     74    rootUrl: '{$ROOT_URL}' 
     75  }); 
     76 
     77  tagsCache.selectize(jQuery('[data-selectize=tags]')); 
    12078   
    12179  {* <!-- CATEGORIES --> *} 
     
    655613        {'Tags'|@translate} 
    656614        <select data-selectize="tags" data-value="{$filter_tags|@json_encode|escape:html}" 
    657           name="filter_tags[]" multiple style="width:400px;" ></select> 
     615          name="filter_tags[]" multiple style="width:400px;"></select> 
    658616        <label><span><input type="radio" name="tag_mode" value="AND" {if !isset($filter.tag_mode) or $filter.tag_mode eq 'AND'}checked="checked"{/if}> {'All tags'|@translate}</span></label> 
    659617        <label><span><input type="radio" name="tag_mode" value="OR" {if isset($filter.tag_mode) and $filter.tag_mode eq 'OR'}checked="checked"{/if}> {'Any tag'|@translate}</span></label> 
     
    875833    <!-- add_tags --> 
    876834    <div id="action_add_tags" class="bulkAction"> 
    877       <select data-selectize="tags-create" name="add_tags[]" multiple style="width:400px;"></select> 
     835      <select data-selectize="tags" data-selectize-create name="add_tags[]" multiple style="width:400px;"></select> 
    878836    </div> 
    879837 
  • trunk/admin/themes/default/template/batch_manager_unit.tpl

    r28532 r28550  
    1111(function(){ 
    1212{* <!-- TAGS --> *} 
    13 var tagsCache = new LocalStorageCache({ 
    14   key: 'tagsAdminList', 
     13var tagsCache = new TagsCache({ 
    1514  serverKey: '{$CACHE_KEYS.tags}', 
    1615  serverId: '{$CACHE_KEYS._hash}', 
    17  
    18   loader: function(callback) { 
    19     jQuery.getJSON('{$ROOT_URL}ws.php?format=json&method=pwg.tags.getAdminList', function(data) { 
    20       var tags = data.result.tags; 
    21        
    22       for (var i=0, l=tags.length; i<l; i++) { 
    23         tags[i].id = '~~' + tags[i].id + '~~'; 
    24       } 
    25        
    26       callback(tags); 
    27     }); 
    28   } 
     16  rootUrl: '{$ROOT_URL}' 
    2917}); 
    3018 
    31 jQuery('[data-selectize=tags]').selectize({ 
    32   valueField: 'id', 
    33   labelField: 'name', 
    34   searchField: ['name'], 
    35   plugins: ['remove_button'], 
    36   create: true 
    37 }); 
    38  
    39 tagsCache.get(function(tags) { 
    40   jQuery('[data-selectize=tags]').each(function() { 
    41     this.selectize.load(function(callback) { 
    42       callback(tags); 
    43     }); 
    44  
    45     jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, tag) { 
    46       this.selectize.addItem(tag.id); 
    47     }, this)); 
    48   }); 
    49 }); 
     19tagsCache.selectize(jQuery('[data-selectize=tags]')); 
    5020 
    5121{* <!-- DATEPICKER --> *} 
     
    12999      <td> 
    130100        <select data-selectize="tags" data-value="{$element.TAGS|@json_encode|escape:html}" 
    131           name="tags-{$element.id}[]" multiple style="width:500px;" ></select> 
     101          name="tags-{$element.id}[]" multiple style="width:500px;" data-selectize-create></select> 
    132102      </td> 
    133103    </tr> 
  • trunk/admin/themes/default/template/cat_perm.tpl

    r28532 r28550  
    77(function(){ 
    88{* <!-- GROUPS --> *} 
    9 var groupsCache = new LocalStorageCache({ 
    10   key: 'groupsAdminList', 
     9var groupsCache = new GroupsCache({ 
    1110  serverKey: '{$CACHE_KEYS.groups}', 
    1211  serverId: '{$CACHE_KEYS._hash}', 
    13  
    14   loader: function(callback) { 
    15     jQuery.getJSON('{$ROOT_URL}ws.php?format=json&method=pwg.groups.getList&per_page=99999', function(data) { 
    16       callback(data.result.groups); 
    17     }); 
    18   } 
     12  rootUrl: '{$ROOT_URL}' 
    1913}); 
    2014 
    21 jQuery('[data-selectize=groups]').selectize({ 
    22   valueField: 'id', 
    23   labelField: 'name', 
    24   searchField: ['name'], 
    25   plugins: ['remove_button'] 
     15groupsCache.selectize(jQuery('[data-selectize=groups]')); 
     16 
     17{* <!-- USERS --> *} 
     18var usersCache = new UsersCache({ 
     19  serverKey: '{$CACHE_KEYS.users}', 
     20  serverId: '{$CACHE_KEYS._hash}', 
     21  rootUrl: '{$ROOT_URL}' 
    2622}); 
    2723 
    28 groupsCache.get(function(groups) { 
    29   jQuery('[data-selectize=groups]').each(function() { 
    30     this.selectize.load(function(callback) { 
    31       callback(groups); 
    32     }); 
    33  
    34     jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, id) { 
    35       this.selectize.addItem(id); 
    36     }, this)); 
    37   }); 
    38 }); 
    39  
    40 {* <!-- USERS --> *} 
    41 var usersCache = new LocalStorageCache({ 
    42   key: 'usersAdminList', 
    43   serverKey: '{$CACHE_KEYS.users}', 
    44   serverId: '{$CACHE_KEYS._hash}', 
    45  
    46   loader: function(callback) { 
    47     var users = []; 
    48      
    49     // recursive loader 
    50     (function load(page){ 
    51       jQuery.getJSON('{$ROOT_URL}ws.php?format=json&method=pwg.users.getList&display=username&per_page=99999&page='+ page, function(data) { 
    52         users = users.concat(data.result.users); 
    53          
    54         if (data.result.paging.count == data.result.paging.per_page) { 
    55           load(++page); 
    56         } 
    57         else { 
    58           callback(users); 
    59         } 
    60       }); 
    61     }(0)); 
    62   } 
    63 }); 
    64  
    65 jQuery('[data-selectize=users]').selectize({ 
    66   valueField: 'id', 
    67   labelField: 'username', 
    68   searchField: ['username'], 
    69   plugins: ['remove_button'] 
    70 }); 
    71  
    72 usersCache.get(function(users) { 
    73   jQuery('[data-selectize=users]').each(function() { 
    74     this.selectize.load(function(callback) { 
    75       callback(users); 
    76     }); 
    77  
    78     jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, id) { 
    79       this.selectize.addItem(id); 
    80     }, this)); 
    81   }); 
    82 }); 
     24usersCache.selectize(jQuery('[data-selectize=users]')); 
    8325 
    8426{* <!-- TOGGLES --> *} 
     
    13173    <br> 
    13274    <select data-selectize="groups" data-value="{$groups_selected|@json_encode|escape:html}" 
    133         name="groups[]" multiple style="width:600px;" ></select> 
     75        name="groups[]" multiple style="width:600px;"></select> 
    13476{else} 
    13577    {'There is no group in this gallery.'|@translate} <a href="admin.php?page=group_list" class="externalLink">{'Group management'|@translate}</a> 
     
    14183    <br> 
    14284    <select data-selectize="users" data-value="{$users_selected|@json_encode|escape:html}" 
    143         name="users[]" multiple style="width:600px;" ></select> 
     85        name="users[]" multiple style="width:600px;"></select> 
    14486  </p> 
    14587 
  • trunk/admin/themes/default/template/picture_modify.tpl

    r28542 r28550  
    2525 
    2626{* <!-- TAGS --> *} 
    27 var tagsCache = new LocalStorageCache({ 
    28   key: 'tagsAdminList', 
     27var tagsCache = new TagsCache({ 
    2928  serverKey: '{$CACHE_KEYS.tags}', 
    3029  serverId: '{$CACHE_KEYS._hash}', 
    31  
    32   loader: function(callback) { 
    33     jQuery.getJSON('{$ROOT_URL}ws.php?format=json&method=pwg.tags.getAdminList', function(data) { 
    34       var tags = data.result.tags; 
    35        
    36       for (var i=0, l=tags.length; i<l; i++) { 
    37         tags[i].id = '~~' + tags[i].id + '~~'; 
    38       } 
    39        
    40       callback(tags); 
    41     }); 
    42   } 
     30  rootUrl: '{$ROOT_URL}' 
    4331}); 
    4432 
    45 jQuery('[data-selectize=tags]').selectize({ 
    46   valueField: 'id', 
    47   labelField: 'name', 
    48   searchField: ['name'], 
    49   plugins: ['remove_button'], 
    50   create: true 
    51 }); 
    52  
    53 tagsCache.get(function(tags) { 
    54   jQuery('[data-selectize=tags]').each(function() { 
    55     this.selectize.load(function(callback) { 
    56       callback(tags); 
    57     }); 
    58  
    59     jQuery.each(jQuery(this).data('value'), jQuery.proxy(function(i, tag) { 
    60       this.selectize.addItem(tag.id); 
    61     }, this)); 
    62   }); 
    63 }); 
     33tagsCache.selectize(jQuery('[data-selectize=tags]')); 
    6434 
    6535{* <!-- DATEPICKER --> *} 
     
    140110      <br> 
    141111      <select data-selectize="categories" data-value="{$associated_albums|@json_encode|escape:html}" 
    142         name="associate[]" multiple style="width:600px;" ></select> 
     112        name="associate[]" multiple style="width:600px;"></select> 
    143113    </p> 
    144114 
     
    147117      <br> 
    148118      <select data-selectize="categories" data-value="{$represented_albums|@json_encode|escape:html}" 
    149         name="represent[]" multiple style="width:600px;" ></select> 
     119        name="represent[]" multiple style="width:600px;"></select> 
    150120    </p> 
    151121 
     
    154124      <br> 
    155125      <select data-selectize="tags" data-value="{$tag_selection|@json_encode|escape:html}" 
    156         name="tags[]" multiple style="width:600px;" ></select> 
     126        name="tags[]" multiple style="width:600px;" data-selectize-create></select> 
    157127    </p> 
    158128 
Note: See TracChangeset for help on using the changeset viewer.