package art.servers.transactionsserver.controller;
|
|
|
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.DeviceAction;
|
import art.library.model.devices.DeviceActionResult;
|
import art.library.model.devices.DeviceCommands;
|
import art.library.model.devices.application.Application;
|
import art.library.model.devices.application.ApplicationInformation;
|
import art.library.model.devices.user.User;
|
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.devices.user.configuration.UserConfigurationPermissionInterop;
|
import art.library.model.devices.user.configuration.UserConfigurationPermissionInteropParameter;
|
import art.library.model.general.ModelFile;
|
import art.library.model.transactions.alarms.DeviceAlarmCommands;
|
import art.library.model.transactions.commands.ScheduledTaskProcedureCommands;
|
import art.library.model.transactions.scheduler.ScheduledTask;
|
import art.library.model.transactions.scheduler.ScheduledTaskProcedure;
|
import art.library.model.transactions.scheduler.ScheduledTaskProcedureInterval;
|
import art.library.model.transactions.tutor.trafficalerts.TrafficAlertProcedure;
|
import art.library.utils.licence.Licence;
|
import art.library.utils.resources.Resources;
|
import art.servers.transactionsserver.Shared;
|
import eu.medsea.mimeutil.MimeUtil2;
|
import java.io.File;
|
import java.io.FileOutputStream;
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Calendar;
|
import java.util.List;
|
|
|
|
public class ListenerImplementation extends art.servers.controller.ListenerImplementation
|
{
|
|
public ListenerImplementation()
|
{
|
}
|
|
|
// <editor-fold defaultstate="collapsed" desc="Java libraries">
|
|
public InteropResponse listJavaLibraries (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
|
// String folderName = (String)parameters.getParameterValue("folder");
|
// String folder = "data/" + Shared.getApplicationName() + "/";
|
// if (folderName != null) folder = folder + folderName + "/";
|
//
|
// File directory = new File(folder);
|
// List<File> lfiles = new ArrayList<File>();
|
// listFiles(directory, lfiles);
|
// List<ModelFile> lmodelfile = new ArrayList<ModelFile>();
|
//
|
// for (File file : lfiles)
|
// {
|
// try
|
// {
|
// if (file.isFile() == true)
|
// {
|
// ModelFile modelFile = new ModelFile();
|
// modelFile.folder = file.getAbsolutePath().replace(directory.getAbsolutePath(), "").replace("\\", "/").replaceFirst("/", "").replaceAll(file.getName(), "");
|
// if (folderName != null) modelFile.folder = modelFile.folder + "/" + folderName;
|
// modelFile.name = file.getName().substring(0, file.getName().lastIndexOf('.'));
|
// modelFile.extension = file.getName().substring(file.getName().lastIndexOf('.') + 1, file.getName().length());
|
//
|
// if (modelFile.extension.equalsIgnoreCase("svg"))
|
// {
|
// modelFile.mime = "image/svg+xml";
|
// }
|
// else
|
// {
|
// MimeUtil2 mimeUtil = new MimeUtil2();
|
// mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
|
// modelFile.mime = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file)).toString();
|
// }
|
//
|
// lmodelfile.add(modelFile);
|
// }
|
// }
|
// catch (Exception e)
|
// {
|
// }
|
// }
|
//
|
// InteropResponse response = new InteropResponse(lmodelfile.toArray(new ModelFile[lmodelfile.size()]));
|
// return response;
|
throw new Exception("Not implemented");
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
|
|
|
|
public InteropResponse getJavaLibrary (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
byte[] data = Resources.getExternalFileBytes(getFileName(parameters));
|
if (data.length == 0) data = Resources.getResourceBytes(getFileName(parameters));
|
InteropResponse response = new InteropResponse(data);
|
return response;
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
// </editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Alarms">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>addAlarmAction</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "username" class: <code>String</code>
|
* <p>name: "computer" class: <code>String</code>
|
* <p>name: "device" class: <code>String</code> device identifier who alarms belongs
|
* <p>name: "alarm" class: <code>String</code> Identifier of the alarm that is being validated, confirmed or cancelled
|
* <p>name: "type" class: <code>Int</code> type of action with alarm (DeviceAlarmCommands.TYPE_ALARM_VALIDATE, DeviceAlarmCommands.TYPE_ALARM_CONFIRM or DeviceAlarmCommands.TYPE_ALARM_CANCEL)
|
* @return <code>InteropResponse</code>
|
* @return <code>InteropResponse</code> with <code>true Boolean</code> if success
|
* @throws SerializationException
|
*/
|
|
public InteropResponse addAlarmAction(InteropParameters parameters) throws SerializationException
|
{
|
String language = (String) parameters.getParameterValue("language");
|
|
try
|
{
|
String username = (String) parameters.getParameterValue("username");
|
String computer = (String) parameters.getParameterValue("computer");
|
// String identifier = (String) parameters.getParameterValue("device");
|
// String alarm = (String) parameters.getParameterValue("alarm");
|
// int type = (parameters.hasParameter("type") == true) ? Integer.parseInt((String)parameters.getParameterValue("type")) : DeviceAlarmCommands.TYPE_ALARM_NOTHING;
|
|
DeviceAlarmCommands deviceAlarmCommands = parameters.getBodyContentValue(DeviceAlarmCommands.class);
|
|
Device device = null;
|
|
try
|
{
|
device = Shared.model.getDeviceExternal(deviceAlarmCommands.deviceIdentifier);
|
}
|
catch (Exception exception)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Device does not exist"), exception);
|
}
|
|
DeviceAction action = new DeviceAction(device, parameters, deviceAlarmCommands);
|
|
action.actionName = deviceAlarmCommands.getActionName();
|
|
DeviceActionResult result = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
|
action.setResult(result);
|
|
Shared.model.addAction(action);
|
|
return new InteropResponse(true);
|
}
|
catch (SerializationException exception)
|
{
|
throw exception;
|
}
|
catch (Exception e)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Error inserting alarm action"), e.getMessage());
|
}
|
}
|
|
//</editor-fold>
|
|
//<editor-fold defaultstate="collapsed" desc="ExternalLayers">
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>createExternalLayer</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lExternalLayer" class: <code>ExternalLayer[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse createExternalLayer(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.createExternalLayer(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>readExternalLayer</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "externalLayerName" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>ExternalLayer</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse readExternalLayer(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.readExternalLayer(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getExternalLayers</code>
|
* <p>name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>ExternalLayer[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getExternalLayers(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.getExternalLayers(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>updateExternalLayer</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lExternalLayer" class: <code>ExternalLayer[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse updateExternalLayer(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.updateExternalLayer(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>deleteExternalLayer</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lName" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse deleteExternalLayer(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.deleteExternalLayer(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>existExternalLayer</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "name" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse existExternalLayer(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelExternalLayers.existExternalLayer(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="GIS">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>createConfigurationGeoline</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lGeoLine" class: <code>GeoLine[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse createConfigurationGeoline(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.createConfigurationGeoline(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>readConfigurationGeoline</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "id" class: <code>Integer</code>
|
* @return <code>InteropResponse</code>
|
* <code>GeoLine</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse readConfigurationGeoline(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.readConfigurationGeoline(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>updateConfigurationGeoline</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lGeoLine" class: <code>GeoLine[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse updateConfigurationGeoline(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.updateConfigurationGeoline(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>deleteConfigurationGeoline</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lId" class: <code>Integer[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse deleteConfigurationGeoline(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.deleteConfigurationGeoline(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>existConfigurationGeoline</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "id" class: <code>Integer</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse existConfigurationGeoline(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.existConfigurationGeoline(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getLayerConfigurationByLayerAndZoom</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "geoline" class: <code>GeoLine</code>
|
* @return <code>InteropResponse</code>
|
* <code>GeoLine[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getLayerConfigurationByLayerAndZoom(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.getLayerConfigurationByLayerAndZoom(parameters);
|
}
|
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getLayerConfigurationByLayerName</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "layerName" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>GeoLine[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getLayerConfigurationByLayerName(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelConfigurationGeoline.getLayerConfigurationByLayerName(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Users">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>addDevices</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "body-content" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* @return <code>InteropResponse</code> with <code>true Boolean</code> if success
|
* @throws SerializationException
|
*/
|
|
public InteropResponse addUsers(InteropParameters parameters) throws SerializationException
|
{
|
return addDevices(parameters);
|
}
|
|
public InteropResponse addDevices(InteropParameters parameters) throws SerializationException
|
{
|
InteropResponse response;
|
String language = (String) parameters.getParameterValue("language");
|
boolean updateRole = false;
|
String username = "";
|
|
try
|
{
|
User[] luser = parameters.getBodyContentValue(User[].class);
|
|
for (User user : luser)
|
{
|
User currentuser = null;
|
|
username = user.getIdentifier();
|
createPermissions(user);
|
|
try
|
{
|
currentuser = (User)Shared.getModel().getDevice(user.getIdentifier());
|
}
|
catch (Exception e)
|
{
|
try
|
{
|
currentuser = (User)Shared.getModel().getDevice(Licence.encrypt(user.getIdentifier()));
|
}
|
catch (Exception ex)
|
{
|
currentuser = null;
|
}
|
}
|
|
if (currentuser != null) {
|
try
|
{
|
if (currentuser.getDeviceInformation().role.equals(user.getDeviceInformation().role) == false)
|
{
|
updateRole = true;
|
}
|
} catch (Exception ex) {
|
}
|
}
|
}
|
|
Shared.model.updateDevice(luser);
|
|
if (updateRole == true)
|
{
|
String resource = Shared.getMessage(language, "Username") + " : " + username;
|
Shared.traceInformation(Shared.getApplicationName(), Shared.getMessage(language, "Profile update"), resource, null, language);
|
}
|
|
return new InteropResponse(true);
|
}
|
catch (Exception e)
|
{
|
String resource = Shared.getMessage(language, "Username") + " : " + username;
|
Shared.traceError(Shared.getApplicationName(), Shared.getMessage(language, "Profile update"), resource, e, null, language);
|
throw new SerializationException("error inserting some users", e.getMessage());
|
}
|
}
|
|
|
private void createPermissions (User user) throws Exception
|
{
|
User userRole = null;
|
|
try
|
{
|
userRole = (User)Shared.getModel().getDevice(Licence.encrypt(user.getDeviceInformation().role));
|
}
|
catch (Exception exception)
|
{
|
try
|
{
|
userRole = (User)Shared.getModel().getDevice(user.getDeviceInformation().role);
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
if (userRole != null)
|
{
|
user.configuration = userRole.configuration;
|
}
|
else
|
{
|
if (user.getDeviceConfiguration() == null)
|
{
|
user.configuration = new UserConfiguration();
|
if (user.getDeviceConfiguration().permissions == null)
|
{
|
user.getDeviceConfiguration().permissions = new UserPermission();
|
}
|
}
|
|
if ("IMH".equalsIgnoreCase(user.getDeviceInformation().role))
|
{
|
user.getDeviceConfiguration().permissions.linterop.clear();
|
|
String regex = "[\\s\\S]*";
|
UserConfigurationPermissionInterop interopGetGeoJson = new UserConfigurationPermissionInterop();
|
interopGetGeoJson.operation = "^getGeoJson.*";
|
interopGetGeoJson.application = "art.servers.zbe.ermserver";
|
interopGetGeoJson.devicesAllow.add(regex);
|
UserConfigurationPermissionInteropParameter permissionParameter = new UserConfigurationPermissionInteropParameter();
|
permissionParameter.name = regex;
|
permissionParameter.values.add(regex);
|
interopGetGeoJson.parametersAllow.add(permissionParameter);
|
user.getDeviceConfiguration().permissions.linterop.add(interopGetGeoJson);
|
|
UserConfigurationPermissionInterop interopGetVehicle = new UserConfigurationPermissionInterop();
|
interopGetVehicle.operation = "^getVehicle";
|
interopGetVehicle.application = "art.servers.zbe.listserver";
|
interopGetVehicle.devicesAllow.add(regex);
|
UserConfigurationPermissionInteropParameter permissionParameterVehicle = new UserConfigurationPermissionInteropParameter();
|
permissionParameterVehicle.name = regex;
|
permissionParameterVehicle.values.add(regex);
|
interopGetVehicle.parametersAllow.add(permissionParameterVehicle);
|
user.getDeviceConfiguration().permissions.linterop.add(interopGetVehicle);
|
}
|
else
|
{
|
user.getDeviceConfiguration().permissions.linterop.clear();
|
|
String regex = "[\\s\\S]*";
|
UserConfigurationPermissionInterop interop = new UserConfigurationPermissionInterop();
|
interop.actionsAllow.add(regex);
|
interop.devicesAllow.add(regex);
|
interop.application = regex;
|
interop.operation = regex;
|
UserConfigurationPermissionInteropParameter permissionParameter = new UserConfigurationPermissionInteropParameter();
|
permissionParameter.name = regex;
|
permissionParameter.values.add(regex);
|
interop.parametersAllow.add(permissionParameter);
|
user.getDeviceConfiguration().permissions.linterop.add(interop);
|
}
|
}
|
}
|
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getUsers</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "body-content" class: <code>String[]</code>
|
* <p>name: "timestamp" class: <code>Long</code>*
|
* @return <code>InteropResponse</code>
|
* <code>User[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getUsers(InteropParameters parameters) throws SerializationException
|
{
|
try
|
{
|
String language = parameters.hasParameter("language") ? parameters.getParameterValue("language") : Shared.getLanguage();
|
String[] lusername = parameters.getBodyContentValue(String[].class);
|
long timestamp = parameters.hasParameter("timestamp") ? getTimestamp(parameters.getParameterValue("timestamp")) : 0L;
|
return new InteropResponse(Shared.getModel().getDevices(lusername, timestamp));
|
} catch (Exception e)
|
{
|
throw new SerializationException(Shared.getMessage("error getting users"), e);
|
}
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getUsersIdentification</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lGroup" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>UserIdentification[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getUsersIdentification(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelUsers.getUsersIdentification(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getUsersIdentification</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lGroup" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>UserIdentification[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getUsersInformation(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelUsers.getUsersInformation(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getUserLdap</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "username" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>UserInformation</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getUserLdap(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelUsers.getUserLdap(parameters);
|
}
|
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "art" class: <code>updatePasswordUser</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "username" class: <code>String</code>
|
* <p>name: "oldpassword" class: <code>String</code>
|
* <p>name: "newpassword" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* @return <code>InteropResponse</code> with <code>true Boolean</code> if success
|
* @throws SerializationException
|
*/
|
|
public InteropResponse updatePasswordUser(InteropParameters parameters) throws SerializationException
|
{
|
try
|
{
|
String language = parameters.hasParameter("language") ? parameters.getParameterValue("language") : Shared.getLanguage();
|
String username = parameters.hasParameter("username") ? parameters.getParameterValue("username") : null;
|
String oldpassword = parameters.hasParameter("oldpassword") ? parameters.getParameterValue("oldpassword") : null;
|
String newpassword = parameters.hasParameter("newpassword") ? parameters.getParameterValue("newpassword") : null;
|
|
if (username == null)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Username cannot be null"));
|
}
|
else if (oldpassword == null)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Old password cannot be null"));
|
}
|
else if (newpassword == null)
|
{
|
throw new SerializationException(Shared.getMessage(language, "New password cannot be null"));
|
}
|
|
User user = (User)Shared.getModel().getDevice(Licence.encrypt(username));
|
String currentpassword = Licence.decrypt(user.getDeviceInformation().password);
|
if (currentpassword.equals(oldpassword) == false)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Old password is not correct"));
|
}
|
|
User newuser = Serialization.clone(user);
|
newuser.getDeviceInformation().password = Licence.encrypt(newpassword);
|
Shared.model.updateDevice(user, newuser);
|
|
return new InteropResponse(new Boolean(true));
|
}
|
catch (SerializationException e)
|
{
|
throw e;
|
}
|
catch (Exception e)
|
{
|
throw new SerializationException(Shared.getMessage("Error updating user password"), e);
|
}
|
}
|
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Sessions">
|
public InteropResponse login(InteropParameters parameters) throws SerializationException
|
{
|
InteropResponse response = startSession(parameters);
|
return response;
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>startSession</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "identification" class: <code>SessionIdentification</code>
|
* <p>name: "lUserIdentification" class: <code>UserIdentification[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Session</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse startSession(InteropParameters parameters) throws SerializationException
|
{
|
InteropResponse response = Shared.getModel().modelSessions.startSession(parameters);
|
return response;
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>addUsersSession</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "session" class: <code>Session</code>
|
* <p>name: "lUserIdentification" class: <code>UserIdentification[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Session</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse addUsersSession(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelSessions.addUsersSession(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>removeUsersSession</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "session" class: <code>Session</code>
|
* <p>name: "lusername" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Session</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse removeUsersSession(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelSessions.removeUsersSession(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>endSession</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "identification" class: <code>SessionIdentification</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse endSession(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelSessions.endSession(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Permissions">
|
public InteropResponse checkToken(InteropParameters parameters) throws SerializationException
|
{
|
return new InteropResponse(new Boolean(true));
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getPermissions</code>
|
* <p>name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>ListPermission</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getPermissions(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelPermissions.getPermissions(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getUserPermission</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lusername" class: <code>String[]</code>
|
* <p>name: "timestamp" class: <code>Long</code>
|
* @return <code>InteropResponse</code>
|
* <code>UserPermission</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getUserPermission(InteropParameters parameters) throws SerializationException
|
{
|
try
|
{
|
return Shared.getModel().modelPermissions.getUserPermission(parameters);
|
} catch (Exception ex)
|
{
|
throw new SerializationException(Shared.getMessage("Error getting user permissions"), ex);
|
}
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Alarms">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getAlarmsInformation</code>
|
* <p>name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>AlarmInformation[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getAlarmsInformation(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelAlarms.getAlarmsInformation(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getAlarmsUserConfiguration</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "lusername" class: <code>String[]</code>
|
* <p>name: "timestamp" class: <code>Long</code> *OPTIONAL
|
* @return <code>InteropResponse</code>
|
* <code>UserAlarmConfiguration[]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getAlarmsUserConfiguration(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelAlarms.getAlarmsUserConfiguration(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Messages">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "get" class: <code>getConfigurationLanguage</code>
|
* <p>name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code>
|
* <code>ConfigurationLanguage</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getConfigurationLanguage(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelMessages.getConfigurationLanguage(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>name: "set" class: <code>setConfigurationLanguage</code>
|
* <p>name: "language" class: <code>String</code>
|
* <p>name: "configurationLanguage" class: <code>String[]</code>
|
* @return <code>InteropResponse</code>
|
* <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse setConfigurationLanguage(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelMessages.setConfigurationLanguage(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Applications">
|
public InteropResponse getApplications(InteropParameters parameters) throws SerializationException
|
{
|
String language = (String) parameters.getParameterValue("language");
|
long timestamp = 0;
|
|
try
|
{
|
if (parameters.hasParameter("timestamp"))
|
{
|
timestamp = Long.parseLong((String) parameters.getParameterValue("timestamp"));
|
}
|
|
Application[] result = Shared.getModel().getApplications(timestamp);
|
|
return new InteropResponse(result);
|
} catch (Exception e)
|
{
|
String msg = "error getting applications";
|
throw new SerializationException(e.getMessage());
|
}
|
}
|
|
public InteropResponse getApplicationsInformation(InteropParameters parameters) throws SerializationException
|
{
|
String language = (String) parameters.getParameterValue("language");
|
long timestamp = 0;
|
try
|
{
|
if (parameters.hasParameter("timestamp"))
|
{
|
timestamp = Long.parseLong((String) parameters.getParameterValue("timestamp"));
|
}
|
|
Application[] lapplication = Shared.getModel().getApplications(timestamp);
|
ApplicationInformation[] result = new ApplicationInformation[lapplication.length];
|
|
for (int i = 0; i < lapplication.length; i++)
|
{
|
result[i] = lapplication[i].getDeviceInformation();
|
}
|
|
return new InteropResponse(result);
|
}
|
catch (Exception e)
|
{
|
String msg = "error getting applications Information";
|
throw new SerializationException(e.getMessage());
|
}
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Login blocked Manager">
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>
|
* name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code> <code>AddressLogin[0]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getBlockedUsers(InteropParameters parameters) throws SerializationException {
|
return Shared.getModel().loginBlockedManager.getBlockedUsers(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>
|
* name: "language" class: <code>String</code>
|
* <p>
|
* name: "body-content" class: <code>String[]</code>
|
* @return <code>InteropResponse</code> <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse unlockUsers(InteropParameters parameters) throws SerializationException {
|
try
|
{
|
return Shared.getModel().loginBlockedManager.unlockUsers(
|
parameters.getBodyContentValue(String[].class));
|
} catch (Exception exception)
|
{
|
throw new SerializationException(Shared.getMessage(exception.getMessage()), exception);
|
}
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>
|
* name: "language" class: <code>String</code>
|
* @return <code>InteropResponse</code> <code>AddressLogin[0]</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse getBlockedIPAddresses(InteropParameters parameters) throws SerializationException {
|
|
return Shared.getModel().loginBlockedManager.getBlockedIPAddresses(parameters);
|
}
|
|
/**
|
* @param parameters <code>InteropParameters</code>
|
* <p>
|
* name: "language" class: <code>String</code>
|
* <p>
|
* name: "body-content" class: <code>String[]</code>
|
* @return <code>InteropResponse</code> <code>Boolean</code>
|
* @throws SerializationException
|
*/
|
public InteropResponse unlockIPAddresses(InteropParameters parameters) throws SerializationException {
|
try
|
{
|
return Shared.getModel().loginBlockedManager.unlockIPAddress(
|
parameters.getBodyContentValue(String[].class));
|
} catch (Exception exception)
|
{
|
throw new SerializationException(Shared.getMessage(exception.getMessage()), exception);
|
}
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Vms messages">
|
public InteropResponse addVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.addVmsGeneralCommandsMessages(parameters);
|
}
|
|
public InteropResponse removeVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.removeVmsGeneralCommandsMessages(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessages(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsMessagesFolders(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesFolders(parameters);
|
}
|
|
public InteropResponse renameVmsGeneralCommandsMessagesFolder(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.renameVmsGeneralCommandsMessagesFolder(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsMessageTypes(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessageTypes(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsMessagesFoldersDevice(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesFoldersDevice(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsMessagesDeviceFolder(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesDeviceFolder(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Vms pictograms">
|
public InteropResponse addVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.addVmsGeneralCommandsPictogram(parameters);
|
}
|
|
public InteropResponse removeVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.removeVmsGeneralCommandsPictogram(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogram(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsPictogramFolders(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogramFolders(parameters);
|
}
|
|
public InteropResponse renameVmsGeneralCommandsPictogramFolder(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.renameVmsGeneralCommandsPictogramFolder(parameters);
|
}
|
|
public InteropResponse getVmsGeneralCommandsPictogramTypes(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogramTypes(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="User Configuration Video">
|
public InteropResponse setUserConfigurationVideo(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVideo.setUserConfigurationVideo(parameters);
|
}
|
|
public InteropResponse addCameraInformationPresetOfLoggedUsers(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVideo.addCameraInformationPresetOfLoggedUsers(parameters);
|
}
|
|
public InteropResponse deleteCameraInformationPresetOfLoggedUsers(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelVideo.deleteCameraInformationPresetOfLoggedUsers(parameters);
|
}
|
//</editor-fold>
|
|
|
//<editor-fold defaultstate="collapsed" desc="Generic objects folders">
|
|
public InteropResponse getObjectsFolders(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.getObjectsFolders(parameters);
|
}
|
|
public InteropResponse getObjectsSummary(InteropParameters parameters) throws SerializationException
|
{
|
parameters.addParameter("summary", null);
|
return Shared.getModel().modelCrudObject.getObjects(parameters);
|
}
|
|
public InteropResponse getObjects(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.getObjects(parameters);
|
}
|
|
public InteropResponse addObject(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.addObject(parameters);
|
}
|
|
public InteropResponse addHistoricalObject(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.addHistoricalObject(parameters);
|
}
|
|
public InteropResponse removeObject(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.removeObject(parameters);
|
}
|
|
public InteropResponse renameObjectFolder(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.renameObjectFolder(parameters);
|
}
|
//</editor-fold>
|
|
|
// <editor-fold defaultstate="collapsed" desc="File server">
|
|
|
|
public InteropResponse listFiles (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
String folderName = (String)parameters.getParameterValue("folder");
|
String folder = "data/" + Shared.getApplicationName() + "/";
|
if (folderName != null) folder = folder + folderName + "/";
|
|
File directory = new File(folder);
|
List<File> lfiles = new ArrayList<File>();
|
listFiles(directory, lfiles);
|
List<ModelFile> lmodelfile = new ArrayList<ModelFile>();
|
|
for (File file : lfiles)
|
{
|
try
|
{
|
if (file.isFile() == true)
|
{
|
ModelFile modelFile = new ModelFile();
|
modelFile.folder = file.getAbsolutePath().replace(directory.getAbsolutePath(), "").replace("\\", "/").replaceFirst("/", "").replaceAll(file.getName(), "");
|
if (folderName != null) modelFile.folder = modelFile.folder + "/" + folderName;
|
modelFile.name = file.getName().substring(0, file.getName().lastIndexOf('.'));
|
modelFile.extension = file.getName().substring(file.getName().lastIndexOf('.') + 1, file.getName().length());
|
|
if (modelFile.extension.equalsIgnoreCase("svg"))
|
{
|
modelFile.mime = "image/svg+xml";
|
}
|
else
|
{
|
MimeUtil2 mimeUtil = new MimeUtil2();
|
mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
|
modelFile.mime = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file)).toString();
|
}
|
|
lmodelfile.add(modelFile);
|
}
|
}
|
catch (Exception e)
|
{
|
}
|
}
|
|
InteropResponse response = new InteropResponse(lmodelfile.toArray(new ModelFile[lmodelfile.size()]));
|
return response;
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
|
|
|
|
public InteropResponse getFile (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
byte[] data = Resources.getExternalFileBytes(getFileName(parameters));
|
if (data.length == 0) data = Resources.getResourceBytes(getFileName(parameters));
|
InteropResponse response = new InteropResponse(data);
|
response.mime = "image/svg+xml";
|
return response;
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
|
|
|
public InteropResponse addFile (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
byte[] data = parameters.getParameterValue("body-content");
|
File file = new File(getFileName(parameters));
|
file.getParentFile().mkdirs();
|
FileOutputStream fos = new FileOutputStream(file);
|
fos.write(data);
|
fos.close();
|
return new InteropResponse(new Boolean(true));
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
|
|
|
public InteropResponse removeFile (InteropParameters parameters) throws SerializationException
|
{
|
String language = (String)parameters.getParameterValue("language");
|
|
try
|
{
|
File file = new File(getFileName(parameters));
|
return new InteropResponse(new Boolean(file.delete()));
|
}
|
catch (Exception e)
|
{
|
throw getException(language, e);
|
}
|
}
|
|
|
|
private void listFiles (File directory, List<File> lfile) throws SerializationException
|
{
|
for (File file : directory.listFiles())
|
{
|
if (file.isDirectory() == true)
|
{
|
listFiles(file, lfile);
|
}
|
else
|
{
|
lfile.add(file);
|
}
|
}
|
}
|
|
|
|
private String getFileName(InteropParameters parameters) throws Exception
|
{
|
String folderName = (String)parameters.getParameterValue("folder");
|
String fileName = (String)parameters.getParameterValue("name");
|
String fileExtension = (String)parameters.getParameterValue("extension");
|
|
String result = "data/" + Shared.getApplicationName() + "/";
|
|
if (folderName != null) result = result + "/" + folderName;
|
if (fileName != null) result = result + "/" + fileName;
|
if (fileExtension != null) result = result + "." + fileExtension;
|
|
return result.replace("\\","/").replace("//", "/");
|
}
|
|
|
// </editor-fold>
|
|
|
|
public InteropResponse getDefaultRecordingPath(InteropParameters parameters) throws SerializationException
|
{
|
try
|
{
|
return new InteropResponse(Shared.getConfiguration().videoViewer.defaultRecordingPath);
|
}
|
catch (Exception e)
|
{
|
throw new SerializationException(Shared.getMessage("the default route could not be obtained"), e);
|
}
|
}
|
|
|
|
//<editor-fold defaultstate="collapsed" desc="Procedure/Schedule Tasks">
|
|
public InteropResponse getScheduledTasks(InteropParameters parameters) throws SerializationException
|
{
|
return Shared.getModel().modelCrudObject.getScheduledTasks(parameters);
|
}
|
|
|
public InteropResponse getScheduledProceduresManual(InteropParameters parameters) throws SerializationException
|
{
|
String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
|
String computer = parameters.hasParameter("computer") ? (String) parameters.getParameterValue("computer") : "?";
|
long millis = System.currentTimeMillis();
|
|
try
|
{
|
// Search SceduledTask that must be executed at this moment and
|
// that contain a manual procedure (with decisions and not automatic actions)
|
|
// Shared.println("Listener " + computer, "Getting ScheduledTasks");
|
List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());
|
// Shared.println("Listener " + computer, "Get ScheduledTasks: " + lobject.size());
|
List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();
|
|
long timestamp = System.currentTimeMillis();
|
|
for (Object object : lobject)
|
{
|
ScheduledTask task = (ScheduledTask)object;
|
// Shared.println("Listener " + computer, "Checking ScheduledTask: " + task.folder + " - " + task.name);
|
if (task.scheduledTask != null)
|
{
|
if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
|
{
|
if (task.scheduledTask.procedure.isManual() == true)
|
{
|
if (task.scheduledTask.specificTimestamp > 0)
|
{
|
// TODO Es correcto esto?
|
if ((timestamp <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestamp + 30000L)))
|
{
|
if (task.scheduledTask.procedure.isManual() == true) lresult.add(task);
|
}
|
}
|
else
|
{
|
timestamp = toScheduledTaskTimestamp(timestamp);
|
if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
|
{
|
/**
|
* Specific time interval every day of week
|
* Timestamp 0 : Monday, 00:00:00
|
* Timestamp 86.400.000 : Tuesday, 00:00:00
|
* Null if not used
|
*/
|
|
for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
|
{
|
if ((weekly.from<=timestamp) && (timestamp<=weekly.to))
|
{
|
lresult.add(task);
|
break;
|
}
|
}
|
}
|
else
|
{
|
ScheduledTaskProcedureInterval interval = null;
|
if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
|
if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;
|
|
if (interval != null)
|
{
|
if ((interval.from<=timestamp) && (timestamp<=interval.to))
|
{
|
lresult.add(task);
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// Shared.println("Listener " + computer, "Checked ScheduledTask: " + task.folder + " - " + task.name);
|
}
|
|
|
// Search the procedures of Segments that have an active traffic alert
|
// Shared.println("Listener " + computer, "Getting active traffic alerts");
|
List<ScheduledTask> ltrafficAlertScheduledTask = getActiveTrafficAlert();
|
lresult.addAll(ltrafficAlertScheduledTask);
|
// Shared.println("Listener " + computer, "Get active traffic alerts: " + ltrafficAlertScheduledTask.size() + " - " + (System.currentTimeMillis()-millis));
|
|
return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
|
}
|
catch (SerializationException exception)
|
{
|
throw exception;
|
}
|
catch (Exception exception)
|
{
|
throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
|
}
|
}
|
|
|
public InteropResponse getScheduledProceduresAuto(InteropParameters parameters) throws SerializationException
|
{
|
String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
|
|
try
|
{
|
List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());
|
|
List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();
|
|
long timestampCurrent = System.currentTimeMillis();
|
long timestampWeekly = toScheduledTaskTimestamp(timestampCurrent);
|
|
for (Object object : lobject)
|
{
|
ScheduledTask task = (ScheduledTask)object;
|
if (task.scheduledTask != null)
|
{
|
Shared.println("Listener", "1.TaskAuto: " + task.folder + "/" + task.name + " - Enabled: " + task.scheduledTask.enabled);
|
if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
|
{
|
Shared.println("Listener", "2.TaskAuto Procedure: " + task.scheduledTask.procedure.folder + "/" + task.scheduledTask.procedure.name);
|
if (task.scheduledTask.procedure.isManual() == false)
|
{
|
Shared.println("Listener", "3.TaskAuto Automatic Procedure: " + task.scheduledTask.procedure.folder + "/" + task.scheduledTask.procedure.name);
|
if (task.scheduledTask.specificTimestamp > 0)
|
{
|
if ((timestampCurrent <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestampCurrent + 30000L)))
|
{
|
lresult.add(task);
|
}
|
}
|
else
|
{
|
Shared.println("Listener", "4.TaskAuto Automatic Procedure weekly: " + Device.getDate(timestampCurrent));
|
Shared.println("Listener", "5.TaskAuto Automatic Procedure weekly: " + Device.getDate(timestampWeekly));
|
if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
|
{
|
/**
|
* Specific time interval every day of week
|
* Timestamp 0 : Monday, 00:00:00
|
* Timestamp 86.400.000 : Tuesday, 00:00:00
|
* Null if not used
|
*/
|
|
for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
|
{
|
Shared.println("Listener", "6.TaskAuto Automatic Procedure weekly: " + "From: " + Device.getDate(weekly.from) + " - Timestamp: " + Device.getDate(timestampWeekly) + " - To: " + Device.getDate(weekly.to));
|
if ((weekly.from<=timestampWeekly) && (timestampWeekly<=weekly.to))
|
{
|
lresult.add(task);
|
break;
|
}
|
}
|
}
|
else
|
{
|
ScheduledTaskProcedureInterval interval = null;
|
if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
|
if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;
|
|
if (interval != null)
|
{
|
if ((interval.from<=timestampWeekly) && (timestampWeekly<=interval.to))
|
{
|
lresult.add(task);
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
|
return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
|
}
|
catch (SerializationException exception)
|
{
|
exception.printStackTrace();
|
throw exception;
|
}
|
catch (Exception exception)
|
{
|
exception.printStackTrace();
|
throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
|
}
|
}
|
|
|
public InteropResponse isScheduledProcedureValid(InteropParameters parameters) throws SerializationException
|
{
|
String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
|
|
try
|
{
|
Shared.println("Listener", "isScheduledProcedureValid Getting ScheduledTask");
|
ScheduledTask task = (ScheduledTask)parameters.getBodyContentValue(ScheduledTask.class);
|
Shared.println("Listener", "isScheduledProcedureValid Get ScheduledTask: " + task);
|
|
long timestamp = getTimestampScheduledTask(task, System.currentTimeMillis());
|
|
// Check if has been accepted by anyone ==> return(false)
|
// Check if has been rejected by this username from this computer ==> return(false)
|
String username = parameters.hasParameter("username") ? (String) parameters.getParameterValue("username") : null;
|
String computer = parameters.hasParameter("computer") ? (String) parameters.getParameterValue("computer") : null;
|
|
String where = "type='" + User.class.getName() + "' AND timestamp>=" + timestamp + " AND timestamp<" + System.currentTimeMillis();
|
List<DeviceAction> laction = Shared.model.getActions(where);
|
Shared.println("Listener", "isScheduledProcedureValid actions: " + laction.size() + " - " + Device.getDate(timestamp));
|
|
for (DeviceAction action : laction)
|
{
|
try
|
{
|
if (action.actionClassType.equalsIgnoreCase(ScheduledTaskProcedureCommands.class.getCanonicalName()) == true)
|
{
|
ScheduledTaskProcedureCommands commands = action.getAction();
|
Shared.println("Listener", "isScheduledProcedureValid Confirmation: " + commands.confirmation);
|
if (commands.confirmation == DeviceCommands.CONDITION_YES)
|
{
|
if (Serialization.equals(task.scheduledTask, commands.taskProcedure))
|
{
|
Shared.println("Listener", "isScheduledProcedureValid Confirmed Procedure");
|
return new InteropResponse(new Boolean(false));
|
}
|
}
|
else if (commands.confirmation == DeviceCommands.CONDITION_NO)
|
{
|
Shared.println("Listener", "isScheduledProcedureValid Confirmation NO: " + action.username + " - " + username + " - " + action.computer + " - " + computer);
|
if ((action.username.equalsIgnoreCase(username) == true) &&
|
(action.computer.equalsIgnoreCase(computer) == true) &&
|
(Serialization.equals(task.scheduledTask, commands.taskProcedure)))
|
{
|
Shared.println("Listener", "isScheduledProcedureValid Rejected Procedure");
|
return new InteropResponse(new Boolean(false));
|
}
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
Shared.printstack("Listener", e);
|
}
|
}
|
}
|
catch (Exception exception)
|
{
|
Shared.printstack("Listener", exception);
|
}
|
|
return new InteropResponse(new Boolean(true));
|
}
|
|
|
public InteropResponse setScheduledProcedureState(InteropParameters parameters) throws SerializationException
|
{
|
String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
|
|
try
|
{
|
String username = parameters.hasParameter("username") ? (String) parameters.getParameterValue("username") : null;
|
|
if (username == null)
|
{
|
throw new SerializationException(Shared.getMessage(language, "Not received username"));
|
}
|
|
boolean accepted = (parameters.hasParameter("accept") == true) ? ((String)parameters.getParameterValue("accept")).equalsIgnoreCase("yes") : false;
|
|
// TODO
|
// Check that not exist an action of the same type, for the same SheduledTask/Procedure accepted in scheduled task period
|
// If exist throw an exception indicating it
|
// Save action in database
|
Shared.println("Listener", "Accepting task: " + accepted);
|
ScheduledTask task = (ScheduledTask)parameters.getBodyContentValue(ScheduledTask.class);
|
Shared.println("Listener", "Accepting task: " + accepted + " - " + task);
|
ScheduledTaskProcedureCommands commands = new ScheduledTaskProcedureCommands();
|
commands.confirmation = DeviceCommands.CONDITION_YES;
|
if (accepted == false) commands.confirmation = DeviceCommands.CONDITION_NO;
|
commands.taskProcedure = task.scheduledTask;
|
|
User userAction = new User();
|
userAction.information = new UserInformation();
|
try
|
{
|
userAction.information.setIdentifier(Licence.decrypt(username));
|
}
|
catch (Exception e)
|
{
|
userAction.information.setIdentifier(username);
|
}
|
|
DeviceAction action = new DeviceAction(userAction, parameters, commands);
|
DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
|
action.setResult(actionResult);
|
Shared.model.addAction(action);
|
|
return new InteropResponse(new Boolean(true));
|
}
|
catch (Exception exception)
|
{
|
Shared.printstack("Listener", exception);
|
}
|
|
return new InteropResponse(new Boolean(false));
|
}
|
|
//</editor-fold>
|
|
|
public InteropResponse getScheduledProceduresManualTest(InteropParameters parameters) throws SerializationException
|
{
|
String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
|
|
try
|
{
|
// TODO David
|
// Buscar los ScheduledTask que han de ejecutarse en este momento y
|
// que contienen un procedure manual (con ifs o acciones no automaticas)
|
List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());
|
|
List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();
|
|
long timestamp = System.currentTimeMillis();
|
|
for (Object object : lobject)
|
{
|
ScheduledTask task = (ScheduledTask)object;
|
if (task.scheduledTask != null)
|
{
|
if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
|
{
|
if (task.scheduledTask.procedure.isManual() == true)
|
{
|
lresult.add(task);
|
// if (task.scheduledTask.specificTimestamp > 0)
|
// {
|
// if ((timestamp <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestamp + 30000L)))
|
// {
|
// if (task.scheduledTask.procedure.isManual() == true) lresult.add(task);
|
// }
|
// }
|
// else
|
// {
|
// timestamp = toScheduledTaskTimestamp(timestamp);
|
// if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
|
// {
|
// /**
|
// * Specific time interval every day of week
|
// * Timestamp 0 : Monday, 00:00:00
|
// * Timestamp 86.400.000 : Tuesday, 00:00:00
|
// * Null if not used
|
// */
|
//
|
// for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
|
// {
|
// if ((weekly.from<=timestamp) && (timestamp<=weekly.to))
|
// {
|
// lresult.add(task);
|
// break;
|
// }
|
// }
|
// }
|
// else
|
// {
|
// ScheduledTaskProcedureInterval interval = null;
|
// if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
|
// if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;
|
//
|
// if (interval != null)
|
// {
|
// if ((interval.from<=timestamp) && (timestamp<=interval.to))
|
// {
|
// lresult.add(task);
|
// break;
|
// }
|
// }
|
// }
|
// }
|
}
|
}
|
}
|
}
|
|
return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
|
}
|
catch (SerializationException exception)
|
{
|
exception.printStackTrace();
|
throw exception;
|
}
|
catch (Exception exception)
|
{
|
exception.printStackTrace();
|
throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
|
}
|
}
|
|
|
|
|
private long toScheduledTaskTimestamp(long timestamp)
|
{
|
try
|
{
|
long sumvalue = 86400000;
|
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTimeInMillis(timestamp);
|
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
|
int hour = calendar.get(Calendar.HOUR_OF_DAY);
|
int minutes = calendar.get(Calendar.MINUTE);
|
int seconds = calendar.get(Calendar.SECOND);
|
int milliseconds = calendar.get(Calendar.MILLISECOND);
|
long day = 0;
|
if (weekday == Calendar.MONDAY)
|
day = 0;
|
if (weekday == Calendar.TUESDAY)
|
day = 1;
|
if (weekday == Calendar.WEDNESDAY)
|
day = 2;
|
if (weekday == Calendar.THURSDAY)
|
day = 3;
|
if (weekday == Calendar.FRIDAY)
|
day = 4;
|
if (weekday == Calendar.SATURDAY)
|
day = 5;
|
if (weekday == Calendar.SUNDAY)
|
day = 6;
|
|
long result = day * sumvalue;
|
result = result + (hour*60L*60000L) + (minutes*60000L) + (seconds*1000L) + milliseconds;
|
return(result);
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
return(timestamp);
|
}
|
|
|
|
|
private long scheduledTaskTimestampToTimestamp(long from)
|
{
|
try
|
{
|
long sumvalue = 86400000;
|
|
Calendar calendar = Calendar.getInstance();
|
calendar.setTimeInMillis(System.currentTimeMillis());
|
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
|
int hour = calendar.get(Calendar.HOUR_OF_DAY);
|
int minutes = calendar.get(Calendar.MINUTE);
|
int seconds = calendar.get(Calendar.SECOND);
|
int milliseconds = calendar.get(Calendar.MILLISECOND);
|
long day = 0;
|
if (weekday == Calendar.MONDAY)
|
day = 0;
|
if (weekday == Calendar.TUESDAY)
|
day = 1;
|
if (weekday == Calendar.WEDNESDAY)
|
day = 2;
|
if (weekday == Calendar.THURSDAY)
|
day = 3;
|
if (weekday == Calendar.FRIDAY)
|
day = 4;
|
if (weekday == Calendar.SATURDAY)
|
day = 5;
|
if (weekday == Calendar.SUNDAY)
|
day = 6;
|
|
int taskday = (int)(from / sumvalue);
|
|
if (taskday == day)
|
{
|
Calendar calendar2 = Calendar.getInstance();
|
calendar2.setTimeInMillis(System.currentTimeMillis());
|
calendar2.set(Calendar.HOUR_OF_DAY, 0);
|
calendar2.set(Calendar.MINUTE, 0);
|
calendar2.set(Calendar.SECOND, 0);
|
calendar2.set(Calendar.MILLISECOND, 0);
|
calendar2.add(Calendar.MILLISECOND, (int)(from % sumvalue));
|
return(calendar2.getTimeInMillis());
|
}
|
}
|
catch (Exception e)
|
{
|
|
}
|
|
return(-1);
|
}
|
|
|
private List<ScheduledTask> getActiveTrafficAlert() throws SerializationException
|
{
|
List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();
|
|
try
|
{
|
// Shared.println("Listener", "Sending request active traffic alerts");
|
// Buscar los procedures de Segments que tienen la traffic alert activa
|
Application applicationSegment = Shared.getModel().getApplicationService("traveltime");
|
// Shared.println("Listener", "Sending request active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName);
|
InteropParameters parameters = new InteropParameters();
|
parameters.addParameter(new InteropParameter("service", applicationSegment.getDeviceInformation().serverServiceName));
|
parameters.addParameter(new InteropParameter("operation", "getTrafficAlertProcedures"));
|
parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
|
// Shared.println("Listener", "Sending socket request active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName);
|
InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, applicationSegment.getDeviceInformation().serverAddress, applicationSegment.getDeviceInformation().serverPort, 30000);
|
TrafficAlertProcedure[] ltrafficAlertProcedures = Arrays.copyOf(response.getValue(), response.getValue().length, TrafficAlertProcedure[].class);
|
// Shared.println("Listener", "Received response active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName + " - " + ltrafficAlertProcedures.length);
|
|
for (TrafficAlertProcedure trafficAlertProcedure : ltrafficAlertProcedures)
|
{
|
try
|
{
|
ScheduledTask scheduledTask = new ScheduledTask();
|
scheduledTask.folder = "";
|
scheduledTask.name = "";
|
scheduledTask.description = "";
|
scheduledTask.scheduledTask = new ScheduledTaskProcedure();
|
scheduledTask.scheduledTask.procedure = trafficAlertProcedure.procedure;
|
scheduledTask.scheduledTask.specificTimestamp = trafficAlertProcedure.tsTrafficAlert;
|
|
lresult.add(scheduledTask);
|
}
|
catch (Exception e)
|
{
|
|
}
|
}
|
|
// Shared.println("Listener", "Returning active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName + " - " + lresult.size());
|
}
|
catch (Exception exception)
|
{
|
|
}
|
|
return (lresult);
|
}
|
|
|
private long getTimestampScheduledTask (ScheduledTask task, long currenttime) throws SerializationException
|
{
|
try
|
{
|
if (task.scheduledTask != null)
|
{
|
if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
|
{
|
if (task.scheduledTask.specificTimestamp > 0)
|
{
|
return(task.scheduledTask.specificTimestamp);
|
}
|
else
|
{
|
if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
|
{
|
long tsWeekly = -1;
|
for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
|
{
|
long ts = scheduledTaskTimestampToTimestamp(weekly.from);
|
if ((ts > 0) && (ts <= currenttime))
|
{
|
if (tsWeekly < 0)
|
{
|
tsWeekly = ts;
|
}
|
else if ((tsWeekly > 0) && (ts > tsWeekly))
|
{
|
// Coger el que se aproxime mas a la fecha actual (anterior)
|
tsWeekly = ts;
|
}
|
}
|
}
|
|
if (tsWeekly > 0) return(tsWeekly);
|
}
|
else if (task.scheduledTask.interval != null)
|
{
|
}
|
else if (task.scheduledTask.monthly != null)
|
{
|
}
|
}
|
}
|
}
|
}
|
catch (Exception exception)
|
{
|
}
|
|
return (System.currentTimeMillis());
|
}
|
|
}
|
