830 lines
35 KiB
Java
830 lines
35 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.control.BControlPoint
|
|
* javax.baja.control.BDiscretePoint
|
|
* javax.baja.control.BPointExtension
|
|
* javax.baja.data.BIDataValue
|
|
* javax.baja.log.Log
|
|
* javax.baja.naming.BOrd
|
|
* javax.baja.naming.BOrdList
|
|
* javax.baja.status.BStatus
|
|
* javax.baja.status.BStatusBoolean
|
|
* javax.baja.status.BStatusValue
|
|
* javax.baja.sys.Action
|
|
* javax.baja.sys.BAbsTime
|
|
* javax.baja.sys.BBoolean
|
|
* javax.baja.sys.BComponent
|
|
* javax.baja.sys.BFacets
|
|
* javax.baja.sys.BIcon
|
|
* javax.baja.sys.BInteger
|
|
* javax.baja.sys.BModule
|
|
* javax.baja.sys.BRelTime
|
|
* javax.baja.sys.BString
|
|
* javax.baja.sys.BValue
|
|
* javax.baja.sys.Clock
|
|
* javax.baja.sys.Clock$Ticket
|
|
* javax.baja.sys.Context
|
|
* javax.baja.sys.Property
|
|
* javax.baja.sys.ServiceNotFoundException
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Topic
|
|
* javax.baja.sys.Type
|
|
* javax.baja.util.BFormat
|
|
* javax.baja.util.Lexicon
|
|
*/
|
|
package javax.baja.alarm.ext;
|
|
|
|
import java.util.HashMap;
|
|
import javax.baja.alarm.AlarmSupport;
|
|
import javax.baja.alarm.BAlarmInstructions;
|
|
import javax.baja.alarm.BAlarmRecord;
|
|
import javax.baja.alarm.BAlarmService;
|
|
import javax.baja.alarm.BAlarmTransitionBits;
|
|
import javax.baja.alarm.BIAlarmSource;
|
|
import javax.baja.alarm.BSourceState;
|
|
import javax.baja.alarm.ext.BAlarmState;
|
|
import javax.baja.alarm.ext.BAlarmTimestamps;
|
|
import javax.baja.alarm.ext.BFaultAlgorithm;
|
|
import javax.baja.alarm.ext.BOffnormalAlgorithm;
|
|
import javax.baja.control.BControlPoint;
|
|
import javax.baja.control.BDiscretePoint;
|
|
import javax.baja.control.BPointExtension;
|
|
import javax.baja.data.BIDataValue;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.naming.BOrdList;
|
|
import javax.baja.status.BStatus;
|
|
import javax.baja.status.BStatusBoolean;
|
|
import javax.baja.status.BStatusValue;
|
|
import javax.baja.sys.Action;
|
|
import javax.baja.sys.BAbsTime;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BIcon;
|
|
import javax.baja.sys.BInteger;
|
|
import javax.baja.sys.BModule;
|
|
import javax.baja.sys.BRelTime;
|
|
import javax.baja.sys.BString;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Clock;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.ServiceNotFoundException;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Topic;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.util.BFormat;
|
|
import javax.baja.util.Lexicon;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BAlarmSourceExt
|
|
extends BPointExtension
|
|
implements BIAlarmSource {
|
|
public static final Property alarmInhibit = BAlarmSourceExt.newProperty((int)0, (BValue)new BStatusBoolean(false), null);
|
|
public static final Property inhibitTime = BAlarmSourceExt.newProperty((int)0, (BValue)BRelTime.DEFAULT, (BFacets)BFacets.make((String)"min", (BIDataValue)BRelTime.make((long)0L)));
|
|
public static final Property alarmState = BAlarmSourceExt.newProperty((int)1, (BValue)BAlarmState.normal, null);
|
|
public static final Property timeDelay = BAlarmSourceExt.newProperty((int)0, (BValue)BRelTime.DEFAULT, (BFacets)BFacets.make((String)"min", (BIDataValue)BRelTime.make((long)0L)));
|
|
public static final Property timeDelayToNormal = BAlarmSourceExt.newProperty((int)0, (BValue)BRelTime.DEFAULT, (BFacets)BFacets.make((String)"min", (BIDataValue)BRelTime.make((long)0L)));
|
|
public static final Property alarmEnable = BAlarmSourceExt.newProperty((int)0, (BValue)BAlarmTransitionBits.DEFAULT, (BFacets)BFacets.make((String[])new String[]{"showNormal", "showAlert"}, (BIDataValue[])new BBoolean[]{BBoolean.FALSE, BBoolean.FALSE}));
|
|
public static final Property ackedTransitions = BAlarmSourceExt.newProperty((int)5, (BValue)BAlarmTransitionBits.ALL, null);
|
|
public static final Property toOffnormalTimes = BAlarmSourceExt.newProperty((int)1, (BValue)new BAlarmTimestamps(), null);
|
|
public static final Property toFaultTimes = BAlarmSourceExt.newProperty((int)1, (BValue)new BAlarmTimestamps(), null);
|
|
public static final Property timeInCurrentState = BAlarmSourceExt.newProperty((int)3, (BValue)BRelTime.DEFAULT, null);
|
|
public static final Property sourceName = BAlarmSourceExt.newProperty((int)0, (BValue)BFormat.make((String)"%parent.displayName%"), null);
|
|
public static final Property toFaultText = BAlarmSourceExt.newProperty((int)0, (BValue)BFormat.make((String)""), (BFacets)BFacets.make((String)"multiLine", (BIDataValue)BBoolean.TRUE));
|
|
public static final Property toOffnormalText = BAlarmSourceExt.newProperty((int)0, (BValue)BFormat.make((String)""), (BFacets)BFacets.make((String)"multiLine", (BIDataValue)BBoolean.TRUE));
|
|
public static final Property toNormalText = BAlarmSourceExt.newProperty((int)0, (BValue)BFormat.make((String)""), (BFacets)BFacets.make((String)"multiLine", (BIDataValue)BBoolean.TRUE));
|
|
public static final Property hyperlinkOrd = BAlarmSourceExt.newProperty((int)0, (BValue)BOrd.NULL, (BFacets)BFacets.make((String)"ordRelativize", (BIDataValue)BBoolean.FALSE, (String)"chooseView", (BIDataValue)BBoolean.TRUE));
|
|
public static final Property soundFile = BAlarmSourceExt.newProperty((int)0, (BValue)BOrd.NULL, (BFacets)BFacets.make((String)"targetType", (BIDataValue)BString.make((String)"file:AudioFile")));
|
|
public static final Property alarmIcon = BAlarmSourceExt.newProperty((int)0, (BValue)BOrd.NULL, (BFacets)BFacets.make((String)"targetType", (BIDataValue)BString.make((String)"file:ImageFile")));
|
|
public static final Property alarmInstructions = BAlarmSourceExt.newProperty((int)0, (BValue)BAlarmInstructions.DEFAULT, (BFacets)BFacets.make((String)"fieldEditor", (BIDataValue)BString.make((String)"alarm:InstructionsFE")));
|
|
public static final Property faultAlgorithm = BAlarmSourceExt.newProperty((int)0, (BValue)new BFaultAlgorithm(), null);
|
|
public static final Property offnormalAlgorithm = BAlarmSourceExt.newProperty((int)0, (BValue)new BOffnormalAlgorithm(), null);
|
|
public static final Property alarmClass = BAlarmSourceExt.newProperty((int)0, (String)"defaultAlarmClass", (BFacets)BFacets.make((String)"fieldEditor", (BIDataValue)BString.make((String)"alarm:AlarmClassFE")));
|
|
public static final Property metaData = BAlarmSourceExt.newProperty((int)0, (BValue)BFacets.DEFAULT, null);
|
|
public static final Property status = BAlarmSourceExt.newProperty((int)7, (BValue)BStatus.DEFAULT, null);
|
|
public static final Action timerExpired = BAlarmSourceExt.newAction((int)4, null);
|
|
public static final Action inhibitTimerExpired = BAlarmSourceExt.newAction((int)4, null);
|
|
public static final Action ackAlarm = BAlarmSourceExt.newAction((int)4, (BValue)new BAlarmRecord(), null);
|
|
public static final Topic toOffnormal = BAlarmSourceExt.newTopic((int)0, null);
|
|
public static final Topic toFault = BAlarmSourceExt.newTopic((int)0, null);
|
|
public static final Topic toNormal = BAlarmSourceExt.newTopic((int)0, null);
|
|
public static final Type TYPE;
|
|
private static final BIcon icon;
|
|
private static final int NON_ALARM_BITS = -139;
|
|
private static Log log;
|
|
private Clock.Ticket ticket;
|
|
private Clock.Ticket inhibitTicket;
|
|
private long timeOfLastStateChange;
|
|
private AlarmSupport support;
|
|
private boolean unackedAlarm;
|
|
private BAbsTime lastOffnormalTime;
|
|
private BAbsTime lastFaultTime;
|
|
private BAbsTime lastToNormalTime;
|
|
private BAbsTime lastAckTime;
|
|
private boolean atSteadyState;
|
|
static /* synthetic */ Class class$javax$baja$alarm$ext$BAlarmSourceExt;
|
|
|
|
public BStatusBoolean getAlarmInhibit() {
|
|
return (BStatusBoolean)this.get(alarmInhibit);
|
|
}
|
|
|
|
public void setAlarmInhibit(BStatusBoolean bStatusBoolean) {
|
|
this.set(alarmInhibit, (BValue)bStatusBoolean, null);
|
|
}
|
|
|
|
public BRelTime getInhibitTime() {
|
|
return (BRelTime)this.get(inhibitTime);
|
|
}
|
|
|
|
public void setInhibitTime(BRelTime bRelTime) {
|
|
this.set(inhibitTime, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public BAlarmState getAlarmState() {
|
|
return (BAlarmState)this.get(alarmState);
|
|
}
|
|
|
|
public void setAlarmState(BAlarmState bAlarmState) {
|
|
this.set(alarmState, (BValue)bAlarmState, null);
|
|
}
|
|
|
|
public BRelTime getTimeDelay() {
|
|
return (BRelTime)this.get(timeDelay);
|
|
}
|
|
|
|
public void setTimeDelay(BRelTime bRelTime) {
|
|
this.set(timeDelay, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public BRelTime getTimeDelayToNormal() {
|
|
return (BRelTime)this.get(timeDelayToNormal);
|
|
}
|
|
|
|
public void setTimeDelayToNormal(BRelTime bRelTime) {
|
|
this.set(timeDelayToNormal, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public BAlarmTransitionBits getAlarmEnable() {
|
|
return (BAlarmTransitionBits)this.get(alarmEnable);
|
|
}
|
|
|
|
public void setAlarmEnable(BAlarmTransitionBits bAlarmTransitionBits) {
|
|
this.set(alarmEnable, (BValue)bAlarmTransitionBits, null);
|
|
}
|
|
|
|
public BAlarmTransitionBits getAckedTransitions() {
|
|
return (BAlarmTransitionBits)this.get(ackedTransitions);
|
|
}
|
|
|
|
public void setAckedTransitions(BAlarmTransitionBits bAlarmTransitionBits) {
|
|
this.set(ackedTransitions, (BValue)bAlarmTransitionBits, null);
|
|
}
|
|
|
|
public BAlarmTimestamps getToOffnormalTimes() {
|
|
return (BAlarmTimestamps)this.get(toOffnormalTimes);
|
|
}
|
|
|
|
public void setToOffnormalTimes(BAlarmTimestamps bAlarmTimestamps) {
|
|
this.set(toOffnormalTimes, (BValue)bAlarmTimestamps, null);
|
|
}
|
|
|
|
public BAlarmTimestamps getToFaultTimes() {
|
|
return (BAlarmTimestamps)this.get(toFaultTimes);
|
|
}
|
|
|
|
public void setToFaultTimes(BAlarmTimestamps bAlarmTimestamps) {
|
|
this.set(toFaultTimes, (BValue)bAlarmTimestamps, null);
|
|
}
|
|
|
|
public BRelTime getTimeInCurrentState() {
|
|
return (BRelTime)this.get(timeInCurrentState);
|
|
}
|
|
|
|
public void setTimeInCurrentState(BRelTime bRelTime) {
|
|
this.set(timeInCurrentState, (BValue)bRelTime, null);
|
|
}
|
|
|
|
public BFormat getSourceName() {
|
|
return (BFormat)this.get(sourceName);
|
|
}
|
|
|
|
public void setSourceName(BFormat bFormat) {
|
|
this.set(sourceName, (BValue)bFormat, null);
|
|
}
|
|
|
|
public BFormat getToFaultText() {
|
|
return (BFormat)this.get(toFaultText);
|
|
}
|
|
|
|
public void setToFaultText(BFormat bFormat) {
|
|
this.set(toFaultText, (BValue)bFormat, null);
|
|
}
|
|
|
|
public BFormat getToOffnormalText() {
|
|
return (BFormat)this.get(toOffnormalText);
|
|
}
|
|
|
|
public void setToOffnormalText(BFormat bFormat) {
|
|
this.set(toOffnormalText, (BValue)bFormat, null);
|
|
}
|
|
|
|
public BFormat getToNormalText() {
|
|
return (BFormat)this.get(toNormalText);
|
|
}
|
|
|
|
public void setToNormalText(BFormat bFormat) {
|
|
this.set(toNormalText, (BValue)bFormat, null);
|
|
}
|
|
|
|
public BOrd getHyperlinkOrd() {
|
|
return (BOrd)this.get(hyperlinkOrd);
|
|
}
|
|
|
|
public void setHyperlinkOrd(BOrd bOrd) {
|
|
this.set(hyperlinkOrd, (BValue)bOrd, null);
|
|
}
|
|
|
|
public BOrd getSoundFile() {
|
|
return (BOrd)this.get(soundFile);
|
|
}
|
|
|
|
public void setSoundFile(BOrd bOrd) {
|
|
this.set(soundFile, (BValue)bOrd, null);
|
|
}
|
|
|
|
public BOrd getAlarmIcon() {
|
|
return (BOrd)this.get(alarmIcon);
|
|
}
|
|
|
|
public void setAlarmIcon(BOrd bOrd) {
|
|
this.set(alarmIcon, (BValue)bOrd, null);
|
|
}
|
|
|
|
public BAlarmInstructions getAlarmInstructions() {
|
|
return (BAlarmInstructions)this.get(alarmInstructions);
|
|
}
|
|
|
|
public void setAlarmInstructions(BAlarmInstructions bAlarmInstructions) {
|
|
this.set(alarmInstructions, (BValue)bAlarmInstructions, null);
|
|
}
|
|
|
|
public BFaultAlgorithm getFaultAlgorithm() {
|
|
return (BFaultAlgorithm)this.get(faultAlgorithm);
|
|
}
|
|
|
|
public void setFaultAlgorithm(BFaultAlgorithm bFaultAlgorithm) {
|
|
this.set(faultAlgorithm, (BValue)bFaultAlgorithm, null);
|
|
}
|
|
|
|
public BOffnormalAlgorithm getOffnormalAlgorithm() {
|
|
return (BOffnormalAlgorithm)this.get(offnormalAlgorithm);
|
|
}
|
|
|
|
public void setOffnormalAlgorithm(BOffnormalAlgorithm bOffnormalAlgorithm) {
|
|
this.set(offnormalAlgorithm, (BValue)bOffnormalAlgorithm, null);
|
|
}
|
|
|
|
public String getAlarmClass() {
|
|
return this.getString(alarmClass);
|
|
}
|
|
|
|
public void setAlarmClass(String string) {
|
|
this.setString(alarmClass, string, null);
|
|
}
|
|
|
|
public BFacets getMetaData() {
|
|
return (BFacets)this.get(metaData);
|
|
}
|
|
|
|
public void setMetaData(BFacets bFacets) {
|
|
this.set(metaData, (BValue)bFacets, null);
|
|
}
|
|
|
|
public BStatus getStatus() {
|
|
return (BStatus)this.get(status);
|
|
}
|
|
|
|
public void setStatus(BStatus bStatus) {
|
|
this.set(status, (BValue)bStatus, null);
|
|
}
|
|
|
|
public void timerExpired() {
|
|
this.invoke(timerExpired, null, null);
|
|
}
|
|
|
|
public void inhibitTimerExpired() {
|
|
this.invoke(inhibitTimerExpired, null, null);
|
|
}
|
|
|
|
public BBoolean ackAlarm(BAlarmRecord bAlarmRecord) {
|
|
return (BBoolean)this.invoke(ackAlarm, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public void fireToOffnormal(BAlarmRecord bAlarmRecord) {
|
|
this.fire(toOffnormal, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public void fireToFault(BAlarmRecord bAlarmRecord) {
|
|
this.fire(toFault, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public void started() throws Exception {
|
|
super.started();
|
|
this.support = new AlarmSupport((BIAlarmSource)this, this.getAlarmClass());
|
|
this.timeOfLastStateChange = Clock.ticks();
|
|
this.initScheduler();
|
|
if (Sys.atSteadyState()) {
|
|
this.atSteadyState = true;
|
|
}
|
|
}
|
|
|
|
public void atSteadyState() throws Exception {
|
|
this.atSteadyState = true;
|
|
this.executePoint();
|
|
}
|
|
|
|
public boolean requiresPointSubscription() {
|
|
return this.getAlarmEnable().isToOffnormal() || this.getAlarmEnable().isToFault();
|
|
}
|
|
|
|
public void checkPointSubscription() {
|
|
BControlPoint bControlPoint = this.getParentPoint();
|
|
if (bControlPoint != null) {
|
|
bControlPoint.checkExtensionsRequireSubscription();
|
|
}
|
|
}
|
|
|
|
public boolean isParentLegal(BComponent bComponent) {
|
|
if (bComponent instanceof BControlPoint) {
|
|
if (!this.getOffnormalAlgorithm().isGrandparentLegal(bComponent)) {
|
|
return false;
|
|
}
|
|
return this.getFaultAlgorithm().isGrandparentLegal(bComponent);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
protected boolean isSiblingLegal(BComponent bComponent) {
|
|
return true;
|
|
}
|
|
|
|
private final void initScheduler() {
|
|
if (this.ticket != null) {
|
|
this.ticket.cancel();
|
|
}
|
|
this.ticket = Clock.schedulePeriodically((BComponent)this, (BRelTime)BRelTime.make((long)10000L), (Action)timerExpired, null);
|
|
}
|
|
|
|
public BOrdList getSourceOrd() {
|
|
return this.support.getSourceOrd();
|
|
}
|
|
|
|
public void doTimerExpired() {
|
|
this.setTimeInCurrentState(BRelTime.make((long)(Clock.ticks() - this.timeOfLastStateChange)));
|
|
}
|
|
|
|
public void doInhibitTimerExpired() {
|
|
this.inhibitTicket = null;
|
|
this.checkPointSubscription();
|
|
this.executePoint();
|
|
}
|
|
|
|
public BBoolean doAckAlarm(BAlarmRecord bAlarmRecord) {
|
|
if (!this.isRunning()) {
|
|
return BBoolean.make((boolean)false);
|
|
}
|
|
try {
|
|
boolean bl = this.support.ackAlarm(bAlarmRecord);
|
|
this.lastAckTime = bAlarmRecord.getAckTime();
|
|
BSourceState bSourceState = bAlarmRecord.getAlarmTransition();
|
|
if (bl) {
|
|
BAlarmTransitionBits bAlarmTransitionBits = this.getAckedTransitions();
|
|
this.setAckedTransitions(BAlarmTransitionBits.make(bAlarmTransitionBits, bSourceState.getAlarmTransitionBits(), true));
|
|
bAlarmTransitionBits = this.getAckedTransitions();
|
|
bSourceState = bAlarmRecord.getSourceState();
|
|
if (bSourceState == BSourceState.normal) {
|
|
this.setAckedTransitions(BAlarmTransitionBits.make(bAlarmTransitionBits, bSourceState.getAlarmTransitionBits(), true));
|
|
}
|
|
BAlarmTimestamps bAlarmTimestamps = null;
|
|
BSourceState bSourceState2 = bAlarmRecord.getAlarmTransition();
|
|
if (bSourceState2 == BSourceState.offnormal) {
|
|
bAlarmTimestamps = this.getToOffnormalTimes();
|
|
} else if (bSourceState2 == BSourceState.fault) {
|
|
bAlarmTimestamps = this.getToFaultTimes();
|
|
}
|
|
if (bAlarmTimestamps != null && !bAlarmTimestamps.getAlarmTime().isNull()) {
|
|
bAlarmTimestamps.setAckTime(bAlarmRecord.getAckTime());
|
|
}
|
|
}
|
|
if (bl && this.getStatus().isUnackedAlarm()) {
|
|
this.setStatus(BStatus.makeUnackedAlarm((BStatus)this.getStatus(), (boolean)false));
|
|
}
|
|
this.executePoint();
|
|
return BBoolean.make((boolean)bl);
|
|
}
|
|
catch (Exception exception) {
|
|
exception.printStackTrace();
|
|
return BBoolean.make((boolean)false);
|
|
}
|
|
}
|
|
|
|
public void onExecute(BStatusValue bStatusValue, Context context) {
|
|
if (!this.isRunning()) {
|
|
return;
|
|
}
|
|
if (!this.atSteadyState) {
|
|
return;
|
|
}
|
|
boolean bl = bStatusValue.getStatus().isAlarm();
|
|
boolean bl2 = bStatusValue.getStatus().isFault();
|
|
this.checkAlarms(bStatusValue);
|
|
String string = Lexicon.make((BModule)TYPE.getModule(), (Context)context).getText("alarm.alarmInhibit.facet");
|
|
BStatus bStatus = bStatusValue.getStatus();
|
|
if (this.inhibitTicket == null || this.inhibitTicket.isExpired()) {
|
|
if (this.getAlarmInhibit().getBoolean() || this.isTimerActive()) {
|
|
this.setStatus(BStatus.make((BStatus)this.getStatus(), (String)string, (boolean)true));
|
|
} else {
|
|
this.setStatus(BStatus.make((int)this.getStatus().getBits(), (BFacets)BFacets.makeRemove((BFacets)this.getStatus().getFacets(), (String)string)));
|
|
}
|
|
} else if (this.getAlarmInhibit().getBoolean() || this.isTimerActive()) {
|
|
this.setStatus(BStatus.make((int)this.getStatus().getBits(), (BFacets)BFacets.makeRemove((BFacets)this.getStatus().getFacets(), (String)string)));
|
|
} else {
|
|
this.setStatus(BStatus.make((BStatus)this.getStatus(), (String)string, (boolean)true));
|
|
}
|
|
BControlPoint bControlPoint = this.getParentPoint();
|
|
Class clazz = class$javax$baja$alarm$ext$BAlarmSourceExt;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$alarm$ext$BAlarmSourceExt = BAlarmSourceExt.class("[Ljavax.baja.alarm.ext.BAlarmSourceExt;", false);
|
|
}
|
|
BAlarmSourceExt[] bAlarmSourceExtArray = (BAlarmSourceExt[])bControlPoint.getChildren(clazz);
|
|
int n = bStatusValue.getStatus().getBits() & 0xFFFFFF75;
|
|
boolean bl3 = false;
|
|
int n2 = 0;
|
|
while (n2 < bAlarmSourceExtArray.length) {
|
|
n |= bAlarmSourceExtArray[n2].getStatus().getBits();
|
|
if (bAlarmSourceExtArray[n2].getStatus().getb(string, false)) {
|
|
bl3 = true;
|
|
}
|
|
if (bAlarmSourceExtArray[n2] == this) break;
|
|
++n2;
|
|
}
|
|
if (bl3) {
|
|
bStatusValue.setStatus(BStatus.make((int)n, (BFacets)BFacets.make((BFacets)bStatusValue.getStatus().getFacets(), (String)string, (BIDataValue)BBoolean.TRUE)));
|
|
} else {
|
|
bStatusValue.setStatus(BStatus.make((int)n, (BFacets)BFacets.makeRemove((BFacets)bStatusValue.getStatus().getFacets(), (String)string)));
|
|
}
|
|
if (bl) {
|
|
bStatusValue.setStatusInAlarm(true);
|
|
}
|
|
if (bl2) {
|
|
bStatusValue.setStatusFault(true);
|
|
}
|
|
}
|
|
|
|
public void changed(Property property, Context context) {
|
|
super.changed(property, context);
|
|
if (!this.isRunning()) {
|
|
return;
|
|
}
|
|
if (property.equals((Object)alarmClass) && this.support != null) {
|
|
this.support.setAlarmClass(this.getAlarmClass());
|
|
} else if (property.equals((Object)timeDelay)) {
|
|
this.executePoint();
|
|
} else if (property.equals((Object)alarmInhibit)) {
|
|
this.checkPointSubscription();
|
|
if (this.getInhibitTime().getMillis() > 0L) {
|
|
if (this.inhibitTicket != null) {
|
|
this.inhibitTicket.cancel();
|
|
}
|
|
if (!this.getAlarmInhibit().getBoolean()) {
|
|
this.inhibitTicket = Clock.schedule((BComponent)this, (BRelTime)this.getInhibitTime(), (Action)inhibitTimerExpired, null);
|
|
} else if (this.getParent() instanceof BDiscretePoint) {
|
|
this.inhibitTicket = Clock.schedule((BComponent)this, (BRelTime)BRelTime.make((long)(this.getInhibitTime().getMillis() * (long)3)), (Action)inhibitTimerExpired, null);
|
|
}
|
|
} else {
|
|
this.executePoint();
|
|
}
|
|
} else if (property.equals((Object)alarmEnable)) {
|
|
this.checkPointSubscription();
|
|
this.executePoint();
|
|
}
|
|
}
|
|
|
|
protected boolean isTimerActive() {
|
|
try {
|
|
return this.getOffnormalAlgorithm().isTimerExpired() ^ true;
|
|
}
|
|
catch (IllegalStateException illegalStateException) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected boolean isInhibitTimerActive() {
|
|
try {
|
|
boolean bl = false;
|
|
if (this.inhibitTicket != null && !this.inhibitTicket.isExpired()) {
|
|
bl = true;
|
|
}
|
|
return bl;
|
|
}
|
|
catch (IllegalStateException illegalStateException) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
protected void checkAlarms(BStatusValue bStatusValue) {
|
|
boolean bl;
|
|
BAlarmState bAlarmState = null;
|
|
BAlarmState bAlarmState2 = this.getAlarmState();
|
|
if ((BAlarmService)Sys.getService((Type)BAlarmService.TYPE) == null) {
|
|
return;
|
|
}
|
|
if (bStatusValue.getStatus().isDisabled() || bStatusValue.getStatus().isStale()) {
|
|
return;
|
|
}
|
|
boolean bl2 = false;
|
|
if (this.getInhibitTime().getMillis() == 0L && this.getAlarmInhibit().getBoolean() || (this.inhibitTicket == null || this.inhibitTicket.isExpired()) && this.getAlarmInhibit().getBoolean() || this.inhibitTicket != null && !this.inhibitTicket.isExpired() && !this.getAlarmInhibit().getBoolean()) {
|
|
bl2 = true;
|
|
}
|
|
if (bl = bl2) {
|
|
if (bAlarmState2 != BAlarmState.normal) {
|
|
bAlarmState = BAlarmState.normal;
|
|
}
|
|
} else {
|
|
if (this.getAlarmEnable().isToFault()) {
|
|
bAlarmState = this.getFaultAlgorithm().checkFault(bStatusValue);
|
|
}
|
|
if (bAlarmState2 == BAlarmState.fault && !this.getAlarmEnable().isToFault()) {
|
|
bAlarmState = BAlarmState.normal;
|
|
}
|
|
if (bAlarmState != BAlarmState.fault && this.getAlarmEnable().isToOffnormal()) {
|
|
if (bAlarmState == null) {
|
|
if (bAlarmState2 != BAlarmState.fault) {
|
|
bAlarmState = this.getOffnormalAlgorithm().checkAlarmState(bStatusValue, this.getTimeDelay().getMillis(), this.getTimeDelayToNormal().getMillis());
|
|
}
|
|
} else if (bAlarmState == BAlarmState.normal && (bAlarmState = this.getOffnormalAlgorithm().checkAlarmState(bStatusValue, this.getTimeDelay().getMillis(), this.getTimeDelayToNormal().getMillis())) == null) {
|
|
bAlarmState = BAlarmState.normal;
|
|
}
|
|
}
|
|
if (bAlarmState2.isOffnormal() && !this.getAlarmEnable().isToOffnormal()) {
|
|
bAlarmState = BAlarmState.normal;
|
|
}
|
|
}
|
|
boolean bl3 = true;
|
|
if (bAlarmState != null) {
|
|
if (this.getAlarmEnable().isToOffnormal() && bAlarmState.isInAlarm()) {
|
|
this.setStatus(BStatus.makeAlarm((BStatus)this.getStatus(), (boolean)true));
|
|
} else if (!bAlarmState.isInAlarm()) {
|
|
this.setStatus(BStatus.makeAlarm((BStatus)this.getStatus(), (boolean)false));
|
|
}
|
|
if (this.getAlarmEnable().isToFault() && bAlarmState == BAlarmState.fault) {
|
|
this.setStatus(BStatus.makeFault((BStatus)this.getStatus(), (boolean)true));
|
|
} else if (bAlarmState != BAlarmState.fault) {
|
|
this.setStatus(BStatus.makeFault((BStatus)this.getStatus(), (boolean)false));
|
|
}
|
|
if (bAlarmState == BAlarmState.normal) {
|
|
bl3 = this.alarmStateTransition(BSourceState.normal, BAlarmState.normal, bStatusValue);
|
|
if (bAlarmState2.isOffnormal()) {
|
|
boolean bl4 = false;
|
|
if (bl3 || this.support.isAckRequired(BSourceState.offnormal)) {
|
|
bl4 = true;
|
|
}
|
|
bl3 = bl4;
|
|
} else if (bAlarmState2.isInAlarm()) {
|
|
boolean bl5 = false;
|
|
if (bl3 || this.support.isAckRequired(BSourceState.fault)) {
|
|
bl5 = true;
|
|
}
|
|
bl3 = bl5;
|
|
}
|
|
} else {
|
|
bl3 = bAlarmState == BAlarmState.fault ? this.alarmStateTransition(BSourceState.fault, BAlarmState.fault, bStatusValue) : this.alarmStateTransition(BSourceState.offnormal, bAlarmState, bStatusValue);
|
|
}
|
|
this.setAlarmState(bAlarmState);
|
|
this.timeOfLastStateChange = Clock.ticks();
|
|
this.setTimeInCurrentState(BRelTime.DEFAULT);
|
|
this.unackedAlarm = bl3;
|
|
} else {
|
|
if (this.getAlarmEnable().isToOffnormal()) {
|
|
this.setStatus(BStatus.makeAlarm((BStatus)this.getStatus(), (boolean)bAlarmState2.isInAlarm()));
|
|
}
|
|
if (this.getAlarmEnable().isToFault()) {
|
|
BStatus bStatus = this.getStatus();
|
|
boolean bl6 = false;
|
|
if (bAlarmState2 == BAlarmState.fault) {
|
|
bl6 = true;
|
|
}
|
|
this.setStatus(BStatus.makeFault((BStatus)bStatus, (boolean)bl6));
|
|
}
|
|
this.setTimeInCurrentState(BRelTime.make((long)(Clock.ticks() - this.timeOfLastStateChange)));
|
|
}
|
|
BAlarmTransitionBits bAlarmTransitionBits = this.getAckedTransitions();
|
|
if (this.getAlarmEnable().isToOffnormal() || this.getAlarmEnable().isToFault()) {
|
|
if (!(bAlarmTransitionBits.isToOffnormal() && bAlarmTransitionBits.isToFault() && bAlarmTransitionBits.isToNormal() || !bl3)) {
|
|
this.setStatus(BStatus.makeUnackedAlarm((BStatus)this.getStatus(), (boolean)true));
|
|
} else {
|
|
this.setStatus(BStatus.makeUnackedAlarm((BStatus)this.getStatus(), (boolean)false));
|
|
}
|
|
}
|
|
if ((bAlarmState2 == BAlarmState.lowLimit || bAlarmState2 == BAlarmState.highLimit) && bAlarmState == BAlarmState.normal) {
|
|
this.checkAlarms(bStatusValue);
|
|
}
|
|
}
|
|
|
|
private final boolean alarmStateTransition(BSourceState bSourceState, BAlarmState bAlarmState, BStatusValue bStatusValue) {
|
|
HashMap<String, Object> hashMap = new HashMap<String, Object>();
|
|
Object var5_5 = null;
|
|
BOrd bOrd = BOrd.NULL;
|
|
Property property = null;
|
|
boolean bl = false;
|
|
bOrd = this.getHyperlinkOrd();
|
|
if (bSourceState == BSourceState.offnormal) {
|
|
hashMap.put("offnormalValue", BString.make((String)bStatusValue.valueToString((Context)this.getPointFacets())));
|
|
hashMap.put("alarmValue", bStatusValue.getValueValue());
|
|
} else if (bSourceState == BSourceState.fault) {
|
|
hashMap.put("faultValue", BString.make((String)bStatusValue.valueToString((Context)this.getPointFacets())));
|
|
hashMap.put("alarmValue", bStatusValue.getValueValue());
|
|
}
|
|
hashMap.put("presentValue", BString.make((String)bStatusValue.valueToString((Context)this.getPointFacets())));
|
|
hashMap.put("fromState", BString.make((String)this.getAlarmState().getTag()));
|
|
hashMap.put("toState", BString.make((String)bAlarmState.getTag()));
|
|
hashMap.put("sourceName", BString.make((String)this.getSourceName().format((Object)this)));
|
|
if (!bOrd.isNull()) {
|
|
hashMap.put("hyperlinkOrd", BString.make((String)bOrd.toString()));
|
|
}
|
|
if (!this.getSoundFile().isNull()) {
|
|
hashMap.put("soundFile", BString.make((String)this.getSoundFile().toString()));
|
|
}
|
|
if (!this.getAlarmIcon().isNull()) {
|
|
hashMap.put("icon", BString.make((String)this.getAlarmIcon().toString()));
|
|
}
|
|
try {
|
|
if (!this.getAlarmInstructions().equals((Object)BAlarmInstructions.NULL)) {
|
|
hashMap.put("instructions", BString.make((String)this.getAlarmInstructions().encodeToString()));
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Could not encode Alarm Instructions", (Throwable)exception);
|
|
}
|
|
BFacets bFacets = this.getMetaData();
|
|
String[] stringArray = bFacets.list();
|
|
boolean bl2 = false;
|
|
while (bl2 < stringArray.length) {
|
|
hashMap.put(stringArray[bl2], bFacets.get(stringArray[bl2]));
|
|
bl2 += 1;
|
|
}
|
|
if (bSourceState == BSourceState.normal) {
|
|
hashMap.put("msgText", BString.make((String)this.getToNormalText().getFormat()));
|
|
if (this.getAlarmState().isInAlarm()) {
|
|
this.getOffnormalAlgorithm().writeAlarmData(bStatusValue, hashMap);
|
|
} else {
|
|
this.getFaultAlgorithm().writeAlarmData(bStatusValue, hashMap);
|
|
}
|
|
} else if (bSourceState == BSourceState.offnormal) {
|
|
hashMap.put("msgText", BString.make((String)this.getToOffnormalText().getFormat()));
|
|
hashMap.put(BAlarmTimestamps.count.getDefaultDisplayName(null), BInteger.make((int)(this.getToOffnormalTimes().getCount() + 1)));
|
|
this.getOffnormalAlgorithm().writeAlarmData(bStatusValue, hashMap);
|
|
property = toOffnormalTimes;
|
|
} else if (bSourceState == BSourceState.fault) {
|
|
hashMap.put("msgText", BString.make((String)this.getToFaultText().getFormat()));
|
|
hashMap.put(BAlarmTimestamps.count.getDefaultDisplayName(null), BInteger.make((int)(this.getToFaultTimes().getCount() + 1)));
|
|
this.getFaultAlgorithm().writeAlarmData(bStatusValue, hashMap);
|
|
property = toFaultTimes;
|
|
} else {
|
|
throw new IllegalStateException();
|
|
}
|
|
bl2 = false;
|
|
try {
|
|
Object object;
|
|
bl2 = this.support.isAckRequired(bSourceState);
|
|
BAlarmRecord bAlarmRecord = null;
|
|
if (bSourceState == BSourceState.normal) {
|
|
this.support.toNormal(BFacets.make(hashMap), null);
|
|
} else if (bSourceState == BSourceState.offnormal) {
|
|
bAlarmRecord = this.support.newOffnormalAlarm(BFacets.make(hashMap));
|
|
this.lastOffnormalTime = bAlarmRecord.getTimestamp();
|
|
this.fireToOffnormal(bAlarmRecord);
|
|
} else if (bSourceState == BSourceState.fault) {
|
|
bAlarmRecord = this.support.newFaultAlarm(BFacets.make(hashMap));
|
|
this.lastFaultTime = bAlarmRecord.getTimestamp();
|
|
this.fireToFault(bAlarmRecord);
|
|
}
|
|
if (bAlarmRecord != null) {
|
|
if (bSourceState == BSourceState.normal) {
|
|
object = this.getToOffnormalTimes();
|
|
if (!((BAlarmTimestamps)((Object)object)).getAlarmTime().isNull()) {
|
|
((BAlarmTimestamps)((Object)object)).setNormalTime(bAlarmRecord.getNormalTime());
|
|
}
|
|
if (!((BAlarmTimestamps)((Object)(object = this.getToFaultTimes()))).getAlarmTime().isNull()) {
|
|
((BAlarmTimestamps)((Object)object)).setNormalTime(bAlarmRecord.getNormalTime());
|
|
}
|
|
}
|
|
if (property != null) {
|
|
object = (BAlarmTimestamps)this.get(property);
|
|
((BAlarmTimestamps)((Object)object)).setAlarmTime(bAlarmRecord.getTimestamp());
|
|
((BAlarmTimestamps)((Object)object)).setAckTime(BAbsTime.NULL);
|
|
((BAlarmTimestamps)((Object)object)).setNormalTime(BAbsTime.NULL);
|
|
((BAlarmTimestamps)((Object)object)).setCount(((BAlarmTimestamps)((Object)object)).getCount() + 1);
|
|
}
|
|
}
|
|
if (bl2) {
|
|
object = this.getAckedTransitions();
|
|
this.setAckedTransitions(BAlarmTransitionBits.make(object, bSourceState.getAlarmTransitionBits(), false));
|
|
}
|
|
}
|
|
catch (ServiceNotFoundException serviceNotFoundException) {
|
|
log.error("AlarmState Transition Failed - AlarmService not found.");
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("AlarmState Transition Failed: " + exception, (Throwable)exception);
|
|
}
|
|
return bl2;
|
|
}
|
|
|
|
public void fireToNormal(BAlarmRecord bAlarmRecord) {
|
|
this.lastToNormalTime = bAlarmRecord.getNormalTime();
|
|
if (bAlarmRecord.getSourceState().getOrdinal() == 0) {
|
|
BAlarmTimestamps bAlarmTimestamps = this.getToOffnormalTimes();
|
|
if (!bAlarmTimestamps.getAlarmTime().isNull()) {
|
|
bAlarmTimestamps.setNormalTime(bAlarmRecord.getNormalTime());
|
|
}
|
|
if (!(bAlarmTimestamps = this.getToFaultTimes()).getAlarmTime().isNull()) {
|
|
bAlarmTimestamps.setNormalTime(bAlarmRecord.getNormalTime());
|
|
}
|
|
}
|
|
this.fire(toNormal, (BValue)bAlarmRecord, null);
|
|
}
|
|
|
|
public BAbsTime getLastOffnormalTime() {
|
|
return this.lastOffnormalTime;
|
|
}
|
|
|
|
public BAbsTime getLastFaultTime() {
|
|
return this.lastFaultTime;
|
|
}
|
|
|
|
public BAbsTime getLastToNormalTime() {
|
|
return this.lastToNormalTime;
|
|
}
|
|
|
|
public BAbsTime getLastAckTime() {
|
|
return this.lastAckTime;
|
|
}
|
|
|
|
public BIcon getIcon() {
|
|
return icon;
|
|
}
|
|
|
|
private static final void dump(String string) {
|
|
System.out.println(string);
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.timeOfLastStateChange = 0L;
|
|
this.unackedAlarm = false;
|
|
this.lastOffnormalTime = BAbsTime.NULL;
|
|
this.lastFaultTime = BAbsTime.NULL;
|
|
this.lastToNormalTime = BAbsTime.NULL;
|
|
this.lastAckTime = BAbsTime.NULL;
|
|
this.atSteadyState = false;
|
|
}
|
|
|
|
public BAlarmSourceExt() {
|
|
this.this();
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$javax$baja$alarm$ext$BAlarmSourceExt;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$alarm$ext$BAlarmSourceExt = BAlarmSourceExt.class("[Ljavax.baja.alarm.ext.BAlarmSourceExt;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
icon = BIcon.make((BIcon)BIcon.std((String)"control/controlExtension.png"), (BIcon)BIcon.std((String)"badges/alarm.png"));
|
|
log = Log.getLog((String)"alarm");
|
|
}
|
|
}
|
|
|