Merge branch 'master' into master

1 files changed, 141 insertions, 294 deletions

diff --git a/src/org/traccar/database/DeviceManager.java b/src/org/traccar/database/DeviceManager.java
index f2a2dd565..1eb90b7eb 100644
--- a/src/org/traccar/database/DeviceManager.java
+++ b/src/org/traccar/database/DeviceManager.java
@@ -16,10 +16,8 @@
 package org.traccar.database;
 
 import java.sql.SQLException;
-import java.util.ArrayList;
 import java.util.Collection;
 import java.util.HashSet;
-import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
@@ -27,137 +25,56 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicLong;
 
-import org.traccar.BaseProtocol;
 import org.traccar.Config;
 import org.traccar.Context;
 import org.traccar.helper.Log;
-import org.traccar.model.Command;
-import org.traccar.model.CommandType;
 import org.traccar.model.Device;
+import org.traccar.model.DeviceState;
 import org.traccar.model.DeviceTotalDistance;
 import org.traccar.model.Group;
 import org.traccar.model.Position;
 import org.traccar.model.Server;
 
-public class DeviceManager implements IdentityManager {
+public class DeviceManager extends BaseObjectManager<Device> implements IdentityManager, ManagableObjects {
 
     public static final long DEFAULT_REFRESH_DELAY = 300;
 
     private final Config config;
-    private final DataManager dataManager;
     private final long dataRefreshDelay;
     private boolean lookupGroupsAttribute;
 
-    private Map<Long, Device> devicesById;
     private Map<String, Device> devicesByUniqueId;
     private Map<String, Device> devicesByPhone;
     private AtomicLong devicesLastUpdate = new AtomicLong();
 
-    private Map<Long, Group> groupsById;
-    private AtomicLong groupsLastUpdate = new AtomicLong();
-
     private final Map<Long, Position> positions = new ConcurrentHashMap<>();
 
-    private boolean fallbackToText;
+    private final Map<Long, DeviceState> deviceStates = new ConcurrentHashMap<>();
 
     public DeviceManager(DataManager dataManager) {
-        this.dataManager = dataManager;
+        super(dataManager, Device.class);
         this.config = Context.getConfig();
+        if (devicesByPhone == null) {
+            devicesByPhone = new ConcurrentHashMap<>();
+        }
+        if (devicesByUniqueId == null) {
+            devicesByUniqueId = new ConcurrentHashMap<>();
+        }
         dataRefreshDelay = config.getLong("database.refreshDelay", DEFAULT_REFRESH_DELAY) * 1000;
         lookupGroupsAttribute = config.getBoolean("deviceManager.lookupGroupsAttribute");
-        fallbackToText = config.getBoolean("command.fallbackToSms");
-        if (dataManager != null) {
-            try {
-                updateGroupCache(true);
-                updateDeviceCache(true);
-                for (Position position : dataManager.getLatestPositions()) {
-                    positions.put(position.getDeviceId(), position);
-                }
-            } catch (SQLException error) {
-                Log.warning(error);
-            }
-        }
+        refreshLastPositions();
     }
 
     private void updateDeviceCache(boolean force) throws SQLException {
-
         long lastUpdate = devicesLastUpdate.get();
         if ((force || System.currentTimeMillis() - lastUpdate > dataRefreshDelay)
                 && devicesLastUpdate.compareAndSet(lastUpdate, System.currentTimeMillis())) {
-            GeofenceManager geofenceManager = Context.getGeofenceManager();
-            Collection<Device> databaseDevices = dataManager.getAllDevices();
-            if (devicesById == null) {
-                devicesById = new ConcurrentHashMap<>(databaseDevices.size());
-            }
-            if (devicesByUniqueId == null) {
-                devicesByUniqueId = new ConcurrentHashMap<>(databaseDevices.size());
-            }
-            if (devicesByPhone == null) {
-                devicesByPhone = new ConcurrentHashMap<>(databaseDevices.size());
-            }
-            Set<Long> databaseDevicesIds = new HashSet<>();
-            Set<String> databaseDevicesUniqueIds = new HashSet<>();
-            Set<String> databaseDevicesPhones = new HashSet<>();
-            for (Device device : databaseDevices) {
-                databaseDevicesIds.add(device.getId());
-                databaseDevicesUniqueIds.add(device.getUniqueId());
-                databaseDevicesPhones.add(device.getPhone());
-                if (devicesById.containsKey(device.getId())) {
-                    Device cachedDevice = devicesById.get(device.getId());
-                    cachedDevice.setName(device.getName());
-                    cachedDevice.setGroupId(device.getGroupId());
-                    cachedDevice.setCategory(device.getCategory());
-                    cachedDevice.setContact(device.getContact());
-                    cachedDevice.setModel(device.getModel());
-                    cachedDevice.setAttributes(device.getAttributes());
-                    if (!device.getUniqueId().equals(cachedDevice.getUniqueId())) {
-                        devicesByUniqueId.put(device.getUniqueId(), cachedDevice);
-                    }
-                    cachedDevice.setUniqueId(device.getUniqueId());
-                    if (device.getPhone() != null && !device.getPhone().isEmpty()
-                            && !device.getPhone().equals(cachedDevice.getPhone())) {
-                        devicesByPhone.put(device.getPhone(), cachedDevice);
-                    }
-                    cachedDevice.setPhone(device.getPhone());
-                } else {
-                    devicesById.put(device.getId(), device);
-                    devicesByUniqueId.put(device.getUniqueId(), device);
-                    if (device.getPhone() != null && !device.getPhone().isEmpty()) {
-                        devicesByPhone.put(device.getPhone(), device);
-                    }
-                    if (geofenceManager != null) {
-                        Position lastPosition = getLastPosition(device.getId());
-                        if (lastPosition != null) {
-                            device.setGeofenceIds(geofenceManager.getCurrentDeviceGeofences(lastPosition));
-                        }
-                    }
-                }
-            }
-            for (Iterator<Long> iterator = devicesById.keySet().iterator(); iterator.hasNext();) {
-                if (!databaseDevicesIds.contains(iterator.next())) {
-                    iterator.remove();
-                }
-            }
-            for (Iterator<String> iterator = devicesByUniqueId.keySet().iterator(); iterator.hasNext();) {
-                if (!databaseDevicesUniqueIds.contains(iterator.next())) {
-                    iterator.remove();
-                }
-            }
-            for (Iterator<String> iterator = devicesByPhone.keySet().iterator(); iterator.hasNext();) {
-                if (!databaseDevicesPhones.contains(iterator.next())) {
-                    iterator.remove();
-                }
-            }
+            refreshItems();
         }
     }
 
     @Override
-    public Device getDeviceById(long id) {
-        return devicesById.get(id);
-    }
-
-    @Override
-    public Device getDeviceByUniqueId(String uniqueId) throws SQLException {
+    public Device getByUniqueId(String uniqueId) throws SQLException {
         boolean forceUpdate = !devicesByUniqueId.containsKey(uniqueId) && !config.getBoolean("database.ignoreUnknown");
 
         updateDeviceCache(forceUpdate);
@@ -169,76 +86,127 @@ public class DeviceManager implements IdentityManager {
         return devicesByPhone.get(phone);
     }
 
+    @Override
+    public Set<Long> getAllItems() {
+        Set<Long> result = super.getAllItems();
+        if (result.isEmpty()) {
+            try {
+                updateDeviceCache(true);
+            } catch (SQLException e) {
+                Log.warning(e);
+            }
+            result = super.getAllItems();
+        }
+        return result;
+    }
+
     public Collection<Device> getAllDevices() {
-        boolean forceUpdate = devicesById.isEmpty();
+        return getItems(getAllItems());
+    }
 
-        try {
-            updateDeviceCache(forceUpdate);
-        } catch (SQLException e) {
-            Log.warning(e);
+    @Override
+    public Set<Long> getUserItems(long userId) {
+        if (Context.getPermissionsManager() != null) {
+            return Context.getPermissionsManager().getDevicePermissions(userId);
+        } else {
+            return new HashSet<>();
         }
-
-        return devicesById.values();
     }
 
-    public Collection<Device> getDevices(long userId) throws SQLException {
-        Collection<Device> devices = new ArrayList<>();
-        for (long id : Context.getPermissionsManager().getDevicePermissions(userId)) {
-            devices.add(devicesById.get(id));
+    @Override
+    public Set<Long> getManagedItems(long userId) {
+        Set<Long> result = new HashSet<>();
+        result.addAll(getUserItems(userId));
+        for (long managedUserId : Context.getUsersManager().getUserItems(userId)) {
+            result.addAll(getUserItems(managedUserId));
         }
-        return devices;
+        return result;
     }
 
-    public Collection<Device> getManagedDevices(long userId) throws SQLException {
-        Collection<Device> devices = new HashSet<>();
-        devices.addAll(getDevices(userId));
-        for (long managedUserId : Context.getPermissionsManager().getUserPermissions(userId)) {
-            devices.addAll(getDevices(managedUserId));
+    private void putUniqueDeviceId(Device device) {
+        if (devicesByUniqueId == null) {
+            devicesByUniqueId = new ConcurrentHashMap<>(getAllItems().size());
         }
-        return devices;
+        devicesByUniqueId.put(device.getUniqueId(), device);
     }
 
-    public void addDevice(Device device) throws SQLException {
-        dataManager.addDevice(device);
+    private void putPhone(Device device) {
+        if (devicesByPhone == null) {
+            devicesByPhone = new ConcurrentHashMap<>(getAllItems().size());
+        }
+        devicesByPhone.put(device.getPhone(), device);
+    }
 
-        devicesById.put(device.getId(), device);
-        devicesByUniqueId.put(device.getUniqueId(), device);
+    @Override
+    protected void addNewItem(Device device) {
+        super.addNewItem(device);
+        putUniqueDeviceId(device);
         if (device.getPhone() != null  && !device.getPhone().isEmpty()) {
-            devicesByPhone.put(device.getPhone(), device);
+            putPhone(device);
+        }
+        if (Context.getGeofenceManager() != null) {
+            Position lastPosition = getLastPosition(device.getId());
+            if (lastPosition != null) {
+                device.setGeofenceIds(Context.getGeofenceManager().getCurrentDeviceGeofences(lastPosition));
+            }
         }
     }
 
-    public void updateDevice(Device device) throws SQLException {
-        dataManager.updateDevice(device);
+    @Override
+    protected void updateCachedItem(Device device) {
+        Device cachedDevice = getById(device.getId());
+        cachedDevice.setName(device.getName());
+        cachedDevice.setGroupId(device.getGroupId());
+        cachedDevice.setCategory(device.getCategory());
+        cachedDevice.setContact(device.getContact());
+        cachedDevice.setModel(device.getModel());
+        cachedDevice.setAttributes(device.getAttributes());
+        if (!device.getUniqueId().equals(cachedDevice.getUniqueId())) {
+            devicesByUniqueId.remove(cachedDevice.getUniqueId());
+            cachedDevice.setUniqueId(device.getUniqueId());
+            putUniqueDeviceId(cachedDevice);
+        }
+        if (device.getPhone() != null && !device.getPhone().isEmpty()
+                && !device.getPhone().equals(cachedDevice.getPhone())) {
+            devicesByPhone.remove(cachedDevice.getPhone());
+            cachedDevice.setPhone(device.getPhone());
+            putPhone(cachedDevice);
+        }
+    }
 
-        devicesById.put(device.getId(), device);
-        devicesByUniqueId.put(device.getUniqueId(), device);
-        if (device.getPhone() != null && !device.getPhone().isEmpty()) {
-            devicesByPhone.put(device.getPhone(), device);
+    @Override
+    protected void removeCachedItem(long deviceId) {
+        Device cachedDevice = getById(deviceId);
+        if (cachedDevice != null) {
+            String deviceUniqueId = cachedDevice.getUniqueId();
+            String phone = cachedDevice.getPhone();
+            super.removeCachedItem(deviceId);
+            devicesByUniqueId.remove(deviceUniqueId);
+            if (phone != null && !phone.isEmpty()) {
+                devicesByPhone.remove(phone);
+            }
         }
+        positions.remove(deviceId);
     }
 
     public void updateDeviceStatus(Device device) throws SQLException {
-        dataManager.updateDeviceStatus(device);
-        if (devicesById.containsKey(device.getId())) {
-            Device cachedDevice = devicesById.get(device.getId());
+        getDataManager().updateDeviceStatus(device);
+        Device cachedDevice = getById(device.getId());
+        if (cachedDevice != null) {
             cachedDevice.setStatus(device.getStatus());
         }
     }
 
-    public void removeDevice(long deviceId) throws SQLException {
-        dataManager.removeDevice(deviceId);
-
-        if (devicesById.containsKey(deviceId)) {
-            String deviceUniqueId = devicesById.get(deviceId).getUniqueId();
-            String phone = devicesById.get(deviceId).getPhone();
-            devicesById.remove(deviceId);
-            devicesByUniqueId.remove(deviceUniqueId);
-            if (phone != null && !phone.isEmpty()) {
-                devicesByPhone.remove(phone);
+    private void refreshLastPositions() {
+        if (getDataManager() != null) {
+            try {
+                for (Position position : getDataManager().getLatestPositions()) {
+                    positions.put(position.getDeviceId(), position);
+                }
+            } catch (SQLException error) {
+                Log.warning(error);
             }
         }
-        positions.remove(deviceId);
     }
 
     public boolean isLatestPosition(Position position) {
@@ -250,10 +218,11 @@ public class DeviceManager implements IdentityManager {
 
         if (isLatestPosition(position)) {
 
-            dataManager.updateLatestPosition(position);
+            getDataManager().updateLatestPosition(position);
 
-            if (devicesById.containsKey(position.getDeviceId())) {
-                devicesById.get(position.getDeviceId()).setPositionId(position.getId());
+            Device device = getById(position.getDeviceId());
+            if (device != null) {
+                device.setPositionId(position.getId());
             }
 
             positions.put(position.getDeviceId(), position);
@@ -274,7 +243,7 @@ public class DeviceManager implements IdentityManager {
         List<Position> result = new LinkedList<>();
 
         if (Context.getPermissionsManager() != null) {
-            for (long deviceId : Context.getPermissionsManager().getDevicePermissions(userId)) {
+            for (long deviceId : getUserItems(userId)) {
                 if (positions.containsKey(deviceId)) {
                     result.add(positions.get(deviceId));
                 }
@@ -284,154 +253,62 @@ public class DeviceManager implements IdentityManager {
         return result;
     }
 
-    private void updateGroupCache(boolean force) throws SQLException {
-
-        long lastUpdate = groupsLastUpdate.get();
-        if ((force || System.currentTimeMillis() - lastUpdate > dataRefreshDelay)
-                && groupsLastUpdate.compareAndSet(lastUpdate, System.currentTimeMillis())) {
-            Collection<Group> databaseGroups = dataManager.getAllGroups();
-            if (groupsById == null) {
-                groupsById = new ConcurrentHashMap<>(databaseGroups.size());
-            }
-            Set<Long> databaseGroupsIds = new HashSet<>();
-            for (Group group : databaseGroups) {
-                databaseGroupsIds.add(group.getId());
-                if (groupsById.containsKey(group.getId())) {
-                    Group cachedGroup = groupsById.get(group.getId());
-                    cachedGroup.setName(group.getName());
-                    cachedGroup.setGroupId(group.getGroupId());
-                } else {
-                    groupsById.put(group.getId(), group);
-                }
-            }
-            for (Long cachedGroupId : groupsById.keySet()) {
-                if (!databaseGroupsIds.contains(cachedGroupId)) {
-                    devicesById.remove(cachedGroupId);
-                }
-            }
-            databaseGroupsIds.clear();
-        }
-    }
-
-    public Group getGroupById(long id) {
-        return groupsById.get(id);
-    }
-
-    public Collection<Group> getAllGroups() {
-        boolean forceUpdate = groupsById.isEmpty();
-
-        try {
-            updateGroupCache(forceUpdate);
-        } catch (SQLException e) {
-            Log.warning(e);
-        }
-
-        return groupsById.values();
-    }
-
-    public Collection<Group> getGroups(long userId) throws SQLException {
-        Collection<Group> groups = new ArrayList<>();
-        for (long id : Context.getPermissionsManager().getGroupPermissions(userId)) {
-            groups.add(getGroupById(id));
-        }
-        return groups;
-    }
-
-    public Collection<Group> getManagedGroups(long userId) throws SQLException {
-        Collection<Group> groups = new ArrayList<>();
-        groups.addAll(getGroups(userId));
-        for (long managedUserId : Context.getPermissionsManager().getUserPermissions(userId)) {
-            groups.addAll(getGroups(managedUserId));
-        }
-        return groups;
-    }
-
-    private void checkGroupCycles(Group group) {
-        Set<Long> groups = new HashSet<>();
-        while (group != null) {
-            if (groups.contains(group.getId())) {
-                throw new IllegalArgumentException("Cycle in group hierarchy");
-            }
-            groups.add(group.getId());
-            group = groupsById.get(group.getGroupId());
-        }
-    }
-
-    public void addGroup(Group group) throws SQLException {
-        checkGroupCycles(group);
-        dataManager.addGroup(group);
-        groupsById.put(group.getId(), group);
-    }
-
-    public void updateGroup(Group group) throws SQLException {
-        checkGroupCycles(group);
-        dataManager.updateGroup(group);
-        groupsById.put(group.getId(), group);
-    }
-
-    public void removeGroup(long groupId) throws SQLException {
-        dataManager.removeGroup(groupId);
-        groupsById.remove(groupId);
-    }
-
     public boolean lookupAttributeBoolean(
             long deviceId, String attributeName, boolean defaultValue, boolean lookupConfig) {
-        String result = lookupAttribute(deviceId, attributeName, lookupConfig);
+        Object result = lookupAttribute(deviceId, attributeName, lookupConfig);
         if (result != null) {
-            return Boolean.parseBoolean(result);
+            return result instanceof String ? Boolean.parseBoolean((String) result) : (Boolean) result;
         }
         return defaultValue;
     }
 
     public String lookupAttributeString(
             long deviceId, String attributeName, String defaultValue, boolean lookupConfig) {
-        String result = lookupAttribute(deviceId, attributeName, lookupConfig);
-        if (result != null) {
-            return result;
-        }
-        return defaultValue;
+        Object result = lookupAttribute(deviceId, attributeName, lookupConfig);
+        return result != null ? (String) result : defaultValue;
     }
 
     public int lookupAttributeInteger(long deviceId, String attributeName, int defaultValue, boolean lookupConfig) {
-        String result = lookupAttribute(deviceId, attributeName, lookupConfig);
+        Object result = lookupAttribute(deviceId, attributeName, lookupConfig);
         if (result != null) {
-            return Integer.parseInt(result);
+            return result instanceof String ? Integer.parseInt((String) result) : ((Number) result).intValue();
         }
         return defaultValue;
     }
 
     public long lookupAttributeLong(
             long deviceId, String attributeName, long defaultValue, boolean lookupConfig) {
-        String result = lookupAttribute(deviceId, attributeName, lookupConfig);
+        Object result = lookupAttribute(deviceId, attributeName, lookupConfig);
         if (result != null) {
-            return Long.parseLong(result);
+            return result instanceof String ? Long.parseLong((String) result) : ((Number) result).longValue();
         }
         return defaultValue;
     }
 
     public double lookupAttributeDouble(
             long deviceId, String attributeName, double defaultValue, boolean lookupConfig) {
-        String result = lookupAttribute(deviceId, attributeName, lookupConfig);
+        Object result = lookupAttribute(deviceId, attributeName, lookupConfig);
         if (result != null) {
-            return Double.parseDouble(result);
+            return result instanceof String ? Double.parseDouble((String) result) : ((Number) result).doubleValue();
         }
         return defaultValue;
     }
 
-    private String lookupAttribute(long deviceId, String attributeName, boolean lookupConfig) {
-        String result = null;
-        Device device = getDeviceById(deviceId);
+    private Object lookupAttribute(long deviceId, String attributeName, boolean lookupConfig) {
+        Object result = null;
+        Device device = getById(deviceId);
         if (device != null) {
-            result = device.getString(attributeName);
+            result = device.getAttributes().get(attributeName);
             if (result == null && lookupGroupsAttribute) {
                 long groupId = device.getGroupId();
                 while (groupId != 0) {
-                    if (getGroupById(groupId) != null) {
-                        result = getGroupById(groupId).getString(attributeName);
+                    Group group = Context.getGroupsManager().getById(groupId);
+                    if (group != null) {
+                        result = group.getAttributes().get(attributeName);
                         if (result != null) {
                             break;
                         }
-                        groupId = getGroupById(groupId).getGroupId();
+                        groupId = group.getGroupId();
                     } else {
                         groupId = 0;
                     }
@@ -442,7 +319,7 @@ public class DeviceManager implements IdentityManager {
                     result = Context.getConfig().getString(attributeName);
                 } else {
                     Server server = Context.getPermissionsManager().getServer();
-                    result = server.getString(attributeName);
+                    result = server.getAttributes().get(attributeName);
                 }
             }
         }
@@ -453,54 +330,24 @@ public class DeviceManager implements IdentityManager {
         Position last = positions.get(deviceTotalDistance.getDeviceId());
         if (last != null) {
             last.getAttributes().put(Position.KEY_TOTAL_DISTANCE, deviceTotalDistance.getTotalDistance());
-            dataManager.addPosition(last);
+            getDataManager().addPosition(last);
             updateLatestPosition(last);
         } else {
             throw new IllegalArgumentException();
         }
     }
 
-    public void sendCommand(Command command) throws Exception {
-        long deviceId = command.getDeviceId();
-        if (command.getTextChannel()) {
-            Position lastPosition = getLastPosition(deviceId);
-            if (lastPosition != null) {
-                BaseProtocol protocol = Context.getServerManager().getProtocol(lastPosition.getProtocol());
-                protocol.sendTextCommand(devicesById.get(deviceId).getPhone(), command);
-            } else if (command.getType().equals(Command.TYPE_CUSTOM)) {
-                Context.getSmppManager().sendMessageSync(devicesById.get(deviceId).getPhone(),
-                        command.getString(Command.KEY_DATA), true);
-            } else {
-                throw new RuntimeException("Command " + command.getType() + " is not supported");
-            }
-        } else {
-            ActiveDevice activeDevice = Context.getConnectionManager().getActiveDevice(deviceId);
-            if (activeDevice != null) {
-                activeDevice.sendCommand(command);
-            } else {
-                if (fallbackToText) {
-                    command.setTextChannel(true);
-                    sendCommand(command);
-                } else {
-                    throw new RuntimeException("Device is not online");
-                }
-            }
+    public DeviceState getDeviceState(long deviceId) {
+        DeviceState deviceState = deviceStates.get(deviceId);
+        if (deviceState == null) {
+            deviceState = new DeviceState();
+            deviceStates.put(deviceId, deviceState);
         }
+        return deviceState;
     }
 
-    public Collection<CommandType> getCommandTypes(long deviceId, boolean textChannel) {
-        List<CommandType> result = new ArrayList<>();
-        Position lastPosition = Context.getDeviceManager().getLastPosition(deviceId);
-        if (lastPosition != null) {
-            BaseProtocol protocol = Context.getServerManager().getProtocol(lastPosition.getProtocol());
-            Collection<String> commands;
-            commands = textChannel ? protocol.getSupportedTextCommands() : protocol.getSupportedDataCommands();
-            for (String commandKey : commands) {
-                result.add(new CommandType(commandKey));
-            }
-        } else {
-            result.add(new CommandType(Command.TYPE_CUSTOM));
-        }
-        return result;
+    public void setDeviceState(long deviceId, DeviceState deviceState) {
+        deviceStates.put(deviceId, deviceState);
     }
+
 }