mirror of https://github.com/apache/lucene.git
4632 lines
226 KiB
JavaScript
4632 lines
226 KiB
JavaScript
var loader = {
|
|
|
|
show : function( element )
|
|
{
|
|
$( element )
|
|
.addClass( 'loader' );
|
|
},
|
|
|
|
hide : function( element )
|
|
{
|
|
$( element )
|
|
.removeClass( 'loader' );
|
|
}
|
|
|
|
};
|
|
|
|
Number.prototype.esc = function()
|
|
{
|
|
return new String( this ).esc();
|
|
}
|
|
|
|
String.prototype.esc = function()
|
|
{
|
|
return this.replace( /</g, '<' ).replace( />/g, '>' );
|
|
}
|
|
|
|
var sammy = $.sammy
|
|
(
|
|
function()
|
|
{
|
|
this.bind
|
|
(
|
|
'run',
|
|
function( event, config )
|
|
{
|
|
if( 0 === config.start_url.length )
|
|
{
|
|
location.href = '#/';
|
|
return false;
|
|
}
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'ping',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : $( this.params.element ).attr( 'rel' ) + '?wt=json&ts=' + (new Date).getTime(),
|
|
dataType : 'json',
|
|
context: this.params.element,
|
|
beforeSend : function( arr, form, options )
|
|
{
|
|
loader.show( this );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( this )
|
|
.removeAttr( 'title' );
|
|
|
|
$( this ).parents( 'li' )
|
|
.removeClass( 'error' );
|
|
|
|
var qtime_element = $( '.qtime', this );
|
|
|
|
if( 0 === qtime_element.size() )
|
|
{
|
|
qtime_element = $( '<small class="qtime"> (<span></span>)</small>' );
|
|
|
|
$( this )
|
|
.append
|
|
(
|
|
qtime_element
|
|
);
|
|
}
|
|
|
|
$( 'span', qtime_element )
|
|
.html( response.responseHeader.QTime + 'ms' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
$( this )
|
|
.attr( 'title', '/admin/ping is not configured (' + xhr.status + ': ' + error_thrown + ')' );
|
|
|
|
$( this ).parents( 'li' )
|
|
.addClass( 'error' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
loader.hide( this );
|
|
}
|
|
}
|
|
);
|
|
|
|
return false;
|
|
}
|
|
);
|
|
|
|
// activate_core
|
|
this.before
|
|
(
|
|
{},
|
|
function()
|
|
{
|
|
$( 'li[id].active', app.menu_element )
|
|
.removeClass( 'active' );
|
|
|
|
$( 'ul li.active', app.menu_element )
|
|
.removeClass( 'active' );
|
|
|
|
if( this.params.splat )
|
|
{
|
|
var active_element = $( '#' + this.params.splat[0], app.menu_element );
|
|
|
|
active_element
|
|
.addClass( 'active' );
|
|
|
|
if( this.params.splat[1] )
|
|
{
|
|
$( '.' + this.params.splat[1], active_element )
|
|
.addClass( 'active' );
|
|
}
|
|
|
|
if( !active_element.hasClass( 'global' ) )
|
|
{
|
|
this.active_core = active_element;
|
|
}
|
|
}
|
|
}
|
|
);
|
|
|
|
// #/cloud
|
|
this.get
|
|
(
|
|
/^#\/(cloud)$/,
|
|
function( context )
|
|
{
|
|
var content_element = $( '#content' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/cloud.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var zookeeper_element = $( '#zookeeper', content_element );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : app.config.zookeeper_path,
|
|
dataType : 'json',
|
|
context : $( '.content', zookeeper_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.html( '<div class="loader">Loading ...</div>' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
this
|
|
.html( '<div id="zookeeper-tree" class="tree"></div>' );
|
|
|
|
$( '#zookeeper-tree', this )
|
|
.jstree
|
|
(
|
|
{
|
|
"plugins" : [ "json_data" ],
|
|
"json_data" : {
|
|
"data" : response.tree,
|
|
"progressive_render" : true
|
|
},
|
|
"core" : {
|
|
"animation" : 0
|
|
}
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'cores_load_data',
|
|
function( event, params )
|
|
{
|
|
if( app.cores_data )
|
|
{
|
|
params.callback( app.cores_data );
|
|
return true;
|
|
}
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : app.config.solr_path + app.config.core_admin_path + '?wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
app.cores_data = response.status;
|
|
params.callback( app.cores_data );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'cores_build_navigation',
|
|
function( event, params )
|
|
{
|
|
var navigation_content = ['<ul>'];
|
|
|
|
for( var core in params.cores )
|
|
{
|
|
navigation_content.push( '<li><a href="' + params.basepath + core + '">' + core + '</a></li>' );
|
|
}
|
|
|
|
params.navigation_element
|
|
.html( navigation_content.join( "\n" ) );
|
|
|
|
$( 'a[href="' + params.basepath + params.current_core + '"]', params.navigation_element ).parent()
|
|
.addClass( 'current' );
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'cores_load_template',
|
|
function( event, params )
|
|
{
|
|
if( app.cores_template )
|
|
{
|
|
params.callback();
|
|
return true;
|
|
}
|
|
|
|
$.get
|
|
(
|
|
'tpl/cores.html',
|
|
function( template )
|
|
{
|
|
params.content_element
|
|
.html( template );
|
|
|
|
app.cores_template = template;
|
|
params.callback();
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/cores
|
|
this.get
|
|
(
|
|
/^#\/(cores)$/,
|
|
function( context )
|
|
{
|
|
delete app.cores_template;
|
|
|
|
sammy.trigger
|
|
(
|
|
'cores_load_data',
|
|
{
|
|
callback : function( cores )
|
|
{
|
|
var first_core = null;
|
|
for( var key in cores )
|
|
{
|
|
if( !first_core )
|
|
{
|
|
first_core = key;
|
|
}
|
|
continue;
|
|
}
|
|
context.redirect( context.path + '/' + first_core );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/cores
|
|
this.get
|
|
(
|
|
/^#\/(cores)\//,
|
|
function( context )
|
|
{
|
|
var content_element = $( '#content' );
|
|
|
|
var path_parts = this.path.match( /^(.+\/cores\/)(.*)$/ );
|
|
var current_core = path_parts[2];
|
|
|
|
sammy.trigger
|
|
(
|
|
'cores_load_data',
|
|
{
|
|
callback : function( cores )
|
|
{
|
|
sammy.trigger
|
|
(
|
|
'cores_load_template',
|
|
{
|
|
content_element : content_element,
|
|
callback : function()
|
|
{
|
|
var cores_element = $( '#cores', content_element );
|
|
var navigation_element = $( '#navigation', cores_element );
|
|
var list_element = $( '#list', navigation_element );
|
|
var data_element = $( '#data', cores_element );
|
|
var core_data_element = $( '#core-data', data_element );
|
|
var index_data_element = $( '#index-data', data_element );
|
|
|
|
sammy.trigger
|
|
(
|
|
'cores_build_navigation',
|
|
{
|
|
cores : cores,
|
|
basepath : path_parts[1],
|
|
current_core : current_core,
|
|
navigation_element : list_element
|
|
}
|
|
);
|
|
|
|
var core_data = cores[current_core];
|
|
var core_basepath = $( '#' + current_core, app.menu_element ).attr( 'data-basepath' );
|
|
|
|
// core-data
|
|
|
|
$( 'h2 span', core_data_element )
|
|
.html( core_data.name );
|
|
|
|
$( '.startTime dd', core_data_element )
|
|
.html( core_data.startTime );
|
|
|
|
$( '.instanceDir dd', core_data_element )
|
|
.html( core_data.instanceDir );
|
|
|
|
$( '.dataDir dd', core_data_element )
|
|
.html( core_data.dataDir );
|
|
|
|
// index-data
|
|
|
|
$( '.lastModified dd', index_data_element )
|
|
.html( core_data.index.lastModified );
|
|
|
|
$( '.version dd', index_data_element )
|
|
.html( core_data.index.version );
|
|
|
|
$( '.numDocs dd', index_data_element )
|
|
.html( core_data.index.numDocs );
|
|
|
|
$( '.maxDoc dd', index_data_element )
|
|
.html( core_data.index.maxDoc );
|
|
|
|
$( '.optimized dd', index_data_element )
|
|
.addClass( core_data.index.optimized ? 'ico-1' : 'ico-0' );
|
|
|
|
$( '#actions .optimize', cores_element )
|
|
.show();
|
|
|
|
$( '.optimized dd span', index_data_element )
|
|
.html( core_data.index.optimized ? 'yes' : 'no' );
|
|
|
|
$( '.current dd', index_data_element )
|
|
.addClass( core_data.index.current ? 'ico-1' : 'ico-0' );
|
|
|
|
$( '.current dd span', index_data_element )
|
|
.html( core_data.index.current ? 'yes' : 'no' );
|
|
|
|
$( '.hasDeletions dd', index_data_element )
|
|
.addClass( core_data.index.hasDeletions ? 'ico-1' : 'ico-0' );
|
|
|
|
$( '.hasDeletions dd span', index_data_element )
|
|
.html( core_data.index.hasDeletions ? 'yes' : 'no' );
|
|
|
|
$( '.directory dd', index_data_element )
|
|
.html
|
|
(
|
|
core_data.index.directory
|
|
.replace( /:/g, ':​' )
|
|
.replace( /@/g, '@​' )
|
|
);
|
|
|
|
var core_names = [];
|
|
var core_selects = $( '#actions select', cores_element );
|
|
|
|
for( var key in cores )
|
|
{
|
|
core_names.push( '<option value="' + key + '">' + key + '</option>' )
|
|
}
|
|
|
|
core_selects
|
|
.html( core_names.join( "\n") );
|
|
|
|
$( 'option[value="' + current_core + '"]', core_selects.filter( '#swap_core' ) )
|
|
.attr( 'selected', 'selected' );
|
|
|
|
$( 'option[value="' + current_core + '"]', core_selects.filter( '.other' ) )
|
|
.attr( 'disabled', 'disabled' )
|
|
.addClass( 'disabled' );
|
|
|
|
$( 'input[name="core"]', cores_element )
|
|
.val( current_core );
|
|
|
|
// layout
|
|
|
|
var actions_element = $( '.actions', cores_element );
|
|
var button_holder_element = $( '.button-holder.options', actions_element );
|
|
|
|
button_holder_element
|
|
.die( 'toggle' )
|
|
.live
|
|
(
|
|
'toggle',
|
|
function( event )
|
|
{
|
|
var element = $( this );
|
|
|
|
element
|
|
.toggleClass( 'active' );
|
|
|
|
if( element.hasClass( 'active' ) )
|
|
{
|
|
button_holder_element
|
|
.not( element )
|
|
.removeClass( 'active' );
|
|
}
|
|
}
|
|
);
|
|
|
|
$( '.button a', button_holder_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).parents( '.button-holder' )
|
|
.trigger( 'toggle' );
|
|
}
|
|
);
|
|
|
|
$( 'form a.submit', button_holder_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
var element = $( this );
|
|
var form_element = element.parents( 'form' );
|
|
var action = $( 'input[name="action"]', form_element ).val().toLowerCase();
|
|
|
|
form_element
|
|
.ajaxSubmit
|
|
(
|
|
{
|
|
url : app.config.solr_path + app.config.core_admin_path + '?wt=json',
|
|
dataType : 'json',
|
|
beforeSubmit : function( array, form, options )
|
|
{
|
|
//loader
|
|
},
|
|
success : function( response, status_text, xhr, form )
|
|
{
|
|
delete app.cores_data;
|
|
|
|
if( 'rename' === action )
|
|
{
|
|
context.redirect( path_parts[1] + $( 'input[name="other"]', form_element ).val() );
|
|
}
|
|
else if( 'swap' === action )
|
|
{
|
|
window.location.reload();
|
|
}
|
|
|
|
$( 'a.reset', form )
|
|
.trigger( 'click' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
},
|
|
complete : function()
|
|
{
|
|
//loader
|
|
}
|
|
}
|
|
);
|
|
|
|
return false;
|
|
}
|
|
);
|
|
|
|
$( 'form a.reset', button_holder_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).parents( 'form' )
|
|
.resetForm();
|
|
|
|
$( this ).parents( '.button-holder' )
|
|
.trigger( 'toggle' );
|
|
|
|
return false;
|
|
}
|
|
);
|
|
|
|
var reload_button = $( '#actions .reload', cores_element );
|
|
reload_button
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : app.config.solr_path + app.config.core_admin_path + '?wt=json&action=RELOAD&core=' + current_core,
|
|
dataType : 'json',
|
|
context : $( this ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
this
|
|
.addClass( 'success' );
|
|
|
|
window.setTimeout
|
|
(
|
|
function()
|
|
{
|
|
reload_button
|
|
.removeClass( 'success' );
|
|
},
|
|
5000
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
$( '#actions .unload', cores_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : app.config.solr_path + app.config.core_admin_path + '?wt=json&action=UNLOAD&core=' + current_core,
|
|
dataType : 'json',
|
|
context : $( this ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
delete app.cores_data;
|
|
context.redirect( path_parts[1].substr( 0, path_parts[1].length - 1 ) );
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
var optimize_button = $( '#actions .optimize', cores_element );
|
|
optimize_button
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/update?optimize=true&waitFlush=true&wt=json',
|
|
dataType : 'json',
|
|
context : $( this ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
this
|
|
.addClass( 'success' );
|
|
|
|
window.setTimeout
|
|
(
|
|
function()
|
|
{
|
|
optimize_button
|
|
.removeClass( 'success' );
|
|
},
|
|
5000
|
|
);
|
|
|
|
$( '.optimized dd.ico-0', index_data_element )
|
|
.removeClass( 'ico-0' )
|
|
.addClass( 'ico-1' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
console.warn( 'd0h, optimize broken!' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
$( '.timeago', data_element )
|
|
.timeago();
|
|
|
|
$( 'ul', data_element )
|
|
.each
|
|
(
|
|
function( i, element )
|
|
{
|
|
$( 'li:odd', element )
|
|
.addClass( 'odd' );
|
|
}
|
|
)
|
|
}
|
|
}
|
|
);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/logging
|
|
this.get
|
|
(
|
|
/^#\/(logging)$/,
|
|
function( context )
|
|
{
|
|
var content_element = $( '#content' );
|
|
|
|
content_element
|
|
.html( '<div id="logging"></div>' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : 'logging.json',
|
|
dataType : 'json',
|
|
context : $( '#logging', content_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.html( '<div class="loader">Loading ...</div>' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var logger = response.logger;
|
|
|
|
var loglevel = '<div class="loglevel %class%">' + "\n";
|
|
loglevel += '<a class="effective_level trigger"><span>%effective_level%</span></a>' + "\n";
|
|
loglevel += '<ul>' + "\n";
|
|
|
|
for( var key in response.levels )
|
|
{
|
|
var level = response.levels[key].esc();
|
|
loglevel += '<li class="' + level + '"><a>' + level + '</a></li>' + "\n";
|
|
}
|
|
|
|
loglevel += '<li class="UNSET"><a>UNSET</a></li>' + "\n";
|
|
loglevel += '</ul>' + "\n";
|
|
loglevel += '</div>';
|
|
|
|
var logger_tree = function( filter )
|
|
{
|
|
var logger_content = '';
|
|
var filter_regex = new RegExp( '^' + filter + '\\.\\w+$' );
|
|
|
|
for( var logger_name in logger )
|
|
{
|
|
var continue_matcher = false;
|
|
|
|
if( !filter )
|
|
{
|
|
continue_matcher = logger_name.indexOf( '.' ) !== -1;
|
|
}
|
|
else
|
|
{
|
|
continue_matcher = !logger_name.match( filter_regex );
|
|
}
|
|
|
|
if( continue_matcher )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var has_logger_instance = !!logger[logger_name];
|
|
|
|
var classes = [];
|
|
|
|
has_logger_instance
|
|
? classes.push( 'active' )
|
|
: classes.push( 'inactive' );
|
|
|
|
logger_content += '<li class="jstree-leaf">';
|
|
logger_content += '<ins class="jstree-icon"> </ins>';
|
|
logger_content += '<a class="trigger ' + classes.join( ' ' ) + '" ' + "\n" +
|
|
'title="' + logger_name.esc() + '"><span>' + "\n" +
|
|
logger_name.split( '.' ).pop().esc() + "\n" +
|
|
'</span></a>';
|
|
|
|
logger_content += loglevel
|
|
.replace
|
|
(
|
|
/%class%/g,
|
|
classes.join( ' ' )
|
|
)
|
|
.replace
|
|
(
|
|
/%effective_level%/g,
|
|
has_logger_instance
|
|
? logger[logger_name].effective_level
|
|
: 'null'
|
|
);
|
|
|
|
var child_logger_content = logger_tree( logger_name );
|
|
if( child_logger_content )
|
|
{
|
|
logger_content += '<ul>';
|
|
logger_content += child_logger_content;
|
|
logger_content += '</ul>';
|
|
}
|
|
|
|
logger_content += '</li>';
|
|
}
|
|
|
|
return logger_content;
|
|
}
|
|
|
|
var logger_content = logger_tree( null );
|
|
|
|
this
|
|
.html( '<ul class="tree jstree">' + logger_content + '</ul>' );
|
|
|
|
$( 'li:last-child', this )
|
|
.addClass( 'jstree-last' );
|
|
|
|
$( '.loglevel', this )
|
|
.each
|
|
(
|
|
function( index, element )
|
|
{
|
|
var element = $( element );
|
|
var effective_level = $( '.effective_level span', element ).text();
|
|
|
|
element
|
|
.css( 'z-index', 800 - index );
|
|
|
|
$( 'ul .' + effective_level, element )
|
|
.addClass( 'selected' );
|
|
}
|
|
);
|
|
|
|
$( '.trigger', this )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( '.loglevel', $( this ).parents( 'li' ).first() ).first()
|
|
.trigger( 'toggle' );
|
|
}
|
|
);
|
|
|
|
$( '.loglevel', this )
|
|
.die( 'toggle')
|
|
.live
|
|
(
|
|
'toggle',
|
|
function( event )
|
|
{
|
|
$( this )
|
|
.toggleClass( 'open' );
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/java-properties
|
|
this.get
|
|
(
|
|
/^#\/(java-properties)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = $( 'li[data-basepath]', app.menu_element ).attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
content_element
|
|
.html( '<div id="java-properties"></div>' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/properties?wt=json',
|
|
dataType : 'json',
|
|
context : $( '#java-properties', content_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.html( '<div class="loader">Loading ...</div>' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var system_properties = response['system.properties'];
|
|
var properties_data = {};
|
|
var properties_content = [];
|
|
var properties_order = [];
|
|
|
|
for( var key in system_properties )
|
|
{
|
|
var displayed_key = key.replace( /\./g, '.​' );
|
|
var displayed_value = [ system_properties[key] ];
|
|
var item_class = 'clearfix';
|
|
|
|
if( -1 !== key.indexOf( '.path' ) )
|
|
{
|
|
displayed_value = system_properties[key].split( system_properties['path.separator'] );
|
|
if( 1 < displayed_value.length )
|
|
{
|
|
item_class += ' multi';
|
|
}
|
|
}
|
|
|
|
var item_content = '<li><dl class="' + item_class + '">' + "\n" +
|
|
'<dt>' + displayed_key.esc() + '</dt>' + "\n";
|
|
|
|
for( var i in displayed_value )
|
|
{
|
|
item_content += '<dd>' + displayed_value[i].esc() + '</dd>' + "\n";
|
|
}
|
|
|
|
item_content += '</dl></li>';
|
|
|
|
properties_data[key] = item_content;
|
|
properties_order.push( key );
|
|
}
|
|
|
|
properties_order.sort();
|
|
for( var i in properties_order )
|
|
{
|
|
properties_content.push( properties_data[properties_order[i]] );
|
|
}
|
|
|
|
this
|
|
.html( '<ul>' + properties_content.join( "\n" ) + '</ul>' );
|
|
|
|
$( 'li:odd', this )
|
|
.addClass( 'odd' );
|
|
|
|
$( '.multi dd:odd', this )
|
|
.addClass( 'odd' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/threads
|
|
this.get
|
|
(
|
|
/^#\/(threads)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = $( 'li[data-basepath]', app.menu_element ).attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/threads.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/threads?wt=json',
|
|
dataType : 'json',
|
|
context : $( '#threads', content_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var self = this;
|
|
|
|
var threadDumpData = response.system.threadDump;
|
|
var threadDumpContent = [];
|
|
var c = 0;
|
|
for( var i = 1; i < threadDumpData.length; i += 2 )
|
|
{
|
|
var state = threadDumpData[i].state.esc();
|
|
var name = '<a><span>' + threadDumpData[i].name.esc() + '</span></a>';
|
|
|
|
var classes = [state];
|
|
var details = '';
|
|
|
|
if( 0 !== c % 2 )
|
|
{
|
|
classes.push( 'odd' );
|
|
}
|
|
|
|
if( threadDumpData[i].lock )
|
|
{
|
|
classes.push( 'lock' );
|
|
name += "\n" + '<p title="Waiting on">' + threadDumpData[i].lock.esc() + '</p>';
|
|
}
|
|
|
|
if( threadDumpData[i].stackTrace && 0 !== threadDumpData[i].stackTrace.length )
|
|
{
|
|
classes.push( 'stacktrace' );
|
|
|
|
var stack_trace = threadDumpData[i].stackTrace
|
|
.join( '###' )
|
|
.esc()
|
|
.replace( /\(/g, '​(' )
|
|
.replace( /###/g, '</li><li>' );
|
|
|
|
name += '<div>' + "\n"
|
|
+ '<ul>' + "\n"
|
|
+ '<li>' + stack_trace + '</li>'
|
|
+ '</ul>' + "\n"
|
|
+ '</div>';
|
|
}
|
|
|
|
var item = '<tr class="' + classes.join( ' ' ) +'">' + "\n"
|
|
|
|
+ '<td class="ico" title="' + state +'"><span>' + state +'</span></td>' + "\n"
|
|
+ '<td class="id">' + threadDumpData[i].id.esc() + '</td>' + "\n"
|
|
+ '<td class="name">' + name + '</td>' + "\n"
|
|
+ '<td class="time">' + threadDumpData[i].cpuTime.esc() + '</td>' + "\n"
|
|
+ '<td class="time">' + threadDumpData[i].userTime.esc() + '</td>' + "\n"
|
|
|
|
+ '</tr>';
|
|
|
|
threadDumpContent.push( item );
|
|
c++;
|
|
}
|
|
|
|
var threadDumpBody = $( '#thread-dump tbody', this );
|
|
|
|
threadDumpBody
|
|
.html( threadDumpContent.join( "\n" ) );
|
|
|
|
$( '.name a', threadDumpBody )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).closest( 'tr' )
|
|
.toggleClass( 'open' );
|
|
}
|
|
);
|
|
|
|
$( '.controls a', this )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
var threads_element = $( self );
|
|
var is_collapsed = threads_element.hasClass( 'collapsed' );
|
|
var thread_rows = $( 'tr', threads_element );
|
|
|
|
thread_rows
|
|
.each
|
|
(
|
|
function( index, element )
|
|
{
|
|
if( is_collapsed )
|
|
{
|
|
$( element )
|
|
.addClass( 'open' );
|
|
}
|
|
else
|
|
{
|
|
$( element )
|
|
.removeClass( 'open' );
|
|
}
|
|
}
|
|
);
|
|
|
|
threads_element
|
|
.toggleClass( 'collapsed' )
|
|
.toggleClass( 'expanded' );
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/replication
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(replication)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/replication.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var replication_element = $( '#replication', content_element );
|
|
var navigation_element = $( '#navigation', replication_element );
|
|
|
|
function convert_seconds_to_readable_time( value )
|
|
{
|
|
var text = [];
|
|
value = parseInt( value );
|
|
|
|
var minutes = Math.floor( value / 60 );
|
|
var hours = Math.floor( minutes / 60 );
|
|
|
|
if( 0 !== hours )
|
|
{
|
|
text.push( hours + 'h' );
|
|
value -= hours * 60 * 60;
|
|
minutes -= hours * 60;
|
|
}
|
|
|
|
if( 0 !== minutes )
|
|
{
|
|
text.push( minutes + 'm' );
|
|
value -= minutes * 60;
|
|
}
|
|
|
|
text.push( value + 's' );
|
|
|
|
return text.join( ' ' );
|
|
}
|
|
|
|
function replication_fetch_status()
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/replication?command=details&wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
$( '.refresh-status', navigation_element )
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( '.refresh-status', navigation_element )
|
|
.removeClass( 'loader' );
|
|
|
|
var data = response.details;
|
|
var is_slave = 'true' === data.isSlave;
|
|
|
|
replication_element
|
|
.addClass( is_slave ? 'slave' : 'master' );
|
|
|
|
if( is_slave )
|
|
{
|
|
var error_element = $( '#error', replication_element );
|
|
|
|
if( data.slave.ERROR )
|
|
{
|
|
error_element
|
|
.html( data.slave.ERROR )
|
|
.show();
|
|
}
|
|
else
|
|
{
|
|
error_element
|
|
.hide()
|
|
.empty();
|
|
}
|
|
|
|
var progress_element = $( '#progress', replication_element );
|
|
|
|
var start_element = $( '#start', progress_element );
|
|
$( 'span', start_element )
|
|
.text( data.slave.replicationStartTime );
|
|
|
|
var eta_element = $( '#eta', progress_element );
|
|
$( 'span', eta_element )
|
|
.text( convert_seconds_to_readable_time( data.slave.timeRemaining ) );
|
|
|
|
var bar_element = $( '#bar', progress_element );
|
|
$( '.files span', bar_element )
|
|
.text( data.slave.numFilesToDownload );
|
|
$( '.size span', bar_element )
|
|
.text( data.slave.bytesToDownload );
|
|
|
|
var speed_element = $( '#speed', progress_element );
|
|
$( 'span', speed_element )
|
|
.text( data.slave.downloadSpeed );
|
|
|
|
var done_element = $( '#done', progress_element );
|
|
$( '.files span', done_element )
|
|
.text( data.slave.numFilesDownloaded );
|
|
$( '.size span', done_element )
|
|
.text( data.slave.bytesDownloaded );
|
|
$( '.percent span', done_element )
|
|
.text( parseInt(data.slave.totalPercent ) );
|
|
|
|
var percent = parseInt( data.slave.totalPercent );
|
|
if( 0 === percent )
|
|
{
|
|
done_element
|
|
.css( 'width', '1px' );
|
|
}
|
|
else
|
|
{
|
|
done_element
|
|
.css( 'width', percent + '%' );
|
|
}
|
|
|
|
var current_file_element = $( '#current-file', replication_element );
|
|
$( '.file', current_file_element )
|
|
.text( data.slave.currentFile );
|
|
$( '.done', current_file_element )
|
|
.text( data.slave.currentFileSizeDownloaded );
|
|
$( '.total', current_file_element )
|
|
.text( data.slave.currentFileSize );
|
|
$( '.percent', current_file_element )
|
|
.text( parseInt( data.slave.currentFileSizePercent ) );
|
|
|
|
if( !data.slave.indexReplicatedAtList )
|
|
{
|
|
data.slave.indexReplicatedAtList = [];
|
|
}
|
|
|
|
if( !data.slave.replicationFailedAtList )
|
|
{
|
|
data.slave.replicationFailedAtList = [];
|
|
}
|
|
|
|
var iterations_element = $( '#iterations', replication_element );
|
|
var iterations_list = $( '.iterations ul', iterations_element );
|
|
|
|
var iterations_data = [];
|
|
$.merge( iterations_data, data.slave.indexReplicatedAtList );
|
|
$.merge( iterations_data, data.slave.replicationFailedAtList );
|
|
|
|
if( 0 !== iterations_data.length )
|
|
{
|
|
var iterations = [];
|
|
for( var i = 0; i < iterations_data.length; i++ )
|
|
{
|
|
iterations.push
|
|
(
|
|
'<li data-date="' + iterations_data[i] + '">' +
|
|
iterations_data[i] + '</li>'
|
|
);
|
|
}
|
|
|
|
iterations_list
|
|
.html( iterations.join( "\n" ) )
|
|
.show();
|
|
|
|
$( data.slave.indexReplicatedAtList )
|
|
.each
|
|
(
|
|
function( key, value )
|
|
{
|
|
$( 'li[data-date="' + value + '"]', iterations_list )
|
|
.addClass( 'replicated' );
|
|
}
|
|
);
|
|
|
|
if( data.slave.indexReplicatedAt )
|
|
{
|
|
$(
|
|
'li[data-date="' + data.slave.indexReplicatedAt + '"]',
|
|
iterations_list
|
|
)
|
|
.addClass( 'latest' );
|
|
}
|
|
|
|
$( data.slave.replicationFailedAtList )
|
|
.each
|
|
(
|
|
function( key, value )
|
|
{
|
|
$( 'li[data-date="' + value + '"]', iterations_list )
|
|
.addClass( 'failed' );
|
|
}
|
|
);
|
|
|
|
if( data.slave.replicationFailedAt )
|
|
{
|
|
$(
|
|
'li[data-date="' + data.slave.replicationFailedAt + '"]',
|
|
iterations_list
|
|
)
|
|
.addClass( 'latest' );
|
|
}
|
|
|
|
if( 0 !== $( 'li:hidden', iterations_list ).size() )
|
|
{
|
|
$( 'a', iterations_element )
|
|
.show();
|
|
}
|
|
else
|
|
{
|
|
$( 'a', iterations_element )
|
|
.hide();
|
|
}
|
|
}
|
|
}
|
|
|
|
var details_element = $( '#details', replication_element );
|
|
var current_type_element = $( ( is_slave ? '.slave' : '.master' ), details_element );
|
|
|
|
$( '.version div', current_type_element )
|
|
.html( data.indexVersion );
|
|
$( '.generation div', current_type_element )
|
|
.html( data.generation );
|
|
$( '.size div', current_type_element )
|
|
.html( data.indexSize );
|
|
|
|
if( is_slave )
|
|
{
|
|
var master_element = $( '.master', details_element );
|
|
$( '.version div', master_element )
|
|
.html( data.slave.masterDetails.indexVersion );
|
|
$( '.generation div', master_element )
|
|
.html( data.slave.masterDetails.generation );
|
|
$( '.size div', master_element )
|
|
.html( data.slave.masterDetails.indexSize );
|
|
|
|
if( data.indexVersion !== data.slave.masterDetails.indexVersion )
|
|
{
|
|
$( '.version', details_element )
|
|
.addClass( 'diff' );
|
|
}
|
|
else
|
|
{
|
|
$( '.version', details_element )
|
|
.removeClass( 'diff' );
|
|
}
|
|
|
|
if( data.generation !== data.slave.masterDetails.generation )
|
|
{
|
|
$( '.generation', details_element )
|
|
.addClass( 'diff' );
|
|
}
|
|
else
|
|
{
|
|
$( '.generation', details_element )
|
|
.removeClass( 'diff' );
|
|
}
|
|
}
|
|
|
|
if( is_slave )
|
|
{
|
|
var settings_element = $( '#settings', replication_element );
|
|
|
|
if( data.slave.masterUrl )
|
|
{
|
|
$( '.masterUrl dd', settings_element )
|
|
.html( response.details.slave.masterUrl )
|
|
.parents( 'li' ).show();
|
|
}
|
|
|
|
var polling_content = ' ';
|
|
var polling_ico = 'ico-1';
|
|
|
|
if( 'true' === data.slave.isPollingDisabled )
|
|
{
|
|
polling_ico = 'ico-0';
|
|
|
|
$( '.disable-polling', navigation_element ).hide();
|
|
$( '.enable-polling', navigation_element ).show();
|
|
}
|
|
else
|
|
{
|
|
$( '.disable-polling', navigation_element ).show();
|
|
$( '.enable-polling', navigation_element ).hide();
|
|
|
|
if( data.slave.pollInterval )
|
|
{
|
|
polling_content = '(interval: ' + data.slave.pollInterval + ')';
|
|
}
|
|
}
|
|
|
|
$( '.isPollingDisabled dd', settings_element )
|
|
.removeClass( 'ico-0' )
|
|
.removeClass( 'ico-1' )
|
|
.addClass( polling_ico )
|
|
.html( polling_content )
|
|
.parents( 'li' ).show();
|
|
}
|
|
|
|
var master_settings_element = $( '#master-settings', replication_element );
|
|
|
|
var master_data = is_slave
|
|
? data.slave.masterDetails.master
|
|
: data.master;
|
|
|
|
var replication_icon = 'ico-0';
|
|
if( 'true' === master_data.replicationEnabled )
|
|
{
|
|
replication_icon = 'ico-1';
|
|
|
|
$( '.disable-replication', navigation_element ).show();
|
|
$( '.enable-replication', navigation_element ).hide();
|
|
}
|
|
else
|
|
{
|
|
$( '.disable-replication', navigation_element ).hide();
|
|
$( '.enable-replication', navigation_element ).show();
|
|
}
|
|
|
|
$( '.replicationEnabled dd', master_settings_element )
|
|
.removeClass( 'ico-0' )
|
|
.removeClass( 'ico-1' )
|
|
.addClass( replication_icon )
|
|
.parents( 'li' ).show();
|
|
|
|
$( '.replicateAfter dd', master_settings_element )
|
|
.html( master_data.replicateAfter.join( ', ' ) )
|
|
.parents( 'li' ).show();
|
|
|
|
if( master_data.confFiles )
|
|
{
|
|
var conf_files = [];
|
|
var conf_data = master_data.confFiles.split( ',' );
|
|
|
|
for( var i = 0; i < conf_data.length; i++ )
|
|
{
|
|
var item = conf_data[i];
|
|
|
|
if( - 1 !== item.indexOf( ':' ) )
|
|
{
|
|
info = item.split( ':' );
|
|
item = '<abbr title="' + info[0] + ' » ' + info[1] + '">'
|
|
+ ( is_slave ? info[1] : info[0] )
|
|
+ '</abbr>';
|
|
}
|
|
|
|
conf_files.push( item );
|
|
}
|
|
|
|
$( '.confFiles dd', master_settings_element )
|
|
.html( conf_files.join( ', ' ) )
|
|
.parents( 'li' ).show();
|
|
}
|
|
|
|
|
|
$( '.block', replication_element ).last()
|
|
.addClass( 'last' );
|
|
|
|
|
|
|
|
|
|
if( 'true' === data.slave.isReplicating )
|
|
{
|
|
replication_element
|
|
.addClass( 'replicating' );
|
|
|
|
$( '.replicate-now', navigation_element ).hide();
|
|
$( '.abort-replication', navigation_element ).show();
|
|
|
|
window.setTimeout( replication_fetch_status, 1000 );
|
|
}
|
|
else
|
|
{
|
|
replication_element
|
|
.removeClass( 'replicating' );
|
|
|
|
$( '.replicate-now', navigation_element ).show();
|
|
$( '.abort-replication', navigation_element ).hide();
|
|
}
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
$( '#content' )
|
|
.html( 'sorry, no replication-handler defined!' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
replication_fetch_status();
|
|
|
|
$( '#iterations a', content_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).parents( '.iterations' )
|
|
.toggleClass( 'expanded' );
|
|
|
|
return false;
|
|
}
|
|
);
|
|
|
|
$( 'button', navigation_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
var button = $( this );
|
|
var command = button.data( 'command' );
|
|
|
|
if( button.hasClass( 'refresh-status' ) && !button.hasClass( 'loader' ) )
|
|
{
|
|
replication_fetch_status();
|
|
}
|
|
else if( command )
|
|
{
|
|
$.get
|
|
(
|
|
core_basepath + '/replication?command=' + command + '&wt=json',
|
|
function()
|
|
{
|
|
replication_fetch_status();
|
|
}
|
|
);
|
|
}
|
|
return false;
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'schema_browser_navi',
|
|
function( event, params )
|
|
{
|
|
var related_navigation_element = $( '#related dl#f-df-t', params.schema_browser_element );
|
|
var related_navigation_meta = $( '#related dl.ukf-dsf', params.schema_browser_element );
|
|
var related_select_element = $( '#related select', params.schema_browser_element )
|
|
var type = 'index';
|
|
|
|
var sammy_basepath = '#/' + $( 'p a', params.active_core ).html() + '/schema-browser';
|
|
|
|
if( !related_navigation_meta.hasClass( 'done' ) )
|
|
{
|
|
if( app.schema_browser_data.unique_key_field )
|
|
{
|
|
$( '.unique-key-field', related_navigation_meta )
|
|
.show()
|
|
.after
|
|
(
|
|
'<dd class="unique-key-field"><a href="' + sammy_basepath + '/field/' +
|
|
app.schema_browser_data.unique_key_field + '">' +
|
|
app.schema_browser_data.unique_key_field + '</a></dd>'
|
|
);
|
|
}
|
|
|
|
if( app.schema_browser_data.default_search_field )
|
|
{
|
|
$( '.default-search-field', related_navigation_meta )
|
|
.show()
|
|
.after
|
|
(
|
|
'<dd class="default-search-field"><a href="' + sammy_basepath + '/field/' +
|
|
app.schema_browser_data.default_search_field + '">' +
|
|
app.schema_browser_data.default_search_field + '</a></dd>'
|
|
);
|
|
}
|
|
|
|
related_navigation_meta
|
|
.addClass( 'done' );
|
|
}
|
|
|
|
if( params.route_params )
|
|
{
|
|
var type = params.route_params.splat[3];
|
|
var value = params.route_params.splat[4];
|
|
|
|
var navigation_data = {
|
|
'fields' : [],
|
|
'copyfield_source' : [],
|
|
'copyfield_dest' : [],
|
|
'dynamic_fields' : [],
|
|
'types' : []
|
|
}
|
|
|
|
$( 'option[value="' + params.route_params.splat[2] + '"]', related_select_element )
|
|
.attr( 'selected', 'selected' );
|
|
|
|
if( 'field' === type )
|
|
{
|
|
navigation_data.fields.push( value );
|
|
navigation_data.types.push( app.schema_browser_data.relations.f_t[value] );
|
|
|
|
if( app.schema_browser_data.relations.f_df[value] )
|
|
{
|
|
navigation_data.dynamic_fields.push( app.schema_browser_data.relations.f_df[value] );
|
|
}
|
|
|
|
if( 0 !== app.schema_browser_data.fields[value].copySources.length )
|
|
{
|
|
navigation_data.copyfield_source = app.schema_browser_data.fields[value].copySources;
|
|
}
|
|
|
|
if( 0 !== app.schema_browser_data.fields[value].copyDests.length )
|
|
{
|
|
navigation_data.copyfield_dest = app.schema_browser_data.fields[value].copyDests;
|
|
}
|
|
}
|
|
else if( 'dynamic-field' === type )
|
|
{
|
|
navigation_data.dynamic_fields.push( value );
|
|
navigation_data.types.push( app.schema_browser_data.relations.df_t[value] );
|
|
|
|
if( app.schema_browser_data.relations.df_f[value] )
|
|
{
|
|
navigation_data.fields = app.schema_browser_data.relations.df_f[value];
|
|
}
|
|
}
|
|
else if( 'type' === type )
|
|
{
|
|
navigation_data.types.push( value );
|
|
|
|
if( app.schema_browser_data.relations.t_f[value] )
|
|
{
|
|
navigation_data.fields = app.schema_browser_data.relations.t_f[value];
|
|
}
|
|
|
|
if( app.schema_browser_data.relations.t_df[value] )
|
|
{
|
|
navigation_data.dynamic_fields = app.schema_browser_data.relations.t_df[value];
|
|
}
|
|
}
|
|
|
|
var navigation_content = '';
|
|
|
|
if( 0 !== navigation_data.fields.length )
|
|
{
|
|
navigation_data.fields.sort();
|
|
navigation_content += '<dt class="field">Fields</dt>' + "\n";
|
|
for( var i in navigation_data.fields )
|
|
{
|
|
var href = sammy_basepath + '/field/' + navigation_data.fields[i];
|
|
navigation_content += '<dd class="field"><a href="' + href + '">' +
|
|
navigation_data.fields[i] + '</a></dd>' + "\n";
|
|
}
|
|
}
|
|
|
|
if( 0 !== navigation_data.copyfield_source.length )
|
|
{
|
|
navigation_data.copyfield_source.sort();
|
|
navigation_content += '<dt class="copyfield">Copied from</dt>' + "\n";
|
|
for( var i in navigation_data.copyfield_source )
|
|
{
|
|
var href = sammy_basepath + '/field/' + navigation_data.copyfield_source[i];
|
|
navigation_content += '<dd class="copyfield"><a href="' + href + '">' +
|
|
navigation_data.copyfield_source[i] + '</a></dd>' + "\n";
|
|
}
|
|
}
|
|
|
|
if( 0 !== navigation_data.copyfield_dest.length )
|
|
{
|
|
navigation_data.copyfield_dest.sort();
|
|
navigation_content += '<dt class="copyfield">Copied to</dt>' + "\n";
|
|
for( var i in navigation_data.copyfield_dest )
|
|
{
|
|
var href = sammy_basepath + '/field/' + navigation_data.copyfield_dest[i];
|
|
navigation_content += '<dd class="copyfield"><a href="' + href + '">' +
|
|
navigation_data.copyfield_dest[i] + '</a></dd>' + "\n";
|
|
}
|
|
}
|
|
|
|
if( 0 !== navigation_data.dynamic_fields.length )
|
|
{
|
|
navigation_data.dynamic_fields.sort();
|
|
navigation_content += '<dt class="dynamic-field">Dynamic Fields</dt>' + "\n";
|
|
for( var i in navigation_data.dynamic_fields )
|
|
{
|
|
var href = sammy_basepath + '/dynamic-field/' + navigation_data.dynamic_fields[i];
|
|
navigation_content += '<dd class="dynamic-field"><a href="' + href + '">' +
|
|
navigation_data.dynamic_fields[i] + '</a></dd>' + "\n";
|
|
}
|
|
}
|
|
|
|
if( 0 !== navigation_data.types.length )
|
|
{
|
|
navigation_data.types.sort();
|
|
navigation_content += '<dt class="type">Types</dt>' + "\n";
|
|
for( var i in navigation_data.types )
|
|
{
|
|
var href = sammy_basepath + '/type/' + navigation_data.types[i];
|
|
navigation_content += '<dd class="type"><a href="' + href + '">' +
|
|
navigation_data.types[i] + '</a></dd>' + "\n";
|
|
}
|
|
}
|
|
|
|
related_navigation_element
|
|
.show()
|
|
.attr( 'class', type )
|
|
.html( navigation_content );
|
|
}
|
|
else
|
|
{
|
|
related_navigation_element
|
|
.hide();
|
|
|
|
$( 'option:selected', related_select_element )
|
|
.removeAttr( 'selected' );
|
|
}
|
|
|
|
if( 'field' === type && value === app.schema_browser_data.unique_key_field )
|
|
{
|
|
$( '.unique-key-field', related_navigation_meta )
|
|
.addClass( 'active' );
|
|
}
|
|
else
|
|
{
|
|
$( '.unique-key-field', related_navigation_meta )
|
|
.removeClass( 'active' );
|
|
}
|
|
|
|
if( 'field' === type && value === app.schema_browser_data.default_search_field )
|
|
{
|
|
$( '.default-search-field', related_navigation_meta )
|
|
.addClass( 'active' );
|
|
}
|
|
else
|
|
{
|
|
$( '.default-search-field', related_navigation_meta )
|
|
.removeClass( 'active' );
|
|
}
|
|
|
|
if( params.callback )
|
|
{
|
|
params.callback( app.schema_browser_data, $( '#data', params.schema_browser_element ) );
|
|
}
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'schema_browser_load',
|
|
function( event, params )
|
|
{
|
|
var core_basepath = params.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
if( app.schema_browser_data )
|
|
{
|
|
params.schema_browser_element = $( '#schema-browser', content_element );
|
|
|
|
sammy.trigger
|
|
(
|
|
'schema_browser_navi',
|
|
params
|
|
);
|
|
}
|
|
else
|
|
{
|
|
content_element
|
|
.html( '<div id="schema-browser"><div class="loader">Loading ...</div></div>' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/luke?numTerms=50&wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
app.schema_browser_data = {
|
|
default_search_field : null,
|
|
unique_key_field : null,
|
|
key : {},
|
|
fields : {},
|
|
dynamic_fields : {},
|
|
types : {},
|
|
relations : {
|
|
f_df : {},
|
|
f_t : {},
|
|
df_f : {},
|
|
df_t : {},
|
|
t_f : {},
|
|
t_df : {}
|
|
}
|
|
};
|
|
|
|
app.schema_browser_data.fields = response.fields;
|
|
app.schema_browser_data.key = response.info.key;
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/luke?show=schema&wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
app.schema_browser_data.default_search_field = response.schema.defaultSearchField;
|
|
app.schema_browser_data.unique_key_field = response.schema.uniqueKeyField;
|
|
|
|
app.schema_browser_data.dynamic_fields = response.schema.dynamicFields;
|
|
app.schema_browser_data.types = response.schema.types;
|
|
|
|
var luke_array_to_struct = function( array )
|
|
{
|
|
var struct = {
|
|
keys : [],
|
|
values : []
|
|
};
|
|
for( var i = 0; i < array.length; i += 2 )
|
|
{
|
|
struct.keys.push( array[i] );
|
|
struct.values.push( array[i+1] );
|
|
}
|
|
return struct;
|
|
}
|
|
|
|
var luke_array_to_hash = function( array )
|
|
{
|
|
var hash = {};
|
|
for( var i = 0; i < array.length; i += 2 )
|
|
{
|
|
hash[ array[i] ] = array[i+1];
|
|
}
|
|
return hash;
|
|
}
|
|
|
|
for( var field in response.schema.fields )
|
|
{
|
|
app.schema_browser_data.fields[field] = $.extend
|
|
(
|
|
{},
|
|
app.schema_browser_data.fields[field],
|
|
response.schema.fields[field]
|
|
);
|
|
}
|
|
|
|
for( var field in app.schema_browser_data.fields )
|
|
{
|
|
app.schema_browser_data.fields[field].copySourcesRaw = null;
|
|
|
|
if( app.schema_browser_data.fields[field].copySources &&
|
|
0 !== app.schema_browser_data.fields[field].copySources.length )
|
|
{
|
|
app.schema_browser_data.fields[field].copySourcesRaw =
|
|
app.schema_browser_data.fields[field].copySources;
|
|
}
|
|
|
|
app.schema_browser_data.fields[field].copyDests = [];
|
|
app.schema_browser_data.fields[field].copySources = [];
|
|
}
|
|
|
|
for( var field in app.schema_browser_data.fields )
|
|
{
|
|
if( app.schema_browser_data.fields[field].histogram )
|
|
{
|
|
var histogram = app.schema_browser_data.fields[field].histogram;
|
|
|
|
app.schema_browser_data.fields[field].histogram =
|
|
luke_array_to_struct( histogram );
|
|
|
|
app.schema_browser_data.fields[field].histogram_hash =
|
|
luke_array_to_hash( histogram );
|
|
}
|
|
|
|
if( app.schema_browser_data.fields[field].topTerms )
|
|
{
|
|
var top_terms = app.schema_browser_data.fields[field].topTerms;
|
|
|
|
app.schema_browser_data.fields[field].topTerms =
|
|
luke_array_to_struct( top_terms );
|
|
|
|
app.schema_browser_data.fields[field].topTerms_hash =
|
|
luke_array_to_hash( top_terms );
|
|
}
|
|
|
|
if( app.schema_browser_data.fields[field].copySourcesRaw )
|
|
{
|
|
var copy_sources = app.schema_browser_data.fields[field].copySourcesRaw;
|
|
for( var i in copy_sources )
|
|
{
|
|
var target = copy_sources[i].replace( /^.+:(.+)\{.+$/, '$1' );
|
|
|
|
app.schema_browser_data.fields[field].copySources.push( target );
|
|
app.schema_browser_data.fields[target].copyDests.push( field );
|
|
}
|
|
}
|
|
|
|
app.schema_browser_data.relations.f_t[field] = app.schema_browser_data.fields[field].type;
|
|
|
|
if( !app.schema_browser_data.relations.t_f[app.schema_browser_data.fields[field].type] )
|
|
{
|
|
app.schema_browser_data.relations.t_f[app.schema_browser_data.fields[field].type] = [];
|
|
}
|
|
app.schema_browser_data.relations.t_f[app.schema_browser_data.fields[field].type].push( field );
|
|
|
|
if( app.schema_browser_data.fields[field].dynamicBase )
|
|
{
|
|
app.schema_browser_data.relations.f_df[field] = app.schema_browser_data.fields[field].dynamicBase;
|
|
|
|
if( !app.schema_browser_data.relations.df_f[app.schema_browser_data.fields[field].dynamicBase] )
|
|
{
|
|
app.schema_browser_data.relations.df_f[app.schema_browser_data.fields[field].dynamicBase] = [];
|
|
}
|
|
app.schema_browser_data.relations.df_f[app.schema_browser_data.fields[field].dynamicBase].push( field );
|
|
}
|
|
}
|
|
|
|
for( var dynamic_field in app.schema_browser_data.dynamic_fields )
|
|
{
|
|
app.schema_browser_data.relations.df_t[dynamic_field] = app.schema_browser_data.dynamic_fields[dynamic_field].type;
|
|
|
|
if( !app.schema_browser_data.relations.t_df[app.schema_browser_data.dynamic_fields[dynamic_field].type] )
|
|
{
|
|
app.schema_browser_data.relations.t_df[app.schema_browser_data.dynamic_fields[dynamic_field].type] = [];
|
|
}
|
|
app.schema_browser_data.relations.t_df[app.schema_browser_data.dynamic_fields[dynamic_field].type].push( dynamic_field );
|
|
}
|
|
|
|
$.get
|
|
(
|
|
'tpl/schema-browser.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var schema_browser_element = $( '#schema-browser', content_element );
|
|
var related_element = $( '#related', schema_browser_element );
|
|
var related_select_element = $( 'select', related_element );
|
|
var data_element = $( '#data', schema_browser_element );
|
|
|
|
var related_options = '';
|
|
|
|
var fields = [];
|
|
for( var field_name in app.schema_browser_data.fields )
|
|
{
|
|
fields.push
|
|
(
|
|
'<option value="/field/' + field_name + '">' + field_name + '</option>'
|
|
);
|
|
}
|
|
if( 0 !== fields.length )
|
|
{
|
|
fields.sort();
|
|
related_options += '<optgroup label="Fields">' + "\n";
|
|
related_options += fields.sort().join( "\n" ) + "\n";
|
|
related_options += '</optgroup>' + "\n";
|
|
}
|
|
|
|
var dynamic_fields = [];
|
|
for( var type_name in app.schema_browser_data.dynamic_fields )
|
|
{
|
|
dynamic_fields.push
|
|
(
|
|
'<option value="/dynamic-field/' + type_name + '">' + type_name + '</option>'
|
|
);
|
|
}
|
|
if( 0 !== dynamic_fields.length )
|
|
{
|
|
dynamic_fields.sort();
|
|
related_options += '<optgroup label="DynamicFields">' + "\n";
|
|
related_options += dynamic_fields.sort().join( "\n" ) + "\n";
|
|
related_options += '</optgroup>' + "\n";
|
|
}
|
|
|
|
var types = [];
|
|
for( var type_name in app.schema_browser_data.types )
|
|
{
|
|
types.push
|
|
(
|
|
'<option value="/type/' + type_name + '">' + type_name + '</option>'
|
|
);
|
|
}
|
|
if( 0 !== types.length )
|
|
{
|
|
types.sort();
|
|
related_options += '<optgroup label="Types">' + "\n";
|
|
related_options += types.sort().join( "\n" ) + "\n";
|
|
related_options += '</optgroup>' + "\n";
|
|
}
|
|
|
|
related_select_element
|
|
.attr( 'rel', '#/' + $( 'p a', params.active_core ).html() + '/schema-browser' )
|
|
.append( related_options );
|
|
|
|
related_select_element
|
|
.die( 'change' )
|
|
.live
|
|
(
|
|
'change',
|
|
function( event )
|
|
{
|
|
var select_element = $( this );
|
|
var option_element = $( 'option:selected', select_element );
|
|
|
|
location.href = select_element.attr( 'rel' ) + option_element.val();
|
|
return false;
|
|
}
|
|
);
|
|
|
|
params.schema_browser_element = schema_browser_element;
|
|
sammy.trigger
|
|
(
|
|
'schema_browser_navi',
|
|
params
|
|
);
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
}
|
|
);
|
|
|
|
// #/:core/schema-browser
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(schema-browser)$/,
|
|
function( context )
|
|
{
|
|
var callback = function( schema_browser_data, data_element )
|
|
{
|
|
data_element
|
|
.hide();
|
|
};
|
|
|
|
delete app.schema_browser_data;
|
|
|
|
sammy.trigger
|
|
(
|
|
'schema_browser_load',
|
|
{
|
|
callback : callback,
|
|
active_core : this.active_core
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/schema-browser/field|dynamic-field|type/$field
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(schema-browser)(\/(field|dynamic-field|type)\/(.+))$/,
|
|
function( context )
|
|
{
|
|
var callback = function( schema_browser_data, data_element )
|
|
{
|
|
var field = context.params.splat[4];
|
|
|
|
var type = context.params.splat[3];
|
|
var is_f = 'field' === type;
|
|
var is_df = 'dynamic-field' === type;
|
|
var is_t = 'type' === type;
|
|
|
|
var options_element = $( '.options', data_element );
|
|
var sammy_basepath = context.path.indexOf( '/', context.path.indexOf( '/', 2 ) + 1 );
|
|
|
|
data_element
|
|
.show();
|
|
|
|
var keystring_to_list = function( keystring, element_class )
|
|
{
|
|
var key_list = keystring.replace( /-/g, '' ).split( '' );
|
|
var list = [];
|
|
|
|
for( var i in key_list )
|
|
{
|
|
var option_key = schema_browser_data.key[key_list[i]];
|
|
|
|
if( !option_key )
|
|
{
|
|
option_key = schema_browser_data.key[key_list[i].toLowerCase()];
|
|
}
|
|
|
|
if( !option_key )
|
|
{
|
|
option_key = schema_browser_data.key[key_list[i].toUpperCase()];
|
|
}
|
|
|
|
if( option_key )
|
|
{
|
|
list.push
|
|
(
|
|
'<dd ' + ( element_class ? ' class="' + element_class + '"' : '' ) + '>' +
|
|
option_key +
|
|
',</dd>'
|
|
);
|
|
}
|
|
}
|
|
|
|
list[list.length-1] = list[key_list.length-1].replace( /,/, '' );
|
|
|
|
return list;
|
|
}
|
|
|
|
var flags = null;
|
|
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].flags )
|
|
{
|
|
flags = schema_browser_data.fields[field].flags;
|
|
}
|
|
else if( is_df && schema_browser_data.dynamic_fields[field] && schema_browser_data.dynamic_fields[field].flags )
|
|
{
|
|
flags = schema_browser_data.dynamic_fields[field].flags;
|
|
}
|
|
|
|
// -- properties
|
|
var properties_element = $( 'dt.properties', options_element );
|
|
if( flags )
|
|
{
|
|
var properties_keys = keystring_to_list( flags, 'properties' );
|
|
|
|
$( 'dd.properties', options_element )
|
|
.remove();
|
|
|
|
properties_element
|
|
.show()
|
|
.after( properties_keys.join( "\n" ) );
|
|
}
|
|
else
|
|
{
|
|
$( '.properties', options_element )
|
|
.hide();
|
|
}
|
|
|
|
// -- schema
|
|
var schema_element = $( 'dt.schema', options_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].schema )
|
|
{
|
|
var schema_keys = keystring_to_list( schema_browser_data.fields[field].schema, 'schema' );
|
|
|
|
$( 'dd.schema', options_element )
|
|
.remove();
|
|
|
|
schema_element
|
|
.show()
|
|
.after( schema_keys.join( "\n" ) );
|
|
}
|
|
else
|
|
{
|
|
$( '.schema', options_element )
|
|
.hide();
|
|
}
|
|
|
|
// -- index
|
|
var index_element = $( 'dt.index', options_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].index )
|
|
{
|
|
var index_keys = [];
|
|
|
|
if( 0 === schema_browser_data.fields[field].index.indexOf( '(' ) )
|
|
{
|
|
index_keys.push( '<dd class="index">' + schema_browser_data.fields[field].index + '</dd>' );
|
|
}
|
|
else
|
|
{
|
|
index_keys = keystring_to_list( schema_browser_data.fields[field].index, 'index' );
|
|
}
|
|
|
|
$( 'dd.index', options_element )
|
|
.remove();
|
|
|
|
index_element
|
|
.show()
|
|
.after( index_keys.join( "\n" ) );
|
|
}
|
|
else
|
|
{
|
|
$( '.index', options_element )
|
|
.hide();
|
|
}
|
|
|
|
// -- docs
|
|
var docs_element = $( 'dt.docs', options_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].docs )
|
|
{
|
|
$( 'dd.docs', options_element )
|
|
.remove();
|
|
|
|
docs_element
|
|
.show()
|
|
.after( '<dd class="docs">' + schema_browser_data.fields[field].docs + '</dd>' );
|
|
}
|
|
else
|
|
{
|
|
$( '.docs', options_element )
|
|
.hide();
|
|
}
|
|
|
|
// -- distinct
|
|
var distinct_element = $( 'dt.distinct', options_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].distinct )
|
|
{
|
|
$( 'dd.distinct', options_element )
|
|
.remove();
|
|
|
|
distinct_element
|
|
.show()
|
|
.after( '<dd class="distinct">' + schema_browser_data.fields[field].distinct + '</dd>' );
|
|
}
|
|
else
|
|
{
|
|
$( '.distinct', options_element )
|
|
.hide();
|
|
}
|
|
|
|
// -- position-increment-gap
|
|
var pig_element = $( 'dt.position-increment-gap', options_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].positionIncrementGap )
|
|
{
|
|
$( 'dt.position-increment-gap', options_element )
|
|
.remove();
|
|
|
|
pig_element
|
|
.show()
|
|
.after( '<dd class="position-increment-gap">' + schema_browser_data.fields[field].positionIncrementGap + '</dd>' );
|
|
}
|
|
else
|
|
{
|
|
$( '.position-increment-gap', options_element )
|
|
.hide();
|
|
}
|
|
|
|
var analyzer_element = $( '.analyzer', data_element );
|
|
var analyzer_data = null;
|
|
|
|
if( is_f )
|
|
{
|
|
analyzer_data = schema_browser_data.types[schema_browser_data.relations.f_t[field]];
|
|
}
|
|
else if( is_df )
|
|
{
|
|
analyzer_data = schema_browser_data.types[schema_browser_data.relations.df_t[field]];
|
|
}
|
|
else if( is_t )
|
|
{
|
|
analyzer_data = schema_browser_data.types[field];
|
|
}
|
|
|
|
if( analyzer_data )
|
|
{
|
|
var transform_analyzer_data_into_list = function( analyzer_data )
|
|
{
|
|
var args = [];
|
|
for( var key in analyzer_data.args )
|
|
{
|
|
var arg_class = '';
|
|
var arg_content = '';
|
|
|
|
if( 'true' === analyzer_data.args[key] || '1' === analyzer_data.args[key] )
|
|
{
|
|
arg_class = 'ico-1';
|
|
arg_content = key;
|
|
}
|
|
else if( 'false' === analyzer_data.args[key] || '0' === analyzer_data.args[key] )
|
|
{
|
|
arg_class = 'ico-0';
|
|
arg_content = key;
|
|
}
|
|
else
|
|
{
|
|
arg_content = key + ': ';
|
|
|
|
if( 'synonyms' === key || 'words' === key )
|
|
{
|
|
// @TODO: set link target for file
|
|
arg_content += '<a>' + analyzer_data.args[key] + '</a>';
|
|
}
|
|
else
|
|
{
|
|
arg_content += analyzer_data.args[key];
|
|
}
|
|
}
|
|
|
|
args.push( '<dd class="' + arg_class + '">' + arg_content + '</dd>' );
|
|
}
|
|
|
|
var list_content = '<dt>' + analyzer_data.className + '</dt>';
|
|
if( 0 !== args.length )
|
|
{
|
|
args.sort();
|
|
list_content += args.join( "\n" );
|
|
}
|
|
|
|
return list_content;
|
|
}
|
|
|
|
// -- field-type
|
|
var field_type_element = $( 'dt.field-type', options_element );
|
|
|
|
$( 'dd.field-type', options_element )
|
|
.remove();
|
|
|
|
field_type_element
|
|
.show()
|
|
.after( '<dd class="field-type">' + analyzer_data.className + '</dd>' );
|
|
|
|
|
|
for( var key in analyzer_data )
|
|
{
|
|
var key_match = key.match( /^(.+)Analyzer$/ );
|
|
if( !key_match )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var analyzer_key_element = $( '.' + key_match[1], analyzer_element );
|
|
var analyzer_key_data = analyzer_data[key];
|
|
|
|
analyzer_element.show();
|
|
analyzer_key_element.show();
|
|
|
|
if( analyzer_key_data.className )
|
|
{
|
|
$( 'dl:first dt', analyzer_key_element )
|
|
.html( analyzer_key_data.className );
|
|
}
|
|
|
|
$( 'ul li', analyzer_key_element )
|
|
.hide();
|
|
|
|
for( var type in analyzer_key_data )
|
|
{
|
|
if( 'object' !== typeof analyzer_key_data[type] )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var type_element = $( '.' + type, analyzer_key_element );
|
|
var type_content = [];
|
|
|
|
type_element.show();
|
|
|
|
if( analyzer_key_data[type].className )
|
|
{
|
|
type_content.push( transform_analyzer_data_into_list( analyzer_key_data[type] ) );
|
|
}
|
|
else
|
|
{
|
|
for( var entry in analyzer_key_data[type] )
|
|
{
|
|
type_content.push( transform_analyzer_data_into_list( analyzer_key_data[type][entry] ) );
|
|
}
|
|
}
|
|
|
|
$( 'dl', type_element )
|
|
.empty()
|
|
.append( type_content.join( "\n" ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
var topterms_holder_element = $( '.topterms-holder', data_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].topTerms_hash )
|
|
{
|
|
topterms_holder_element
|
|
.show();
|
|
|
|
var topterms_table_element = $( 'table', topterms_holder_element );
|
|
|
|
var topterms_navi_less = $( 'p.navi .less', topterms_holder_element );
|
|
var topterms_navi_more = $( 'p.navi .more', topterms_holder_element );
|
|
|
|
var topterms_count = schema_browser_data.fields[field].topTerms.keys.length;
|
|
var topterms_hash = schema_browser_data.fields[field].topTerms_hash;
|
|
var topterms_content = '<tbody>';
|
|
|
|
var i = 1;
|
|
for( var term in topterms_hash )
|
|
{
|
|
topterms_content += '<tr>' + "\n" +
|
|
'<td class="position">' + i + '</td>' + "\n" +
|
|
'<td class="term">' + term + '</td>' + "\n" +
|
|
'<td class="frequency">' + topterms_hash[term] + '</td>' + "\n" +
|
|
'</tr>' + "\n";
|
|
|
|
if( i !== topterms_count && 0 === i % 10 )
|
|
{
|
|
topterms_content += '</tbody><tbody>';
|
|
}
|
|
|
|
i++;
|
|
}
|
|
|
|
topterms_content += '</tbody>';
|
|
|
|
topterms_table_element
|
|
.empty()
|
|
.append( topterms_content );
|
|
|
|
$( 'tbody', topterms_table_element )
|
|
.die( 'change' )
|
|
.live
|
|
(
|
|
'change',
|
|
function()
|
|
{
|
|
var blocks = $( 'tbody', topterms_table_element );
|
|
var visible_blocks = blocks.filter( ':visible' );
|
|
var hidden_blocks = blocks.filter( ':hidden' );
|
|
|
|
$( 'p.head .shown', topterms_holder_element )
|
|
.html( $( 'tr', visible_blocks ).size() );
|
|
|
|
0 < hidden_blocks.size()
|
|
? topterms_navi_more.show()
|
|
: topterms_navi_more.hide();
|
|
|
|
1 < visible_blocks.size()
|
|
? topterms_navi_less.show()
|
|
: topterms_navi_less.hide();
|
|
}
|
|
);
|
|
|
|
$( 'tbody tr:odd', topterms_table_element )
|
|
.addClass( 'odd' );
|
|
|
|
$( 'tbody:first', topterms_table_element )
|
|
.show()
|
|
.trigger( 'change' );
|
|
|
|
$( 'p.head .max', topterms_holder_element )
|
|
.html( schema_browser_data.fields[field].distinct );
|
|
|
|
topterms_navi_less
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( 'tbody:visible', topterms_table_element ).last()
|
|
.hide()
|
|
.trigger( 'change' );
|
|
}
|
|
);
|
|
|
|
topterms_navi_more
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( 'tbody:hidden', topterms_table_element ).first()
|
|
.show()
|
|
.trigger( 'change' );
|
|
}
|
|
);
|
|
}
|
|
else
|
|
{
|
|
topterms_holder_element
|
|
.hide();
|
|
}
|
|
|
|
var histogram_holder_element = $( '.histogram-holder', data_element );
|
|
if( is_f && schema_browser_data.fields[field] && schema_browser_data.fields[field].histogram_hash )
|
|
{
|
|
histogram_holder_element
|
|
.show();
|
|
|
|
var histogram_element = $( '.histogram', histogram_holder_element );
|
|
|
|
var histogram_values = schema_browser_data.fields[field].histogram_hash;
|
|
var histogram_legend = '';
|
|
|
|
histogram_holder_element
|
|
.show();
|
|
|
|
for( var key in histogram_values )
|
|
{
|
|
histogram_legend += '<dt><span>' + key + '</span></dt>' + "\n" +
|
|
'<dd title="' + key + '">' +
|
|
'<span>' + histogram_values[key] + '</span>' +
|
|
'</dd>' + "\n";
|
|
}
|
|
|
|
$( 'dl', histogram_holder_element )
|
|
.html( histogram_legend );
|
|
|
|
histogram_element
|
|
.sparkline
|
|
(
|
|
schema_browser_data.fields[field].histogram.values,
|
|
{
|
|
type : 'bar',
|
|
barColor : '#c0c0c0',
|
|
zeroColor : '#ffffff',
|
|
height : histogram_element.height(),
|
|
barWidth : 46,
|
|
barSpacing : 3
|
|
}
|
|
);
|
|
}
|
|
else
|
|
{
|
|
histogram_holder_element
|
|
.hide();
|
|
}
|
|
}
|
|
|
|
sammy.trigger
|
|
(
|
|
'schema_browser_load',
|
|
{
|
|
callback : callback,
|
|
active_core : this.active_core,
|
|
route_params : this.params
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
this.bind
|
|
(
|
|
'dataimport_queryhandler_load',
|
|
function( event, params )
|
|
{
|
|
var core_basepath = params.active_core.attr( 'data-basepath' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/mbeans?cat=QUERYHANDLER&wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var handlers = response['solr-mbeans'][1];
|
|
var dataimport_handlers = [];
|
|
for( var key in handlers )
|
|
{
|
|
if( handlers[key]['class'] !== key &&
|
|
handlers[key]['class'] === 'org.apache.solr.handler.dataimport.DataImportHandler' )
|
|
{
|
|
dataimport_handlers.push( key );
|
|
}
|
|
}
|
|
params.callback( dataimport_handlers );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/dataimport
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(dataimport)$/,
|
|
function( context )
|
|
{
|
|
sammy.trigger
|
|
(
|
|
'dataimport_queryhandler_load',
|
|
{
|
|
active_core : this.active_core,
|
|
callback : function( dataimport_handlers )
|
|
{
|
|
if( 0 === dataimport_handlers.length )
|
|
{
|
|
$( '#content' )
|
|
.html( 'sorry, no dataimport-handler defined!' );
|
|
|
|
return false;
|
|
}
|
|
|
|
context.redirect( context.path + '/' + dataimport_handlers[0] );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/dataimport
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(dataimport)\//,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
var path_parts = this.path.match( /^(.+\/dataimport\/)(.*)$/ );
|
|
var current_handler = path_parts[2];
|
|
|
|
$( 'li.dataimport', this.active_core )
|
|
.addClass( 'active' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/dataimport.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var dataimport_element = $( '#dataimport', content_element );
|
|
var form_element = $( '#form', dataimport_element );
|
|
var config_element = $( '#config', dataimport_element );
|
|
var config_error_element = $( '#config-error', dataimport_element );
|
|
|
|
// handler
|
|
|
|
sammy.trigger
|
|
(
|
|
'dataimport_queryhandler_load',
|
|
{
|
|
active_core : context.active_core,
|
|
callback : function( dataimport_handlers )
|
|
{
|
|
|
|
var handlers_element = $( '.handler', form_element );
|
|
var handlers = [];
|
|
|
|
for( var i = 0; i < dataimport_handlers.length; i++ )
|
|
{
|
|
handlers.push
|
|
(
|
|
'<li><a href="' + path_parts[1] + dataimport_handlers[i] + '">' +
|
|
dataimport_handlers[i] +
|
|
'</a></li>'
|
|
);
|
|
}
|
|
|
|
$( 'ul', handlers_element )
|
|
.html( handlers.join( "\n") ) ;
|
|
|
|
$( 'a[href="' + context.path + '"]', handlers_element ).parent()
|
|
.addClass( 'active' );
|
|
|
|
handlers_element
|
|
.show();
|
|
}
|
|
}
|
|
);
|
|
|
|
// config
|
|
|
|
function dataimport_fetch_config()
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/select?qt=' + current_handler + '&command=show-config',
|
|
dataType : 'xml',
|
|
context : $( '#dataimport_config', config_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( config, text_status, xhr )
|
|
{
|
|
dataimport_element
|
|
.removeClass( 'error' );
|
|
|
|
config_error_element
|
|
.hide();
|
|
|
|
config_element
|
|
.addClass( 'hidden' );
|
|
|
|
|
|
var entities = [];
|
|
|
|
$( 'document > entity', config )
|
|
.each
|
|
(
|
|
function( i, element )
|
|
{
|
|
entities.push( '<option>' + $( element ).attr( 'name' ) + '</option>' );
|
|
}
|
|
);
|
|
|
|
$( '#entity', form_element )
|
|
.append( entities.join( "\n" ) );
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
if( 'parsererror' === error_thrown )
|
|
{
|
|
dataimport_element
|
|
.addClass( 'error' );
|
|
|
|
config_error_element
|
|
.show();
|
|
|
|
config_element
|
|
.removeClass( 'hidden' );
|
|
}
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
var code = $(
|
|
'<pre class="syntax language-xml"><code>' +
|
|
xhr.responseText.replace( /\</g, '<' ).replace( /\>/g, '>' ) +
|
|
'</code></pre>'
|
|
);
|
|
this.html( code );
|
|
|
|
if( 'success' === text_status )
|
|
{
|
|
hljs.highlightBlock( code.get(0) );
|
|
}
|
|
}
|
|
}
|
|
);
|
|
}
|
|
dataimport_fetch_config();
|
|
|
|
$( '.toggle', config_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).parents( '.block' )
|
|
.toggleClass( 'hidden' );
|
|
|
|
return false;
|
|
}
|
|
)
|
|
|
|
var reload_config_element = $( '.reload_config', config_element );
|
|
reload_config_element
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/select?qt=' + current_handler + '&command=reload-config',
|
|
dataType : 'xml',
|
|
context: $( this ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
this
|
|
.addClass( 'success' );
|
|
|
|
window.setTimeout
|
|
(
|
|
function()
|
|
{
|
|
reload_config_element
|
|
.removeClass( 'success' );
|
|
},
|
|
5000
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
this
|
|
.addClass( 'error' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
|
|
dataimport_fetch_config();
|
|
}
|
|
}
|
|
);
|
|
return false;
|
|
}
|
|
)
|
|
|
|
// state
|
|
|
|
function dataimport_fetch_status()
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/select?qt=' + current_handler + '&command=status',
|
|
dataType : 'xml',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var state_element = $( '#current_state', content_element );
|
|
|
|
var status = $( 'str[name="status"]', response ).text();
|
|
var rollback_element = $( 'str[name="Rolledback"]', response );
|
|
var messages_count = $( 'lst[name="statusMessages"] str', response ).size();
|
|
|
|
var started_at = $( 'str[name="Full Dump Started"]', response ).text();
|
|
if( !started_at )
|
|
{
|
|
started_at = (new Date()).toGMTString();
|
|
}
|
|
|
|
function dataimport_compute_details( response, details_element )
|
|
{
|
|
var details = [];
|
|
|
|
var requests = parseInt( $( 'str[name="Total Requests made to DataSource"]', response ).text() );
|
|
if( NaN !== requests )
|
|
{
|
|
details.push
|
|
(
|
|
'<abbr title="Total Requests made to DataSource">Requests</abbr>: ' +
|
|
requests
|
|
);
|
|
}
|
|
|
|
var fetched = parseInt( $( 'str[name="Total Rows Fetched"]', response ).text() );
|
|
if( NaN !== fetched )
|
|
{
|
|
details.push
|
|
(
|
|
'<abbr title="Total Rows Fetched">Fetched</abbr>: ' +
|
|
fetched
|
|
);
|
|
}
|
|
|
|
var skipped = parseInt( $( 'str[name="Total Documents Skipped"]', response ).text() );
|
|
if( NaN !== requests )
|
|
{
|
|
details.push
|
|
(
|
|
'<abbr title="Total Documents Skipped">Skipped</abbr>: ' +
|
|
skipped
|
|
);
|
|
}
|
|
|
|
var processed = parseInt( $( 'str[name="Total Documents Processed"]', response ).text() );
|
|
if( NaN !== processed )
|
|
{
|
|
details.push
|
|
(
|
|
'<abbr title="Total Documents Processed">Processed</abbr>: ' +
|
|
processed
|
|
);
|
|
}
|
|
|
|
details_element
|
|
.html( details.join( ', ' ) );
|
|
}
|
|
|
|
state_element
|
|
.removeClass( 'indexing' )
|
|
.removeClass( 'success' )
|
|
.removeClass( 'failure' );
|
|
|
|
$( '.info', state_element )
|
|
.removeClass( 'loader' );
|
|
|
|
if( 0 !== rollback_element.size() )
|
|
{
|
|
state_element
|
|
.addClass( 'failure' )
|
|
.show();
|
|
|
|
$( '.info strong', state_element )
|
|
.text( $( 'str[name=""]', response ).text() );
|
|
|
|
console.debug( 'rollback @ ', rollback_element.text() );
|
|
}
|
|
else if( 'idle' === status && 0 !== messages_count )
|
|
{
|
|
state_element
|
|
.addClass( 'success' )
|
|
.show();
|
|
|
|
$( '.time', state_element )
|
|
.text( started_at )
|
|
.timeago();
|
|
|
|
$( '.info strong', state_element )
|
|
.text( $( 'str[name=""]', response ).text() );
|
|
|
|
dataimport_compute_details( response, $( '.info .details', state_element ) );
|
|
}
|
|
else if( 'busy' === status )
|
|
{
|
|
state_element
|
|
.addClass( 'indexing' )
|
|
.show();
|
|
|
|
$( '.time', state_element )
|
|
.text( started_at )
|
|
.timeago();
|
|
|
|
$( '.info', state_element )
|
|
.addClass( 'loader' );
|
|
|
|
$( '.info strong', state_element )
|
|
.text( 'Indexing ...' );
|
|
|
|
dataimport_compute_details( response, $( '.info .details', state_element ) );
|
|
|
|
window.setTimeout( dataimport_fetch_status, 2000 );
|
|
}
|
|
else
|
|
{
|
|
state_element.hide();
|
|
}
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
console.debug( arguments );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
dataimport_fetch_status();
|
|
|
|
// form
|
|
|
|
$( 'form', form_element )
|
|
.die( 'submit' )
|
|
.live
|
|
(
|
|
'submit',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/select?qt=' + current_handler + '&command=full-import',
|
|
dataType : 'xml',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
console.debug( response );
|
|
dataimport_fetch_status();
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
console.debug( arguments );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
return false;
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
|
|
|
|
this.bind
|
|
(
|
|
'plugins_load',
|
|
function( event, params )
|
|
{
|
|
var callback = function()
|
|
{
|
|
params.callback( app.plugin_data.plugin_data, app.plugin_data.sort_table, app.plugin_data.types );
|
|
}
|
|
|
|
if( app.plugin_data )
|
|
{
|
|
callback( app.plugin_data );
|
|
return true;
|
|
}
|
|
|
|
var core_basepath = params.active_core.attr( 'data-basepath' );
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/mbeans?stats=true&wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var types = [];
|
|
var sort_table = {};
|
|
var plugin_data = {};
|
|
|
|
var types_obj = {};
|
|
var plugin_key = null;
|
|
|
|
for( var i = 0; i < response['solr-mbeans'].length; i++ )
|
|
{
|
|
if( !( i % 2 ) )
|
|
{
|
|
plugin_key = response['solr-mbeans'][i];
|
|
}
|
|
else
|
|
{
|
|
plugin_data[plugin_key] = response['solr-mbeans'][i];
|
|
}
|
|
}
|
|
|
|
for( var key in plugin_data )
|
|
{
|
|
sort_table[key] = {
|
|
url : [],
|
|
component : [],
|
|
handler : []
|
|
};
|
|
for( var part_key in plugin_data[key] )
|
|
{
|
|
if( 0 < part_key.indexOf( '.' ) )
|
|
{
|
|
types_obj[key] = true;
|
|
sort_table[key]['handler'].push( part_key );
|
|
}
|
|
else if( 0 === part_key.indexOf( '/' ) )
|
|
{
|
|
types_obj[key] = true;
|
|
sort_table[key]['url'].push( part_key );
|
|
}
|
|
else
|
|
{
|
|
types_obj[key] = true;
|
|
sort_table[key]['component'].push( part_key );
|
|
}
|
|
}
|
|
}
|
|
|
|
for( var type in types_obj )
|
|
{
|
|
types.push( type );
|
|
}
|
|
types.sort();
|
|
|
|
app.plugin_data = {
|
|
'plugin_data' : plugin_data,
|
|
'sort_table' : sort_table,
|
|
'types' : types
|
|
}
|
|
|
|
$.get
|
|
(
|
|
'tpl/plugins.html',
|
|
function( template )
|
|
{
|
|
$( '#content' )
|
|
.html( template );
|
|
|
|
callback( app.plugin_data );
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/plugins/$type
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(plugins)\/(\w+)$/,
|
|
function( context )
|
|
{
|
|
var content_element = $( '#content' );
|
|
var type = context.params.splat[2].toUpperCase();
|
|
var context_path = context.path.split( '?' ).shift();
|
|
|
|
sammy.trigger
|
|
(
|
|
'plugins_load',
|
|
{
|
|
active_core : this.active_core,
|
|
callback : function( plugin_data, plugin_sort, types )
|
|
{
|
|
var frame_element = $( '#frame', content_element );
|
|
var navigation_element = $( '#navigation ul', content_element );
|
|
|
|
var navigation_content = [];
|
|
for( var i = 0; i < types.length; i++ )
|
|
{
|
|
var type_url = context.params.splat[0] + '/' +
|
|
context.params.splat[1] + '/' +
|
|
types[i].toLowerCase();
|
|
|
|
navigation_content.push
|
|
(
|
|
'<li class="' + types[i].toLowerCase() + '">' +
|
|
'<a href="#/' + type_url + '">' + types[i] + '</a>' +
|
|
'</li>'
|
|
);
|
|
}
|
|
|
|
navigation_element
|
|
.html( navigation_content.join( "\n" ) );
|
|
|
|
$( 'a[href="' + context_path + '"]', navigation_element )
|
|
.parent().addClass( 'current' );
|
|
|
|
var content = '<ul>';
|
|
for( var sort_key in plugin_sort[type] )
|
|
{
|
|
plugin_sort[type][sort_key].sort();
|
|
var plugin_type_length = plugin_sort[type][sort_key].length;
|
|
|
|
for( var i = 0; i < plugin_type_length; i++ )
|
|
{
|
|
content += '<li class="entry">' + "\n";
|
|
content += '<a href="' + context_path + '?entry=' + plugin_sort[type][sort_key][i] + '">';
|
|
content += plugin_sort[type][sort_key][i]
|
|
content += '</a>' + "\n";
|
|
content += '<ul class="detail">' + "\n";
|
|
|
|
var details = plugin_data[type][ plugin_sort[type][sort_key][i] ];
|
|
for( var detail_key in details )
|
|
{
|
|
if( 'stats' !== detail_key )
|
|
{
|
|
var detail_value = details[detail_key];
|
|
|
|
if( 'description' === detail_key )
|
|
{
|
|
detail_value = detail_value.replace( /,/g, ',​' );
|
|
}
|
|
else if( 'src' === detail_key )
|
|
{
|
|
detail_value = detail_value.replace( /\//g, '/​' );
|
|
}
|
|
|
|
content += '<li><dl class="clearfix">' + "\n";
|
|
content += '<dt>' + detail_key + ':</dt>' + "\n";
|
|
content += '<dd>' + detail_value + '</dd>' + "\n";
|
|
content += '</dl></li>' + "\n";
|
|
}
|
|
else if( 'stats' === detail_key && details[detail_key] )
|
|
{
|
|
content += '<li class="stats clearfix">' + "\n";
|
|
content += '<span>' + detail_key + ':</span>' + "\n";
|
|
content += '<ul>' + "\n";
|
|
|
|
for( var stats_key in details[detail_key] )
|
|
{
|
|
var stats_value = details[detail_key][stats_key];
|
|
|
|
if( 'readerDir' === stats_key )
|
|
{
|
|
stats_value = stats_value.replace( /@/g, '@​' );
|
|
}
|
|
|
|
content += '<li><dl class="clearfix">' + "\n";
|
|
content += '<dt>' + stats_key + ':</dt>' + "\n";
|
|
content += '<dd>' + stats_value + '</dd>' + "\n";
|
|
content += '</dl></li>' + "\n";
|
|
}
|
|
|
|
content += '</ul></li>' + "\n";
|
|
}
|
|
}
|
|
|
|
content += '</ul>' + "\n";
|
|
}
|
|
}
|
|
content += '</ul>' + "\n";
|
|
|
|
frame_element
|
|
.html( content );
|
|
|
|
$( 'a[href="' + decodeURIComponent( context.path ) + '"]', frame_element )
|
|
.parent().addClass( 'expanded' );
|
|
|
|
$( '.entry', frame_element )
|
|
.each
|
|
(
|
|
function( i, entry )
|
|
{
|
|
$( '.detail > li', entry ).not( '.stats' ).filter( ':even' )
|
|
.addClass( 'odd' );
|
|
|
|
$( '.stats li:odd', entry )
|
|
.addClass( 'odd' );
|
|
}
|
|
);
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/plugins
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(plugins)$/,
|
|
function( context )
|
|
{
|
|
delete app.plugin_data;
|
|
|
|
sammy.trigger
|
|
(
|
|
'plugins_load',
|
|
{
|
|
active_core : this.active_core,
|
|
callback : function( plugin_data, plugin_sort, types )
|
|
{
|
|
context.redirect( context.path + '/' + types[0].toLowerCase() );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/query
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(query)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/query.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var query_element = $( '#query', content_element );
|
|
var query_form = $( '#form form', query_element );
|
|
var url_element = $( '#url input', query_element );
|
|
var result_element = $( '#result', query_element );
|
|
var response_element = $( '#response iframe', result_element );
|
|
|
|
url_element
|
|
.die( 'change' )
|
|
.live
|
|
(
|
|
'change',
|
|
function( event )
|
|
{
|
|
var check_iframe_ready_state = function()
|
|
{
|
|
var iframe_element = response_element.get(0).contentWindow.document ||
|
|
response_element.get(0).document;
|
|
|
|
if( !iframe_element )
|
|
{
|
|
console.debug( 'no iframe_element found', response_element );
|
|
return false;
|
|
}
|
|
|
|
url_element
|
|
.addClass( 'loader' );
|
|
|
|
if( 'complete' === iframe_element.readyState )
|
|
{
|
|
url_element
|
|
.removeClass( 'loader' );
|
|
}
|
|
else
|
|
{
|
|
window.setTimeout( check_iframe_ready_state, 100 );
|
|
}
|
|
}
|
|
check_iframe_ready_state();
|
|
|
|
response_element
|
|
.attr( 'src', this.value )
|
|
|
|
if( !response_element.hasClass( 'resized' ) )
|
|
{
|
|
response_element
|
|
.addClass( 'resized' )
|
|
.css( 'height', $( '#main' ).height() - 60 );
|
|
}
|
|
}
|
|
)
|
|
|
|
$( '.optional legend input[type=checkbox]', query_form )
|
|
.die( 'change' )
|
|
.live
|
|
(
|
|
'change',
|
|
function( event )
|
|
{
|
|
var fieldset = $( this ).parents( 'fieldset' );
|
|
|
|
this.checked
|
|
? fieldset.addClass( 'expanded' )
|
|
: fieldset.removeClass( 'expanded' );
|
|
}
|
|
)
|
|
|
|
for( var key in context.params )
|
|
{
|
|
if( 'string' === typeof context.params[key] )
|
|
{
|
|
$( '[name="' + key + '"]', query_form )
|
|
.val( context.params[key] );
|
|
}
|
|
}
|
|
|
|
query_form
|
|
.die( 'submit' )
|
|
.live
|
|
(
|
|
'submit',
|
|
function( event )
|
|
{
|
|
var form_map = {};
|
|
var form_values = [];
|
|
var all_form_values = query_form.formToArray();
|
|
|
|
for( var i = 0; i < all_form_values.length; i++ )
|
|
{
|
|
if( !all_form_values[i].value || 0 === all_form_values[i].value.length )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var name_parts = all_form_values[i].name.split( '.' );
|
|
if( 1 < name_parts.length && !form_map[name_parts[0]] )
|
|
{
|
|
console.debug( 'skip "' + all_form_values[i].name + '", parent missing' );
|
|
continue;
|
|
}
|
|
|
|
form_map[all_form_values[i].name] = all_form_values[i].value;
|
|
form_values.push( all_form_values[i] );
|
|
}
|
|
|
|
var query_url = window.location.protocol + '//' +
|
|
window.location.host +
|
|
core_basepath +
|
|
'/select?' +
|
|
$.param( form_values );
|
|
|
|
url_element
|
|
.val( query_url )
|
|
.trigger( 'change' );
|
|
|
|
result_element
|
|
.show();
|
|
|
|
return false;
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/analysis
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(analysis)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
$.get
|
|
(
|
|
'tpl/analysis.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var analysis_element = $( '#analysis', content_element );
|
|
var analysis_form = $( 'form', analysis_element );
|
|
var analysis_result = $( '#analysis-result', analysis_element );
|
|
analysis_result.hide();
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/luke?wt=json&show=schema',
|
|
dataType : 'json',
|
|
context : $( '#type_or_name', analysis_form ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.html( '<option value="">Loading ... </option>' )
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
var content = '';
|
|
|
|
var fields = [];
|
|
for( var field_name in response.schema.fields )
|
|
{
|
|
fields.push
|
|
(
|
|
'<option value="fieldname=' + field_name + '">' + field_name + '</option>'
|
|
);
|
|
}
|
|
if( 0 !== fields.length )
|
|
{
|
|
content += '<optgroup label="Fields">' + "\n";
|
|
content += fields.sort().join( "\n" ) + "\n";
|
|
content += '</optgroup>' + "\n";
|
|
}
|
|
|
|
var types = [];
|
|
for( var type_name in response.schema.types )
|
|
{
|
|
types.push
|
|
(
|
|
'<option value="fieldtype=' + type_name + '">' + type_name + '</option>'
|
|
);
|
|
}
|
|
if( 0 !== types.length )
|
|
{
|
|
content += '<optgroup label="Types">' + "\n";
|
|
content += types.sort().join( "\n" ) + "\n";
|
|
content += '</optgroup>' + "\n";
|
|
}
|
|
|
|
this
|
|
.html( content );
|
|
|
|
$( 'option[value="fieldname\=' + response.schema.defaultSearchField + '"]', this )
|
|
.attr( 'selected', 'selected' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
|
|
$( '.verbose_output a', analysis_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$( this ).parent()
|
|
.toggleClass( 'active' );
|
|
|
|
analysis_result
|
|
.toggleClass( 'verbose_output' );
|
|
|
|
check_empty_spacer();
|
|
}
|
|
);
|
|
|
|
var check_empty_spacer = function()
|
|
{
|
|
var spacer_holder = $( 'td.part.data.spacer .holder', analysis_result );
|
|
|
|
if( 0 === spacer_holder.size() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var verbose_output = analysis_result.hasClass( 'verbose_output' );
|
|
|
|
spacer_holder
|
|
.each
|
|
(
|
|
function( index, element )
|
|
{
|
|
element = $( element );
|
|
|
|
if( verbose_output )
|
|
{
|
|
var cell = element.parent();
|
|
element.height( cell.height() );
|
|
}
|
|
else
|
|
{
|
|
element.removeAttr( 'style' );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
var button = $( 'button', analysis_form )
|
|
|
|
analysis_form
|
|
.ajaxForm
|
|
(
|
|
{
|
|
url : core_basepath + '/analysis/field?wt=json',
|
|
dataType : 'json',
|
|
beforeSubmit : function( array, form, options )
|
|
{
|
|
loader.show( button );
|
|
button.attr( 'disabled', true );
|
|
|
|
array.push( { name: 'analysis.showmatch', value: 'true' } );
|
|
|
|
var type_or_name = $( '#type_or_name', form ).val().split( '=' );
|
|
|
|
array.push( { name: 'analysis.' + type_or_name[0], value: type_or_name[1] } );
|
|
},
|
|
success : function( response, status_text, xhr, form )
|
|
{
|
|
analysis_result
|
|
.empty()
|
|
.show();
|
|
|
|
for( var name in response.analysis.field_names )
|
|
{
|
|
build_analysis_table( 'name', name, response.analysis.field_names[name] );
|
|
}
|
|
|
|
for( var name in response.analysis.field_types )
|
|
{
|
|
build_analysis_table( 'type', name, response.analysis.field_types[name] );
|
|
}
|
|
|
|
check_empty_spacer();
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
$( '#analysis-error', analysis_element )
|
|
.show();
|
|
},
|
|
complete : function()
|
|
{
|
|
loader.hide( $( 'button', analysis_form ) );
|
|
button.removeAttr( 'disabled' );
|
|
}
|
|
}
|
|
);
|
|
|
|
var generate_class_name = function( type )
|
|
{
|
|
var classes = [type];
|
|
if( 'text' !== type )
|
|
{
|
|
classes.push( 'verbose_output' );
|
|
}
|
|
return classes.join( ' ' );
|
|
}
|
|
|
|
var build_analysis_table = function( field_or_name, name, analysis_data )
|
|
{
|
|
for( var type in analysis_data )
|
|
{
|
|
var type_length = analysis_data[type].length;
|
|
if( 0 !== type_length )
|
|
{
|
|
var global_elements_count = 0;
|
|
for( var i = 0; i < analysis_data[type].length; i += 2 )
|
|
{
|
|
if( 'string' === typeof analysis_data[type][i+1] )
|
|
{
|
|
analysis_data[type][i+1] = [{ 'text': analysis_data[type][i+1] }]
|
|
}
|
|
global_elements_count = Math.max( global_elements_count,
|
|
analysis_data[type][i+1].length );
|
|
}
|
|
|
|
var content = '<div class="' + type + '">' + "\n";
|
|
content += '<table border="0" cellspacing="0" cellpadding="0">' + "\n";
|
|
|
|
for( var i = 0; i < analysis_data[type].length; i += 2 )
|
|
{
|
|
var colspan = 1;
|
|
var elements = analysis_data[type][i+1];
|
|
var elements_count = global_elements_count;
|
|
|
|
if( !elements[0].positionHistory )
|
|
{
|
|
colspan = elements_count;
|
|
elements_count = 1;
|
|
}
|
|
|
|
var legend = [];
|
|
for( var key in elements[0] )
|
|
{
|
|
var key_parts = key.split( '#' );
|
|
var used_key = key_parts.pop();
|
|
var short_key = used_key;
|
|
|
|
if( 1 === key_parts.length )
|
|
{
|
|
used_key = '<abbr title="' + key + '">' + used_key + '</abbr>';
|
|
}
|
|
|
|
if( 'positionHistory' === short_key || 'match' === short_key )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
legend.push
|
|
(
|
|
'<tr class="' + generate_class_name( short_key ) + '">' +
|
|
'<td>' + used_key + '</td>' +
|
|
'</tr>'
|
|
);
|
|
}
|
|
|
|
content += '<tbody>' + "\n";
|
|
content += '<tr class="step">' + "\n";
|
|
|
|
// analyzer
|
|
var analyzer_name = analysis_data[type][i]
|
|
.replace( /(\$1)+$/g, '' );
|
|
|
|
var analyzer_short = -1 !== analyzer_name.indexOf( '$' )
|
|
? analyzer_name.split( '$' )[1]
|
|
: analyzer_name.split( '.' ).pop();
|
|
analyzer_short = analyzer_short.match( /[A-Z]/g ).join( '' );
|
|
|
|
content += '<td class="part analyzer"><div>' + "\n";
|
|
content += '<abbr title="' + analysis_data[type][i] + '">' + "\n";
|
|
content += analyzer_short + '</abbr></div></td>' + "\n";
|
|
|
|
// legend
|
|
content += '<td class="part legend"><div class="holder">' + "\n";
|
|
content += '<table border="0" cellspacing="0" cellpadding="0">' + "\n";
|
|
content += '<tr><td>' + "\n";
|
|
content += '<table border="0" cellspacing="0" cellpadding="0">' + "\n";
|
|
content += legend.join( "\n" ) + "\n";
|
|
content += '</table></td></tr></table></td>' + "\n";
|
|
|
|
// data
|
|
var cell_content = '<td class="part data spacer" '
|
|
+ ' colspan="' + colspan + '">'
|
|
+ '<div class="holder"> </div>'
|
|
+ '</td>';
|
|
var cells = new Array( elements_count + 1 ).join( cell_content );
|
|
content += cells + "\n";
|
|
|
|
content += '</tr>' + "\n";
|
|
content += '</tbody>' + "\n";
|
|
}
|
|
content += '</table>' + "\n";
|
|
content += '</div>' + "\n";
|
|
|
|
$( '.' + type, analysis_result )
|
|
.remove();
|
|
|
|
analysis_result
|
|
.append( content );
|
|
|
|
var analysis_result_type = $( '.' + type, analysis_result );
|
|
|
|
for( var i = 0; i < analysis_data[type].length; i += 2 )
|
|
{
|
|
for( var j = 0; j < analysis_data[type][i+1].length; j += 1 )
|
|
{
|
|
var pos = analysis_data[type][i+1][j].positionHistory
|
|
? analysis_data[type][i+1][j].positionHistory[0]
|
|
: 1;
|
|
var selector = 'tr.step:eq(' + ( i / 2 ) +') '
|
|
+ 'td.data:eq(' + ( pos - 1 ) + ') '
|
|
+ '.holder';
|
|
var cell = $( selector, analysis_result_type );
|
|
|
|
cell.parent()
|
|
.removeClass( 'spacer' );
|
|
|
|
var table = $( 'table tr.details', cell );
|
|
if( 0 === table.size() )
|
|
{
|
|
cell
|
|
.html
|
|
(
|
|
'<table border="0" cellspacing="0" cellpadding="0">' +
|
|
'<tr class="details"></tr></table>'
|
|
);
|
|
var table = $( 'table tr.details', cell );
|
|
}
|
|
|
|
var tokens = [];
|
|
for( var key in analysis_data[type][i+1][j] )
|
|
{
|
|
var short_key = key.split( '#' ).pop();
|
|
|
|
if( 'positionHistory' === short_key || 'match' === short_key )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
var classes = [];
|
|
classes.push( generate_class_name( short_key ) );
|
|
|
|
var data = analysis_data[type][i+1][j][key];
|
|
if( 'object' === typeof data && data instanceof Array )
|
|
{
|
|
data = data.join( ' ' );
|
|
}
|
|
if( 'string' === typeof data )
|
|
{
|
|
data = data.esc();
|
|
}
|
|
|
|
if( null === data || 0 === data.length )
|
|
{
|
|
classes.push( 'empty' );
|
|
data = '∅';
|
|
}
|
|
|
|
if( analysis_data[type][i+1][j].match &&
|
|
( 'text' === short_key || 'raw_bytes' === short_key ) )
|
|
{
|
|
classes.push( 'match' );
|
|
}
|
|
|
|
tokens.push
|
|
(
|
|
'<tr class="' + classes.join( ' ' ) + '">' +
|
|
'<td>' + data + '</td>' +
|
|
'</tr>'
|
|
);
|
|
}
|
|
table
|
|
.append
|
|
(
|
|
'<td class="details">' +
|
|
'<table border="0" cellspacing="0" cellpadding="0">' +
|
|
tokens.join( "\n" ) +
|
|
'</table></td>'
|
|
);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core/schema, #/:core/config
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)\/(schema|config)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + app.config[context.params.splat[1] + '_path'],
|
|
dataType : 'xml',
|
|
context : $( '#content' ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.html( '<div class="loader">Loading ...</div>' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
var code = $(
|
|
'<pre class="syntax language-xml"><code>' +
|
|
xhr.responseText.replace( /\</g, '<' ).replace( /\>/g, '>' ) +
|
|
'</code></pre>'
|
|
);
|
|
this.html( code );
|
|
|
|
if( 'success' === text_status )
|
|
{
|
|
hljs.highlightBlock( code.get(0) );
|
|
}
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/:core
|
|
this.get
|
|
(
|
|
/^#\/([\w\d-]+)$/,
|
|
function( context )
|
|
{
|
|
var core_basepath = this.active_core.attr( 'data-basepath' );
|
|
var content_element = $( '#content' );
|
|
|
|
content_element
|
|
.removeClass( 'single' );
|
|
|
|
var core_menu = $( 'ul', this.active_core );
|
|
if( !core_menu.data( 'admin-extra-loaded' ) )
|
|
{
|
|
core_menu.data( 'admin-extra-loaded', new Date() );
|
|
|
|
$.get
|
|
(
|
|
core_basepath + '/admin/file/?file=admin-extra.menu-top.html',
|
|
function( menu_extra )
|
|
{
|
|
core_menu
|
|
.prepend( menu_extra );
|
|
}
|
|
);
|
|
|
|
$.get
|
|
(
|
|
core_basepath + '/admin/file/?file=admin-extra.menu-bottom.html',
|
|
function( menu_extra )
|
|
{
|
|
core_menu
|
|
.append( menu_extra );
|
|
}
|
|
);
|
|
}
|
|
|
|
$.get
|
|
(
|
|
'tpl/dashboard.html',
|
|
function( template )
|
|
{
|
|
content_element
|
|
.html( template );
|
|
|
|
var dashboard_element = $( '#dashboard' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/luke?wt=json',
|
|
dataType : 'json',
|
|
context : $( '#statistics', dashboard_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
$( 'h2', this )
|
|
.addClass( 'loader' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Loading ...' );
|
|
|
|
$( '.content' )
|
|
.hide();
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( '.message', this )
|
|
.empty()
|
|
.hide();
|
|
|
|
$( '.content', this )
|
|
.show();
|
|
|
|
var data = {
|
|
'index_num-docs' : response['index']['numDocs'],
|
|
'index_max-doc' : response['index']['maxDoc'],
|
|
'index_last-modified' : response['index']['lastModified']
|
|
};
|
|
|
|
for( var key in data )
|
|
{
|
|
$( '.' + key, this )
|
|
.show();
|
|
|
|
$( '.value.' + key, this )
|
|
.html( data[key] );
|
|
}
|
|
|
|
var optimized_element = $( '.value.index_optimized', this );
|
|
if( response['index']['optimized'] )
|
|
{
|
|
optimized_element
|
|
.addClass( 'ico-1' );
|
|
|
|
$( 'span', optimized_element )
|
|
.html( 'yes' );
|
|
}
|
|
else
|
|
{
|
|
optimized_element
|
|
.addClass( 'ico-0' );
|
|
|
|
$( 'span', optimized_element )
|
|
.html( 'no' );
|
|
}
|
|
|
|
var current_element = $( '.value.index_current', this );
|
|
if( response['index']['current'] )
|
|
{
|
|
current_element
|
|
.addClass( 'ico-1' );
|
|
|
|
$( 'span', current_element )
|
|
.html( 'yes' );
|
|
}
|
|
else
|
|
{
|
|
current_element
|
|
.addClass( 'ico-0' );
|
|
|
|
$( 'span', current_element )
|
|
.html( 'no' );
|
|
}
|
|
|
|
var deletions_element = $( '.value.index_has-deletions', this );
|
|
if( response['index']['hasDeletions'] )
|
|
{
|
|
deletions_element.prev()
|
|
.show();
|
|
|
|
deletions_element
|
|
.show()
|
|
.addClass( 'ico-0' );
|
|
|
|
$( 'span', deletions_element )
|
|
.html( 'yes' );
|
|
}
|
|
|
|
$( 'a', optimized_element )
|
|
.die( 'click' )
|
|
.live
|
|
(
|
|
'click',
|
|
function( event )
|
|
{
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/update?optimize=true&waitFlush=true&wt=json',
|
|
dataType : 'json',
|
|
context : $( this ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
this
|
|
.addClass( 'loader' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
this.parents( 'dd' )
|
|
.removeClass( 'ico-0' )
|
|
.addClass( 'ico-1' );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
console.warn( 'd0h, optimize broken!' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
this
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
$( '.timeago', this )
|
|
.timeago();
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
this
|
|
.addClass( 'disabled' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Luke is not configured' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
$( 'h2', this )
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/replication?command=details&wt=json',
|
|
dataType : 'json',
|
|
context : $( '#replication', dashboard_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
$( 'h2', this )
|
|
.addClass( 'loader' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Loading' );
|
|
|
|
$( '.content', this )
|
|
.hide();
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( '.message', this )
|
|
.empty()
|
|
.hide();
|
|
|
|
$( '.content', this )
|
|
.show();
|
|
|
|
$( '.replication', context.active_core )
|
|
.show();
|
|
|
|
var data = response.details;
|
|
var is_slave = 'undefined' !== typeof( data.slave );
|
|
var headline = $( 'h2 span', this );
|
|
var details_element = $( '#details', this );
|
|
var current_type_element = $( ( is_slave ? '.slave' : '.master' ), this );
|
|
|
|
if( is_slave )
|
|
{
|
|
this
|
|
.addClass( 'slave' );
|
|
|
|
headline
|
|
.html( headline.html() + ' (Slave)' );
|
|
}
|
|
else
|
|
{
|
|
this
|
|
.addClass( 'master' );
|
|
|
|
headline
|
|
.html( headline.html() + ' (Master)' );
|
|
}
|
|
|
|
$( '.version div', current_type_element )
|
|
.html( data.indexVersion );
|
|
$( '.generation div', current_type_element )
|
|
.html( data.generation );
|
|
$( '.size div', current_type_element )
|
|
.html( data.indexSize );
|
|
|
|
if( is_slave )
|
|
{
|
|
var master_element = $( '.master', details_element );
|
|
$( '.version div', master_element )
|
|
.html( data.slave.masterDetails.indexVersion );
|
|
$( '.generation div', master_element )
|
|
.html( data.slave.masterDetails.generation );
|
|
$( '.size div', master_element )
|
|
.html( data.slave.masterDetails.indexSize );
|
|
|
|
if( data.indexVersion !== data.slave.masterDetails.indexVersion )
|
|
{
|
|
$( '.version', details_element )
|
|
.addClass( 'diff' );
|
|
}
|
|
else
|
|
{
|
|
$( '.version', details_element )
|
|
.removeClass( 'diff' );
|
|
}
|
|
|
|
if( data.generation !== data.slave.masterDetails.generation )
|
|
{
|
|
$( '.generation', details_element )
|
|
.addClass( 'diff' );
|
|
}
|
|
else
|
|
{
|
|
$( '.generation', details_element )
|
|
.removeClass( 'diff' );
|
|
}
|
|
}
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
this
|
|
.addClass( 'disabled' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Replication is not configured' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
$( 'h2', this )
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/dataimport?command=details&wt=json',
|
|
dataType : 'json',
|
|
context : $( '#dataimport', dashboard_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
$( 'h2', this )
|
|
.addClass( 'loader' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Loading' );
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( '.message', this )
|
|
.empty()
|
|
.hide();
|
|
|
|
$( 'dl', this )
|
|
.show();
|
|
|
|
var data = {
|
|
'status' : response['status'],
|
|
'info' : response['statusMessages']['']
|
|
};
|
|
|
|
for( var key in data )
|
|
{
|
|
$( '.' + key, this )
|
|
.show();
|
|
|
|
$( '.value.' + key, this )
|
|
.html( data[key] );
|
|
}
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
this
|
|
.addClass( 'disabled' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Dataimport is not configured' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
$( 'h2', this )
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : core_basepath + '/admin/file/?file=admin-extra.html',
|
|
dataType : 'html',
|
|
context : $( '#admin-extra', dashboard_element ),
|
|
beforeSend : function( xhr, settings )
|
|
{
|
|
$( 'h2', this )
|
|
.addClass( 'loader' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'Loading' );
|
|
|
|
$( '.content', this )
|
|
.hide();
|
|
},
|
|
success : function( response, text_status, xhr )
|
|
{
|
|
$( '.message', this )
|
|
.hide()
|
|
.empty();
|
|
|
|
$( '.content', this )
|
|
.show()
|
|
.html( response );
|
|
},
|
|
error : function( xhr, text_status, error_thrown)
|
|
{
|
|
this
|
|
.addClass( 'disabled' );
|
|
|
|
$( '.message', this )
|
|
.show()
|
|
.html( 'We found no "admin-extra.html" file.' );
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
$( 'h2', this )
|
|
.removeClass( 'loader' );
|
|
}
|
|
}
|
|
);
|
|
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
// #/
|
|
this.get
|
|
(
|
|
/^#\/$/,
|
|
function( context )
|
|
{
|
|
var content_element = $( '#content' );
|
|
|
|
$( '#index', app.menu_element )
|
|
.addClass( 'active' );
|
|
|
|
content_element
|
|
.html( '<div id="index"></div>' );
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : 'tpl/index.html',
|
|
context : $( '#index', content_element ),
|
|
beforeSend : function( arr, form, options )
|
|
{
|
|
},
|
|
success : function( template )
|
|
{
|
|
this
|
|
.html( template );
|
|
|
|
var jvm_memory = $.extend
|
|
(
|
|
{
|
|
'free' : null,
|
|
'total' : null,
|
|
'max' : null,
|
|
'used' : null,
|
|
'raw' : {
|
|
'free' : null,
|
|
'total' : null,
|
|
'max' : null,
|
|
'used' : null,
|
|
'used%' : null
|
|
}
|
|
},
|
|
app.dashboard_values['jvm']['memory']
|
|
);
|
|
|
|
var parse_memory_value = function( value )
|
|
{
|
|
if( value !== Number( value ) )
|
|
{
|
|
var units = 'BKMGTPEZY';
|
|
var match = value.match( /^(\d+([,\.]\d+)?) (\w)\w?$/ );
|
|
var value = parseFloat( match[1] ) * Math.pow( 1024, units.indexOf( match[3].toUpperCase() ) );
|
|
}
|
|
|
|
return value;
|
|
};
|
|
var memory_data = {
|
|
'memory-bar-max' : parse_memory_value( jvm_memory['raw']['max'] || jvm_memory['max'] ),
|
|
'memory-bar-total' : parse_memory_value( jvm_memory['raw']['total'] || jvm_memory['total'] ),
|
|
'memory-bar-used' : parse_memory_value( jvm_memory['raw']['used'] || jvm_memory['used'] )
|
|
};
|
|
|
|
for( var key in memory_data )
|
|
{
|
|
$( '.value.' + key, this )
|
|
.text( memory_data[key] );
|
|
}
|
|
|
|
var data = {
|
|
'start_time' : app.dashboard_values['jvm']['jmx']['startTime'],
|
|
'host' : app.dashboard_values['core']['host'],
|
|
'jvm' : app.dashboard_values['jvm']['name'] + ' (' + app.dashboard_values['jvm']['version'] + ')',
|
|
'solr_spec_version' : app.dashboard_values['lucene']['solr-spec-version'],
|
|
'solr_impl_version' : app.dashboard_values['lucene']['solr-impl-version'],
|
|
'lucene_spec_version' : app.dashboard_values['lucene']['lucene-spec-version'],
|
|
'lucene_impl_version' : app.dashboard_values['lucene']['lucene-impl-version']
|
|
};
|
|
|
|
if( app.dashboard_values['core']['directory']['cwd'] )
|
|
{
|
|
data['cwd'] = app.dashboard_values['core']['directory']['cwd'];
|
|
}
|
|
|
|
for( var key in data )
|
|
{
|
|
var value_element = $( '.' + key + ' dd', this );
|
|
|
|
value_element
|
|
.text( data[key] );
|
|
|
|
value_element.closest( 'li' )
|
|
.show();
|
|
}
|
|
|
|
var commandLineArgs = app.dashboard_values['jvm']['jmx']['commandLineArgs'];
|
|
if( 0 !== commandLineArgs.length )
|
|
{
|
|
var cmd_arg_element = $( '.command_line_args dt', this );
|
|
var cmd_arg_key_element = $( '.command_line_args dt', this );
|
|
var cmd_arg_element = $( '.command_line_args dd', this );
|
|
|
|
for( var key in commandLineArgs )
|
|
{
|
|
cmd_arg_element = cmd_arg_element.clone();
|
|
cmd_arg_element.text( commandLineArgs[key] );
|
|
|
|
cmd_arg_key_element
|
|
.after( cmd_arg_element );
|
|
}
|
|
|
|
cmd_arg_key_element.closest( 'li' )
|
|
.show();
|
|
|
|
$( '.command_line_args dd:last', this )
|
|
.remove();
|
|
|
|
$( '.command_line_args dd:odd', this )
|
|
.addClass( 'odd' );
|
|
}
|
|
|
|
$( '.timeago', this )
|
|
.timeago();
|
|
|
|
$( 'li:visible:odd', this )
|
|
.addClass( 'odd' );
|
|
|
|
// -- memory bar
|
|
|
|
var max_height = Math.round( $( '#memory-bar-max', this ).height() );
|
|
var total_height = Math.round( ( memory_data['memory-bar-total'] * max_height ) / memory_data['memory-bar-max'] );
|
|
var used_height = Math.round( ( memory_data['memory-bar-used'] * max_height ) / memory_data['memory-bar-max'] );
|
|
|
|
var memory_bar_total_value = $( '#memory-bar-total span', this ).first();
|
|
|
|
$( '#memory-bar-total', this )
|
|
.height( total_height );
|
|
|
|
$( '#memory-bar-used', this )
|
|
.height( used_height );
|
|
|
|
if( used_height < total_height + memory_bar_total_value.height() )
|
|
{
|
|
memory_bar_total_value
|
|
.addClass( 'upper' )
|
|
.css( 'margin-top', memory_bar_total_value.height() * -1 );
|
|
}
|
|
|
|
var memory_percentage = ( ( memory_data['memory-bar-used'] / memory_data['memory-bar-max'] ) * 100 ).toFixed(1);
|
|
var headline = $( '#memory h2 span', this );
|
|
|
|
headline
|
|
.text( headline.html() + ' (' + memory_percentage + '%)' );
|
|
|
|
$( '#memory-bar .value', this )
|
|
.each
|
|
(
|
|
function()
|
|
{
|
|
var self = $( this );
|
|
|
|
var byte_value = parseInt( self.html() );
|
|
|
|
self
|
|
.attr( 'title', 'raw: ' + byte_value + ' B' );
|
|
|
|
byte_value /= 1024;
|
|
byte_value /= 1024;
|
|
byte_value = byte_value.toFixed( 2 ) + ' MB';
|
|
|
|
self
|
|
.text( byte_value );
|
|
}
|
|
);
|
|
},
|
|
error : function( xhr, text_status, error_thrown )
|
|
{
|
|
},
|
|
complete : function( xhr, text_status )
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
);
|
|
}
|
|
);
|
|
|
|
var solr_admin = function( app_config )
|
|
{
|
|
menu_element = null,
|
|
|
|
is_multicore = null,
|
|
cores_data = null,
|
|
active_core = null,
|
|
environment_basepath = null,
|
|
|
|
config = app_config,
|
|
params = null,
|
|
dashboard_values = null,
|
|
schema_browser_data = null,
|
|
|
|
plugin_data = null,
|
|
|
|
this.init_menu = function()
|
|
{
|
|
$( '.ping a', menu_element )
|
|
.live
|
|
(
|
|
'click',
|
|
function()
|
|
{
|
|
sammy.trigger
|
|
(
|
|
'ping',
|
|
{ element : this }
|
|
);
|
|
return false;
|
|
}
|
|
);
|
|
}
|
|
|
|
this.init_cores = function()
|
|
{
|
|
var self = this;
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : config.solr_path + config.core_admin_path + '?wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( arr, form, options )
|
|
{
|
|
$( '#content' )
|
|
.html( '<div id="index"><div class="loader">Loading ...</div></div>' );
|
|
},
|
|
success : function( response )
|
|
{
|
|
self.cores_data = response.status;
|
|
is_multicore = 'undefined' === typeof response.status[''];
|
|
|
|
if( is_multicore )
|
|
{
|
|
menu_element
|
|
.addClass( 'multicore' );
|
|
|
|
$( '#cores', menu_element )
|
|
.show();
|
|
}
|
|
else
|
|
{
|
|
menu_element
|
|
.addClass( 'singlecore' );
|
|
}
|
|
|
|
for( var core_name in response.status )
|
|
{
|
|
var core_path = config.solr_path + '/' + core_name;
|
|
|
|
if( !core_name )
|
|
{
|
|
core_name = 'singlecore';
|
|
core_path = config.solr_path
|
|
}
|
|
|
|
if( !environment_basepath )
|
|
{
|
|
environment_basepath = core_path;
|
|
}
|
|
|
|
var core_tpl = '<li id="' + core_name + '" data-basepath="' + core_path + '">' + "\n"
|
|
+ ' <p><a href="#/' + core_name + '">' + core_name + '</a></p>' + "\n"
|
|
+ ' <ul>' + "\n"
|
|
|
|
+ ' <li class="ping"><a rel="' + core_path + '/admin/ping"><span>Ping</span></a></li>' + "\n"
|
|
+ ' <li class="query"><a href="#/' + core_name + '/query"><span>Query</span></a></li>' + "\n"
|
|
+ ' <li class="schema"><a href="#/' + core_name + '/schema"><span>Schema</span></a></li>' + "\n"
|
|
+ ' <li class="config"><a href="#/' + core_name + '/config"><span>Config</span></a></li>' + "\n"
|
|
+ ' <li class="replication"><a href="#/' + core_name + '/replication"><span>Replication</span></a></li>' + "\n"
|
|
+ ' <li class="analysis"><a href="#/' + core_name + '/analysis"><span>Analysis</span></a></li>' + "\n"
|
|
+ ' <li class="schema-browser"><a href="#/' + core_name + '/schema-browser"><span>Schema Browser</span></a></li>' + "\n"
|
|
+ ' <li class="plugins"><a href="#/' + core_name + '/plugins"><span>Plugins</span></a></li>' + "\n"
|
|
+ ' <li class="dataimport"><a href="#/' + core_name + '/dataimport"><span>Dataimport</span></a></li>' + "\n"
|
|
|
|
+ ' </ul>' + "\n"
|
|
+ '</li>';
|
|
|
|
menu_element
|
|
.append( core_tpl );
|
|
}
|
|
|
|
$.ajax
|
|
(
|
|
{
|
|
url : environment_basepath + '/admin/system?wt=json',
|
|
dataType : 'json',
|
|
beforeSend : function( arr, form, options )
|
|
{
|
|
},
|
|
success : function( response )
|
|
{
|
|
self.dashboard_values = response;
|
|
|
|
var environment_args = null;
|
|
var cloud_args = null;
|
|
|
|
if( response.jvm && response.jvm.jmx && response.jvm.jmx.commandLineArgs )
|
|
{
|
|
var command_line_args = response.jvm.jmx.commandLineArgs.join( ' | ' );
|
|
|
|
environment_args = command_line_args
|
|
.match( /-Dsolr.environment=((dev|test|prod)?[\w\d]*)/i );
|
|
|
|
cloud_args = command_line_args
|
|
.match( /-Dzk/i );
|
|
}
|
|
|
|
// environment
|
|
|
|
var environment_element = $( '#environment' );
|
|
if( environment_args )
|
|
{
|
|
environment_element
|
|
.show();
|
|
|
|
if( environment_args[1] )
|
|
{
|
|
environment_element
|
|
.html( environment_args[1] );
|
|
}
|
|
|
|
if( environment_args[2] )
|
|
{
|
|
environment_element
|
|
.addClass( environment_args[2] );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
environment_element
|
|
.remove();
|
|
}
|
|
|
|
// cloud
|
|
|
|
var cloud_nav_element = $( '#menu #cloud' );
|
|
if( cloud_args )
|
|
{
|
|
cloud_nav_element
|
|
.show();
|
|
}
|
|
|
|
// application
|
|
|
|
sammy.run( location.hash );
|
|
},
|
|
error : function()
|
|
{
|
|
},
|
|
complete : function()
|
|
{
|
|
loader.hide( this );
|
|
}
|
|
}
|
|
);
|
|
},
|
|
error : function()
|
|
{
|
|
},
|
|
complete : function()
|
|
{
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
this.__construct = function()
|
|
{
|
|
menu_element = $( '#menu ul' );
|
|
|
|
this.init_menu();
|
|
this.init_cores();
|
|
|
|
this.menu_element = menu_element;
|
|
this.config = config;
|
|
}
|
|
this.__construct();
|
|
}
|
|
|
|
var app;
|
|
$( document ).ready
|
|
(
|
|
function()
|
|
{
|
|
jQuery.timeago.settings.allowFuture = true;
|
|
|
|
app = new solr_admin( app_config );
|
|
}
|
|
);
|