Merge branch 'master' into credentials-param

jovfer · web-flow · commit f7b38ca763ff · 2018-06-01T14:02:09.000+03:00
diff --git a/libindy/src/commands/non_secrets.rs b/libindy/src/commands/non_secrets.rs
@@ -295,7 +295,7 @@ impl NonSecretsCommandExecutor {
         }
 
         let search_result = SearchRecords {
-            total_count: None, // TODO: return search.get_total_count()?
+            total_count: search.get_total_count()?,
             records: if records.is_empty() { None } else { Some(records) }
         };
 
diff --git a/libindy/src/services/wallet/iterator.rs b/libindy/src/services/wallet/iterator.rs
@@ -44,4 +44,9 @@ impl WalletIterator {
             Ok(Some(WalletRecord::new(name, None, value, tags)))
         } else { Ok(None) }
     }
+
+    pub fn get_total_count(&self) -> Result<Option<usize>, WalletError> {
+        let total_count = self.storage_iterator.get_total_count()?;
+        Ok(total_count)
+    }
 }
diff --git a/libindy/src/services/wallet/mod.rs b/libindy/src/services/wallet/mod.rs
@@ -640,15 +640,15 @@ pub struct WalletSearch {
 
 impl WalletSearch {
     pub fn get_total_count(&self) -> Result<Option<usize>, WalletError> {
-        unimplemented!()
+        self.iter.get_total_count()
     }
 
     pub fn fetch_next_record(&mut self) -> Result<Option<WalletRecord>, WalletError> {
         self.iter.next()
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub struct SearchOptions {
     pub retrieve_records: Option<bool>,
@@ -684,6 +684,18 @@ impl SearchOptions {
     }
 }
 
+impl Default for SearchOptions {
+    fn default() -> SearchOptions {
+        SearchOptions {
+            retrieve_records: Some(true),
+            retrieve_total_count: Some(false),
+            retrieve_type: Some(false),
+            retrieve_value: Some(true),
+            retrieve_tags: Some(false),
+        }
+    }
+}
+
 impl JsonEncodable for SearchOptions {}
 
 impl<'a> JsonDecodable<'a> for SearchOptions {}
diff --git a/libindy/src/services/wallet/storage/default/mod.rs b/libindy/src/services/wallet/storage/default/mod.rs
@@ -15,9 +15,9 @@ use utils::environment::EnvironmentUtils;
 use errors::wallet::WalletStorageError;
 use errors::common::CommonError;
 use services::wallet::language;
-use super::super::indy_crypto::utils::json::{JsonDecodable, JsonEncodable};
 
-use super::{StorageIterator, WalletStorageType, WalletStorage, StorageEntity, EncryptedValue, Tag, TagName};
+use super::{StorageIterator, WalletStorageType, WalletStorage, StorageEntity, EncryptedValue, Tag, TagName, FetchOptions};
+use super::super::SearchOptions;
 
 const _SQLITE_DB: &str = "sqlite.db";
 const _PLAIN_TAGS_QUERY: &str = "SELECT name, value from tags_plaintext where item_id = ?";
@@ -93,7 +93,8 @@ struct TagRetriever<'a> {
     encrypted_tags_stmt: rusqlite::Statement<'a>,
 }
 
-type TagRetrieverOwned = OwningHandle<Rc<rusqlite::Connection>, Box<TagRetriever<'static>>>;
+type TagRetrieverOwned = OwningHandle<Rc<rusqlite::Connection>, Box<TagRetriever<'static>>>
+;
 
 impl<'a> TagRetriever<'a> {
     fn new_owned(conn: Rc<rusqlite::Connection>) -> Result<TagRetrieverOwned, WalletStorageError> {
@@ -139,44 +140,52 @@ struct SQLiteStorageIterator {
             Box<rusqlite::Rows<'static>>>>,
     tag_retriever: Option<TagRetrieverOwned>,
     options: FetchOptions,
-    fetch_type_: bool,
+    total_count: Option<usize>,
 }
 
 
 impl SQLiteStorageIterator {
-    fn new(stmt: OwningHandle<Rc<rusqlite::Connection>, Box<rusqlite::Statement<'static>>>,
+    fn new(stmt: Option<OwningHandle<Rc<rusqlite::Connection>, Box<rusqlite::Statement<'static>>>>,
            args: &[&rusqlite::types::ToSql],
            options: FetchOptions,
            tag_retriever: Option<TagRetrieverOwned>,
-           fetch_type_: bool) -> Result<SQLiteStorageIterator, WalletStorageError> {
+           total_count: Option<usize>) -> Result<SQLiteStorageIterator, WalletStorageError> {
         let mut iter = SQLiteStorageIterator {
             rows: None,
             tag_retriever,
             options,
-            fetch_type_,
+            total_count
         };
-        iter.rows = Some(OwningHandle::try_new(
-            stmt, |stmt|
-                unsafe {
-                    (*(stmt as *mut rusqlite::Statement)).query(args).map(Box::new)
-                },
-        )?);
+
+        if let Some(stmt) = stmt {
+            iter.rows = Some(OwningHandle::try_new(
+                stmt, |stmt|
+                    unsafe {
+                        (*(stmt as *mut rusqlite::Statement)).query(args).map(Box::new)
+                    },
+            )?);
+        }
         Ok(iter)
     }
 }
 
 
 impl StorageIterator for SQLiteStorageIterator {
     fn next(&mut self) -> Result<Option<StorageEntity>, WalletStorageError> {
+        // if records are not requested.
+        if self.rows.is_none() {
+            return Ok(None);
+        }
+
         match self.rows.as_mut().unwrap().next() {
             Some(Ok(row)) => {
                 let name = row.get(1);
-                let value = if self.options.fetch_value {
+                let value = if self.options.retrieve_value {
                     Some(EncryptedValue::new(row.get(2), row.get(3)))
                 } else {
                     None
                 };
-                let tags = if self.options.fetch_tags {
+                let tags = if self.options.retrieve_tags {
                     match self.tag_retriever {
                         Some(ref mut tag_retriever) => Some(tag_retriever.retrieve(row.get(0))?),
                         None => return Err(WalletStorageError::CommonError(
@@ -186,7 +195,7 @@ impl StorageIterator for SQLiteStorageIterator {
                 } else {
                     None
                 };
-                let type_ = if self.fetch_type_ {
+                let type_ = if self.options.retrieve_type {
                     Some(row.get(4))
                 } else {
                     None
@@ -197,45 +206,12 @@ impl StorageIterator for SQLiteStorageIterator {
             None => Ok(None)
         }
     }
-}
-
-
-#[derive(Debug,Deserialize,Serialize)]
-struct FetchOptions {
-    #[serde(rename="retrieveType")]
-    fetch_type: bool,
-    #[serde(rename="retrieveValue")]
-    fetch_value: bool,
-    #[serde(rename="retrieveTags")]
-    fetch_tags: bool,
-}
 
-impl FetchOptions {
-    fn new(fetch_type: bool, fetch_value: bool, fetch_tags: bool) -> FetchOptions {
-        FetchOptions {
-            fetch_type: fetch_type,
-            fetch_value: fetch_value,
-            fetch_tags: fetch_tags,
-        }
+    fn get_total_count(&self) -> Result<Option<usize>, WalletStorageError> {
+        Ok(self.total_count)
     }
 }
 
-impl Default for FetchOptions {
-    fn default() -> FetchOptions {
-        FetchOptions {
-            fetch_type: false,
-            fetch_value: true,
-            fetch_tags: false,
-        }
-    }
-}
-
-impl JsonEncodable for FetchOptions {}
-
-impl<'a> JsonDecodable<'a> for FetchOptions {}
-
-
-
 #[derive(Debug)]
 struct SQLiteStorage {
     conn: Rc<rusqlite::Connection>,
@@ -305,9 +281,10 @@ impl WalletStorage for SQLiteStorage {
             Err(rusqlite::Error::QueryReturnedNoRows) => return Err(WalletStorageError::ItemNotFound),
             Err(err) => return Err(WalletStorageError::from(err))
         };
-        let value = if options.fetch_value { Some(EncryptedValue::new(item.1, item.2)) } else { None };
-        let type_ = if options.fetch_type { Some(type_.clone()) } else { None };
-        let tags = if options.fetch_tags {
+        let value = if options.retrieve_value
+            { Some(EncryptedValue::new(item.1, item.2)) } else { None };
+        let type_ = if options.retrieve_type { Some(type_.clone()) } else { None };
+        let tags = if options.retrieve_tags {
             let mut tags = Vec::new();
 
             // get all encrypted.
@@ -552,31 +529,55 @@ impl WalletStorage for SQLiteStorage {
     fn get_all(&self) -> Result<Box<StorageIterator>, WalletStorageError> {
         let statement = self._prepare_statement("SELECT id, name, value, key, type FROM items;")?;
         let fetch_options = FetchOptions {
-            fetch_type: true,
-            fetch_value: true,
-            fetch_tags: true,
+            retrieve_type: true,
+            retrieve_value: true,
+            retrieve_tags: true,
         };
         let tag_retriever = Some(TagRetriever::new_owned(self.conn.clone())?);
 
-        let storage_iterator = SQLiteStorageIterator::new(statement, &[], fetch_options, tag_retriever, true)?;
+        let storage_iterator = SQLiteStorageIterator::new(Some(statement), &[], fetch_options, tag_retriever, None)?;
         Ok(Box::new(storage_iterator))
     }
 
     fn search(&self, type_: &Vec<u8>, query: &language::Operator, options: Option<&str>) -> Result<Box<StorageIterator>, WalletStorageError> {
-        let fetch_options = match options {
-            None => FetchOptions::default(),
+        let search_options = match options {
+            None => SearchOptions::default(),
             Some(option_str) => serde_json::from_str(option_str)?
         };
-        let (query_string, query_arguments) = query::wql_to_sql(type_, query, options)?;
 
-        let statement = self._prepare_statement(&query_string)?;
-        let tag_retriever = if fetch_options.fetch_tags {
-            Some(TagRetriever::new_owned(self.conn.clone())?)
-        } else {
-            None
-        };
-        let storage_iterator = SQLiteStorageIterator::new(statement, &query_arguments, fetch_options, tag_retriever, false)?;
-        Ok(Box::new(storage_iterator))
+        let total_count: Option<usize> = if search_options.retrieve_total_count.unwrap_or(false) {
+            let (query_string, query_arguments) = query::wql_to_sql_count(type_, query)?;
+
+            self.conn.query_row(
+                &query_string,
+                &query_arguments,
+                |row| { let x: i64 = row.get(0); Some(x as usize) }
+            )?
+        } else {None};
+
+
+        if search_options.retrieve_records.unwrap_or(true) {
+            let fetch_options = FetchOptions {
+                retrieve_value: search_options.retrieve_value.unwrap_or(true),
+                retrieve_tags: search_options.retrieve_tags.unwrap_or(false),
+                retrieve_type: search_options.retrieve_type.unwrap_or(false),
+            };
+
+            let (query_string, query_arguments) = query::wql_to_sql(type_, query, options)?;
+
+            let statement = self._prepare_statement(&query_string)?;
+            let tag_retriever = if fetch_options.retrieve_tags {
+                Some(TagRetriever::new_owned(self.conn.clone())?)
+            } else {
+                None
+            };
+            let storage_iterator = SQLiteStorageIterator::new(Some(statement), &query_arguments, fetch_options, tag_retriever, total_count)?;
+            Ok(Box::new(storage_iterator))
+        }
+        else {
+            let storage_iterator = SQLiteStorageIterator::new(None, &[], FetchOptions::default(), None, total_count)?;
+            Ok(Box::new(storage_iterator))
+        }
     }
 
     fn close(&mut self) -> Result<(), WalletStorageError> {
diff --git a/libindy/src/services/wallet/storage/default/query.rs b/libindy/src/services/wallet/storage/default/query.rs
@@ -11,7 +11,20 @@ pub fn wql_to_sql<'a>(class: &'a Vec<u8>, op: &'a Operator, options: Option<&str
     let mut arguments: Vec<&ToSql> = Vec::new();
     arguments.push(class);
     let clause_string = operator_to_sql(op, &mut arguments)?;
-    let mut query_string = "SELECT i.id, i.name, i.value, i.key FROM items as i WHERE i.type = ?".to_string();
+    let mut query_string = "SELECT i.id, i.name, i.value, i.key, i.type FROM items as i WHERE i.type = ?".to_string();
+    if !clause_string.is_empty() {
+        query_string.push_str(" AND ");
+        query_string.push_str(&clause_string);
+    }
+    Ok((query_string, arguments))
+}
+
+
+pub fn wql_to_sql_count<'a>(class: &'a Vec<u8>, op: &'a Operator) -> Result<(String, Vec<&'a ToSql>), WalletQueryError> {
+    let mut arguments: Vec<&ToSql> = Vec::new();
+    arguments.push(class);
+    let clause_string = operator_to_sql(op, &mut arguments)?;
+    let mut query_string = "SELECT count(*) FROM items as i WHERE i.type = ?".to_string();
     if !clause_string.is_empty() {
         query_string.push_str(" AND ");
         query_string.push_str(&clause_string);
diff --git a/libindy/src/services/wallet/storage/mod.rs b/libindy/src/services/wallet/storage/mod.rs
@@ -4,20 +4,62 @@ pub mod plugged;
 use errors::wallet::WalletStorageError;
 use services::wallet::language;
 use services::wallet::wallet::EncryptedValue;
+use super::indy_crypto::utils::json::{JsonDecodable, JsonEncodable};
+use serde_json;
 
 #[derive(Clone, Debug, Ord, PartialOrd, Eq, PartialEq)]
 pub enum Tag {
     Encrypted(Vec<u8>, Vec<u8>),
     PlainText(Vec<u8>, String)
 }
 
+
 #[derive(Debug)]
 pub enum TagName {
     OfEncrypted(Vec<u8>),
     OfPlain(Vec<u8>),
 }
 
 
+#[derive(Debug,Deserialize,Serialize,PartialEq)]
+struct FetchOptions {
+    #[serde(rename="retrieveType")]
+    retrieve_type: bool,
+    #[serde(rename="retrieveValue")]
+    retrieve_value: bool,
+    #[serde(rename="retrieveTags")]
+    retrieve_tags: bool,
+}
+
+
+impl FetchOptions {
+    fn new(fetch_type: bool, fetch_value: bool, fetch_tags: bool) -> FetchOptions {
+        FetchOptions {
+            retrieve_type: fetch_type,
+            retrieve_value: fetch_value,
+            retrieve_tags: fetch_tags,
+        }
+    }
+}
+
+
+impl Default for FetchOptions {
+    fn default() -> FetchOptions {
+        FetchOptions {
+            retrieve_type: false,
+            retrieve_value: true,
+            retrieve_tags: false,
+        }
+    }
+}
+
+
+impl JsonEncodable for FetchOptions {}
+
+
+impl<'a> JsonDecodable<'a> for FetchOptions {}
+
+
 #[derive(Clone, Debug)]
 pub struct StorageEntity {
     pub name: Vec<u8>,
@@ -40,6 +82,7 @@ impl StorageEntity {
 
 pub trait StorageIterator {
     fn next(&mut self) -> Result<Option<StorageEntity>, WalletStorageError>;
+    fn get_total_count(&self) -> Result<Option<usize>, WalletStorageError>;
 }
 
 
diff --git a/libindy/src/services/wallet/storage/plugged/mod.rs b/libindy/src/services/wallet/storage/plugged/mod.rs
diff --git a/libindy/src/services/wallet/wallet.rs b/libindy/src/services/wallet/wallet.rs

Original file line number	Diff line number	Diff line change
`@@ -295,7 +295,7 @@ impl NonSecretsCommandExecutor {`
`295`	`295`	`}`
`296`	`296`
`297`	`297`	`let search_result = SearchRecords {`
`298`		`- total_count: None, // TODO: return search.get_total_count()?`
	`298`	`+ total_count: search.get_total_count()?,`
`299`	`299`	`records: if records.is_empty() { None } else { Some(records) }`
`300`	`300`	`};`
`301`	`301`
Original file line number	Diff line number	Diff line change
`@@ -44,4 +44,9 @@ impl WalletIterator {`
`44`	`44`	`Ok(Some(WalletRecord::new(name, None, value, tags)))`
`45`	`45`	`} else { Ok(None) }`
`46`	`46`	`}`
	`47`	`+`
	`48`	`+ pub fn get_total_count(&self) -> Result<Option<usize>, WalletError> {`
	`49`	`+ let total_count = self.storage_iterator.get_total_count()?;`
	`50`	`+ Ok(total_count)`
	`51`	`+ }`
`47`	`52`	`}`