resources/src/mediawiki.rcfilters/dm/mw.rcfilters.dm.SavedQueriesModel.js

   1 ( function ( mw, $ ) {
   2         /**
   3          * View model for saved queries
   4          *
   5          * @class
   6          * @mixins OO.EventEmitter
   7          * @mixins OO.EmitterList
   8          *
   9          * @constructor
  10          * @param {mw.rcfilters.dm.FiltersViewModel} filtersModel Filters model
  11          * @param {Object} [config] Configuration options
  12          * @cfg {string} [default] Default query ID
  13          */
  14         mw.rcfilters.dm.SavedQueriesModel = function MwRcfiltersDmSavedQueriesModel( filtersModel, config ) {
  15                 config = config || {};
  16
  17                 // Mixin constructor
  18                 OO.EventEmitter.call( this );
  19                 OO.EmitterList.call( this );
  20
  21                 this.default = config.default;
  22                 this.filtersModel = filtersModel;
  23                 this.converted = false;
  24
  25                 // Events
  26                 this.aggregate( { update: 'itemUpdate' } );
  27         };
  28
  29         /* Initialization */
  30
  31         OO.initClass( mw.rcfilters.dm.SavedQueriesModel );
  32         OO.mixinClass( mw.rcfilters.dm.SavedQueriesModel, OO.EventEmitter );
  33         OO.mixinClass( mw.rcfilters.dm.SavedQueriesModel, OO.EmitterList );
  34
  35         /* Events */
  36
  37         /**
  38          * @event initialize
  39          *
  40          * Model is initialized
  41          */
  42
  43         /**
  44          * @event itemUpdate
  45          * @param {mw.rcfilters.dm.SavedQueryItemModel} Changed item
  46          *
  47          * An item has changed
  48          */
  49
  50         /**
  51          * @event default
  52          * @param {string} New default ID
  53          *
  54          * The default has changed
  55          */
  56
  57         /* Methods */
  58
  59         /**
  60          * Initialize the saved queries model by reading it from the user's settings.
  61          * The structure of the saved queries is:
  62          * {
  63          *    version: (string) Version number; if version 2, the query represents
  64          *             parameters. Otherwise, the older version represented filters
  65          *             and needs to be readjusted,
  66          *    default: (string) Query ID
  67          *    queries:{
  68          *       query_id_1: {
  69          *          data:{
  70          *             filters: (Object) Minimal definition of the filters
  71          *             highlights: (Object) Definition of the highlights
  72          *          },
  73          *          label: (optional) Name of this query
  74          *       }
  75          *    }
  76          * }
  77          *
  78          * @param {Object} [savedQueries] An object with the saved queries with
  79          *  the above structure.
  80          * @fires initialize
  81          */
  82         mw.rcfilters.dm.SavedQueriesModel.prototype.initialize = function ( savedQueries ) {
  83                 var model = this;
  84
  85                 savedQueries = savedQueries || {};
  86
  87                 this.clearItems();
  88                 this.default = null;
  89                 this.converted = false;
  90
  91                 if ( savedQueries.version !== '2' ) {
  92                         // Old version dealt with filter names. We need to migrate to the new structure
  93                         // The new structure:
  94                         // {
  95                         //   version: (string) '2',
  96                         //   default: (string) Query ID,
  97                         //   queries: {
  98                         //     query_id: {
  99                         //       label: (string) Name of the query
 100                         //       data: {
 101                         //         params: (object) Representing all the parameter states
 102                         //         highlights: (object) Representing all the filter highlight states
 103                         //     }
 104                         //   }
 105                         // }
 106                         $.each( savedQueries.queries || {}, function ( id, obj ) {
 107                                 if ( obj.data && obj.data.filters ) {
 108                                         obj.data = model.convertToParameters( obj.data );
 109                                 }
 110                         } );
 111
 112                         this.converted = true;
 113                         savedQueries.version = '2';
 114                 }
 115
 116                 // Initialize the query items
 117                 $.each( savedQueries.queries || {}, function ( id, obj ) {
 118                         var normalizedData = obj.data,
 119                                 isDefault = String( savedQueries.default ) === String( id );
 120
 121                         if ( normalizedData && normalizedData.params ) {
 122                                 // Backwards-compat fix: Remove excluded parameters from
 123                                 // the given data, if they exist
 124                                 normalizedData.params = model.filtersModel.removeExcludedParams( normalizedData.params );
 125
 126                                 model.cleanupHighlights( normalizedData );
 127
 128                                 id = String( id );
 129
 130                                 // Skip the addNewQuery method because we don't want to unnecessarily manipulate
 131                                 // the given saved queries unless we literally intend to (like in backwards compat fixes)
 132                                 // And the addNewQuery method also uses a minimization routine that checks for the
 133                                 // validity of items and minimizes the query. This isn't necessary for queries loaded
 134                                 // from the backend, and has the risk of removing values if they're temporarily
 135                                 // invalid (example: if we temporarily removed a cssClass from a filter in the backend)
 136                                 model.addItems( [
 137                                         new mw.rcfilters.dm.SavedQueryItemModel(
 138                                                 id,
 139                                                 obj.label,
 140                                                 normalizedData,
 141                                                 { 'default': isDefault }
 142                                         )
 143                                 ] );
 144
 145                                 if ( isDefault ) {
 146                                         model.default = id;
 147                                 }
 148                         }
 149                 } );
 150
 151                 this.emit( 'initialize' );
 152         };
 153
 154         /**
 155          * Clean up highlight parameters.
 156          * 'highlight' used to be stored, it's not inferred based on the presence of absence of
 157          * filter colors.
 158          *
 159          * @param {Object} data Saved query data
 160          */
 161         mw.rcfilters.dm.SavedQueriesModel.prototype.cleanupHighlights = function ( data ) {
 162                 if (
 163                         data.params.highlight === '0' &&
 164                         data.highlights && Object.keys( data.highlights ).length
 165                 ) {
 166                         data.highlights = {};
 167                 }
 168                 delete data.params.highlight;
 169         };
 170
 171         /**
 172          * Convert from representation of filters to representation of parameters
 173          *
 174          * @param {Object} data Query data
 175          * @return {Object} New converted query data
 176          */
 177         mw.rcfilters.dm.SavedQueriesModel.prototype.convertToParameters = function ( data ) {
 178                 var newData = {},
 179                         defaultFilters = this.filtersModel.getFiltersFromParameters( this.filtersModel.getDefaultParams() ),
 180                         fullFilterRepresentation = $.extend( true, {}, defaultFilters, data.filters ),
 181                         highlightEnabled = data.highlights.highlight;
 182
 183                 delete data.highlights.highlight;
 184
 185                 // Filters
 186                 newData.params = this.filtersModel.getMinimizedParamRepresentation(
 187                         this.filtersModel.getParametersFromFilters( fullFilterRepresentation )
 188                 );
 189
 190                 // Highlights: appending _color to keys
 191                 newData.highlights = {};
 192                 $.each( data.highlights, function ( highlightedFilterName, value ) {
 193                         if ( value ) {
 194                                 newData.highlights[ highlightedFilterName + '_color' ] = data.highlights[ highlightedFilterName ];
 195                         }
 196                 } );
 197
 198                 // Add highlight
 199                 newData.params.highlight = String( Number( highlightEnabled || 0 ) );
 200
 201                 return newData;
 202         };
 203
 204         /**
 205          * Add a query item
 206          *
 207          * @param {string} label Label for the new query
 208          * @param {Object} fulldata Full data representation for the new query, combining highlights and filters
 209          * @param {boolean} isDefault Item is default
 210          * @param {string} [id] Query ID, if exists. If this isn't given, a random
 211          *  new ID will be created.
 212          * @return {string} ID of the newly added query
 213          */
 214         mw.rcfilters.dm.SavedQueriesModel.prototype.addNewQuery = function ( label, fulldata, isDefault, id ) {
 215                 var normalizedData = { params: {}, highlights: {} },
 216                         highlightParamNames = Object.keys( this.filtersModel.getEmptyHighlightParameters() ),
 217                         randomID = String( id || ( new Date() ).getTime() ),
 218                         data = this.filtersModel.getMinimizedParamRepresentation( fulldata );
 219
 220                 // Split highlight/params
 221                 $.each( data, function ( param, value ) {
 222                         if ( param !== 'highlight' && highlightParamNames.indexOf( param ) > -1 ) {
 223                                 normalizedData.highlights[ param ] = value;
 224                         } else {
 225                                 normalizedData.params[ param ] = value;
 226                         }
 227                 } );
 228
 229                 // Add item
 230                 this.addItems( [
 231                         new mw.rcfilters.dm.SavedQueryItemModel(
 232                                 randomID,
 233                                 label,
 234                                 normalizedData,
 235                                 { 'default': isDefault }
 236                         )
 237                 ] );
 238
 239                 if ( isDefault ) {
 240                         this.setDefault( randomID );
 241                 }
 242
 243                 return randomID;
 244         };
 245
 246         /**
 247          * Remove query from model
 248          *
 249          * @param {string} queryID Query ID
 250          */
 251         mw.rcfilters.dm.SavedQueriesModel.prototype.removeQuery = function ( queryID ) {
 252                 var query = this.getItemByID( queryID );
 253
 254                 if ( query ) {
 255                         // Check if this item was the default
 256                         if ( String( this.getDefault() ) === String( queryID ) ) {
 257                                 // Nulify the default
 258                                 this.setDefault( null );
 259                         }
 260
 261                         this.removeItems( [ query ] );
 262                 }
 263         };
 264
 265         /**
 266          * Get an item that matches the requested query
 267          *
 268          * @param {Object} fullQueryComparison Object representing all filters and highlights to compare
 269          * @return {mw.rcfilters.dm.SavedQueryItemModel} Matching item model
 270          */
 271         mw.rcfilters.dm.SavedQueriesModel.prototype.findMatchingQuery = function ( fullQueryComparison ) {
 272                 // Minimize before comparison
 273                 fullQueryComparison = this.filtersModel.getMinimizedParamRepresentation( fullQueryComparison );
 274
 275                 return this.getItems().filter( function ( item ) {
 276                         return OO.compare(
 277                                 item.getCombinedData(),
 278                                 fullQueryComparison
 279                         );
 280                 } )[ 0 ];
 281         };
 282
 283         /**
 284          * Get query by its identifier
 285          *
 286          * @param {string} queryID Query identifier
 287          * @return {mw.rcfilters.dm.SavedQueryItemModel|undefined} Item matching
 288          *  the search. Undefined if not found.
 289          */
 290         mw.rcfilters.dm.SavedQueriesModel.prototype.getItemByID = function ( queryID ) {
 291                 return this.getItems().filter( function ( item ) {
 292                         return item.getID() === queryID;
 293                 } )[ 0 ];
 294         };
 295
 296         /**
 297          * Get the full data representation of the default query, if it exists
 298          *
 299          * @param {boolean} [excludeHiddenParams] Exclude hidden parameters in the result
 300          * @return {Object|null} Representation of the default params if exists.
 301          *  Null if default doesn't exist or if the user is not logged in.
 302          */
 303         mw.rcfilters.dm.SavedQueriesModel.prototype.getDefaultParams = function ( excludeHiddenParams ) {
 304                 var data = ( !mw.user.isAnon() && this.getItemParams( this.getDefault() ) ) || {};
 305
 306                 if ( excludeHiddenParams ) {
 307                         Object.keys( this.filtersModel.getDefaultHiddenParams() ).forEach( function ( paramName ) {
 308                                 delete data[ paramName ];
 309                         } );
 310                 }
 311
 312                 return data;
 313         };
 314
 315         /**
 316          * Get a full parameter representation of an item data
 317          *
 318          * @param  {Object} queryID Query ID
 319          * @return {Object} Parameter representation
 320          */
 321         mw.rcfilters.dm.SavedQueriesModel.prototype.getItemParams = function ( queryID ) {
 322                 var item = this.getItemByID( queryID ),
 323                         data = item ? item.getData() : {};
 324
 325                 return !$.isEmptyObject( data ) ? this.buildParamsFromData( data ) : {};
 326         };
 327
 328         /**
 329          * Build a full parameter representation given item data and model sticky values state
 330          *
 331          * @param  {Object} data Item data
 332          * @return {Object} Full param representation
 333          */
 334         mw.rcfilters.dm.SavedQueriesModel.prototype.buildParamsFromData = function ( data ) {
 335                 // Merge saved filter state with sticky filter values
 336                 var savedFilters;
 337
 338                 data = data || {};
 339
 340                 // In order to merge sticky filters with the data, we have to
 341                 // transform this to filters first, merge, and then back to
 342                 // parameters
 343                 savedFilters = $.extend(
 344                         true, {},
 345                         this.filtersModel.getFiltersFromParameters( data.params ),
 346                         this.filtersModel.getStickyFiltersState()
 347                 );
 348
 349                 // Return parameter representation
 350                 return this.filtersModel.getMinimizedParamRepresentation( $.extend( true, {},
 351                         this.filtersModel.getParametersFromFilters( savedFilters ),
 352                         data.highlights,
 353                         { highlight: data.params.highlight }
 354                 ) );
 355         };
 356
 357         /**
 358          * Get the object representing the state of the entire model and items
 359          *
 360          * @return {Object} Object representing the state of the model and items
 361          */
 362         mw.rcfilters.dm.SavedQueriesModel.prototype.getState = function () {
 363                 var obj = { queries: {}, version: '2' };
 364
 365                 // Translate the items to the saved object
 366                 this.getItems().forEach( function ( item ) {
 367                         obj.queries[ item.getID() ] = item.getState();
 368                 } );
 369
 370                 if ( this.getDefault() ) {
 371                         obj.default = this.getDefault();
 372                 }
 373
 374                 return obj;
 375         };
 376
 377         /**
 378          * Set a default query. Null to unset default.
 379          *
 380          * @param {string} itemID Query identifier
 381          * @fires default
 382          */
 383         mw.rcfilters.dm.SavedQueriesModel.prototype.setDefault = function ( itemID ) {
 384                 if ( this.default !== itemID ) {
 385                         this.default = itemID;
 386
 387                         // Set for individual itens
 388                         this.getItems().forEach( function ( item ) {
 389                                 item.toggleDefault( item.getID() === itemID );
 390                         } );
 391
 392                         this.emit( 'default', itemID );
 393                 }
 394         };
 395
 396         /**
 397          * Get the default query ID
 398          *
 399          * @return {string} Default query identifier
 400          */
 401         mw.rcfilters.dm.SavedQueriesModel.prototype.getDefault = function () {
 402                 return this.default;
 403         };
 404
 405         /**
 406          * Check if the saved queries were converted
 407          *
 408          * @return {boolean} Saved queries were converted from the previous
 409          *  version to the new version
 410          */
 411         mw.rcfilters.dm.SavedQueriesModel.prototype.isConverted = function () {
 412                 return this.converted;
 413         };
 414 }( mediaWiki, jQuery ) );