WIP: Handle expected errors when creating tokens

Author: Nemo157

app/components/api-token-row.js

@@ -3,13 +3,35 @@ import Ember from 'ember';
 export default Ember.Component.extend({
     emptyName: Ember.computed.empty('api_token.name'),
     disableCreate: Ember.computed.or('api_token.isSaving', 'emptyName'),
+    serverError: null,
 
     actions: {
         saveToken() {
-            this.get('api_token').save();
+            this.get('api_token')
+                .save()
+                .then(() => this.set('serverError', null))
+                .catch(err => {
+                    let msg;
+                    if (err.errors && err.errors[0] && err.errors[0].detail) {
+                        msg = `An error occurred while saving this token, ${err.errors[0].detail}`;
+                    } else {
+                        msg = 'An unknown error occurred while saving this token';
+                    }
+                    this.set('serverError', msg);
+                });
         },
         revokeToken() {
-            this.get('api_token').destroyRecord();
+            this.get('api_token')
+                .destroyRecord()
+                .catch(err => {
+                    let msg;
+                    if (err.errors && err.errors[0] && err.errors[0].detail) {
+                        msg = `An error occurred while revoking this token, ${err.errors[0].detail}`;
+                    } else {
+                        msg = 'An unknown error occurred while revoking this token';
+                    }
+                    this.set('serverError', msg);
+                });
         },
     }
 });

app/styles/me.scss

@@ -142,4 +142,10 @@
         @include flex-direction(column);
         @include justify-content(stretch);
     }
+    .error {
+        border-top-width: 0px;
+        font-weight: bold;
+        color: rgb(216, 0, 41);
+        padding: 0px 10px 10px 20px;
+    }
 }

app/templates/components/api-token-row.hbs

@@ -53,6 +53,14 @@
     </div>
 </div>
 
+{{#if serverError}}
+    <div class='row error'>
+        <div>
+            {{ serverError }}
+        </div>
+    </div>
+{{/if}}
+
 {{#if api_token.token}}
     <div class='row new-token'>
         <div>

src/token.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use conduit::{Request, Response};
 use time::Timespec;
 use pg::GenericConnection;
@@ -7,7 +9,7 @@ use rustc_serialize::json;
 
 use db::RequestTransaction;
 use user::RequestUser;
-use util::{RequestUtils, CargoResult, internal, ChainError, human, read_fill};
+use util::{RequestUtils, CargoError, CargoResult, internal, ChainError, human, read_fill};
 use Model;
 
 /// The model representing a row in the `api_tokens` database table.
@@ -136,6 +138,28 @@ impl Model for ApiToken {
     fn table_name(_: Option<ApiToken>) -> &'static str { "api_tokens" }
 }
 
+struct BadRequest<T: CargoError>(T);
+
+impl<T: CargoError> CargoError for BadRequest<T> {
+    fn description(&self) -> &str { self.0.description() }
+    fn response(&self) -> Option<Response> {
+        self.0.response().map(|mut response| {
+            response.status = (400, "Bad Request");
+            response
+        })
+    }
+}
+
+impl<T: CargoError> fmt::Display for BadRequest<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "Bad Request: {}", self.0)
+    }
+}
+
+fn bad_request<T: CargoError>(error: T) -> Box<CargoError> {
+    Box::new(BadRequest(error))
+}
+
 /// Handles the `GET /me/tokens` route.
 pub fn list(req: &mut Request) -> CargoResult<Response> {
     let tokens = ApiToken::find_for_user(req.tx()?, req.user()?.id)?
@@ -155,31 +179,31 @@ pub fn new(req: &mut Request) -> CargoResult<Response> {
     })?;
 
     if length > max_post_size {
-        return Err(human(&format_args!("max post size is: {}", max_post_size)));
+        return Err(bad_request(human(&format_args!("max post size is: {}", max_post_size))));
     }
 
     let mut json = vec![0; length as usize];
     read_fill(req.body(), &mut json)?;
 
     let json = String::from_utf8(json).map_err(|_| {
-        human("json body was not valid utf-8")
+        bad_request(human("json body was not valid utf-8"))
     })?;
 
     let new: NewApiTokenRequest = json::decode(&json).map_err(|e| {
-        human(&format_args!("invalid new token request: {:?}", e))
+        bad_request(human(&format_args!("invalid new token request: {:?}", e)))
     })?;
 
     let name = &new.api_token.name;
     if name.len() < 1 {
-        return Err(human("name must have a value"));
+        return Err(bad_request(human("name must have a value")));
     }
 
     let user = req.user()?;
 
     let max_token_per_user = 500;
     let count = ApiToken::count_for_user(req.tx()?, user.id)?;
     if count >= max_token_per_user {
-        return Err(human(&format_args!("maximum tokens per user is: {}", max_token_per_user)));
+        return Err(bad_request(human(&format_args!("maximum tokens per user is: {}", max_token_per_user))));
     }
 
     let api_token = ApiToken::insert(req.tx()?, user.id, name)?;
@@ -192,7 +216,9 @@ pub fn new(req: &mut Request) -> CargoResult<Response> {
 /// Handles the `DELETE /me/tokens/:id` route.
 pub fn revoke(req: &mut Request) -> CargoResult<Response> {
     let user = req.user()?;
-    let id = req.params()["id"].parse()?;
+    let id = req.params()["id"].parse().map_err(|e| {
+        bad_request(human(&format_args!("invalid token id: {:?}", e)))
+    })?;
 
     ApiToken::delete(req.tx()?, user.id, id)?;