Join the #BuildWithBuildAgent Challenge! Get recognized, earn exclusive swag, and inspire the ServiceNow Community with what you can build using Build Agent.  Join the Challenge.

How to remove button on the service portal?

Arjun Kumar Le1
Tera Contributor

‎01-29-2024 04:24 AM

Hi every one,
I want to hide the button as mentioned on the screen shot.

ArjunKumarLe1_0-1706531195665.png

below is the script of the custom widget

 

 

0 Helpfuls
  • 463 Views
2 REPLIES 2

Arjun Kumar Le1
Tera Contributor

‎01-29-2024 04:27 AM

HTML............

 

<div class="wrapper">
<div class="row">
<div class="col-xs-3 panel panel-default" style="">
<div class="panel-heading" style="border-bottom: 0px">
<span class="panel-title">Alarm responses</span>
<div class="filter state">
${View state}:
<input type="text" ng-model="c.filter.state.display" class="filter-box" ng-focus="c.filter.state.focus = true" ng-blur="c.onBlur($event)">
<span class="caret"></span>
<div class="selection-box" ng-show="c.filter.state.focus == true" ng-mouseover="c.filter.state.selecting = true;" ng-mouseleave="c.filter.state.selecting = false;">
<div class="choice">
<input type="checkbox" ng-model="c.filter.state.selectAll" ng-click="c.toggleFilterElements(c.filter.state.selectAll)">
<span>${All}</span>
</div>
<div ng-repeat="state in c.filter.state.filterStates" ng-init="state.selected = (state.displayValue !== 'Resolved')">
<div class="choice">
<input type="checkbox" ng-model="state.selected" ng-click="c.filterElementChange(state)">
<span>{{state.displayValue}}</span>
</div>
</div>
</div>

</div>
</div>
<div class="panel-body" style="padding:0px">
<div ng-repeat="alarm in c.getAlarmResponses()" style="margin: 0px 3px 0px 0px;">
<div ng-include="'sk_alarm_response_alarm_element.html'" class="guard_element" ng-class="c.getAlarmCSSStyle(alarm)"></div>
</div>
</div>
</div>
<div class="col-xs-7">
<div id="map"></div>
</div>
<div class="col-xs-2 panel panel-default" style="overflow-x:hidden;">
<div class="panel-heading" style="border-bottom: 0px">
<div>
<span class="panel-title">Online users</span><span><input type="text" class="search-box" placeholder="Search route" ng-model="c.guardSearch"></span>
</div>
<div class="user-menu">
<span class="menu-item" ng-class="{'selected' : c.userSelection == 'all'}" ng-click="c.userSelection = 'all'">View all</span>
<span class="menu-item" ng-class="{'selected' : c.userSelection == 'alarm'}" ng-click="c.userSelection = 'alarm'">In alarm ({{c.getUserCountByState('alarm')}})</span>
</div>
</div>
<div class="panel-body" style="padding:0px">
<div ng-repeat="department in c.data.departments" ng-if="c.getNoOfOnlineUsers(department.sys_id.value)">
<p ng-if="department.name.display_value" style="color:white; background-color:#8f96aa; padding: 5px 5px 5px 20px; margin-bottom:0px" class="row"><strong>{{department.name.display_value}} - {{department.code.display_value}}</strong></p>

<div class="row">
<div class="col-xs-12">
<form ng-repeat="user in c.getUserList()"
ng-if="user.department.value == department.sys_id.value"
id="{{user.sys_id.value}}"
ng-click="c.moveToMarker($event)"
ng-mouseenter="c.highlightMarker(user.sys_id.value)"
ng-mouseleave="c.clearMarker(user.sys_id.value)"
dnd-draggable="user"
dnd-type="'user'"
dnd-effect-allowed="copy">

<div ng-include="'sk_alarm_response_guard_element.html'" class="guard_element"
ng-class="{'alarm': c.getState(user.sys_id.value).value=='alarm' || c.getRemainingTime(user.sys_id.value)===0,
'is_on_response' : c.isUserBusy(user)}"
ng-class-even="'even'">
</div>

</form>
</div>
</div>
</div>
</div>
</div>
</div>
</div>

,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,client.......................

