/**
* Checks if our WPS can really handle this process inputs and outputs
*
* @param pf
* @param name
* @return
*/
Set<Name> getProcessBlacklist() {
synchronized (PROCESS_BLACKLIST) {
if (PROCESS_BLACKLIST == Collections.EMPTY_SET) {
Set<Name> blacklist = new HashSet<Name>();
for (ProcessFactory pf : Processors.getProcessFactories()) {
int count = 0;
for (Name name : pf.getNames()) {
try {
// check inputs
for (Parameter<?> p : pf.getParameterInfo(name).values()) {
List<ProcessParameterIO> ppios = ProcessParameterIO.findAll(p, context);
if (ppios.isEmpty()) {
LOGGER.log(
Level.INFO,
"Blacklisting process "
+ name.getURI()
+ " as the input "
+ p.key
+ " of type "
+ p.type
+ " cannot be handled");
blacklist.add(name);
}
}
// check outputs
for (Parameter<?> p : pf.getResultInfo(name, null).values()) {
List<ProcessParameterIO> ppios = ProcessParameterIO.findAll(p, context);
if (ppios.isEmpty()) {
LOGGER.log(
Level.INFO,
"Blacklisting process "
+ name.getURI()
+ " as the output "
+ p.key
+ " of type "
+ p.type
+ " cannot be handled");
blacklist.add(name);
}
}
} catch (Throwable t) {
blacklist.add(name);
}
if (!blacklist.contains(name)) {
count++;
}
}
LOGGER.info("Found " + count + " bindable processes in " + pf.getTitle());
}
PROCESS_BLACKLIST = blacklist;
}
}
return PROCESS_BLACKLIST;
}
@Override
public void onWebSocketClose(final int closeCode, final String message) {
logger.log(
Level.INFO,
"Connection closed with closeCode {0} and message {1}",
new Object[] {closeCode, message});
final App app = StructrApp.getInstance(securityContext);
try (final Tx tx = app.tx()) {
this.session = null;
syncController.unregisterClient(this);
// flush and close open uploads
for (FileUploadHandler upload : uploads.values()) {
upload.finish();
}
tx.success();
uploads.clear();
} catch (FrameworkException fex) {
logger.log(Level.SEVERE, "Error while closing connection", fex);
}
}
/**
* Method description
*
* @param app
* @param net
* @throws SSLException
*/
public void wrap(ByteBuffer app, ByteBuffer net) throws SSLException {
tlsEngineResult = tlsEngine.wrap(app, net);
if (log.isLoggable(Level.FINEST)) {
log.log(
Level.FINEST,
"{0}, tlsEngineRsult.getStatus() = {1}, tlsEngineRsult.getHandshakeStatus() = {2}",
new Object[] {
debugId, tlsEngineResult.getStatus(), tlsEngineResult.getHandshakeStatus()
});
}
if (tlsEngineResult.getHandshakeStatus() == SSLEngineResult.HandshakeStatus.FINISHED) {
if (eventHandler != null) {
eventHandler.handshakeCompleted(this);
}
}
if (tlsEngineResult.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
doTasks();
if (log.isLoggable(Level.FINEST)) {
log.log(
Level.FINEST,
"doTasks(): {0}, {1}",
new Object[] {tlsEngine.getHandshakeStatus(), debugId});
}
}
}
@Override
public <T> T execute(Task<T> task) throws Exception {
long startTime = System.currentTimeMillis();
logger.log(logLevel, "start executing task " + task);
try {
return super.execute(task);
} catch (Exception e) {
logger.log(
logLevel,
"executing task "
+ task
+ " failed after "
+ (System.currentTimeMillis() - startTime)
+ " ms");
throw e;
} finally {
logger.log(
logLevel,
"finished executing task "
+ task
+ " in "
+ (System.currentTimeMillis() - startTime)
+ " ms");
}
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
Cookie[] cookies = request.getCookies();
int userID = -1;
boolean newUser = false;
// determine whether we've seen this user before
if (cookies != null) {
for (Cookie c : cookies) {
if (c.getName().equals("userID")) {
userID = Integer.parseInt(c.getValue());
logger.log(Level.INFO, "Existing user: "******"userID", String.valueOf(userID));
response.addCookie(c);
logger.log(Level.INFO, "New user: "******"text/html");
response.setStatus(HttpServletResponse.SC_OK);
PrintWriter out = response.getWriter();
String title = "Cookie Servlet";
String bootstrapHeader =
"<!DOCTYPE html>"
+ "<html lang=\"en\">\n"
+ " <head>\n"
+ " <title>"
+ title
+ "</title>\n"
+ " <meta charset=\"utf-8\">\n"
+ " <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n"
+ " <link rel=\"stylesheet\" href=\"http://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/css/bootstrap.min.css\">\n"
+ " <script src=\"https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js\"></script>\n"
+ " <script src=\"http://maxcdn.bootstrapcdn.com/bootstrap/3.3.5/js/bootstrap.min.js\"></script>\n"
+ " </head>\n";
String body =
" <body>\n"
+ " <div class=\"container\">\n"
+ " <p>Hello, "
+ (newUser ? "new" : "existing")
+ " user!</p>\n"
+ " </div>\n"
+ " </body>\n";
String footer = "</html>";
String page = bootstrapHeader + body + footer;
out.println(page);
}
@GET
public Response authorize(@Context HttpServletRequest request) {
if (context == null) {
throw new RuntimeException("Servlet Context has not been injected");
}
if (identityManager == null) {
try {
identityManager = OAuthServerUtil.handleIdentityManager(context);
} catch (IOException e) {
log.log(Level.SEVERE, "Identity Manager setup:", e);
throw new RuntimeException(e);
}
if (identityManager == null) {
throw new RuntimeException("Identity Manager has not been created");
}
}
OAuthResponse response = null;
try {
response = OAuthServerUtil.authorizationCodeRequest(request, identityManager);
} catch (OAuthSystemException e) {
log.log(Level.SEVERE, "OAuth Server Authorization Processing:", e);
return Response.serverError().build();
}
// Check for successful processing
String location = response.getLocationUri();
if (location != null && location.isEmpty() == false) {
return Response.status(response.getResponseStatus()).location(URI.create(location)).build();
} else { // We have error
return Response.status(response.getResponseStatus()).entity(response.getBody()).build();
}
}
@Override
public Talk convertLineToTalk(String line) {
if (line == null || line.isEmpty()) {
throw new IllegalArgumentException("line must not be null or empty");
}
line = line.replaceAll("\\s+", " ").trim();
Pattern pattern = Pattern.compile("(.*)(\\s){1}([0-2]?[0-9]?[0-9]{1}min|lightning)\\b");
Matcher matcher = pattern.matcher(line);
if (!matcher.matches()) {
LOG.log(Level.SEVERE, "Line [{0}] is not recognised by the converter", line);
throw new ProposalConverterException();
}
final String title = matcher.group(1);
final String duration = matcher.group(3);
int durationMinutes = 0;
if (duration.equals(IProposalLineConverter.LIGHTNING_TEXT)) {
durationMinutes = IProposalLineConverter.LIGHTNING_DURATION;
} else {
try {
durationMinutes = Integer.parseInt(duration.substring(0, duration.indexOf(MINUTE_SUFFIX)));
} catch (NumberFormatException e) {
LOG.log(Level.SEVERE, "NumberFormatException while parsing minutes into Integer", e);
throw new ProposalConverterException();
}
}
return new Talk(title, durationMinutes);
}
protected URL lookupBpmPlatformXmlLocationFromJndi() {
String jndi = "java:comp/env/" + BPM_PLATFORM_XML_LOCATION;
try {
String bpmPlatformXmlLocation = InitialContext.doLookup(jndi);
URL fileLocation = checkValidBpmPlatformXmlResourceLocation(bpmPlatformXmlLocation);
if (fileLocation != null) {
LOGGER.log(
Level.INFO,
"Found camunda bpm platform configuration in JNDI ["
+ jndi
+ "] at "
+ fileLocation.toString());
}
return fileLocation;
} catch (NamingException e) {
LOGGER.log(
Level.FINE,
"Failed to look up camunda bpm platform configuration in JNDI [" + jndi + "].",
e);
}
return null;
}
public void setUpSolrFile(String url) throws Exception {
if (setUpIsDone) {
return;
}
// do the setup
File testDir = (Paths.get(getClass().getResource("/" + testFile).toURI()).getParent()).toFile();
ProcessBuilder pb =
new ProcessBuilder("java", "-Durl=" + url + "/update", "-jar", "post.jar", testFile);
pb.directory(testDir);
LOGGER.log(Level.FINE, "Starting SOLR import");
final Process command = pb.start();
LOGGER.log(Level.FINE, "Started SOLR import");
String line;
BufferedReader bri = new BufferedReader(new InputStreamReader(command.getInputStream()));
BufferedReader bre = new BufferedReader(new InputStreamReader(command.getErrorStream()));
while ((line = bri.readLine()) != null) {
LOGGER.log(Level.FINE, line);
}
bri.close();
while ((line = bre.readLine()) != null) {
LOGGER.log(Level.FINE, line);
}
bre.close();
int i = command.waitFor();
assertTrue(i == 0);
LOGGER.log(Level.FINE, "SOLR import DONE!");
setUpIsDone = true;
}
private static String getMessageFromResourceBundle(String key, Locale locale) {
ResourceBundle bundle;
String message = "";
if (locale == null) {
locale = FacesContext.getCurrentInstance().getViewRoot().getLocale();
}
try {
bundle = ResourceBundle.getBundle(BUNDLE_NAME, locale, getCurrentLoader(BUNDLE_NAME));
if (bundle == null) {
return NOT_FOUND;
}
} catch (MissingResourceException e) {
LOGGER.log(Level.INFO, e.getMessage(), e);
return NOT_FOUND;
}
try {
message = bundle.getString(key);
} catch (Exception e) {
LOGGER.log(Level.INFO, e.getMessage(), e);
}
return message;
}
public boolean removePlayer(RocketPlayer player) {
logger.log(Level.INFO, "{0} leaves {1}", new Object[] {player.getName(), this.getName()});
AppContext.getDataManager().markForUpdate(this);
Channel tableChannel = tableChannelRef.getForUpdate();
tableChannel.leave(player.getClientSessionRef().get());
// The reference created below should be identical to one of the players
// on our table. I think createReference has some clever logic to
// not create another reference if one already exists.
ManagedReference<RocketPlayer> playerRef = AppContext.getDataManager().createReference(player);
if (playerRef.equals(player1Ref)) {
player1Ref = null;
} else if (playerRef.equals(player2Ref)) {
player2Ref = null;
} else if (playerRef.equals(player3Ref)) {
player3Ref = null;
} else if (playerRef.equals(player4Ref)) {
player4Ref = null;
} else {
logger.log(
Level.SEVERE, "player " + player.getName() + " doesn't appear to be one of this table!");
return false;
}
setTableAvailable(true);
maybeChangeStatusOnRemovePlayer();
return true;
}
public static ResultSet executeSql(final Statement statement, final String sql) {
ResultSet results = null;
if (statement == null) {
return results;
}
if (isBlank(sql)) {
LOGGER.log(Level.FINE, "No SQL provided", new RuntimeException());
return results;
}
try {
statement.clearWarnings();
final boolean hasResults = statement.execute(sql);
if (hasResults) {
results = statement.getResultSet();
} else {
final int updateCount = statement.getUpdateCount();
LOGGER.log(
Level.FINE,
String.format("No results. Update count of %d for query: %s", updateCount, sql));
}
SQLWarning sqlWarning = statement.getWarnings();
while (sqlWarning != null) {
LOGGER.log(Level.INFO, sqlWarning.getMessage(), sqlWarning);
sqlWarning = sqlWarning.getNextWarning();
}
return results;
} catch (final SQLException e) {
LOGGER.log(Level.WARNING, "Error executing: " + sql, e);
return null;
}
}
public synchronized void checkPayments() throws BitcoinException {
Bitcoin.TransactionsSinceBlock t =
monitorBlock == null ? bitcoin.listSinceBlock() : bitcoin.listSinceBlock(monitorBlock);
for (Bitcoin.Transaction transaction : t.transactions()) {
if ("receive".equals(transaction.category())) {
if (!seen.add(transaction.txId())) continue;
for (BitcoinPaymentListener listener : listeners) {
try {
listener.transaction(transaction);
} catch (Exception ex) {
logger.log(Level.SEVERE, null, ex);
}
}
}
}
if (!t.lastBlock().equals(lastBlock)) {
seen.clear();
lastBlock = t.lastBlock();
updateMonitorBlock();
for (BitcoinPaymentListener listener : listeners) {
try {
listener.block(lastBlock);
} catch (Exception ex) {
logger.log(Level.SEVERE, null, ex);
}
}
}
}
@Post
public void newReport(Representation value) throws FileUploadException, IOException {
if (value == null || !MediaType.MULTIPART_FORM_DATA.equals(value.getMediaType(), true)) {
logger.log(Level.SEVERE, "POST request with no entity.");
getResponse().setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
return;
}
RequestParam parameters = Util.getParameters(getRequest());
if (parameters == null) {
logger.log(Level.SEVERE, "POST request with invalid parameters");
getResponse().setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
return;
}
Report report = Util.createReport(parameters);
if (report == null) {
getResponse().setStatus(Status.CLIENT_ERROR_UNAUTHORIZED);
} else {
getResponse().setStatus(Status.SUCCESS_CREATED);
}
return;
}
public void send(final WebSocketMessage message, final boolean clearSessionId) {
// return session status to client
message.setSessionValid(isAuthenticated());
// whether to clear the token (all command except LOGIN (for now) should absolutely do this!)
if (clearSessionId) {
message.setSessionId(null);
}
// set callback
message.setCallback(callback);
if (isAuthenticated() || "STATUS".equals(message.getCommand())) {
String msg = gson.toJson(message, WebSocketMessage.class);
logger.log(
Level.FINE,
"############################################################ SENDING \n{0}",
msg);
try {
session.getRemote().sendString(msg);
} catch (Throwable t) {
logger.log(Level.WARNING, "Unable to send websocket message to remote client");
}
} else {
logger.log(Level.WARNING, "NOT sending message to unauthenticated client.");
}
}
/**
* Find the branch type by branch type id.
*
* @param branchTypeId the branch type id.
* @return the BranchType with the given id, or null if the branchType is not found.
*/
@Override
public BranchType findById(Integer branchTypeId) {
BranchType branchType = null;
ResultSet resultSet = null;
PreparedStatement preparedStatement = null;
try {
Connection connection = DatabaseManager.getInstance().getConnection();
preparedStatement =
connection.prepareStatement(
FIND_BY_ID, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
preparedStatement.setInt(1, branchTypeId);
resultSet = preparedStatement.executeQuery();
if (resultSet.next()) {
String branchTypeName = resultSet.getString(2);
branchType = new BranchType();
branchType.setBranchTypeId(branchTypeId);
branchType.setBranchTypeName(branchTypeName);
}
} catch (SQLException e) {
LOGGER.log(Level.SEVERE, "BranchTypeDAOImpl: SQL exception in findById", e);
} catch (IllegalStateException e) {
LOGGER.log(Level.SEVERE, "BranchTypeDAOImpl: exception in findById", e);
} finally {
closeDbResources(resultSet, preparedStatement);
}
return branchType;
}
/**
* Find all branch types.
*
* @return a List of all the branch types.
*/
@Override
public List<BranchType> findAll() {
List<BranchType> branchTypeList = new ArrayList<>();
ResultSet resultSet = null;
PreparedStatement preparedStatement = null;
try {
Connection connection = DatabaseManager.getInstance().getConnection();
preparedStatement =
connection.prepareStatement(
FIND_ALL, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
resultSet = preparedStatement.executeQuery();
while (resultSet.next()) {
Integer branchTypeId = resultSet.getInt(1);
String branchTypeName = resultSet.getString(2);
BranchType branchType = new BranchType();
branchType.setBranchTypeId(branchTypeId);
branchType.setBranchTypeName(branchTypeName);
branchTypeList.add(branchType);
}
} catch (SQLException e) {
LOGGER.log(Level.SEVERE, "BranchTypeDAOImpl: SQL exception in findAll", e);
} catch (IllegalStateException e) {
LOGGER.log(Level.SEVERE, "BranchTypeDAOImpl: exception in findAll", e);
} finally {
closeDbResources(resultSet, preparedStatement);
}
return branchTypeList;
}
/**
* Uploads a media file to the Joomla instance.
*
* @param subfolder Subfolder to upload the file
* @param filename Name of the file to upload
* @param filedata Data contained in the file
* @return Relative URL of the uploaded file
* @throws JoomlaException If the file could not be uploaded
*/
public String uploadMediaFile(String subfolder, String filename, byte[] filedata)
throws JoomlaException {
try {
LOG.log(Level.INFO, "Uploading {0}", new Object[] {filename});
TimingOutCallback callback = new TimingOutCallback((getTimeout() + 120) * 1000);
XmlRpcClient client = getXmlRpcClient();
Object[] params = new Object[] {username, password, subfolder, filename, filedata};
client.executeAsync(XMLRPC_METHOD_NEW_MEDIA, params, callback);
String location = (String) callback.waitForResponse();
LOG.log(Level.INFO, "Media file #{0} uploaded to {1}", new Object[] {filename, location});
return location;
} catch (TimeoutException ex) {
throw new JoomlaException(ex);
} catch (XmlRpcException ex) {
throw new JoomlaException(ex);
} catch (IOException ex) {
throw new JoomlaException(ex);
} catch (Throwable t) {
throw new JoomlaException(t);
}
}
protected String autoCompleteUrl(String url) {
if (url != null) {
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, "Autocompleting url : [" + url + "]");
}
if (!url.endsWith(BPM_PLATFORM_XML_FILE)) {
String appender;
if (url.contains("/")) {
appender = "/";
} else {
appender = "\\";
}
if (!(url.endsWith("/") || url.endsWith("\\\\"))) {
url += appender;
}
url += BPM_PLATFORM_XML_FILE;
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, "Autocompleted url : [" + url + "]");
}
}
return url;
}
private String readGraphVizOpts(final Config config) {
final String scGraphVizOptsCfg = getStringValue(config, GRAPH_GRAPHVIZ_OPTS, "");
if (!Utility.isBlank(scGraphVizOptsCfg)) {
LOGGER.log(
Level.CONFIG,
"Using additional GraphViz command-line options from config, " + scGraphVizOptsCfg);
return scGraphVizOptsCfg;
}
final String scGraphVizOptsProp = System.getProperty(SC_GRAPHVIZ_OPTS);
if (!Utility.isBlank(scGraphVizOptsProp)) {
LOGGER.log(
Level.CONFIG,
"Using additional GraphViz command-line options from SC_GRAPHVIZ_OPTS system property, "
+ scGraphVizOptsProp);
return scGraphVizOptsProp;
}
final String scGraphVizOptsEnv = System.getenv(SC_GRAPHVIZ_OPTS);
if (!Utility.isBlank(scGraphVizOptsEnv)) {
LOGGER.log(
Level.CONFIG,
"Using additional GraphViz command-line options from SC_GRAPHVIZ_OPTS environmental variable, "
+ scGraphVizOptsEnv);
return scGraphVizOptsEnv;
}
return "";
}
protected SelectableChannel getSelectableChannel(
SocketAddress remoteAddress, SocketAddress localAddress) throws IOException {
SocketChannel newSocketChannel = SocketChannel.open();
Socket newSocket = newSocketChannel.socket();
if (receiveBufferSize > 0) {
try {
newSocket.setReceiveBufferSize(receiveBufferSize);
} catch (SocketException se) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setReceiveBufferSize exception ", se);
} catch (IllegalArgumentException iae) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setReceiveBufferSize exception ", iae);
}
}
if (sendBufferSize > 0) {
try {
newSocket.setSendBufferSize(sendBufferSize);
} catch (SocketException se) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setSendBufferSize exception ", se);
} catch (IllegalArgumentException iae) {
if (logger.isLoggable(Level.FINE))
logger.log(Level.FINE, "setSendBufferSize exception ", iae);
}
}
newSocket.setReuseAddress(reuseAddress);
if (localAddress != null) newSocket.bind(localAddress);
newSocketChannel.configureBlocking(false);
return newSocketChannel;
}
/**
* Return the appropriate {@link javax.faces.webapp.FacesServlet} mapping based on the servlet
* path of the current request.
*
* @param servletPath the servlet path of the request
* @param pathInfo the path info of the request
* @return the appropriate mapping based on the current request
* @see javax.servlet.http.HttpServletRequest#getServletPath()
*/
private static String getMappingForRequest(String servletPath, String pathInfo) {
if (servletPath == null) {
return null;
}
if (LOGGER.isLoggable(Level.FINE)) {
LOGGER.log(Level.FINE, "servletPath " + servletPath);
LOGGER.log(Level.FINE, "pathInfo " + pathInfo);
}
// If the path returned by HttpServletRequest.getServletPath()
// returns a zero-length String, then the FacesServlet has
// been mapped to '/*'.
if (servletPath.length() == 0) {
return "/*";
}
// presence of path info means we were invoked
// using a prefix path mapping
if (pathInfo != null) {
return servletPath;
} else if (servletPath.indexOf('.') < 0) {
// if pathInfo is null and no '.' is present, assume the
// FacesServlet was invoked using prefix path but without
// any pathInfo - i.e. GET /contextroot/faces or
// GET /contextroot/faces/
return servletPath;
} else {
// Servlet invoked using extension mapping
return servletPath.substring(servletPath.lastIndexOf('.'));
}
}
/**
* Check if a configuration update is needed.
*
* <p>There are two main reasons that can trigger a configuration update. Either there is a
* configuration update happening in the cluster, or operations added to the queue can not find
* their corresponding node. For the latter, see the {@link #pastReconnThreshold()} method for
* further details.
*
* <p>If a configuration update is needed, a resubscription for configuration updates is
* triggered. Note that since reconnection takes some time, the method will also wait a time
* period given by {@link #getMinReconnectInterval()} before the resubscription is triggered.
*/
void checkConfigUpdate() {
if (needsReconnect || pastReconnThreshold()) {
long now = System.currentTimeMillis();
long intervalWaited = now - this.configProviderLastUpdateTimestamp;
if (intervalWaited < this.getMinReconnectInterval()) {
LOGGER.log(
Level.FINE,
"Ignoring config update check. Only {0}ms out"
+ " of a threshold of {1}ms since last update.",
new Object[] {intervalWaited, this.getMinReconnectInterval()});
return;
}
if (doingResubscribe.compareAndSet(false, true)) {
resubConfigUpdate();
} else {
LOGGER.log(Level.CONFIG, "Duplicate resubscribe for config updates" + " suppressed.");
}
} else {
LOGGER.log(
Level.FINE,
"No reconnect required, though check requested."
+ " Current config check is {0} out of a threshold of {1}.",
new Object[] {configThresholdCount, maxConfigCheck});
}
}
public void onCreate$tipoAbonoMttoWindow(Event event) throws Exception {
logger.log(Level.INFO, "[TipoAbonoMttoCtrl][onCreate$tipoAbonoMttoWindow]");
try {
doOnCreateCommon(this.tipoAbonoMttoWindow, event);
MensajeMultilinea.doSetTemplate();
if (this.args.containsKey("gestorTipoAbonoCtrl")) {
tipoAbonoListaCtrl = (GestorTipoAbonoCtrl) this.args.get("gestorTipoAbonoCtrl");
} else {
tipoAbonoListaCtrl = null;
}
if (this.args.containsKey("accion")) {
accion = (Integer) this.args.get("accion");
} else {
accion = Constants.ACCION_MANTTO_NEW;
}
if (this.args.containsKey("tipoAbonoSelected")) {
tipoAbonoSelected = (TipoAbono) this.args.get("tipoAbonoSelected");
} else {
tipoAbonoSelected = new TipoAbono();
}
cargarDatosIniciales();
tipoAbonoMttoWindow.doModal();
verificarEstadoBotones();
} catch (Exception e) {
logger.log(Level.SEVERE, e.getLocalizedMessage());
e.printStackTrace();
}
}
@Override
public void entryAdded(EntryEvent<String, BpmEvent> event) {
BpmEvent bpmEvent = event.getValue();
logger.log(
Level.INFO,
"BpmEventListener.entryAdded executor {0}",
new Object[] {bpmEvent.getExecutor()});
try {
BpmEvent.EXECUTOR executor = bpmEvent.getExecutor();
switch (executor) {
case ACTOR_RESOLVER:
InternalAPI.get().executeActorResolver(bpmEvent.getCaseId(), bpmEvent.getTaskId());
break;
case CONNECTOR:
InternalAPI.get().executeConnectorOut(bpmEvent.getCaseId(), bpmEvent.getTaskId());
break;
case JOIN:
InternalAPI.get()
.executeJoin(bpmEvent.getCaseId(), bpmEvent.getTaskId(), bpmEvent.getJoinId());
break;
case TRANSITION:
InternalAPI.get().executeTransition(bpmEvent.getCaseId(), bpmEvent.getTaskId());
break;
}
HazelcastServer.removeBpmEvent(bpmEvent);
} catch (Exception ex) {
logger.log(Level.SEVERE, ex.getMessage(), ex);
}
}
/**
* Create a new Server object to listen to connections on the given port
*
* @param port Port for the server to listen on.
* @return New Server object
*/
public static Server createServer(int port) {
logger.log(Level.INFO, "Starting server on port {0}", port);
logger.log(Level.INFO, "Server version: {0}", SERVER_VERSION);
return new Server(port);
}
static {
// check if we have JAI and or ImageIO
// if these classes are here, then the runtine environment has
// access to JAI and the JAI ImageI/O toolbox.
boolean available = true;
try {
Class.forName("javax.media.jai.JAI");
} catch (Throwable e) {
if (LOGGER.isLoggable(Level.FINE)) LOGGER.log(Level.FINE, e.getLocalizedMessage(), e);
available = false;
}
JAIAvailable = available;
available = true;
try {
Class<?> clazz = Class.forName("com.sun.media.imageioimpl.plugins.tiff.TIFFImageReaderSpi");
readerSpi = (ImageReaderSpi) clazz.newInstance();
Class<?> clazz1 = Class.forName("com.sun.media.imageioimpl.plugins.tiff.TIFFImageWriterSpi");
writerSpi = (ImageWriterSpi) clazz1.newInstance();
} catch (Throwable e) {
if (LOGGER.isLoggable(Level.FINE)) LOGGER.log(Level.FINE, e.getLocalizedMessage(), e);
readerSpi = null;
writerSpi = null;
available = false;
}
TiffAvailable = available;
final HashSet<String> tempSet = new HashSet<String>(2);
tempSet.add(".tfw");
tempSet.add(".tiffw");
tempSet.add(".wld");
TIFF_WORLD_FILE_EXT = Collections.unmodifiableSet(tempSet);
}
/** Assume the frame size is 4. */
public byte[] reverseFrames(byte[] data) {
byte[] reversed = new byte[data.length];
byte[] frame = new byte[4];
for (int ii = 0; ii < data.length / 4; ii++) {
int first = (data.length) - ((ii + 1) * 4) + 0;
int last = (data.length) - ((ii + 1) * 4) + 3;
frame[0] = data[first];
frame[1] = data[(data.length) - ((ii + 1) * 4) + 1];
frame[2] = data[(data.length) - ((ii + 1) * 4) + 2];
frame[3] = data[last];
reversed[ii * 4 + 0] = frame[0];
reversed[ii * 4 + 1] = frame[1];
reversed[ii * 4 + 2] = frame[2];
reversed[ii * 4 + 3] = frame[3];
if (ii < 5 || ii > (data.length / 4) - 5) {
logger.log(Level.FINER, "From \t" + first + " \tlast " + last);
logger.log(Level.FINER, "To \t" + ((ii * 4) + 0) + " \tlast " + ((ii * 4) + 3));
}
}
/*
* for (int ii=0; ii<data.length; ii++) { reversed[ii] =
* data[data.length-1-ii]; }
*/
return reversed;
}
/**
* @param sql the sql query
* @param data the items to update in the sql query in place of question marks
* @param findExisting whether to first check if the data already exists before updating
* @return insert id
* @throws SQLException
*/
public long executeUpdate(String sql, List<Object> data, boolean findExisting)
throws SQLException {
// Convert the UPDATE query into a SELECT query to find the ID
String select =
sql.toLowerCase()
.replaceAll("update (.*) set (.*) where (.*)", "SELECT * FROM $1 WHERE $2 AND $3");
select = select.replace(",", " AND ");
if (findExisting) {
try {
long firstCol = queryFirstColumn(select, data);
if (firstCol != -1) {
return firstCol;
}
} catch (SQLException e) {
LOGGER.log(Level.WARNING, "Querying existing ID failed", e);
}
}
PreparedStatement ps = prepare(sql, data);
if (debugMode) {
LOGGER.finer("Debug mode: returned -1 as update ID");
return -1;
}
ps.executeUpdate();
try {
return queryFirstColumn(select, data);
} catch (SQLException e) {
LOGGER.log(Level.WARNING, "Querying existing ID failed", e);
}
return -1;
}
/**
* Tell the user about, and log, an exception.
*
* @param except the exception in question
* @param filename what file was being read
*/
private void printError(final Exception except, final String filename) {
if (except instanceof MapVersionException) {
LOGGER.log(Level.SEVERE, "Map version in " + filename + " not acceptable to reader", except);
printParagraph("ERROR: Map version not acceptable to reader", ERROR_COLOR);
} else if (except instanceof FileNotFoundException || except instanceof NoSuchFileException) {
printParagraph("ERROR: File not found", ERROR_COLOR);
LOGGER.log(Level.SEVERE, filename + " not found", except);
} else if (except instanceof IOException) {
//noinspection HardcodedFileSeparator
printParagraph("ERROR: I/O error reading file", ERROR_COLOR);
//noinspection HardcodedFileSeparator
LOGGER.log(Level.SEVERE, "I/O error reading " + filename, except);
} else if (except instanceof XMLStreamException) {
printParagraph(
"ERROR: Malformed XML in the file" + "; see following error message for details",
ERROR_COLOR);
final String message =
NullCleaner.valueOrDefault(except.getLocalizedMessage(), "(message was null)");
printParagraph(message, ERROR_COLOR);
LOGGER.log(Level.SEVERE, "Malformed XML in file " + filename, except);
} else if (except instanceof SPFormatException) {
printParagraph(
"ERROR: SP map format error at line "
+ ((SPFormatException) except).getLine()
+ "; see following error message for details",
ERROR_COLOR);
final String message =
NullCleaner.valueOrDefault(except.getLocalizedMessage(), "(message was null)");
printParagraph(message, ERROR_COLOR);
LOGGER.log(Level.SEVERE, "SP map format error reading " + filename, except);
} else {
throw new IllegalStateException("Unhandled exception class");
}
}