369 lines
No EOL
14 KiB
Java
369 lines
No EOL
14 KiB
Java
package com.alexanderlogistics.metrics;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
import java.util.concurrent.ConcurrentHashMap;
|
|
import java.util.logging.Logger;
|
|
|
|
import org.eclipse.microprofile.config.inject.ConfigProperty;
|
|
import org.eclipse.microprofile.metrics.Metadata;
|
|
import org.eclipse.microprofile.metrics.MetricRegistry;
|
|
import org.eclipse.microprofile.metrics.Tag;
|
|
import org.eclipse.microprofile.metrics.annotation.RegistryScope;
|
|
import org.imixs.workflow.ItemCollection;
|
|
import org.imixs.workflow.engine.DocumentService;
|
|
import org.imixs.workflow.engine.ProcessingEvent;
|
|
import org.imixs.workflow.exceptions.PluginException;
|
|
import org.imixs.workflow.exceptions.QueryException;
|
|
|
|
import com.alexanderlogistics.InvoiceUtil;
|
|
import com.alexanderlogistics.KreditorDebitorService;
|
|
|
|
import jakarta.annotation.security.DeclareRoles;
|
|
import jakarta.annotation.security.RolesAllowed;
|
|
import jakarta.annotation.security.RunAs;
|
|
import jakarta.ejb.TransactionAttribute;
|
|
import jakarta.ejb.TransactionAttributeType;
|
|
import jakarta.enterprise.context.ApplicationScoped;
|
|
import jakarta.enterprise.event.Observes;
|
|
import jakarta.inject.Inject;
|
|
|
|
/**
|
|
* Dieser Service reagiert auch ProcessingEvents und speichert/aktualisiert die
|
|
* zugehörige Creditor Metric Entity (type=metric.creditor).
|
|
* <p>
|
|
* Beim Rechnungseingang gilt eine Rechnung als Bezahlt wenn diese einen finalen
|
|
* Status erreicht hat (>=5800)
|
|
* <p>
|
|
* Der Service liest in einem AFTER_PROCESS Event den alten invoice.saldo aus.
|
|
* Hierzu wird die Rechnung in einer neuen Transaktion geladen was einem
|
|
* 'Dirty-Read' entspricht. Dadurch kennt die Methode den letzten saldo der
|
|
* Rechnung. Hat sich nun der aktuelle Saldo geändert, aktualisiert der Serivce
|
|
* die entsprechende Metric.
|
|
*
|
|
*
|
|
*/
|
|
@DeclareRoles({ "org.imixs.ACCESSLEVEL.NOACCESS", "org.imixs.ACCESSLEVEL.READERACCESS",
|
|
"org.imixs.ACCESSLEVEL.AUTHORACCESS", "org.imixs.ACCESSLEVEL.EDITORACCESS",
|
|
"org.imixs.ACCESSLEVEL.MANAGERACCESS" })
|
|
@RolesAllowed({ "org.imixs.ACCESSLEVEL.NOACCESS", "org.imixs.ACCESSLEVEL.READERACCESS",
|
|
"org.imixs.ACCESSLEVEL.AUTHORACCESS", "org.imixs.ACCESSLEVEL.EDITORACCESS",
|
|
"org.imixs.ACCESSLEVEL.MANAGERACCESS" })
|
|
@RunAs("org.imixs.ACCESSLEVEL.MANAGERACCESS")
|
|
@ApplicationScoped
|
|
public class MetricCreditorService {
|
|
|
|
private static Logger logger = Logger.getLogger(MetricCreditorService.class.getName());
|
|
private final ConcurrentHashMap<String, ItemCollection> metricCache = new ConcurrentHashMap<>();
|
|
private final Set<String> registeredGauges = ConcurrentHashMap.newKeySet();
|
|
|
|
public static final String TYPE_METRIC_CREDITOR = "metric.creditor";
|
|
public static final String ITEM_TOTAL = "invoice.total";
|
|
public static final String ITEM_SALDO = "invoice.saldo";
|
|
|
|
@Inject
|
|
@RegistryScope(scope = MetricRegistry.APPLICATION_SCOPE)
|
|
MetricRegistry metricRegistry;
|
|
|
|
@Inject
|
|
DocumentService documentService;
|
|
|
|
@Inject
|
|
KreditorDebitorService kreditorDebitorService;
|
|
|
|
@Inject
|
|
MetricDataService metricDataService;
|
|
|
|
@Inject
|
|
@ConfigProperty(name = "metrics.enabled", defaultValue = "false")
|
|
private boolean metricsEnabled;
|
|
|
|
/**
|
|
* Reset the internal metricCache and clears all registered Gauges.
|
|
*/
|
|
public void reset() {
|
|
metricCache.clear();
|
|
registeredGauges.clear();
|
|
}
|
|
|
|
/**
|
|
* Reset the internal metricCache and clears all registered Gauges for a list of
|
|
* metric keys.
|
|
*/
|
|
public void reset(List<String> metricKeys) {
|
|
for (String metricKey : metricKeys) {
|
|
metricCache.remove(metricKey);
|
|
metricRegistry.remove(metricKey);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Process Metric only if some data has changed....
|
|
*
|
|
* @param processingEvent
|
|
* @throws PluginException
|
|
*/
|
|
public void onProcessingEvent(@Observes ProcessingEvent processingEvent) {
|
|
long l = System.currentTimeMillis();
|
|
if (!metricsEnabled) {
|
|
return;
|
|
}
|
|
|
|
ItemCollection invoice = processingEvent.getDocument();
|
|
if (!InvoiceUtil.isCreditorInvoice(invoice)) {
|
|
// skip event
|
|
return;
|
|
}
|
|
|
|
// update metric and the metric cache
|
|
if (processingEvent.getEventType() == ProcessingEvent.AFTER_PROCESS) {
|
|
// load the last invoice metric and reduce the saldo...
|
|
ItemCollection lastInvoice = metricDataService.readDirtyWorkitem(invoice.getUniqueID());
|
|
if (lastInvoice != null) {
|
|
try {
|
|
ItemCollection lastMetricData = getMetricByInvoice(lastInvoice);
|
|
subtractInvoice(lastMetricData, lastInvoice);
|
|
putMetric(lastMetricData);
|
|
metricDataService.saveMetric(lastMetricData);
|
|
} catch (PluginException e) {
|
|
// invalid invoice - e.g. no cdtr. number
|
|
}
|
|
}
|
|
|
|
try {
|
|
// load the invoice metric and add the saldo...
|
|
ItemCollection metricData = getMetricByInvoice(invoice);
|
|
// Saldo-Berechnung
|
|
addInvoice(metricData, invoice);
|
|
putMetric(metricData);
|
|
metricDataService.saveMetric(metricData);
|
|
|
|
// Update the Gauge
|
|
updateGauge(metricData);
|
|
logger.info("Metric cdtr update took " + (System.currentTimeMillis() - l) + "ms");
|
|
} catch (PluginException e) {
|
|
// invalid invoice - e.g. no cdtr. number
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Returns the corresponding metric data object for an invoice. The method uses
|
|
* an internal cache. If the metric was not yet cached the method loads the
|
|
* metric from the database. If not metric exists in the database the method
|
|
* automatically creates a new metric data object.
|
|
*
|
|
* The method throws a PluginException if no metric can be build from this
|
|
* invoice (e.g. missing cdtr.number).
|
|
*
|
|
* @param invoice
|
|
* @return
|
|
* @throws PluginException
|
|
*/
|
|
public ItemCollection getMetricByInvoice(ItemCollection invoice) throws PluginException {
|
|
if (invoice == null) {
|
|
return null;
|
|
}
|
|
String metricKey = MetricDataService.buildKeyByInvoice(invoice);
|
|
ItemCollection metricData = metricCache.get(metricKey);
|
|
if (metricData == null) {
|
|
metricData = loadMetric(invoice);
|
|
}
|
|
// if metric still null we create a new metric data object.
|
|
if (metricData == null) {
|
|
metricData = createMetaData(invoice);
|
|
}
|
|
return metricData;
|
|
}
|
|
|
|
/**
|
|
* Returns a metric data object by key
|
|
*
|
|
* @param key
|
|
* @return
|
|
*/
|
|
public ItemCollection getMetric(String key) {
|
|
return metricCache.get(key);
|
|
}
|
|
|
|
/**
|
|
* Puts a metric data object into the cache.
|
|
*
|
|
* @param metricData
|
|
*/
|
|
public void putMetric(ItemCollection metricData) {
|
|
metricCache.put(metricData.getItemValueString("name"), metricData);
|
|
}
|
|
|
|
/**
|
|
* Returns a list with all cached metric keys.
|
|
* The method returns an unmodifiable list to prevent modifications.
|
|
*
|
|
* @return
|
|
*/
|
|
public List<String> getMetricKeys() {
|
|
return Collections.unmodifiableList(new ArrayList<>(metricCache.keySet()));
|
|
}
|
|
|
|
/**
|
|
* This method loads a metric entity for a given invoice workitem. If no metric
|
|
* entity exits, the method
|
|
* creates a new metric entity.
|
|
*
|
|
* @param invoice
|
|
* @return
|
|
* @throws PluginException
|
|
*/
|
|
private ItemCollection loadMetric(ItemCollection invoice) throws PluginException {
|
|
ItemCollection creditorMetric = null;
|
|
if (invoice == null) {
|
|
return null;
|
|
}
|
|
try {
|
|
String metricKey = MetricDataService.buildKeyByInvoice(invoice);
|
|
String query = "(type:" + TYPE_METRIC_CREDITOR + ") AND (name:" + metricKey + ")";
|
|
List<ItemCollection> result = documentService.find(query, 1, 0, "$modified", true);
|
|
if (result.size() > 0) {
|
|
creditorMetric = result.get(0);
|
|
}
|
|
} catch (IllegalArgumentException | QueryException e) {
|
|
throw new PluginException(PluginException.class.getName(),
|
|
"Failed to load metric object for invoice " + invoice.getUniqueID() + ": ", e.getMessage(), e);
|
|
}
|
|
return creditorMetric;
|
|
}
|
|
|
|
/**
|
|
* Creates an empty Creditor Meta Data Object (ItemCollection)
|
|
* <p>
|
|
* The ItemCollection stores the name and number and also all saldos for all
|
|
* currencies
|
|
*
|
|
* @param invoice - invoice ItemCollection
|
|
* @return
|
|
* @throws PluginException
|
|
*/
|
|
private ItemCollection createMetaData(ItemCollection invoice) throws PluginException {
|
|
if (invoice == null) {
|
|
return null;
|
|
}
|
|
String key = MetricDataService.buildKeyByInvoice(invoice);
|
|
ItemCollection metricData = new ItemCollection();
|
|
metricData.setType(TYPE_METRIC_CREDITOR);
|
|
metricData.setItemValue("name", key);
|
|
metricData.setItemValue("bp.id", InvoiceUtil.getBPId(invoice));
|
|
metricData.setItemValue("bp.name", InvoiceUtil.getBPName(invoice));
|
|
metricData.setItemValue("country", invoice.getItemValueString("invoice.country"));
|
|
metricData.setItemValue("currency", invoice.getItemValueString("invoice.currency"));
|
|
metricData.setItemValue("department", invoice.getItemValueString("space.name"));
|
|
|
|
return metricData;
|
|
}
|
|
|
|
/**
|
|
* Helper method to register a gauge for a creditor
|
|
*
|
|
* @param cdtrNumber - the creditor number
|
|
* @param cdtrName - the creditor name
|
|
*/
|
|
public void updateGauge(ItemCollection metricData) {
|
|
|
|
String metricKey = metricData.getItemValueString("name");
|
|
String bpName = metricData.getItemValueString("bp.name");
|
|
String bpId = metricData.getItemValueString("bp.id");
|
|
String country = metricData.getItemValueString("country");
|
|
String department = metricData.getItemValueString("department");
|
|
String currency = metricData.getItemValueString("currency");
|
|
|
|
// Prüfen ob Gauge bereits registriert ist
|
|
if (registeredGauges.add(metricKey)) { // returns true newly added
|
|
List<Tag> tags = new ArrayList<>();
|
|
tags.add(new Tag("type", "cdtr"));
|
|
tags.add(new Tag("id", bpId));
|
|
tags.add(new Tag("name", bpName));
|
|
tags.add(new Tag("country", country));
|
|
tags.add(new Tag("currency", currency));
|
|
tags.add(new Tag("department", department));
|
|
logger.fine("register new metric for department: " + department +
|
|
", " + metricData.getItemValueString(ITEM_SALDO) +
|
|
" " + currency);
|
|
Metadata metadata = Metadata.builder()
|
|
.withName("cdtr.balance")
|
|
.withDescription("Creditor Balance")
|
|
.build();
|
|
|
|
metricCache.get(metricKey);
|
|
metricRegistry.gauge(metadata,
|
|
() -> metricCache.get(metricKey).getItemValueDouble(ITEM_SALDO),
|
|
tags.toArray(new Tag[0]));
|
|
} else {
|
|
logger.fine("Cdtr Gauge already registered for department: " + department);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Addiert den saldo einer Invoice zu einem metricData object
|
|
*
|
|
* @param metricData
|
|
* @param invoice
|
|
*/
|
|
public void addInvoice(ItemCollection metricData, ItemCollection invoice) {
|
|
double invoiceTotal = invoice.getItemValueDouble(ITEM_TOTAL);
|
|
if (!"workitem".equals(invoice.getType()) || invoice.getTaskID() >= 5800) {
|
|
// vorgang ist archiviert oder gelöscht worden => saldo = 0!
|
|
invoiceTotal = 0.0;
|
|
}
|
|
// is the metric new?
|
|
if (!metricData.hasItem(ITEM_SALDO)) {
|
|
// init metric with the total value!
|
|
metricData.setItemValue(ITEM_SALDO, InvoiceUtil.round(invoiceTotal));
|
|
} else {
|
|
double lastSaldo = metricData.getItemValueDouble(ITEM_SALDO);
|
|
metricData.setItemValue(ITEM_SALDO, InvoiceUtil.round(lastSaldo + invoiceTotal));
|
|
}
|
|
}
|
|
|
|
public void subtractInvoice(ItemCollection metricData, ItemCollection invoice) {
|
|
if (metricData == null || invoice == null) {
|
|
return;
|
|
}
|
|
double invoiceTotal = invoice.getItemValueDouble(ITEM_TOTAL);
|
|
if (!"workitem".equals(invoice.getType()) || invoice.getTaskID() >= 5800) {
|
|
// vorgang ist archiviert oder gelöscht worden => saldo = 0!
|
|
invoiceTotal = 0.0;
|
|
}
|
|
// subtract only if metric saldo exists
|
|
if (metricData.hasItem(ITEM_SALDO)) {
|
|
double lastSaldo = metricData.getItemValueDouble(ITEM_SALDO);
|
|
metricData.setItemValue(ITEM_SALDO, InvoiceUtil.round(lastSaldo - invoiceTotal));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper Method that refreshes all gauges. The method is called by the
|
|
* RestService during a rebuild.
|
|
*/
|
|
@TransactionAttribute(value = TransactionAttributeType.REQUIRES_NEW)
|
|
public void refreshGauges() {
|
|
List<String> keys = getMetricKeys();
|
|
refreshGauges(keys);
|
|
}
|
|
|
|
/**
|
|
* Helper Method that refreshes all gauges. The method is called by the
|
|
* RestService during a rebuild.
|
|
*/
|
|
@TransactionAttribute(value = TransactionAttributeType.REQUIRES_NEW)
|
|
public void refreshGauges(List<String> keys) {
|
|
for (String hashKey : keys) {
|
|
ItemCollection metricData = getMetric(hashKey);
|
|
documentService.save(metricData);
|
|
updateGauge(metricData);
|
|
}
|
|
}
|
|
|
|
} |