many small API cleanups

- use FatCatId much more often (though not everywhere yet)
- more consistent types
- remove redundant error handling code in wrappers

5 files changed, 148 insertions, 193 deletions

diff --git a/rust/src/api_entity_crud.rs b/rust/src/api_entity_crud.rs
index a1f4742b..dd0961d5 100644
--- a/rust/src/api_entity_crud.rs
+++ b/rust/src/api_entity_crud.rs
@@ -43,19 +43,9 @@ where
     fn parse_editgroup_id(&self) -> Result<Option<FatCatId>>;
 
     // Generic Methods
-    fn db_get(
-        conn: &DbConn,
-        ident: FatCatId
-    ) -> Result<Self>;
-    fn db_get_rev(
-        conn: &DbConn,
-        rev_id: Uuid
-    ) -> Result<Self>;
-    fn db_create(
-        &self,
-        conn: &DbConn,
-        edit_context: &EditContext
-    ) -> Result<Self::EditRow>;
+    fn db_get(conn: &DbConn, ident: FatCatId) -> Result<Self>;
+    fn db_get_rev(conn: &DbConn, rev_id: Uuid) -> Result<Self>;
+    fn db_create(&self, conn: &DbConn, edit_context: &EditContext) -> Result<Self::EditRow>;
     fn db_create_batch(
         conn: &DbConn,
         edit_context: &EditContext,
@@ -77,10 +67,7 @@ where
         ident: FatCatId,
         limit: Option<i64>,
     ) -> Result<Vec<EntityHistoryEntry>>;
-    fn db_accept_edits(
-        conn: &DbConn,
-        editgroup_id: FatCatId
-    ) -> Result<u64>;
+    fn db_accept_edits(conn: &DbConn, editgroup_id: FatCatId) -> Result<u64>;
 
     // Entity-specific Methods
     fn db_from_row(
@@ -88,14 +75,8 @@ where
         rev_row: Self::RevRow,
         ident_row: Option<Self::IdentRow>,
     ) -> Result<Self>;
-    fn db_insert_rev(
-        &self,
-        conn: &DbConn
-    ) -> Result<Uuid>;
-    fn db_insert_revs(
-        conn: &DbConn,
-        models: &[&Self]
-    ) -> Result<Vec<Uuid>>;
+    fn db_insert_rev(&self, conn: &DbConn) -> Result<Uuid>;
+    fn db_insert_revs(conn: &DbConn, models: &[&Self]) -> Result<Vec<Uuid>>;
 }
 
 // TODO: this could be a separate trait on all entities
