aboutsummaryrefslogtreecommitdiffstats
path: root/rust/src
diff options
context:
space:
mode:
Diffstat (limited to 'rust/src')
-rw-r--r--rust/src/api_entity_crud.rs82
-rw-r--r--rust/src/api_helpers.rs35
-rw-r--r--rust/src/api_server.rs90
-rw-r--r--rust/src/api_wrappers.rs132
-rw-r--r--rust/src/lib.rs2
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;