package art.servers.transactionsserver;
|
|
import art.library.gui.flat.FlatDialog;
|
import art.library.interop.InteropParameter;
|
import art.library.interop.InteropParameters;
|
import art.library.interop.InteropResponse;
|
import art.library.interop.serialization.Serialization;
|
import art.library.interop.serialization.SerializationException;
|
import art.library.model.devices.Device;
|
import art.library.model.devices.DevicePersistenceHistorical;
|
import art.library.model.devices.DevicePersistenceTimeless;
|
import art.library.model.devices.application.Application;
|
import art.library.model.devices.user.User;
|
import art.library.model.devices.user.UserAlarmConfiguration;
|
import art.library.model.devices.user.UserConfiguration;
|
import art.library.model.devices.user.UserInformation;
|
import art.library.model.devices.user.UserPermission;
|
import art.library.model.transactions.alarms.AlarmInformation;
|
import art.library.model.transactions.permissions.ListPermission;
|
import art.library.model.transactions.permissions.PermissionFeature;
|
import art.library.persistence.Persistence;
|
import art.library.utils.licence.Licence;
|
import art.library.utils.resources.Resources;
|
import art.servers.ServerException;
|
import art.servers.configuration.Configuration;
|
import art.servers.transactionsserver.controller.ControllerTransactions;
|
import art.servers.transactionsserver.model.access.ModelPermissions;
|
import art.servers.transactionsserver.model.access.ModelSessions;
|
import art.servers.transactionsserver.model.access.ModelUsers;
|
import art.servers.transactionsserver.model.access.login.BlockingNotificationEmailSender;
|
import art.servers.transactionsserver.model.access.login.LoginBlockedManager;
|
import art.servers.transactionsserver.model.alarms.ModelAlarms;
|
import art.servers.transactionsserver.model.configuration.ModelMessages;
|
import art.servers.transactionsserver.model.gis.ModelConfigurationGeoline;
|
import art.servers.transactionsserver.model.gis.ModelExternalLayers;
|
import art.servers.transactionsserver.model.objects.ModelCrudObject;
|
import art.servers.transactionsserver.model.video.ModelVideo;
|
import art.servers.transactionsserver.model.vms.ModelVmsMessagesLibrary;
|
import art.servers.transactionsserver.model.vms.ModelVmsPictogramsLibrary;
|
import java.io.File;
|
import java.io.PrintWriter;
|
import java.io.StringWriter;
|
import java.text.SimpleDateFormat;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Calendar;
|
import java.util.List;
|
import java.util.logging.Level;
|
import java.util.logging.Logger;
|
import java.util.stream.Collectors;
|
|
public class Model extends art.servers.Model
|
{
|
|
public ModelUsers modelUsers;
|
public ModelSessions modelSessions;
|
public ModelPermissions modelPermissions;
|
public ModelAlarms modelAlarms;
|
public ModelMessages modelMessages;
|
public ModelExternalLayers modelExternalLayers;
|
public ModelConfigurationGeoline modelConfigurationGeoline;
|
public ModelVmsMessagesLibrary modelVmsMessagesLibrary;
|
public ModelVmsPictogramsLibrary modelVmsPictogramsLibrary;
|
public ModelVideo modelVideo;
|
public ModelCrudObject modelCrudObject;
|
|
public LoginBlockedManager loginBlockedManager;
|
public ControllerTransactions controllerTransactions;
|
public BlockingNotificationEmailSender blockingNotificationEmailSender;
|
|
|
public Model(Configuration configuration) throws Exception
|
{
|
super(configuration, null, User.class.getName(), UserInformation.class.getName());
|
|
try
|
{
|
modelUsers = new ModelUsers();
|
modelSessions = new ModelSessions();
|
modelPermissions = new ModelPermissions();
|
modelAlarms = new ModelAlarms();
|
modelMessages = new ModelMessages();
|
modelConfigurationGeoline = new ModelConfigurationGeoline();
|
modelExternalLayers = new ModelExternalLayers();
|
modelVmsMessagesLibrary = new ModelVmsMessagesLibrary();
|
modelVmsPictogramsLibrary = new ModelVmsPictogramsLibrary();
|
modelVideo = new ModelVideo();
|
modelCrudObject = new ModelCrudObject();
|
|
blockingNotificationEmailSender = new BlockingNotificationEmailSender(configuration.lsmtp, ((art.servers.transactionsserver.configuration.Configuration)configuration).loginBlockedManager.lnotificationMail);
|
loginBlockedManager = new LoginBlockedManager(((art.servers.transactionsserver.configuration.Configuration)configuration).loginBlockedManager, blockingNotificationEmailSender);
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
throw e;
|
}
|
}
|
|
public void initializeRootUser() throws Exception
|
{
|
InteropParameters parameters = new InteropParameters();
|
parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
|
InteropResponse response = modelPermissions.getPermissions(parameters);
|
ListPermission lPermission = (ListPermission) response.getValue()[0];
|
|
//If user is not in the json configuration file do nothing
|
//User user = Shared.getConfiguration().administrator;
|
User user = (User) Shared.getModel().getDevice(Licence.encrypt("root"));
|
if (user != null)
|
{
|
user.information.setCreationTimestamp(configurationSymbolsTimestamp);
|
|
user.configuration = new UserConfiguration();
|
user.getDeviceConfiguration().permissions = new UserPermission();
|
|
//USER PERMISSIONS
|
List<PermissionFeature> lPermissionFeature = lPermission.permissionsFeature;
|
user.getDeviceConfiguration().permissions.lPermissionFeature.addAll(lPermissionFeature);
|
|
//USER ALARMS
|
AlarmInformation[] aAlarm;
|
try
|
{
|
response = modelAlarms.getAlarmsInformation(parameters);
|
aAlarm = Arrays.copyOf(response.getValue(), response.getValue().length, AlarmInformation[].class);
|
}
|
catch (Exception e)
|
{
|
String msg = "error getting alarms configuration";
|
initializeAlarmsInformation();
|
}
|
finally
|
{
|
response = modelAlarms.getAlarmsInformation(parameters);
|
aAlarm = Arrays.copyOf(response.getValue(), response.getValue().length, AlarmInformation[].class);
|
}
|
user.getDeviceConfiguration().lalarmConfiguration = new ArrayList<>();
|
for (AlarmInformation alarmInformation : aAlarm)
|
{
|
UserAlarmConfiguration alarmUserConfiguration = new UserAlarmConfiguration();
|
alarmUserConfiguration.clazz = alarmInformation.clazz;
|
alarmUserConfiguration.deviceIdentifier = alarmInformation.deviceIdentifier;
|
alarmUserConfiguration.alarmName = alarmInformation.alarmName;
|
user.getDeviceConfiguration().lalarmConfiguration.add(alarmUserConfiguration);
|
}
|
|
updateDevice(user);
|
}
|
}
|
|
private void initializeAlarmsInformation() throws Exception
|
{
|
if (modelAlarms != null)
|
{
|
modelAlarms.generateAlarmsJson();
|
}
|
}
|
|
|
@SuppressWarnings("unchecked")
|
public void readDevices()
|
{
|
mutexListDevices.lockWrite();
|
|
try
|
{
|
ldevice.clear();
|
mdevice.clear();
|
|
if (Shared.controllerDatabase != null)
|
{
|
List<Device> ldevice = (List<Device>) DevicePersistenceTimeless.getDevices((List<Object>) (List<?>) Shared.controllerDatabase.timeless_getObject(DevicePersistenceTimeless.class.getName(), "type = '" + User.class.getName() + "'"));
|
|
for (Device device : ldevice)
|
{
|
//if ((device instanceof User)
|
// && (device.getDeviceInformation().serverPort == Shared.configuration.listener.port)
|
// && (device.getDeviceInformation().serverAddress.equalsIgnoreCase(Shared.configuration.listener.address)))
|
if (device instanceof User)
|
{
|
User user = (User) device;
|
user.information = (UserInformation) user.getDeviceInformation();
|
user.information.serverAddress = Shared.configuration.listener.address;
|
user.information.serverPort = Shared.configuration.listener.port;
|
user.information.serverAddressExternal = Shared.configuration.listener.addressExternal;
|
user.information.serverPortExternal = Shared.configuration.listener.portExternal;
|
this.ldevice.add(device);
|
this.mdevice.put(device.getIdentifier(), device);
|
}
|
}
|
}
|
} catch (Exception e)
|
{
|
e.printStackTrace();
|
} finally
|
{
|
}
|
|
try
|
{
|
UserInformation[] luserInformation = null;
|
|
if (new File(Shared.getApplicationName() + ".users.json").exists())
|
{
|
try{luserInformation = (UserInformation[]) Serialization.deserialize(UserInformation[].class, new File(Shared.getApplicationName() + ".users.json"));}
|
catch (Exception e)
|
{
|
Logger.getLogger(Model.class.getName()).log(Level.INFO, "message");
|
}
|
} else
|
{
|
if (new File("data/" + Shared.getApplicationName() + ".users.json").exists())
|
{
|
try{luserInformation = (UserInformation[]) Serialization.deserialize(UserInformation[].class, Resources.getResourceStream("data/" + Shared.getApplicationName() + ".users.json"));} catch (Exception e){}
|
}
|
}
|
|
if (luserInformation != null)
|
{
|
for (UserInformation userInformation : luserInformation)
|
{
|
String password = Licence.encrypt(userInformation.password);
|
String identifier = Licence.encrypt(userInformation.getIdentifier());
|
if (mdevice.containsKey(identifier) == false)
|
{
|
userInformation.setIdentifier(identifier);
|
userInformation.password = password;
|
addDevice(userInformation);
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
StringWriter sw = new StringWriter();
|
e.printStackTrace(new PrintWriter(sw));
|
FlatDialog.showDialog(null, Shared.getMessage("Error"), e.getMessage() + "\n\n" + sw.toString(), true, FlatDialog.DIALOG_INFORMATION);
|
}
|
|
mutexListDevices.releaseWrite();
|
}
|
|
public void addDevices(UserInformation[] linformation) throws Exception
|
{
|
// Es ineficiente, pero hay que tener en cuenta que es una operación residual
|
|
mutexListDevices.lockWrite();
|
|
try
|
{
|
for (UserInformation information : linformation)
|
{
|
addDevice(information);
|
}
|
} catch (Exception e)
|
{
|
} finally
|
{
|
mutexListDevices.releaseWrite();
|
}
|
}
|
|
private void addDevice(UserInformation information) throws Exception
|
{
|
|
User user = (User) mdevice.get(information.getIdentifier());
|
|
long timestamp = System.currentTimeMillis();
|
|
if (user == null)
|
{
|
user = new User(information.getIdentifier());
|
user.information = information;
|
user.information.setCreationTimestamp(timestamp);
|
user.information.serverAddress = Shared.configuration.listener.address;
|
user.information.serverPort = Shared.configuration.listener.port;
|
user.information.serverAddressExternal = Shared.configuration.listener.addressExternal;
|
user.information.serverPortExternal = Shared.configuration.listener.portExternal;
|
user.setLastTimestampInformationUpdate(timestamp);
|
|
if (Shared.controllerDatabase != null)
|
{
|
Shared.controllerDatabase.timeless_updateOrAddObject(new DevicePersistenceTimeless(user));
|
|
try
|
{
|
Shared.controllerDatabase.historical_updateOrAddObject(new DevicePersistenceHistorical(user));
|
}
|
catch (org.postgresql.util.PSQLException exception)
|
{
|
if ((exception.getMessage().toUpperCase().indexOf("NO PARTITION OF RELATION") > -1) ||
|
(exception.getMessage().toUpperCase().indexOf("NO SE ENCONTRÓ UNA PARTICIÓN") > -1))
|
{
|
try
|
{
|
Calendar calendar1 = Calendar.getInstance();
|
calendar1.setTimeInMillis(user.getLastTimestampUpdate());
|
calendar1.set(Calendar.DATE, 1);
|
calendar1.set(Calendar.HOUR_OF_DAY, 0);
|
calendar1.set(Calendar.MINUTE, 0);
|
calendar1.set(Calendar.SECOND, 0);
|
calendar1.set(Calendar.MILLISECOND, 0);
|
|
SimpleDateFormat formato1 = new SimpleDateFormat("yyyy_MM");
|
|
String tablename = "devices_" + formato1.format(calendar1.getTimeInMillis());
|
long startdate = calendar1.getTimeInMillis();
|
calendar1.add(Calendar.MONTH, 1);
|
long enddate = calendar1.getTimeInMillis();
|
|
String query1 = "CREATE UNLOGGED TABLE IF NOT EXISTS " + tablename + " PARTITION OF devices FOR VALUES FROM ('" + startdate + "') TO ('" + enddate + "')";
|
try{art.servers.Shared.controllerDatabase.historical_update(query1);} catch (Exception e){};
|
executeAlterTableDevicesVacuum(true, tablename);
|
|
// Do again the insert
|
try
|
{
|
art.servers.Shared.controllerDatabase.historical_updateOrAddObject(new DevicePersistenceHistorical(user));
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
}
|
}
|
}
|
mdevice.put(user.getIdentifier(), user);
|
ldevice.add(user);
|
} else
|
{
|
if (Serialization.equals(user.information, information) == false)
|
{
|
user.information = information;
|
user.setLastTimestampInformationUpdate(timestamp);
|
Shared.controllerDatabase.timeless_updateOrAddObject(new DevicePersistenceTimeless(user));
|
Shared.controllerDatabase.historical_updateOrAddObject(new DevicePersistenceHistorical(user));
|
}
|
}
|
}
|
|
|
public User[] getDevices(String lusername[], long timestamp)
|
{
|
List<User> luser = new ArrayList<>();
|
for (String username : lusername)
|
{
|
try
|
{
|
User nextUser = (User) getDevice(username);
|
if ((nextUser.getLastTimestampUpdate() > timestamp) || (nextUser.getLastTimestampUpdate() == 0))
|
{
|
luser.add(nextUser);
|
}
|
}
|
catch (Exception ex)
|
{
|
}
|
}
|
return luser.toArray(new User[0]);
|
}
|
|
|
@SuppressWarnings("unchecked")
|
public List<User> getDevicesUserGenericGroup()
|
{
|
try
|
{
|
List<User> luser = (List<User>) (List<?>) Arrays.asList(getDevices());
|
List<User> luserAdmin = luser.stream()
|
.filter(u -> u.getDeviceInformation().groupManager == true)
|
.collect(Collectors.toList());
|
return luserAdmin;
|
}
|
catch (Exception e)
|
{
|
e.printStackTrace();
|
}
|
return new ArrayList<User>();
|
}
|
|
private String decryptUsername(String username)
|
{
|
try
|
{
|
return Licence.decrypt(username);
|
}
|
catch (Exception ex)
|
{
|
Logger.getLogger(Model.class.getName()).log(Level.SEVERE, null, ex);
|
}
|
return "";
|
}
|
|
@SuppressWarnings("unchecked")
|
public Application[] getApplications(Long timestamp) throws SerializationException
|
{
|
try
|
{
|
List<Application> result = new ArrayList<>();
|
for (Persistence persistence : Shared.controllerDatabase.getTimelessPersistance())
|
{
|
List<DevicePersistenceTimeless> ldevicePersistenceTimeless = (List<DevicePersistenceTimeless>) (List<?>) persistence.getObject(DevicePersistenceTimeless.class.getName(), "type = '" + Application.class.getName() + "'");
|
for (DevicePersistenceTimeless devicePersistenceTimeless : ldevicePersistenceTimeless)
|
{
|
Application device = (Application) devicePersistenceTimeless.device;
|
|
if ((device != null) && (device.getLastTimestampUpdate() > timestamp))
|
{
|
result.add(device);
|
}
|
}
|
}
|
|
return result.toArray(new Application[0]);
|
}
|
catch (Exception e)
|
{
|
String msg = "error getting applications";
|
throw new SerializationException(e.getMessage());
|
}
|
}
|
}
|
