Merge pull request #3349 from Abyss777/drivers

Drivers implementation

3 files changed, 310 insertions, 0 deletions

diff --git a/src/org/traccar/database/DataManager.java b/src/org/traccar/database/DataManager.java
index dd65289e4..1c2a66bcf 100644
--- a/src/org/traccar/database/DataManager.java
+++ b/src/org/traccar/database/DataManager.java
@@ -44,11 +44,15 @@ import org.traccar.model.CalendarPermission;
 import org.traccar.model.Attribute;
 import org.traccar.model.Device;
 import org.traccar.model.DeviceAttribute;
+import org.traccar.model.DeviceDriver;
 import org.traccar.model.DevicePermission;
+import org.traccar.model.Driver;
+import org.traccar.model.DriverPermission;
 import org.traccar.model.Event;
 import org.traccar.model.Geofence;
 import org.traccar.model.Group;
 import org.traccar.model.GroupAttribute;
+import org.traccar.model.GroupDriver;
 import org.traccar.model.GroupGeofence;
 import org.traccar.model.GroupPermission;
 import org.traccar.model.Notification;
@@ -638,4 +642,84 @@ public class DataManager {
                 .executeUpdate();
     }
 
+    public Collection<Driver> getDrivers() throws SQLException {
+        return QueryBuilder.create(dataSource, getQuery("database.selectDrivers"))
+                .executeQuery(Driver.class);
+    }
+
+    public void addDriver(Driver driver) throws SQLException {
+        driver.setId(QueryBuilder.create(dataSource, getQuery("database.insertDriver"), true)
+                .setObject(driver)
+                .executeUpdate());
+    }
+
+    public void updateDriver(Driver driver) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.updateDriver"))
+                .setObject(driver)
+                .executeUpdate();
+    }
+
+    public void removeDriver(long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.deleteDriver"))
+                .setLong("id", driverId)
+                .executeUpdate();
+    }
+
+    public Collection<DriverPermission> getDriverPermissions() throws SQLException {
+        return QueryBuilder.create(dataSource, getQuery("database.selectDriverPermissions"))
+                .executeQuery(DriverPermission.class);
+    }
+
+    public void linkDriver(long userId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.linkDriver"))
+                .setLong("userId", userId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
+    public void unlinkDriver(long userId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.unlinkDriver"))
+                .setLong("userId", userId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
+    public Collection<GroupDriver> getGroupDrivers() throws SQLException {
+        return QueryBuilder.create(dataSource, getQuery("database.selectGroupDrivers"))
+                .executeQuery(GroupDriver.class);
+    }
+
+    public void linkGroupDriver(long groupId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.linkGroupDriver"))
+                .setLong("groupId", groupId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
+    public void unlinkGroupDriver(long groupId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.unlinkGroupDriver"))
+                .setLong("groupId", groupId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
+    public Collection<DeviceDriver> getDeviceDrivers() throws SQLException {
+        return QueryBuilder.create(dataSource, getQuery("database.selectDeviceDrivers"))
+                .executeQuery(DeviceDriver.class);
+    }
+
+    public void linkDeviceDriver(long deviceId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.linkDeviceDriver"))
+                .setLong("deviceId", deviceId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
+    public void unlinkDeviceDriver(long deviceId, long driverId) throws SQLException {
+        QueryBuilder.create(dataSource, getQuery("database.unlinkDeviceDriver"))
+                .setLong("deviceId", deviceId)
+                .setLong("driverId", driverId)
+                .executeUpdate();
+    }
+
 }
diff --git a/src/org/traccar/database/DriversManager.java b/src/org/traccar/database/DriversManager.java
new file mode 100644
index 000000000..e89d59311
--- /dev/null
+++ b/src/org/traccar/database/DriversManager.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2017 Anton Tananaev (anton@traccar.org)
+ * Copyright 2017 Andrey Kunitsyn (andrey@traccar.org)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.traccar.database;
+
+import java.sql.SQLException;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.traccar.Context;
+import org.traccar.helper.Log;
+import org.traccar.model.Device;
+import org.traccar.model.DeviceDriver;
+import org.traccar.model.Driver;
+import org.traccar.model.DriverPermission;
+import org.traccar.model.GroupDriver;
+
+public class DriversManager {
+
+    private final DataManager dataManager;
+
+    private final Map<Long, Driver> drivers = new ConcurrentHashMap<>();
+    private final Map<String, Driver> driversByUniqueId = new ConcurrentHashMap<>();
+    private final Map<Long, Set<Long>> deviceDrivers = new ConcurrentHashMap<>();
+    private final Map<Long, Set<Long>> deviceDriversWithGroups = new ConcurrentHashMap<>();
+    private final Map<Long, Set<Long>> groupDrivers = new ConcurrentHashMap<>();
+    private final Map<Long, Set<Long>> userDrivers = new ConcurrentHashMap<>();
+
+    public DriversManager(DataManager dataManager) {
+        this.dataManager = dataManager;
+        refreshDrivers();
+    }
+
+    public Set<Long> getUserDrivers(long userId) {
+        if (!userDrivers.containsKey(userId)) {
+            userDrivers.put(userId, new HashSet<Long>());
+        }
+        return userDrivers.get(userId);
+    }
+
+    public Set<Long> getGroupDrivers(long groupId) {
+        if (!groupDrivers.containsKey(groupId)) {
+            groupDrivers.put(groupId, new HashSet<Long>());
+        }
+        return groupDrivers.get(groupId);
+    }
+
+    public Set<Long> getDeviceDrivers(long deviceId) {
+        return getDeviceDrivers(deviceDrivers, deviceId);
+    }
+
+    public Set<Long> getAllDeviceDrivers(long deviceId) {
+        return getDeviceDrivers(deviceDriversWithGroups, deviceId);
+    }
+
+    private Set<Long> getDeviceDrivers(Map<Long, Set<Long>> deviceDrivers, long deviceId) {
+        if (!deviceDrivers.containsKey(deviceId)) {
+            deviceDrivers.put(deviceId, new HashSet<Long>());
+        }
+        return deviceDrivers.get(deviceId);
+    }
+
+    public final void refreshDrivers() {
+        if (dataManager != null) {
+            try {
+                drivers.clear();
+                driversByUniqueId.clear();
+                for (Driver driver : dataManager.getDrivers()) {
+                    drivers.put(driver.getId(), driver);
+                    driversByUniqueId.put(driver.getUniqueId(), driver);
+                }
+            } catch (SQLException error) {
+                Log.warning(error);
+            }
+        }
+        refreshUserDrivers();
+        refresh();
+    }
+
+    public final void refreshUserDrivers() {
+        if (dataManager != null) {
+            try {
+                userDrivers.clear();
+                for (DriverPermission driverPermission : dataManager.getDriverPermissions()) {
+                    getUserDrivers(driverPermission.getUserId()).add(driverPermission.getDriverId());
+                }
+            } catch (SQLException error) {
+                Log.warning(error);
+            }
+        }
+    }
+
+    public final void refresh() {
+        if (dataManager != null) {
+            try {
+
+                Collection<GroupDriver> databaseGroupDrivers = dataManager.getGroupDrivers();
+
+                groupDrivers.clear();
+                for (GroupDriver groupDriver : databaseGroupDrivers) {
+                    getGroupDrivers(groupDriver.getGroupId()).add(groupDriver.getDriverId());
+                }
+
+                Collection<DeviceDriver> databaseDeviceDrivers = dataManager.getDeviceDrivers();
+                Collection<Device> allDevices = Context.getDeviceManager().getAllDevices();
+
+                deviceDrivers.clear();
+                deviceDriversWithGroups.clear();
+
+                for (DeviceDriver deviceAttribute : databaseDeviceDrivers) {
+                    getDeviceDrivers(deviceAttribute.getDeviceId())
+                        .add(deviceAttribute.getDriverId());
+                    getAllDeviceDrivers(deviceAttribute.getDeviceId())
+                        .add(deviceAttribute.getDriverId());
+                }
+
+                for (Device device : allDevices) {
+                    long groupId = device.getGroupId();
+                    while (groupId != 0) {
+                        getAllDeviceDrivers(device.getId()).addAll(getGroupDrivers(groupId));
+                        if (Context.getDeviceManager().getGroupById(groupId) != null) {
+                            groupId = Context.getDeviceManager().getGroupById(groupId).getGroupId();
+                        } else {
+                            groupId = 0;
+                        }
+                    }
+                }
+
+            } catch (SQLException error) {
+                Log.warning(error);
+            }
+        }
+    }
+
+    public void addDriver(Driver driver) throws SQLException {
+        dataManager.addDriver(driver);
+        drivers.put(driver.getId(), driver);
+        driversByUniqueId.put(driver.getUniqueId(), driver);
+    }
+
+    public void updateDriver(Driver driver) throws SQLException {
+        dataManager.updateDriver(driver);
+        Driver cachedDriver = drivers.get(driver.getId());
+        cachedDriver.setName(driver.getName());
+        if (!driver.getUniqueId().equals(cachedDriver.getUniqueId())) {
+            driversByUniqueId.remove(cachedDriver.getUniqueId());
+            cachedDriver.setUniqueId(driver.getUniqueId());
+            driversByUniqueId.put(cachedDriver.getUniqueId(), cachedDriver);
+        }
+        cachedDriver.setAttributes(driver.getAttributes());
+    }
+
+    public void removeDriver(long driverId) throws SQLException {
+        dataManager.removeDriver(driverId);
+        if (drivers.containsKey(driverId)) {
+            String driverUniqueId = drivers.get(driverId).getUniqueId();
+            drivers.remove(driverId);
+            driversByUniqueId.remove(driverUniqueId);
+        }
+        refreshUserDrivers();
+        refresh();
+    }
+
+    public boolean checkDriver(long userId, long driverId) {
+        return getUserDrivers(userId).contains(driverId);
+    }
+
+    public Driver getDriver(long id) {
+        return drivers.get(id);
+    }
+
+    public Driver getDriverByUniqueId(String uniqueId) {
+        return driversByUniqueId.get(uniqueId);
+    }
+
+    public final Collection<Driver> getDrivers(Set<Long> driverIds) {
+        Collection<Driver> result = new LinkedList<>();
+        for (long driverId : driverIds) {
+            result.add(getDriver(driverId));
+        }
+        return result;
+    }
+
+    public final Set<Long> getAllDrivers() {
+        return drivers.keySet();
+    }
+
+    public final Set<Long> getManagedDrivers(long userId) {
+        Set<Long> drivers = new HashSet<>();
+        drivers.addAll(getUserDrivers(userId));
+        for (long managedUserId : Context.getPermissionsManager().getUserPermissions(userId)) {
+            drivers.addAll(getUserDrivers(managedUserId));
+        }
+        return drivers;
+    }
+}
diff --git a/src/org/traccar/database/PermissionsManager.java b/src/org/traccar/database/PermissionsManager.java
index 9a82efd48..82ca6af49 100644
--- a/src/org/traccar/database/PermissionsManager.java
+++ b/src/org/traccar/database/PermissionsManager.java
@@ -322,6 +322,19 @@ public class PermissionsManager {
         }
     }
 
+    public void checkDriver(long userId, long driverId) throws SecurityException {
+        if (!Context.getDriversManager().checkDriver(userId, driverId) && !isAdmin(userId)) {
+            checkManager(userId);
+            for (long managedUserId : getUserPermissions(userId)) {
+                if (Context.getDriversManager().checkDriver(managedUserId, driverId)) {
+                    return;
+                }
+            }
+            throw new SecurityException("Driver access denied");
+        }
+    }
+
+
     public void checkCalendar(long userId, long calendarId) throws SecurityException {
         if (!Context.getCalendarManager().checkCalendar(userId, calendarId) && !isAdmin(userId)) {
             checkManager(userId);