From 12606726c11efbbf7213b05284c94e28a1ae4b8e Mon Sep 17 00:00:00 2001 From: Trygve Laugstøl Date: Sat, 5 Jan 2013 22:39:18 +0100 Subject: o Including state in both badge and badge progress. o Removing count from badge, inserting one badge per badge received. --- .../esper/testing/core/badge/BadgeProgress.java | 2 +- .../esper/testing/core/badge/BadgeService.java | 45 +++++++++++++++---- .../esper/testing/core/badge/PersonalBadge.java | 13 ++++++ .../esper/testing/core/badge/UnbreakableBadge.java | 13 ++++-- .../core/badge/UnbreakableBadgeProgress.java | 51 ++++++++++++---------- .../testing/core/badge/UnbreakablePoller.java | 39 ++++++++--------- .../io/trygvis/esper/testing/core/db/BuildDao.java | 4 +- .../esper/testing/core/db/PersonBadgeDto.java | 25 ----------- .../trygvis/esper/testing/core/db/PersonDao.java | 44 ++++++++----------- .../esper/testing/core/db/PersonalBadgeDto.java | 25 +++++++++++ 10 files changed, 150 insertions(+), 111 deletions(-) create mode 100644 src/main/java/io/trygvis/esper/testing/core/badge/PersonalBadge.java delete mode 100644 src/main/java/io/trygvis/esper/testing/core/db/PersonBadgeDto.java create mode 100644 src/main/java/io/trygvis/esper/testing/core/db/PersonalBadgeDto.java (limited to 'src/main/java/io/trygvis/esper/testing/core') diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/BadgeProgress.java b/src/main/java/io/trygvis/esper/testing/core/badge/BadgeProgress.java index eb8d4bd..c2fda15 100644 --- a/src/main/java/io/trygvis/esper/testing/core/badge/BadgeProgress.java +++ b/src/main/java/io/trygvis/esper/testing/core/badge/BadgeProgress.java @@ -1,6 +1,6 @@ package io.trygvis.esper.testing.core.badge; -import io.trygvis.esper.testing.core.db.PersonBadgeDto.*; +import io.trygvis.esper.testing.core.db.PersonalBadgeDto.*; public abstract class BadgeProgress { public final BadgeType type; diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/BadgeService.java b/src/main/java/io/trygvis/esper/testing/core/badge/BadgeService.java index ea0c0dc..bf06fbb 100644 --- a/src/main/java/io/trygvis/esper/testing/core/badge/BadgeService.java +++ b/src/main/java/io/trygvis/esper/testing/core/badge/BadgeService.java @@ -9,20 +9,38 @@ import java.io.*; public class BadgeService { private final Logger logger = LoggerFactory.getLogger(getClass()); - private static final ObjectMapper objectMapper = new ObjectMapper(); + private final ObjectMapper objectMapper; - public UnbreakableBadgeProgress unbreakable(PersonBadgeProgressDto dto) { - String state = dto.state; + public BadgeService(ObjectMapper objectMapper) { + this.objectMapper = objectMapper; + } - try { - return objectMapper.readValue(state, UnbreakableBadgeProgress.class); - } catch (IOException e) { - logger.error("Could not de-serialize badge state: {}", state); - throw new RuntimeException(e); + public BadgeProgress badgeProgress(PersonBadgeProgressDto dto) { + switch (PersonalBadgeDto.BadgeType.valueOf(dto.badge)) { + case UNBREAKABLE: + return getProgress(dto.state, UnbreakableBadgeProgress.class); } + + throw new RuntimeException("Unknown badge type: " + dto.badge); + } + + public T badgeProgress(PersonBadgeProgressDto dto, Class klass) { + switch (PersonalBadgeDto.BadgeType.valueOf(dto.badge)) { + case UNBREAKABLE: + if(!klass.equals(UnbreakableBadgeProgress.class)) { + throw new RuntimeException("Badge is not of the expected type: UNBREAKABLE."); + } + return getProgress(dto.state, klass); + } + + throw new RuntimeException("Unknown badge type: " + dto.badge); } - public String serialize(UnbreakableBadgeProgress badge) { + public UnbreakableBadge unbreakable(PersonalBadgeDto dto) { + return getProgress(dto.state, UnbreakableBadge.class); + } + + public String serialize(Object badge) { try { CharArrayWriter writer = new CharArrayWriter(); objectMapper.writeValue(writer, badge); @@ -32,4 +50,13 @@ public class BadgeService { throw new RuntimeException(e); } } + + private T getProgress(String state, Class klass) { + try { + return objectMapper.readValue(state, klass); + } catch (IOException e) { + logger.error("Could not de-serialize badge state: {}", state); + throw new RuntimeException(e); + } + } } diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/PersonalBadge.java b/src/main/java/io/trygvis/esper/testing/core/badge/PersonalBadge.java new file mode 100644 index 0000000..c34c35c --- /dev/null +++ b/src/main/java/io/trygvis/esper/testing/core/badge/PersonalBadge.java @@ -0,0 +1,13 @@ +package io.trygvis.esper.testing.core.badge; + +import io.trygvis.esper.testing.*; + +public class PersonalBadge { + public final Uuid person; + public final int level; + + public PersonalBadge(Uuid person, int level) { + this.person = person; + this.level = level; + } +} diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadge.java b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadge.java index a4f1e54..6b1c78d 100644 --- a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadge.java +++ b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadge.java @@ -1,14 +1,19 @@ package io.trygvis.esper.testing.core.badge; -class UnbreakableBadge { +import io.trygvis.esper.testing.*; + +import java.util.*; + +class UnbreakableBadge extends PersonalBadge { // Configuration for this badge public static final int LEVEL_1_COUNT = 10; public static final int LEVEL_2_COUNT = 20; public static final int LEVEL_3_COUNT = 50; - public final int level; + public final List builds; - UnbreakableBadge(int level) { - this.level = level; + UnbreakableBadge(Uuid person, int level, List builds) { + super(person, level); + this.builds = builds; } } diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadgeProgress.java b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadgeProgress.java index 4cba611..f43ec94 100644 --- a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadgeProgress.java +++ b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakableBadgeProgress.java @@ -4,30 +4,34 @@ import static fj.P.*; import fj.*; import fj.data.*; import static fj.data.Option.*; +import static java.util.Collections.singletonList; + +import io.trygvis.esper.testing.*; import io.trygvis.esper.testing.core.db.*; -import io.trygvis.esper.testing.core.db.PersonBadgeDto.*; +import io.trygvis.esper.testing.core.db.PersonalBadgeDto.*; import java.util.*; +import java.util.List; public class UnbreakableBadgeProgress extends BadgeProgress { - public final UUID person; - public final int count; + public final Uuid person; + public final List builds; - private UnbreakableBadgeProgress(UUID person, int count) { + private UnbreakableBadgeProgress(Uuid person, List builds) { super(BadgeType.UNBREAKABLE); this.person = person; - this.count = count; + this.builds = Collections.unmodifiableList(builds); } @SuppressWarnings("UnusedDeclaration") private UnbreakableBadgeProgress() { super(BadgeType.UNBREAKABLE); person = null; - count = -1; + builds = null; } - public static UnbreakableBadgeProgress initial(UUID person) { - return new UnbreakableBadgeProgress(person, 0); + public static UnbreakableBadgeProgress initial(Uuid person) { + return new UnbreakableBadgeProgress(person, Collections.emptyList()); } public P2> onBuild(BuildDto build) { @@ -35,33 +39,36 @@ public class UnbreakableBadgeProgress extends BadgeProgress { return p(initial(person), Option.none()); } - int count = this.count + 1; + List builds = new ArrayList<>(this.builds); + builds.add(build.uuid); - if (count == UnbreakableBadge.LEVEL_3_COUNT) { - return p(initial(person), some(new UnbreakableBadge(3))); + if (progression() == UnbreakableBadge.LEVEL_3_COUNT) { + // You have to start from scratch now. + builds = singletonList(build.uuid); + return p(new UnbreakableBadgeProgress(person, builds), some(new UnbreakableBadge(person, 3, builds))); } - if (count == UnbreakableBadge.LEVEL_2_COUNT) { - return p(new UnbreakableBadgeProgress(person, count), some(new UnbreakableBadge(2))); + if (progression() == UnbreakableBadge.LEVEL_2_COUNT) { + return p(new UnbreakableBadgeProgress(person, builds), some(new UnbreakableBadge(person, 2, builds))); } - if (count == UnbreakableBadge.LEVEL_1_COUNT) { - return p(new UnbreakableBadgeProgress(person, count), some(new UnbreakableBadge(1))); + if (progression() == UnbreakableBadge.LEVEL_1_COUNT) { + return p(new UnbreakableBadgeProgress(person, builds), some(new UnbreakableBadge(person, 1, builds))); } - return p(new UnbreakableBadgeProgress(person, count), Option.none()); + return p(new UnbreakableBadgeProgress(person, builds), Option.none()); } public int progression() { - return count; + return builds.size(); } public int goal() { - if (count > UnbreakableBadge.LEVEL_2_COUNT) { + if (progression() > UnbreakableBadge.LEVEL_2_COUNT) { return UnbreakableBadge.LEVEL_3_COUNT; } - if (count > UnbreakableBadge.LEVEL_1_COUNT) { + if (progression() > UnbreakableBadge.LEVEL_1_COUNT) { return UnbreakableBadge.LEVEL_2_COUNT; } @@ -69,11 +76,11 @@ public class UnbreakableBadgeProgress extends BadgeProgress { } public int progressingAgainstLevel() { - if (count > UnbreakableBadge.LEVEL_2_COUNT) { + if (progression() > UnbreakableBadge.LEVEL_2_COUNT) { return 3; } - if (count > UnbreakableBadge.LEVEL_1_COUNT) { + if (progression() > UnbreakableBadge.LEVEL_1_COUNT) { return 2; } @@ -81,6 +88,6 @@ public class UnbreakableBadgeProgress extends BadgeProgress { } public String toString() { - return "UnbreakableBadgeProgress{person=" + person + ", count=" + count + '}'; + return "UnbreakableBadgeProgress{person=" + person + ", #builds=" + builds.size() + '}'; } } diff --git a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakablePoller.java b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakablePoller.java index ab0abd8..76dee02 100755 --- a/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakablePoller.java +++ b/src/main/java/io/trygvis/esper/testing/core/badge/UnbreakablePoller.java @@ -11,25 +11,28 @@ import org.slf4j.*; import java.sql.*; import java.util.List; -import java.util.*; -import static fj.data.Option.some; import static io.trygvis.esper.testing.Config.*; -import static io.trygvis.esper.testing.core.db.PersonBadgeDto.BadgeType.*; +import static io.trygvis.esper.testing.core.db.PersonalBadgeDto.BadgeType.*; public class UnbreakablePoller implements TablePoller.NewRowCallback { private final Logger logger = LoggerFactory.getLogger(getClass()); - private final BadgeService badgeService = new BadgeService(); + private final BadgeService badgeService; + + public UnbreakablePoller(BadgeService badgeService) { + this.badgeService = badgeService; + } public static void main(String[] args) throws Exception { String pollerName = "unbreakable"; String tableName = "build"; String columnNames = BuildDao.BUILD; SqlF f = BuildDao.build; - TablePoller.NewRowCallback callback = new UnbreakablePoller(); Config config = loadFromDisk("unbreakable-poller"); + BadgeService badgeService = new BadgeService(config.createObjectMapper()); + TablePoller.NewRowCallback callback = new UnbreakablePoller(badgeService); BoneCPDataSource dataSource = config.createBoneCp(); @@ -41,11 +44,11 @@ public class UnbreakablePoller implements TablePoller.NewRowCallback { public void process(Connection c, BuildDto build) throws SQLException { Daos daos = new Daos(c); - List persons = daos.buildDao.selectBuildParticipantByBuild(build.uuid); + List persons = daos.buildDao.selectBuildParticipantByBuild(build.uuid); logger.info("Processing build={}, success={}, #persons={}", build.uuid, build.success, persons.size()); - for (UUID person : persons) { - logger.info("person={}", person); + for (Uuid person : persons) { + logger.info("person={}", person.toUuidString()); SqlOption o = daos.personDao.selectBadgeProgress(person, UNBREAKABLE); @@ -53,37 +56,31 @@ public class UnbreakablePoller implements TablePoller.NewRowCallback { UnbreakableBadgeProgress badge = UnbreakableBadgeProgress.initial(person); logger.info("New badge progress"); String state = badgeService.serialize(badge); - daos.personDao.insertBadgeProgress(new Uuid(person), UNBREAKABLE, state); + daos.personDao.insertBadgeProgress(person, UNBREAKABLE, state); continue; } - UnbreakableBadgeProgress badge = badgeService.unbreakable(o.get()); + UnbreakableBadgeProgress badge = badgeService.badgeProgress(o.get(), UnbreakableBadgeProgress.class); - logger.info("Existing badge progress: count={}", badge.count); + logger.info("Existing badge progress: progression={}", badge.progression()); P2> p = badge.onBuild(build); badge = p._1(); - logger.info("New badge progress: count={}", badge.count); + logger.info("New badge progress: progression={}", badge.progression()); if (p._2().isSome()) { UnbreakableBadge b = p._2().some(); - logger.info("New unbreakable badge: person={}, level={}", person, b.level); - - SqlOption option = daos.personDao.selectBadge(person, UNBREAKABLE, b.level); + logger.info("New unbreakable badge: person={}, level={}", person.toUuidString(), b.level); - if (option.isNone()) { - daos.personDao.insertBadge(person, UNBREAKABLE, b.level, 1); - } else { - daos.personDao.incrementBadgeCount(person, UNBREAKABLE, b.level); - } + daos.personDao.insertBadge(build.createdDate, person, UNBREAKABLE, b.level, badgeService.serialize(b)); } String state = badgeService.serialize(badge); - daos.personDao.updateBadgeProgress(new Uuid(person), UNBREAKABLE, state); + daos.personDao.updateBadgeProgress(person, UNBREAKABLE, state); } } } diff --git a/src/main/java/io/trygvis/esper/testing/core/db/BuildDao.java b/src/main/java/io/trygvis/esper/testing/core/db/BuildDao.java index cd103d6..32afe42 100755 --- a/src/main/java/io/trygvis/esper/testing/core/db/BuildDao.java +++ b/src/main/java/io/trygvis/esper/testing/core/db/BuildDao.java @@ -57,7 +57,7 @@ public class BuildDao { } } - public List selectBuildParticipantByBuild(UUID build) throws SQLException { + public List selectBuildParticipantByBuild(UUID build) throws SQLException { try (PreparedStatement s = c.prepareStatement("SELECT person FROM build_participant WHERE build=?")) { int i = 1; s.setString(i, build.toString()); @@ -86,7 +86,7 @@ public class BuildDao { int i = 1; s.setString(i++, ref.type); s.setString(i, ref.uuid.toString()); - return fromRs(s.executeQuery()).map(getUuid); + return fromRs(s.executeQuery()).map(getUUID); } } diff --git a/src/main/java/io/trygvis/esper/testing/core/db/PersonBadgeDto.java b/src/main/java/io/trygvis/esper/testing/core/db/PersonBadgeDto.java deleted file mode 100644 index 0f34347..0000000 --- a/src/main/java/io/trygvis/esper/testing/core/db/PersonBadgeDto.java +++ /dev/null @@ -1,25 +0,0 @@ -package io.trygvis.esper.testing.core.db; - -import io.trygvis.esper.testing.*; -import org.joda.time.*; - -import java.util.*; - -public class PersonBadgeDto extends AbstractEntity { - public enum BadgeType { - UNBREAKABLE - } - - public final Uuid person; - public final BadgeType type; - public final int level; - public final int count; - - public PersonBadgeDto(UUID uuid, DateTime createdDate, Uuid person, BadgeType type, int level, int count) { - super(uuid, createdDate); - this.person = person; - this.type = type; - this.level = level; - this.count = count; - } -} diff --git a/src/main/java/io/trygvis/esper/testing/core/db/PersonDao.java b/src/main/java/io/trygvis/esper/testing/core/db/PersonDao.java index 0f80219..7a682dc 100755 --- a/src/main/java/io/trygvis/esper/testing/core/db/PersonDao.java +++ b/src/main/java/io/trygvis/esper/testing/core/db/PersonDao.java @@ -2,7 +2,7 @@ package io.trygvis.esper.testing.core.db; import fj.data.*; import io.trygvis.esper.testing.*; -import io.trygvis.esper.testing.core.db.PersonBadgeDto.*; +import io.trygvis.esper.testing.core.db.PersonalBadgeDto.*; import io.trygvis.esper.testing.util.sql.*; import org.joda.time.*; @@ -30,18 +30,18 @@ public class PersonDao { } }; - public static final String PERSON_BADGE = "uuid, created_date, person, name, level, count"; + public static final String PERSON_BADGE = "uuid, created_date, person, name, level, state"; - public static final SqlF personBadge = new SqlF() { - public PersonBadgeDto apply(ResultSet rs) throws SQLException { + public static final SqlF personBadge = new SqlF() { + public PersonalBadgeDto apply(ResultSet rs) throws SQLException { int i = 1; - return new PersonBadgeDto( + return new PersonalBadgeDto( UUID.fromString(rs.getString(i++)), new DateTime(rs.getTimestamp(i++).getTime()), Uuid.fromString(rs.getString(i++)), BadgeType.valueOf(rs.getString(i++)), rs.getInt(i++), - rs.getInt(i)); + rs.getString(i)); } }; @@ -146,41 +146,31 @@ public class PersonDao { // Badge // ----------------------------------------------------------------------- - public UUID insertBadge(UUID person, BadgeType type, int level, int count) throws SQLException { + public UUID insertBadge(DateTime createdDate, Uuid person, BadgeType type, int level, String state) throws SQLException { try (PreparedStatement s = c.prepareStatement("INSERT INTO person_badge(" + PERSON_BADGE + ") VALUES(?, ?, ?, ?, ?, ?)")) { UUID uuid = UUID.randomUUID(); int i = 1; s.setString(i++, uuid.toString()); - s.setTimestamp(i++, new Timestamp(currentTimeMillis())); - s.setString(i++, person.toString()); + s.setTimestamp(i++, new Timestamp(createdDate.getMillis())); + s.setString(i++, person.toUuidString()); s.setString(i++, type.toString()); s.setInt(i++, level); - s.setInt(i, count); + s.setString(i, state); s.executeUpdate(); return uuid; } } - public void incrementBadgeCount(UUID person, BadgeType type, int level) throws SQLException { - try (PreparedStatement s = c.prepareStatement("UPDATE person_badge SET count=count+1 WHERE person=? AND name=? AND level=?")) { - int i = 1; - s.setString(i++, person.toString()); - s.setString(i++, type.toString()); - s.setInt(i, level); - s.executeUpdate(); - } - } - - public List selectBadges(Uuid person) throws SQLException { - try (PreparedStatement s = c.prepareStatement("SELECT " + PERSON_BADGE + " FROM person_badge WHERE person=? ORDER BY name, level DESC")) { + public List selectBadges(Uuid person) throws SQLException { + try (PreparedStatement s = c.prepareStatement("SELECT " + PERSON_BADGE + " FROM person_badge WHERE person=? ORDER BY created_date DESC")) { int i = 1; s.setString(i, person.toUuidString()); return toList(s, personBadge); } } - public SqlOption selectBadge(UUID person, BadgeType type, int level) throws SQLException { - try (PreparedStatement s = c.prepareStatement("SELECT " + PERSON_BADGE + " FROM person_badge WHERE person=? AND name=? AND level=?")) { + public SqlOption selectBadge(UUID person, BadgeType type, int level) throws SQLException { + try (PreparedStatement s = c.prepareStatement("SELECT " + PERSON_BADGE + " FROM person_badge WHERE person=? AND name=? AND level=? LIMIT 1")) { int i = 1; s.setString(i++, person.toString()); s.setString(i++, type.toString()); @@ -189,7 +179,7 @@ public class PersonDao { } } - public List selectBadges(Option person, Option type, Option level, PageRequest page) throws SQLException { + public List selectBadges(Option person, Option type, Option level, PageRequest page) throws SQLException { String sql = "SELECT " + PERSON_BADGE + " FROM person_badge WHERE 1=1"; if (person.isSome()) { @@ -227,10 +217,10 @@ public class PersonDao { // Badge Progress // ----------------------------------------------------------------------- - public SqlOption selectBadgeProgress(UUID person, BadgeType type) throws SQLException { + public SqlOption selectBadgeProgress(Uuid person, BadgeType type) throws SQLException { try (PreparedStatement s = c.prepareStatement("SELECT " + PERSON_BADGE_PROGRESS + " FROM person_badge_progress WHERE person=? AND badge=?")) { int i = 1; - s.setString(i++, person.toString()); + s.setString(i++, person.toUuidString()); s.setString(i, type.toString()); return fromRs(s.executeQuery()).map(personBadgeProgress); } diff --git a/src/main/java/io/trygvis/esper/testing/core/db/PersonalBadgeDto.java b/src/main/java/io/trygvis/esper/testing/core/db/PersonalBadgeDto.java new file mode 100644 index 0000000..cc2a739 --- /dev/null +++ b/src/main/java/io/trygvis/esper/testing/core/db/PersonalBadgeDto.java @@ -0,0 +1,25 @@ +package io.trygvis.esper.testing.core.db; + +import io.trygvis.esper.testing.*; +import org.joda.time.*; + +import java.util.*; + +public class PersonalBadgeDto extends AbstractEntity { + public enum BadgeType { + UNBREAKABLE + } + + public final Uuid person; + public final BadgeType type; + public final int level; + public final String state; + + public PersonalBadgeDto(UUID uuid, DateTime createdDate, Uuid person, BadgeType type, int level, String state) { + super(uuid, createdDate); + this.person = person; + this.type = type; + this.level = level; + this.state = state; + } +} -- cgit v1.2.3