Fix preflux patch for changes on develop

1 files changed, 124 insertions, 3 deletions

diff --git a/src/main/patch/preflux/default.patch b/src/main/patch/preflux/default.patch
index acbcf0f..b3531b4 100644
--- a/src/main/patch/preflux/default.patch
+++ b/src/main/patch/preflux/default.patch
@@ -74,12 +74,133 @@ index eda8e051..5353e179 100644
      "check:fix": "npm run format:fix && npm run lint:fix && npm run test:no-watch",
 -    "format:check": "prettier --check \"src/main/angular/**/*.{ts,html,css,json}\"",
 -    "format:fix": "prettier --write \"src/main/angular/**/*.{ts,html,css,json}\"",
--    "lint": "ng lint --format verbose",
+-    "lint": "ng lint",
 -    "lint:fix": "ng lint --fix",
 +    "format:check": "true",
 +    "format:fix": "true",
 +    "lint": "true",
 +    "lint:fix": "true",
-     "test": "ng test --watch=true --browsers=ChromeHeadlessNoSandbox",
+     "test": "ng test --watch --browsers=ChromeHeadlessNoSandbox",
      "test:ci": "npm run test:no-watch",
-     "test:no-watch": "ng test --watch=false --browsers=ChromeHeadlessNoSandbox"
+     "test:no-watch": "ng test --no-watch --browsers=ChromeHeadlessNoSandbox"
+diff --git a/preflux-web/src/main/java/org/apache/logging/slf4j/Log4jLogger.java b/preflux-web/src/main/java/org/apache/logging/slf4j/Log4jLogger.java
+new file mode 100644
+index 00000000..e437dc34
+--- /dev/null
++++ b/preflux-web/src/main/java/org/apache/logging/slf4j/Log4jLogger.java
+@@ -0,0 +1,115 @@
++package org.apache.logging.slf4j;
++
++import org.apache.logging.log4j.spi.ExtendedLogger;
++import org.slf4j.Logger;
++import org.slf4j.Marker;
++import org.slf4j.spi.LocationAwareLogger;
++
++import java.io.Serializable;
++import java.lang.reflect.Constructor;
++import java.lang.reflect.InvocationTargetException;
++import java.lang.reflect.Method;
++
++
++/** <p>This class only exists to really, really, really, really use the wanted
++ * logger impl. And only the one choosen logger impl and no other log impl. In
++ * fact there should be no reason for this class to exist. But it seems as some
++ * code still manages to stubbornly use some unwanted logger impls occasionally,
++ * for whatever reason. As it seems impossible to configure this properly, this
++ * class here at least make it fail-fast, before make devs wasting time searching
++ * expected logs which magically never appear.</p>
++ */
++public class Log4jLogger implements LocationAwareLogger, Serializable {
++
++    private static final Method getLoggerFn;
++    private static final Object loggerFactory;
++    private final Logger log;
++
++    static {
++        try {
++            Class<?> slfClass = Class.forName("org.slf4j.simple.SimpleLoggerFactory");
++            getLoggerFn = slfClass.getDeclaredMethod("getLogger", String.class);
++            Constructor<?> ctor = slfClass.getConstructor();
++            ctor.setAccessible(true);
++            loggerFactory = ctor.newInstance();
++        } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | InstantiationException |
++                 IllegalAccessException ex) {
++            throw new UnsupportedOperationException(/*TODO*/"Not impl yet", ex);
++        }
++    }
++
++    Log4jLogger(Object markerFactory, ExtendedLogger logger, final String name) {
++        try {
++            this.log = (Logger) getLoggerFn.invoke(loggerFactory, name);
++        } catch (InvocationTargetException | IllegalAccessException ex) {
++            throw new UnsupportedOperationException(/*TODO*/"Not impl yet", ex);
++        }
++    }
++
++    @Override public void log(Marker marker, String s, int i, String s1, Object[] objects, Throwable throwable) {
++        throw new UnsupportedOperationException(/*TODO*/"Not impl yet");
++    }
++
++    @Override public String getName() { return log.getName(); }
++    @Override public boolean isTraceEnabled() { return log.isTraceEnabled(); }
++    @Override public void trace(String s) { log.trace(s); }
++    @Override public void trace(String s, Object o) { log.trace(s, o); }
++    @Override public void trace(String s, Object o, Object o1) { log.trace(s, o, o1); }
++    @Override public void trace(String s, Object... objects) { log.trace(s, objects); }
++    @Override public void trace(String s, Throwable throwable) { log.trace(s, throwable); }
++    @Override public boolean isTraceEnabled(Marker marker) { return log.isTraceEnabled(marker); }
++    @Override public void trace(Marker marker, String s) { log.trace(marker, s); }
++    @Override public void trace(Marker marker, String s, Object o) { log.trace(marker, s, o); }
++    @Override public void trace(Marker marker, String s, Object o, Object o1) { log.trace(marker, s, o, o1); }
++    @Override public void trace(Marker marker, String s, Object... objects) { log.trace(marker, s, objects); }
++    @Override public void trace(Marker marker, String s, Throwable throwable) { log.trace(marker, s, throwable); }
++    @Override public boolean isDebugEnabled() { return log.isDebugEnabled(); }
++    @Override public void debug(String s) { log.debug(s); }
++    @Override public void debug(String s, Object o) { log.debug(s, o); }
++    @Override public void debug(String s, Object o, Object o1) { log.debug(s, o, o1); }
++    @Override public void debug(String s, Object... objects) { log.debug(s, objects); }
++    @Override public void debug(String s, Throwable throwable) { log.debug(s, throwable); }
++    @Override public boolean isDebugEnabled(Marker marker) { return log.isDebugEnabled(marker); }
++    @Override public void debug(Marker marker, String s) { log.debug(marker, s); }
++    @Override public void debug(Marker marker, String s, Object o) { log.debug(marker, s, o); }
++    @Override public void debug(Marker marker, String s, Object o, Object o1) { log.debug(marker, s, o, o1); }
++    @Override public void debug(Marker marker, String s, Object... objects) { log.debug(marker, s, objects); }
++    @Override public void debug(Marker marker, String s, Throwable throwable) { log.debug(marker, s, throwable); }
++    @Override public boolean isInfoEnabled() { return log.isInfoEnabled(); }
++    @Override public void info(String s) { log.info(s); }
++    @Override public void info(String s, Object o) { log.info(s, o); }
++    @Override public void info(String s, Object o, Object o1) { log.info(s, o, o1); }
++    @Override public void info(String s, Object... objects) { log.info(s, objects); }
++    @Override public void info(String s, Throwable throwable) { log.info(s, throwable); }
++    @Override public boolean isInfoEnabled(Marker marker) { return log.isInfoEnabled(marker); }
++    @Override public void info(Marker marker, String s) { log.info(marker, s); }
++    @Override public void info(Marker marker, String s, Object o) { log.info(marker, s, o); }
++    @Override public void info(Marker marker, String s, Object o, Object o1) { log.info(marker, s, o, o1); }
++    @Override public void info(Marker marker, String s, Object... objects) { log.info(marker, s, objects); }
++    @Override public void info(Marker marker, String s, Throwable throwable) { log.info(marker, s, throwable); }
++    @Override public boolean isWarnEnabled() { return log.isWarnEnabled(); }
++    @Override public void warn(String s) { log.warn(s); }
++    @Override public void warn(String s, Object o) { log.warn(s, o); }
++    @Override public void warn(String s, Object... objects) { log.warn(s, objects); }
++    @Override public void warn(String s, Object o, Object o1) { log.warn(s, o, o1); }
++    @Override public void warn(String s, Throwable throwable) { log.warn(s, throwable); }
++    @Override public boolean isWarnEnabled(Marker marker) { return log.isWarnEnabled(marker); }
++    @Override public void warn(Marker marker, String s) { log.warn(marker, s); }
++    @Override public void warn(Marker marker, String s, Object o) { log.warn(marker, s, o); }
++    @Override public void warn(Marker marker, String s, Object o, Object o1) { log.warn(marker, s, o, o1); }
++    @Override public void warn(Marker marker, String s, Object... objects) { log.warn(marker, s, objects); }
++    @Override public void warn(Marker marker, String s, Throwable throwable) { log.warn(marker, s, throwable); }
++    @Override public boolean isErrorEnabled() { return log.isErrorEnabled(); }
++    @Override public void error(String s) { log.error(s); }
++    @Override public void error(String s, Object o) { log.error(s, o); }
++    @Override public void error(String s, Object o, Object o1) { log.error(s, o, o1); }
++    @Override public void error(String s, Object... objects) { log.error(s, objects); }
++    @Override public void error(String s, Throwable throwable) { log.error(s, throwable); }
++    @Override public boolean isErrorEnabled(Marker marker) { return log.isErrorEnabled(marker); }
++    @Override public void error(Marker marker, String s) { log.error(marker, s); }
++    @Override public void error(Marker marker, String s, Object o) { log.error(marker, s, o); }
++    @Override public void error(Marker marker, String s, Object o, Object o1) { log.error(marker, s, o, o1); }
++    @Override public void error(Marker marker, String s, Object... objects) { log.error(marker, s, objects); }
++    @Override public void error(Marker marker, String s, Throwable throwable) { log.error(marker, s, throwable); }
++
++}