function($rootScope, $scope, spUtil, $http, $interval, $timeout, spModal) {
//console.log("Client start "+Date.now())
// <ICONS> 
var manIcon = {
url: "/map_icon_man_default.png",
size: new google.maps.Size(32, 37),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(16, 37)
}
var manIconBusy = {
url: "/map_icon_man_busy.png",
size: new google.maps.Size(32, 37),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(16, 37)
}
var houseIcon = {
url: "/map_icon_house_default.png",
size: new google.maps.Size(32, 37),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(16, 37)
}
var houseFocusIcon = {
url: "/map_icon_house_focus.png", 
size: new google.maps.Size(32, 37),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(16, 37)
}
var manFocusIcon = {
url: "/map_icon_man_focus.png",
size: new google.maps.Size(32, 37),
origin: new google.maps.Point(0, 0),
anchor: new google.maps.Point(16, 37)
}
// </ICONS>
/* widget controller */
var c = this;
c.usersDragged = [];
var personMarkers = {};
var alarmMarkers = {};
var paths = {};
//$scope.users = c.data.users;
//$scope.onlineUsers = c.data.onlineUsers;
/*$scope.alarmResponses = c.data.alarmResponses;
$scope.guardwatchers = c.data.guardwatchers;
$scope.routes = c.data.routes;
$scope.departments = c.data.departments;
 
$scope.alarmResponseStates = c.data.alarmResponseStates;
$scope.guardwatcherStates = c.data.guardwatcherStates;
$scope.alarmResponseConfigurations = c.data.alarmResponseConfigurations;
*/
c.data.isPosting = false;//$scope.data.isPosting = false;
 
var previous = {};
 
//Initialize user filtering as All
c.userSelection = 'all';
console.log(c.data);
 
c.filter = {};
c.filter.state = {selecting : false, selectAll : false, display : 'All', focus : false, filterStates : c.data.general.filterStates};
 
c.isUserBusy = function(user)
{
//console.log("Is user busy??", user, c.data.guardwatchers); //"related_to"
return user.guardwatcher.related_to.value != "";
}
c.getAlarmResponsesForUser = function(user)
{
var responses = [];
for(var k in c.data.alarmResponses)
if(c.data.alarmResponses[k].assigned_to && 
   c.data.alarmResponses[k].assigned_to.value == user.sys_id.value &&
   c.data.alarmResponses[k].active.value.toString() == "true")
responses.push(c.data.alarmResponses[k]);
return responses;
};
 
 
c.getUserIcon = function(user)
{
if(c.isUserBusy(user) == true)
return manIconBusy;
return manIcon;
}
 
c.onBlur = function(event)
{
if(c.filter.state.selecting == true)
return;
else
c.filter.state.focus = false;
}
c.toggleFilterElements = function(selectAll)
{
c.filter.state.selecting = true;
if(selectAll == true)
c.filter.state.display = "All";
else
c.filter.state.display = "None";
 
for(var k in c.filter.state.filterStates)
c.filter.state.filterStates[k].selected = selectAll;
c.filter.state.focus = false;
c.filter.state.selecting = false;
}
 
c.filterElementChange = function(state)
{
c.filter.state.selecting = true;
var selectedFilters = c.filter.state.filterStates.filter(function(e){return e.selected==true;});
 
if(selectedFilters.length == c.filter.state.filterStates.length)
c.filter.state.display = "All";
else if(selectedFilters.length == 0)
c.filter.state.display = "None";
else
c.filter.state.display = "Custom";
 
c.filter.state.selectAll = (selectedFilters.length == c.filter.state.filterStates.length);
 
c.filter.state.focus = false;
c.filter.state.selecting = false;
}
 
c.canSetAlarmState = function(alarm)
{
if(!alarm || !alarm.state || !alarm.state.value)
return false;
var state = parseInt(alarm.state.value);
if(state <= -3 && state >= -6)
return true;
return false;
}
 
c.setAlarmHandler = function(alarm)
{
c.server.get({action : "assign_new_handler", 
  alarm_id : alarm.sys_id.value,
  handler : alarm.newHandler}).then(function(response){
if(response.data.obj)
{
console.log(c.data.alarmResponses);
c.data.alarmResponses[response.data.obj.sys_id.value] = response.data.obj;
}
});
}
 
c.setNewAlarmState = function(alarm)
{
c.server.get({action : "set_new_alarm_state", 
  alarm_id : alarm.sys_id.value}).then(function(response){
if(response.data.obj)
{
c.data.alarmResponses[response.data.obj.sys_id.value] = response.data.obj;
}
});
}
 
c.getAlarmNextValidState = function(alarm)
{
switch(alarm.state.value.toString())
{
case "-3":{ return {value : -4, displayValue : "Accepted"};} //Assigned
case "-4":{ return {value : -5, displayValue : "On the way"};} //Accepted
case "-5":{ return {value : -6, displayValue : "On site"};} //On the way
case "-6":{ return {value : -7, displayValue : "Resolved"};} //On the way
default : {return {value:null, displayValue : ""};}
}
}
 
c.setUserGWState = function(user)
{
console.log(user);
spModal.open({
title: 'Set guard watcher state as OK for user ' + user.name.display_value,
message: 'Please enter a comment.',
input: true,
buttons: [
{label:'✘ ${Cancel}', cancel: true},
{label:'✔ ${OK}', primary: true}
]
//value: c.name
}).then(function(comment) {
if(user.guardwatcher){
c.server.get({action : "set_gw_ok", 
  gw_sys_id : user.guardwatcher.sys_id.value,
  user : user,
  comment : comment}).then(function(response){
console.log("Response ", response);
if(response.data.guardwatchers)
{
for(var k in response.data.guardwatchers)
{
c.data.guardwatchers[k] = response.data.guardwatchers[k];
}
}
});
}
})
 
};
 
c.updateGeoMarkerOpacity = function(geoPosition)
{
var max = parseFloat(c.data.fadeGeoPositionsAfter) * 60 * 60 * 1000;
var dif = new Date() - new Date(geoPosition.location_timestamp.display_value);
 
fadeAmount = 1-(1 / (max / dif));
 
if(fadeAmount < 0)
fadeAmount = 0;
 
geoPosition.opacity = {hsl : "hsl(" + fadeAmount * 90 + ",94%,47%)"}; //Function of changing green to red based on fadeAmount
var ago = "";
var mins = (dif / 60 / 1000);
ago += parseInt(mins / 60) + " h";
ago += " " + parseInt(mins % 60) + " m";
geoPosition.ago =  ago + " ago";
}
 
c.getUserList = function()
{
/*var onlineUsers = [];
if(c.guardSearch && c.guardSearch != "")
{
var searchedUsers = {};
//Find routes matching condition
for(var k in c.data.routes)
{
if(c.data.routes[k].short_description && c.data.routes[k].short_description.display_value.includes(c.guardSearch))
{
//Found a route which matches the search conditions
for(i = 0; i < c.data.routes[k].assignees.length; i++)
{
if(!searchedUsers[c.data.routes[k].assignees[i].value])
searchedUsers[c.data.routes[k].assignees[i].value] = c.data.onlineUsers[c.data.routes[k].assignees[i].value];
}
 
}
}
onlineUsers = Object.values(searchedUsers);
}
else
onlineUsers = Object.values(c.data.onlineUsers);
 
*/
var onlineUsers = Object.values(c.data.onlineUsers);
if(c.userSelection == "all")
{
if(c.guardSearch && c.guardSearch != "")
{
return onlineUsers.filter(function(item){
if(item.routes)
{
for(var k in item.routes)
{
if(item.routes[k].short_description.display_value.toLowerCase().includes(c.guardSearch.toLowerCase()))
return true;
}
}
return false;
});
}
else
return onlineUsers;
}
else
{
return onlineUsers.filter(function(item){
return (c.getState(item.sys_id.value).value=='alarm');
});
}
}
 
c.getUserCountByState = function(state)
{
var onlineUsers = Object.values(c.data.onlineUsers);
if(state == "all")
return onlineUsers.length;
else
{
var filteredList = onlineUsers.filter(function(item){
return (c.getState(item.sys_id.value).value=='alarm');
});
return filteredList.length;
}
}
 
var map;
function initMap(callback) {
// Directions Service API is not active
// var directionsService;
// var directionsRenderer; 
 
// directionsService = new google.maps.DirectionsService();
// directionsRenderer = new google.maps.DirectionsRenderer();
 
var center = {lat: 59.9102339, lng: 10.698260}
map = new google.maps.Map(document.getElementById("map"), {
center: center,
zoom: 8
});
// directionsRenderer.setMap(map);
map.addListener('click', clearShapes);
 
callback();
return true;
}
var initialized = initMap(updateMarkers);
 
initateRecordWatchers();
/*for (var alarmId in $scope.alarmResponses) {
getActivityStream(alarmId);
}*/
c.dragoverCallback = function(index, external, type)
{
if(type=="user")
return true;
return false;
}
 
c.dropCallback = function(index,item,external,type, alarm) {
 
console.log("dropping", index,item,external,type, alarm);
alarm.dropInfo = {user : item};
alarm.expanded = true;
}
 
 
 
 
c.getPositionMarkerOpacity = function()
{
var color = "0.0";
for(var k in c.data.onlineUsers)
{
if(c.data.onlineUsers[k].geoPositions && c.data.onlineUsers[k].geoPositions.last_position)
{
c.updateGeoMarkerOpacity(c.data.onlineUsers[k].geoPositions.last_position);
insertOrUpdatePersonMarker(c.data.onlineUsers[k].sys_id.value, c.data.onlineUsers[k].geoPositions.last_position);
}
}
$timeout(c.getPositionMarkerOpacity, 1*60*1000);
};
 
c.getPositionMarkerOpacity();
 
 
c.assignResponseToUser = function(alarm, user, type)
{
alarm.dropInfo = null;
alarm.expanded = false;
//console.log("Assigning alarm to user", alarm, user);
c.server.get({action:"assign_user_to_response", 
  user : user,
  type : type,
  response : alarm.sys_id.value}).then(function(response){
 
for(var k in response.data.alarmResponses)
{
c.data.alarmResponses[k] = response.data.alarmResponses[k];
}
for(var k in response.data.onlineUsers)
{
c.data.onlineUsers[k] = response.data.onlineUsers[k];
c.updateGeoMarkerOpacity(c.data.onlineUsers[k].geoPositions.last_position);
}
for(var k in response.data.guardwatchers)
{
c.data.guardwatchers[k] = response.data.guardwatchers[k];
}
 
/*var marker = personMarkers[user.sys_id.value];
if (marker) 
marker.setIcon(c.getUserIcon(user));*/
});
}
 
c.getStateWeight = function(state)
{
switch(state)
{
case "-1": return 1000; //New
case "-3": return 700; //Assigned
case "-4": return 600; //Accepted
case "-5": return 500; //On the way
case "-6": return 400; //On site
case "-7": return 800; //Resolved
default : return 0;
}
}
 
c.getAlarmResponses = function()
{
for(var k in c.data.alarmResponses)
{
c.data.alarmResponses[k].weight = c.getStateWeight(c.data.alarmResponses[k].state.value);
}
var alarmResponseArr = Object.values(c.data.alarmResponses);
 
//Check filters
if(!c.filter.state.selectAll)
{
var selectedStates = c.filter.state.filterStates.filter(function(e){return e.selected==true;});
selectedStates = selectedStates.map(function(e){return e.value});
 
alarmResponseArr = alarmResponseArr.filter(function(alarm){
return selectedStates.filter(function(state){
return state.toString() == alarm.state.value;
}).length > 0;
});
}
 
return alarmResponseArr.sort(function(a, b){return b.weight - a.weight});//$scope.alarmResponses.sort(function(a, b){return b.weight - a.weight});
}
 
/*
c.$on('record.updated', function (name, data) {
console.log("broadcast");
console.log(data);
})*/
 
$interval(function() {
var now = Date.now();
for (var alarm in c.data.alarmResponses) {
calculateFollowUp(c.data.alarmResponses[alarm].follow_up, now);
}
for (var guardwatcher in c.data.guardwatchers) {
calculateFollowUp(c.data.guardwatchers[guardwatcher].timeout, now);
}
}, 1000)
// <FUCNTIONS>
c.toggleComments = function (sysId) {
console.log(c.data.alarmResponses[sysId].display_comments);
 
var alarm = c.data.alarmResponses[sysId];
if (alarm) 
{
if(!alarm.activity_stream)
getActivityStream(sysId);
}
c.data.alarmResponses[sysId].display_comments = !c.data.alarmResponses[sysId].display_comments;
}
 
c.toggleAlarmResponse = function (event, sysId) {
c.data.alarmResponses[sysId].expanded = !c.data.alarmResponses[sysId].expanded;
if(c.data.alarmResponses[sysId].expanded == true)
c.moveToMarker(sysId);
}
 
c.getAlarmCSSStyle = function(alarm)
{
var cssClass = [];
if(alarm.follow_up.minutes===0 && alarm.follow_up.seconds===0 || alarm.state.value==-1)
{
cssClass.push('attention');
}
else if( alarm.state.value==-7)
{
cssClass.push('wip');
}
else if(alarm.state.value==-3)
{
cssClass.push('assigned');
}
else
cssClass.push('unread');
 
if(alarm.handler.value != "" && alarm.owner.value!="" && alarm.handler.value != c.data.portal_owner)
cssClass.push("dotted");
return cssClass.join(" ");
}
 
 
c.getNoOfOnlineUsers = function(departmentId) {
var onlineUsers = 0;
//for (var i = 0; i < $scope.users.length; i++) {
var userList = c.getUserList();
for (var i = 0; i < userList.length; i++) {
if(!userList[i].department)
console.log("userList[i].department.value EMPOTY", userList[i]);
if (userList[i].department.value == departmentId) {
onlineUsers++;
}
}
return onlineUsers;
}
 
c.getState = function (userId)
{
for (var guardwatcherId in c.data.guardwatchers)
{
if (c.data.guardwatchers[guardwatcherId].user.value == userId) 
{
if(c.data.guardwatchers[guardwatcherId].type && 
   c.data.guardwatchers[guardwatcherId].type == "mam")
{
//For MAM guard watchers, we only want to display alerts if the
//guard is on a response. Otherwise the MAM OMC will handle the missing alive msg
//in the MAM portal
return (c.data.guardwatchers[guardwatcherId].is_response.value.toString() == "true" || 
c.data.guardwatchers[guardwatcherId].is_response.value.toString() == "1" ?
c.data.guardwatchers[guardwatcherId].state : "");
}
return c.data.guardwatchers[guardwatcherId].state;
}
}
return "";
}
$scope.getRemainingTime = function (userId) {
for (var guardwatcherId in c.data.guardwatchers) {
if (c.data.guardwatchers[guardwatcherId].user.value == userId) {
return c.data.guardwatchers[guardwatcherId].timeout.minutes*60 + c.data.guardwatchers[guardwatcherId].timeout.seconds;
}
}
return "";
}
 
c.getRoute = function (userId) {
//for (var i = 0; i < $scope.routes.length; i++) {
for (var i in c.data.routes) 
{
if(c.data.routes[i].assignees)
{
for(var k in c.data.routes[i].assignees)
{
if (c.data.routes[i].assignees[k].value == userId) 
{
return c.data.routes[i].short_description.display_value;
}
}
}
}
return "";
}
 
c.getGuardwatcherField = function (userId, field) {
for (var guardwatcherId in c.data.guardwatchers) {
if (c.data.guardwatchers[guardwatcherId].user.value == userId) {
return c.data.guardwatchers[guardwatcherId][field];
}
}
return "";
}
 
function getUser(userId) {
/*for (var user in c.data.onlineUsers) {
if (c.data.onlineUsers[user].sys_id.value == userId) {
return c.data.onlineUsers[user];
}
}*/
if(c.data.onlineUsers[userId])
return c.data.onlineUsers[userId];
return null;
}
 
function updateAlarmResponseField(alarmId, fieldName, values) {
c.data.alarmResponses[alarmId][fieldName].value = values.value;
c.data.alarmResponses[alarmId][fieldName].display_value = values.display_value;
c.data.alarmResponses[alarmId][fieldName].displayValue = values.display_value;
for (var index in c.data.onlineUsers) {
for (var k in c.data.onlineUsers[index].alarmResponses) {
var alarmResponse = c.data.onlineUsers[index].alarmResponses[k];
if (alarmResponse.sys_id.value == alarmId) {
alarmResponse[fieldName].value = values.value;
alarmResponse[fieldName].display_value = values.display_value;
alarmResponse[fieldName].displayValue = values.display_value;
}
}
}
}
 
function calculateFollowUp(followUpObj, now) {
if (!followUpObj.epoch) {
followUpObj.minutes = '';
followUpObj.seconds = '';
return;
}
if (!now) {
now = Date.now();
}
var diff = followUpObj.epoch - now;
if (diff <= 0) {
followUpObj.minutes = 0;
followUpObj.seconds = 0;
return;
}
followUpObj.minutes = Math.floor((followUpObj.epoch - now) / (1000 * 60));
followUpObj.seconds = Math.floor(((followUpObj.epoch - now) % (1000 * 60)) / 1000);
return;
}
 
function updateMarkers() {
for (var id in personMarkers) {
var user = getUser(id);
if (!user) {
personMarkers[id].setMap(null);
delete personMarkers[id];
if (paths[id]) {
for (var i = 0; i < paths[id].length; i++) {
paths[id][i].setMap(null);
}
delete paths[id];
}
}
}
 
for (var id in alarmMarkers) {
if (!c.data.alarmResponses[id]){
alarmMarkers[id].setMap(null);
delete alarmMarkers[id]
}
}
 
for (var index in c.data.onlineUsers) {
if (c.data.onlineUsers[index].geoPositions && c.data.onlineUsers[index].geoPositions.positions.length) 
{
c.updateGeoMarkerOpacity(c.data.onlineUsers[index].geoPositions.last_position);
insertOrUpdatePersonMarker(c.data.onlineUsers[index].sys_id.value, c.data.onlineUsers[index].geoPositions.last_position);
}
}
 
for (var alarm in c.data.alarmResponses) {
insertOrUpdateAlarmMarker(alarm);
}
}
 
function refreshData() {
console.log("REFRESH CALLED!");
c.server.refresh().then(function(response) {
console.log(response.data);
c.data.onlineUsers = response.data.onlineUsers;
for (var alarm in c.data.alarmResponses) {
if (c.data.alarmResponses[alarm].expanded) {
if (response.data.alarmResponses[alarm]) {
response.data.alarmResponses[alarm].expanded = true
}
}
}
c.data.alarmResponses = response.data.alarmResponses;
c.data.guardwatchers = response.data.guardwatchers;
 
updateMarkers();
/*for (var alarmId in $scope.alarmResponses) {
getActivityStream(alarmId);
}*/
})
}
 
function hasActiveGuardwatcher(user) {
for (var gwId in c.data.guardwatchers) {
if (c.data.guardwatchers[gwId].user.value == user) {
return true;
}
}
return false;
}
 
function getActivityStream(alarmId) {
var options = {
active: true,
table: 'x_nokas_sim_res_alarm_response',
sys_id: alarmId,
includeExtended: true,
hideAttachmentBtn: false,
title: "Comments",
use_dynamic_placeholder: true,
btnLabel: "Post"
}
spUtil.get("widget-ticket-conversation-sim-res", options).then(function(response) {
var alarm = c.data.alarmResponses[alarmId];
if (alarm) {
alarm.activity_stream = response;
}
});
}
// </FUNCTIONS>
// <RECORD WATCHERS>
c.onGuardwatcherChange = function(response) {
console.log(response.data);
var sysId = response.data.sys_id;
 
if (response.data.operation == "insert" || response.data.operation == "update") {
if (!c.data.guardwatchers[sysId]) {
refreshData();
}
else {
 
// Update values
response.data.changes.forEach(function(field) {
if (c.data.guardwatchers[sysId][field]) {
c.data.guardwatchers[sysId][field].value = response.data.record[field].value;
c.data.guardwatchers[sysId][field].display_value = response.data.record[field].display_value;
c.data.guardwatchers[sysId][field].displayValue = response.data.record[field].display_value;
}
});
 
c.data.onlineUsers[c.data.guardwatchers[sysId].user.value].guardwatcher = c.data.guardwatchers[sysId];
 
if(response.data.changes.includes('timeout')) {
c.data.guardwatchers[sysId].timeout.epoch = new Date(c.data.guardwatchers[sysId].timeout.display_value).getTime();
}
if (response.data.changes.includes('state') && response.data.record.state.value == 'complete') {
refreshData();
}
if (response.data.changes.includes('related_to'))
{
insertOrUpdatePersonMarker(c.data.guardwatchers[sysId].user.value);
/*var user = c.data.guardwatchers[sysId].user;
if (user) {
user.sys_id = {value : user.value};
user.guardwatcher = c.data.guardwatchers[sysId];
var marker = personMarkers[user.sys_id.value];
if (marker) {
c.clearMarker(user.value);
marker.setIcon(c.getUserIcon(user));
/*if(response.data.record.related_to.value == "")
marker.setZIndex(0);
else
marker.setZIndex(10);* /
}
}*/
}
}
}
else if (response.data.operation == "delete") {
refreshData();
}
}
 
function initateRecordWatchers() {
spUtil.recordWatch($scope, "x_nokas_sim_res_alarm_response", "", function(response) {
c.server.get({action:"refresh_alarm_response", response : response.data.sys_id }).then(function(res){
c.data.alarmResponses[response.data.sys_id] = res.data.alarmResponses[response.data.sys_id];
});
//$scope.$broadcast('record.updated', response.data);
/*console.log(response.data);
var sysId = response.data.sys_id;
 
if (response.data.operation == "insert" || response.data.operation == "update") {
if (!$scope.alarmResponses[sysId]) {
refreshData();
}
else {
//$rootScope.$broadcast('record.updated', {table_name: 'x_nokas_sim_res_alarm_response', sys_id: sysId});
//$scope.$broadcast('record.updated', {table_name: 'x_nokas_sim_res_alarm_response', sys_id: sysId});
//$scope.$emit('record.updated', {table_name: 'x_nokas_sim_res_alarm_response', sys_id: sysId});
// Update values
response.data.changes.forEach(function(field) {
if ($scope.alarmResponses[sysId][field]) {
updateAlarmResponseField(sysId, field, response.data.record[field]);
}
});
if(response.data.changes.includes('follow_up')) {
$scope.alarmResponses[sysId].follow_up.epoch = new Date($scope.alarmResponses[sysId].follow_up.display_value).getTime();
}
if (response.data.changes.includes('active') && $scope.alarmResponses[sysId].active.value !== "true") {
refreshData();
}
getActivityStream(sysId);
}
}
else if (response.data.operation == "delete") {
refreshData();
}*/
});
spUtil.recordWatch($scope, "x_nokas_sim_res_sim_guardwatcher", "", function(response){
c.onGuardwatcherChange(response)
});
spUtil.recordWatch($scope, "x_nokas_mam_guardwatcher", "", function(response){
c.onGuardwatcherChange(response)
});
spUtil.recordWatch($scope, "geo_history", "", function(response) {
console.log(response.data);
var sysId = response.data.sys_id;
 
if (response.data.operation == "insert") {
var key = response.data.record.user.value;
// Check if a Guardwatcher is active
if (hasActiveGuardwatcher(key)) {
var geoPosition = {sys_id: {
display_value: response.data.sys_id,
value: response.data.sys_id
}};
response.data.changes.forEach(function(field) {
geoPosition[field] = response.data.record[field];
});
var user = getUser(key);
if (user) {
user.geoPositions.last_position = geoPosition;
user.geoPositions.positions.push(geoPosition);
c.updateGeoMarkerOpacity(geoPosition);
insertOrUpdatePersonMarker(key,geoPosition);
userExists = true;
}
/*else {
c.data.onlineUsers.push({
user: response.data.record.user,
geoPositions: []
});
}*/
}
}
});
}
 
 
// </RECORD WATCHERS>
// <MAP FUNCTIONS>
c.moveToMarker = function(alarmId) {
// get Alarm object
var alarm = c.data.alarmResponses[alarmId];
var marker;
if (alarm) {
// set unread to false
c.data.alarmResponses[alarmId].unread = false;
// get marker
marker = alarmMarkers[alarmId];
if (marker) {
map.panTo(marker.getPosition());
//map.setZoom(12);
}
}
else {
// If paning to a person icon
var user = getUser(alarmId);
if (user) {
marker = personMarkers[user.sys_id.value];
if (marker) {
map.panTo(marker.getPosition());
}
}
}
}
 
c.highlightMarker = function (sysId) {
var alarm = c.data.alarmResponses[sysId] //[event.currentTarget.id];
if (alarm) {
marker = alarmMarkers[sysId];//event.currentTarget.id];
if (marker) {
marker.setIcon(houseFocusIcon);
marker.setZIndex(10);
}
}
else {
// person marker
var user = getUser(sysId) //(event.currentTarget.id);
if (user) {
marker = personMarkers[user.sys_id.value];
if (marker) {
marker.setIcon(manFocusIcon);
marker.setZIndex(10);
}
}
}
}
 
c.clearMarker = function (sysId) {
//console.log(sysId);
var alarm = c.data.alarmResponses[sysId]; //[event.currentTarget.id];
if (alarm) {
marker = alarmMarkers[sysId];//event.currentTarget.id];
if (marker) {
marker.setIcon(houseIcon);
marker.setZIndex(0);
}
}
else {
// person marker
var user = getUser(sysId);//event.currentTarget.id)
if (user) {
marker = personMarkers[user.sys_id.value];
if (marker) {
marker.setIcon(c.getUserIcon(user));
marker.setZIndex(0);
}
}
}
}
 
function clickOnPersonMarker(marker, map, type, id) {
console.log(marker, map, type);
var content = null;
if(type=="person")
{
if(c.data.onlineUsers[id] && c.data.onlineUsers[id].geoPositions)
{
var user = c.data.onlineUsers[id];
content = "<div style='padding:10px'>";
content += "<h4>" + user.name.display_value + "</h4>";
content += "<div class='marker-heading'>Last position (" + user.geoPositions.last_position.ago + "):</div>";
if(user.geoPositions.last_position.location)
content += user.geoPositions.last_position.location.display_value + "</br>";
content += "(lat: " + user.geoPositions.last_position.latitude.display_value + ", ";
content += "long: " + user.geoPositions.last_position.longitude.display_value + ")";
 
 
var gwState = c.getGuardwatcherField(user.sys_id.value, 'state');
if(gwState)
content += "<div class='marker-value-pair'><span class='marker-heading'>Guard watcher state:</span><span class='marker-value'>" + 
gwState.display_value + 
"</span></div>";
 
var route = c.getRoute(user.sys_id.value);
if(route)
content += "<div class='marker-value-pair'><span class='marker-heading'>On route:</span><span class='marker-value'>" + 
route + "</span></div>";
var alarms = c.getAlarmResponsesForUser(user);
if(alarms && alarms.length > 0)
{
content += "<div class='marker-value-pair'><span class='marker-heading'>On alarm response(s):</span>";
for(i = 0; i < alarms.length; i++)
content += "<div><a href='" + alarms[i].url +"' target='_blank'>" + alarms[i].number.display_value + " (" + alarms[i].job_no.display_value + ")</a></div>";
content += "</div>";
}
 
content += '</div>';
}
}
if(type=="alarm")
{
if(c.data.alarmResponses[id])
{
content = "<div style='padding:10px'>"
content += "<h4>" + "<a href='" + c.data.alarmResponses[id].url +"' target='_blank'>" +
c.data.alarmResponses[id].number.display_value + "</a></h4>"
content += "Job no: " + c.data.alarmResponses[id].job_no.display_value + "<br>";
content += "State: " + c.data.alarmResponses[id].state.display_value;
content += "<h6>Location:</h6>";
content += c.data.alarmResponses[id].location.display_value;
content += '</div>';
}
}
 
if(content)
{
if (c.infowindow) {
c.infowindow.close();
}
 
c.infowindow = new google.maps.InfoWindow({
content: content
});
c.infowindow.open(map,marker);
}
 
/*var infowindow = new google.maps.InfoWindow({
content: 'Latitude: ' + location.lat() +
'<br>Longitude: ' + location.lng()
});
infowindow.open(map,marker);
*/
 
/*if (this.type == "user" || this.type == "alarm") {
if (!paths[this.id]) {
paths[this.id] = [];
if (this.type == "user") {
showGeopositionHistory(this.id);
showDestination(this.id);
}
else if (this.type == "alarm") {
showResponders(this.id)
}
}
}
return;
*/
}
 
function clearShapes(event) {
for (var path in paths) {
for (var i = 0; i < paths[path].length; i++) {
paths[path][i].setMap(null);
}
delete paths[path];
}
}
 
function insertOrUpdatePersonMarker(userId, geoPosition) {
var user = getUser(userId);
if (!user || !user.geoPositions.last_position) {
return;
}
//var lastIndex = user.geoPositions.length - 1
var position = {lat: Number(user.geoPositions.last_position.latitude.value), lng: Number(user.geoPositions.last_position.longitude.value)};
if (personMarkers[userId]) {
personMarkers[userId].setPosition(position);
personMarkers[userId].setIcon(c.getUserIcon(user));
if (paths[userId]) {
// reset path
for (var i = 0; i < paths[userId].length; i++) {
paths[userId][i].setMap(null);
}
delete paths[userId];
 
paths[userId] = [];
showGeopositionHistory(userId);
showDestination(userId);
}
}
else {
 
var marker = new google.maps.Marker({
position: position,
map: map,
title: user.name.display_value, 
icon: c.getUserIcon(user), 
type: "user",
id: userId
});
marker.addListener("click", function(){clickOnPersonMarker(marker,map,"person",userId);})
personMarkers[userId] = marker;
}
//if(geoPosition && geoPosition.opacity)
// personMarkers[userId].setOpacity(geoPosition.opacity.value);
return personMarkers[userId]
}
 
function insertOrUpdateAlarmMarker (alarmResponseId) {
var position = {lat: Number(c.data.alarmResponses[alarmResponseId].location.latitude), lng: Number(c.data.alarmResponses[alarmResponseId].location.longitude)};
if (!alarmMarkers[alarmResponseId]) {
var marker = new google.maps.Marker({
position: position,
map: map,
title: c.data.alarmResponses[alarmResponseId].number.display_value, 
icon: houseIcon, 
type: "alarm",
id: alarmResponseId
});
marker.addListener("click", function(){clickOnPersonMarker(marker,map,"alarm",alarmResponseId);})
alarmMarkers[alarmResponseId] = marker;
}
else {
alarmMarkers[alarmResponseId].setPosition(position);
}
return alarmMarkers[alarmResponseId];
}
 
function showGeopositionHistory(userId) {
var user = getUser(userId);
if (user) {
var geolocationHistory = [];
for (var i = 0; i < user.geoPositions.length ; i++) {
var latLng = { lat: Number(user.geoPositions[i].latitude.value), lng: Number(user.geoPositions[i].longitude.value) };
geolocationHistory.push(latLng)
}
if (geolocationHistory.length > 1) {
var geolocationPath = new google.maps.Polyline({
path: geolocationHistory,
geodesic: true,
strokeColor: "#FF0000",
strokeOpacity: 1.0,
strokeWeight: 2, 
type: 'history'
});
 
geolocationPath.setMap(map);
paths[userId].push(geolocationPath);
}
}
return;
}
 
function showDestination(userId) {
var user = getUser(userId);
if (user) {
var lastPosition = user.geoPositions[user.geoPositions.length-1];
if(!lastPosition)
return;
var start = {lat: Number(lastPosition.latitude.value), lng: Number(lastPosition.longitude.value)};
var destinations = [];
for (var alarm in c.data.alarmResponses) {
if (c.data.alarmResponses[alarm].assigned_to.value == userId) {
console.log(c.data.alarmResponses[alarm].location.latitude)
var latLng = {lat: Number(c.data.alarmResponses[alarm].location.latitude), lng: Number(c.data.alarmResponses[alarm].location.longitude)};
if (!Number.isNaN(latLng.lat) && !Number.isNaN(latLng.lng)) {
destinations.push(latLng);
}
}
}
for (var i = 0; i < destinations.length; i++) {
var geolocationPath = new google.maps.Polyline({
path: [start, destinations[i]],
geodesic: true,
strokeColor: "#0000FF",
strokeOpacity: 1.0,
strokeWeight: 2,
type: 'destination'
});
geolocationPath.setMap(map);
paths[userId].push(geolocationPath);
}
}
return;
}
 
function showResponders (alarmId) {
if (c.data.alarmResponses[alarmId]) {
var start = {lat: Number(c.data.alarmResponses[alarmId].location.latitude), lng: Number(c.data.alarmResponses[alarmId].location.longitude)};
if (Number.isNaN(start.lat) || Number.isNaN(start.lng)) {
return;
}
var responders = c.data.alarmResponses[alarmId].assigned_to.value + ',' + c.data.alarmResponses[alarmId].additional_assignee_list.value;
console.log(responders);
var respondersArr = responders.split(',')
var destinations = [];
for (var k in respondersArr) {
var responder = respondersArr[k];
var user = getUser(responder);
if (user) {
var lastPosition = user.geoPositions[user.geoPositions.length-1];
var latLng = {lat: Number(lastPosition.latitude.value), lng: Number(lastPosition.longitude.value)};
if (!Number.isNaN(latLng.lat) && !Number.isNaN(latLng.lng)) {
destinations.push(latLng);
}
}
}
for (var i = 0; i < destinations.length; i++) {
var geolocationPath = new google.maps.Polyline({
path: [start, destinations[i]],
geodesic: true,
strokeColor: "#0000FF",
strokeOpacity: 1.0,
strokeWeight: 2,
type: 'destination'
});
geolocationPath.setMap(map);
paths[alarmId].push(geolocationPath);
}
}
return;
}
// </MAP FUNCTIONS>
}
............................SERVER,,,,,,,,,,,,,,,,,,,,,,

