gistfile1.js

onatype.repoServer.RulesetEditor = function( config ){
	var config = config || {};
	var defaultConfig = {
    	region: 'center',
    	width: '100%',
    	height: '100%',
    	autoScroll: true,
    	border: false,
    	frame: true,
    	collapsible: false,
    	collapsed: false,	
    	buttonAlign: 'center',
	};
	Ext.apply( this, config, defaultConfig ); 

	this.ruleTypeDataStore = new Ext.data.JsonStore({
		root: 'data',
		id: 'id',
		fields: [
			{ name: 'id' },
			{ name: 'name', sortType: Ext.data.SortTypes.asUCString }
		],	
		url: Sonatype.config.servicePath + '/staging/rule_types',
		sortInfo: {field: 'name', direction: 'ASC'},
		autoLoad: true
	});	
	
	this.ruleStore = new Ext.data.SimpleStore({
		id: 0,
		fields: [
			{ name: 'name', sortType: Ext.data.SortTypes.asUCString },
			{ name: 'enabled' },
			{ name: 'typeId' },
			{ name: 'typeName' },
			{ name: 'properties' }
		],			
		sortInfo: {field: 'name', direction: 'ASC'}
	});
	
	Sonatype.repoServer.RulesetEditor.superclass.constructor.call( this, {
		items: [
		{
			xtype: 'hidden',
			name: 'id'
		},
		{
			xtype: 'textfield',
			fieldLabel: 'Name',
			itemCls: 'required-field',
			name: 'name',
			width: 250,
			allowBlank: false
		},
		{
			xtype: 'textfield',
			fieldLabel: 'Description',
			name: 'description',
			width: 250
		},
		{
			xtype: 'fieldset',
			title: 'Rules',
			collapsible: false,
			autoHeight: true,
			buttonAlign: 'left',
			items: [
			{
				xtype: 'grid',
				name: 'rulesGrid',
				width: 600,
				height: 200,
				frame: true,
				store: this.ruleStore,
				colModel: new Ext.grid.ColumnModel({
					defaults: {
						width: 120,
						sortable: true
					},
					columns: [
					{ header: 'Enabled', dataIndex: 'enabled', width: 60 },
					{ header: 'Name', dataIndex: 'name', width: 200 },
					{ header: 'Type', dataIndex: 'typeName', width: 200 }
					],
				}),
				selModel: new Ext.grid.RowSelectionModel({
					singleSelect: true
				})
			},
			{
				xtype: 'checkbox',
				fieldLabel: 'Enabled',
				name: 'ruleEnabled',
				checked: true
			},			
			{
				xtype: 'textfield',
				fieldLabel: 'Rule Name',
				name: 'ruleName',
				width: 200
			},
			{
				xtype: 'combo',
				fieldLabel: 'Rule Type',
				name: 'ruleType',
				width: 200,
				store: this.ruleTypeDataStore,
				displayField: 'name',
				valueField: 'id',
				editable: false,
				emptyText: 'Select...',
				selectOnFocus: true,
				triggerAction: 'all',
				forceSelection: true,
				mode: 'local'
			}
			],
			buttons: [
			{
				name: 'ruleAdd',
				text: 'Add',
				handler: this.ruleAddHandler,
				scope: this
			},
			{
				name: 'ruleDelete',
				text: 'Delete',
				handler: this.ruleDeleteHandler,
				scope: this
			}
			]
		}
		],
		buttons: [
		{
			name: 'rulesetSave',
			text: 'Save'
		},
		{
			name: 'rulesetCancel',
			text: 'Cancel'
		}
		]
	});	
	
	this.on( 'afterlayout', this.initData, this );
	
};

Ext.extend( Sonatype.repoServer.RulesetEditor, Ext.form.FormPanel, {
	initData: function() {
		var idField = this.find( 'name', 'id')[0];
		var nameField = this.find( 'name', 'name')[0];
		var descriptionField = this.find( 'name', 'description')[0];
		idField.setValue( this.payload.data.id );
		nameField.setValue( this.payload.data.name );
		this.ruleStore.removeAll();
		descriptionField.setValue( this.payload.data.description );
		for ( var i=0; i < this.payload.data.rules.length; i++ ){
			var ruleRec = new Ext.data.Record( this.payload.data.rules[i] );
			this.ruleStore.addSorted( ruleRec );
		}
	},
	ruleAddHandler: function() {
		var nameField = this.find( 'name', 'ruleName' )[0];
		var name = nameField.getValue();
		if ( this.isRuleNameExisted( name ) )
		{
			nameField.markInvalid( 'Rule with the same name is already existed.' );
			return;
		}
		
		var enabled = this.find( 'name', 'ruleEnabled' )[0].getValue();
		var typeId = this.find( 'name', 'ruleType' )[0].getValue();
		var typeName = this.ruleTypeDataStore.getById( typeId ).data.name;
		var rec = new Ext.data.Record({});
		rec.beginEdit();
		rec.set( 'enabled', enabled );
		rec.set( 'name', name );
		rec.set( 'typeId', typeId );
		rec.set( 'typeName', typeName );
		rec.commit();
		rec.endEdit();
		this.ruleStore.addSorted( rec );
	},
	ruleDeleteHandler: function() {
		var rulesGrid = this.find( 'name', 'rulesGrid' )[0];
		var rec = rulesGrid.getSelectionModel().getSelected();
		this.ruleStore.remove( rec );
	},
	isRuleNameExisted: function ( ruleName ){
		if ( this.ruleStore.getById( ruleName) ){
			return true;
		}
		return false;
	}
});

Sonatype.Events.addListener( 'rulesetViewInit', function( cardPanel, rec, gridPanel ) {
  var sp = Sonatype.lib.Permissions;
  if ( sp.checkPermission( 'nexus:stagingrulesets', sp.READ ) &&
      ( sp.checkPermission( 'nexus:stagingrulesets', sp.CREATE ) ||
        sp.checkPermission( 'nexus:stagingrulesets', sp.DELETE ) ||
        sp.checkPermission( 'nexus:stagingrulesets', sp.EDIT ) ) ) {
    cardPanel.add( new Sonatype.repoServer.RulesetEditor( {
    	payload: rec 
    } ) );
  }
} );