link start!

2026-03-17 13:31:18 -07:00
commit 08abe87cfb
5910 changed files with 386288 additions and 0 deletions
@@ -0,0 +1,419 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.baja.collection.BICollection
+ *  javax.baja.data.BIDataValue
+ *  javax.baja.log.Log
+ *  javax.baja.naming.BOrd
+ *  javax.baja.naming.BOrdList
+ *  javax.baja.naming.SlotPath
+ *  javax.baja.nre.util.Array
+ *  javax.baja.security.BIProtected
+ *  javax.baja.security.BPermissions
+ *  javax.baja.security.PermissionException
+ *  javax.baja.sys.Action
+ *  javax.baja.sys.BAbsTime
+ *  javax.baja.sys.BComplex
+ *  javax.baja.sys.BComponent
+ *  javax.baja.sys.BFacets
+ *  javax.baja.sys.BRelTime
+ *  javax.baja.sys.BString
+ *  javax.baja.sys.BValue
+ *  javax.baja.sys.BasicContext
+ *  javax.baja.sys.Clock
+ *  javax.baja.sys.Clock$Ticket
+ *  javax.baja.sys.Context
+ *  javax.baja.sys.Cursor
+ *  javax.baja.sys.Property
+ *  javax.baja.sys.Slot
+ *  javax.baja.sys.Sys
+ *  javax.baja.sys.Type
+ *  javax.baja.user.BUser
+ *  javax.baja.util.BUuid
+ */
+package com.tridium.alarm.model;
+
+import com.tridium.alarm.BConsoleRecipient;
+import com.tridium.alarm.model.BAlarmConsoleRow;
+import javax.baja.alarm.BAckState;
+import javax.baja.alarm.BAlarmClass;
+import javax.baja.alarm.BAlarmDatabase;
+import javax.baja.alarm.BAlarmRecipient;
+import javax.baja.alarm.BAlarmRecord;
+import javax.baja.alarm.BAlarmService;
+import javax.baja.alarm.BSourceState;
+import javax.baja.collection.BICollection;
+import javax.baja.data.BIDataValue;
+import javax.baja.log.Log;
+import javax.baja.naming.BOrd;
+import javax.baja.naming.BOrdList;
+import javax.baja.naming.SlotPath;
+import javax.baja.nre.util.Array;
+import javax.baja.security.BIProtected;
+import javax.baja.security.BPermissions;
+import javax.baja.security.PermissionException;
+import javax.baja.sys.Action;
+import javax.baja.sys.BAbsTime;
+import javax.baja.sys.BComplex;
+import javax.baja.sys.BComponent;
+import javax.baja.sys.BFacets;
+import javax.baja.sys.BRelTime;
+import javax.baja.sys.BString;
+import javax.baja.sys.BValue;
+import javax.baja.sys.BasicContext;
+import javax.baja.sys.Clock;
+import javax.baja.sys.Context;
+import javax.baja.sys.Cursor;
+import javax.baja.sys.Property;
+import javax.baja.sys.Slot;
+import javax.baja.sys.Sys;
+import javax.baja.sys.Type;
+import javax.baja.user.BUser;
+import javax.baja.util.BUuid;
+
+/*
+ * Illegal identifiers - consider using --renameillegalidents true
+ */
+public final class BAlarmConsoleModel
+extends BComponent {
+    public static final Action routeAlarm = BAlarmConsoleModel.newAction((int)260, (BValue)new BAlarmRecord(), null);
+    public static final Action ackAlarms = BAlarmConsoleModel.newAction((int)260, (BValue)new BComponent(), null);
+    public static final Action forceClear = BAlarmConsoleModel.newAction((int)260, (BValue)new BComponent(), null);
+    public static final Action refresh = BAlarmConsoleModel.newAction((int)260, null);
+    public static final Action addNotes = BAlarmConsoleModel.newAction((int)260, (BValue)new BComponent(), null);
+    public static final Action expire = BAlarmConsoleModel.newAction((int)260, null);
+    public static final Type TYPE;
+    private static final BRelTime expiryTime;
+    private static final Log log;
+    private volatile Context routeAlarmCx;
+    private final Object alarmMon;
+    private volatile boolean started;
+    private volatile Clock.Ticket expireTicket;
+    static /* synthetic */ Class class$com$tridium$alarm$model$BAlarmConsoleModel;
+    static /* synthetic */ Class class$com$tridium$alarm$model$BAlarmConsoleRow;
+    static /* synthetic */ Class class$javax$baja$alarm$BAlarmRecord;
+
+    public final void routeAlarm(BAlarmRecord bAlarmRecord) {
+        this.invoke(routeAlarm, (BValue)bAlarmRecord, null);
+    }
+
+    public final void ackAlarms(BComponent bComponent) {
+        this.invoke(ackAlarms, (BValue)bComponent, null);
+    }
+
+    public final void forceClear(BComponent bComponent) {
+        this.invoke(forceClear, (BValue)bComponent, null);
+    }
+
+    public final void refresh() {
+        this.invoke(refresh, null, null);
+    }
+
+    public final void addNotes(BComponent bComponent) {
+        this.invoke(addNotes, (BValue)bComponent, null);
+    }
+
+    public final void expire() {
+        this.invoke(expire, null, null);
+    }
+
+    public final Type getType() {
+        return TYPE;
+    }
+
+    public final void started() {
+        this.linkTo(this.getConsole(), (Slot)BAlarmRecipient.routeAlarm, (Slot)routeAlarm);
+        this.expireTicket = Clock.schedule((BComponent)this, (BRelTime)expiryTime, (Action)expire, null);
+    }
+
+    public final void stopped() throws Exception {
+        this.expireTicket.cancel();
+    }
+
+    public final void subscribed() {
+        this.expireTicket.cancel();
+    }
+
+    public final void unsubscribed() {
+        if (this.isRunning()) {
+            this.expireTicket = Clock.schedule((BComponent)this, (BRelTime)expiryTime, (Action)expire, null);
+        }
+    }
+
+    public final boolean isParentLegal(BComponent bComponent) {
+        return bComponent instanceof BConsoleRecipient;
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     * Unable to fully structure code
+     * Enabled aggressive block sorting
+     * Enabled unnecessary exception pruning
+     * Enabled aggressive exception aggregation
+     */
+    public final void doRefresh(Context var1_1) {
+        if (this.routeAlarmCx == null) {
+            this.routeAlarmCx = new BasicContext(var1_1.getUser(), var1_1.getLanguage());
+        }
+        this.started = true;
+        var2_2 = this.alarmMon;
+        synchronized (var2_2) {
+            if (BAlarmConsoleModel.log.isTraceOn()) {
+                BAlarmConsoleModel.log.trace("Refreshing alarm console");
+            }
+            if ((v0 = BAlarmConsoleModel.class$com$tridium$alarm$model$BAlarmConsoleRow) == null) {
+                v0 = BAlarmConsoleModel.class$com$tridium$alarm$model$BAlarmConsoleRow = BAlarmConsoleModel.class("[Lcom.tridium.alarm.model.BAlarmConsoleRow;", false);
+            }
+            var4_3 = (BAlarmConsoleRow[])this.getChildren(v0);
+            var5_4 = 0;
+            while (true) {
+                block8: {
+                    if (var5_4 < var4_3.length) break block8;
+                    var5_5 = this.getConsole().getOpenAlarms(var1_1);
+                    if (true) ** GOTO lbl27
+                }
+                this.remove((BComplex)var4_3[var5_4]);
+                ++var5_4;
+            }
+            do {
+                if ((var6_6 = (BAlarmRecord)var5_5.get()).getSourceState() == BSourceState.normal && (var6_6.isAcknowledged() || !var6_6.getAckRequired())) continue;
+                this.doRouteAlarm(var6_6, var1_1);
+lbl27:
+                // 3 sources
+
+            } while (var5_5.next());
+            return;
+        }
+    }
+
+    /*
+     * WARNING - Removed try catching itself - possible behaviour change.
+     * Enabled aggressive block sorting
+     * Enabled unnecessary exception pruning
+     * Enabled aggressive exception aggregation
+     */
+    public final void doRouteAlarm(BAlarmRecord bAlarmRecord, Context context) {
+        if (!this.started) {
+            return;
+        }
+        if (!this.getConsole().accept(bAlarmRecord)) {
+            return;
+        }
+        BAlarmService bAlarmService = (BAlarmService)Sys.getService((Type)BAlarmService.TYPE);
+        if (!this.hasPermissions(bAlarmService, bAlarmRecord, BPermissions.operatorRead, this.routeAlarmCx)) {
+            return;
+        }
+        Object object = this.alarmMon;
+        synchronized (object) {
+            block11: {
+                BAlarmConsoleRow bAlarmConsoleRow;
+                String string;
+                block10: {
+                    string = SlotPath.escape((String)bAlarmRecord.getSource().toString());
+                    bAlarmConsoleRow = (BAlarmConsoleRow)this.get(string);
+                    if (bAlarmConsoleRow == null) {
+                        bAlarmConsoleRow = new BAlarmConsoleRow(this.routeAlarmCx);
+                    }
+                    bAlarmConsoleRow.update(bAlarmRecord);
+                    if (!bAlarmConsoleRow.isEmpty()) break block10;
+                    if (bAlarmConsoleRow.getParent() != null) {
+                        this.remove((BComplex)bAlarmConsoleRow);
+                    }
+                    break block11;
+                }
+                int n = 258;
+                if (!this.hasPermissions(bAlarmService, bAlarmRecord, BPermissions.operatorWrite, this.routeAlarmCx)) {
+                    n |= 1;
+                }
+                if (bAlarmConsoleRow.getParent() == null) {
+                    this.add(string, (BValue)bAlarmConsoleRow, n);
+                }
+            }
+            return;
+        }
+    }
+
+    private final BAlarmRecord[] getAlarmRecords(BAlarmService bAlarmService, BComponent bComponent) throws Exception {
+        BComponent bComponent2 = (BComponent)bComponent.get("alarmSources");
+        Class clazz = class$javax$baja$alarm$BAlarmRecord;
+        if (clazz == null) {
+            clazz = class$javax$baja$alarm$BAlarmRecord = BAlarmConsoleModel.class("[Ljavax.baja.alarm.BAlarmRecord;", false);
+        }
+        Array array = new Array(clazz);
+        if (bComponent2 != null) {
+            Property[] propertyArray = bComponent2.getDynamicPropertiesArray();
+            int n = 0;
+            while (n < propertyArray.length) {
+                BValue bValue = bComponent2.get(propertyArray[n]);
+                if (bValue instanceof BOrdList) {
+                    BOrdList bOrdList = (BOrdList)bValue;
+                    BOrd bOrd = BOrd.make((String)("alarm:|bql:select * from openAlarms where source = OrdList '" + SlotPath.escape((String)bOrdList.encodeToString()) + '\''));
+                    BICollection bICollection = (BICollection)bOrd.get();
+                    Cursor cursor = bICollection.cursor();
+                    while (cursor.next()) {
+                        array.add((Object)cursor.get().asValue().newCopy(true));
+                    }
+                }
+                ++n;
+            }
+        } else {
+            BComponent bComponent3 = (BComponent)bComponent.get("alarms");
+            Property[] propertyArray = bComponent3.getDynamicPropertiesArray();
+            int n = 0;
+            while (n < propertyArray.length) {
+                BAlarmRecord bAlarmRecord = bAlarmService.getAlarmDb().getRecord((BUuid)bComponent3.get(propertyArray[n]));
+                if (bAlarmRecord != null) {
+                    array.add((Object)bAlarmRecord.newCopy(true));
+                }
+                ++n;
+            }
+        }
+        return (BAlarmRecord[])array.trim();
+    }
+
+    public final void doAckAlarms(BComponent bComponent, Context context) throws Exception {
+        if (log.isTraceOn()) {
+            log.trace("Acknowledging alarms");
+        }
+        BAlarmService bAlarmService = (BAlarmService)Sys.getService((Type)BAlarmService.TYPE);
+        BAlarmDatabase bAlarmDatabase = bAlarmService.getAlarmDb();
+        BAlarmRecord[] bAlarmRecordArray = this.getAlarmRecords(bAlarmService, bComponent);
+        int n = 0;
+        while (n < bAlarmRecordArray.length) {
+            if (this.hasPermissions(bAlarmService, bAlarmRecordArray[n], BPermissions.operatorWrite, context)) {
+                boolean bl = false;
+                if (bAlarmRecordArray[n].getAckState() != BAckState.ackPending) {
+                    bl = true;
+                }
+                boolean bl2 = bl;
+                bAlarmRecordArray[n].setUser(context.getUser().getUsername());
+                bAlarmRecordArray[n].setAckTime(BAbsTime.now());
+                bAlarmRecordArray[n].setAckState(BAckState.ackPending);
+                if (bl2) {
+                    bAlarmDatabase.update(bAlarmRecordArray[n]);
+                }
+                bAlarmService.ackAlarm(bAlarmRecordArray[n]);
+            }
+            ++n;
+        }
+    }
+
+    public final void doAddNotes(BComponent bComponent, Context context) throws Exception {
+        if (log.isTraceOn()) {
+            log.trace("Add Notes to alarms");
+        }
+        BAlarmService bAlarmService = (BAlarmService)Sys.getService((Type)BAlarmService.TYPE);
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append("##");
+        stringBuffer.append(BAbsTime.now().toString());
+        stringBuffer.append(" - ");
+        stringBuffer.append(context.getUser().getName());
+        stringBuffer.append(" ##\n");
+        stringBuffer.append(((BString)bComponent.get("notes")).toString());
+        BAlarmRecord[] bAlarmRecordArray = this.getAlarmRecords(bAlarmService, bComponent);
+        int n = 0;
+        while (n < bAlarmRecordArray.length) {
+            if (this.hasPermissions(bAlarmService, bAlarmRecordArray[n], BPermissions.operatorWrite, context)) {
+                String string = bAlarmRecordArray[n].getAlarmData().gets("notes", "");
+                bAlarmRecordArray[n].setAlarmData(BFacets.make((BFacets)bAlarmRecordArray[n].getAlarmData(), (String)"notes", (BIDataValue)BString.make((String)(stringBuffer + string))));
+                bAlarmRecordArray[n].setLastUpdate(BAbsTime.now());
+                bAlarmService.routeAlarm(bAlarmRecordArray[n]);
+                bAlarmService.doRouteToSource(bAlarmRecordArray[n]);
+            }
+            ++n;
+        }
+    }
+
+    public final void doExpire(Context context) {
+        if (log.isTraceOn()) {
+            log.trace("Expiring Alarm Console Model: " + this.toPathString());
+        }
+        this.getConsole().remove((BComplex)this);
+    }
+
+    public final void doForceClear(BComponent bComponent, Context context) throws Exception {
+        if (log.isTraceOn()) {
+            log.trace("Alarm force clear");
+        }
+        BAlarmService bAlarmService = (BAlarmService)Sys.getService((Type)BAlarmService.TYPE);
+        BAlarmDatabase bAlarmDatabase = bAlarmService.getAlarmDb();
+        BUser bUser = context.getUser();
+        BPermissions bPermissions = bUser.getPermissionsFor((BIProtected)this.getConsole());
+        if (!bPermissions.has(BPermissions.adminWrite) && !bPermissions.has(BPermissions.adminInvoke)) {
+            throw new PermissionException(bPermissions + " < " + BPermissions.adminWrite);
+        }
+        BAlarmRecord[] bAlarmRecordArray = this.getAlarmRecords(bAlarmService, bComponent);
+        int n = 0;
+        while (n < bAlarmRecordArray.length) {
+            BAlarmRecord bAlarmRecord = bAlarmRecordArray[n];
+            BAlarmClass bAlarmClass = bAlarmService.lookupAlarmClass(bAlarmRecord.getAlarmClass());
+            if (bAlarmClass == null) {
+                bAlarmClass = bAlarmService.getDefaultAlarmClass();
+            }
+            if (bUser.getPermissionsFor((BIProtected)bAlarmClass).has(BPermissions.adminWrite)) {
+                bAlarmRecord.addAlarmFacet("forceCleared", (BIDataValue)BString.make((String)bUser.getUsername()));
+                if (bAlarmRecord.getAckTime().equals((Object)BAbsTime.NULL)) {
+                    bAlarmRecord.setAckTime(BAbsTime.now());
+                }
+                if (bAlarmRecord.getNormalTime().equals((Object)BAbsTime.NULL)) {
+                    bAlarmRecord.setNormalTime(BAbsTime.now());
+                }
+                if (!bAlarmRecord.getAckState().equals((Object)BAckState.acked)) {
+                    bAlarmRecord.setUser(bUser.getUsername());
+                }
+                bAlarmRecord.setSourceState(BSourceState.normal);
+                bAlarmRecord.setAckState(BAckState.acked);
+                bAlarmDatabase.update(bAlarmRecord);
+                bAlarmService.invoke(BAlarmService.auditForceClear, (BValue)bAlarmRecord, context);
+            }
+            ++n;
+        }
+    }
+
+    private final boolean hasPermissions(BAlarmService bAlarmService, BAlarmRecord bAlarmRecord, BPermissions bPermissions, Context context) {
+        BAlarmClass bAlarmClass = bAlarmService.lookupAlarmClass(bAlarmRecord.getAlarmClass());
+        if (bAlarmClass == null) {
+            bAlarmClass = bAlarmService.getDefaultAlarmClass();
+        }
+        return context.getUser().getPermissionsFor((BIProtected)bAlarmClass).has(bPermissions);
+    }
+
+    private final BConsoleRecipient getConsole() {
+        return (BConsoleRecipient)this.getParent();
+    }
+
+    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.alarmMon = new Object();
+        this.started = false;
+        this.expireTicket = Clock.expiredTicket;
+    }
+
+    public BAlarmConsoleModel() {
+        this.this();
+    }
+
+    static {
+        Class clazz = class$com$tridium$alarm$model$BAlarmConsoleModel;
+        if (clazz == null) {
+            clazz = class$com$tridium$alarm$model$BAlarmConsoleModel = BAlarmConsoleModel.class("[Lcom.tridium.alarm.model.BAlarmConsoleModel;", false);
+        }
+        TYPE = Sys.loadType((Class)clazz);
+        expiryTime = BRelTime.makeSeconds((int)60);
+        log = Log.getLog((String)"alarm.alarmConsoleModel");
+    }
+}
+
@@ -0,0 +1,191 @@
+/*
+ * Decompiled with CFR 0.152.
+ * 
+ * Could not load the following classes:
+ *  javax.baja.sys.BStruct
+ *  javax.baja.sys.BValue
+ *  javax.baja.sys.Context
+ *  javax.baja.sys.Property
+ *  javax.baja.sys.Sys
+ *  javax.baja.sys.Type
+ */
+package com.tridium.alarm.model;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import javax.baja.alarm.BAckState;
+import javax.baja.alarm.BAlarmRecord;
+import javax.baja.alarm.BSourceState;
+import javax.baja.sys.BStruct;
+import javax.baja.sys.BValue;
+import javax.baja.sys.Context;
+import javax.baja.sys.Property;
+import javax.baja.sys.Sys;
+import javax.baja.sys.Type;
+
+/*
+ * Illegal identifiers - consider using --renameillegalidents true
+ */
+public final class BAlarmConsoleRow
+extends BStruct {
+    public static final Property alarm = BAlarmConsoleRow.newProperty((int)257, (BValue)new BAlarmRecord(), null);
+    public static final Property ackState = BAlarmConsoleRow.newProperty((int)257, (String)"", null);
+    public static final Type TYPE;
+    private Map openAlarms;
+    private Context cx;
+    private int ackedCount;
+    private int ackPendingCount;
+    private int unackedCount;
+    static /* synthetic */ Class class$com$tridium$alarm$model$BAlarmConsoleRow;
+
+    public final BAlarmRecord getAlarm() {
+        return (BAlarmRecord)this.get(alarm);
+    }
+
+    public final void setAlarm(BAlarmRecord bAlarmRecord) {
+        this.set(alarm, (BValue)bAlarmRecord, null);
+    }
+
+    public final String getAckState() {
+        return this.getString(ackState);
+    }
+
+    public final void setAckState(String string) {
+        this.setString(ackState, string, null);
+    }
+
+    public final Type getType() {
+        return TYPE;
+    }
+
+    public final String toString(Context context) {
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(this.getAlarm().getTimestamp().toString());
+        stringBuffer.append(" ");
+        stringBuffer.append(this.getAckStateStr());
+        return stringBuffer.toString();
+    }
+
+    final void update(BAlarmRecord bAlarmRecord) {
+        BAlarmRecord bAlarmRecord2 = (BAlarmRecord)((Object)this.openAlarms.get(bAlarmRecord.getUuid()));
+        bAlarmRecord = (BAlarmRecord)bAlarmRecord.newCopy(true);
+        this.openAlarms.put(bAlarmRecord.getUuid(), bAlarmRecord);
+        if (bAlarmRecord2 != null) {
+            if (!bAlarmRecord2.isAcknowledged() && !bAlarmRecord2.isAckPending() && bAlarmRecord.isAckPending()) {
+                ++this.ackPendingCount;
+                --this.unackedCount;
+            } else if (bAlarmRecord2.isAckPending() && bAlarmRecord.isAcknowledged()) {
+                --this.ackPendingCount;
+                ++this.ackedCount;
+            } else if (bAlarmRecord2.isAckPending() && !bAlarmRecord.isAcknowledged() && !bAlarmRecord.isAckPending()) {
+                --this.ackPendingCount;
+                ++this.unackedCount;
+            } else if (bAlarmRecord2.isAcknowledged() && !bAlarmRecord.isAcknowledged() && !bAlarmRecord.isAckPending()) {
+                --this.ackedCount;
+                ++this.unackedCount;
+            } else if (bAlarmRecord2.isAcknowledged() && bAlarmRecord.isAckPending()) {
+                --this.ackedCount;
+                ++this.ackPendingCount;
+            } else if (bAlarmRecord.isAcknowledged() && !bAlarmRecord2.isAcknowledged() && !bAlarmRecord2.isAckPending()) {
+                ++this.ackedCount;
+                --this.unackedCount;
+            }
+        } else if (bAlarmRecord.isAcknowledged()) {
+            ++this.ackedCount;
+        } else if (bAlarmRecord.isAckPending()) {
+            ++this.ackPendingCount;
+        } else {
+            ++this.unackedCount;
+        }
+        if (!(bAlarmRecord.getSourceState() != BSourceState.normal && bAlarmRecord.getSourceState() != BSourceState.alert || !bAlarmRecord.isAcknowledged() && bAlarmRecord.getAckRequired())) {
+            if (this.openAlarms.get(bAlarmRecord.getUuid()) == null) {
+                return;
+            }
+            this.openAlarms.remove(bAlarmRecord.getUuid());
+            if (bAlarmRecord.isAcknowledged()) {
+                --this.ackedCount;
+            } else if (bAlarmRecord.getAckState() == BAckState.ackPending) {
+                --this.ackPendingCount;
+            } else {
+                --this.unackedCount;
+            }
+        }
+        this.updateAlarmInfo();
+    }
+
+    final boolean isEmpty() {
+        boolean bl = false;
+        if (this.openAlarms.size() == 0) {
+            bl = true;
+        }
+        return bl;
+    }
+
+    private final void updateAlarmInfo() {
+        BAlarmRecord bAlarmRecord = null;
+        BAlarmRecord bAlarmRecord2 = null;
+        Iterator iterator = this.openAlarms.keySet().iterator();
+        while (iterator.hasNext()) {
+            bAlarmRecord2 = (BAlarmRecord)((Object)this.openAlarms.get(iterator.next()));
+            if (bAlarmRecord == null) {
+                bAlarmRecord = bAlarmRecord2;
+                continue;
+            }
+            if (!bAlarmRecord2.getTimestamp().isAfter(bAlarmRecord.getTimestamp())) continue;
+            bAlarmRecord = bAlarmRecord2;
+        }
+        if (bAlarmRecord != null) {
+            this.setAlarm(bAlarmRecord);
+        }
+        this.setAckState(this.getAckStateStr());
+    }
+
+    private final String getAckStateStr() {
+        StringBuffer stringBuffer = new StringBuffer();
+        stringBuffer.append(this.ackedCount).append(" ").append(BAckState.acked.getDisplayTag(this.cx)).append(" / ");
+        stringBuffer.append(this.unackedCount).append(" ").append(BAckState.unacked.getDisplayTag(this.cx));
+        if (this.ackPendingCount > 0) {
+            stringBuffer.append(" / ").append(this.ackPendingCount).append(" ").append(BAckState.ackPending.getDisplayTag(this.cx));
+        }
+        return stringBuffer.toString();
+    }
+
+    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.openAlarms = new HashMap();
+        this.ackedCount = 0;
+        this.ackPendingCount = 0;
+        this.unackedCount = 0;
+    }
+
+    public BAlarmConsoleRow() {
+        this.this();
+    }
+
+    public BAlarmConsoleRow(Context context) {
+        this.this();
+        this.cx = context;
+    }
+
+    static {
+        Class clazz = class$com$tridium$alarm$model$BAlarmConsoleRow;
+        if (clazz == null) {
+            clazz = class$com$tridium$alarm$model$BAlarmConsoleRow = BAlarmConsoleRow.class("[Lcom.tridium.alarm.model.BAlarmConsoleRow;", false);
+        }
+        TYPE = Sys.loadType((Class)clazz);
+    }
+}
+