@@ -328,11 +309,7 @@ macro_rules! generic_db_get_history {
 #[allow(unused_macros)]
 macro_rules! generic_db_accept_edits_batch {
     ($entity_name_str:expr) => {
-        fn db_accept_edits(
-            conn: &DbConn,
-            editgroup_id: FatCatId,
-        ) -> Result<u64> {
-
+        fn db_accept_edits(conn: &DbConn, editgroup_id: FatCatId) -> Result<u64> {
             let count = diesel::sql_query(format!(
                 "
                     UPDATE {entity}_ident
@@ -344,12 +321,12 @@ macro_rules! generic_db_accept_edits_batch {
                     WHERE
                         {entity}_ident.id = {entity}_edit.ident_id
                         AND {entity}_edit.editgroup_id = $1",
-                entity = $entity_name_str 
+                entity = $entity_name_str
             )).bind::<diesel::sql_types::Uuid, _>(editgroup_id.to_uuid())
                 .execute(conn)?;
             Ok(count as u64)
         }
-    }
+    };
 }
 
 // UPDATE ROW version: single query per row
@@ -357,11 +334,7 @@ macro_rules! generic_db_accept_edits_batch {
 #[allow(unused_macros)]
 macro_rules! generic_db_accept_edits_each {
     ($ident_table:ident, $edit_table:ident) => {
-        fn db_accept_edits(
-            conn: &DbConn,
-            editgroup_id: FatCatId,
-        ) -> Result<u64> {
-
+        fn db_accept_edits(conn: &DbConn, editgroup_id: FatCatId) -> Result<u64> {
             // 1. select edit rows (in sql)
             let edit_rows: Vec<Self::EditRow> = $edit_table::table
                 .filter($edit_table::editgroup_id.eq(&editgroup_id.to_uuid()))
@@ -369,31 +342,26 @@ macro_rules! generic_db_accept_edits_each {
             // 2. create ident rows (in rust)
             let ident_rows: Vec<Self::IdentRow> = edit_rows
                 .iter()
-                .map(|edit|
-                    Self::IdentRow {
-                        id: edit.ident_id,
-                        is_live: true,
-                        rev_id: edit.rev_id,
-                        redirect_id: edit.redirect_id,
-
-                    }
-                )
+                .map(|edit| Self::IdentRow {
+                    id: edit.ident_id,
+                    is_live: true,
+                    rev_id: edit.rev_id,
+                    redirect_id: edit.redirect_id,
+                })
                 .collect();
             /*
-            // 3. upsert ident rows (in sql)
-            let count: u64 = diesel::insert_into($ident_table::table)
-                .values(ident_rows)
-                .on_conflict()
-                .do_update()
-                .set(ident_rows)
-                .execute(conn)?;
-            */
+                                    // 3. upsert ident rows (in sql)
+                                    let count: u64 = diesel::insert_into($ident_table::table)
+                                        .values(ident_rows)
+                                        .on_conflict()
+                                        .do_update()
+                                        .set(ident_rows)
+                                        .execute(conn)?;
+                                    */
             // 3. update every row individually
             let count = ident_rows.len() as u64;
             for row in ident_rows {
-                diesel::update(&row)
-                    .set(&row)
-                    .execute(conn)?;
+                diesel::update(&row).set(&row).execute(conn)?;
             }
             Ok(count)
         }
diff --git a/rust/src/api_helpers.rs b/rust/src/api_helpers.rs
index 2d203232..6c214223 100644
--- a/rust/src/api_helpers.rs
+++ b/rust/src/api_helpers.rs
@@ -1,15 +1,15 @@
+use api_entity_crud::EntityCrud;
 use data_encoding::BASE32_NOPAD;
 use database_models::*;
 use database_schema::*;
-use fatcat_api::models::*;
-use serde_json;
 use diesel;
 use diesel::prelude::*;
 use errors::*;
+use fatcat_api::models::*;
 use regex::Regex;
+use serde_json;
 use std::str::FromStr;
 use uuid::Uuid;
-use api_entity_crud::EntityCrud;
 
 pub type DbConn =
     diesel::r2d2::PooledConnection<diesel::r2d2::ConnectionManager<diesel::PgConnection>>;
@@ -21,7 +21,11 @@ pub struct EditContext {
     pub autoaccept: bool,
 }
 
-pub fn make_edit_context(conn: &DbConn, editgroup_id: Option<FatCatId>, autoaccept: bool) -> Result<EditContext> {
+pub fn make_edit_context(
+    conn: &DbConn,
+    editgroup_id: Option<FatCatId>,
+    autoaccept: bool,
+) -> Result<EditContext> {
     let editor_id = Uuid::parse_str("00000000-0000-0000-AAAA-000000000001")?; // TODO: auth
     let editgroup_id: FatCatId = match (editgroup_id, autoaccept) {
         (Some(eg), _) => eg,
@@ -31,7 +35,7 @@ pub fn make_edit_context(conn: &DbConn, editgroup_id: Option<FatCatId>, autoacce
                 .values((editgroup::editor_id.eq(editor_id),))
                 .get_result(conn)?;
             FatCatId::from_uuid(&eg_row.id)
-        },
+        }
         (None, false) => FatCatId::from_uuid(&get_or_create_editgroup(editor_id, conn)?),
     };
     Ok(EditContext {
@@ -61,34 +65,33 @@ pub fn get_or_create_editgroup(editor_id: Uuid, conn: &DbConn) -> Result<Uuid> {
 }
 
 /// This function should always be run within a transaction
-pub fn accept_editgroup(editgroup_id: Uuid, conn: &DbConn) -> Result<ChangelogRow> {
+pub fn accept_editgroup(editgroup_id: FatCatId, conn: &DbConn) -> Result<ChangelogRow> {
     // check that we haven't accepted already (in changelog)
     // NB: could leave this to a UNIQUE constraint
     let count: i64 = changelog::table
-        .filter(changelog::editgroup_id.eq(editgroup_id))
+        .filter(changelog::editgroup_id.eq(editgroup_id.to_uuid()))
         .count()
         .get_result(conn)?;
     if count > 0 {
-        return Err(ErrorKind::EditgroupAlreadyAccepted(uuid2fcid(&editgroup_id)).into());
+        return Err(ErrorKind::EditgroupAlreadyAccepted(editgroup_id.to_string()).into());
     }
 
     // copy edit columns to ident table
-    let eg_id = FatCatId::from_uuid(&editgroup_id);
-    ContainerEntity::db_accept_edits(conn, eg_id)?;
-    CreatorEntity::db_accept_edits(conn, eg_id)?;
-    FileEntity::db_accept_edits(conn, eg_id)?;
-    ReleaseEntity::db_accept_edits(conn, eg_id)?;
-    WorkEntity::db_accept_edits(conn, eg_id)?;
+    ContainerEntity::db_accept_edits(conn, editgroup_id)?;
+    CreatorEntity::db_accept_edits(conn, editgroup_id)?;
+    FileEntity::db_accept_edits(conn, editgroup_id)?;
+    ReleaseEntity::db_accept_edits(conn, editgroup_id)?;
+    WorkEntity::db_accept_edits(conn, editgroup_id)?;
 
     // append log/changelog row
     let entry: ChangelogRow = diesel::insert_into(changelog::table)
-        .values((changelog::editgroup_id.eq(editgroup_id),))
+        .values((changelog::editgroup_id.eq(editgroup_id.to_uuid()),))
         .get_result(conn)?;
 
     // update any editor's active editgroup
     let no_active: Option<Uuid> = None;
     diesel::update(editor::table)
-        .filter(editor::active_editgroup_id.eq(editgroup_id))
+        .filter(editor::active_editgroup_id.eq(editgroup_id.to_uuid()))
         .set(editor::active_editgroup_id.eq(no_active))
         .execute(conn)?;
     Ok(entry)
diff --git a/rust/src/api_server.rs b/rust/src/api_server.rs
index e832385a..076bc085 100644
--- a/rust/src/api_server.rs
+++ b/rust/src/api_server.rs
@@ -1,8 +1,8 @@
 //! API endpoint handlers
 
+use api_entity_crud::EntityCrud;
 use api_helpers::*;
 use chrono;
-use api_entity_crud::EntityCrud;
 use database_models::*;
 use database_schema::*;
 use diesel::prelude::*;
@@ -11,7 +11,6 @@ use errors::*;
 use fatcat_api::models;
 use fatcat_api::models::*;
 use std::str::FromStr;
-use uuid::Uuid;
 use ConnectionPool;
 
 macro_rules! entity_batch_handler {
@@ -61,11 +60,11 @@ pub struct Server {
 impl Server {
     pub fn get_container_handler(
         &self,
-        id: &Uuid,
+        id: FatCatId,
         _expand: Option<String>,
         conn: &DbConn,
     ) -> Result<ContainerEntity> {
-        ContainerEntity::db_get(conn, FatCatId::from_uuid(id))
+        ContainerEntity::db_get(conn, id)
     }
 
     pub fn lookup_container_handler(&self, issnl: &str, conn: &DbConn) -> Result<ContainerEntity> {
@@ -85,11 +84,11 @@ impl Server {
 
     pub fn get_creator_handler(
         &self,
-        id: &Uuid,
+        id: FatCatId,
         _expand: Option<String>,
         conn: &DbConn,
     ) -> Result<CreatorEntity> {
-        CreatorEntity::db_get(conn, FatCatId::from_uuid(id))
+        CreatorEntity::db_get(conn, id)
     }
 
     pub fn lookup_creator_handler(&self, orcid: &str, conn: &DbConn) -> Result<CreatorEntity> {
@@ -109,16 +108,14 @@ impl Server {
 
     pub fn get_creator_releases_handler(
         &self,
-        id: &str,
+        id: FatCatId,
         conn: &DbConn,
     ) -> Result<Vec<ReleaseEntity>> {
-        let id = fcid2uuid(&id)?;
-
         // TODO: some kind of unique or group-by?
         let rows: Vec<(ReleaseRevRow, ReleaseIdentRow, ReleaseContribRow)> = release_rev::table
             .inner_join(release_ident::table)
             .inner_join(release_contrib::table)
-            .filter(release_contrib::creator_ident_id.eq(&id))
+            .filter(release_contrib::creator_ident_id.eq(&id.to_uuid()))
             .filter(release_ident::is_live.eq(true))
             .filter(release_ident::redirect_id.is_null())
             .load(conn)?;
@@ -131,11 +128,11 @@ impl Server {
 
     pub fn get_file_handler(
         &self,
-        id: &Uuid,
+        id: FatCatId,
         _expand: Option<String>,
         conn: &DbConn,
     ) -> Result<FileEntity> {
-        FileEntity::db_get(conn, FatCatId::from_uuid(id))
+        FileEntity::db_get(conn, id)
     }
 
     pub fn lookup_file_handler(&self, sha1: &str, conn: &DbConn) -> Result<FileEntity> {
@@ -154,19 +151,18 @@ impl Server {
 
     pub fn get_release_handler(
         &self,
-        id: &Uuid,
+        id: FatCatId,
         expand: Option<String>,
         conn: &DbConn,
     ) -> Result<ReleaseEntity> {
-        let mut release = ReleaseEntity::db_get(conn, FatCatId::from_uuid(id))?;
+        let mut release = ReleaseEntity::db_get(conn, id)?;
 
         // For now, if there is any expand param we do them all
         if expand.is_some() {
-            release.files =
-                Some(self.get_release_files_handler(&release.ident.clone().unwrap(), conn)?);
+            release.files = Some(self.get_release_files_handler(id, conn)?);
             if let Some(ref cid) = release.container_id {
                 release.container =
-                    Some(self.get_container_handler(&fcid2uuid(&cid)?, None, conn)?);
+                    Some(self.get_container_handler(FatCatId::from_str(&cid)?, None, conn)?);
             }
         }
         Ok(release)
@@ -187,13 +183,15 @@ impl Server {
         ReleaseEntity::db_from_row(conn, rev, Some(ident))
     }
 
-    pub fn get_release_files_handler(&self, id: &str, conn: &DbConn) -> Result<Vec<FileEntity>> {
-        let ident = FatCatId::from_str(id)?;
-
+    pub fn get_release_files_handler(
+        &self,
+        id: FatCatId,
+        conn: &DbConn,
+    ) -> Result<Vec<FileEntity>> {
         let rows: Vec<(FileRevRow, FileIdentRow, FileReleaseRow)> = file_rev::table
             .inner_join(file_ident::table)
             .inner_join(file_release::table)
-            .filter(file_release::target_release_ident_id.eq(&ident.to_uuid()))
+            .filter(file_release::target_release_ident_id.eq(&id.to_uuid()))
             .filter(file_ident::is_live.eq(true))
             .filter(file_ident::redirect_id.is_null())
             .load(conn)?;
@@ -205,19 +203,21 @@ impl Server {
 
     pub fn get_work_handler(
         &self,
-        id: &Uuid,
+        id: FatCatId,
         _expand: Option<String>,
         conn: &DbConn,
     ) -> Result<WorkEntity> {
-        WorkEntity::db_get(conn, FatCatId::from_uuid(id))
+        WorkEntity::db_get(conn, id)
     }
 
-    pub fn get_work_releases_handler(&self, id: &str, conn: &DbConn) -> Result<Vec<ReleaseEntity>> {
-        let id = fcid2uuid(&id)?;
-
+    pub fn get_work_releases_handler(
+        &self,
+        id: FatCatId,
+        conn: &DbConn,
+    ) -> Result<Vec<ReleaseEntity>> {
         let rows: Vec<(ReleaseRevRow, ReleaseIdentRow)> = release_rev::table
             .inner_join(release_ident::table)
-            .filter(release_rev::work_ident_id.eq(&id))
+            .filter(release_rev::work_ident_id.eq(&id.to_uuid()))
             .filter(release_ident::is_live.eq(true))
             .filter(release_ident::redirect_id.is_null())
             .load(conn)?;
@@ -227,8 +227,8 @@ impl Server {
             .collect()
     }
 
-    pub fn accept_editgroup_handler(&self, id: &str, conn: &DbConn) -> Result<()> {
-        accept_editgroup(fcid2uuid(id)?, conn)?;
+    pub fn accept_editgroup_handler(&self, id: FatCatId, conn: &DbConn) -> Result<()> {
+        accept_editgroup(id, conn)?;
         Ok(())
     }
 
@@ -239,7 +239,7 @@ impl Server {
     ) -> Result<Editgroup> {
         let row: EditgroupRow = insert_into(editgroup::table)
             .values((
-                editgroup::editor_id.eq(fcid2uuid(&entity.editor_id)?),
+                editgroup::editor_id.eq(FatCatId::from_str(&entity.editor_id)?.to_uuid()),
                 editgroup::description.eq(entity.description),
                 editgroup::extra_json.eq(entity.extra),
             ))
@@ -254,14 +254,13 @@ impl Server {
         })
     }
 
-    pub fn get_editgroup_handler(&self, id: &str, conn: &DbConn) -> Result<Editgroup> {
-        let id = fcid2uuid(id)?;
-        let row: EditgroupRow = editgroup::table.find(id).first(conn)?;
+    pub fn get_editgroup_handler(&self, id: FatCatId, conn: &DbConn) -> Result<Editgroup> {
+        let row: EditgroupRow = editgroup::table.find(id.to_uuid()).first(conn)?;
 
         let edits = EditgroupEdits {
             containers: Some(
                 container_edit::table
-                    .filter(container_edit::editgroup_id.eq(id))
+                    .filter(container_edit::editgroup_id.eq(id.to_uuid()))
                     .get_results(conn)?
                     .into_iter()
                     .map(|e: ContainerEditRow| e.into_model().unwrap())
@@ -269,7 +268,7 @@ impl Server {
             ),
             creators: Some(
                 creator_edit::table
-                    .filter(creator_edit::editgroup_id.eq(id))
+                    .filter(creator_edit::editgroup_id.eq(id.to_uuid()))
                     .get_results(conn)?
                     .into_iter()
                     .map(|e: CreatorEditRow| e.into_model().unwrap())
@@ -277,7 +276,7 @@ impl Server {
             ),
             files: Some(
                 file_edit::table
-                    .filter(file_edit::editgroup_id.eq(id))
+                    .filter(file_edit::editgroup_id.eq(id.to_uuid()))
                     .get_results(conn)?
                     .into_iter()
                     .map(|e: FileEditRow| e.into_model().unwrap())
@@ -285,7 +284,7 @@ impl Server {
             ),
             releases: Some(
                 release_edit::table
-                    .filter(release_edit::editgroup_id.eq(id))
+                    .filter(release_edit::editgroup_id.eq(id.to_uuid()))
                     .get_results(conn)?
                     .into_iter()
                     .map(|e: ReleaseEditRow| e.into_model().unwrap())
@@ -293,7 +292,7 @@ impl Server {
             ),
             works: Some(
                 work_edit::table
-                    .filter(work_edit::editgroup_id.eq(id))
+                    .filter(work_edit::editgroup_id.eq(id.to_uuid()))
                     .get_results(conn)?
                     .into_iter()
                     .map(|e: WorkEditRow| e.into_model().unwrap())
@@ -311,9 +310,8 @@ impl Server {
         Ok(eg)
     }
 
-    pub fn get_editor_handler(&self, id: &str, conn: &DbConn) -> Result<Editor> {
-        let id = fcid2uuid(id)?;
-        let row: EditorRow = editor::table.find(id).first(conn)?;
+    pub fn get_editor_handler(&self, id: FatCatId, conn: &DbConn) -> Result<Editor> {
+        let row: EditorRow = editor::table.find(id.to_uuid()).first(conn)?;
 
         let ed = Editor {
             id: Some(uuid2fcid(&row.id)),
@@ -322,14 +320,13 @@ impl Server {
         Ok(ed)
     }
 
-    pub fn editor_changelog_get_handler(
+    pub fn get_editor_changelog_handler(
         &self,
-        id: &str,
+        id: FatCatId,
         conn: &DbConn,
     ) -> Result<Vec<ChangelogEntry>> {
-        let id = fcid2uuid(id)?;
         // TODO: single query
-        let editor: EditorRow = editor::table.find(id).first(conn)?;
+        let editor: EditorRow = editor::table.find(id.to_uuid()).first(conn)?;
         let changes: Vec<(ChangelogRow, EditgroupRow)> = changelog::table
             .inner_join(editgroup::table)
             .filter(editgroup::editor_id.eq(editor.id))
@@ -374,7 +371,8 @@ impl Server {
 
     pub fn get_changelog_entry_handler(&self, id: i64, conn: &DbConn) -> Result<ChangelogEntry> {
         let cl_row: ChangelogRow = changelog::table.find(id).first(conn)?;
-        let editgroup = self.get_editgroup_handler(&uuid2fcid(&cl_row.editgroup_id), conn)?;
+        let editgroup =
+            self.get_editgroup_handler(FatCatId::from_uuid(&cl_row.editgroup_id), conn)?;
 
         let mut entry = cl_row.into_model();
         entry.editgroup = Some(editgroup);
diff --git a/rust/src/api_wrappers.rs b/rust/src/api_wrappers.rs
index 0600f3de..f6425c8c 100644
--- a/rust/src/api_wrappers.rs
+++ b/rust/src/api_wrappers.rs
@@ -1,15 +1,15 @@
 //! API endpoint handlers
 
+use api_entity_crud::EntityCrud;
 use api_helpers::*;
 use api_server::Server;
+use database_models::EntityEditRow;
 use diesel::Connection;
 use errors::*;
 use fatcat_api::models;
 use fatcat_api::models::*;
 use fatcat_api::*;
 use futures::{self, Future};
-use api_entity_crud::EntityCrud;
-use database_models::EntityEditRow;
 use std::str::FromStr;
 
 /// Helper for generating wrappers (which return "Box::new(futures::done(Ok(BLAH)))" like the
@@ -32,13 +32,12 @@ macro_rules! wrap_entity_handlers {
             expand: Option<String>,
             _context: &Context,
         ) -> Box<Future<Item = $get_resp, Error = ApiError> + Send> {
-            let id = if let Ok(parsed) = fcid2uuid(&id) { parsed } else {
-                return Box::new(futures::done(Ok($get_resp::BadRequest(ErrorResponse {
-                    message: ErrorKind::InvalidFatcatId(id).to_string() }))));
-            };
             let conn = self.db_pool.get().expect("db_pool error");
             // No transaction for GET
-            let ret = match self.$get_handler(&id, expand, &conn) {
+            let ret = match conn.transaction(|| {
+                let entity_id = FatCatId::from_str(&id)?;
+                self.$get_handler(entity_id, expand, &conn)
+            }) {
                 Ok(entity) =>
                     $get_resp::FoundEntity(entity),
                 Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) =>
@@ -242,6 +241,35 @@ macro_rules! wrap_lookup_handler {
     }
 }
 
+macro_rules! wrap_fcid_handler {
+    ($get_fn:ident, $get_handler:ident, $get_resp:ident) => {
+        fn $get_fn(
+            &self,
+            id: String,
+            _context: &Context,
+        ) -> Box<Future<Item = $get_resp, Error = ApiError> + Send> {
+            let conn = self.db_pool.get().expect("db_pool error");
+            // No transaction for GET
+            let ret = match (|| {
+                let fcid = FatCatId::from_str(&id)?;
+                self.$get_handler(fcid, &conn)
+            })() {
+                Ok(entity) =>
+                    $get_resp::Found(entity),
+                Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) =>
+                    $get_resp::NotFound(ErrorResponse { message: format!("Not found: {}", id) }),
+                Err(Error(ErrorKind::MalformedExternalId(e), _)) =>
+                    $get_resp::BadRequest(ErrorResponse { message: e.to_string() }),
+                Err(e) => {
+                    error!("{}", e);
+                    $get_resp::BadRequest(ErrorResponse { message: e.to_string() })
+                },
+            };
+            Box::new(futures::done(Ok(ret)))
+        }
+    }
+}
+
 impl Api for Server {
     wrap_entity_handlers!(
         get_container,
@@ -359,26 +387,26 @@ impl Api for Server {
         String
     );
 
-    wrap_lookup_handler!(
+    wrap_fcid_handler!(
         get_release_files,
         get_release_files_handler,
-        GetReleaseFilesResponse,
-        id,
-        String
+        GetReleaseFilesResponse
     );
-    wrap_lookup_handler!(
+    wrap_fcid_handler!(
         get_work_releases,
         get_work_releases_handler,
-        GetWorkReleasesResponse,
-        id,
-        String
+        GetWorkReleasesResponse
     );
-    wrap_lookup_handler!(
+    wrap_fcid_handler!(
         get_creator_releases,
         get_creator_releases_handler,
-        GetCreatorReleasesResponse,
-        id,
-        String
+        GetCreatorReleasesResponse
+    );
+    wrap_fcid_handler!(get_editor, get_editor_handler, GetEditorResponse);
+    wrap_fcid_handler!(
+        get_editor_changelog,
+        get_editor_changelog_handler,
+        GetEditorChangelogResponse
     );
 
     fn accept_editgroup(
@@ -387,7 +415,10 @@ impl Api for Server {
         _context: &Context,
     ) -> Box<Future<Item = AcceptEditgroupResponse, Error = ApiError> + Send> {
         let conn = self.db_pool.get().expect("db_pool error");
-        let ret = match conn.transaction(|| self.accept_editgroup_handler(&id, &conn)) {
+        let ret = match conn.transaction(|| {
+            let id = FatCatId::from_str(&id)?;
+            self.accept_editgroup_handler(id, &conn)
+        }) {
             Ok(()) => AcceptEditgroupResponse::MergedSuccessfully(Success {
                 message: "horray!".to_string(),
             }),
@@ -414,9 +445,12 @@ impl Api for Server {
         _context: &Context,
     ) -> Box<Future<Item = GetEditgroupResponse, Error = ApiError> + Send> {
         let conn = self.db_pool.get().expect("db_pool error");
-        let ret = match conn.transaction(|| self.get_editgroup_handler(&id, &conn)) {
+        let ret = match conn.transaction(|| {
+            let id = FatCatId::from_str(&id)?;
+            self.get_editgroup_handler(id, &conn)
+        }) {
             Ok(entity) =>
-                GetEditgroupResponse::FoundEntity(entity),
+                GetEditgroupResponse::Found(entity),
             Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) =>
                 GetEditgroupResponse::NotFound(
                     ErrorResponse { message: format!("No such editgroup: {}", id) }),
@@ -434,7 +468,9 @@ impl Api for Server {
         _context: &Context,
     ) -> Box<Future<Item = CreateEditgroupResponse, Error = ApiError> + Send> {
         let conn = self.db_pool.get().expect("db_pool error");
-        let ret = match conn.transaction(|| self.create_editgroup_handler(entity, &conn)) {
+        let ret = match conn.transaction(||
+            self.create_editgroup_handler(entity, &conn)
+        ) {
             Ok(eg) =>
                 CreateEditgroupResponse::SuccessfullyCreated(eg),
             Err(e) =>
@@ -445,56 +481,6 @@ impl Api for Server {
         Box::new(futures::done(Ok(ret)))
     }
 
-    fn get_editor_changelog(
-        &self,
-        username: String,
-        _context: &Context,
-    ) -> Box<Future<Item = GetEditorChangelogResponse, Error = ApiError> + Send> {
-        let conn = self.db_pool.get().expect("db_pool error");
-        // No transaction for GET
-        let ret = match self.editor_changelog_get_handler(&username, &conn) {
-            Ok(entries) => GetEditorChangelogResponse::FoundMergedChanges(entries),
-            Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) => {
-                GetEditorChangelogResponse::NotFound(ErrorResponse {
-                    message: format!("No such editor: {}", username.clone()),
-                })
-            }
-            Err(e) => {
-                // TODO: dig in to error type here
-                error!("{}", e);
-                GetEditorChangelogResponse::GenericError(ErrorResponse {
-                    message: e.to_string(),
-                })
-            }
-        };
-        Box::new(futures::done(Ok(ret)))
-    }
-
-    fn get_editor(
-        &self,
-        username: String,
-        _context: &Context,
-    ) -> Box<Future<Item = GetEditorResponse, Error = ApiError> + Send> {
-        let conn = self.db_pool.get().expect("db_pool error");
-        // No transaction for GET
-        let ret = match self.get_editor_handler(&username, &conn) {
-            Ok(entity) => GetEditorResponse::FoundEditor(entity),
-            Err(Error(ErrorKind::Diesel(::diesel::result::Error::NotFound), _)) => {
-                GetEditorResponse::NotFound(ErrorResponse {
-                    message: format!("No such editor: {}", username.clone()),
-                })
-            }
-            Err(e) => {
-                // TODO: dig in to error type here
-                error!("{}", e);
-                GetEditorResponse::GenericError(ErrorResponse {
-                    message: e.to_string(),
-                })
-            }
-        };
-        Box::new(futures::done(Ok(ret)))
-    }
-
     fn get_changelog(
         &self,
         limit: Option<i64>,
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 58147139..57cc535c 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -22,10 +22,10 @@ extern crate regex;
 extern crate lazy_static;
 extern crate sha1;
 
+pub mod api_entity_crud;
 pub mod api_helpers;
 pub mod api_server;
 pub mod api_wrappers;
-pub mod api_entity_crud;
 pub mod database_models;
 pub mod database_schema;