o Showing recent badges on the front page.

1 files changed, 98 insertions, 52 deletions

diff --git a/src/main/java/io/trygvis/esper/testing/web/resource/CoreResource.java b/src/main/java/io/trygvis/esper/testing/web/resource/CoreResource.java
index aa7a5ee..f68d6ec 100755
--- a/src/main/java/io/trygvis/esper/testing/web/resource/CoreResource.java
+++ b/src/main/java/io/trygvis/esper/testing/web/resource/CoreResource.java
@@ -15,6 +15,7 @@ import java.sql.*;
 import java.util.*;
 import java.util.List;
 
+import static fj.data.Option.fromNull;
 import static io.trygvis.esper.testing.util.sql.PageRequest.*;
 
 @Path("/resource/core")
@@ -34,14 +35,14 @@ public class CoreResource extends AbstractResource {
 
     @GET
     @Path("/person")
-    public List<PersonJson> getPersons(@Context final HttpServletRequest req) throws Exception {
+    public List<PersonDetailJson> getPersons(@Context final HttpServletRequest req) throws Exception {
         final PageRequest pageRequest = pageReq(req);
 
-        return da.inTransaction(new DatabaseAccess.DaosCallback<List<PersonJson>>() {
-            public List<PersonJson> run(Daos daos) throws SQLException {
-                List<PersonJson> list = new ArrayList<>();
+        return da.inTransaction(new CoreDaosCallback<List<PersonDetailJson>>() {
+            protected List<PersonDetailJson> run() throws SQLException {
+                List<PersonDetailJson> list = new ArrayList<>();
                 for (PersonDto person : daos.personDao.selectPersons(pageRequest)) {
-                    list.add(getPersonJson(daos, person));
+                    list.add(super.getPersonDetailJson.apply(person));
                 }
                 return list;
             }
@@ -50,44 +51,14 @@ public class CoreResource extends AbstractResource {
 
     @GET
     @Path("/person/{uuid}")
-    public PersonJson getPerson(@PathParam("uuid") final Uuid uuid) throws Exception {
-        System.out.println("uuid.toStringBase64() = " + uuid.toStringBase64());
-        System.out.println("uuid.toUuidString() = " + uuid.toUuidString());
-        return get(new DatabaseAccess.DaosCallback<Option<PersonJson>>() {
-            public Option<PersonJson> run(Daos daos) throws SQLException {
-                SqlOption<PersonDto> o = daos.personDao.selectPerson(uuid);
-                if (o.isNone()) {
-                    return Option.none();
-                }
-
-                return Option.some(getPersonJson(daos, o.get()));
+    public PersonDetailJson getPerson(@PathParam("uuid") final Uuid uuid) throws Exception {
+        return sql(new CoreDaosCallback<SqlOption<PersonDetailJson>>() {
+            protected SqlOption<PersonDetailJson> run() throws SQLException {
+                return daos.personDao.selectPerson(uuid).map(super.getPersonDetailJson);
             }
         });
     }
 
-    private PersonJson getPersonJson(Daos daos, PersonDto person) throws SQLException {
-        List<BadgeJson> badges = new ArrayList<>();
-
-        for (PersonBadgeDto badge : daos.personDao.selectBadges(person.uuid)) {
-            badges.add(new BadgeJson(badge.type.name(), badge.level, badge.count, 100, 100));
-        }
-
-        List<BadgeJson> badgesInProgress = new ArrayList<>();
-
-        for (PersonBadgeProgressDto badgeProgressDto : daos.personDao.selectBadgeProgresses(person.uuid)) {
-            UnbreakableBadgeProgress progress = badgeService.unbreakable(badgeProgressDto);
-            badgesInProgress.add(new BadgeJson(progress.type.name(), progress.progressingAgainstLevel(), 0,
-                    progress.progression(), progress.goal()));
-        }
-
-        return new PersonJson(
-                person.uuid,
-                person.name,
-                badges,
-                badgesInProgress
-        );
-    }
-
     // -----------------------------------------------------------------------
     // Build
     // -----------------------------------------------------------------------
@@ -116,12 +87,12 @@ public class CoreResource extends AbstractResource {
 
     @GET
     @Path("/build-participant/{uuid}")
-    public List<PersonJson> getBuildParticipants(@MagicParam final UUID build) throws Exception {
-        return da.inTransaction(new DatabaseAccess.DaosCallback<List<PersonJson>>() {
-            public List<PersonJson> run(Daos daos) throws SQLException {
-                List<PersonJson> list = new ArrayList<>();
+    public List<PersonDetailJson> getBuildParticipants(@MagicParam final UUID build) throws Exception {
+        return da.inTransaction(new CoreDaosCallback<List<PersonDetailJson>>() {
+            protected List<PersonDetailJson> run() throws SQLException {
+                List<PersonDetailJson> list = new ArrayList<>();
                 for (PersonDto person : daos.buildDao.selectPersonsFromBuildParticipant(build)) {
-                    list.add(getPersonJson(daos, person));
+                    list.add(super.getPersonDetailJson.apply(person));
                 }
                 return list;
             }
@@ -147,15 +118,90 @@ public class CoreResource extends AbstractResource {
         return new BuildJson(build.uuid, build.timestamp, build.success);
     }
 
-    public static class BuildJson {
-        public final UUID uuid;
-        public final DateTime timestamp;
-        public final boolean success;
+    // -----------------------------------------------------------------------
+    // Badge
+    // -----------------------------------------------------------------------
+
+    @GET
+    @Path("/badge")
+    public List<BadgeDetailJson> getBadges(@MagicParam final PageRequest page, @MagicParam(query = "person") final Uuid person) throws Exception {
+        return da.inTransaction(new CoreDaosCallback<List<BadgeDetailJson>>() {
+            protected List<BadgeDetailJson> run() throws SQLException {
+                List<PersonBadgeDto> badgeDtos = daos.personDao.selectBadges(fromNull(person), Option.<PersonBadgeDto.BadgeType>none(), Option.<Integer>none(), page);
+
+                List<BadgeDetailJson> list = new ArrayList<>();
+                for (PersonBadgeDto badge : badgeDtos) {
+                    list.add(getBadgeDetailJson.apply(badge));
+                }
+                return list;
+            }
+        });
+    }
+
+    abstract class CoreDaosCallback<T> implements DatabaseAccess.DaosCallback<T> {
+        protected Daos daos;
 
-        public BuildJson(UUID uuid, DateTime timestamp, boolean success) {
-            this.uuid = uuid;
-            this.timestamp = timestamp;
-            this.success = success;
+        protected abstract T run() throws SQLException;
+
+        public T run(Daos daos) throws SQLException {
+            this.daos = daos;
+            return run();
         }
+
+        protected final SqlF<PersonDto, PersonJson> getPersonJson = new SqlF<PersonDto, PersonJson>() {
+            public PersonJson apply(PersonDto person) throws SQLException {
+                return new PersonJson(person.uuid, person.name);
+            }
+        };
+
+        protected final SqlF<PersonDto, PersonDetailJson> getPersonDetailJson = new SqlF<PersonDto, PersonDetailJson>() {
+            public PersonDetailJson apply(PersonDto person) throws SQLException {
+                List<BadgeJson> badges = new ArrayList<>();
+
+                for (PersonBadgeDto badge : daos.personDao.selectBadges(person.uuid)) {
+                    badges.add(getBadge(badge));
+                }
+
+                List<BadgeJson> badgesInProgress = new ArrayList<>();
+
+                for (PersonBadgeProgressDto badgeProgressDto : daos.personDao.selectBadgeProgresses(person.uuid)) {
+                    UnbreakableBadgeProgress progress = badgeService.unbreakable(badgeProgressDto);
+                    badgesInProgress.add(getBadge(progress));
+                }
+
+                return new PersonDetailJson(
+                        getPersonJson.apply(person),
+                        badges,
+                        badgesInProgress
+                );
+            }
+        };
+
+        private BadgeJson getBadge(PersonBadgeDto badge) {
+            return new BadgeJson(badge.type.name(), badge.level, badge.count, 100, 100);
+        }
+
+        private BadgeJson getBadge(BadgeProgress progress) {
+            return new BadgeJson(progress.type.name(), progress.progressingAgainstLevel(), 0, progress.progression(), progress.goal());
+        }
+
+        protected final SqlF<PersonBadgeDto, BadgeDetailJson> getBadgeDetailJson = new SqlF<PersonBadgeDto, BadgeDetailJson>() {
+            public BadgeDetailJson apply(PersonBadgeDto badgeDto) throws SQLException {
+                return new BadgeDetailJson(getBadge(badgeDto),
+                        daos.personDao.selectPerson(badgeDto.person).map(getPersonJson).get());
+            }
+        };
+    }
+}
+
+class BuildJson {
+    public final UUID uuid;
+    public final DateTime timestamp;
+    public final boolean success;
+
+    public BuildJson(UUID uuid, DateTime timestamp, boolean success) {
+        this.uuid = uuid;
+        this.timestamp = timestamp;
+        this.success = success;
     }
 }