mirror of
https://github.com/LaCasemate/fab-manager.git
synced 2024-12-04 15:24:23 +01:00
793 lines
23 KiB
JavaScript
793 lines
23 KiB
JavaScript
/*
|
|
* decaffeinate suggestions:
|
|
* DS101: Remove unnecessary use of Array.from
|
|
* DS102: Remove unnecessary code created because of implicit returns
|
|
* DS205: Consider reworking code to avoid use of IIFEs
|
|
* Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
|
|
*/
|
|
'use strict';
|
|
|
|
|
|
|
|
Application.Controllers.controller("StatisticsController", ["$scope", "$state", "$rootScope", '$uibModal', "es", "Member", '_t', 'membersPromise', 'statisticsPromise'
|
|
, function($scope, $state, $rootScope, $uibModal, es, Member, _t, membersPromise, statisticsPromise) {
|
|
|
|
|
|
|
|
/* PRIVATE STATIC CONSTANTS */
|
|
|
|
//# search window size
|
|
const RESULTS_PER_PAGE = 20;
|
|
|
|
//# keep search context for (delay in minutes) ...
|
|
const ES_SCROLL_TIME = 1;
|
|
|
|
|
|
|
|
/* PUBLIC SCOPE */
|
|
|
|
//# ui-view transitions optimization: if true, the stats will never be refreshed
|
|
$scope.preventRefresh = false;
|
|
|
|
//# statistics structure in elasticSearch
|
|
$scope.statistics = statisticsPromise;
|
|
|
|
//# fablab users list
|
|
$scope.members = membersPromise;
|
|
|
|
//# statistics data recovered from elasticSearch
|
|
$scope.data = null;
|
|
|
|
//# when did the search was triggered
|
|
$scope.searchDate = null;
|
|
|
|
//# id of the elastic search context
|
|
$scope.scrollId = null;
|
|
|
|
//# total number of results for the current query
|
|
$scope.totalHits = null;
|
|
|
|
//# configuration of the widget allowing to pick the ages range
|
|
$scope.agePicker = {
|
|
show: false,
|
|
start: null,
|
|
end: null
|
|
};
|
|
|
|
//# total CA for the current view
|
|
$scope.sumCA = 0;
|
|
|
|
//# average users' age for the current view
|
|
$scope.averageAge = 0;
|
|
|
|
//# total of the stat field for non simple types
|
|
$scope.sumStat = 0;
|
|
|
|
//# Results of custom aggregations for the current type
|
|
$scope.customAggs = {};
|
|
|
|
//# default: results are not sorted
|
|
$scope.sorting = {
|
|
ca: 'none',
|
|
date: 'desc'
|
|
};
|
|
|
|
//# active tab will be set here
|
|
$scope.selectedIndex = null;
|
|
|
|
//# type filter binding
|
|
$scope.type = {
|
|
selected: null,
|
|
active: null
|
|
};
|
|
|
|
//# selected custom filter
|
|
$scope.customFilter = {
|
|
show: false,
|
|
criterion: {},
|
|
value : null,
|
|
exclude: false,
|
|
datePicker: {
|
|
format: Fablab.uibDateFormat,
|
|
opened: false, // default: datePicker is not shown
|
|
minDate: null,
|
|
maxDate: moment().toDate(),
|
|
options: {
|
|
startingDay: 1
|
|
}
|
|
} // France: the week starts on monday
|
|
};
|
|
|
|
//# available custom filters
|
|
$scope.filters = [];
|
|
|
|
//# default: we do not open the datepicker menu
|
|
$scope.datePicker =
|
|
{show: false};
|
|
|
|
//# datePicker parameters for interval beginning
|
|
$scope.datePickerStart = {
|
|
format: Fablab.uibDateFormat,
|
|
opened: false, // default: datePicker is not shown
|
|
minDate: null,
|
|
maxDate: moment().subtract(1, 'day').toDate(),
|
|
selected: moment().utc().subtract(1, 'months').subtract(1, 'day').startOf('day').toDate(),
|
|
options: {
|
|
startingDay: Fablab.weekStartingDay
|
|
}
|
|
};
|
|
|
|
//# datePicker parameters for interval ending
|
|
$scope.datePickerEnd = {
|
|
format: Fablab.uibDateFormat,
|
|
opened: false, // default: datePicker is not shown
|
|
minDate: null,
|
|
maxDate: moment().subtract(1, 'day').toDate(),
|
|
selected: moment().subtract(1, 'day').endOf('day').toDate(),
|
|
options: {
|
|
startingDay: Fablab.weekStartingDay
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to open the datepicker (interval start)
|
|
// @param $event {Object} jQuery event object
|
|
//#
|
|
$scope.toggleStartDatePicker = $event => toggleDatePicker($event, $scope.datePickerStart);
|
|
|
|
|
|
|
|
//#
|
|
// Callback to open the datepicker (interval end)
|
|
// @param $event {Object} jQuery event object
|
|
//#
|
|
$scope.toggleEndDatePicker = $event => toggleDatePicker($event, $scope.datePickerEnd);
|
|
|
|
|
|
|
|
//#
|
|
// Callback to open the datepicker (custom filter)
|
|
// @param $event {Object} jQuery event object
|
|
//#
|
|
$scope.toggleCustomDatePicker = $event => toggleDatePicker($event, $scope.customFilter.datePicker);
|
|
|
|
|
|
|
|
//#
|
|
// Callback called when the active tab is changed.
|
|
// recover the current tab and store its value in $scope.selectedIndex
|
|
// @param tab {Object} elasticsearch statistic structure (from statistic_indices table)
|
|
//#
|
|
$scope.setActiveTab = function(tab) {
|
|
$scope.selectedIndex = tab;
|
|
$scope.type.selected = tab.types[0];
|
|
$scope.type.active = $scope.type.selected;
|
|
$scope.customFilter.criterion = {};
|
|
$scope.customFilter.value = null;
|
|
$scope.customFilter.exclude = false;
|
|
$scope.sorting.ca = 'none';
|
|
$scope.sorting.date = 'desc';
|
|
buildCustomFiltersList();
|
|
return refreshStats();
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Returns true if the provided tab must be hidden due to some global or local configuration
|
|
// @param tab {Object} elasticsearch statistic structure (from statistic_indices table)
|
|
//#
|
|
$scope.hiddenTab = function(tab) {
|
|
if (tab.table) {
|
|
if ((tab.es_type_key === 'subscription') && $rootScope.fablabWithoutPlans) {
|
|
return true;
|
|
} else if ((tab.es_type_key === 'space') && $rootScope.fablabWithoutSpaces) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
} else {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to validate the filters and send a new request to elastic
|
|
//#
|
|
$scope.validateFilterChange = function() {
|
|
$scope.agePicker.show = false;
|
|
$scope.customFilter.show = false;
|
|
$scope.type.active = $scope.type.selected;
|
|
buildCustomFiltersList();
|
|
return refreshStats();
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to validate the dates range and refresh the data from elastic
|
|
//#
|
|
$scope.validateDateChange = function() {
|
|
$scope.datePicker.show = false;
|
|
return refreshStats();
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Parse the given date and return a user-friendly string
|
|
// @param date {Date} JS date or ant moment.js compatible date string
|
|
//#
|
|
$scope.formatDate = date => moment(date).format("LL");
|
|
|
|
|
|
|
|
//#
|
|
// Parse the sex and return a user-friendly string
|
|
// @param sex {string} 'male' | 'female'
|
|
//#
|
|
$scope.formatSex = function(sex) {
|
|
if (sex === 'male') {
|
|
return _t('man');
|
|
}
|
|
if (sex === 'female') {
|
|
return _t('woman');
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Retrieve the label for the given subtype in the current type
|
|
// @param key {string} statistic subtype key
|
|
//#
|
|
$scope.formatSubtype = function(key) {
|
|
let label = "";
|
|
angular.forEach($scope.type.active.subtypes, function(subtype) {
|
|
if (subtype.key === key) {
|
|
return label = subtype.label;
|
|
}
|
|
});
|
|
return label;
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Helper usable in ng-switch to determine the input type to display for custom filter value
|
|
// @param filter {Object} custom filter criterion
|
|
//#
|
|
$scope.getCustomValueInputType = function(filter) {
|
|
if (filter && filter.values) {
|
|
if (typeof(filter.values[0]) === 'string') {
|
|
return filter.values[0];
|
|
} else if (typeof(filter.values[0] === 'object')) {
|
|
return 'input_select';
|
|
}
|
|
} else {
|
|
return 'input_text';
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Change the sorting order and refresh the results to match the new order
|
|
// @param filter {Object} any filter
|
|
//#
|
|
$scope.toggleSorting = function(filter) {
|
|
switch ($scope.sorting[filter]) {
|
|
case 'none': $scope.sorting[filter] = 'asc'; break;
|
|
case 'asc': $scope.sorting[filter] = 'desc'; break;
|
|
case 'desc': $scope.sorting[filter] = 'none'; break;
|
|
}
|
|
return refreshStats();
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Return the user's name from his given ID
|
|
// @param id {number} user ID
|
|
//#
|
|
$scope.getUserNameFromId = function(id) {
|
|
const name = $scope.members[id];
|
|
return (name ? name : `ID ${id}`);
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Run a scroll query to elasticsearch to append the next packet of results to those displayed.
|
|
// If the ES search context has expired when the user ask for more results, we re-run the whole query.
|
|
//#
|
|
$scope.showMoreResults = function() {
|
|
// if all results were retrieved, do nothing
|
|
if ($scope.data.length >= $scope.totalHits) {
|
|
return;
|
|
}
|
|
|
|
if (moment($scope.searchDate).add(ES_SCROLL_TIME, 'minutes').isBefore(moment())) {
|
|
// elastic search context has expired, so we run again the whole query
|
|
return refreshStats();
|
|
} else {
|
|
return es.scroll({
|
|
"scroll": ES_SCROLL_TIME+'m',
|
|
"body": {scrollId: $scope.scrollId}
|
|
}
|
|
, function(error, response) {
|
|
if (error) {
|
|
return console.error(`Error: something unexpected occurred during elasticSearch scroll query: ${error}`);
|
|
} else {
|
|
$scope.scrollId = response._scroll_id;
|
|
return $scope.data = $scope.data.concat(response.hits.hits);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Open a modal dialog asking the user for details about exporting the statistics tables to an excel file
|
|
//#
|
|
$scope.exportToExcel = function() {
|
|
const options = {
|
|
templateUrl: '<%= asset_path "admin/statistics/export.html" %>',
|
|
size: 'sm',
|
|
controller: 'ExportStatisticsController',
|
|
resolve: {
|
|
dates() {
|
|
return {
|
|
start: $scope.datePickerStart.selected,
|
|
end: $scope.datePickerEnd.selected
|
|
};
|
|
},
|
|
query() {
|
|
const custom = buildCustomFilterQuery();
|
|
return buildElasticDataQuery($scope.type.active.key, custom, $scope.agePicker.start, $scope.agePicker.end, moment($scope.datePickerStart.selected), moment($scope.datePickerEnd.selected), $scope.sorting);
|
|
},
|
|
index() {
|
|
return {key: $scope.selectedIndex.es_type_key};
|
|
},
|
|
type() {
|
|
return {key: $scope.type.active.key};
|
|
}
|
|
}
|
|
};
|
|
|
|
return $uibModal.open(options)
|
|
.result['finally'](null).then(info=> console.log(info));
|
|
};
|
|
|
|
|
|
|
|
|
|
/* PRIVATE SCOPE */
|
|
|
|
//#
|
|
// Kind of constructor: these actions will be realized first when the controller is loaded
|
|
//#
|
|
const initialize = () =>
|
|
// workaround for angular-bootstrap::tabs behavior: on tab deletion, another tab will be selected
|
|
// which will cause every tabs to reload, one by one, when the view is closed
|
|
$rootScope.$on('$stateChangeStart', function(event, toState, toParams, fromState, fromParams) {
|
|
if ((fromState.name === 'app.admin.statistics') && (Object.keys(fromParams).length === 0)) {
|
|
return $scope.preventRefresh = true;
|
|
}
|
|
})
|
|
;
|
|
|
|
|
|
|
|
//#
|
|
// Generic function to toggle a bootstrap datePicker
|
|
// @param $event {Object} jQuery event object
|
|
// @param datePicker {Object} settings object of the concerned datepicker. Must have an 'opened' property
|
|
//#
|
|
var toggleDatePicker = function($event, datePicker) {
|
|
$event.preventDefault();
|
|
$event.stopPropagation();
|
|
return datePicker.opened = !datePicker.opened;
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Force update the statistics table, querying elasticSearch according to the current config values
|
|
//#
|
|
var refreshStats = function() {
|
|
if ($scope.selectedIndex && !$scope.preventRefresh) {
|
|
$scope.data = [];
|
|
$scope.sumCA = 0;
|
|
$scope.averageAge = 0;
|
|
$scope.sumStat = 0;
|
|
$scope.customAggs = {};
|
|
$scope.totalHits = null;
|
|
$scope.searchDate = new Date();
|
|
let custom = buildCustomFilterQuery();
|
|
return queryElasticStats($scope.selectedIndex.es_type_key, $scope.type.active.key, custom, function(res, err){
|
|
if (err) {
|
|
return console.error(`[statisticsController::refreshStats] Unable to refresh due to ${err}`);
|
|
} else {
|
|
$scope.data = res.hits.hits;
|
|
$scope.totalHits = res.hits.total;
|
|
$scope.sumCA = res.aggregations.total_ca.value;
|
|
$scope.averageAge = Math.round(res.aggregations.average_age.value * 100) / 100;
|
|
$scope.sumStat = res.aggregations.total_stat.value;
|
|
$scope.scrollId = res._scroll_id;
|
|
return (() => {
|
|
const result = [];
|
|
for (custom of Array.from($scope.type.active.custom_aggregations)) {
|
|
result.push($scope.customAggs[custom.field] = res.aggregations[custom.field].value);
|
|
}
|
|
return result;
|
|
})();
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Run the elasticSearch query to retreive the /stats/type aggregations
|
|
// @param index {String} elasticSearch document type (account|event|machine|project|subscription|training)
|
|
// @param type {String} statistics type (month|year|booking|hour|user|project)
|
|
// @param custom {{key:{string}, value:{string}}|null} custom filter property or null to disable this filter
|
|
// @param callback {function} function be to run after results were retrieved, it will receive
|
|
// two parameters : results {Object}, error {String} (if any)
|
|
//#
|
|
var queryElasticStats = function(index, type, custom, callback) {
|
|
// handle invalid callback
|
|
if (typeof(callback) !== "function") {
|
|
console.error('[statisticsController::queryElasticStats] Error: invalid callback provided');
|
|
return;
|
|
}
|
|
|
|
// run query
|
|
return es.search({
|
|
"index": "stats",
|
|
"type": index,
|
|
"size": RESULTS_PER_PAGE,
|
|
"scroll": ES_SCROLL_TIME+'m',
|
|
"stat-type": type,
|
|
"custom-query": custom ? JSON.stringify(Object.assign({exclude: custom.exclude}, buildElasticCustomCriterion(custom))) : '',
|
|
"start-date": moment($scope.datePickerStart.selected).format(),
|
|
"end-date": moment($scope.datePickerEnd.selected).format(),
|
|
"body": buildElasticDataQuery(type, custom, $scope.agePicker.start, $scope.agePicker.end, moment($scope.datePickerStart.selected), moment($scope.datePickerEnd.selected), $scope.sorting)
|
|
}
|
|
, function(error, response) {
|
|
if (error) {
|
|
return callback({}, `Error: something unexpected occurred during elasticSearch query: ${error}`);
|
|
} else {
|
|
return callback(response);
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Build an object representing the content of the REST-JSON query to elasticSearch,
|
|
// based on the provided parameters for row data recovering.
|
|
// @param type {String} statistics type (month|year|booking|hour|user|project)
|
|
// @param custom {{key:{string}, value:{string}}|null} custom filter property or null to disable this filter
|
|
// @param ageMin {Number|null} filter by age: range lower value OR null to do not filter
|
|
// @param ageMax {Number|null} filter by age: range higher value OR null to do not filter
|
|
// @param intervalBegin {moment} statitics interval beginning (moment.js type)
|
|
// @param intervalEnd {moment} statitics interval ending (moment.js type)
|
|
// @param sortings {Array|null} elasticSearch criteria for sorting the results
|
|
//#
|
|
var buildElasticDataQuery = function(type, custom, ageMin, ageMax, intervalBegin, intervalEnd, sortings) {
|
|
const q = {
|
|
"query": {
|
|
"bool": {
|
|
"must": [
|
|
{
|
|
"term": {
|
|
"type": type
|
|
}
|
|
},
|
|
{
|
|
"range": {
|
|
"date": {
|
|
"gte": intervalBegin.format(),
|
|
"lte": intervalEnd.format()
|
|
}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
};
|
|
// optional date range
|
|
if ((typeof ageMin === 'number') && (typeof ageMax === 'number')) {
|
|
q.query.bool.must.push({
|
|
"range": {
|
|
"age": {
|
|
"gte": ageMin,
|
|
"lte": ageMax
|
|
}
|
|
}
|
|
});
|
|
}
|
|
// optional criterion
|
|
if (custom) {
|
|
const criterion = buildElasticCustomCriterion(custom);
|
|
if (custom.exclude) {
|
|
q.query.bool.must_not = [
|
|
{"term": criterion.match}
|
|
];
|
|
} else {
|
|
q.query.bool.must.push(criterion);
|
|
}
|
|
}
|
|
|
|
|
|
if (sortings) {
|
|
q["sort"] = buildElasticSortCriteria(sortings);
|
|
}
|
|
|
|
// aggregations (avg age & CA sum)
|
|
q["aggs"] = {
|
|
"total_ca": {
|
|
"sum": {
|
|
"field": "ca"
|
|
}
|
|
},
|
|
"average_age": {
|
|
"avg": {
|
|
"field": "age"
|
|
}
|
|
},
|
|
"total_stat": {
|
|
"sum": {
|
|
"field": "stat"
|
|
}
|
|
}
|
|
};
|
|
return q;
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Build the elasticSearch query DSL to match the selected cutom filter
|
|
// @param custom {Object} if custom is empty or undefined, an empty string will be returned
|
|
// @returns {{match:{*}}|string}
|
|
//#
|
|
var buildElasticCustomCriterion = function(custom) {
|
|
if (custom) {
|
|
const criterion = {
|
|
"match" : {}
|
|
};
|
|
switch ($scope.getCustomValueInputType($scope.customFilter.criterion)) {
|
|
case 'input_date': criterion.match[custom.key] = moment(custom.value).format('YYYY-MM-DD'); break;
|
|
case 'input_select': criterion.match[custom.key] = custom.value.key; break;
|
|
case 'input_list': criterion.match[custom.key+".name"] = custom.value; break;
|
|
default: criterion.match[custom.key] = custom.value;
|
|
}
|
|
return criterion;
|
|
} else {
|
|
return '';
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Parse the provided criteria array and return the corresponding elasticSearch syntax
|
|
// @param criteria {Array} array of {key_to_sort:order}
|
|
//#
|
|
var buildElasticSortCriteria = function(criteria) {
|
|
const crits = [];
|
|
angular.forEach(criteria, function(value, key) {
|
|
if ((typeof value !== 'undefined') && (value !== null) && (value !== 'none')) {
|
|
const c = {};
|
|
c[key] = {'order': value};
|
|
return crits.push(c);
|
|
}
|
|
});
|
|
return crits;
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Fullfil the list of available options in the custom filter panel. The list will be based on common
|
|
// properties and on index-specific properties (additional_fields)
|
|
//#
|
|
var buildCustomFiltersList = function() {
|
|
$scope.filters = [];
|
|
|
|
const filters = [
|
|
{key: 'date', label: _t('date'), values: ['input_date']},
|
|
{key: 'userId', label: _t('user_id'), values: ['input_number']},
|
|
{key: 'gender', label: _t('gender'), values: [{key:'male', label:_t('man')}, {key:'female', label:_t('woman')}]},
|
|
{key: 'age', label: _t('age'), values: ['input_number']},
|
|
{key: 'subType', label: _t('type'), values: $scope.type.active.subtypes},
|
|
{key: 'ca', label: _t('revenue'), values: ['input_number']}
|
|
];
|
|
|
|
$scope.filters = filters;
|
|
|
|
if (!$scope.type.active.simple) {
|
|
const f = {key: 'stat', label: $scope.type.active.label, values: ['input_number']};
|
|
$scope.filters.push(f);
|
|
}
|
|
|
|
return angular.forEach($scope.selectedIndex.additional_fields, function(field) {
|
|
const filter = {key: field.key, label: field.label, values:[]};
|
|
switch (field.data_type) {
|
|
case 'index': filter.values.push('input_number'); break;
|
|
case 'number': filter.values.push('input_number'); break;
|
|
case 'date': filter.values.push('input_date'); break;
|
|
case 'list': filter.values.push('input_list'); break;
|
|
default: filter.values.push('input_text');
|
|
}
|
|
|
|
return $scope.filters.push(filter);
|
|
});
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Build and return an object according to the custom filter set by the user, used to request elasticsearch
|
|
// @return {Object|null}
|
|
//#
|
|
var buildCustomFilterQuery = function() {
|
|
let custom = null;
|
|
if (!angular.isUndefinedOrNull($scope.customFilter.criterion) &&
|
|
!angular.isUndefinedOrNull($scope.customFilter.criterion.key) &&
|
|
!angular.isUndefinedOrNull($scope.customFilter.value)) {
|
|
custom = {};
|
|
custom.key = $scope.customFilter.criterion.key;
|
|
custom.value = $scope.customFilter.value;
|
|
custom.exclude = $scope.customFilter.exclude;
|
|
}
|
|
return custom;
|
|
};
|
|
|
|
|
|
|
|
// init the controller (call at the end !)
|
|
return initialize();
|
|
}
|
|
|
|
]);
|
|
|
|
|
|
|
|
Application.Controllers.controller('ExportStatisticsController', [ '$scope', '$uibModalInstance', 'Export','dates', 'query', 'index', 'type', 'CSRF', 'growl', '_t'
|
|
, function($scope, $uibModalInstance, Export, dates, query, index, type, CSRF, growl, _t) {
|
|
|
|
//# Retrieve Anti-CSRF tokens from cookies
|
|
CSRF.setMetaTags();
|
|
|
|
//# Bindings for date range
|
|
$scope.dates = dates;
|
|
|
|
//# Body of the query to export
|
|
$scope.query = JSON.stringify(query);
|
|
|
|
//# API URL where the form will be posted
|
|
$scope.actionUrl = `/stats/${index.key}/export`;
|
|
|
|
//# Key of the current search' statistic type
|
|
$scope.typeKey = type.key;
|
|
|
|
//# Form action on the above URL
|
|
$scope.method = "post";
|
|
|
|
//# Anti-CSRF token to inject into the download form
|
|
$scope.csrfToken = angular.element('meta[name="csrf-token"]')[0].content;
|
|
|
|
//# Binding of the export type (global / current)
|
|
$scope.export =
|
|
{type: 'current'};
|
|
|
|
//# datePicker parameters for interval beginning
|
|
$scope.exportStart = {
|
|
format: Fablab.uibDateFormat,
|
|
opened: false, // default: datePicker is not shown
|
|
minDate: null,
|
|
maxDate: moment().subtract(1, 'day').toDate(),
|
|
options: {
|
|
startingDay: Fablab.weekStartingDay
|
|
}
|
|
};
|
|
|
|
//# datePicker parameters for interval ending
|
|
$scope.exportEnd = {
|
|
format: Fablab.uibDateFormat,
|
|
opened: false, // default: datePicker is not shown
|
|
minDate: null,
|
|
maxDate: moment().subtract(1, 'day').toDate(),
|
|
options: {
|
|
startingDay: Fablab.weekStartingDay
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to open the datepicker (interval start)
|
|
// @param $event {Object} jQuery event object
|
|
//#
|
|
$scope.toggleStartDatePicker = $event => $scope.exportStart.opened = !$scope.exportStart.opened;
|
|
|
|
|
|
|
|
//#
|
|
// Callback to open the datepicker (interval end)
|
|
// @param $event {Object} jQuery event object
|
|
//#
|
|
$scope.toggleEndDatePicker = $event => $scope.exportEnd.opened = !$scope.exportEnd.opened;
|
|
|
|
|
|
|
|
//#
|
|
// Callback when exchanging the export type between 'global' and 'current view'
|
|
// Adjust the query and the requesting url according to this type.
|
|
//#
|
|
$scope.setRequest = function() {
|
|
if ($scope.export.type === 'global') {
|
|
$scope.actionUrl = '/stats/global/export';
|
|
return $scope.query = JSON.stringify({
|
|
"query": {
|
|
"bool": {
|
|
"must": [
|
|
{
|
|
"range": {
|
|
"date": {
|
|
"gte": moment($scope.dates.start).format(),
|
|
"lte": moment($scope.dates.end).format()
|
|
}
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
$scope.actionUrl = `/stats/${index.key}/export`;
|
|
return $scope.query = JSON.stringify(query);
|
|
}
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to close the modal, telling the caller what is exported
|
|
//#
|
|
$scope.exportData = function() {
|
|
const statusQry = {category: 'statistics', type: $scope.export.type, query: $scope.query};
|
|
if ($scope.export.type !== 'global') {
|
|
statusQry['type'] = index.key;
|
|
statusQry['key'] = type.key;
|
|
}
|
|
|
|
Export.status(statusQry).then(function(res) {
|
|
if (!res.data.exists) {
|
|
return growl.success(_t('export_is_running_you_ll_be_notified_when_its_ready'));
|
|
}
|
|
});
|
|
|
|
return $uibModalInstance.close(statusQry);
|
|
};
|
|
|
|
|
|
|
|
//#
|
|
// Callback to cancel the export and close the modal
|
|
//#
|
|
return $scope.cancel = () => $uibModalInstance.dismiss('cancel');
|
|
}
|
|
]);
|