', {
class: config.moduleHeadClass
}).append(
$('
', {
class: config.moduleHandlerClass
}),
$('', {
class: 'pull-right'
}).append(
$('', {
class: ['fas', 'fa-fw', 'fa-sliders-h', config.moduleHeadlineIconClass, config.moduleHeadlineIconSettingsClass].join(' '),
title: 'settings'
}).attr('data-html', 'true').attr('data-toggle', 'tooltip'),
$('', {
class: ['fas', 'fa-fw', 'fa-search', config.moduleHeadlineIconClass, config.moduleHeadlineIconSearchClass].join(' '),
title: 'find route'
}).attr('data-html', 'true').attr('data-toggle', 'tooltip'),
$('', {
class: ['fas', 'fa-fw', 'fa-sync', config.moduleHeadlineIconClass, config.moduleHeadlineIconRefreshClass].join(' '),
title: 'refresh all'
}).attr('data-html', 'true').attr('data-toggle', 'tooltip')
),
$('', {
text: 'Routes'
})
)
);
// save systemFromData to module (data never changes during module lifetime)
// -> we need this later in updateModule()
let systemFromData = {
systemId: systemData.systemId,
name: systemData.name,
};
moduleElement.data('systemFromData', systemFromData);
let table = $('
', {
class: ['compact', 'stripe', 'order-column', 'row-border', config.systemInfoRoutesTableClass].join(' ')
});
moduleElement.append(table);
// init empty table
let routesTable = table.dataTable( {
paging: false,
ordering: true,
order: [[ 2, 'asc' ], [ 0, 'asc' ]],
info: false,
searching: false,
hover: false,
autoWidth: false,
rowId: 'systemTo',
language: {
emptyTable: 'No routes added'
},
columnDefs: [
{
targets: 0,
orderable: true,
title: '',
width: 2,
class: ['text-center'].join(' '),
data: 'status',
render: {
_: 'formatted',
sort: 'value'
}
},{
targets: 1,
orderable: true,
title: 'system ',
class: Util.config.popoverTriggerClass,
data: 'systemToData',
render: {
_: 'name',
sort: 'name'
},
createdCell: function(cell, cellData, rowData, rowIndex, colIndex){
// init context menu
$(cell).initSystemPopover({
systemToData: rowData.systemToData
});
$(cell).toggleClass(config.rallyClass, cellData.hasOwnProperty('rally'));
}
},{
targets: 2,
orderable: true,
title: ' ',
width: 16,
class: 'text-right',
data: 'jumps',
render: {
_: 'formatted',
sort: 'value'
}
},{
targets: 3,
orderable: true,
title: 'Ø ',
width: 14,
class: 'text-right',
data: 'avgTrueSec',
render: {
_: 'formatted',
sort: 'value'
}
},{
targets: 4,
orderable: false,
title: 'route',
class: [config.dataTableRouteCellClass].join(' '),
data: 'route',
render: {
_: 'value'
}
},{
targets: 5,
title: '',
orderable: false,
searchable: false,
width: 10,
class: ['text-center', config.dataTableActionCellClass].join(' '),
data: 'connections',
render: {
_: 'button'
},
createdCell: function(cell, cellData, rowData, rowIndex, colIndex){
let tempTableApi = this.api();
$(cell).on('click', function(e){
let routeCellElement = tempTableApi.cell( rowIndex, 4 ).nodes().to$();
if(routeCellElement.hasClass(config.dataTableJumpCellClass)){
routeCellElement.toggleClass(config.dataTableJumpCellClass, false);
$(this).find('i').toggleClass('txt-color-orange', false);
}else{
routeCellElement.toggleClass(config.dataTableJumpCellClass, true);
$(this).find('i').toggleClass('txt-color-orange', true);
}
});
}
},{
targets: 6,
title: '',
orderable: false,
searchable: false,
width: 10,
class: ['text-center', config.dataTableActionCellClass].join(' '),
data: 'flag',
render: {
_: 'button'
},
createdCell: function(cell, cellData, rowData, rowIndex, colIndex){
let tempTableApi = this.api();
$(cell).on('click', function(e){
// get current row data (important!)
// -> "rowData" param is not current state, values are "on createCell()" state
rowData = tempTableApi.row( $(cell).parents('tr')).data();
let routeData = getRouteRequestDataFromRowData( rowData );
// overwrite some params
routeData.skipSearch = 0;
routeData.flag = routeData.flag === 'shortest' ? 'secure' : 'shortest'; // toggle
let context = {
moduleElement: moduleElement,
dataTable: tempTableApi
};
let requestData = {
routeData: [routeData]
};
getRouteData(requestData, context, callbackAddRouteRows);
});
}
},{
targets: 7,
title: '',
orderable: false,
searchable: false,
width: 10,
class: ['text-center', config.dataTableActionCellClass].join(' '),
data: 'reload',
render: {
_: 'button'
},
createdCell: function(cell, cellData, rowData, rowIndex, colIndex){
let tempTableApi = this.api();
$(cell).on('click', function(e){
// get current row data (important!)
// -> "rowData" param is not current state, values are "on createCell()" state
rowData = tempTableApi.row( $(cell).parents('tr')).data();
let routeData = getRouteRequestDataFromRowData( rowData );
// overwrite some params
routeData.skipSearch = 0;
let context = {
moduleElement: moduleElement,
dataTable: tempTableApi
};
let requestData = {
routeData: [routeData]
};
getRouteData(requestData, context, callbackAddRouteRows);
});
}
},{
targets: 8,
title: '',
orderable: false,
searchable: false,
width: 10,
class: ['text-center', config.dataTableActionCellClass].join(' '),
data: 'clear',
render: {
_: 'button'
},
createdCell: function(cell, cellData, rowData, rowIndex, colIndex){
let tempTableElement = this;
let confirmationSettings = {
title: 'delete route',
template: Util.getConfirmationTemplate(null, {
size: 'small',
noTitle: true
}),
onConfirm : function(e, target){
let deleteRowElement = $(cell).parents('tr');
tempTableElement.api().rows(deleteRowElement).remove().draw();
}
};
// init confirmation dialog
$(cell).confirmation(confirmationSettings);
}
}
],
drawCallback: function(settings){
let animationRows = this.api().rows().nodes().to$().filter(function(){
return (
$(this).data('animationStatus') ||
$(this).data('animationTimer')
);
});
for(let i = 0; i < animationRows.length; i++){
let animationRow = $(animationRows[i]);
animationRow.pulseBackgroundColor(animationRow.data('animationStatus'));
animationRow.removeData('animationStatus');
}
},
initComplete: function(settings, json){
// click on "fake connection" -------------------------------------------------------------------------
$(this).on('click', '.pf-fake-connection', function(){
let fakeConnectionElement = $(this);
let mapId = fakeConnectionElement.attr('data-mapId');
let connectionId = fakeConnectionElement.attr('data-connectionId');
let connection = $().getConnectionById(mapId, connectionId);
if(connection){
let map = connection._jsPlumb.instance;
MapUtil.showConnectionInfo(map, [connection]);
}
});
},
data: [] // will be added dynamic
});
// init tooltips for this module
let tooltipElements = moduleElement.find('[data-toggle="tooltip"]');
tooltipElements.tooltip({
container: 'body'
});
return moduleElement;
};
/**
* init system popover (e.g. for setWaypoints)
* @param options
*/
$.fn.initSystemPopover = function(options){
let elements = $(this);
let eventNamespace = 'hideSystemPopup';
let systemToData = options.systemToData;
requirejs(['text!templates/tooltip/system_popover.html', 'mustache'], function(template, Mustache){
let data = {
systemToData: systemToData
};
let content = Mustache.render(template, data);
elements.each(function(){
let element = $(this);
// destroy "popover" and remove "click" event for animation
element.popover('destroy').off();
// init popover and add specific class to it (for styling)
element.popover({
html: true,
title: systemToData.name,
trigger: 'manual',
placement: 'top',
container: 'body',
content: content
}).data('bs.popover').tip().addClass('pf-popover');
});
// set popup "close" observer
elements.initPopoverClose(eventNamespace);
// set "open" trigger on "right click"
// -> this is not supported by the "trigger" param in .popover();
// -> therefore we need to set it up manually
elements.on('contextmenu', function(e){
e.preventDefault();
$(this).popover('show');
});
// set link observer "on shown" event
elements.on('shown.bs.popover', function(){
let popoverRoot = $(this);
popoverRoot.data('bs.popover').tip().find('a').on('click', function(){
// hint: "data" attributes should be in lower case!
let systemData = {
systemId: $(this).data('systemid'),
name: $(this).data('name')
};
Util.setDestination(systemData, 'set_destination');
// close popover
popoverRoot.popover('hide');
});
});
});
};
/**
* get data from all Rally Point systems
* @param mapId
* @returns {Array}
*/
let getRallySystemsData = (mapId) => {
let systemsRallyData = [];
let map = MapUtil.getMapInstance(mapId);
if(map){
let mapContainer = $(map.getContainer());
let systems = mapContainer.find('.pf-system-info-rally');
for(let system of systems){
system = $(system);
systemsRallyData.push({
systemId: system.data('systemId'),
name: system.data('name'),
rally: 1
});
}
}
return systemsRallyData;
};
/**
* update trigger function for this module
* @param moduleElement
* @param data
*/
let updateModule = (moduleElement, data) => {
let routesTableElement = moduleElement.find('.' + config.systemInfoRoutesTableClass);
let routesTable = routesTableElement.DataTable();
switch(data.task){
case 'showFindRouteDialog':
let dialogData = {
moduleElement: moduleElement,
mapId: data.mapId,
systemFromData: moduleElement.data('systemFromData'),
systemToData: data.systemToData,
dataTable: routesTable
};
showFindRouteDialog(dialogData);
break;
case 'findRoute':
drawRouteTable(data.mapId, moduleElement, moduleElement.data('systemFromData'), routesTable, [data.systemToData]);
break;
}
};
/**
* init route module
* -> request route path fore "default" trade hub systems
* @param moduleElement
* @param mapId
* @param systemData
*/
let initModule = (moduleElement, mapId, systemData) => {
let systemFromData = {
systemId: systemData.systemId,
name: systemData.name
};
let routesTableElement = moduleElement.find('.' + config.systemInfoRoutesTableClass);
let routesTable = routesTableElement.DataTable();
// init refresh routes ----------------------------------------------------------------------------------------
moduleElement.find('.' + config.moduleHeadlineIconRefreshClass).on('click', function(e){
updateRoutesTable(moduleElement, routesTable);
});
// init search routes dialog ----------------------------------------------------------------------------------
moduleElement.find('.' + config.moduleHeadlineIconSearchClass).on('click', function(e){
let maxRouteSearchLimit = this.Init.routeSearch.limit;
if(routesTable.rows().count() >= maxRouteSearchLimit){
// max routes limit reached -> show warning
Util.showNotify({title: 'Route limit reached', text: 'Search is limited by ' + maxRouteSearchLimit, type: 'warning'});
}else{
let dialogData = {
moduleElement: moduleElement,
mapId: mapId,
systemFromData: systemFromData,
dataTable: routesTable
};
showFindRouteDialog(dialogData);
}
}.bind({
Init: Init
}));
// init settings dialog ---------------------------------------------------------------------------------------
moduleElement.find('.' + config.moduleHeadlineIconSettingsClass).on('click', function(e){
let dialogData = {
mapId: mapId
};
showSettingsDialog(dialogData, moduleElement, systemFromData, routesTable);
});
// fill routesTable with data --------------------------------------------------------------------------------
let promiseStore = MapUtil.getLocaleData('map', mapId);
promiseStore.then(function(dataStore){
// selected systems (if already stored)
let systemsTo = [{
systemId: 30000142,
name: 'Jita'
}];
if(
dataStore &&
dataStore.routes
){
systemsTo = dataStore.routes;
}
// add "Rally Point" systems to table
let systemsToData = getRallySystemsData(mapId);
systemsToData.push(...systemsTo);
drawRouteTable(mapId, moduleElement, systemFromData, routesTable, systemsToData);
});
};
/**
* before module destroy callback
* @param moduleElement
*/
let beforeDestroy = moduleElement => {
let routeTableElement = moduleElement.find('.' + config.systemInfoRoutesTableClass);
let tableApi = routeTableElement.DataTable();
tableApi.destroy();
};
/**
* get all jump mass related connection types that have a lower "jumpMassMin" than connectionType
* @param connectionType
* @returns {Array}
*/
let getLowerSizeConnectionTypes = connectionType => {
let lowerSizeTypes = [];
let jumpMassMin = Util.getObjVal(Init.wormholeSizes, connectionType + '.jumpMassMin') || 0;
if(jumpMassMin){
for(let [type, data] of Object.entries(Init.wormholeSizes)){
if(data.jumpMassMin < jumpMassMin){
lowerSizeTypes.push(type);
}
}
}
return lowerSizeTypes;
};
return {
config: config,
getModule: getModule,
initModule: initModule,
updateModule: updateModule,
beforeDestroy: beforeDestroy
};
});