Merge "mw.Upload.BookletLayout: Don't explode when the API call fails with 'exception'"
authorjenkins-bot <jenkins-bot@gerrit.wikimedia.org>
Fri, 22 Jan 2016 19:54:32 +0000 (19:54 +0000)
committerGerrit Code Review <gerrit@wikimedia.org>
Fri, 22 Jan 2016 19:54:32 +0000 (19:54 +0000)
1  2 
resources/src/mediawiki/mediawiki.Upload.BookletLayout.js

         */
        mw.Upload.BookletLayout.prototype.initialize = function () {
                var
 -                      apiPromise,
                        booklet = this,
                        deferred = $.Deferred();
  
                this.upload = this.createUpload();
                this.setPage( 'upload' );
  
 -              apiPromise = this.upload.apiPromise || $.Deferred().resolve( this.upload.api );
 -              apiPromise.done( function ( api ) {
 +              this.upload.getApi().done( function ( api ) {
                        // If the user can't upload anything, don't give them the option to.
                        api.getUserInfo().done( function ( userInfo ) {
                                if ( userInfo.rights.indexOf( 'upload' ) === -1 ) {
                        } ).always( function () {
                                deferred.resolve();
                        } );
 +              } ).fail( function ( errorMsg ) {
 +                      booklet.getPage( 'upload' ).$element.msg( errorMsg );
 +                      deferred.resolve();
                } );
  
                return deferred.promise();
                        layout = this,
                        file = this.getFile();
  
 -              this.filenameWidget.setValue( file.name );
 +              this.setFilename( file.name );
 +
                this.setPage( 'info' );
  
                if ( this.shouldRecordBucket ) {
                }
  
                this.upload.setFile( file );
 -              // Explicitly set the filename so that the old filename isn't used in case of retry
 -              this.upload.setFilenameFromFile();
 +              // The original file name might contain invalid characters, so use our sanitized one
 +              this.upload.setFilename( this.getFilename() );
  
                this.uploadPromise = this.upload.uploadToStash();
                this.uploadPromise.then( function () {
                        warnings = stateDetails.upload && stateDetails.upload.warnings;
  
                if ( state === mw.Upload.State.ERROR ) {
+                       if ( !error ) {
+                               // If there's an 'exception' key, this might be a timeout, or other connection problem
+                               return new OO.ui.Error(
+                                       $( '<p>' ).msg( 'api-error-unknownerror', JSON.stringify( stateDetails ) ),
+                                       { recoverable: false }
+                               );
+                       }
                        // HACK We should either have a hook here to allow TitleBlacklist to handle this, or just have
                        // TitleBlacklist produce sane error messages that can be displayed without arcane knowledge
                        if ( error.info === 'TitleBlacklist prevents this title from being created' ) {
                                // HACK Apparently the only reliable way to determine whether TitleBlacklist was involved
                                return new OO.ui.Error(
 -                                      $( '<p>' ).html(
 -                                              // HACK TitleBlacklist doesn't have a sensible message, this one is from UploadWizard
 -                                              mw.message( 'api-error-blacklisted' ).parse()
 -                                      ),
 +                                      // HACK TitleBlacklist doesn't have a sensible message, this one is from UploadWizard
 +                                      $( '<p>' ).msg( 'api-error-blacklisted' ),
                                        { recoverable: false }
                                );
                        }
                                message = mw.message( 'api-error-unknownerror', JSON.stringify( stateDetails ) );
                        }
                        return new OO.ui.Error(
 -                              $( '<p>' ).html(
 -                                      message.parse()
 -                              ),
 +                              $( '<p>' ).append( message.parseDom() ),
                                { recoverable: false }
                        );
                }
                        } else if ( warnings.badfilename !== undefined ) {
                                // Change the name if the current name isn't acceptable
                                // TODO This might not really be the best place to do this
 -                              this.filenameWidget.setValue( warnings.badfilename );
 +                              this.setFilename( warnings.badfilename );
                                return new OO.ui.Error(
                                        $( '<p>' ).msg( 'badfilename', warnings.badfilename )
                                );
                        } else {
                                return new OO.ui.Error(
 -                                      $( '<p>' ).html(
 -                                              // Let's get all the help we can if we can't pin point the error
 -                                              mw.message( 'api-error-unknown-warning', JSON.stringify( stateDetails ) ).parse()
 -                                      ),
 +                                      // Let's get all the help we can if we can't pin point the error
 +                                      $( '<p>' ).msg( 'api-error-unknown-warning', JSON.stringify( stateDetails ) ),
                                        { recoverable: false }
                                );
                        }
                fieldset.addItems( [
                        new OO.ui.FieldLayout( this.filenameWidget, {
                                label: mw.msg( 'upload-form-label-infoform-name' ),
 -                              align: 'top'
 +                              align: 'top',
 +                              help: mw.msg( 'upload-form-label-infoform-name-tooltip' )
                        } ),
                        new OO.ui.FieldLayout( this.descriptionWidget, {
                                label: mw.msg( 'upload-form-label-infoform-description' ),
 -                              align: 'top'
 +                              align: 'top',
 +                              help: mw.msg( 'upload-form-label-infoform-description-tooltip' )
                        } )
                ] );
                this.infoForm = new OO.ui.FormLayout( { items: [ fieldset ] } );
         * @return {string}
         */
        mw.Upload.BookletLayout.prototype.getFilename = function () {
 -              return this.filenameWidget.getValue();
 +              var filename = this.filenameWidget.getValue();
 +              if ( this.filenameExtension ) {
 +                      filename += '.' + this.filenameExtension;
 +              }
 +              return filename;
 +      };
 +
 +      /**
 +       * Prefills the {@link #infoForm information form} with the given filename.
 +       *
 +       * @protected
 +       * @param {string} filename
 +       */
 +      mw.Upload.BookletLayout.prototype.setFilename = function ( filename ) {
 +              var title = mw.Title.newFromFileName( filename );
 +
 +              if ( title ) {
 +                      this.filenameWidget.setValue( title.getNameText() );
 +                      this.filenameExtension = mw.Title.normalizeExtension( title.getExtension() );
 +              } else {
 +                      // Seems to happen for files with no extension, which should fail some checks anyway...
 +                      this.filenameWidget.setValue( filename );
 +                      this.filenameExtension = null;
 +              }
        };
  
        /**