504 lines
18 KiB
Java
504 lines
18 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* com.tridium.crypto.core.cert.NHostExemption
|
|
* com.tridium.crypto.core.io.ICoreExemptionStore
|
|
* com.tridium.platform.ui.util.BCommandBoundTable
|
|
* com.tridium.platform.ui.util.BCommandEnablePolicy
|
|
* com.tridium.platform.ui.util.CommandBindings$Support
|
|
* com.tridium.platform.ui.util.CommandBindings$TableSelection
|
|
* com.tridium.platform.ui.util.CommandUtil
|
|
* javax.baja.gx.BImage
|
|
* javax.baja.log.Log
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.nre.util.SortUtil
|
|
* javax.baja.sys.Sys
|
|
* javax.baja.sys.Type
|
|
* javax.baja.ui.BDialog
|
|
* javax.baja.ui.BWidget
|
|
* javax.baja.ui.Command
|
|
* javax.baja.ui.CommandArtifact
|
|
* javax.baja.ui.table.DynamicTableModel
|
|
* javax.baja.ui.table.TableModel
|
|
* javax.baja.util.Lexicon
|
|
*/
|
|
package com.tridium.platcrypto.ui;
|
|
|
|
import com.tridium.crypto.core.cert.NHostExemption;
|
|
import com.tridium.crypto.core.io.ICoreExemptionStore;
|
|
import com.tridium.platcrypto.ui.BExemptionChangedDialog;
|
|
import com.tridium.platcrypto.ui.BExemptionViewDialog;
|
|
import com.tridium.platform.ui.util.BCommandBoundTable;
|
|
import com.tridium.platform.ui.util.BCommandEnablePolicy;
|
|
import com.tridium.platform.ui.util.CommandBindings;
|
|
import com.tridium.platform.ui.util.CommandUtil;
|
|
import java.util.Enumeration;
|
|
import javax.baja.gx.BImage;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.nre.util.SortUtil;
|
|
import javax.baja.sys.Sys;
|
|
import javax.baja.sys.Type;
|
|
import javax.baja.ui.BDialog;
|
|
import javax.baja.ui.BWidget;
|
|
import javax.baja.ui.Command;
|
|
import javax.baja.ui.CommandArtifact;
|
|
import javax.baja.ui.table.DynamicTableModel;
|
|
import javax.baja.ui.table.TableModel;
|
|
import javax.baja.util.Lexicon;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BExemptionTable
|
|
extends BCommandBoundTable
|
|
implements CommandBindings.Support {
|
|
public static final Type TYPE;
|
|
public static final int COL_HOST = 0;
|
|
public static final int COL_SUBJECT = 1;
|
|
public static final int COL_STATUS = 2;
|
|
public static final int COL_CREATED = 3;
|
|
public static final int COL_ISSUER = 4;
|
|
public static final int COL_NOT_BEFORE = 5;
|
|
public static final int COL_NOT_AFTER = 6;
|
|
public static final int COL_KEY_ALG = 7;
|
|
public static final int COL_KEY_SIZE = 8;
|
|
public static final int COL_SIG_ALG = 9;
|
|
public static final int COL_SIG_SIZE = 10;
|
|
public static final int COL_VALID = 11;
|
|
protected static Log log;
|
|
public static final Lexicon lex;
|
|
static final BImage securityHigh;
|
|
static final BImage securityMedium;
|
|
static final BImage securityLow;
|
|
protected ICoreExemptionStore mgr;
|
|
protected boolean readonly;
|
|
static /* synthetic */ Class class$com$tridium$platcrypto$ui$BExemptionTable;
|
|
|
|
public Type getType() {
|
|
return TYPE;
|
|
}
|
|
|
|
public void load() throws Exception {
|
|
this.exemptModel().load();
|
|
}
|
|
|
|
protected void initCommands() {
|
|
this.getCommandBindings().setSupport((CommandBindings.Support)this);
|
|
ViewCommand viewCommand = new ViewCommand();
|
|
this.addCommand(viewCommand, BCommandEnablePolicy.singleSelection);
|
|
this.setDoubleClickCommand(viewCommand);
|
|
this.addCommand(new ApproveCommand(), BCommandEnablePolicy.anySelection);
|
|
this.addCommand(new UnapproveCommand(), BCommandEnablePolicy.anySelection);
|
|
this.addCommand(new DeleteCommand(), BCommandEnablePolicy.anySelection);
|
|
}
|
|
|
|
protected ExemptionModel exemptModel() {
|
|
DynamicTableModel dynamicTableModel = (DynamicTableModel)this.getModel();
|
|
return (ExemptionModel)dynamicTableModel.getRootModel();
|
|
}
|
|
|
|
public boolean isReadonly() {
|
|
return this.readonly;
|
|
}
|
|
|
|
public void setReadonly(boolean bl) {
|
|
this.readonly = bl;
|
|
this.setCommandEnabledStates();
|
|
}
|
|
|
|
public void setBoundCommandEnabled(Command command, boolean bl) {
|
|
if (this.readonly && (command instanceof ApproveCommand || command instanceof UnapproveCommand || command instanceof DeleteCommand)) {
|
|
command.setEnabled(false);
|
|
} else {
|
|
CommandBindings.TableSelection tableSelection = (CommandBindings.TableSelection)this.getSelection();
|
|
int[] nArray = tableSelection.getRows();
|
|
if (nArray.length > 0 && command instanceof ApprovalCommand) {
|
|
ApprovalCommand approvalCommand = (ApprovalCommand)command;
|
|
DynamicTableModel dynamicTableModel = (DynamicTableModel)this.getModel();
|
|
ExemptionModel exemptionModel = (ExemptionModel)dynamicTableModel.getRootModel();
|
|
boolean bl2 = true;
|
|
int n = 0;
|
|
while (n < nArray.length) {
|
|
NHostExemption nHostExemption = (NHostExemption)exemptionModel.exemptions.get(nArray[n]);
|
|
bl2 &= nHostExemption.getApproved();
|
|
++n;
|
|
}
|
|
command.setEnabled(approvalCommand.isApproved() ? bl2 ^ true : bl2);
|
|
} else {
|
|
command.setEnabled(bl);
|
|
}
|
|
}
|
|
}
|
|
|
|
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.mgr = null;
|
|
this.readonly = false;
|
|
}
|
|
|
|
public BExemptionTable() throws UnsupportedOperationException {
|
|
this.this();
|
|
throw new UnsupportedOperationException();
|
|
}
|
|
|
|
public BExemptionTable(ICoreExemptionStore iCoreExemptionStore) throws Exception {
|
|
int[] nArray = new int[7];
|
|
nArray[1] = 1;
|
|
nArray[2] = 2;
|
|
nArray[3] = 3;
|
|
nArray[4] = 4;
|
|
nArray[5] = 5;
|
|
nArray[6] = 6;
|
|
super((TableModel)new DynamicTableModel((TableModel)new ExemptionModel(iCoreExemptionStore), nArray));
|
|
this.this();
|
|
this.mgr = iCoreExemptionStore;
|
|
this.initCommands();
|
|
}
|
|
|
|
static {
|
|
Class clazz = class$com$tridium$platcrypto$ui$BExemptionTable;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$platcrypto$ui$BExemptionTable = BExemptionTable.class("[Lcom.tridium.platcrypto.ui.BExemptionTable;", false);
|
|
}
|
|
TYPE = Sys.loadType((Class)clazz);
|
|
log = Log.getLog((String)"crypto");
|
|
lex = Lexicon.make((String)"platCrypto");
|
|
securityHigh = BImage.make((String)lex.get("security.high.x16.icon", "module://icons/x16/security-high.png"));
|
|
securityMedium = BImage.make((String)lex.get("security.medium.x16.icon", "module://icons/x16/security-medium.png"));
|
|
securityLow = BImage.make((String)lex.get("security.low.x16.icon", "module://icons/x16/security-low.png"));
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
static class ExemptionModel
|
|
extends TableModel {
|
|
private Array exemptions;
|
|
private ICoreExemptionStore mgr;
|
|
static /* synthetic */ Class class$com$tridium$crypto$core$cert$NHostExemption;
|
|
|
|
public BImage getRowIcon(int n) {
|
|
if (!this.exemption(n).getApproved()) {
|
|
return securityLow;
|
|
}
|
|
if (this.exemption(n).getChanged() != null) {
|
|
return securityMedium;
|
|
}
|
|
return securityHigh;
|
|
}
|
|
|
|
public void load() throws Exception {
|
|
Enumeration enumeration = this.mgr.exemptions();
|
|
Class clazz = class$com$tridium$crypto$core$cert$NHostExemption;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$crypto$core$cert$NHostExemption = ExemptionModel.class("[Lcom.tridium.crypto.core.cert.NHostExemption;", false);
|
|
}
|
|
this.exemptions = new Array(clazz);
|
|
while (enumeration.hasMoreElements()) {
|
|
this.exemptions.add(enumeration.nextElement());
|
|
}
|
|
this.updateTable(true);
|
|
this.getSelection().deselectAll();
|
|
}
|
|
|
|
public int getColumnCount() {
|
|
return 12;
|
|
}
|
|
|
|
public String getColumnName(int n) {
|
|
switch (n) {
|
|
case 0: {
|
|
return lex.getText("exempt.field.host");
|
|
}
|
|
case 2: {
|
|
return lex.getText("exempt.field.approved");
|
|
}
|
|
case 3: {
|
|
return lex.getText("exempt.field.created");
|
|
}
|
|
case 4: {
|
|
return lex.getText("cert.field.issuedBy");
|
|
}
|
|
case 1: {
|
|
return lex.getText("cert.field.subject");
|
|
}
|
|
case 5: {
|
|
return lex.getText("cert.field.notBefore");
|
|
}
|
|
case 6: {
|
|
return lex.getText("cert.field.notAfter");
|
|
}
|
|
case 7: {
|
|
return lex.getText("cert.field.keyAlgorithm");
|
|
}
|
|
case 8: {
|
|
return lex.getText("cert.field.keySize");
|
|
}
|
|
case 9: {
|
|
return lex.getText("cert.field.signatureAlgorithm");
|
|
}
|
|
case 10: {
|
|
return lex.getText("cert.field.signatureSize");
|
|
}
|
|
case 11: {
|
|
return lex.getText("cert.field.valid");
|
|
}
|
|
}
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
|
|
public boolean isColumnSortable(int n) {
|
|
return true;
|
|
}
|
|
|
|
public void sortByColumn(int n, boolean bl) {
|
|
Object[] objectArray = this.getColumnValues(n);
|
|
Object[] objectArray2 = this.exemptions.trim();
|
|
SortUtil.sort((Object[])objectArray, (Object[])objectArray2, (boolean)bl);
|
|
this.exemptions.clear();
|
|
this.exemptions.addAll(objectArray2);
|
|
this.updateTable(false);
|
|
}
|
|
|
|
public int getRowCount() {
|
|
int n = 0;
|
|
if (this.exemptions != null) {
|
|
n = this.exemptions.size();
|
|
}
|
|
return n;
|
|
}
|
|
|
|
public NHostExemption exemption(int n) {
|
|
return (NHostExemption)this.exemptions.get(n);
|
|
}
|
|
|
|
public Object getValueAt(int n, int n2) {
|
|
switch (n2) {
|
|
case 0: {
|
|
return this.exemption(n).getHost();
|
|
}
|
|
case 2: {
|
|
return this.exemption(n).getApproved() ? lex.getText("exempt.field.approved.true") : lex.getText("exempt.field.approved.false");
|
|
}
|
|
case 3: {
|
|
return this.exemption(n).getCreated();
|
|
}
|
|
case 4: {
|
|
return this.exemption(n).getCertificate().getIssuer();
|
|
}
|
|
case 1: {
|
|
return this.exemption(n).getCertificate().getSubject();
|
|
}
|
|
case 5: {
|
|
return this.exemption(n).getCertificate().getNotBefore();
|
|
}
|
|
case 6: {
|
|
return this.exemption(n).getCertificate().getNotAfter();
|
|
}
|
|
case 7: {
|
|
return this.exemption(n).getCertificate().getKeyAlgorithm();
|
|
}
|
|
case 8: {
|
|
return "" + this.exemption(n).getCertificate().getKeySize();
|
|
}
|
|
case 9: {
|
|
return this.exemption(n).getCertificate().getSignatureAlgorithm();
|
|
}
|
|
case 10: {
|
|
return "" + this.exemption(n).getCertificate().getSignatureSize();
|
|
}
|
|
case 11: {
|
|
return this.exemption(n).getCertificate().checkValidity() ? lex.getText("cert.field.valid.true") : lex.getText("cert.field.valid.false");
|
|
}
|
|
}
|
|
throw new IndexOutOfBoundsException();
|
|
}
|
|
|
|
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.exemptions = null;
|
|
this.mgr = null;
|
|
}
|
|
|
|
public ExemptionModel(ICoreExemptionStore iCoreExemptionStore) {
|
|
this.this();
|
|
this.mgr = iCoreExemptionStore;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
protected class ViewCommand
|
|
extends Command {
|
|
public CommandArtifact doInvoke() {
|
|
try {
|
|
int n = BExemptionTable.this.exemptModel().getSelection().getRow();
|
|
NHostExemption nHostExemption = BExemptionTable.this.exemptModel().exemption(n);
|
|
if (nHostExemption.getChanged() != null) {
|
|
if (BExemptionChangedDialog.show((BWidget)BExemptionTable.this, nHostExemption)) {
|
|
nHostExemption.approveChanged();
|
|
BExemptionTable.this.mgr.setExemption(nHostExemption);
|
|
BExemptionTable.this.mgr.save();
|
|
}
|
|
} else {
|
|
BExemptionViewDialog.show((BWidget)BExemptionTable.this, nHostExemption);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
CommandUtil.error((Command)this, (Throwable)exception);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public ViewCommand() {
|
|
super((BWidget)BExemptionTable.this, lex, "exemption.button.view");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
protected class ApproveCommand
|
|
extends ApprovalCommand {
|
|
public String getTitle() {
|
|
return "exempt.approve.dialog.title";
|
|
}
|
|
|
|
public String getInfo() {
|
|
return "exempt.approve.dialog.info";
|
|
}
|
|
|
|
public boolean isApproved() {
|
|
return true;
|
|
}
|
|
|
|
public ApproveCommand() {
|
|
super((BWidget)BExemptionTable.this, lex, "exemption.button.approve");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
protected class UnapproveCommand
|
|
extends ApprovalCommand {
|
|
public String getTitle() {
|
|
return "exempt.unapprove.dialog.title";
|
|
}
|
|
|
|
public String getInfo() {
|
|
return "exempt.unapprove.dialog.info";
|
|
}
|
|
|
|
public boolean isApproved() {
|
|
return false;
|
|
}
|
|
|
|
public UnapproveCommand() {
|
|
super((BWidget)BExemptionTable.this, lex, "exemption.button.unapprove");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
protected class DeleteCommand
|
|
extends Command {
|
|
public CommandArtifact doInvoke() {
|
|
try {
|
|
if (4 == BDialog.confirm((BWidget)BExemptionTable.this, (String)lex.getText("exempt.delete.dialog.title"), (Object)lex.getText("exempt.delete.dialog.info"), (int)12)) {
|
|
int[] nArray = BExemptionTable.this.getSelection().getRows();
|
|
int n = 0;
|
|
while (n < nArray.length) {
|
|
String string = BExemptionTable.this.exemptModel().exemption(nArray[n]).getHost();
|
|
BExemptionTable.this.mgr.deleteExemption(string);
|
|
++n;
|
|
}
|
|
BExemptionTable.this.mgr.save();
|
|
BExemptionTable.this.exemptModel().load();
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
CommandUtil.error((Command)this, (Throwable)exception);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public DeleteCommand() {
|
|
super((BWidget)BExemptionTable.this, lex, "exemption.button.delete");
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
protected abstract class ApprovalCommand
|
|
extends Command {
|
|
public abstract String getTitle();
|
|
|
|
public abstract String getInfo();
|
|
|
|
public abstract boolean isApproved();
|
|
|
|
public CommandArtifact doInvoke() {
|
|
try {
|
|
if (4 == BDialog.confirm((BWidget)BExemptionTable.this, (String)lex.getText(this.getTitle()), (Object)lex.getText(this.getInfo()), (int)12)) {
|
|
int[] nArray = BExemptionTable.this.getSelection().getRows();
|
|
boolean bl = false;
|
|
int n = 0;
|
|
while (n < nArray.length) {
|
|
NHostExemption nHostExemption = BExemptionTable.this.exemptModel().exemption(nArray[n]);
|
|
boolean bl2 = this.isApproved();
|
|
if (bl2 != nHostExemption.getApproved()) {
|
|
nHostExemption.setApproved(bl2);
|
|
BExemptionTable.this.mgr.setExemption(nHostExemption);
|
|
bl = true;
|
|
}
|
|
++n;
|
|
}
|
|
if (bl) {
|
|
BExemptionTable.this.mgr.save();
|
|
}
|
|
BExemptionTable.this.exemptModel().load();
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
CommandUtil.error((Command)this, (Throwable)exception);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public ApprovalCommand(BWidget bWidget, Lexicon lexicon, String string) {
|
|
super(bWidget, lexicon, string);
|
|
}
|
|
}
|
|
}
|
|
|