(function() {
var instance = gs.getProperty('glide.servlet.uri');
 
var scriptUtils = new x_nokas_sim_res.SimResponseUtils();
data.guardwatchers = {};
data.onlineUsers = {};
data.alarmResponses = {};
data.routes = {};
data.portal_owner = options.portal_owner;
var user_query = null;
 
data.fadeGeoPositionsAfter = gs.getProperty("x_nokas_sim_res.geo_positions.fade.marker") || 0.5; //half hour is default
data.general = {};
 
data.general.filterStates = [{value : -1, displayValue : "New"},
{value : -3, displayValue : "Assigned"},
{value : -4, displayValue : "Accepted"},
//{value : -5, displayValue : "On the way"},
{value : -6, displayValue : "On site"},
{value : -7, displayValue : "Resolved"}];
 
if (input) 
{
if(input.action)
{
var grAlarm = new GlideRecord('x_nokas_sim_res_alarm_response');
switch(input.action)
{
case "assign_user_to_response":
{
if( grAlarm.get(input.response) )
{
if(!input.type) //Switch or clean assign
{
if(input.user.guardwatcher)
grAlarm.assigned_to_guard = input.user.guardwatcher.sys_id.value;
 
if(grAlarm.state > -4) //If the alarm response current state is New or Assigned
grAlarm.state = -3; //Assigned
 
grAlarm.update();
}
else if(input.type == "additional")
{
var currentAdditionalList = grAlarm.additional_guard_list.toString();
currentAdditionalList = currentAdditionalList.split(",");
if(input.user.type && input.user.type == "mam" && input.user.guardwatcher)
{
if(currentAdditionalList.indexOf(input.user.guardwatcher.sys_id.value) < 0)
{
currentAdditionalList.push(input.user.guardwatcher.sys_id.value);
grAlarm.additional_guard_list = currentAdditionalList.join(",");
grAlarm.update();
}
}
}
if(input.user.type && input.user.type == "mam")
{
if(input.user.guardwatcher)
{
var grGW = new GlideRecord("x_nokas_mam_guardwatcher");
grGW.get(input.user.guardwatcher.sys_id.value);
grGW.related_to_table = grAlarm.sys_class_name.toString();
grGW.related_to=grAlarm.sys_id.toString();
grGW.update();
}
}
 
 
 
 
data.alarmResponses[input.response] = createAlarmResponseObject(grAlarm);
 
getGuardwatchers('x_nokas_sim_res_sim_guardwatcher',
'state!=' + x_nokas_guardwatch.GuardwatcherState.COMPLETE + 
"^user=" + input.user.sys_id.value,
'sn');
getGuardwatchers('x_nokas_mam_guardwatcher',
'categoryINalive,wait_on_duty^stateINok,warning,alarm^guard_available_for_response=true'+ 
"^user=" + input.user.sys_id.value,
'mam');
 
getGeoHistory(data.onlineUsers);
return data;
}
}
case "refresh_alarm_response":
{
if( grAlarm.get(input.response) )
{
if (grAlarm.owner == options.portal_owner || grAlarm.handler == options.portal_owner) 
data.alarmResponses[input.response] = createAlarmResponseObject(grAlarm);
 
return data;
}
}
case "set_gw_ok":
{
var gr = new GlideRecord("x_nokas_guardwatch_guardwatcher");
if(gr.get(input.gw_sys_id))
{
new x_nokas_mam.MAMGuardwatchUtils().agentOverrideAliveMessage(gr, input.comment);
getGuardwatchers('x_nokas_sim_res_sim_guardwatcher',
'state!=' + x_nokas_guardwatch.GuardwatcherState.COMPLETE + 
"^user=" + input.user.sys_id.value,
'sn');
getGuardwatchers('x_nokas_mam_guardwatcher',
'categoryINalive,wait_on_duty^stateINok,warning,alarm^guard_available_for_response=true'+ 
"^user=" + input.user.sys_id.value,
'mam');
 
return data;
}
}
case "assign_new_handler":
{
grAlarm = new GlideRecord("x_nokas_sim_res_alarm_response");
if(input.alarm_id && grAlarm.get(input.alarm_id))
{
grAlarm.handler = input.handler.value;
grAlarm.update();
data.obj = createAlarmResponseObject(grAlarm);
}
return data;
}
case "set_new_alarm_state":
{
grAlarm = new GlideRecord("x_nokas_sim_res_alarm_response");
if(input.alarm_id && grAlarm.get(input.alarm_id))
{
var newState;
 
switch(grAlarm.state.toString())
{
case "-3":{ newState = -4; break;} //Assigned
case "-4":{ newState = -5; break;} //Accepted
case "-5":{ newState = -6; break;} //On the way
case "-6":{ newState = -7; break;} //On the way
default : {newState = null;}
}
if(newState != null)
{
 
grAlarm.state = newState;
grAlarm.update();
}
data.obj = createAlarmResponseObject(grAlarm);
}
return data;
 
}
}
}
}
// Get all online users
//var onlineUsers = [];
 
//var users = [];
 
getGuardwatchers('x_nokas_sim_res_sim_guardwatcher',
'state!=' + x_nokas_guardwatch.GuardwatcherState.COMPLETE + 
(user_query ? "^user=" + user_query : ""),
'sn');
getGuardwatchers('x_nokas_mam_guardwatcher',
'categoryINalive,wait_on_duty^stateINok,warning,alarm^guard_available_for_response=true'+ 
(user_query ? "^user=" + user_query : ""),
'mam');
 
// Get their last known position
 
getGeoHistory(data.onlineUsers);
 
// Get all active Alarm responses
 
data.alarmResponses = getAlarmResponses((user_query ? "assigned_to=" + user_query : ""));
if(options.handler_query && options.handler_query != "")
data.alarmHandlers = getAlarmHandlers();
// Get WIP security routes
getRoutes(data.onlineUsers);
 
// Get departments
 
data.departments = getDepartments();
 
function getAlarmHandlers()
{
var alarmHandlers = [];
var grAlarmHandler = new GlideRecord("sys_user_group");
grAlarmHandler.addEncodedQuery(options.handler_query);
grAlarmHandler.query();
while(grAlarmHandler.next())
{
alarmHandlers.push({value : grAlarmHandler.sys_id.toString(), displayValue : grAlarmHandler.getDisplayValue()});
}
return alarmHandlers;
}
 
 
function getDepartments()
{
var departmentFields = ['sys_id','name','code'];
var departments = [];
var emptyObj = {};
for (var l = 0; l < departmentFields.length; l++) {
emptyObj[departmentFields[l]] = {value: "", display_value: ""}
}
departments.push(emptyObj);
var departmentGr = new GlideRecord('cmn_department');
departmentGr.addQuery('u_type', 'Department');
departmentGr.addQuery('u_active', true);
departmentGr.orderBy('name');
departmentGr.query();
while (departmentGr.next()) {
var departmentObj = {};
$sp.getRecordElements(departmentObj, departmentGr, departmentFields.join(','));
departments.push(departmentObj);
}
return departments;
}
 
function getRoutes (users)
{
//var routes = {};
var route = new GlideRecord('x_nokas_security_route');
route.addQuery('state', '2');
route.addActiveQuery();
route.addQuery('assigned_toIN' + Object.keys(users).join(','));
route.query();
 
while (route.next()) {
var routeObject = {};
//$sp.getRecordElements(routeObject, route, "sys_id,short_description,route_template,state");
 
routeObject.sys_id = {value : route.sys_id.toString(), display_value : route.sys_id.toString()};
routeObject.short_description = {value : route.short_description.toString(), display_value : route.short_description.toString()};
routeObject.state = {value : route.state.toString(), display_value : route.state.getDisplayValue()};
 
if(!route.assigned_to.nil())
{
routeObject.assignees = [{sys_id : route.assigned_to.sys_id.toString(),
  value  : route.assigned_to.sys_id.toString(),
  display_value : route.getDisplayValue()}];
if(data.onlineUsers[route.assigned_to.sys_id.toString()])
{
if(!data.onlineUsers[route.assigned_to.sys_id.toString()].routes)
data.onlineUsers[route.assigned_to.sys_id.toString()].routes = {};
if(!data.onlineUsers[route.assigned_to.sys_id.toString()].routes[route.sys_id.toString()])
data.onlineUsers[route.assigned_to.sys_id.toString()].routes[route.sys_id.toString()] = routeObject;
}
}
else
routeObject.assignees = [];
data.routes[route.sys_id.toString()] = routeObject;
}
}
 
function getAlarmResponses(query)
{
var alarmResponse = new GlideRecordSecure('x_nokas_sim_res_alarm_response');
alarmResponse.addActiveQuery();
if(query && query != "")
alarmResponse.addEncodedQuery(query);
//if(options.portal_owner)
// alarmResponse.addEncodedQuery('owner=' + options.portal_owner + '^ORhandler=' + options.portal_owner);if(options.alarm_query)
alarmResponse.addEncodedQuery(options.alarm_query);
alarmResponse.addNotNullQuery('location');
alarmResponse.query();
 
var alarmResponses = {};
while(alarmResponse.next()) {
var alarmResObj = createAlarmResponseObject(alarmResponse);
alarmResponses[alarmResponse.getUniqueValue()] = alarmResObj;
//if (!alarmResponse.assigned_to.nil()) {
// var assignedTo = alarmResponse.getValue('assigned_to');
/*for (var j = 0; j < users.length; j++) {
if (users[j].sys_id.value == assignedTo) {
users[j].alarmResponses.push(alarmResObj);
}
}*/
/*var user = data.onlineUsers[assignedTo];
if(!user)
continue;
user.alarmResponses.push(alarmResObj);*/
 
}
 
return alarmResponses;
}
 
function getGuardwatchers(table, query, type)
{
var guardwatcher;
if(table == "x_nokas_mam_guardwatcher") //Quick and dirty to avoid ACLs as the setup is complex for MAM (A Guardwatcher references an MAM assignment which has a reference to an Activity profile which in turn has references to a Guard object or RS Route)...
guardwatcher = new GlideRecord(table);
else
guardwatcher = new GlideRecordSecure(table);
 
guardwatcher.addEncodedQuery(query + '^' + options.guard_query);
guardwatcher.query();
while (guardwatcher.next()) {
var guardwatcherId = guardwatcher.getUniqueValue();
data.guardwatchers[guardwatcherId] = {};
$sp.getRecordElements(data.guardwatchers[guardwatcherId], guardwatcher, "sys_id,user,state,timeout,duty_phone_number");
if (data.guardwatchers[guardwatcherId].timeout && data.guardwatchers[guardwatcherId].timeout.value) {
var timeoutGdt = new GlideDateTime(data.guardwatchers[guardwatcherId].timeout.value);
data.guardwatchers[guardwatcherId].timeout.epoch = timeoutGdt.getNumericValue();
}
data.guardwatchers[guardwatcherId].type = type;
// Add user to list of online users
/*for (var i = 0; i < onlineUsers.length; i++) {
if (data.onlineUsers[i] === guardwatcherUser.getUniqueValue()) {
addUser = false;
break;
}
}*/
if (!guardwatcher.user.nil() &&
!data.onlineUsers[guardwatcher.user.sys_id.toString()]) {
var guardwatcherUser = guardwatcher.user.getRefRecord();
var userObj = {};
$sp.getRecordElements(userObj, guardwatcherUser, 'sys_id,name,mobile_phone,employee_number,department');
data.onlineUsers[guardwatcher.user.sys_id.toString()] = userObj;
userObj.geoPositions = { last_position : "", positions : []};
userObj.alarmResponses = [];
userObj.guardwatcher = data.guardwatchers[guardwatcherId];
userObj.url = instance+guardwatcherUser.getTableName()+".do?sys_id="+guardwatcherUser.getUniqueValue();
userObj.type = type;
//users.push(userObj);
}
if(table == "x_nokas_mam_guardwatcher") //MAM specific logic
{
if(guardwatcher.source && !guardwatcher.source.nil())
{
if(guardwatcher.source.activity_profile && !guardwatcher.source.activity_profile.nil())
{
var routeInfo = getMAMRouteInfo(guardwatcher.source.activity_profile.getRefRecord());
 
if(routeInfo)
{
routeInfo.short_description = routeInfo.name;
if(!routeInfo.assignees)
routeInfo.assignees = [];
routeInfo.assignees.push({value : guardwatcher.user.sys_id.toString(),
  display_value : guardwatcher.user.getDisplayValue()});
 
if(routeInfo.sys_id)
{
data.routes[routeInfo.sys_id.value] = routeInfo;
if(data.onlineUsers[guardwatcher.user.sys_id.toString()])
{
if(!data.onlineUsers[guardwatcher.user.sys_id.toString()].routes)
data.onlineUsers[guardwatcher.user.sys_id.toString()].routes = {};
data.onlineUsers[guardwatcher.user.sys_id.toString()].routes[routeInfo.sys_id.value] = routeInfo;
}
}
 
}
}
}
//data.guardwatchers[guardwatcherId].is_response = $sp.getField(guardwatcher, "is_response");
data.guardwatchers[guardwatcherId].is_response = {value : guardwatcher.is_response.toString(), 
  display_value : guardwatcher.is_response.toString()};
data.guardwatchers[guardwatcherId].related_to = {value : guardwatcher.related_to.toString(), 
display_value : guardwatcher.related_to.getDisplayValue()};
}
}
}
 
function createAlarmResponseObject(alarmResponse) {
var alarmResponseObj = {};
var alarmResponseFields = ['sys_id', 'number', 'assignment_group', 'assigned_to', 'owner', 'handler','additional_assignee_list', 'location', 'state', 'sys_updated_on', 'sys_class_name', 'active', 'follow_up', 'job_no'];
var alarmResponseId = alarmResponse.getUniqueValue();
$sp.getRecordElements(alarmResponseObj, alarmResponse, alarmResponseFields.join(","));
var alarmURL = alarmResponse.getValue('sys_class_name')+".do?sys_id="+alarmResponseId;
alarmResponseObj.url = instance+alarmURL+"&sysparm_stack="+alarmResponse.getValue('sys_class_name')+"_list.do";
 
alarmResponseObj.location.latitude = Number(alarmResponse.location.latitude.toString());
alarmResponseObj.location.longitude = Number(alarmResponse.location.longitude.toString());
 
alarmResponseObj.assigned_to_guard = (alarmResponse.assigned_to_guard.nil() ? "" : alarmResponse.assigned_to.getDisplayValue());
 
 
if(!alarmResponse.location.nil() && !alarmResponse.location.account.nil())
alarmResponseObj.account = alarmResponse.location.account.getDisplayValue();
 
if (alarmResponseObj.follow_up && alarmResponseObj.follow_up.value) {
var followUpGdt = new GlideDateTime(alarmResponseObj.follow_up.value);
alarmResponseObj.follow_up.epoch = followUpGdt.getNumericValue();
}
for (var field in alarmResponseObj) {
var fieldObj = alarmResponseObj[field];
if (fieldObj.display_value) {
fieldObj.displayValue = fieldObj.display_value;
}
if (fieldObj.type == "reference") {
var referenceQualifier = scriptUtils.getReferenceQualifier("x_nokas_sim_res_alarm_response", field);
alarmResponseObj[field].referenceQualifier = referenceQualifier
}
}
/*
if(!alarmResponse.handler.nil())
alarmResponseObj.handler = alarmResponse.handler.sys_id.toString();
else
alarmResponseObj.handler = {}; */
return alarmResponseObj;
}
 
function getGeoHistory(users)
{
var hours = 8;
var startDateTime = new GlideDateTime();
startDateTime.addSeconds((hours*60*60)*-1);
 
var geoHistory = new GlideRecord('geo_history');
var query = 'userIN' + Object.keys(users).join(',');
geoHistory.addQuery(query);
//geoHistory.addQuery('sys_created_onRELATIVEGT@dayofweek@ago@1')
//geoHistory.addEncodedQuery('location_timestampONLast 2 hours@javascript&colon;gs.beginningOfLast2Hours()@javascript&colon;gs.endOfLast2Hours()');
geoHistory.addEncodedQuery("location_timestamp>javascript&colon;gs.dateGenerate('" + startDateTime.getDate().getDisplayValue()+"','"+ startDateTime.getTime().getDisplayValue() +"')");
geoHistory.addEncodedQuery("userISNOTEMPTY");
geoHistory.orderBy('user');
geoHistory.orderByDesc('location_timestamp');
geoHistory.query();
 
 
var geolocationHistory = {};
var geolocationHistoryFields = ['sys_id','user', 'latitude', 'longitude', 'location_timestamp', 'location'];
var previousUser;
//var user;
while (geoHistory.next()) {
//var currentUser = geoHistory.getValue('user');
/*if (currentUser != previousUser) {
for (var k = 0; k < users.length; k++) {
if (users[k].sys_id.value == currentUser) {
user = users[k];
console.log("User " + currentUser + " - geo " + new GlideDateTime().getDisplayValue());
}
}
}*/
if(!geoHistory.user.nil() && data.onlineUsers[geoHistory.user.sys_id.toString()])
{
var user = data.onlineUsers[geoHistory.user.sys_id.toString()];
var geoHistoryRecord = {};
$sp.getRecordElements(geoHistoryRecord, geoHistory, geolocationHistoryFields.join(","));
var geoHistoryId = geoHistory.getUniqueValue();
if(user.geoPositions.last_position == "")
user.geoPositions.last_position = geoHistoryRecord;
user.geoPositions.positions.push(geoHistoryRecord);
//previousUser = currentUser;
}
}
}
 
function getMAMRouteInfo(grActivityProfile)
{
var routeInfo = {};
if(grActivityProfile.profile_type == "mobile")
{
if(!grActivityProfile.route.nil())
{
if(data.routes[grActivityProfile.route.sys_id.toString()])
return data.routes[grActivityProfile.route.sys_id.toString()];
/*$sp.getRecordElements(routeInfo, 
  grActivityProfile.route.getRefRecord(),
  "sys_id,short_description,assigned_to,state,name");
*/
routeInfo.sys_id = {value : grActivityProfile.route.sys_id.toString(), 
display_value : grActivityProfile.route.sys_id.toString()};
routeInfo.name = {value : grActivityProfile.route.name.toString(), 
  display_value : grActivityProfile.route.getDisplayValue()};
}
}
else// if(grActivityProfile.profile_type == "stationary")
{
if(data.routes[grActivityProfile.sys_id.toString()])
return data.routes[grActivityProfile.sys_id.toString()];
/*$sp.getRecordElements(routeInfo, 
  grActivityProfile,
  "sys_id,name");*/
routeInfo.sys_id = {value : grActivityProfile.sys_id.toString(), 
display_value : grActivityProfile.sys_id.toString()};
routeInfo.name = {value : grActivityProfile.name.toString(), 
  display_value : grActivityProfile.getDisplayValue()};
 
}
 
return routeInfo;
}
})();
 
0 Helpfuls

Arjun Kumar Le1
Tera Contributor
In response to Arjun Kumar Le1

‎01-29-2024 04:44 AM

can any one help me on it

0 Helpfuls