Make sure the inputs are always in the same case (PascalCase, which is what upstream seems to prefer most of the time)

src/api/core/accounts.rs

@@ -3,7 +3,7 @@ use rocket_contrib::Json;
 use db::DbConn;
 use db::models::*;
 
-use api::{PasswordData, JsonResult, EmptyResult};
+use api::{PasswordData, JsonResult, EmptyResult, JsonUpcase};
 use auth::Headers;
 
 use CONFIG;
@@ -11,12 +11,12 @@ use CONFIG;
 #[derive(Deserialize, Debug)]
 #[allow(non_snake_case)]
 struct RegisterData {
-    email: String,
+    Email: String,
-    key: String,
+    Key: String,
-    keys: Option<KeysData>,
+    Keys: Option<KeysData>,
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    masterPasswordHint: Option<String>,
+    MasterPasswordHint: Option<String>,
-    name: Option<String>,
+    Name: Option<String>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -27,29 +27,29 @@ struct KeysData {
 }
 
 #[post("/accounts/register", data = "<data>")]
-fn register(data: Json<RegisterData>, conn: DbConn) -> EmptyResult {
+fn register(data: JsonUpcase<RegisterData>, conn: DbConn) -> EmptyResult {
-    let data: RegisterData = data.into_inner();
+    let data: RegisterData = data.into_inner().data;
 
     if !CONFIG.signups_allowed {
         err!(format!("Signups not allowed"))
     }
 
-    if let Some(_) = User::find_by_mail(&data.email, &conn) {
+    if let Some(_) = User::find_by_mail(&data.Email, &conn) {
         err!("Email already exists")
     }
 
-    let mut user = User::new(data.email, data.key, data.masterPasswordHash);
+    let mut user = User::new(data.Email, data.Key, data.MasterPasswordHash);
 
     // Add extra fields if present
-    if let Some(name) = data.name {
+    if let Some(name) = data.Name {
         user.name = name;
     }
 
-    if let Some(hint) = data.masterPasswordHint {
+    if let Some(hint) = data.MasterPasswordHint {
         user.password_hint = Some(hint);
     }
 
-    if let Some(keys) = data.keys {
+    if let Some(keys) = data.Keys {
         user.private_key = Some(keys.encryptedPrivateKey);
         user.public_key = Some(keys.publicKey);
     }
@@ -79,8 +79,8 @@ fn get_public_keys(uuid: String, _headers: Headers, conn: DbConn) -> JsonResult
 }
 
 #[post("/accounts/keys", data = "<data>")]
-fn post_keys(data: Json<KeysData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_keys(data: JsonUpcase<KeysData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: KeysData = data.into_inner();
+    let data: KeysData = data.into_inner().data;
 
     let mut user = headers.user;
 
@@ -95,33 +95,33 @@ fn post_keys(data: Json<KeysData>, headers: Headers, conn: DbConn) -> JsonResult
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct ChangePassData {
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    newMasterPasswordHash: String,
+    NewMasterPasswordHash: String,
-    key: String,
+    Key: String,
 }
 
 #[post("/accounts/password", data = "<data>")]
-fn post_password(data: Json<ChangePassData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_password(data: JsonUpcase<ChangePassData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: ChangePassData = data.into_inner();
+    let data: ChangePassData = data.into_inner().data;
     let mut user = headers.user;
 
-    if !user.check_valid_password(&data.masterPasswordHash) {
+    if !user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password")
     }
 
-    user.set_password(&data.newMasterPasswordHash);
+    user.set_password(&data.NewMasterPasswordHash);
-    user.key = data.key;
+    user.key = data.Key;
     user.save(&conn);
 
     Ok(())
 }
 
 #[post("/accounts/security-stamp", data = "<data>")]
-fn post_sstamp(data: Json<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_sstamp(data: JsonUpcase<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
     let mut user = headers.user;
 
-    if !user.check_valid_password(&data.masterPasswordHash) {
+    if !user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password")
     }
 
@@ -134,36 +134,36 @@ fn post_sstamp(data: Json<PasswordData>, headers: Headers, conn: DbConn) -> Empt
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct ChangeEmailData {
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    newEmail: String,
+    NewEmail: String,
 }
 
 
 #[post("/accounts/email-token", data = "<data>")]
-fn post_email(data: Json<ChangeEmailData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_email(data: JsonUpcase<ChangeEmailData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: ChangeEmailData = data.into_inner();
+    let data: ChangeEmailData = data.into_inner().data;
     let mut user = headers.user;
 
-    if !user.check_valid_password(&data.masterPasswordHash) {
+    if !user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password")
     }
 
-    if User::find_by_mail(&data.newEmail, &conn).is_some() {
+    if User::find_by_mail(&data.NewEmail, &conn).is_some() {
         err!("Email already in use");
     }
 
-    user.email = data.newEmail;
+    user.email = data.NewEmail;
     user.save(&conn);
 
     Ok(())
 }
 
 #[post("/accounts/delete", data = "<data>")]
-fn delete_account(data: Json<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn delete_account(data: JsonUpcase<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
     let user = headers.user;
 
-    if !user.check_valid_password(&data.masterPasswordHash) {
+    if !user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password")
     }
 

src/api/core/ciphers.rs

@@ -17,7 +17,7 @@ use db::models::*;
 use util;
 use crypto;
 
-use api::{self, PasswordData, JsonResult, EmptyResult};
+use api::{self, PasswordData, JsonResult, EmptyResult, JsonUpcase};
 use auth::Headers;
 
 use CONFIG;
@@ -85,9 +85,9 @@ fn get_cipher_details(uuid: String, headers: Headers, conn: DbConn) -> JsonResul
 #[allow(non_snake_case)]
 struct CipherData {
     // Folder id is not included in import
-    folderId: Option<String>,
+    FolderId: Option<String>,
     // TODO: Some of these might appear all the time, no need for Option
-    organizationId: Option<String>,
+    OrganizationId: Option<String>,
 
     /*
     Login = 1,
@@ -95,32 +95,31 @@ struct CipherData {
     Card = 3,
     Identity = 4
     */
-    #[serde(rename = "type")]
+    Type: i32, // TODO: Change this to NumberOrString
-    type_: i32,
+    Name: String,
-    name: String,
+    Notes: Option<String>,
-    notes: Option<String>,
+    Fields: Option<Value>,
-    fields: Option<Value>,
 
     // Only one of these should exist, depending on type
-    login: Option<Value>,
+    Login: Option<Value>,
-    secureNote: Option<Value>,
+    SecureNote: Option<Value>,
-    card: Option<Value>,
+    Card: Option<Value>,
-    identity: Option<Value>,
+    Identity: Option<Value>,
 
-    favorite: Option<bool>,
+    Favorite: Option<bool>,
 }
 
 #[post("/ciphers/admin", data = "<data>")]
-fn post_ciphers_admin(data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_ciphers_admin(data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
     // TODO: Implement this correctly
     post_ciphers(data, headers, conn)
 }
 
 #[post("/ciphers", data = "<data>")]
-fn post_ciphers(data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_ciphers(data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: CipherData = data.into_inner();
+    let data: CipherData = data.into_inner().data;
 
-    let mut cipher = Cipher::new(data.type_, data.name.clone());
+    let mut cipher = Cipher::new(data.Type, data.Name.clone());
     update_cipher_from_data(&mut cipher, data, &headers, true, &conn)?;
 
     Ok(Json(cipher.to_json(&headers.host, &headers.user.uuid, &conn)))
@@ -128,7 +127,7 @@ fn post_ciphers(data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonR
 
 fn update_cipher_from_data(cipher: &mut Cipher, data: CipherData, headers: &Headers, is_new_or_shared: bool, conn: &DbConn) -> EmptyResult {
     if is_new_or_shared {
-        if let Some(org_id) = data.organizationId {
+        if let Some(org_id) = data.OrganizationId {
             match UserOrganization::find_by_user_and_org(&headers.user.uuid, &org_id, &conn) {
                 None => err!("You don't have permission to add item to organization"),
                 Some(org_user) => if org_user.has_full_access() {
@@ -143,7 +142,7 @@ fn update_cipher_from_data(cipher: &mut Cipher, data: CipherData, headers: &Head
         }
     }
 
-    if let Some(ref folder_id) = data.folderId {
+    if let Some(ref folder_id) = data.FolderId {
         match Folder::find_by_uuid(folder_id, conn) {
             Some(folder) => {
                 if folder.user_uuid != headers.user.uuid {
@@ -154,7 +153,7 @@ fn update_cipher_from_data(cipher: &mut Cipher, data: CipherData, headers: &Head
         }
     }
 
-    let uppercase_fields = data.fields.map(|f| {
+    let uppercase_fields = data.Fields.map(|f| {
         let mut value = json!({});
         // Copy every field object and change the names to the correct case
         copy_values(&f, &mut value);
@@ -165,18 +164,18 @@ fn update_cipher_from_data(cipher: &mut Cipher, data: CipherData, headers: &Head
     // To remove backwards compatibility, just create an empty values object,
     // and remove the compat code from cipher::to_json
     let mut values = json!({
-        "Name": data.name,
+        "Name": data.Name,
-        "Notes": data.notes
+        "Notes": data.Notes
     });
 
     values["Fields"] = uppercase_fields.clone().unwrap_or(Value::Null);
     // TODO: ******* Backwards compat end **********
 
-    let type_data_opt = match data.type_ {
+    let type_data_opt = match data.Type {
-        1 => data.login,
+        1 => data.Login,
-        2 => data.secureNote,
+        2 => data.SecureNote,
-        3 => data.card,
+        3 => data.Card,
-        4 => data.identity,
+        4 => data.Identity,
         _ => err!("Invalid type")
     };
 
@@ -188,15 +187,15 @@ fn update_cipher_from_data(cipher: &mut Cipher, data: CipherData, headers: &Head
     // Copy the type data and change the names to the correct case
     copy_values(&type_data, &mut values);
 
-    cipher.favorite = data.favorite.unwrap_or(false);
+    cipher.favorite = data.Favorite.unwrap_or(false);
-    cipher.name = data.name;
+    cipher.name = data.Name;
-    cipher.notes = data.notes;
+    cipher.notes = data.Notes;
     cipher.fields = uppercase_fields.map(|f| f.to_string());
     cipher.data = values.to_string();
 
     cipher.save(&conn);
 
-    if cipher.move_to_folder(data.folderId, &headers.user.uuid, &conn).is_err() {
+    if cipher.move_to_folder(data.FolderId, &headers.user.uuid, &conn).is_err() {
         err!("Error saving the folder information")
     }
 
@@ -225,9 +224,9 @@ use super::folders::FolderData;
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct ImportData {
-    ciphers: Vec<CipherData>,
+    Ciphers: Vec<CipherData>,
-    folders: Vec<FolderData>,
+    Folders: Vec<FolderData>,
-    folderRelationships: Vec<RelationsData>,
+    FolderRelationships: Vec<RelationsData>,
 }
 
 #[derive(Deserialize)]
@@ -241,12 +240,12 @@ struct RelationsData {
 
 
 #[post("/ciphers/import", data = "<data>")]
-fn post_ciphers_import(data: Json<ImportData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_ciphers_import(data: JsonUpcase<ImportData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: ImportData = data.into_inner();
+    let data: ImportData = data.into_inner().data;
 
     // Read and create the folders
-    let folders: Vec<_> = data.folders.into_iter().map(|folder| {
+    let folders: Vec<_> = data.Folders.into_iter().map(|folder| {
-        let mut folder = Folder::new(headers.user.uuid.clone(), folder.name);
+        let mut folder = Folder::new(headers.user.uuid.clone(), folder.Name);
         folder.save(&conn);
         folder
     }).collect();
@@ -255,17 +254,17 @@ fn post_ciphers_import(data: Json<ImportData>, headers: Headers, conn: DbConn) -
     use std::collections::HashMap;
     let mut relations_map = HashMap::new();
 
-    for relation in data.folderRelationships {
+    for relation in data.FolderRelationships {
         relations_map.insert(relation.key, relation.value);
     }
 
     // Read and create the ciphers
     let mut index = 0;
-    for cipher_data in data.ciphers {
+    for cipher_data in data.Ciphers {
         let folder_uuid = relations_map.get(&index)
             .map(|i| folders[*i as usize].uuid.clone());
 
-        let mut cipher = Cipher::new(cipher_data.type_, cipher_data.name.clone());
+        let mut cipher = Cipher::new(cipher_data.Type, cipher_data.Name.clone());
         update_cipher_from_data(&mut cipher, cipher_data, &headers, true, &conn)?;
 
         cipher.move_to_folder(folder_uuid, &headers.user.uuid.clone(), &conn).ok();
@@ -277,19 +276,19 @@ fn post_ciphers_import(data: Json<ImportData>, headers: Headers, conn: DbConn) -
 }
 
 #[post("/ciphers/<uuid>/admin", data = "<data>")]
-fn post_cipher_admin(uuid: String, data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_cipher_admin(uuid: String, data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
     // TODO: Implement this correctly
     post_cipher(uuid, data, headers, conn)
 }
 
 #[post("/ciphers/<uuid>", data = "<data>")]
-fn post_cipher(uuid: String, data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_cipher(uuid: String, data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
     put_cipher(uuid, data, headers, conn)
 }
 
 #[put("/ciphers/<uuid>", data = "<data>")]
-fn put_cipher(uuid: String, data: Json<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn put_cipher(uuid: String, data: JsonUpcase<CipherData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: CipherData = data.into_inner();
+    let data: CipherData = data.into_inner().data;
 
     let mut cipher = match Cipher::find_by_uuid(&uuid, &conn) {
         Some(cipher) => cipher,
@@ -308,17 +307,17 @@ fn put_cipher(uuid: String, data: Json<CipherData>, headers: Headers, conn: DbCo
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct CollectionsAdminData {
-    collectionIds: Vec<String>,
+    CollectionIds: Vec<String>,
 }
 
 #[post("/ciphers/<uuid>/collections", data = "<data>")]
-fn post_collections_update(uuid: String, data: Json<CollectionsAdminData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_collections_update(uuid: String, data: JsonUpcase<CollectionsAdminData>, headers: Headers, conn: DbConn) -> EmptyResult {
     post_collections_admin(uuid, data, headers, conn)
 }
 
 #[post("/ciphers/<uuid>/collections-admin", data = "<data>")]
-fn post_collections_admin(uuid: String, data: Json<CollectionsAdminData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_collections_admin(uuid: String, data: JsonUpcase<CollectionsAdminData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: CollectionsAdminData = data.into_inner();
+    let data: CollectionsAdminData = data.into_inner().data;
 
     let cipher = match Cipher::find_by_uuid(&uuid, &conn) {
         Some(cipher) => cipher,
@@ -329,7 +328,7 @@ fn post_collections_admin(uuid: String, data: Json<CollectionsAdminData>, header
         err!("Cipher is not write accessible")
     }
 
-    let posted_collections: HashSet<String> = data.collectionIds.iter().cloned().collect();
+    let posted_collections: HashSet<String> = data.CollectionIds.iter().cloned().collect();
     let current_collections: HashSet<String> = cipher.get_collections(&headers.user.uuid ,&conn).iter().cloned().collect();
 
     for collection in posted_collections.symmetric_difference(&current_collections) {
@@ -355,13 +354,14 @@ fn post_collections_admin(uuid: String, data: Json<CollectionsAdminData>, header
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct ShareCipherData {
-    cipher: CipherData,
+    #[serde(deserialize_with = "util::upcase_deserialize")]
-    collectionIds: Vec<String>,
+    Cipher: CipherData,
+    CollectionIds: Vec<String>,
 }
 
 #[post("/ciphers/<uuid>/share", data = "<data>")]
-fn post_cipher_share(uuid: String, data: Json<ShareCipherData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_cipher_share(uuid: String, data: JsonUpcase<ShareCipherData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: ShareCipherData = data.into_inner();
+    let data: ShareCipherData = data.into_inner().data;
 
     let mut cipher = match Cipher::find_by_uuid(&uuid, &conn) {
         Some(cipher) => {
@@ -374,11 +374,11 @@ fn post_cipher_share(uuid: String, data: Json<ShareCipherData>, headers: Headers
         None => err!("Cipher doesn't exist")
     };
 
-    match data.cipher.organizationId {
+    match data.Cipher.OrganizationId {
         None => err!("Organization id not provided"),
         Some(_) => {
-            update_cipher_from_data(&mut cipher, data.cipher, &headers, true, &conn)?;
+            update_cipher_from_data(&mut cipher, data.Cipher, &headers, true, &conn)?;
-            for collection in data.collectionIds.iter() {
+            for collection in data.CollectionIds.iter() {
                 match Collection::find_by_uuid(&collection, &conn) {
                     None => err!("Invalid collection ID provided"),
                     Some(collection) => {
@@ -478,10 +478,10 @@ fn delete_cipher(uuid: String, headers: Headers, conn: DbConn) -> EmptyResult {
 }
 
 #[post("/ciphers/delete", data = "<data>")]
-fn delete_cipher_selected(data: Json<Value>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn delete_cipher_selected(data: JsonUpcase<Value>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: Value = data.into_inner();
+    let data: Value = data.into_inner().data;
 
-    let uuids = match data.get("ids") {
+    let uuids = match data.get("Ids") {
         Some(ids) => match ids.as_array() {
             Some(ids) => ids.iter().filter_map(|uuid| { uuid.as_str() }),
             None => err!("Posted ids field is not an array")
@@ -499,8 +499,10 @@ fn delete_cipher_selected(data: Json<Value>, headers: Headers, conn: DbConn) ->
 }
 
 #[post("/ciphers/move", data = "<data>")]
-fn move_cipher_selected(data: Json<Value>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn move_cipher_selected(data: JsonUpcase<Value>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let folder_id = match data.get("folderId") {
+    let data = data.into_inner().data;
+
+    let folder_id = match data.get("FolderId") {
         Some(folder_id) => {
             match folder_id.as_str() {
                 Some(folder_id) => {
@@ -520,7 +522,7 @@ fn move_cipher_selected(data: Json<Value>, headers: Headers, conn: DbConn) -> Em
         None => None
     };
 
-    let uuids = match data.get("ids") {
+    let uuids = match data.get("Ids") {
         Some(ids) => match ids.as_array() {
             Some(ids) => ids.iter().filter_map(|uuid| { uuid.as_str() }),
             None => err!("Posted ids field is not an array")
@@ -549,9 +551,9 @@ fn move_cipher_selected(data: Json<Value>, headers: Headers, conn: DbConn) -> Em
 }
 
 #[post("/ciphers/purge", data = "<data>")]
-fn delete_all(data: Json<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn delete_all(data: JsonUpcase<PasswordData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
-    let password_hash = data.masterPasswordHash;
+    let password_hash = data.MasterPasswordHash;
 
     let user = headers.user;
 

src/api/core/folders.rs

@@ -3,7 +3,7 @@ use rocket_contrib::{Json, Value};
 use db::DbConn;
 use db::models::*;
 
-use api::{JsonResult, EmptyResult};
+use api::{JsonResult, EmptyResult, JsonUpcase};
 use auth::Headers;
 
 #[get("/folders")]
@@ -33,15 +33,17 @@ fn get_folder(uuid: String, headers: Headers, conn: DbConn) -> JsonResult {
 }
 
 #[derive(Deserialize)]
+#[allow(non_snake_case)]
+
 pub struct FolderData {
-    pub name: String
+    pub Name: String
 }
 
 #[post("/folders", data = "<data>")]
-fn post_folders(data: Json<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_folders(data: JsonUpcase<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: FolderData = data.into_inner();
+    let data: FolderData = data.into_inner().data;
 
-    let mut folder = Folder::new(headers.user.uuid.clone(), data.name);
+    let mut folder = Folder::new(headers.user.uuid.clone(), data.Name);
 
     folder.save(&conn);
 
@@ -49,13 +51,13 @@ fn post_folders(data: Json<FolderData>, headers: Headers, conn: DbConn) -> JsonR
 }
 
 #[post("/folders/<uuid>", data = "<data>")]
-fn post_folder(uuid: String, data: Json<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn post_folder(uuid: String, data: JsonUpcase<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
     put_folder(uuid, data, headers, conn)
 }
 
 #[put("/folders/<uuid>", data = "<data>")]
-fn put_folder(uuid: String, data: Json<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn put_folder(uuid: String, data: JsonUpcase<FolderData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: FolderData = data.into_inner();
+    let data: FolderData = data.into_inner().data;
 
     let mut folder = match Folder::find_by_uuid(&uuid, &conn) {
         Some(folder) => folder,
@@ -66,7 +68,7 @@ fn put_folder(uuid: String, data: Json<FolderData>, headers: Headers, conn: DbCo
         err!("Folder belongs to another user")
     }
 
-    folder.name = data.name;
+    folder.name = data.Name;
 
     folder.save(&conn);
 

src/api/core/mod.rs

@@ -100,7 +100,7 @@ use rocket_contrib::Json;
 
 use db::DbConn;
 
-use api::{JsonResult, EmptyResult};
+use api::{JsonResult, EmptyResult, JsonUpcase};
 use auth::Headers;
 
 #[put("/devices/identifier/<uuid>/clear-token")]
@@ -155,8 +155,8 @@ struct EquivDomainData {
 }
 
 #[post("/settings/domains", data = "<data>")]
-fn post_eq_domains(data: Json<EquivDomainData>, headers: Headers, conn: DbConn) -> EmptyResult {
+fn post_eq_domains(data: JsonUpcase<EquivDomainData>, headers: Headers, conn: DbConn) -> EmptyResult {
-    let data: EquivDomainData = data.into_inner();
+    let data: EquivDomainData = data.into_inner().data;
 
     let excluded_globals = data.ExcludedGlobalEquivalentDomains.unwrap_or(Vec::new());
     let equivalent_domains = data.EquivalentDomains.unwrap_or(Vec::new());

src/api/core/organizations.rs

@@ -5,45 +5,45 @@ use rocket_contrib::{Json, Value};
 use db::DbConn;
 use db::models::*;
 
-use api::{PasswordData, JsonResult, EmptyResult, NumberOrString};
+use api::{PasswordData, JsonResult, EmptyResult, NumberOrString, JsonUpcase};
 use auth::{Headers, AdminHeaders, OwnerHeaders};
 
 
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct OrgData {
-    billingEmail: String,
+    BillingEmail: String,
-    collectionName: String,
+    CollectionName: String,
-    key: String,
+    Key: String,
-    name: String,
+    Name: String,
-    #[serde(rename = "planType")]
+    #[serde(rename = "PlanType")]
-    _planType: String, // Ignored, always use the same plan
+    _PlanType: String, // Ignored, always use the same plan
 }
 
 #[derive(Deserialize, Debug)]
 #[allow(non_snake_case)]
 struct OrganizationUpdateData {
-    billingEmail: String,
+    BillingEmail: String,
-    name: String,
+    Name: String,
 }
 
 #[derive(Deserialize, Debug)]
 #[allow(non_snake_case)]
 struct NewCollectionData {
-    name: String,
+    Name: String,
 }
 
 #[post("/organizations", data = "<data>")]
-fn create_organization(headers: Headers, data: Json<OrgData>, conn: DbConn) -> JsonResult {
+fn create_organization(headers: Headers, data: JsonUpcase<OrgData>, conn: DbConn) -> JsonResult {
-    let data: OrgData = data.into_inner();
+    let data: OrgData = data.into_inner().data;
 
-    let mut org = Organization::new(data.name, data.billingEmail);
+    let mut org = Organization::new(data.Name, data.BillingEmail);
     let mut user_org = UserOrganization::new(
         headers.user.uuid.clone(), org.uuid.clone());
     let mut collection = Collection::new(
-        org.uuid.clone(), data.collectionName);
+        org.uuid.clone(), data.CollectionName);
 
-    user_org.key = data.key;
+    user_org.key = data.Key;
     user_org.access_all = true;
     user_org.type_ = UserOrgType::Owner as i32;
     user_org.status = UserOrgStatus::Confirmed as i32;
@@ -56,9 +56,9 @@ fn create_organization(headers: Headers, data: Json<OrgData>, conn: DbConn) -> J
 }
 
 #[post("/organizations/<org_id>/delete", data = "<data>")]
-fn delete_organization(org_id: String, data: Json<PasswordData>, headers: OwnerHeaders, conn: DbConn) -> EmptyResult {
+fn delete_organization(org_id: String, data: JsonUpcase<PasswordData>, headers: OwnerHeaders, conn: DbConn) -> EmptyResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
-    let password_hash = data.masterPasswordHash;
+    let password_hash = data.MasterPasswordHash;
 
     if !headers.user.check_valid_password(&password_hash) {
         err!("Invalid password")
@@ -82,16 +82,16 @@ fn get_organization(org_id: String, _headers: OwnerHeaders, conn: DbConn) -> Jso
 }
 
 #[post("/organizations/<org_id>", data = "<data>")]
-fn post_organization(org_id: String, _headers: OwnerHeaders, data: Json<OrganizationUpdateData>, conn: DbConn) -> JsonResult {
+fn post_organization(org_id: String, _headers: OwnerHeaders, data: JsonUpcase<OrganizationUpdateData>, conn: DbConn) -> JsonResult {
-    let data: OrganizationUpdateData = data.into_inner();
+    let data: OrganizationUpdateData = data.into_inner().data;
 
     let mut org = match Organization::find_by_uuid(&org_id, &conn) {
         Some(organization) => organization,
         None => err!("Can't find organization details")
     };
 
-    org.name = data.name;
+    org.name = data.Name;
-    org.billing_email = data.billingEmail;
+    org.billing_email = data.BillingEmail;
     org.save(&conn);
 
     Ok(Json(org.to_json()))
@@ -126,15 +126,15 @@ fn get_org_collections(org_id: String, _headers: AdminHeaders, conn: DbConn) ->
 }
 
 #[post("/organizations/<org_id>/collections", data = "<data>")]
-fn post_organization_collections(org_id: String, _headers: AdminHeaders, data: Json<NewCollectionData>, conn: DbConn) -> JsonResult {
+fn post_organization_collections(org_id: String, _headers: AdminHeaders, data: JsonUpcase<NewCollectionData>, conn: DbConn) -> JsonResult {
-    let data: NewCollectionData = data.into_inner();
+    let data: NewCollectionData = data.into_inner().data;
 
     let org = match Organization::find_by_uuid(&org_id, &conn) {
         Some(organization) => organization,
         None => err!("Can't find organization details")
     };
 
-    let mut collection = Collection::new(org.uuid.clone(), data.name);
+    let mut collection = Collection::new(org.uuid.clone(), data.Name);
 
     collection.save(&conn);
 
@@ -142,8 +142,8 @@ fn post_organization_collections(org_id: String, _headers: AdminHeaders, data: J
 }
 
 #[post("/organizations/<org_id>/collections/<col_id>", data = "<data>")]
-fn post_organization_collection_update(org_id: String, col_id: String, _headers: AdminHeaders, data: Json<NewCollectionData>, conn: DbConn) -> JsonResult {
+fn post_organization_collection_update(org_id: String, col_id: String, _headers: AdminHeaders, data: JsonUpcase<NewCollectionData>, conn: DbConn) -> JsonResult {
-    let data: NewCollectionData = data.into_inner();
+    let data: NewCollectionData = data.into_inner().data;
 
     let org = match Organization::find_by_uuid(&org_id, &conn) {
         Some(organization) => organization,
@@ -159,7 +159,7 @@ fn post_organization_collection_update(org_id: String, col_id: String, _headers:
         err!("Collection is not owned by organization");
     }
 
-    collection.name = data.name.clone();
+    collection.name = data.Name.clone();
     collection.save(&conn);
 
     Ok(Json(collection.to_json()))
@@ -195,13 +195,13 @@ fn post_organization_collection_delete_user(org_id: String, col_id: String, org_
 #[derive(Deserialize, Debug)]
 #[allow(non_snake_case)]
 struct DeleteCollectionData {
-    id: String,
+    Id: String,
-    orgId: String,
+    OrgId: String,
 }
 
 #[post("/organizations/<org_id>/collections/<col_id>/delete", data = "<data>")]
-fn post_organization_collection_delete(org_id: String, col_id: String, _headers: AdminHeaders, data: Json<DeleteCollectionData>, conn: DbConn) -> EmptyResult {
+fn post_organization_collection_delete(org_id: String, col_id: String, _headers: AdminHeaders, data: JsonUpcase<DeleteCollectionData>, conn: DbConn) -> EmptyResult {
-    let _data: DeleteCollectionData = data.into_inner();
+    let _data: DeleteCollectionData = data.into_inner().data;
 
     match Collection::find_by_uuid(&col_id, &conn) {
         None => err!("Collection not found"),
@@ -295,18 +295,17 @@ struct CollectionData {
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct InviteData {
-    emails: Vec<String>,
+    Emails: Vec<String>,
-    #[serde(rename = "type")]
+    Type: NumberOrString,
-    type_: NumberOrString,
+    Collections: Vec<CollectionData>,
-    collections: Vec<CollectionData>,
+    AccessAll: Option<bool>,
-    accessAll: Option<bool>,
 }
 
 #[post("/organizations/<org_id>/users/invite", data = "<data>")]
-fn send_invite(org_id: String, data: Json<InviteData>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
+fn send_invite(org_id: String, data: JsonUpcase<InviteData>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
-    let data: InviteData = data.into_inner();
+    let data: InviteData = data.into_inner().data;
 
-    let new_type = match UserOrgType::from_str(&data.type_.to_string()) {
+    let new_type = match UserOrgType::from_str(&data.Type.to_string()) {
         Some(new_type) => new_type as i32,
         None => err!("Invalid type")
     };
@@ -316,7 +315,7 @@ fn send_invite(org_id: String, data: Json<InviteData>, headers: AdminHeaders, co
         err!("Only Owners can invite Admins or Owners")
     }
 
-    for user_opt in data.emails.iter().map(|email| User::find_by_mail(email, &conn)) {
+    for user_opt in data.Emails.iter().map(|email| User::find_by_mail(email, &conn)) {
         match user_opt {
             None => err!("User email does not exist"),
             Some(user) => {
@@ -326,13 +325,13 @@ fn send_invite(org_id: String, data: Json<InviteData>, headers: AdminHeaders, co
                 }
 
                 let mut new_user = UserOrganization::new(user.uuid.clone(), org_id.clone());
-                let access_all = data.accessAll.unwrap_or(false);
+                let access_all = data.AccessAll.unwrap_or(false);
                 new_user.access_all = access_all;
                 new_user.type_ = new_type;
 
                 // If no accessAll, add the collections received
                 if !access_all {
-                    for col in data.collections.iter() {
+                    for col in data.Collections.iter() {
                         match Collection::find_by_uuid_and_org(&col.id, &org_id, &conn) {
                             None => err!("Collection not found in Organization"),
                             Some(collection) => {
@@ -354,7 +353,9 @@ fn send_invite(org_id: String, data: Json<InviteData>, headers: AdminHeaders, co
 }
 
 #[post("/organizations/<org_id>/users/<user_id>/confirm", data = "<data>")]
-fn confirm_invite(org_id: String, user_id: String, data: Json<Value>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
+fn confirm_invite(org_id: String, user_id: String, data: JsonUpcase<Value>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
+    let data = data.into_inner().data;
+
     let mut user_to_confirm = match UserOrganization::find_by_uuid(&user_id, &conn) {
         Some(user) => user,
         None => err!("Failed to find user membership")
@@ -401,17 +402,16 @@ fn get_user(org_id: String, user_id: String, _headers: AdminHeaders, conn: DbCon
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct EditUserData {
-    #[serde(rename = "type")]
+    Type: NumberOrString,
-    type_: NumberOrString,
+    Collections: Vec<CollectionData>,
-    collections: Vec<CollectionData>,
+    AccessAll: bool,
-    accessAll: bool,
 }
 
 #[post("/organizations/<org_id>/users/<user_id>", data = "<data>", rank = 1)]
-fn edit_user(org_id: String, user_id: String, data: Json<EditUserData>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
+fn edit_user(org_id: String, user_id: String, data: JsonUpcase<EditUserData>, headers: AdminHeaders, conn: DbConn) -> EmptyResult {
-    let data: EditUserData = data.into_inner();
+    let data: EditUserData = data.into_inner().data;
 
-    let new_type = match UserOrgType::from_str(&data.type_.to_string()) {
+    let new_type = match UserOrgType::from_str(&data.Type.to_string()) {
         Some(new_type) => new_type as i32,
         None => err!("Invalid type")
     };
@@ -444,7 +444,7 @@ fn edit_user(org_id: String, user_id: String, data: Json<EditUserData>, headers:
         }
     }
 
-    user_to_edit.access_all = data.accessAll;
+    user_to_edit.access_all = data.AccessAll;
     user_to_edit.type_ = new_type;
 
     // Delete all the odd collections
@@ -456,8 +456,8 @@ fn edit_user(org_id: String, user_id: String, data: Json<EditUserData>, headers:
     }
 
     // If no accessAll, add the collections received
-    if !data.accessAll {
+    if !data.AccessAll {
-        for col in data.collections.iter() {
+        for col in data.Collections.iter() {
             match Collection::find_by_uuid_and_org(&col.id, &org_id, &conn) {
                 None => err!("Collection not found in Organization"),
                 Some(collection) => {

src/api/core/two_factor.rs

@@ -6,7 +6,7 @@ use db::DbConn;
 
 use crypto;
 
-use api::{PasswordData, JsonResult, NumberOrString};
+use api::{PasswordData, JsonResult, NumberOrString, JsonUpcase};
 use auth::Headers;
 
 #[get("/two-factor")]
@@ -28,10 +28,10 @@ fn get_twofactor(headers: Headers) -> JsonResult {
 }
 
 #[post("/two-factor/get-recover", data = "<data>")]
-fn get_recover(data: Json<PasswordData>, headers: Headers) -> JsonResult {
+fn get_recover(data: JsonUpcase<PasswordData>, headers: Headers) -> JsonResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
 
-    if !headers.user.check_valid_password(&data.masterPasswordHash) {
+    if !headers.user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password");
     }
 
@@ -44,30 +44,30 @@ fn get_recover(data: Json<PasswordData>, headers: Headers) -> JsonResult {
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct RecoverTwoFactor {
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    email: String,
+    Email: String,
-    recoveryCode: String,
+    RecoveryCode: String,
 }
 
 #[post("/two-factor/recover", data = "<data>")]
-fn recover(data: Json<RecoverTwoFactor>, conn: DbConn) -> JsonResult {
+fn recover(data: JsonUpcase<RecoverTwoFactor>, conn: DbConn) -> JsonResult {
-    let data: RecoverTwoFactor = data.into_inner();
+    let data: RecoverTwoFactor = data.into_inner().data;
 
     use db::models::User;
 
     // Get the user
-    let mut user = match User::find_by_mail(&data.email, &conn) {
+    let mut user = match User::find_by_mail(&data.Email, &conn) {
         Some(user) => user,
         None => err!("Username or password is incorrect. Try again.")
     };
 
     // Check password
-    if !user.check_valid_password(&data.masterPasswordHash) {
+    if !user.check_valid_password(&data.MasterPasswordHash) {
         err!("Username or password is incorrect. Try again.")
     }
 
     // Check if recovery code is correct
-    if !user.check_valid_recovery_code(&data.recoveryCode) {
+    if !user.check_valid_recovery_code(&data.RecoveryCode) {
         err!("Recovery code is incorrect. Try again.")
     }
 
@@ -79,10 +79,10 @@ fn recover(data: Json<RecoverTwoFactor>, conn: DbConn) -> JsonResult {
 }
 
 #[post("/two-factor/get-authenticator", data = "<data>")]
-fn generate_authenticator(data: Json<PasswordData>, headers: Headers) -> JsonResult {
+fn generate_authenticator(data: JsonUpcase<PasswordData>, headers: Headers) -> JsonResult {
-    let data: PasswordData = data.into_inner();
+    let data: PasswordData = data.into_inner().data;
 
-    if !headers.user.check_valid_password(&data.masterPasswordHash) {
+    if !headers.user.check_valid_password(&data.MasterPasswordHash) {
         err!("Invalid password");
     }
 
@@ -101,17 +101,17 @@ fn generate_authenticator(data: Json<PasswordData>, headers: Headers) -> JsonRes
 #[derive(Deserialize, Debug)]
 #[allow(non_snake_case)]
 struct EnableTwoFactorData {
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    key: String,
+    Key: String,
-    token: NumberOrString,
+    Token: NumberOrString,
 }
 
 #[post("/two-factor/authenticator", data = "<data>")]
-fn activate_authenticator(data: Json<EnableTwoFactorData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn activate_authenticator(data: JsonUpcase<EnableTwoFactorData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: EnableTwoFactorData = data.into_inner();
+    let data: EnableTwoFactorData = data.into_inner().data;
-    let password_hash = data.masterPasswordHash;
+    let password_hash = data.MasterPasswordHash;
-    let key = data.key;
+    let key = data.Key;
-    let token = match data.token.to_i32() {
+    let token = match data.Token.to_i32() {
         Some(n) => n as u64,
         None => err!("Malformed token")
     };
@@ -155,15 +155,15 @@ fn activate_authenticator(data: Json<EnableTwoFactorData>, headers: Headers, con
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct DisableTwoFactorData {
-    masterPasswordHash: String,
+    MasterPasswordHash: String,
-    #[serde(rename = "type")]
+    Type: NumberOrString,
-    _type: NumberOrString,
 }
 
 #[post("/two-factor/disable", data = "<data>")]
-fn disable_authenticator(data: Json<DisableTwoFactorData>, headers: Headers, conn: DbConn) -> JsonResult {
+fn disable_authenticator(data: JsonUpcase<DisableTwoFactorData>, headers: Headers, conn: DbConn) -> JsonResult {
-    let data: DisableTwoFactorData = data.into_inner();
+    let data: DisableTwoFactorData = data.into_inner().data;
-    let password_hash = data.masterPasswordHash;
+    let password_hash = data.MasterPasswordHash;
+    let _type = data.Type;
 
     if !headers.user.check_valid_password(&password_hash) {
         err!("Invalid password");

src/api/mod.rs

@@ -15,11 +15,14 @@ use rocket_contrib::Json;
 type JsonResult = Result<Json, BadRequest<Json>>;
 type EmptyResult = Result<(), BadRequest<Json>>;
 
+use util;
+type JsonUpcase<T> = Json<util::UpCase<T>>;
+
 // Common structs representing JSON data received
 #[derive(Deserialize)]
 #[allow(non_snake_case)]
 struct PasswordData {
-    masterPasswordHash: String
+    MasterPasswordHash: String
 }
 
 #[derive(Deserialize, Debug)]

src/util.rs

@@ -124,3 +124,29 @@ const DATETIME_FORMAT: &'static str = "%Y-%m-%dT%H:%M:%S%.6fZ";
 pub fn format_date(date: &NaiveDateTime) -> String {
     date.format(DATETIME_FORMAT).to_string()
 }
+
+///
+/// Deserialization methods
+///
+
+use std::collections::BTreeMap as Map;
+
+use serde::de::{self, Deserialize, DeserializeOwned, Deserializer};
+use serde_json::Value;
+
+/// https://github.com/serde-rs/serde/issues/586
+pub fn upcase_deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+    where T: DeserializeOwned,
+          D: Deserializer<'de>
+{
+    let map = Map::<String, Value>::deserialize(deserializer)?;
+    let lower = map.into_iter().map(|(k, v)| (upcase_first(&k), v)).collect();
+    T::deserialize(Value::Object(lower)).map_err(de::Error::custom)
+}
+
+#[derive(PartialEq, Serialize, Deserialize)]
+pub struct UpCase<T: DeserializeOwned> {
+    #[serde(deserialize_with = "upcase_deserialize")]
+    #[serde(flatten)]
+    pub data: T,
+}