mirror of
https://github.com/openstf/stf
synced 2025-10-05 02:29:26 +02:00
464 lines
12 KiB
JavaScript
464 lines
12 KiB
JavaScript
/**
|
|
* Copyright © 2019 code initially contributed by Orange SA, authors: Denis Barbaron - Licensed under the Apache license 2.0
|
|
**/
|
|
|
|
const _ = require('lodash')
|
|
|
|
module.exports = function GroupListCtrl(
|
|
$scope
|
|
, $filter
|
|
, GroupsService
|
|
, UserService
|
|
, UsersService
|
|
, DevicesService
|
|
, SettingsService
|
|
, ItemsPerPageOptionsService
|
|
, CommonService
|
|
) {
|
|
const users = []
|
|
const usersByEmail = {}
|
|
const devices = []
|
|
const devicesBySerial = {}
|
|
const groupsById = {}
|
|
const groupsEnv = {}
|
|
const groupUserToAdd = {}
|
|
const userFields =
|
|
'email,' +
|
|
'name,' +
|
|
'privilege'
|
|
const deviceFields =
|
|
'serial,' +
|
|
'version,' +
|
|
'manufacturer,' +
|
|
'marketName,' +
|
|
'sdk,' +
|
|
'display.width,' +
|
|
'display.height,' +
|
|
'model'
|
|
|
|
function incrStateStats(group, incr) {
|
|
if (group.isActive) {
|
|
$scope.activeGroups += incr
|
|
}
|
|
else if (group.state === 'pending') {
|
|
$scope.pendingGroups += incr
|
|
}
|
|
$scope.readyGroups = $scope.groups.length - $scope.activeGroups - $scope.pendingGroups
|
|
}
|
|
|
|
function updateStateStats(oldGroup, newGroup) {
|
|
if (oldGroup === null) {
|
|
incrStateStats(newGroup, 1)
|
|
}
|
|
else if (newGroup === null) {
|
|
incrStateStats(oldGroup, -1)
|
|
}
|
|
else {
|
|
if (newGroup.isActive && !oldGroup.isActive) {
|
|
incrStateStats(newGroup, 1)
|
|
}
|
|
else if (!newGroup.isActive && oldGroup.isActive) {
|
|
incrStateStats(oldGroup, -1)
|
|
}
|
|
else if (newGroup.state === 'ready' && oldGroup.state === 'pending') {
|
|
incrStateStats(oldGroup, -1)
|
|
}
|
|
}
|
|
}
|
|
|
|
function updateGroupExtraProperties(group) {
|
|
const status = {pending: 'Pending', waiting: 'Waiting', ready: 'Ready'}
|
|
|
|
group.status = group.isActive ? 'Active' : status[group.state]
|
|
group.startTime = $filter('date')(group.dates[0].start, SettingsService.get('dateFormat'))
|
|
group.stopTime = $filter('date')(group.dates[0].stop, SettingsService.get('dateFormat'))
|
|
|
|
}
|
|
|
|
function updateQuotaBar(bar, consumed, allocated) {
|
|
bar.value = (consumed / allocated) * 100 | 0
|
|
if (bar.value < 25) {
|
|
bar.type = 'success'
|
|
}
|
|
else if (bar.value < 50) {
|
|
bar.type = 'info'
|
|
}
|
|
else if (bar.value < 75) {
|
|
bar.type = 'warning'
|
|
}
|
|
else {
|
|
bar.type = 'danger'
|
|
}
|
|
}
|
|
|
|
function updateQuotaBars() {
|
|
updateQuotaBar(
|
|
$scope.numberBar
|
|
, $scope.user.groups.quotas.consumed.number
|
|
, $scope.user.groups.quotas.allocated.number
|
|
)
|
|
updateQuotaBar(
|
|
$scope.durationBar
|
|
, $scope.user.groups.quotas.consumed.duration
|
|
, $scope.user.groups.quotas.allocated.duration
|
|
)
|
|
}
|
|
|
|
function addGroup(group, timeStamp) {
|
|
if (CommonService.add(
|
|
$scope.groups
|
|
, groupsById
|
|
, group
|
|
, 'id'
|
|
, timeStamp)) {
|
|
$scope.groupsEnv[group.id] = {
|
|
devices: []
|
|
, users: []
|
|
}
|
|
groupsEnv[group.id] = {
|
|
devicesBySerial: {}
|
|
, usersByEmail: {}
|
|
}
|
|
updateStateStats(null, group)
|
|
updateGroupExtraProperties(group)
|
|
return group
|
|
}
|
|
return null
|
|
}
|
|
|
|
function updateGroup(group, timeStamp) {
|
|
return CommonService.update(
|
|
$scope.groups
|
|
, groupsById
|
|
, group
|
|
, 'id'
|
|
, timeStamp)
|
|
}
|
|
|
|
function deleteGroup(id, timeStamp) {
|
|
const group = CommonService.delete(
|
|
$scope.groups
|
|
, groupsById
|
|
, id
|
|
, timeStamp)
|
|
|
|
if (group) {
|
|
updateStateStats(group, null)
|
|
delete $scope.groupsEnv[group.id]
|
|
delete groupsEnv[group.id]
|
|
}
|
|
return group
|
|
}
|
|
|
|
function addUser(user, timeStamp) {
|
|
if (CommonService.add(
|
|
users
|
|
, usersByEmail
|
|
, user
|
|
, 'email'
|
|
, timeStamp
|
|
) && typeof groupUserToAdd[user.email] !== 'undefined') {
|
|
addGroupUser(
|
|
groupUserToAdd[user.email].id
|
|
, user.email
|
|
, groupUserToAdd[user.email].timeStamp)
|
|
delete groupUserToAdd[user.email]
|
|
}
|
|
}
|
|
|
|
function deleteUser(email, timeStamp) {
|
|
return CommonService.delete(
|
|
users
|
|
, usersByEmail
|
|
, email
|
|
, timeStamp)
|
|
}
|
|
|
|
function addDevice(device, timeStamp) {
|
|
return CommonService.add(
|
|
devices
|
|
, devicesBySerial
|
|
, device
|
|
, 'serial'
|
|
, timeStamp)
|
|
}
|
|
|
|
function updateDevice(device, timeStamp) {
|
|
return CommonService.update(
|
|
devices
|
|
, devicesBySerial
|
|
, device
|
|
, 'serial'
|
|
, timeStamp)
|
|
}
|
|
|
|
function deleteDevice(serial, timeStamp) {
|
|
return CommonService.delete(
|
|
devices
|
|
, devicesBySerial
|
|
, serial
|
|
, timeStamp)
|
|
}
|
|
|
|
function addGroupUser(id, email, timeStamp) {
|
|
if (CommonService.isExisting(usersByEmail[email])) {
|
|
CommonService.add(
|
|
$scope.groupsEnv[id].users
|
|
, groupsEnv[id].usersByEmail
|
|
, users[usersByEmail[email].index]
|
|
, 'email'
|
|
, timeStamp)
|
|
}
|
|
else {
|
|
groupUserToAdd[email] = {id: id, timeStamp: timeStamp}
|
|
}
|
|
}
|
|
|
|
function deleteGroupUser(id, email, timeStamp) {
|
|
CommonService.delete(
|
|
$scope.groupsEnv[id].users
|
|
, groupsEnv[id].usersByEmail
|
|
, email
|
|
, timeStamp)
|
|
}
|
|
|
|
function addGroupDevice(id, serial, timeStamp) {
|
|
if (CommonService.isExisting(devicesBySerial[serial])) {
|
|
CommonService.add(
|
|
$scope.groupsEnv[id].devices
|
|
, groupsEnv[id].devicesBySerial
|
|
, devices[devicesBySerial[serial].index]
|
|
, 'serial'
|
|
, timeStamp)
|
|
}
|
|
else {
|
|
GroupsService.getGroupDevice(id, serial, deviceFields)
|
|
.then(function(response) {
|
|
if (addDevice(response.data.device, timeStamp)) {
|
|
CommonService.add(
|
|
$scope.groupsEnv[id].devices
|
|
, groupsEnv[id].devicesBySerial
|
|
, devices[devicesBySerial[serial].index]
|
|
, 'serial'
|
|
, timeStamp)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
function deleteGroupDevice(id, serial, timeStamp) {
|
|
CommonService.delete(
|
|
$scope.groupsEnv[id].devices
|
|
, groupsEnv[id].devicesBySerial
|
|
, serial
|
|
, timeStamp)
|
|
}
|
|
|
|
function updateGroupDevices(group, isAddedDevice, devices, timeStamp) {
|
|
if (devices.length) {
|
|
if (isAddedDevice) {
|
|
devices.forEach(function(serial) {
|
|
addGroupDevice(group.id, serial, timeStamp)
|
|
})
|
|
}
|
|
else {
|
|
devices.forEach(function(serial) {
|
|
deleteGroupDevice(group.id, serial, timeStamp)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
function updateGroupUsers(group, isAddedUser, users, timeStamp) {
|
|
if (users.length) {
|
|
if (isAddedUser) {
|
|
users.forEach(function(email) {
|
|
addGroupUser(group.id, email, timeStamp)
|
|
})
|
|
}
|
|
else {
|
|
users.forEach(function(email) {
|
|
deleteGroupUser(group.id, email, timeStamp)
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
function initScope() {
|
|
GroupsService.getOboeGroups(function(group) {
|
|
addGroup(group, -1)
|
|
})
|
|
.done(function() {
|
|
$scope.$digest()
|
|
})
|
|
|
|
UserService.getUser().then(function(response) {
|
|
$scope.user = response.data.user
|
|
updateQuotaBars()
|
|
})
|
|
|
|
UsersService.getOboeUsers(userFields, function(user) {
|
|
addUser(user, -1)
|
|
})
|
|
}
|
|
|
|
$scope.scopeGroupListCtrl = $scope
|
|
$scope.sortBy = CommonService.sortBy
|
|
$scope.getDuration = CommonService.getDuration
|
|
$scope.getClassName = CommonService.getClassName
|
|
$scope.user = UserService.currentUser
|
|
$scope.numberBar = {}
|
|
$scope.durationBar = {}
|
|
$scope.groupsEnv = {}
|
|
$scope.groups = []
|
|
$scope.activeGroups = $scope.readyGroups = $scope.pendingGroups = 0
|
|
$scope.itemsPerPageOptions = ItemsPerPageOptionsService
|
|
SettingsService.bind($scope, {
|
|
target: 'groupItemsPerPage'
|
|
, source: 'groupViewItemsPerPage'
|
|
, defaultValue: $scope.itemsPerPageOptions[2]
|
|
})
|
|
$scope.groupColumns = [
|
|
{name: 'Status', property: 'status'}
|
|
, {name: 'Name', property: 'name'}
|
|
, {name: 'Identifier', property: 'id'}
|
|
, {name: 'Owner', property: 'owner.name'}
|
|
, {name: 'Devices', property: 'devices.length'}
|
|
, {name: 'Users', property: 'users.length'}
|
|
, {name: 'Class', property: 'class'}
|
|
, {name: 'Repetitions', property: 'repetitions'}
|
|
, {name: 'Duration', property: 'duration'}
|
|
, {name: 'Starting Date', property: 'startTime'}
|
|
, {name: 'Expiration Date', property: 'stopTime'}
|
|
]
|
|
$scope.defaultGroupData = {
|
|
columns: [
|
|
{name: 'Status', selected: true, sort: 'none'}
|
|
, {name: 'Name', selected: true, sort: 'sort-asc'}
|
|
, {name: 'Identifier', selected: false, sort: 'none'}
|
|
, {name: 'Owner', selected: true, sort: 'none'}
|
|
, {name: 'Devices', selected: true, sort: 'none'}
|
|
, {name: 'Users', selected: true, sort: 'none'}
|
|
, {name: 'Class', selected: true, sort: 'none'}
|
|
, {name: 'Repetitions', selected: true, sort: 'none'}
|
|
, {name: 'Duration', selected: true, sort: 'none'}
|
|
, {name: 'Starting Date', selected: true, sort: 'none'}
|
|
, {name: 'Expiration Date', selected: true, sort: 'none'}
|
|
]
|
|
, sort: {index: 1, reverse: false}
|
|
}
|
|
SettingsService.bind($scope, {
|
|
target: 'groupData'
|
|
, source: 'groupData'
|
|
, defaultValue: $scope.defaultGroupData
|
|
})
|
|
|
|
$scope.mailToGroupOwners = function(groups) {
|
|
CommonService.copyToClipboard(_.uniq(groups.map(function(group) {
|
|
return group.owner.email
|
|
}))
|
|
.join(SettingsService.get('emailSeparator')))
|
|
.url('mailto:?body=*** Paste the email addresses from the clipboard! ***')
|
|
}
|
|
|
|
$scope.mailToGroupUsers = function(group, users) {
|
|
// group unused actually..
|
|
CommonService.copyToClipboard(users.map(function(user) {
|
|
return user.email
|
|
})
|
|
.join(SettingsService.get('emailSeparator')))
|
|
.url('mailto:?body=*** Paste the email addresses from the clipboard! ***')
|
|
}
|
|
|
|
$scope.getTooltip = function(objects) {
|
|
var tooltip = ''
|
|
|
|
objects.forEach(function(object) {
|
|
tooltip += object + '\n'
|
|
})
|
|
return tooltip
|
|
}
|
|
|
|
$scope.resetData = function() {
|
|
$scope.groupData = JSON.parse(JSON.stringify($scope.defaultGroupData))
|
|
}
|
|
|
|
$scope.initGroupUsers = function(group) {
|
|
if (typeof $scope.groupsEnv[group.id].userCurrentPage === 'undefined') {
|
|
$scope.groupsEnv[group.id].userCurrentPage = 1
|
|
$scope.groupsEnv[group.id].userItemsPerPage = $scope.itemsPerPageOptions[1]
|
|
}
|
|
group.users.forEach(function(email) {
|
|
addGroupUser(group.id, email, -1)
|
|
})
|
|
}
|
|
|
|
$scope.initGroupDevices = function(group) {
|
|
if (typeof $scope.groupsEnv[group.id].deviceCurrentPage === 'undefined') {
|
|
$scope.groupsEnv[group.id].deviceCurrentPage = 1
|
|
$scope.groupsEnv[group.id].deviceItemsPerPage = $scope.itemsPerPageOptions[1]
|
|
}
|
|
GroupsService.getOboeGroupDevices(group.id, false, deviceFields, function(device) {
|
|
addDevice(device, -1)
|
|
addGroupDevice(group.id, device.serial, -1)
|
|
})
|
|
.done(function() {
|
|
$scope.$digest()
|
|
})
|
|
}
|
|
|
|
$scope.$on('user.view.groups.created', function(event, message) {
|
|
addGroup(message.group, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.view.groups.deleted', function(event, message) {
|
|
deleteGroup(message.group.id, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.view.groups.updated', function(event, message) {
|
|
if (CommonService.isExisting(groupsById[message.group.id])) {
|
|
if (message.group.users.indexOf(UserService.currentUser.email) < 0) {
|
|
deleteGroup(message.group.id, message.timeStamp)
|
|
}
|
|
else {
|
|
updateStateStats($scope.groups[groupsById[message.group.id].index], message.group)
|
|
updateGroupDevices(message.group, message.isAddedDevice, message.devices, message.timeStamp)
|
|
updateGroupUsers(message.group, message.isAddedUser, message.users, message.timeStamp)
|
|
updateGroup(message.group, message.timeStamp)
|
|
updateGroupExtraProperties($scope.groups[groupsById[message.group.id].index])
|
|
}
|
|
}
|
|
else {
|
|
addGroup(message.group, message.timeStamp)
|
|
}
|
|
})
|
|
|
|
$scope.$on('user.settings.users.created', function(event, message) {
|
|
addUser(message.user, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.settings.users.deleted', function(event, message) {
|
|
deleteUser(message.user.email, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.view.users.updated', function(event, message) {
|
|
if (message.user.email === $scope.user.email) {
|
|
$scope.user = message.user
|
|
updateQuotaBars()
|
|
}
|
|
})
|
|
|
|
$scope.$on('user.settings.devices.created', function(event, message) {
|
|
addDevice(message.device, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.settings.devices.deleted', function(event, message) {
|
|
deleteDevice(message.device.serial, message.timeStamp)
|
|
})
|
|
|
|
$scope.$on('user.settings.devices.updated', function(event, message) {
|
|
updateDevice(message.device, message.timeStamp)
|
|
})
|
|
|
|
initScope()
|
|
}
|