Wordpress Media Uploader query-attachment parameter

Question

I'm trying to use the Media Uploader in a plugin. I need to pass additional parameters to the query-attachment request. I've tried to add a parameter to the Library like this:

        file_frame = wp.media.frames.file_frame = wp.media({
        title: "User's photo",
        button: {
            text: "Upload image",
        },
        library: {
            type: ['image/jpeg','image/png'],
     -->       additional_param: 'a value'

        },
        multiple: false  // Set to true to allow multiple files to be selected
    });

But this additional parameter seems to screw up the new attachment upload process - the new uploaded attachment isn't display in the grid at the download end.

Is there a valid way to add a custom parameter to the query-attachment request?

Thank you for your answers

Answer 1

I solved it with:

var post_type = 'my-cpt';
var real_ajax_url = wp.ajax.settings.url;

// For uploading.
window.wp.Uploader.defaults.multipart_params.post_type = post_type;

// For querying.
wp.ajax.settings.url = real_ajax_url + '?post_type=' + post_type;

Then listen on the wp_ajax_query-attachments action for $_GET['post_type'] and listen on the admin_init hook for 'upload-attachment' !== $_POST['action'] and $_POST['post_type'] set to 'my-cpt'.

And unset/restore the values when finished with the dialog.

Answer 2

I dug a little bit un process and the best way to pass additional parameter I found is to add it during the query call. To do it, several classes add to be extended.

Extending Query (wp.media.model.Query) The sync Query's method is responsible to place the actual admin-ajax call to query the attachments. The sync method has 3 arguments, the last one - options - contains the parameters passed to the http request. The extended sync method adds the additional parameter before calling the parent sync request.

// Extending the wp.media.query to add a parameter
var Query1;
Query1=wp.media.model.Query1 = oldQuery.extend({

  sync: function( method, model, options ) {
    options = options || {};
    options = _.extend(options, {'data':{'CadTest': '1'}});
    return oldQuery.prototype.sync.apply(this, arguments);
  }...

Now the must find a way to have this new class instancied. This done is the requery method of the Attachements class which call the 'static' ou 'class method' get of Query. In order to create a query based on Query1, the get method has had to be duplicated creating an Query1 object

    get1: (function(){
    /**
     * @static
     * @type Array
     */
    var queries = [];

    /**
     * @returns {Query}
     */
    return function( props, options ) {
        var args     = {},
            orderby  = Query1.orderby,
            defaults = Query1.defaultProps,
            query,
            cache    = !! props.cache || _.isUndefined( props.cache );

        // Remove the `query` property. This isn't linked to a query,
        // this *is* the query.
        delete props.query;
        delete props.cache;

        // Fill default args.
        _.defaults( props, defaults );

        // Normalize the order.
        props.order = props.order.toUpperCase();
        if ( 'DESC' !== props.order && 'ASC' !== props.order ) {
            props.order = defaults.order.toUpperCase();
        }

        // Ensure we have a valid orderby value.
        if ( ! _.contains( orderby.allowed, props.orderby ) ) {
            props.orderby = defaults.orderby;
        }

        _.each( [ 'include', 'exclude' ], function( prop ) {
            if ( props[ prop ] && ! _.isArray( props[ prop ] ) ) {
                props[ prop ] = [ props[ prop ] ];
            }
        } );

        // Generate the query `args` object.
        // Correct any differing property names.
        _.each( props, function( value, prop ) {
            if ( _.isNull( value ) ) {
                return;
            }

            args[ Query1.propmap[ prop ] || prop ] = value;
        });

        // Fill any other default query args.
        _.defaults( args, Query1.defaultArgs );

        // `props.orderby` does not always map directly to `args.orderby`.
        // Substitute exceptions specified in orderby.keymap.
        args.orderby = orderby.valuemap[ props.orderby ] || props.orderby;

        // Search the query cache for a matching query.
        if ( cache ) {
            query = _.find( queries, function( query ) {
                return _.isEqual( query.args, args );
            });
        } else {
            queries = [];
        }

        // Otherwise, create a new query and add it to the cache.
        if ( ! query ) {
            query = new wp.media.model.Query1( [], _.extend( options || {}, {
                props: props,
                args:  args
            } ) );
            queries.push( query );
        }

        return query;
    };
}()),

Note that get1 is a class method to create in the 2nd parameter of extend()

Extending Attachments - when the _requery method is called - in our case - the Attachments collection is replaced by a Query collection (which makes the actual admin-ajax call to query the attachments). In the extended _requery method, a Query1 query is created instead of a regular Query.

wp.media.model.Attachments1 = oldAttachments.extend({


  _requery: function( refresh ) {
    var props;
    if ( this.props.get('query') ) {
        props = this.props.toJSON();
        props.cache = ( true !== refresh );
        this.mirror( wp.media.model.Query1.get1( props ) );
    }
  },
});

Finally an object of type Attachment1 must be created during the library creation

wp.media.query1 = function( props ) {
  return new wp.media.model.Attachments1( null, {
    props: _.extend( _.defaults( props || {}, { orderby: 'date' } ), { query: true } )
  });
};

and

// Extending the current media library frame to add a new tab
wp.media.view.MediaFrame.Post1 = oldMediaFrame.extend({

 initialize: function(){
    oldMediaFrame.prototype.initialize.apply(this, arguments);
    var options = this.options;
    this.states.add([
        new Library({
            id:         'inserts',
            title:      vja_params.title,
            priority:   20,
            toolbar:    'main-insert',
            filterable: 'all',
            multiple:   false,
            editable:   false,
            library:  wp.media.query1( _.defaults({
                type: 'image'
            }, options.library ) ),


            // Show the attachment display settings.
            displaySettings: true,
            // Update user settings when users adjust the
            // attachment display settings.
            displayUserSettings: true
        }),
   ]);
 },

The additional parameter is added in the _POST array and can be used in PHP code - ie in the query_attachments_args filter

    public function query_attachments_args($args){
      if (isset($_POST[CadTest])) {
        do whatever you want...
      }
      return $args;
   }