Merge pull request #10 from PuyallupFoursquare/maven

Switching from Ivy+Ant to Maven.

24 files changed, 3272 insertions, 0 deletions

diff --git a/src/main/java/com/p4square/grow/backend/BackendVerifier.java b/src/main/java/com/p4square/grow/backend/BackendVerifier.java
new file mode 100644
index 0000000..83160a9
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/BackendVerifier.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend;
+
+import java.io.IOException;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+
+import org.apache.commons.codec.binary.Hex;
+
+import org.restlet.security.SecretVerifier;
+
+import com.p4square.grow.model.UserRecord;
+import com.p4square.grow.provider.Provider;
+
+/**
+ * Verify the given credentials against the users with backend access.
+ */
+public class BackendVerifier extends SecretVerifier {
+
+    private final Provider<String, UserRecord> mUserProvider;
+
+    public BackendVerifier(Provider<String, UserRecord> userProvider) {
+        mUserProvider = userProvider;
+    }
+
+    @Override
+    public int verify(String identifier, char[] secret) {
+        if (identifier == null) {
+            throw new IllegalArgumentException("Null identifier");
+        }
+
+        if (secret == null) {
+            throw new IllegalArgumentException("Null secret");
+        }
+
+        // Does the user exist?
+        UserRecord user;
+        try {
+            user = mUserProvider.get(identifier);
+            if (user == null) {
+                return RESULT_UNKNOWN;
+            }
+
+        } catch (IOException e) {
+            return RESULT_UNKNOWN;
+        }
+
+        // Does the user have a backend password?
+        String storedHash = user.getBackendPasswordHash();
+        if (storedHash == null) {
+            // This user doesn't have access
+            return RESULT_INVALID;
+        }
+
+        // Validate the password.
+        try {
+            String hashedInput = hashPassword(secret);
+            if (hashedInput.equals(storedHash)) {
+                return RESULT_VALID;
+            }
+
+        } catch (NoSuchAlgorithmException e) {
+            return RESULT_UNSUPPORTED;
+        }
+
+        // If all else fails, fail.
+        return RESULT_INVALID;
+    }
+
+    /**
+     * Hash the given secret.
+     */
+    public static String hashPassword(char[] secret) throws NoSuchAlgorithmException {
+        MessageDigest md = MessageDigest.getInstance("SHA-1");
+
+        // Convert the char[] to byte[]
+        // FIXME This approach is incorrectly truncating multibyte
+        // characters.
+        byte[] b = new byte[secret.length];
+        for (int i = 0; i < secret.length; i++) {
+            b[i] = (byte) secret[i];
+        }
+
+        md.update(b);
+
+        byte[] hash = md.digest();
+        return new String(Hex.encodeHex(hash));
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/CassandraGrowData.java b/src/main/java/com/p4square/grow/backend/CassandraGrowData.java
new file mode 100644
index 0000000..22a7716
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/CassandraGrowData.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend;
+
+import java.io.IOException;
+
+import com.p4square.grow.config.Config;
+
+import com.p4square.grow.backend.db.CassandraDatabase;
+import com.p4square.grow.backend.db.CassandraKey;
+import com.p4square.grow.backend.db.CassandraProviderImpl;
+import com.p4square.grow.backend.db.CassandraCollectionProvider;
+import com.p4square.grow.backend.db.CassandraTrainingRecordProvider;
+
+import com.p4square.grow.model.Message;
+import com.p4square.grow.model.MessageThread;
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.model.Question;
+import com.p4square.grow.model.TrainingRecord;
+import com.p4square.grow.model.UserRecord;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.DelegateCollectionProvider;
+import com.p4square.grow.provider.DelegateProvider;
+import com.p4square.grow.provider.Provider;
+
+/**
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+class CassandraGrowData implements GrowData {
+    private static final String DEFAULT_COLUMN = "value";
+
+    private final Config mConfig;
+    private final CassandraDatabase mDatabase;
+
+    private final Provider<String, UserRecord> mUserRecordProvider;
+
+    private final Provider<String, Question> mQuestionProvider;
+    private final CassandraTrainingRecordProvider mTrainingRecordProvider;
+    private final CollectionProvider<String, String, String> mVideoProvider;
+
+    private final CollectionProvider<String, String, MessageThread> mFeedThreadProvider;
+    private final CollectionProvider<String, String, Message> mFeedMessageProvider;
+
+    private final Provider<String, String> mStringProvider;
+
+    private final CollectionProvider<String, String, String> mAnswerProvider;
+
+    public CassandraGrowData(final Config config) {
+        mConfig = config;
+        mDatabase = new CassandraDatabase();
+
+        mUserRecordProvider = new DelegateProvider<String, CassandraKey, UserRecord>(
+                new CassandraProviderImpl<UserRecord>(mDatabase, UserRecord.class)) {
+            @Override
+            public CassandraKey makeKey(String userid) {
+                return new CassandraKey("accounts", userid, DEFAULT_COLUMN);
+            }
+        };
+
+        mQuestionProvider = new DelegateProvider<String, CassandraKey, Question>(
+                new CassandraProviderImpl<Question>(mDatabase, Question.class)) {
+            @Override
+            public CassandraKey makeKey(String questionId) {
+                return new CassandraKey("strings", "/questions/" + questionId, DEFAULT_COLUMN);
+            }
+        };
+
+        mFeedThreadProvider = new CassandraCollectionProvider<MessageThread>(mDatabase,
+                "feedthreads", MessageThread.class);
+        mFeedMessageProvider = new CassandraCollectionProvider<Message>(mDatabase,
+                "feedmessages", Message.class);
+
+        mTrainingRecordProvider = new CassandraTrainingRecordProvider(mDatabase);
+
+        mVideoProvider = new DelegateCollectionProvider<String, String, String, String, String>(
+                new CassandraCollectionProvider<String>(mDatabase, "strings", String.class)) {
+            @Override
+            public String makeCollectionKey(String key) {
+                return "/training/" + key;
+            }
+
+            @Override
+            public String makeKey(String key) {
+                return key;
+            }
+
+            @Override
+            public String unmakeKey(String key) {
+                return key;
+            }
+        };
+
+        mStringProvider = new DelegateProvider<String, CassandraKey, String>(
+                new CassandraProviderImpl<String>(mDatabase, String.class)) {
+            @Override
+            public CassandraKey makeKey(String id) {
+                return new CassandraKey("strings", id, DEFAULT_COLUMN);
+            }
+        };
+
+        mAnswerProvider = new CassandraCollectionProvider<String>(
+                mDatabase, "assessments", String.class);
+    }
+
+    @Override
+    public void start() throws Exception {
+        mDatabase.setClusterName(mConfig.getString("clusterName", "Dev Cluster"));
+        mDatabase.setKeyspaceName(mConfig.getString("keyspace", "GROW"));
+        mDatabase.init();
+    }
+
+    @Override
+    public void stop() throws Exception {
+        mDatabase.close();
+    }
+
+    /**
+     * @return the current database.
+     */
+    public CassandraDatabase getDatabase() {
+        return mDatabase;
+    }
+
+    @Override
+    public Provider<String, UserRecord> getUserRecordProvider() {
+        return mUserRecordProvider;
+    }
+
+    @Override
+    public Provider<String, Question> getQuestionProvider() {
+        return mQuestionProvider;
+    }
+
+    @Override
+    public Provider<String, TrainingRecord> getTrainingRecordProvider() {
+        return mTrainingRecordProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getVideoProvider() {
+        return mVideoProvider;
+    }
+
+    @Override
+    public Playlist getDefaultPlaylist() throws IOException {
+        return mTrainingRecordProvider.getDefaultPlaylist();
+    }
+
+    @Override
+    public CollectionProvider<String, String, MessageThread> getThreadProvider() {
+        return mFeedThreadProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, Message> getMessageProvider() {
+        return mFeedMessageProvider;
+    }
+
+    @Override
+    public Provider<String, String> getStringProvider() {
+        return mStringProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getAnswerProvider() {
+        return mAnswerProvider;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/DynamoGrowData.java b/src/main/java/com/p4square/grow/backend/DynamoGrowData.java
new file mode 100644
index 0000000..3b38eac
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/DynamoGrowData.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend;
+
+import java.io.IOException;
+
+import com.amazonaws.auth.AWSCredentials;
+
+import com.p4square.grow.backend.dynamo.DynamoDatabase;
+import com.p4square.grow.backend.dynamo.DynamoKey;
+import com.p4square.grow.backend.dynamo.DynamoProviderImpl;
+import com.p4square.grow.backend.dynamo.DynamoCollectionProviderImpl;
+
+import com.p4square.grow.config.Config;
+
+import com.p4square.grow.model.Message;
+import com.p4square.grow.model.MessageThread;
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.model.Question;
+import com.p4square.grow.model.TrainingRecord;
+import com.p4square.grow.model.UserRecord;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.DelegateCollectionProvider;
+import com.p4square.grow.provider.DelegateProvider;
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * 
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+class DynamoGrowData implements GrowData {
+    private static final String DEFAULT_COLUMN = "value";
+    private static final String DEFAULT_PLAYLIST_KEY = "/training/defaultplaylist";
+
+    private final Config mConfig;
+    private final DynamoDatabase mDatabase;
+
+    private final Provider<String, UserRecord> mUserRecordProvider;
+
+    private final Provider<String, Question> mQuestionProvider;
+    private final Provider<String, TrainingRecord> mTrainingRecordProvider;
+    private final CollectionProvider<String, String, String> mVideoProvider;
+
+    private final CollectionProvider<String, String, MessageThread> mFeedThreadProvider;
+    private final CollectionProvider<String, String, Message> mFeedMessageProvider;
+
+    private final Provider<String, String> mStringProvider;
+
+    private final CollectionProvider<String, String, String> mAnswerProvider;
+
+    public DynamoGrowData(final Config config) {
+        mConfig = config;
+
+        mDatabase = new DynamoDatabase(config);
+
+        mUserRecordProvider = new DelegateProvider<String, DynamoKey, UserRecord>(
+                new DynamoProviderImpl<UserRecord>(mDatabase, UserRecord.class)) {
+            @Override
+            public DynamoKey makeKey(String userid) {
+                return DynamoKey.newAttributeKey("accounts", userid, DEFAULT_COLUMN);
+            }
+        };
+
+        mQuestionProvider = new DelegateProvider<String, DynamoKey, Question>(
+                new DynamoProviderImpl<Question>(mDatabase, Question.class)) {
+            @Override
+            public DynamoKey makeKey(String questionId) {
+                return DynamoKey.newAttributeKey("strings",
+                                                 "/questions/" + questionId,
+                                                 DEFAULT_COLUMN);
+            }
+        };
+
+        mFeedThreadProvider = new DynamoCollectionProviderImpl<MessageThread>(
+                mDatabase, "feedthreads", MessageThread.class);
+        mFeedMessageProvider = new DynamoCollectionProviderImpl<Message>(
+                mDatabase, "feedmessages", Message.class);
+
+        mTrainingRecordProvider = new DelegateProvider<String, DynamoKey, TrainingRecord>(
+                new DynamoProviderImpl<TrainingRecord>(mDatabase, TrainingRecord.class)) {
+            @Override
+            public DynamoKey makeKey(String userId) {
+                return DynamoKey.newAttributeKey("training",
+                                                 userId,
+                                                 DEFAULT_COLUMN);
+            }
+        };
+
+        mVideoProvider = new DelegateCollectionProvider<String, String, String, String, String>(
+                new DynamoCollectionProviderImpl<String>(mDatabase, "strings", String.class)) {
+            @Override
+            public String makeCollectionKey(String key) {
+                return "/training/" + key;
+            }
+
+            @Override
+            public String makeKey(String key) {
+                return key;
+            }
+
+            @Override
+            public String unmakeKey(String key) {
+                return key;
+            }
+        };
+
+        mStringProvider = new DelegateProvider<String, DynamoKey, String>(
+                new DynamoProviderImpl<String>(mDatabase, String.class)) {
+            @Override
+            public DynamoKey makeKey(String id) {
+                return DynamoKey.newAttributeKey("strings", id, DEFAULT_COLUMN);
+            }
+        };
+
+        mAnswerProvider = new DynamoCollectionProviderImpl<String>(
+                mDatabase, "assessments", String.class);
+    }
+
+    @Override
+    public void start() throws Exception {
+    }
+
+    @Override
+    public void stop() throws Exception {
+    }
+
+    @Override
+    public Provider<String, UserRecord> getUserRecordProvider() {
+        return mUserRecordProvider;
+    }
+
+    @Override
+    public Provider<String, Question> getQuestionProvider() {
+        return mQuestionProvider;
+    }
+
+    @Override
+    public Provider<String, TrainingRecord> getTrainingRecordProvider() {
+        return mTrainingRecordProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getVideoProvider() {
+        return mVideoProvider;
+    }
+
+    @Override
+    public Playlist getDefaultPlaylist() throws IOException {
+        String blob = mStringProvider.get(DEFAULT_PLAYLIST_KEY);
+        if (blob == null) {
+            return null;
+        }
+
+        return JsonEncodedProvider.MAPPER.readValue(blob, Playlist.class);
+    }
+
+    @Override
+    public CollectionProvider<String, String, MessageThread> getThreadProvider() {
+        return mFeedThreadProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, Message> getMessageProvider() {
+        return mFeedMessageProvider;
+    }
+
+    @Override
+    public Provider<String, String> getStringProvider() {
+        return mStringProvider;
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getAnswerProvider() {
+        return mAnswerProvider;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/GrowBackend.java b/src/main/java/com/p4square/grow/backend/GrowBackend.java
new file mode 100644
index 0000000..4091138
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/GrowBackend.java
@@ -0,0 +1,211 @@
+/*
+ * Copyright 2012 Jesse Morgan
+ */
+
+package com.p4square.grow.backend;
+
+import java.io.IOException;
+
+import com.codahale.metrics.MetricRegistry;
+
+import org.apache.log4j.Logger;
+
+import org.restlet.Application;
+import org.restlet.Component;
+import org.restlet.Restlet;
+import org.restlet.data.Protocol;
+import org.restlet.data.Reference;
+import org.restlet.resource.Directory;
+import org.restlet.routing.Router;
+
+import com.p4square.grow.config.Config;
+
+import com.p4square.grow.model.Message;
+import com.p4square.grow.model.MessageThread;
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.model.Question;
+import com.p4square.grow.model.TrainingRecord;
+import com.p4square.grow.model.UserRecord;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.ProvidesQuestions;
+import com.p4square.grow.provider.ProvidesTrainingRecords;
+import com.p4square.grow.provider.ProvidesUserRecords;
+
+import com.p4square.grow.backend.resources.AccountResource;
+import com.p4square.grow.backend.resources.BannerResource;
+import com.p4square.grow.backend.resources.SurveyResource;
+import com.p4square.grow.backend.resources.SurveyResultsResource;
+import com.p4square.grow.backend.resources.TrainingRecordResource;
+import com.p4square.grow.backend.resources.TrainingResource;
+
+import com.p4square.grow.backend.feed.FeedDataProvider;
+import com.p4square.grow.backend.feed.ThreadResource;
+import com.p4square.grow.backend.feed.TopicResource;
+
+import com.p4square.restlet.metrics.MetricRouter;
+
+/**
+ * Main class for the backend application.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class GrowBackend extends Application implements GrowData {
+
+    private final static Logger LOG = Logger.getLogger(GrowBackend.class);
+
+    private final MetricRegistry mMetricRegistry;
+
+    private final Config mConfig;
+    private final GrowData mGrowData;
+
+    public GrowBackend() {
+        this(new Config(), new MetricRegistry());
+    }
+
+    public GrowBackend(Config config, MetricRegistry metricRegistry) {
+        mConfig = config;
+
+        mMetricRegistry = metricRegistry;
+
+        mGrowData = new DynamoGrowData(config);
+    }
+
+    public MetricRegistry getMetrics() {
+        return mMetricRegistry;
+    }
+
+    @Override
+    public Restlet createInboundRoot() {
+        Router router = new MetricRouter(getContext(), mMetricRegistry);
+
+        // Account API
+        router.attach("/accounts/{userId}", AccountResource.class);
+
+        // Survey API
+        router.attach("/assessment/question/{questionId}", SurveyResource.class);
+
+        router.attach("/accounts/{userId}/assessment", SurveyResultsResource.class);
+        router.attach("/accounts/{userId}/assessment/answers/{questionId}",
+                SurveyResultsResource.class);
+
+        // Training API
+        router.attach("/training/{level}", TrainingResource.class);
+        router.attach("/training/{level}/videos/{videoId}", TrainingResource.class);
+
+        router.attach("/accounts/{userId}/training", TrainingRecordResource.class);
+        router.attach("/accounts/{userId}/training/videos/{videoId}",
+                TrainingRecordResource.class);
+
+        // Misc.
+        router.attach("/banner", BannerResource.class);
+
+        // Feed
+        router.attach("/feed/{topic}", TopicResource.class);
+        router.attach("/feed/{topic}/{thread}", ThreadResource.class);
+        //router.attach("/feed/{topic/{thread}/{message}", MessageResource.class);
+
+        router.attachDefault(new Directory(getContext(), new Reference(getClass().getResource("apiinfo.html"))));
+
+        return router;
+    }
+
+    /**
+     * Open the database.
+     */
+    @Override
+    public void start() throws Exception {
+        super.start();
+
+        mGrowData.start();
+    }
+
+    /**
+     * Close the database.
+     */
+    @Override
+    public void stop() throws Exception {
+        LOG.info("Shutting down...");
+        mGrowData.stop();
+
+        super.stop();
+    }
+
+    @Override
+    public Provider<String, UserRecord> getUserRecordProvider() {
+        return mGrowData.getUserRecordProvider();
+    }
+
+    @Override
+    public Provider<String, Question> getQuestionProvider() {
+        return mGrowData.getQuestionProvider();
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getVideoProvider() {
+        return mGrowData.getVideoProvider();
+    }
+
+    @Override
+    public Provider<String, TrainingRecord> getTrainingRecordProvider() {
+        return mGrowData.getTrainingRecordProvider();
+    }
+
+    /**
+     * @return the Default Playlist.
+     */
+    public Playlist getDefaultPlaylist() throws IOException {
+        return mGrowData.getDefaultPlaylist();
+    }
+
+    @Override
+    public CollectionProvider<String, String, MessageThread> getThreadProvider() {
+        return mGrowData.getThreadProvider();
+    }
+
+    @Override
+    public CollectionProvider<String, String, Message> getMessageProvider() {
+        return mGrowData.getMessageProvider();
+    }
+
+    @Override
+    public Provider<String, String> getStringProvider() {
+        return mGrowData.getStringProvider();
+    }
+
+    @Override
+    public CollectionProvider<String, String, String> getAnswerProvider() {
+        return mGrowData.getAnswerProvider();
+    }
+
+    /**
+     * Stand-alone main for testing.
+     */
+    public static void main(String[] args) throws Exception {
+        // Start the HTTP Server
+        final Component component = new Component();
+        component.getServers().add(Protocol.HTTP, 9095);
+        component.getClients().add(Protocol.HTTP);
+        component.getDefaultHost().attach(new GrowBackend());
+
+        // Setup shutdown hook
+        Runtime.getRuntime().addShutdownHook(new Thread() {
+            public void run() {
+                try {
+                    component.stop();
+                } catch (Exception e) {
+                    LOG.error("Exception during cleanup", e);
+                }
+            }
+        });
+
+        LOG.info("Starting server...");
+
+        try {
+            component.start();
+        } catch (Exception e) {
+            LOG.fatal("Could not start: " + e.getMessage(), e);
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/GrowData.java b/src/main/java/com/p4square/grow/backend/GrowData.java
new file mode 100644
index 0000000..293bb88
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/GrowData.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend;
+
+import com.p4square.grow.backend.feed.FeedDataProvider;
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.provider.ProvidesAssessments;
+import com.p4square.grow.provider.ProvidesQuestions;
+import com.p4square.grow.provider.ProvidesStrings;
+import com.p4square.grow.provider.ProvidesTrainingRecords;
+import com.p4square.grow.provider.ProvidesUserRecords;
+import com.p4square.grow.provider.ProvidesVideos;
+
+/**
+ * Aggregate of the data provider interfaces.
+ *
+ * Used by GrowBackend to swap out implementations of the providers.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+interface GrowData extends ProvidesQuestions, ProvidesTrainingRecords, ProvidesVideos,
+                                   FeedDataProvider, ProvidesUserRecords, ProvidesStrings,
+                                   ProvidesAssessments {
+
+    /**
+     * Start the data provider.
+     */
+    void start() throws Exception;
+
+    /**
+     * Stop the data provider.
+     */
+    void stop() throws Exception;
+}
diff --git a/src/main/java/com/p4square/grow/backend/db/CassandraCollectionProvider.java b/src/main/java/com/p4square/grow/backend/db/CassandraCollectionProvider.java
new file mode 100644
index 0000000..bfcb48d
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/db/CassandraCollectionProvider.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.db;
+
+import java.io.IOException;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.netflix.astyanax.model.Column;
+import com.netflix.astyanax.model.ColumnList;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * CollectionProvider implementation backed by a Cassandra ColumnFamily.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class CassandraCollectionProvider<V> implements CollectionProvider<String, String, V> {
+    private final CassandraDatabase mDb;
+    private final String mCF;
+    private final Class<V> mClazz;
+
+    public CassandraCollectionProvider(CassandraDatabase db, String columnFamily, Class<V> clazz) {
+        mDb = db;
+        mCF = columnFamily;
+        mClazz = clazz;
+    }
+
+    @Override
+    public V get(String collection, String key) throws IOException {
+        String blob = mDb.getKey(mCF, collection, key);
+        return decode(blob);
+    }
+
+    @Override
+    public Map<String, V> query(String collection) throws IOException {
+        return query(collection, -1);
+    }
+
+    @Override
+    public Map<String, V> query(String collection, int limit) throws IOException {
+        Map<String, V> result = new LinkedHashMap<>();
+
+        ColumnList<String> row = mDb.getRow(mCF, collection);
+        if (!row.isEmpty()) {
+            int count = 0;
+            for (Column<String> c : row) {
+                if (limit >= 0 && ++count > limit) {
+                    break; // Limit reached.
+                }
+
+                String key = c.getName();
+                String blob = c.getStringValue();
+                V obj = decode(blob);
+
+                result.put(key, obj);
+            }
+        }
+
+        return Collections.unmodifiableMap(result);
+    }
+
+    @Override
+    public void put(String collection, String key, V obj) throws IOException {
+        String blob = encode(obj);
+        mDb.putKey(mCF, collection, key, blob);
+    }
+
+    /**
+     * Encode the object as JSON.
+     *
+     * @param obj The object to encode.
+     * @return The JSON encoding of obj.
+     * @throws IOException if the object cannot be encoded.
+     */
+    protected String encode(V obj) throws IOException {
+        if (mClazz == String.class) {
+            return (String) obj;
+        } else {
+            return JsonEncodedProvider.MAPPER.writeValueAsString(obj);
+        }
+    }
+
+    /**
+     * Decode the JSON string as an object.
+     *
+     * @param blob The JSON data to decode.
+     * @return The decoded object or null if blob is null.
+     * @throws IOException If an object cannot be decoded.
+     */
+    protected V decode(String blob) throws IOException {
+        if (blob == null) {
+            return null;
+        }
+
+        if (mClazz == String.class) {
+            return (V) blob;
+        }
+
+        V obj = JsonEncodedProvider.MAPPER.readValue(blob, mClazz);
+        return obj;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/db/CassandraDatabase.java b/src/main/java/com/p4square/grow/backend/db/CassandraDatabase.java
new file mode 100644
index 0000000..b8cb6df
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/db/CassandraDatabase.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.db;
+
+import com.netflix.astyanax.AstyanaxContext;
+import com.netflix.astyanax.connectionpool.exceptions.ConnectionException;
+import com.netflix.astyanax.connectionpool.impl.ConnectionPoolConfigurationImpl;
+import com.netflix.astyanax.connectionpool.impl.CountingConnectionPoolMonitor;
+import com.netflix.astyanax.connectionpool.NodeDiscoveryType;
+import com.netflix.astyanax.connectionpool.OperationResult;
+import com.netflix.astyanax.impl.AstyanaxConfigurationImpl;
+import com.netflix.astyanax.Keyspace;
+import com.netflix.astyanax.ColumnMutation;
+import com.netflix.astyanax.model.Column;
+import com.netflix.astyanax.model.ColumnFamily;
+import com.netflix.astyanax.model.ColumnList;
+import com.netflix.astyanax.ColumnListMutation;
+import com.netflix.astyanax.MutationBatch;
+import com.netflix.astyanax.serializers.StringSerializer;
+import com.netflix.astyanax.thrift.ThriftFamilyFactory;
+
+import org.apache.log4j.Logger;
+
+/**
+ * Cassandra Database Abstraction for the Backend.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class CassandraDatabase {
+    private static Logger cLog = Logger.getLogger(CassandraDatabase.class);
+
+    // Configuration fields.
+    private String mClusterName;
+    private String mKeyspaceName;
+    private String mSeedEndpoint   = "127.0.0.1:9160";
+    private int    mPort           = 9160;
+
+    private AstyanaxContext<Keyspace>  mContext;
+    private Keyspace mKeyspace;
+
+    /**
+     * Connect to Cassandra.
+     *
+     * Cluster and Keyspace must be set before calling init().
+     */
+    public void init() {
+        mContext = new AstyanaxContext.Builder()
+            .forCluster(mClusterName)
+            .forKeyspace(mKeyspaceName)
+            .withAstyanaxConfiguration(new AstyanaxConfigurationImpl()
+                .setDiscoveryType(NodeDiscoveryType.RING_DESCRIBE)
+            )
+            .withConnectionPoolConfiguration(new ConnectionPoolConfigurationImpl("MyConnectionPool")
+                .setPort(mPort)
+                .setMaxConnsPerHost(1)
+                .setSeeds(mSeedEndpoint)
+            )
+            .withConnectionPoolMonitor(new CountingConnectionPoolMonitor())
+            .buildKeyspace(ThriftFamilyFactory.getInstance());
+
+        mContext.start();
+        mKeyspace = mContext.getClient();
+    }
+
+    /**
+     * Close the database connection.
+     */
+    public void close() {
+        mContext.shutdown();
+    }
+
+    /**
+     * Set the cluster name to connect to.
+     */
+    public void setClusterName(final String cluster) {
+        mClusterName = cluster;
+    }
+
+    /**
+     * Set the name of the keyspace to open.
+     */
+    public void setKeyspaceName(final String keyspace) {
+        mKeyspaceName = keyspace;
+    }
+
+    /**
+     * Change the seed endpoint.
+     * The default is 127.0.0.1:9160.
+     */
+    public void setSeedEndpoint(final String endpoint) {
+        mSeedEndpoint = endpoint;
+    }
+
+    /**
+     * Change the port to connect to.
+     * The default is 9160.
+     */
+    public void setPort(final int port) {
+        mPort = port;
+    }
+
+    /**
+     * @return The entire row associated with this key.
+     */
+    public ColumnList<String> getRow(final String cfName, final String key) {
+        try {
+            ColumnFamily<String, String> cf = new ColumnFamily(cfName,
+                StringSerializer.get(),
+                StringSerializer.get());
+
+            OperationResult<ColumnList<String>> result =
+                mKeyspace.prepareQuery(cf)
+                    .getKey(key)
+                    .execute();
+
+            return result.getResult();
+
+        } catch (ConnectionException e) {
+            cLog.error("getRow failed due to Connection Exception", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * @return The value associated with the given key.
+     */
+    public String getKey(final String cfName, final String key) {
+        return getKey(cfName, key, "value");
+    }
+
+    /**
+     * @return The value associated with the given key, column pair.
+     */
+    public String getKey(final String cfName, final String key, final String column) {
+        final ColumnList<String> row = getRow(cfName, key);
+
+        if (row != null) {
+            final Column rowColumn = row.getColumnByName(column);
+            if (rowColumn != null) {
+                return rowColumn.getStringValue();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Assign value to key.
+     */
+    public void putKey(final String cfName, final String key, final String value) {
+        putKey(cfName, key, "value", value);
+    }
+
+    /**
+     * Assign value to the key, column pair.
+     */
+    public void putKey(final String cfName, final String key,
+            final String column, final String value) {
+
+        ColumnFamily<String, String> cf = new ColumnFamily(cfName,
+            StringSerializer.get(),
+            StringSerializer.get());
+
+        MutationBatch m = mKeyspace.prepareMutationBatch();
+        m.withRow(cf, key).putColumn(column, value);
+
+        try {
+            m.execute();
+        } catch (ConnectionException e) {
+            cLog.error("putKey failed due to Connection Exception", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Remove a key, column pair.
+     */
+    public void deleteKey(final String cfName, final String key, final String column) {
+        ColumnFamily<String, String> cf = new ColumnFamily(cfName,
+            StringSerializer.get(),
+            StringSerializer.get());
+
+        try {
+            ColumnMutation m = mKeyspace.prepareColumnMutation(cf, key, column);
+            m.deleteColumn().execute();
+        } catch (ConnectionException e) {
+            cLog.error("deleteKey failed due to Connection Exception", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Remove a row
+     */
+    public void deleteRow(final String cfName, final String key) {
+        ColumnFamily<String, String> cf = new ColumnFamily(cfName,
+            StringSerializer.get(),
+            StringSerializer.get());
+
+        try {
+            MutationBatch batch = mKeyspace.prepareMutationBatch();
+            ColumnListMutation<String> cfm = batch.withRow(cf, key).delete();
+            batch.execute();
+
+        } catch (ConnectionException e) {
+            cLog.error("deleteRow failed due to Connection Exception", e);
+            throw new RuntimeException(e);
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/db/CassandraKey.java b/src/main/java/com/p4square/grow/backend/db/CassandraKey.java
new file mode 100644
index 0000000..853fe96
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/db/CassandraKey.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.db;
+
+/**
+ * CassandraKey represents a Cassandra key / column pair.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class CassandraKey {
+    private final String mColumnFamily;
+    private final String mId;
+    private final String mColumn;
+
+    public CassandraKey(String columnFamily, String id, String column) {
+        mColumnFamily = columnFamily;
+        mId = id;
+        mColumn = column;
+    }
+
+    public String getColumnFamily() {
+        return mColumnFamily;
+    }
+
+    public String getId() {
+        return mId;
+    }
+
+    public String getColumn() {
+        return mColumn;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/db/CassandraProviderImpl.java b/src/main/java/com/p4square/grow/backend/db/CassandraProviderImpl.java
new file mode 100644
index 0000000..da5a9f2
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/db/CassandraProviderImpl.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.db;
+
+import java.io.IOException;
+
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * Provider implementation backed by a Cassandra ColumnFamily.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class CassandraProviderImpl<V> extends JsonEncodedProvider<V> implements Provider<CassandraKey, V> {
+    private final CassandraDatabase mDb;
+
+    public CassandraProviderImpl(CassandraDatabase db, Class<V> clazz) {
+        super(clazz);
+
+        mDb = db;
+    }
+
+    @Override
+    public V get(CassandraKey key) throws IOException {
+        String blob = mDb.getKey(key.getColumnFamily(), key.getId(), key.getColumn());
+        return decode(blob);
+    }
+
+    @Override
+    public void put(CassandraKey key, V obj) throws IOException {
+        String blob = encode(obj);
+        mDb.putKey(key.getColumnFamily(), key.getId(), key.getColumn(), blob);
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/db/CassandraTrainingRecordProvider.java b/src/main/java/com/p4square/grow/backend/db/CassandraTrainingRecordProvider.java
new file mode 100644
index 0000000..4face52
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/db/CassandraTrainingRecordProvider.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.db;
+
+import java.io.IOException;
+
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.model.TrainingRecord;
+
+import com.p4square.grow.provider.JsonEncodedProvider;
+import com.p4square.grow.provider.Provider;
+
+/**
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class CassandraTrainingRecordProvider implements Provider<String, TrainingRecord> {
+    private static final CassandraKey DEFAULT_PLAYLIST_KEY = new CassandraKey("strings", "defaultPlaylist", "value");
+
+    private static final String COLUMN_FAMILY = "training";
+    private static final String PLAYLIST_KEY = "playlist";
+    private static final String LAST_VIDEO_KEY = "lastVideo";
+
+    private final CassandraDatabase mDb;
+    private final Provider<CassandraKey, Playlist> mPlaylistProvider;
+
+    public CassandraTrainingRecordProvider(CassandraDatabase db) {
+        mDb = db;
+        mPlaylistProvider = new CassandraProviderImpl<>(db, Playlist.class);
+    }
+
+    @Override
+    public TrainingRecord get(String userid) throws IOException {
+        Playlist playlist = mPlaylistProvider.get(new CassandraKey(COLUMN_FAMILY, userid, PLAYLIST_KEY));
+
+        if (playlist == null) {
+            // We consider no playlist to mean no record whatsoever.
+            return null;
+        }
+
+        TrainingRecord r = new TrainingRecord();
+        r.setPlaylist(playlist);
+        r.setLastVideo(mDb.getKey(COLUMN_FAMILY, userid, LAST_VIDEO_KEY));
+
+        return r;
+    }
+
+    @Override
+    public void put(String userid, TrainingRecord record) throws IOException {
+        String lastVideo = record.getLastVideo();
+        Playlist playlist = record.getPlaylist();
+
+        mDb.putKey(COLUMN_FAMILY, userid, LAST_VIDEO_KEY, lastVideo);
+        mPlaylistProvider.put(new CassandraKey(COLUMN_FAMILY, userid, PLAYLIST_KEY), playlist);
+    }
+
+    /**
+     * @return the default playlist stored in the database.
+     */
+    public Playlist getDefaultPlaylist() throws IOException {
+        Playlist playlist = mPlaylistProvider.get(DEFAULT_PLAYLIST_KEY);
+
+        if (playlist == null) {
+            playlist = new Playlist();
+        }
+
+        return playlist;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/dynamo/DbTool.java b/src/main/java/com/p4square/grow/backend/dynamo/DbTool.java
new file mode 100644
index 0000000..374fa83
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/dynamo/DbTool.java
@@ -0,0 +1,481 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.dynamo;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+
+import com.p4square.grow.backend.dynamo.DynamoDatabase;
+import com.p4square.grow.backend.dynamo.DynamoKey;
+import com.p4square.grow.config.Config;
+import com.p4square.grow.model.UserRecord;
+import com.p4square.grow.provider.Provider;
+
+/**
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class DbTool {
+    private static final FilenameFilter JSON_FILTER = new JsonFilter();
+
+    private static Config mConfig;
+    private static DynamoDatabase mDatabase;
+
+    public static void usage() {
+        System.out.println("java com.p4square.grow.backend.dynamo.DbTool <command>...\n");
+        System.out.println("Commands:");
+        System.out.println("\t--domain <domain>                           Set config domain");
+        System.out.println("\t--dev                                       Set config domain to dev");
+        System.out.println("\t--config <file>                             Merge in config file");
+        System.out.println("\t--list                                      List all tables");
+        System.out.println("\t--create <table> <reads> <writes>           Create a table");
+        System.out.println("\t--update <table> <reads> <writes>           Update table throughput");
+        System.out.println("\t--drop   <table>                            Delete a table");
+        System.out.println("\t--get    <table> <key> <attribute>          Get a value");
+        System.out.println("\t--put    <table> <key> <attribute> <value>  Put a value");
+        System.out.println("\t--delete <table> <key> <attribute>          Delete a value");
+        System.out.println("\t--scan   <table>                            List all rows");
+        System.out.println("\t--scanf  <table> <attribute>                List all rows");
+        System.out.println();
+        System.out.println("Bootstrap Commands:");
+        System.out.println("\t--bootstrap <data>          Create all tables and import all data");
+        System.out.println("\t--loadStrings <data>        Load all videos and questions");
+        System.out.println("\t--destroy                   Drop all tables");
+        System.out.println("\t--addadmin <user> <pass>    Add a backend account");
+        System.out.println("\t--import   <table> <file>   Backfill a table");
+    }
+
+    public static void main(String... args) {
+        if (args.length == 0) {
+            usage();
+            System.exit(1);
+        }
+
+        mConfig = new Config();
+
+        try {
+            mConfig.updateConfig(DbTool.class.getResourceAsStream("/grow.properties"));
+
+            int offset = 0;
+            while (offset < args.length) {
+                if ("--domain".equals(args[offset])) {
+                    mConfig.setDomain(args[offset + 1]);
+                    mDatabase = null;
+                    offset += 2;
+
+                } else if ("--dev".equals(args[offset])) {
+                    mConfig.setDomain("dev");
+                    mDatabase = null;
+                    offset += 1;
+
+                } else if ("--config".equals(args[offset])) {
+                    mConfig.updateConfig(args[offset + 1]);
+                    mDatabase = null;
+                    offset += 2;
+
+                } else if ("--list".equals(args[offset])) {
+                    //offset = list(args, ++offset);
+
+                } else if ("--create".equals(args[offset])) {
+                    offset = create(args, ++offset);
+
+                } else if ("--update".equals(args[offset])) {
+                    offset = update(args, ++offset);
+
+                } else if ("--drop".equals(args[offset])) {
+                    offset = drop(args, ++offset);
+
+                } else if ("--get".equals(args[offset])) {
+                    offset = get(args, ++offset);
+
+                } else if ("--put".equals(args[offset])) {
+                    offset = put(args, ++offset);
+
+                } else if ("--delete".equals(args[offset])) {
+                    offset = delete(args, ++offset);
+
+                } else if ("--scan".equals(args[offset])) {
+                    offset = scan(args, ++offset);
+
+                } else if ("--scanf".equals(args[offset])) {
+                    offset = scanf(args, ++offset);
+
+                /* Bootstrap Commands */
+                } else if ("--bootstrap".equals(args[offset])) {
+                    if ("dev".equals(mConfig.getDomain())) {
+                        offset = bootstrapDevTables(args, ++offset);
+                    } else {
+                        offset = bootstrapTables(args, ++offset);
+                    }
+                    offset = loadStrings(args, offset);
+
+                } else if ("--loadStrings".equals(args[offset])) {
+                    offset = loadStrings(args, ++offset);
+
+                } else if ("--destroy".equals(args[offset])) {
+                    offset = destroy(args, ++offset);
+
+                } else if ("--addadmin".equals(args[offset])) {
+                    offset = addAdmin(args, ++offset);
+
+                } else if ("--import".equals(args[offset])) {
+                    offset = importTable(args, ++offset);
+
+                } else {
+                    throw new IllegalArgumentException("Unknown command " + args[offset]);
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            System.exit(2);
+        }
+    }
+
+    private static DynamoDatabase getDatabase() {
+        if (mDatabase == null) {
+            mDatabase = new DynamoDatabase(mConfig);
+        }
+
+        return mDatabase;
+    }
+
+    private static int create(String[] args, int offset) {
+        String name = args[offset++];
+        long reads  = Long.parseLong(args[offset++]);
+        long writes = Long.parseLong(args[offset++]);
+
+        DynamoDatabase db = getDatabase();
+
+        db.createTable(name, reads, writes);
+
+        return offset;
+    }
+
+    private static int update(String[] args, int offset) {
+        String name = args[offset++];
+        long reads  = Long.parseLong(args[offset++]);
+        long writes = Long.parseLong(args[offset++]);
+
+        DynamoDatabase db = getDatabase();
+
+        db.updateTable(name, reads, writes);
+
+        return offset;
+    }
+
+    private static int drop(String[] args, int offset) {
+        String name = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        db.deleteTable(name);
+
+        return offset;
+    }
+
+    private static int get(String[] args, int offset) {
+        String table     = args[offset++];
+        String key       = args[offset++];
+        String attribute = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        String value = db.getAttribute(DynamoKey.newAttributeKey(table, key, attribute));
+
+        if (value == null) {
+            value = "<null>";
+        }
+
+        System.out.printf("%s %s:%s\n%s\n\n", table, key, attribute, value);
+
+        return offset;
+    }
+
+    private static int put(String[] args, int offset) {
+        String table     = args[offset++];
+        String key       = args[offset++];
+        String attribute = args[offset++];
+        String value     = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        db.putAttribute(DynamoKey.newAttributeKey(table, key, attribute), value);
+
+        return offset;
+    }
+
+    private static int delete(String[] args, int offset) {
+        String table     = args[offset++];
+        String key       = args[offset++];
+        String attribute = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        db.deleteAttribute(DynamoKey.newAttributeKey(table, key, attribute));
+
+        System.out.printf("Deleted %s %s:%s\n\n", table, key, attribute);
+
+        return offset;
+    }
+
+    private static int scan(String[] args, int offset) {
+        String table     = args[offset++];
+
+        DynamoKey key = DynamoKey.newKey(table, null);
+
+        doScan(key);
+
+        return offset;
+    }
+
+    private static int scanf(String[] args, int offset) {
+        String table     = args[offset++];
+        String attribute = args[offset++];
+
+        DynamoKey key = DynamoKey.newAttributeKey(table, null, attribute);
+
+        doScan(key);
+
+        return offset;
+    }
+
+    private static void doScan(DynamoKey key) {
+        DynamoDatabase db = getDatabase();
+
+        String attributeFilter = key.getAttribute();
+
+        while (key != null) {
+            Map<DynamoKey, Map<String, String>> result = db.getAll(key);
+
+            key = null; // If there are no results, exit
+
+            for (Map.Entry<DynamoKey, Map<String, String>> entry : result.entrySet()) {
+                key = entry.getKey(); // Save the last key
+
+                for (Map.Entry<String, String> attribute : entry.getValue().entrySet()) {
+                    if (attributeFilter == null || attributeFilter.equals(attribute.getKey())) {
+                        String keyString = key.getHashKey();
+                        if (key.getRangeKey() != null) {
+                            keyString += "(" + key.getRangeKey() + ")";
+                        }
+                        System.out.printf("%s %s:%s\n%s\n\n",
+                                key.getTable(), keyString, attribute.getKey(),
+                                attribute.getValue());
+                    }
+                }
+            }
+        }
+    }
+
+
+    private static int bootstrapTables(String[] args, int offset) {
+        DynamoDatabase db = getDatabase();
+
+        db.createTable("strings",      5,  1);
+        db.createTable("accounts",     5,  1);
+        db.createTable("assessments",  5,  5);
+        db.createTable("training",     5,  5);
+        db.createTable("feedthreads",  5,  1);
+        db.createTable("feedmessages", 5,  1);
+
+        return offset;
+    }
+
+    private static int bootstrapDevTables(String[] args, int offset) {
+        DynamoDatabase db = getDatabase();
+
+        db.createTable("strings",      1,  1);
+        db.createTable("accounts",     1,  1);
+        db.createTable("assessments",  1,  1);
+        db.createTable("training",     1,  1);
+        db.createTable("feedthreads",  1,  1);
+        db.createTable("feedmessages", 1,  1);
+
+        return offset;
+    }
+
+    private static int loadStrings(String[] args, int offset) throws IOException {
+        String data = args[offset++];
+        File baseDir = new File(data);
+
+        DynamoDatabase db = getDatabase();
+
+        insertQuestions(baseDir);
+        insertVideos(baseDir);
+        insertDefaultPlaylist(baseDir);
+
+        return offset;
+    }
+
+    private static int destroy(String[] args, int offset) {
+        DynamoDatabase db = getDatabase();
+
+        final String[] tables = { "strings",
+                                  "accounts",
+                                  "assessments",
+                                  "training",
+                                  "feedthreads",
+                                  "feedmessages"
+                                };
+
+        for (String table : tables) {
+            try {
+                db.deleteTable(table);
+            } catch (Exception e) {
+                System.err.println("Deleting " + table + ": " + e.getMessage());
+            }
+        }
+
+        return offset;
+    }
+
+    private static int addAdmin(String[] args, int offset) throws IOException {
+        String user = args[offset++];
+        String pass = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        UserRecord record = new UserRecord();
+        record.setId(user);
+        record.setBackendPassword(pass);
+
+        Provider<DynamoKey, UserRecord> provider = new DynamoProviderImpl(db, UserRecord.class);
+        provider.put(DynamoKey.newAttributeKey("accounts", user, "value"), record);
+
+        return offset;
+    }
+
+    private static int importTable(String[] args, int offset) throws IOException {
+        String table = args[offset++];
+        String filename = args[offset++];
+
+        DynamoDatabase db = getDatabase();
+
+        List<String> lines = Files.readAllLines(new File(filename).toPath(),
+                StandardCharsets.UTF_8);
+
+        int count = 0;
+
+        String key = null;
+        Map<String, String> attributes = new HashMap<>();
+        for (String line : lines) {
+            if (line.length() == 0) {
+                if (attributes.size() > 0) {
+                    db.putKey(DynamoKey.newKey(table, key), attributes);
+                    count++;
+
+                    if (count % 50 == 0) {
+                        System.out.printf("Imported %d records into %s...\n", count, table);
+                    }
+                }
+                key = null;
+                attributes = new HashMap<>();
+                continue;
+            }
+
+            if (key == null) {
+                key = line;
+                continue;
+            }
+
+            int space = line.indexOf(' ');
+            String attribute = line.substring(0, space);
+            String value = line.substring(space + 1);
+
+            attributes.put(attribute, value);
+        }
+
+        // Finish up the remaining attributes.
+        if (key != null && attributes.size() > 0) {
+            db.putKey(DynamoKey.newKey(table, key), attributes);
+            count++;
+        }
+
+        System.out.printf("Imported %d records into %s.\n", count, table);
+
+        return offset;
+    }
+
+    private static void insertQuestions(File baseDir) throws IOException {
+        DynamoDatabase db = getDatabase();
+        File questions = new File(baseDir, "questions");
+
+        File[] files = questions.listFiles(JSON_FILTER);
+        Arrays.sort(files);
+
+        for (File file : files) {
+            String filename = file.getName();
+            String questionId = filename.substring(0, filename.lastIndexOf('.'));
+
+            byte[] encoded = Files.readAllBytes(file.toPath());
+            String value = new String(encoded, StandardCharsets.UTF_8);
+            db.putAttribute(DynamoKey.newAttributeKey("strings",
+                        "/questions/" + questionId, "value"), value);
+            System.out.println("Inserted /questions/" + questionId);
+        }
+
+        String filename = files[0].getName();
+        String first    = filename.substring(0, filename.lastIndexOf('.'));
+        int    count    = files.length;
+        String summary  = "{\"first\": \"" + first + "\", \"count\": " + count + "}";
+        db.putAttribute(DynamoKey.newAttributeKey("strings", "/questions", "value"), summary);
+        System.out.println("Inserted /questions");
+    }
+
+    private static void insertVideos(File baseDir) throws IOException {
+        DynamoDatabase db = getDatabase();
+        File videos = new File(baseDir, "videos");
+
+        for (File topic : videos.listFiles()) {
+            if (!topic.isDirectory()) {
+                continue;
+            }
+
+            String topicName = topic.getName();
+
+            Map<String, String> attributes = new HashMap<>();
+            File[] files = topic.listFiles(JSON_FILTER);
+            for (File file : files) {
+                String filename = file.getName();
+                String videoId = filename.substring(0, filename.lastIndexOf('.'));
+
+                byte[] encoded = Files.readAllBytes(file.toPath());
+                String value = new String(encoded, StandardCharsets.UTF_8);
+
+                attributes.put(videoId, value);
+                System.out.println("Found /training/" + topicName + ":" + videoId);
+            }
+
+            db.putKey(DynamoKey.newKey("strings",
+                        "/training/" + topicName), attributes);
+            System.out.println("Inserted /training/" + topicName);
+        }
+    }
+
+    private static void insertDefaultPlaylist(File baseDir) throws IOException {
+        DynamoDatabase db = getDatabase();
+        File file = new File(baseDir, "videos/playlist.json");
+
+        byte[] encoded = Files.readAllBytes(file.toPath());
+        String value = new String(encoded, StandardCharsets.UTF_8);
+        db.putAttribute(DynamoKey.newAttributeKey("strings",
+                    "/training/defaultplaylist", "value"), value);
+        System.out.println("Inserted /training/defaultplaylist");
+    }
+
+    private static class JsonFilter implements FilenameFilter {
+        @Override
+        public boolean accept(File dir, String name) {
+            return name.endsWith(".json");
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/dynamo/DynamoCollectionProviderImpl.java b/src/main/java/com/p4square/grow/backend/dynamo/DynamoCollectionProviderImpl.java
new file mode 100644
index 0000000..b53e9f7
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/dynamo/DynamoCollectionProviderImpl.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.dynamo;
+
+import java.io.IOException;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * 
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class DynamoCollectionProviderImpl<V> implements CollectionProvider<String, String, V> {
+    private final DynamoDatabase mDb;
+    private final String mTable;
+    private final Class<V> mClazz;
+
+    public DynamoCollectionProviderImpl(DynamoDatabase db, String table, Class<V> clazz) {
+        mDb = db;
+        mTable = table;
+        mClazz = clazz;
+    }
+
+    @Override
+    public V get(String collection, String key) throws IOException {
+        String blob = mDb.getAttribute(DynamoKey.newAttributeKey(mTable, collection, key));
+        return decode(blob);
+    }
+
+    @Override
+    public Map<String, V> query(String collection) throws IOException {
+        return query(collection, -1);
+    }
+
+    @Override
+    public Map<String, V> query(String collection, int limit) throws IOException {
+        Map<String, V> result = new LinkedHashMap<>();
+
+        Map<String, String> row = mDb.getKey(DynamoKey.newKey(mTable, collection));
+        if (row.size() > 0) {
+            int count = 0;
+            for (Map.Entry<String, String> c : row.entrySet()) {
+                if (limit >= 0 && ++count > limit) {
+                    break; // Limit reached.
+                }
+
+                String key = c.getKey();
+                String blob = c.getValue();
+                V obj = decode(blob);
+
+                result.put(key, obj);
+            }
+        }
+
+        return Collections.unmodifiableMap(result);
+    }
+
+    @Override
+    public void put(String collection, String key, V obj) throws IOException {
+        if (obj == null) {
+            mDb.deleteAttribute(DynamoKey.newAttributeKey(mTable, collection, key));
+        } else {
+            String blob = encode(obj);
+            mDb.putAttribute(DynamoKey.newAttributeKey(mTable, collection, key), blob);
+        }
+    }
+
+    /**
+     * Encode the object as JSON.
+     *
+     * @param obj The object to encode.
+     * @return The JSON encoding of obj.
+     * @throws IOException if the object cannot be encoded.
+     */
+    protected String encode(V obj) throws IOException {
+        if (mClazz == String.class) {
+            return (String) obj;
+        } else {
+            return JsonEncodedProvider.MAPPER.writeValueAsString(obj);
+        }
+    }
+
+    /**
+     * Decode the JSON string as an object.
+     *
+     * @param blob The JSON data to decode.
+     * @return The decoded object or null if blob is null.
+     * @throws IOException If an object cannot be decoded.
+     */
+    protected V decode(String blob) throws IOException {
+        if (blob == null) {
+            return null;
+        }
+
+        if (mClazz == String.class) {
+            return (V) blob;
+        }
+
+        V obj = JsonEncodedProvider.MAPPER.readValue(blob, mClazz);
+        return obj;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/dynamo/DynamoDatabase.java b/src/main/java/com/p4square/grow/backend/dynamo/DynamoDatabase.java
new file mode 100644
index 0000000..68a165d
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/dynamo/DynamoDatabase.java
@@ -0,0 +1,307 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.dynamo;
+
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.amazonaws.auth.AWSCredentials;
+import com.amazonaws.auth.DefaultAWSCredentialsProviderChain;
+import com.amazonaws.regions.Region;
+import com.amazonaws.regions.Regions;
+import com.amazonaws.services.dynamodbv2.AmazonDynamoDBClient;
+import com.amazonaws.services.dynamodbv2.model.AttributeAction;
+import com.amazonaws.services.dynamodbv2.model.AttributeDefinition;
+import com.amazonaws.services.dynamodbv2.model.AttributeValue;
+import com.amazonaws.services.dynamodbv2.model.AttributeValueUpdate;
+import com.amazonaws.services.dynamodbv2.model.CreateTableRequest;
+import com.amazonaws.services.dynamodbv2.model.CreateTableResult;
+import com.amazonaws.services.dynamodbv2.model.DeleteItemRequest;
+import com.amazonaws.services.dynamodbv2.model.DeleteItemResult;
+import com.amazonaws.services.dynamodbv2.model.DeleteTableRequest;
+import com.amazonaws.services.dynamodbv2.model.DeleteTableResult;
+import com.amazonaws.services.dynamodbv2.model.GetItemRequest;
+import com.amazonaws.services.dynamodbv2.model.GetItemResult;
+import com.amazonaws.services.dynamodbv2.model.KeySchemaElement;
+import com.amazonaws.services.dynamodbv2.model.KeyType;
+import com.amazonaws.services.dynamodbv2.model.ProvisionedThroughput;
+import com.amazonaws.services.dynamodbv2.model.PutItemRequest;
+import com.amazonaws.services.dynamodbv2.model.PutItemResult;
+import com.amazonaws.services.dynamodbv2.model.ScanRequest;
+import com.amazonaws.services.dynamodbv2.model.ScanResult;
+import com.amazonaws.services.dynamodbv2.model.UpdateItemRequest;
+import com.amazonaws.services.dynamodbv2.model.UpdateItemResult;
+import com.amazonaws.services.dynamodbv2.model.UpdateTableRequest;
+import com.amazonaws.services.dynamodbv2.model.UpdateTableResult;
+
+import com.p4square.grow.config.Config;
+
+/**
+ * A wrapper around the Dynamo API.
+ */
+public class DynamoDatabase {
+    private final AmazonDynamoDBClient mClient;
+    private final String mTablePrefix;
+
+    public DynamoDatabase(final Config config) {
+        AWSCredentials creds;
+
+        String awsAccessKey = config.getString("awsAccessKey");
+        if (awsAccessKey != null) {
+            creds = new AWSCredentials() {
+                @Override
+                public String getAWSAccessKeyId() {
+                    return config.getString("awsAccessKey");
+                }
+                @Override
+                public String getAWSSecretKey() {
+                    return config.getString("awsSecretKey");
+                }
+            };
+        } else {
+            creds = new DefaultAWSCredentialsProviderChain().getCredentials();
+        }
+
+        mClient = new AmazonDynamoDBClient(creds);
+
+        String endpoint = config.getString("dynamoEndpoint");
+        if (endpoint != null) {
+            mClient.setEndpoint(endpoint);
+        }
+
+        String region = config.getString("awsRegion");
+        if (region != null) {
+            mClient.setRegion(Region.getRegion(Regions.fromName(region)));
+        }
+
+        mTablePrefix = config.getString("dynamoTablePrefix", "");
+    }
+
+    public void createTable(String name, long reads, long writes) {
+        ArrayList<AttributeDefinition> attributeDefinitions = new ArrayList<>();
+        attributeDefinitions.add(new AttributeDefinition()
+                .withAttributeName("id")
+                .withAttributeType("S"));
+
+        ArrayList<KeySchemaElement> ks = new ArrayList<>();
+        ks.add(new KeySchemaElement().withAttributeName("id").withKeyType(KeyType.HASH));
+
+        ProvisionedThroughput provisionedThroughput = new ProvisionedThroughput()
+            .withReadCapacityUnits(reads)
+            .withWriteCapacityUnits(writes);
+
+        CreateTableRequest request = new CreateTableRequest()
+            .withTableName(mTablePrefix + name)
+            .withAttributeDefinitions(attributeDefinitions)
+            .withKeySchema(ks)
+            .withProvisionedThroughput(provisionedThroughput);
+
+        CreateTableResult result = mClient.createTable(request);
+    }
+
+    public void updateTable(String name, long reads, long writes) {
+        ProvisionedThroughput provisionedThroughput = new ProvisionedThroughput()
+            .withReadCapacityUnits(reads)
+            .withWriteCapacityUnits(writes);
+
+        UpdateTableRequest request = new UpdateTableRequest()
+            .withTableName(mTablePrefix + name)
+            .withProvisionedThroughput(provisionedThroughput);
+
+        UpdateTableResult result = mClient.updateTable(request);
+    }
+
+    public void deleteTable(String name) {
+        DeleteTableRequest deleteTableRequest = new DeleteTableRequest()
+            .withTableName(mTablePrefix + name);
+
+        DeleteTableResult result = mClient.deleteTable(deleteTableRequest);
+    }
+
+    /**
+     * Get all rows from a table.
+     *
+     * The key parameter must specify a table. If hash/range key is specified,
+     * the scan will begin after that key.
+     *
+     * @param key Previous key to start with.
+     * @return An ordered map of all results.
+     */
+    public Map<DynamoKey, Map<String, String>> getAll(final DynamoKey key) {
+        ScanRequest scanRequest = new ScanRequest().withTableName(mTablePrefix + key.getTable());
+
+        if (key.getHashKey() != null) {
+            scanRequest.setExclusiveStartKey(generateKey(key));
+        }
+
+        ScanResult scanResult = mClient.scan(scanRequest);
+
+        Map<DynamoKey, Map<String, String>> result = new LinkedHashMap<>();
+        for (Map<String, AttributeValue> map : scanResult.getItems()) {
+            String id = null;
+            String range = null;
+            Map<String, String> row = new LinkedHashMap<>();
+            for (Map.Entry<String, AttributeValue> entry : map.entrySet()) {
+                if ("id".equals(entry.getKey())) {
+                    id = entry.getValue().getS();
+                } else if ("range".equals(entry.getKey())) {
+                    range = entry.getValue().getS();
+                } else {
+                    row.put(entry.getKey(), entry.getValue().getS());
+                }
+            }
+            result.put(DynamoKey.newRangeKey(key.getTable(), id, range), row);
+        }
+
+        return result;
+    }
+
+    public Map<String, String> getKey(final DynamoKey key) {
+        GetItemRequest getItemRequest = new GetItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withKey(generateKey(key));
+
+        GetItemResult getItemResult = mClient.getItem(getItemRequest);
+        Map<String, AttributeValue> map = getItemResult.getItem();
+
+        Map<String, String> result = new LinkedHashMap<>();
+        if (map != null) {
+            for (Map.Entry<String, AttributeValue> entry : map.entrySet()) {
+                if (!"id".equals(entry.getKey())) {
+                    result.put(entry.getKey(), entry.getValue().getS());
+                }
+            }
+        }
+
+        return result;
+    }
+
+    public String getAttribute(final DynamoKey key) {
+        checkAttributeKey(key);
+
+        GetItemRequest getItemRequest = new GetItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withKey(generateKey(key))
+            .withAttributesToGet(key.getAttribute());
+
+        GetItemResult result = mClient.getItem(getItemRequest);
+        Map<String, AttributeValue> map = result.getItem();
+
+        if (map == null) {
+            return null;
+        }
+
+        AttributeValue value = map.get(key.getAttribute());
+        if (value != null) {
+            return value.getS();
+
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Set all attributes for the given key.
+     *
+     * @param key The key.
+     * @param values Map of attributes to values.
+     */
+    public void putKey(final DynamoKey key, final Map<String, String> values) {
+        Map<String, AttributeValue> item = new HashMap<>();
+        for (Map.Entry<String, String> entry : values.entrySet()) {
+            item.put(entry.getKey(), new AttributeValue().withS(entry.getValue()));
+        }
+
+        // Set the Key
+        item.putAll(generateKey(key));
+
+        PutItemRequest putItemRequest = new PutItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withItem(item);
+
+        PutItemResult result = mClient.putItem(putItemRequest);
+    }
+
+    /**
+     * Set the particular attributes of the given key.
+     *
+     * @param key The key.
+     * @param value The new value.
+     */
+    public void putAttribute(final DynamoKey key, final String value) {
+        checkAttributeKey(key);
+
+        Map<String, AttributeValueUpdate> updateItem = new HashMap<>();
+        updateItem.put(key.getAttribute(),
+                new AttributeValueUpdate()
+                .withAction(AttributeAction.PUT)
+                .withValue(new AttributeValue().withS(value)));
+
+        UpdateItemRequest updateItemRequest = new UpdateItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withKey(generateKey(key))
+            .withAttributeUpdates(updateItem);
+        // TODO: Check conditions.
+
+        UpdateItemResult result = mClient.updateItem(updateItemRequest);
+    }
+
+    /**
+     * Delete the given key.
+     *
+     * @param key The key.
+     */
+    public void deleteKey(final DynamoKey key) {
+        DeleteItemRequest deleteItemRequest = new DeleteItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withKey(generateKey(key));
+
+        DeleteItemResult result = mClient.deleteItem(deleteItemRequest);
+    }
+
+    /**
+     * Delete an attribute from the given key.
+     *
+     * @param key The key.
+     */
+    public void deleteAttribute(final DynamoKey key) {
+        checkAttributeKey(key);
+
+        Map<String, AttributeValueUpdate> updateItem = new HashMap<>();
+        updateItem.put(key.getAttribute(),
+                new AttributeValueUpdate().withAction(AttributeAction.DELETE));
+
+        UpdateItemRequest updateItemRequest = new UpdateItemRequest()
+            .withTableName(mTablePrefix + key.getTable())
+            .withKey(generateKey(key))
+            .withAttributeUpdates(updateItem);
+
+        UpdateItemResult result = mClient.updateItem(updateItemRequest);
+    }
+
+    /**
+     * Generate a DynamoDB Key Map from the DynamoKey.
+     */
+    private Map<String, AttributeValue> generateKey(final DynamoKey key) {
+        HashMap<String, AttributeValue> keyMap = new HashMap<>();
+        keyMap.put("id", new AttributeValue().withS(key.getHashKey()));
+
+        String range = key.getRangeKey();
+        if (range != null) {
+            keyMap.put("range", new AttributeValue().withS(range));
+        }
+
+        return keyMap;
+    }
+
+    private void checkAttributeKey(DynamoKey key) {
+        if (null == key.getAttribute()) {
+            throw new IllegalArgumentException("Attribute must be non-null");
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/dynamo/DynamoKey.java b/src/main/java/com/p4square/grow/backend/dynamo/DynamoKey.java
new file mode 100644
index 0000000..5cdbacd
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/dynamo/DynamoKey.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2014 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.dynamo;
+
+/**
+ * DynamoKey represents a table, hash key, and range key tupl.
+ */
+public class DynamoKey {
+    private final String mTable;
+    private final String mHashKey;
+    private final String mRangeKey;
+    private final String mAttribute;
+
+    public static DynamoKey newKey(final String table, final String hashKey) {
+        return new DynamoKey(table, hashKey, null, null);
+    }
+
+    public static DynamoKey newRangeKey(final String table, final String hashKey,
+            final String rangeKey) {
+
+        return new DynamoKey(table, hashKey, rangeKey, null);
+    }
+
+    public static DynamoKey newAttributeKey(final String table, final String hashKey,
+            final String attribute) {
+
+        return new DynamoKey(table, hashKey, null, attribute);
+    }
+
+    public DynamoKey(final String table, final String hashKey, final String rangeKey,
+            final String attribute) {
+
+        mTable = table;
+        mHashKey = hashKey;
+        mRangeKey = rangeKey;
+        mAttribute = attribute;
+    }
+
+    public String getTable() {
+        return mTable;
+    }
+
+    public String getHashKey() {
+        return mHashKey;
+    }
+
+    public String getRangeKey() {
+        return mRangeKey;
+    }
+
+    public String getAttribute() {
+        return mAttribute;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/dynamo/DynamoProviderImpl.java b/src/main/java/com/p4square/grow/backend/dynamo/DynamoProviderImpl.java
new file mode 100644
index 0000000..93a535f
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/dynamo/DynamoProviderImpl.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.dynamo;
+
+import java.io.IOException;
+
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * Provider implementation backed by a DynamoDB Table.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class DynamoProviderImpl<V> extends JsonEncodedProvider<V> implements Provider<DynamoKey, V> {
+    private final DynamoDatabase mDb;
+
+    public DynamoProviderImpl(DynamoDatabase db, Class<V> clazz) {
+        super(clazz);
+
+        mDb = db;
+    }
+
+    @Override
+    public V get(DynamoKey key) throws IOException {
+        String blob = mDb.getAttribute(key);
+        return decode(blob);
+    }
+
+    @Override
+    public void put(DynamoKey key, V obj) throws IOException {
+        String blob = encode(obj);
+        mDb.putAttribute(key, blob);
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/feed/FeedDataProvider.java b/src/main/java/com/p4square/grow/backend/feed/FeedDataProvider.java
new file mode 100644
index 0000000..6f090c0
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/feed/FeedDataProvider.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.feed;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+import com.p4square.grow.model.MessageThread;
+import com.p4square.grow.model.Message;
+import com.p4square.grow.provider.CollectionProvider;
+
+/**
+ * Implementing this interface indicates you can provide a data source for the Feed.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public interface FeedDataProvider {
+    public static final Collection<String> TOPICS = Collections.unmodifiableCollection(
+            Arrays.asList(new String[] { "seeker", "believer", "disciple", "teacher", "leader" }));
+
+    /**
+     * @return a CollectionProvider of Threads.
+     */
+    CollectionProvider<String, String, MessageThread> getThreadProvider();
+
+    /**
+     * @return a CollectionProvider of Messages.
+     */
+    CollectionProvider<String, String, Message> getMessageProvider();
+}
diff --git a/src/main/java/com/p4square/grow/backend/feed/ThreadResource.java b/src/main/java/com/p4square/grow/backend/feed/ThreadResource.java
new file mode 100644
index 0000000..e8f46c2
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/feed/ThreadResource.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.feed;
+
+import java.io.IOException;
+
+import java.util.Date;
+import java.util.Map;
+
+import org.restlet.data.Status;
+import org.restlet.resource.ServerResource;
+import org.restlet.representation.Representation;
+
+import org.restlet.ext.jackson.JacksonRepresentation;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.model.Message;
+
+/**
+ * ThreadResource manages the messages that make up a thread.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class ThreadResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(ThreadResource.class);
+
+    private FeedDataProvider mBackend;
+    private String mTopic;
+    private String mThreadId;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        mBackend = (FeedDataProvider) getApplication();
+        mTopic = getAttribute("topic");
+        mThreadId = getAttribute("thread");
+    }
+
+    /**
+     * GET a list of messages in a thread.
+     */
+    @Override
+    protected Representation get() {
+        // If the topic or threadId are missing, return a 404.
+        if (mTopic == null || mTopic.length() == 0 ||
+                mThreadId == null || mThreadId.length() == 0) {
+            setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+            return null;
+        }
+
+        // TODO: Support limit query parameter.
+
+        try {
+            String collectionKey = mTopic + "/" + mThreadId;
+            Map<String, Message> messages = mBackend.getMessageProvider().query(collectionKey);
+            return new JacksonRepresentation(messages.values());
+
+        } catch (IOException e) {
+            LOG.error("Unexpected exception: " + e.getMessage(), e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+
+    /**
+     * POST a new message to the thread.
+     */
+    @Override
+    protected Representation post(Representation entity) {
+        // If the topic and thread are not provided, respond with not allowed.
+        // TODO: Check if the thread exists.
+        if (mTopic == null || !mBackend.TOPICS.contains(mTopic) ||
+                mThreadId == null || mThreadId.length() == 0) {
+            setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+            return null;
+        }
+
+        try {
+            JacksonRepresentation<Message> jsonRep = new JacksonRepresentation<Message>(entity, Message.class);
+            Message message = jsonRep.getObject();
+
+            // Force the thread id and message to be what we expect.
+            message.setThreadId(mThreadId);
+            message.setId(Message.generateId());
+
+            if (message.getCreated() == null) {
+                message.setCreated(new Date());
+            }
+
+            String collectionKey = mTopic + "/" + mThreadId;
+            mBackend.getMessageProvider().put(collectionKey, message.getId(), message);
+
+            setLocationRef(mThreadId + "/" + message.getId());
+            return new JacksonRepresentation(message);
+
+        } catch (IOException e) {
+            LOG.error("Unexpected exception: " + e.getMessage(), e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/feed/TopicResource.java b/src/main/java/com/p4square/grow/backend/feed/TopicResource.java
new file mode 100644
index 0000000..24b6a92
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/feed/TopicResource.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.feed;
+
+import java.io.IOException;
+
+import java.util.Date;
+import java.util.Map;
+
+import org.restlet.data.Status;
+import org.restlet.resource.ServerResource;
+import org.restlet.representation.Representation;
+
+import org.restlet.ext.jackson.JacksonRepresentation;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.model.Message;
+import com.p4square.grow.model.MessageThread;
+
+/**
+ * TopicResource manages the threads contained in a topic.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class TopicResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(TopicResource.class);
+
+    private FeedDataProvider mBackend;
+    private String mTopic;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        mBackend = (FeedDataProvider) getApplication();
+        mTopic = getAttribute("topic");
+    }
+
+    /**
+     * GET a list of threads in the topic.
+     */
+    @Override
+    protected Representation get() {
+        // If no topic is provided, return a list of topics.
+        if (mTopic == null || mTopic.length() == 0) {
+            return new JacksonRepresentation(FeedDataProvider.TOPICS);
+        }
+
+        // Parse limit query parameter.
+        int limit = -1;
+        String limitString = getQueryValue("limit");
+        if (limitString != null) {
+           try {
+               limit = Integer.parseInt(limitString);
+           } catch (NumberFormatException e) {
+               setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
+               return null;
+           }
+        }
+
+        try {
+            Map<String, MessageThread> threads = mBackend.getThreadProvider().query(mTopic, limit);
+            return new JacksonRepresentation(threads.values());
+
+        } catch (IOException e) {
+            LOG.error("Unexpected exception: " + e.getMessage(), e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+
+    /**
+     * POST a new thread to the topic.
+     */
+    @Override
+    protected Representation post(Representation entity) {
+        // If no topic is provided, respond with not allowed.
+        if (mTopic == null || !mBackend.TOPICS.contains(mTopic)) {
+            setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+            return null;
+        }
+
+        try {
+            // Deserialize the incoming message.
+            JacksonRepresentation<MessageThread> jsonRep =
+                new JacksonRepresentation<MessageThread>(entity, MessageThread.class);
+
+            // Get the message from the request.
+            // Throw away the wrapping MessageThread because we'll create our own later.
+            Message message = jsonRep.getObject().getMessage();
+            if (message.getCreated() == null) {
+                message.setCreated(new Date());
+            }
+
+            // Create the new thread.
+            MessageThread newThread = MessageThread.createNew();
+
+            // Force the thread id and message to be what we expect.
+            message.setId(Message.generateId());
+            message.setThreadId(newThread.getId());
+            newThread.setMessage(message);
+
+            mBackend.getThreadProvider().put(mTopic, newThread.getId(), newThread);
+
+            setLocationRef(mTopic + "/" + newThread.getId());
+            return new JacksonRepresentation(newThread);
+
+        } catch (IOException e) {
+            LOG.error("Unexpected exception: " + e.getMessage(), e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/AccountResource.java b/src/main/java/com/p4square/grow/backend/resources/AccountResource.java
new file mode 100644
index 0000000..2ac7061
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/AccountResource.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+
+import org.restlet.data.Status;
+import org.restlet.resource.ServerResource;
+import org.restlet.representation.Representation;
+
+import org.restlet.ext.jackson.JacksonRepresentation;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.model.UserRecord;
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.ProvidesUserRecords;
+import com.p4square.grow.provider.JsonEncodedProvider;
+
+/**
+ * Stores a document about a user.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class AccountResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(AccountResource.class);
+
+    private Provider<String, UserRecord> mUserRecordProvider;
+
+    private String mUserId;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        final ProvidesUserRecords backend = (ProvidesUserRecords) getApplication();
+        mUserRecordProvider = backend.getUserRecordProvider();
+
+        mUserId = getAttribute("userId");
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        try {
+            UserRecord result = mUserRecordProvider.get(mUserId);
+
+            if (result == null) {
+                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+                return null;
+            }
+
+            JacksonRepresentation<UserRecord> rep = new JacksonRepresentation<UserRecord>(result);
+            rep.setObjectMapper(JsonEncodedProvider.MAPPER);
+            return rep;
+
+        } catch (IOException e) {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+
+    /**
+     * Handle PUT requests
+     */
+    @Override
+    protected Representation put(Representation entity) {
+        try {
+            JacksonRepresentation<UserRecord> representation =
+                new JacksonRepresentation<>(entity, UserRecord.class);
+            representation.setObjectMapper(JsonEncodedProvider.MAPPER);
+            UserRecord record = representation.getObject();
+
+            mUserRecordProvider.put(mUserId, record);
+            setStatus(Status.SUCCESS_NO_CONTENT);
+
+        } catch (IOException e) {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/BannerResource.java b/src/main/java/com/p4square/grow/backend/resources/BannerResource.java
new file mode 100644
index 0000000..2b9c8e6
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/BannerResource.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+
+import org.restlet.data.Status;
+import org.restlet.ext.jackson.JacksonRepresentation;
+import org.restlet.representation.Representation;
+import org.restlet.representation.StringRepresentation;
+import org.restlet.resource.ServerResource;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.backend.GrowBackend;
+import com.p4square.grow.model.Banner;
+import com.p4square.grow.provider.JsonEncodedProvider;
+import com.p4square.grow.provider.Provider;
+
+/**
+ * Fetches or sets the banner string.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class BannerResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(BannerResource.class);
+
+    public static final ObjectMapper MAPPER = JsonEncodedProvider.MAPPER;
+
+    private Provider<String, String> mStringProvider;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        final GrowBackend backend = (GrowBackend) getApplication();
+        mStringProvider = backend.getStringProvider();
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        String result = null;
+        try {
+            result = mStringProvider.get("banner");
+
+        } catch (IOException e) {
+            LOG.warn("Exception loading banner: " + e);
+        }
+
+        if (result == null || result.length() == 0) {
+            result = "{\"html\":null}";
+        }
+
+        return new StringRepresentation(result);
+    }
+
+    /**
+     * Handle PUT requests
+     */
+    @Override
+    protected Representation put(Representation entity) {
+        try {
+            JacksonRepresentation<Banner> representation =
+                new JacksonRepresentation<>(entity, Banner.class);
+            representation.setObjectMapper(MAPPER);
+
+            Banner banner = representation.getObject();
+
+            mStringProvider.put("banner", MAPPER.writeValueAsString(banner));
+            setStatus(Status.SUCCESS_NO_CONTENT);
+
+        } catch (IOException e) {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/SurveyResource.java b/src/main/java/com/p4square/grow/backend/resources/SurveyResource.java
new file mode 100644
index 0000000..8723ee2
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/SurveyResource.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+
+import java.util.Map;
+import java.util.HashMap;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.restlet.data.MediaType;
+import org.restlet.data.Status;
+import org.restlet.ext.jackson.JacksonRepresentation;
+import org.restlet.representation.Representation;
+import org.restlet.representation.StringRepresentation;
+import org.restlet.resource.ServerResource;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.backend.GrowBackend;
+import com.p4square.grow.model.Question;
+import com.p4square.grow.provider.JsonEncodedProvider;
+import com.p4square.grow.provider.Provider;
+
+/**
+ * This resource manages assessment questions.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class SurveyResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(SurveyResource.class);
+
+    private static final ObjectMapper MAPPER = JsonEncodedProvider.MAPPER;
+
+    private Provider<String, Question> mQuestionProvider;
+    private Provider<String, String> mStringProvider;
+
+    private String mQuestionId;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        final GrowBackend backend = (GrowBackend) getApplication();
+        mQuestionProvider = backend.getQuestionProvider();
+        mStringProvider = backend.getStringProvider();
+
+        mQuestionId = getAttribute("questionId");
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        String result = "{}";
+
+        if (mQuestionId == null) {
+            // TODO: List all question ids
+
+        } else if (mQuestionId.equals("first")) {
+            // Get the first question id from db?
+            Map<?, ?> questionSummary = getQuestionsSummary();
+            mQuestionId = (String) questionSummary.get("first");
+
+        } else if (mQuestionId.equals("count")) {
+            // Get the first question id from db?
+            Map<?, ?> questionSummary = getQuestionsSummary();
+
+            return new StringRepresentation("{\"count\":" +
+                    String.valueOf((Integer) questionSummary.get("count")) + "}");
+        }
+
+        if (mQuestionId != null) {
+            // Get a question by id
+            Question question = null;
+            try {
+                question = mQuestionProvider.get(mQuestionId);
+            } catch (IOException e) {
+                LOG.error("IOException loading question: " + e);
+            }
+
+            if (question == null) {
+                // 404
+                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+                return null;
+            }
+
+            JacksonRepresentation<Question> rep = new JacksonRepresentation<>(question);
+            rep.setObjectMapper(MAPPER);
+            return rep;
+        }
+
+        return new StringRepresentation(result);
+    }
+
+    private Map<?, ?> getQuestionsSummary() {
+        try {
+            // TODO: This could be better. Quick fix for provider support.
+            String json = mStringProvider.get("/questions");
+
+            if (json != null) {
+                return MAPPER.readValue(json, Map.class);
+            }
+
+        } catch (IOException e) {
+            LOG.info("Exception reading questions summary.", e);
+        }
+
+        return null;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/SurveyResultsResource.java b/src/main/java/com/p4square/grow/backend/resources/SurveyResultsResource.java
new file mode 100644
index 0000000..7c15cfd
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/SurveyResultsResource.java
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.HashMap;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.restlet.data.MediaType;
+import org.restlet.data.Status;
+import org.restlet.representation.Representation;
+import org.restlet.representation.StringRepresentation;
+import org.restlet.resource.ServerResource;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.backend.GrowBackend;
+import com.p4square.grow.model.Answer;
+import com.p4square.grow.model.Question;
+import com.p4square.grow.model.RecordedAnswer;
+import com.p4square.grow.model.Score;
+import com.p4square.grow.model.UserRecord;
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.Provider;
+
+
+/**
+ * Store the user's answers to the assessment and generate their score.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class SurveyResultsResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(SurveyResultsResource.class);
+
+    private static final ObjectMapper MAPPER = new ObjectMapper();
+
+    static enum RequestType {
+        ASSESSMENT, ANSWER
+    }
+
+    private CollectionProvider<String, String, String> mAnswerProvider;
+    private Provider<String, Question> mQuestionProvider;
+    private Provider<String, UserRecord> mUserRecordProvider;
+
+    private RequestType mRequestType;
+    private String mUserId;
+    private String mQuestionId;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        final GrowBackend backend = (GrowBackend) getApplication();
+        mAnswerProvider = backend.getAnswerProvider();
+        mQuestionProvider = backend.getQuestionProvider();
+        mUserRecordProvider = backend.getUserRecordProvider();
+
+        mUserId = getAttribute("userId");
+        mQuestionId = getAttribute("questionId");
+
+        mRequestType = RequestType.ASSESSMENT;
+        if (mQuestionId != null) {
+            mRequestType = RequestType.ANSWER;
+        }
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        try {
+            String result = null;
+
+            switch (mRequestType) {
+                case ANSWER:
+                    result = mAnswerProvider.get(mUserId, mQuestionId);
+                    break;
+
+                case ASSESSMENT:
+                    result = mAnswerProvider.get(mUserId, "summary");
+                    if (result == null || result.length() == 0) {
+                        result = buildAssessment();
+                    }
+                    break;
+            }
+
+            if (result == null) {
+                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+                return null;
+            }
+
+            return new StringRepresentation(result);
+        } catch (IOException e) {
+            LOG.error("IOException getting answer: ", e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+
+    /**
+     * Handle PUT requests
+     */
+    @Override
+    protected Representation put(Representation entity) {
+        boolean success = false;
+
+        switch (mRequestType) {
+            case ANSWER:
+                try {
+                    mAnswerProvider.put(mUserId, mQuestionId, entity.getText());
+                    mAnswerProvider.put(mUserId, "lastAnswered", mQuestionId);
+                    mAnswerProvider.put(mUserId, "summary", null);
+                    success = true;
+
+                } catch (Exception e) {
+                    LOG.warn("Caught exception putting answer: " + e.getMessage(), e);
+                }
+                break;
+
+            default:
+                setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+                return null;
+        }
+
+        if (success) {
+            setStatus(Status.SUCCESS_NO_CONTENT);
+
+        } else {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+        }
+
+        return null;
+    }
+
+    /**
+     * Clear assessment results.
+     */
+    @Override
+    protected Representation delete() {
+        boolean success = false;
+
+        switch (mRequestType) {
+            case ANSWER:
+                try {
+                    mAnswerProvider.put(mUserId, mQuestionId, null);
+                    mAnswerProvider.put(mUserId, "summary", null);
+                    success = true;
+
+                } catch (Exception e) {
+                    LOG.warn("Caught exception putting answer: " + e.getMessage(), e);
+                }
+                break;
+
+            case ASSESSMENT:
+                try {
+                    mAnswerProvider.put(mUserId, "summary", null);
+                    mAnswerProvider.put(mUserId, "lastAnswered", null);
+                    // TODO Delete answers
+
+                    UserRecord record = mUserRecordProvider.get(mUserId);
+                    if (record != null) {
+                        record.setLanding("assessment");
+                        mUserRecordProvider.put(mUserId, record);
+                    }
+
+                    success = true;
+
+                } catch (Exception e) {
+                    LOG.warn("Caught exception putting answer: " + e.getMessage(), e);
+                }
+                break;
+
+            default:
+                setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+                return null;
+        }
+
+        if (success) {
+            setStatus(Status.SUCCESS_NO_CONTENT);
+
+        } else {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+        }
+
+        return null;
+
+    }
+
+    /**
+     * This method compiles assessment results.
+     */
+    private String buildAssessment() throws IOException {
+        StringBuilder sb = new StringBuilder("{ ");
+
+        // Last question answered
+        final String lastAnswered = mAnswerProvider.get(mUserId, "lastAnswered");
+        if (lastAnswered != null && lastAnswered.length() > 0) {
+            sb.append("\"lastAnswered\": \"" + lastAnswered + "\", ");
+        }
+
+        // Compute score
+        Map<String, String> row = mAnswerProvider.query(mUserId);
+        if (row.size() > 0) {
+            Score score = new Score();
+            boolean scoringDone = false;
+            int totalAnswers = 0;
+            for (Map.Entry<String, String> c : row.entrySet()) {
+                if (c.getKey().equals("lastAnswered") || c.getKey().equals("summary")) {
+                    continue;
+                }
+
+                try {
+                    Question question = mQuestionProvider.get(c.getKey());
+                    RecordedAnswer userAnswer = MAPPER.readValue(c.getValue(), RecordedAnswer.class);
+
+                    if (question == null) {
+                        LOG.warn("Answer for unknown question: " + c.getKey());
+                        continue;
+                    }
+
+                    LOG.debug("Scoring questionId: " + c.getKey());
+                    scoringDone = !question.scoreAnswer(score, userAnswer);
+
+                } catch (Exception e) {
+                    LOG.error("Failed to score question: {userid: \"" + mUserId +
+                            "\", questionid:\"" + c.getKey() +
+                            "\", userAnswer:\"" + c.getValue() + "\"}", e);
+                }
+
+                totalAnswers++;
+            }
+
+            sb.append("\"score\":" + score.getScore());
+            sb.append(", \"sum\":" + score.getSum());
+            sb.append(", \"count\":" + score.getCount());
+            sb.append(", \"totalAnswers\":" + totalAnswers);
+            sb.append(", \"result\":\"" + score.toString() + "\"");
+        }
+
+        sb.append(" }");
+        String summary = sb.toString();
+
+        // Persist summary
+        mAnswerProvider.put(mUserId, "summary", summary);
+
+        return summary;
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/TrainingRecordResource.java b/src/main/java/com/p4square/grow/backend/resources/TrainingRecordResource.java
new file mode 100644
index 0000000..51ba56a
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/TrainingRecordResource.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.HashMap;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import org.restlet.data.MediaType;
+import org.restlet.data.Status;
+import org.restlet.resource.ServerResource;
+import org.restlet.representation.Representation;
+import org.restlet.representation.StringRepresentation;
+
+import org.restlet.ext.jackson.JacksonRepresentation;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.backend.GrowBackend;
+
+import com.p4square.grow.model.Chapter;
+import com.p4square.grow.model.Playlist;
+import com.p4square.grow.model.VideoRecord;
+import com.p4square.grow.model.TrainingRecord;
+
+import com.p4square.grow.provider.CollectionProvider;
+import com.p4square.grow.provider.JsonEncodedProvider;
+import com.p4square.grow.provider.Provider;
+import com.p4square.grow.provider.ProvidesAssessments;
+import com.p4square.grow.provider.ProvidesTrainingRecords;
+
+import com.p4square.grow.model.Score;
+
+/**
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class TrainingRecordResource extends ServerResource {
+    private static final Logger LOG = Logger.getLogger(TrainingRecordResource.class);
+    private static final ObjectMapper MAPPER = JsonEncodedProvider.MAPPER;
+
+    static enum RequestType {
+        SUMMARY, VIDEO
+    }
+
+    private Provider<String, TrainingRecord> mTrainingRecordProvider;
+    private CollectionProvider<String, String, String> mAnswerProvider;
+
+    private RequestType mRequestType;
+    private String mUserId;
+    private String mVideoId;
+    private TrainingRecord mRecord;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        mTrainingRecordProvider = ((ProvidesTrainingRecords) getApplication()).getTrainingRecordProvider();
+        mAnswerProvider = ((ProvidesAssessments) getApplication()).getAnswerProvider();
+
+        mUserId = getAttribute("userId");
+        mVideoId = getAttribute("videoId");
+
+        try {
+            Playlist defaultPlaylist = ((ProvidesTrainingRecords) getApplication()).getDefaultPlaylist();
+
+            mRecord = mTrainingRecordProvider.get(mUserId);
+            if (mRecord == null) {
+                mRecord = new TrainingRecord();
+                mRecord.setPlaylist(defaultPlaylist);
+                skipAssessedChapters(mUserId, mRecord);
+            } else {
+                // Merge the playlist with the most recent version.
+                mRecord.getPlaylist().merge(defaultPlaylist);
+            }
+
+        } catch (IOException e) {
+            LOG.error("IOException loading TrainingRecord: " + e.getMessage(), e);
+            mRecord = null;
+        }
+
+        mRequestType = RequestType.SUMMARY;
+        if (mVideoId != null) {
+            mRequestType = RequestType.VIDEO;
+        }
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        JacksonRepresentation<?> rep = null;
+
+        if (mRecord == null) {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+
+        switch (mRequestType) {
+            case VIDEO:
+                VideoRecord video = mRecord.getPlaylist().find(mVideoId);
+                if (video == null) {
+                    break; // Fall through and return 404
+                }
+                rep = new JacksonRepresentation<VideoRecord>(video);
+                break;
+
+            case SUMMARY:
+                rep = new JacksonRepresentation<TrainingRecord>(mRecord);
+                break;
+        }
+
+        if (rep == null) {
+            setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+            return null;
+
+        } else {
+            rep.setObjectMapper(JsonEncodedProvider.MAPPER);
+            return rep;
+        }
+    }
+
+    /**
+     * Handle PUT requests
+     */
+    @Override
+    protected Representation put(Representation entity) {
+        if (mRecord == null) {
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+
+        switch (mRequestType) {
+            case VIDEO:
+                try {
+                    JacksonRepresentation<VideoRecord> representation =
+                        new JacksonRepresentation<>(entity, VideoRecord.class);
+                    representation.setObjectMapper(JsonEncodedProvider.MAPPER);
+                    VideoRecord update = representation.getObject();
+                    VideoRecord video = mRecord.getPlaylist().find(mVideoId);
+
+                    if (video == null) {
+                        // TODO: Video isn't on their playlist...
+                        LOG.warn("Skipping video completion for video missing from playlist.");
+
+                    } else if (update.getComplete() && !video.getComplete()) {
+                        // Video was newly completed
+                        video.complete();
+                        mRecord.setLastVideo(mVideoId);
+
+                        mTrainingRecordProvider.put(mUserId, mRecord);
+                    }
+
+                    setStatus(Status.SUCCESS_NO_CONTENT);
+
+                } catch (Exception e) {
+                    LOG.warn("Caught exception updating training record: " + e.getMessage(), e);
+                    setStatus(Status.SERVER_ERROR_INTERNAL);
+                }
+                break;
+
+            default:
+                setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+        }
+
+        return null;
+    }
+
+    private Score getAssessedScore(String userId) throws IOException {
+        // Get the user's score.
+        Score assessedScore = new Score(0, 0);
+
+        String summaryString = mAnswerProvider.get(userId, "summary");
+        if (summaryString == null) {
+            throw new IOException("Asked to create training record for unassessed user " + userId);
+        }
+
+        Map<?,?> summary = MAPPER.readValue(summaryString, Map.class);
+
+        if (summary.containsKey("sum") && summary.containsKey("count")) {
+            double sum = (Double) summary.get("sum");
+            int count = (Integer) summary.get("count");
+            assessedScore = new Score(sum, count);
+        }
+
+        return assessedScore;
+    }
+
+    /**
+     * Mark the chapters which the user assessed through as not required.
+     */
+    private void skipAssessedChapters(String userId, TrainingRecord record) {
+        // Get the user's score.
+        Score assessedScore = new Score(0, 0);
+
+        try {
+            assessedScore = getAssessedScore(userId);
+        } catch (IOException e) {
+            LOG.error("IOException fetching assessment record for " + userId, e);
+            return;
+        }
+
+        // Mark the correct videos as not required.
+        Playlist playlist = record.getPlaylist();
+
+        for (Map.Entry<String, Chapter> entry : playlist.getChaptersMap().entrySet()) {
+            String chapterId = entry.getKey();
+            Chapter chapter = entry.getValue();
+            boolean required;
+
+            if ("introduction".equals(chapter)) {
+                // Introduction chapter is always required
+                required = true;
+
+            } else {
+                // Chapter required if the floor of the score is <= the chapter's numeric value.
+                required = assessedScore.floor() <= Score.numericScore(chapterId);
+            }
+
+            if (!required) {
+                for (VideoRecord video : chapter.getVideos().values()) {
+                    video.setRequired(required);
+                }
+            }
+        }
+    }
+}
diff --git a/src/main/java/com/p4square/grow/backend/resources/TrainingResource.java b/src/main/java/com/p4square/grow/backend/resources/TrainingResource.java
new file mode 100644
index 0000000..6efdfab
--- /dev/null
+++ b/src/main/java/com/p4square/grow/backend/resources/TrainingResource.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2013 Jesse Morgan
+ */
+
+package com.p4square.grow.backend.resources;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.restlet.data.Status;
+import org.restlet.resource.ServerResource;
+import org.restlet.representation.Representation;
+import org.restlet.representation.StringRepresentation;
+
+import org.apache.log4j.Logger;
+
+import com.p4square.grow.backend.GrowBackend;
+import com.p4square.grow.backend.db.CassandraDatabase;
+
+import com.p4square.grow.provider.CollectionProvider;
+/**
+ * This resource returns a listing of training items for a particular level.
+ *
+ * @author Jesse Morgan <jesse@jesterpm.net>
+ */
+public class TrainingResource extends ServerResource {
+    private final static Logger LOG = Logger.getLogger(TrainingResource.class);
+
+    private CollectionProvider<String, String, String> mVideoProvider;
+
+    private String mLevel;
+    private String mVideoId;
+
+    @Override
+    public void doInit() {
+        super.doInit();
+
+        GrowBackend backend = (GrowBackend) getApplication();
+        mVideoProvider = backend.getVideoProvider();
+
+        mLevel = getAttribute("level");
+        mVideoId = getAttribute("videoId");
+    }
+
+    /**
+     * Handle GET Requests.
+     */
+    @Override
+    protected Representation get() {
+        String result = null;
+
+        if (mLevel == null) {
+            setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+            return null;
+        }
+
+        try {
+            if (mVideoId == null) {
+                // Get all videos
+                // TODO: This could be improved, but this is the quickest way to get
+                // providers working.
+                Map<String, String> videos = mVideoProvider.query(mLevel);
+                if (videos.size() > 0) {
+                    StringBuilder sb = new StringBuilder("{ \"level\": \"" + mLevel + "\"");
+                    sb.append(", \"videos\": [");
+                    boolean first = true;
+                    for (String value : videos.values()) {
+                        if (!first) {
+                            sb.append(", ");
+                        }
+                        sb.append(value);
+                        first = false;
+                    }
+                    sb.append("] }");
+                    result = sb.toString();
+                }
+
+            } else {
+                // Get single video
+                result = mVideoProvider.get(mLevel, mVideoId);
+            }
+
+            if (result == null) {
+                // 404
+                setStatus(Status.CLIENT_ERROR_NOT_FOUND);
+                return null;
+            }
+
+            return new StringRepresentation(result);
+
+        } catch (IOException e) {
+            LOG.error("IOException fetch video: " + e.getMessage(), e);
+            setStatus(Status.SERVER_ERROR_INTERNAL);
+            return null;
+        }
+    }
+}