Refactor commands manager

3 files changed, 55 insertions, 138 deletions

diff --git a/src/main/java/org/traccar/database/CommandsManager.java b/src/main/java/org/traccar/database/CommandsManager.java
index 57ce0f9a4..d440755f7 100644
--- a/src/main/java/org/traccar/database/CommandsManager.java
+++ b/src/main/java/org/traccar/database/CommandsManager.java
@@ -16,66 +16,75 @@
  */
 package org.traccar.database;
 
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
+import org.traccar.BaseProtocol;
+import org.traccar.ServerManager;
+import org.traccar.config.Config;
+import org.traccar.config.Keys;
+import org.traccar.model.Command;
+import org.traccar.model.Device;
+import org.traccar.model.Position;
+import org.traccar.session.ConnectionManager;
+import org.traccar.session.DeviceSession;
+import org.traccar.sms.SmsManager;
+import org.traccar.storage.Storage;
+import org.traccar.storage.query.Columns;
+import org.traccar.storage.query.Condition;
+import org.traccar.storage.query.Request;
+
+import javax.annotation.Nullable;
+import javax.inject.Inject;
+import javax.inject.Singleton;
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
 import java.util.Map;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.traccar.BaseProtocol;
-import org.traccar.Context;
-import org.traccar.model.Command;
-import org.traccar.model.Typed;
-import org.traccar.model.Position;
-import org.traccar.session.DeviceSession;
-
-public class CommandsManager  extends ExtendedObjectManager<Command> {
+@Singleton
+public class CommandsManager {
 
-    private static final Logger LOGGER = LoggerFactory.getLogger(CommandsManager.class);
+    private final ReadWriteLock lock = new ReentrantReadWriteLock();
 
     private final Map<Long, Queue<Command>> deviceQueues = new ConcurrentHashMap<>();
 
-    private final boolean queueing;
+    private final Storage storage;
+    private final ServerManager serverManager;
+    private final SmsManager smsManager;
+    private final ConnectionManager connectionManager;
 
-    public CommandsManager(DataManager dataManager, boolean queueing) {
-        super(dataManager, Command.class);
-        this.queueing = queueing;
-    }
+    private final boolean queueing;
 
-    public boolean checkDeviceCommand(long deviceId, long commandId) {
-        return !getAllDeviceItems(deviceId).contains(commandId);
+    @Inject
+    public CommandsManager(
+            Storage storage, ServerManager serverManager, @Nullable SmsManager smsManager,
+            ConnectionManager connectionManager, Config config) {
+        this.storage = storage;
+        this.serverManager = serverManager;
+        this.smsManager = smsManager;
+        this.connectionManager = connectionManager;
+        queueing = config.getBoolean(Keys.COMMANDS_QUEUEING);
     }
 
     public boolean sendCommand(Command command) throws Exception {
         long deviceId = command.getDeviceId();
-        if (command.getId() != 0) {
-            command = getById(command.getId()).clone();
-            command.setDeviceId(deviceId);
-        }
         if (command.getTextChannel()) {
-            Position lastPosition = Context.getIdentityManager().getLastPosition(deviceId);
-            String phone = Context.getIdentityManager().getById(deviceId).getPhone();
-            if (lastPosition != null) {
-                BaseProtocol protocol = Context.getServerManager().getProtocol(lastPosition.getProtocol());
-                protocol.sendTextCommand(phone, command);
+            Device device = storage.getObject(Device.class, new Request(
+                    new Columns.All(), new Condition.Equals("id", "id", deviceId)));
+            Position position = storage.getObject(Position.class, new Request(
+                    new Columns.All(), new Condition.Equals("id", "id", device.getPositionId())));
+            if (position != null) {
+                BaseProtocol protocol = serverManager.getProtocol(position.getProtocol());
+                protocol.sendTextCommand(device.getPhone(), command);
             } else if (command.getType().equals(Command.TYPE_CUSTOM)) {
-                if (Context.getSmsManager() != null) {
-                    Context.getSmsManager().sendMessageSync(phone, command.getString(Command.KEY_DATA), true);
-                } else {
-                    throw new RuntimeException("SMS is not enabled");
-                }
+                smsManager.sendMessageSync(device.getPhone(), command.getString(Command.KEY_DATA), true);
             } else {
                 throw new RuntimeException("Command " + command.getType() + " is not supported");
             }
         } else {
-            DeviceSession deviceSession = Context.getConnectionManager().getDeviceSession(deviceId);
+            DeviceSession deviceSession = connectionManager.getDeviceSession(deviceId);
             if (deviceSession != null) {
                 if (deviceSession.supportsLiveCommands()) {
                     deviceSession.sendCommand(command);
@@ -93,76 +102,22 @@ public class CommandsManager  extends ExtendedObjectManager<Command> {
         return true;
     }
 
-    public Collection<Long> getSupportedCommands(long deviceId) {
-        List<Long> result = new ArrayList<>();
-        Position lastPosition = Context.getIdentityManager().getLastPosition(deviceId);
-        for (long commandId : getAllDeviceItems(deviceId)) {
-            Command command = getById(commandId);
-            if (lastPosition != null) {
-                BaseProtocol protocol = Context.getServerManager().getProtocol(lastPosition.getProtocol());
-                if (command.getTextChannel() && protocol.getSupportedTextCommands().contains(command.getType())
-                        || !command.getTextChannel()
-                        && protocol.getSupportedDataCommands().contains(command.getType())) {
-                    result.add(commandId);
-                }
-            } else if (command.getType().equals(Command.TYPE_CUSTOM)) {
-                result.add(commandId);
-            }
-        }
-        return result;
-    }
-
-    public Collection<Typed> getCommandTypes(long deviceId, boolean textChannel) {
-        Position lastPosition = Context.getIdentityManager().getLastPosition(deviceId);
-        if (lastPosition != null) {
-            return getCommandTypes(lastPosition.getProtocol(), textChannel);
-        } else {
-            return Collections.singletonList(new Typed(Command.TYPE_CUSTOM));
-        }
-    }
-
-    public Collection<Typed> getCommandTypes(String protocolName, boolean textChannel) {
-        List<Typed> result = new ArrayList<>();
-        BaseProtocol protocol = Context.getServerManager().getProtocol(protocolName);
-        Collection<String> commands;
-        commands = textChannel ? protocol.getSupportedTextCommands() : protocol.getSupportedDataCommands();
-        for (String commandKey : commands) {
-            result.add(new Typed(commandKey));
-        }
-        return result;
-    }
-
-    public Collection<Typed> getAllCommandTypes() {
-        List<Typed> result = new ArrayList<>();
-        Field[] fields = Command.class.getDeclaredFields();
-        for (Field field : fields) {
-            if (Modifier.isStatic(field.getModifiers()) && field.getName().startsWith("TYPE_")) {
-                try {
-                    result.add(new Typed(field.get(null).toString()));
-                } catch (IllegalArgumentException | IllegalAccessException error) {
-                    LOGGER.warn("Get command types error", error);
-                }
-            }
-        }
-        return result;
-    }
-
     private Queue<Command> getDeviceQueue(long deviceId) {
         Queue<Command> deviceQueue;
         try {
-            readLock();
+            lock.readLock().lock();
             deviceQueue = deviceQueues.get(deviceId);
         } finally {
-            readUnlock();
+            lock.readLock().unlock();
         }
         if (deviceQueue != null) {
             return deviceQueue;
         } else {
             try {
-                writeLock();
+                lock.writeLock().lock();
                 return deviceQueues.computeIfAbsent(deviceId, key -> new ConcurrentLinkedQueue<>());
             } finally {
-                writeUnlock();
+                lock.writeLock().unlock();
             }
         }
     }
@@ -174,10 +129,10 @@ public class CommandsManager  extends ExtendedObjectManager<Command> {
     public Collection<Command> readQueuedCommands(long deviceId, int count) {
         Queue<Command> deviceQueue;
         try {
-            readLock();
+            lock.readLock().lock();
             deviceQueue = deviceQueues.get(deviceId);
         } finally {
-            readUnlock();
+            lock.readLock().unlock();
         }
         Collection<Command> result = new ArrayList<>();
         if (deviceQueue != null) {
diff --git a/src/main/java/org/traccar/database/DataManager.java b/src/main/java/org/traccar/database/DataManager.java
index b5966ca9e..1426daea3 100644
--- a/src/main/java/org/traccar/database/DataManager.java
+++ b/src/main/java/org/traccar/database/DataManager.java
@@ -50,8 +50,6 @@ import java.lang.reflect.Method;
 import java.net.URL;
 import java.util.Collection;
 import java.util.Date;
-import java.util.LinkedList;
-import java.util.List;
 
 public class DataManager {
 
@@ -205,14 +203,9 @@ public class DataManager {
     }
 
     public Collection<Position> getLatestPositions() throws StorageException {
-        List<Position> positions = new LinkedList<>();
-        List<Device> devices = storage.getObjects(Device.class, new Request(new Columns.Include("positionId")));
-        for (Device device : devices) {
-            positions.addAll(storage.getObjects(Position.class, new Request(
-                    new Columns.All(),
-                    new Condition.Equals("id", "id", device.getPositionId()))));
-        }
-        return positions;
+        return storage.getObjects(Position.class, new Request(
+                new Columns.All(),
+                new Condition.LatestPositions()));
     }
 
     public Server getServer() throws StorageException {
diff --git a/src/main/java/org/traccar/database/PermissionsManager.java b/src/main/java/org/traccar/database/PermissionsManager.java
index 29bb8a27b..4d5c59fcc 100644
--- a/src/main/java/org/traccar/database/PermissionsManager.java
+++ b/src/main/java/org/traccar/database/PermissionsManager.java
@@ -20,7 +20,6 @@ import org.slf4j.LoggerFactory;
 import org.traccar.Context;
 import org.traccar.model.BaseModel;
 import org.traccar.model.Calendar;
-import org.traccar.model.Command;
 import org.traccar.model.Device;
 import org.traccar.model.Driver;
 import org.traccar.model.Geofence;
@@ -274,18 +273,6 @@ public class PermissionsManager {
         }
     }
 
-    public void checkLimitCommands(long userId) throws SecurityException {
-        if (!getUserAdmin(userId) && (server.getLimitCommands() || getUserLimitCommands(userId))) {
-            throw new SecurityException("Account has limit sending commands");
-        }
-    }
-
-    public void checkUserDeviceCommand(long userId, long deviceId, long commandId) throws SecurityException {
-        if (!getUserAdmin(userId) && Context.getCommandsManager().checkDeviceCommand(deviceId, commandId)) {
-            throw new SecurityException("Command can not be sent to this device");
-        }
-    }
-
     public void checkUserEnabled(long userId) throws SecurityException {
         User user = getUser(userId);
         if (user == null) {
@@ -367,21 +354,9 @@ public class PermissionsManager {
 
         if (object.equals(Device.class)) {
             checkDevice(userId, objectId);
-        } else if (object.equals(Command.class)) {
-            manager = Context.getCommandsManager();
         } else {
             throw new IllegalArgumentException("Unknown object type");
         }
-
-        if (manager != null && !manager.checkItemPermission(userId, objectId) && !getUserAdmin(userId)) {
-            checkManager(userId);
-            for (long managedUserId : usersManager.getManagedItems(userId)) {
-                if (manager.checkItemPermission(managedUserId, objectId)) {
-                    return;
-                }
-            }
-            throw new SecurityException("Type " + object + " access denied");
-        }
     }
 
     public void refreshAllUsersPermissions() {
@@ -390,7 +365,6 @@ public class PermissionsManager {
         }
         Context.getCalendarManager().refreshUserItems();
         Context.getDriversManager().refreshUserItems();
-        Context.getCommandsManager().refreshUserItems();
         Context.getMaintenancesManager().refreshUserItems();
         if (Context.getNotificationManager() != null) {
             Context.getNotificationManager().refreshUserItems();
@@ -402,7 +376,6 @@ public class PermissionsManager {
             Context.getGeofenceManager().refreshExtendedPermissions();
         }
         Context.getDriversManager().refreshExtendedPermissions();
-        Context.getCommandsManager().refreshExtendedPermissions();
         Context.getMaintenancesManager().refreshExtendedPermissions();
     }
 
@@ -420,8 +393,6 @@ public class PermissionsManager {
                 Context.getDriversManager().refreshUserItems();
             } else if (permission.getPropertyClass().equals(Calendar.class)) {
                 Context.getCalendarManager().refreshUserItems();
-            } else if (permission.getPropertyClass().equals(Command.class)) {
-                Context.getCommandsManager().refreshUserItems();
             } else if (permission.getPropertyClass().equals(Maintenance.class)) {
                 Context.getMaintenancesManager().refreshUserItems();
             } else if (permission.getPropertyClass().equals(Order.class)) {
@@ -435,8 +406,6 @@ public class PermissionsManager {
                 Context.getGeofenceManager().refreshExtendedPermissions();
             } else if (permission.getPropertyClass().equals(Driver.class)) {
                 Context.getDriversManager().refreshExtendedPermissions();
-            } else if (permission.getPropertyClass().equals(Command.class)) {
-                Context.getCommandsManager().refreshExtendedPermissions();
             } else if (permission.getPropertyClass().equals(Maintenance.class)) {
                 Context.getMaintenancesManager().refreshExtendedPermissions();
             } else if (permission.getPropertyClass().equals(Order.class)) {