--- /dev/null
+package org.cacert.gigi.database;
+
+public interface DBEnum {
+
+ public String getDBName();
+}
}
}
+ public void setEnum(int parameterIndex, DBEnum x) {
+ try {
+ target.setString(parameterIndex, x.getDBName());
+ } catch (SQLException e) {
+ handleSQL(e);
+ throw new Error(e);
+ }
+ }
+
public void setDate(int parameterIndex, Date x) {
try {
target.setDate(parameterIndex, x);
}
}
+ public int getParameterCount() {
+ try {
+ return target.getParameterMetaData().getParameterCount();
+ } catch (SQLException e) {
+ throw new Error(e);
+ }
+ }
+
private void handleSQL(SQLException e) {
// TODO Auto-generated method stub
package org.cacert.gigi.dbObjects;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.dbObjects.wrappers.DataContainer;
@DataContainer
public class Assurance {
- public enum AssuranceType {
+ public enum AssuranceType implements DBEnum {
FACE_TO_FACE("Face to Face Meeting"), TOPUP("TOPUP"), TTP_ASSISTED("TTP-Assisted"), NUCLEUS("Nucleus Bonus");
private final String description;
public String getDescription() {
return description;
}
+
+ @Override
+ public String getDBName() {
+ return description;
+ }
}
private int id;
import java.util.Map.Entry;
import org.cacert.gigi.GigiApiException;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiPreparedStatement;
import org.cacert.gigi.database.GigiResultSet;
import org.cacert.gigi.output.template.Outputable;
public class Certificate implements IdCachable {
- public enum SANType {
+ public enum SANType implements DBEnum {
EMAIL("email"), DNS("DNS");
private final String opensslName;
public String getOpensslName() {
return opensslName;
}
+
+ @Override
+ public String getDBName() {
+ return opensslName;
+ }
}
public static class SubjectAlternateName implements Comparable<SubjectAlternateName> {
public static Certificate[] findBySANPattern(String request, SANType type) {
try (GigiPreparedStatement prep = new GigiPreparedStatement("SELECT `certId` FROM `subjectAlternativeNames` WHERE `contents` LIKE ? and `type`=?::`SANType` GROUP BY `certId` LIMIT 100", true)) {
prep.setString(1, request);
- prep.setString(2, type.getOpensslName());
+ prep.setEnum(2, type);
return fetchCertsToArray(prep);
}
}
public void addPing(DomainPingType type, String config) throws GigiApiException {
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `pingconfig` SET `domainid`=?, `type`=?::`pingType`, `info`=?")) {
ps.setInt(1, id);
- ps.setString(2, type.toString().toLowerCase());
+ ps.setEnum(2, type);
ps.setString(3, config);
ps.execute();
}
package org.cacert.gigi.dbObjects;
-public enum DomainPingType {
+import org.cacert.gigi.database.DBEnum;
+
+public enum DomainPingType implements DBEnum {
EMAIL, DNS, HTTP, SSL;
+
+ @Override
+ public String getDBName() {
+ return toString().toLowerCase();
+ }
}
if (id != 0) {
throw new IllegalStateException("already inserted.");
}
- try (GigiPreparedStatement psCheck = new GigiPreparedStatement("SELECT 1 FROM `emails` WHERE email=? AND deleted is NULL"); GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `emails` SET memid=?, email=?")) {
- ps.setInt(1, owner.getId());
- ps.setString(2, address);
+ try (GigiPreparedStatement psCheck = new GigiPreparedStatement("SELECT 1 FROM `emails` WHERE email=? AND deleted is NULL")) {
psCheck.setString(1, address);
GigiResultSet res = psCheck.executeQuery();
if (res.next()) {
throw new GigiApiException("The email address is already known to the system.");
}
+ }
+ try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `emails` SET memid=?, email=?")) {
+ ps.setInt(1, owner.getId());
+ ps.setString(2, address);
ps.execute();
id = ps.lastInsertId();
}
package org.cacert.gigi.dbObjects;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiPreparedStatement;
import org.cacert.gigi.database.GigiResultSet;
import org.cacert.gigi.output.template.Outputable;
import org.cacert.gigi.output.template.TranslateCommand;
-public enum Group {
+public enum Group implements DBEnum {
SUPPORTER("supporter", "supporter", true, false, true), //
ARBITRATOR("arbitrator", "arbitrator", true, false, true), //
BLOCKEDASSURER("blockedassurer", "may not verify", true, false, false), //
return isSelfViewable;
}
- public String getDatabaseName() {
- return dbName;
- }
-
public User[] getMembers(int offset, int count) {
try (GigiPreparedStatement gps = new GigiPreparedStatement("SELECT `user` FROM `user_groups` WHERE `permission`=?::`userGroup` AND `deleted` IS NULL OFFSET ? LIMIT ?", true)) {
- gps.setString(1, dbName);
+ gps.setEnum(1, this);
gps.setInt(2, offset);
gps.setInt(3, count);
GigiResultSet grs = gps.executeQuery();
public int getMemberCount() {
try (GigiPreparedStatement gps = new GigiPreparedStatement("SELECT COUNT(`user`) FROM `user_groups` WHERE `permission`=?::`userGroup` AND `deleted` IS NULL", true)) {
- gps.setString(1, dbName);
+ gps.setEnum(1, this);
GigiResultSet grs = gps.executeQuery();
if ( !grs.next()) {
return 0;
public Outputable getName() {
return tc;
}
+
+ @Override
+ public String getDBName() {
+ return dbName;
+ }
}
import java.sql.Date;
import org.cacert.gigi.GigiApiException;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiPreparedStatement;
import org.cacert.gigi.database.GigiResultSet;
import org.cacert.gigi.output.CertificateValiditySelector;
this.id = id;
}
- public static enum JobType {
+ public static enum JobType implements DBEnum {
SIGN("sign"), REVOKE("revoke");
private final String name;
this.name = name;
}
- public String getName() {
+ @Override
+ public String getDBName() {
return name;
}
}
CertificateValiditySelector.checkValidityLength(period);
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `jobs` SET targetId=?, task=?::`jobType`, executeFrom=?, executeTo=?")) {
ps.setInt(1, targetId.getId());
- ps.setString(2, JobType.SIGN.getName());
+ ps.setEnum(2, JobType.SIGN);
ps.setDate(3, start);
ps.setString(4, period);
ps.execute();
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `jobs` SET targetId=?, task=?::`jobType`")) {
ps.setInt(1, targetId.getId());
- ps.setString(2, JobType.REVOKE.getName());
+ ps.setEnum(2, JobType.REVOKE);
ps.execute();
return cache.put(new Job(ps.lastInsertId()));
}
if (i != null) {
return i;
}
- try (GigiPreparedStatement ps = new GigiPreparedStatement("SELECT 1 FROM `jobs` WHERE id=?'")) {
+ try (GigiPreparedStatement ps = new GigiPreparedStatement("SELECT 1 FROM `jobs` WHERE id=?")) {
ps.setInt(1, id);
GigiResultSet rs = ps.executeQuery();
if (rs.next()) {
import java.util.Map;
import org.cacert.gigi.GigiApiException;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiPreparedStatement;
import org.cacert.gigi.database.GigiResultSet;
import org.cacert.gigi.dbObjects.NamePart.NamePartType;
public class Name implements Outputable, IdCachable {
+ public static enum NameSchemaType implements DBEnum {
+ SINGLE, WESTERN;
+
+ @Override
+ public String getDBName() {
+ return toString().toLowerCase();
+ }
+
+ }
+
private abstract static class SchemedName {
/**
*/
public abstract String toAbbreviatedString();
- public abstract String getSchemeName();
+ public abstract NameSchemaType getSchemeName();
/**
* @see Name#output(PrintWriter, Language, Map)
}
@Override
- public String getSchemeName() {
- return "single";
+ public NameSchemaType getSchemeName() {
+ return NameSchemaType.SINGLE;
}
@Override
}
@Override
- public String getSchemeName() {
- return "western";
+ public NameSchemaType getSchemeName() {
+ return NameSchemaType.WESTERN;
}
@Override
}
try (GigiPreparedStatement inserter = new GigiPreparedStatement("INSERT INTO `names` SET `uid`=?, `type`=?::`nameSchemaType`")) {
inserter.setInt(1, u.getId());
- inserter.setString(2, scheme.getSchemeName());
+ inserter.setEnum(2, scheme.getSchemeName());
inserter.execute();
id = inserter.lastInsertId();
}
inserter.setInt(1, id);
for (int i = 0; i < np.length; i++) {
inserter.setInt(2, i);
- inserter.setString(3, np[i].getType().getDbValue());
+ inserter.setEnum(3, np[i].getType());
inserter.setString(4, np[i].getValue());
inserter.execute();
}
package org.cacert.gigi.dbObjects;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiResultSet;
import org.cacert.gigi.dbObjects.wrappers.DataContainer;
@DataContainer
public class NamePart {
- public enum NamePartType {
+ public enum NamePartType implements DBEnum {
FIRST_NAME, LAST_NAME, SINGLE_NAME, SUFFIX;
- public String getDbValue() {
+ public String getDBName() {
return name().toLowerCase().replace("_", "-");
}
}
public Name[] getNames() {
try (GigiPreparedStatement gps = new GigiPreparedStatement("SELECT `id` FROM `names` WHERE `uid`=? AND `deleted` IS NULL", true)) {
+ gps.setInt(1, getId());
return fetchNamesToArray(gps);
}
}
public Name[] getNonDeprecatedNames() {
try (GigiPreparedStatement gps = new GigiPreparedStatement("SELECT `id` FROM `names` WHERE `uid`=? AND `deleted` IS NULL AND `deprecated` IS NULL", true)) {
+ gps.setInt(1, getId());
return fetchNamesToArray(gps);
}
}
private Name[] fetchNamesToArray(GigiPreparedStatement gps) {
- gps.setInt(1, getId());
GigiResultSet rs = gps.executeQuery();
rs.last();
Name[] dt = new Name[rs.getRow()];
public int getExperiencePoints() {
try (GigiPreparedStatement query = new GigiPreparedStatement("SELECT count(*) FROM ( SELECT `names`.`uid` FROM `notary` INNER JOIN `names` ON `names`.`id` = `to` WHERE `from`=? AND `notary`.`deleted` IS NULL AND `method` = ? ::`notaryType` GROUP BY `names`.`uid`) as p")) {
query.setInt(1, getId());
- query.setString(2, AssuranceType.FACE_TO_FACE.getDescription());
+ query.setEnum(2, AssuranceType.FACE_TO_FACE);
GigiResultSet rs = query.executeQuery();
int points = 0;
groups.add(toGrant);
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `user_groups` SET `user`=?, `permission`=?::`userGroup`, `grantedby`=?")) {
ps.setInt(1, getId());
- ps.setString(2, toGrant.getDatabaseName());
+ ps.setEnum(2, toGrant);
ps.setInt(3, granter.getId());
ps.execute();
}
groups.remove(toRevoke);
try (GigiPreparedStatement ps = new GigiPreparedStatement("UPDATE `user_groups` SET `deleted`=CURRENT_TIMESTAMP, `revokedby`=? WHERE `deleted` IS NULL AND `permission`=?::`userGroup` AND `user`=?")) {
ps.setInt(1, revoker.getId());
- ps.setString(2, toRevoke.getDatabaseName());
+ ps.setEnum(2, toRevoke);
ps.setInt(3, getId());
ps.execute();
}
continue;
}
- try (GigiPreparedStatement statmt = new GigiPreparedStatement("INSERT INTO `emailPinglog` SET `when`=NOW(), `email`=?, `result`=?, `uid`=?, `type`='fast', `status`=?::`pingState`")) {
+ try (GigiPreparedStatement statmt = new GigiPreparedStatement("INSERT INTO `emailPinglog` SET `when`=NOW(), `email`=?, `result`=?, `uid`=?, `type`='fast', `status`='success'::`pingState`")) {
statmt.setString(1, address);
statmt.setString(2, line);
statmt.setInt(3, forUid);
- statmt.setString(4, "success");
statmt.execute();
}
}
}
- try (GigiPreparedStatement statmt = new GigiPreparedStatement("INSERT INTO `emailPinglog` SET `when`=NOW(), `email`=?, `result`=?, `uid`=?, `type`='fast', `status`=?::`pingState`")) {
+ try (GigiPreparedStatement statmt = new GigiPreparedStatement("INSERT INTO `emailPinglog` SET `when`=NOW(), `email`=?, `result`=?, `uid`=?, `type`='fast'::`emailPingType`, `status`='failed'::`pingState`")) {
statmt.setString(1, address);
statmt.setString(2, "Failed to make a connection to the mail server");
statmt.setInt(3, forUid);
- statmt.setString(4, "failed");
statmt.execute();
}
return FAIL;
out.println("<select name='" + name + "'>");
for (Group g : Group.values()) {
if (mayManage(g)) {
- out.print("<option value='" + g.getDatabaseName());
+ out.print("<option value='" + g.getDBName());
if (g.equals(value)) {
out.print(" selected");
}
package org.cacert.gigi.ping;
+import org.cacert.gigi.database.DBEnum;
import org.cacert.gigi.database.GigiPreparedStatement;
import org.cacert.gigi.dbObjects.CertificateOwner;
import org.cacert.gigi.dbObjects.Domain;
public abstract class DomainPinger {
+ public static enum PingState implements DBEnum {
+ OPEN, SUCCESS, FAILED;
+
+ @Override
+ public String getDBName() {
+ return toString().toLowerCase();
+ }
+ }
+
public static final String PING_STILL_PENDING = null;
public static final String PING_SUCCEDED = "";
public abstract void ping(Domain domain, String configuration, CertificateOwner target, int confId);
protected static void enterPingResult(int configId, String state, String result, String token) {
+ PingState estate = DomainPinger.PING_STILL_PENDING == state ? PingState.OPEN : DomainPinger.PING_SUCCEDED.equals(state) ? PingState.SUCCESS : PingState.FAILED;
try (GigiPreparedStatement enterPingResult = new GigiPreparedStatement("INSERT INTO `domainPinglog` SET `configId`=?, `state`=?::`pingState`, `result`=?, `challenge`=?")) {
enterPingResult.setInt(1, configId);
- enterPingResult.setString(2, DomainPinger.PING_STILL_PENDING == state ? "open" : DomainPinger.PING_SUCCEDED.equals(state) ? "success" : "failed");
+ enterPingResult.setEnum(2, estate);
enterPingResult.setString(3, result);
enterPingResult.setString(4, token);
enterPingResult.execute();
try (GigiPreparedStatement ps = new GigiPreparedStatement("SELECT 1 FROM `notary` where `to`=? and `from`=? and `method` = ? ::`notaryType` AND `deleted` IS NULL AND `when` > (now() - interval '1 days' * ?)")) {
ps.setInt(1, target.getId());
ps.setInt(2, assurer.getId());
- ps.setString(3, AssuranceType.FACE_TO_FACE.getDescription());
+ ps.setEnum(3, AssuranceType.FACE_TO_FACE);
ps.setInt(4, LIMIT_DAYS_VERIFICATION);
GigiResultSet rs = ps.executeQuery();
return !rs.next();
assertTrue(rs.next());
assertEquals(0, rs.getInt("revokedby"));
assertEquals(granter.getId(), rs.getInt("grantedby"));
- assertEquals(ttpGroup.getDatabaseName(), rs.getString("permission"));
+ assertEquals(ttpGroup.getDBName(), rs.getString("permission"));
assertNull(rs.getDate("deleted"));
assertNotNull(rs.getDate("granted"));
assertTrue(rs.next());
assertEquals(granter.getId(), rs.getInt("revokedby"));
assertEquals(granter.getId(), rs.getInt("grantedby"));
- assertEquals(ttpGroup.getDatabaseName(), rs.getString("permission"));
+ assertEquals(ttpGroup.getDBName(), rs.getString("permission"));
assertNotNull(rs.getDate("deleted"));
assertNotNull(rs.getDate("granted"));
public void testModifyUserGroup() throws IOException {
User user = User.getById(id);
// test add group
- assertNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=addGroup&groupToModify=" + URLEncoder.encode(Group.LOCATE_AGENT.getDatabaseName(), "UTF-8"), 0));
+ assertNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=addGroup&groupToModify=" + URLEncoder.encode(Group.LOCATE_AGENT.getDBName(), "UTF-8"), 0));
user = User.getById(id);
user.refreshGroups();
assertTrue(user.isInGroup(Group.LOCATE_AGENT));
// test remove group
- assertNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=removeGroup&groupToModify=" + URLEncoder.encode(Group.LOCATE_AGENT.getDatabaseName(), "UTF-8"), 0));
+ assertNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=removeGroup&groupToModify=" + URLEncoder.encode(Group.LOCATE_AGENT.getDBName(), "UTF-8"), 0));
user = User.getById(id);
user.refreshGroups();
assertFalse(user.isInGroup(Group.LOCATE_AGENT));
// test add group that only support can add
- assertNotNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=addGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDatabaseName(), "UTF-8"), 0));
+ assertNotNull(executeBasicWebInteraction(cookie, MyDetails.PATH, "action=addGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDBName(), "UTF-8"), 0));
user = User.getById(id);
user.refreshGroups();
@Test
public void testGrantUserGroup() throws MalformedURLException, IOException {
- executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "addGroup&groupToModify=" + URLEncoder.encode(Group.CODESIGNING.getDatabaseName(), "UTF-8"), 0);
+ executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "addGroup&groupToModify=" + URLEncoder.encode(Group.CODESIGNING.getDBName(), "UTF-8"), 0);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
@Test
public void testRemoveUserGroup() throws MalformedURLException, IOException {
- executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "removeGroup&groupToModify=" + URLEncoder.encode(Group.CODESIGNING.getDatabaseName(), "UTF-8"), 0);
+ executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "removeGroup&groupToModify=" + URLEncoder.encode(Group.CODESIGNING.getDBName(), "UTF-8"), 0);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
@Test
public void testGrantSupporterGroup() throws MalformedURLException, IOException {
- executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "addGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDatabaseName(), "UTF-8"), 0);
+ executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "addGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDBName(), "UTF-8"), 0);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
@Test
public void testRemoveSupporterGroup() throws MalformedURLException, IOException {
- executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "removeGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDatabaseName(), "UTF-8"), 0);
+ executeBasicWebInteraction(cookie, SupportUserDetailsPage.PATH + targetID + "/", "removeGroup&groupToModify=" + URLEncoder.encode(Group.SUPPORTER.getDBName(), "UTF-8"), 0);
StringWriter sw = new StringWriter();
PrintWriter pw = new PrintWriter(sw);
supporter = createVerifiedUser();
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `user_groups` SET `user`=?, `permission`=?::`userGroup`, `grantedby`=?")) {
ps.setInt(1, supporter.getId());
- ps.setString(2, Group.SUPPORTER.getDatabaseName());
+ ps.setString(2, Group.SUPPORTER.getDBName());
ps.setInt(3, supporter.getId());
ps.execute();
}
int i = createVerifiedUser("fn", "ln", createUniqueName() + "@email.com", TEST_PASSWORD);
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `user_groups` SET `user`=?, `permission`=?::`userGroup`, `grantedby`=?")) {
ps.setInt(1, i);
- ps.setString(2, Group.SUPPORTER.getDatabaseName());
+ ps.setString(2, Group.SUPPORTER.getDBName());
ps.setInt(3, i);
ps.execute();
}
if ( !u.isInGroup(Group.SUPPORTER)) {
try (GigiPreparedStatement ps = new GigiPreparedStatement("INSERT INTO `user_groups` SET `user`=?, `permission`=?::`userGroup`, `grantedby`=?")) {
ps.setInt(1, u.getId());
- ps.setString(2, Group.SUPPORTER.getDatabaseName());
+ ps.setString(2, Group.SUPPORTER.getDBName());
ps.setInt(3, u.getId());
ps.execute();
}
projects / gigi.git / commitdiff