Public key reset endpoint WIP

Author: joepio

lib/src/agents.rs

@@ -5,7 +5,7 @@
 use base64::{engine::general_purpose, Engine};
 use serde_json::from_slice;
 
-use crate::{errors::AtomicResult, urls, Resource, Storelike, Value};
+use crate::{errors::AtomicResult, urls, Query, Resource, Storelike, Value};
 
 /// None represents no right checks will be performed, effectively SUDO mode.
 #[derive(Clone, Debug, PartialEq)]
@@ -81,6 +81,41 @@ impl Agent {
         Ok(resource)
     }
 
+    pub fn from_email(email: &str, store: &impl Storelike) -> AtomicResult<Self> {
+        let mut query = Query::new();
+        query.property = Some(urls::EMAIL.into());
+        query.value = Some(Value::String(email.to_string()));
+        let response = store.query(&query)?;
+        if response.resources.is_empty() {
+            return Err(format!("Agent with Email {} not found", email).into());
+        }
+        if response.resources.len() > 1 {
+            return Err(format!(
+                "Email {} is not unique, {} agents have this email",
+                email, response.count
+            )
+            .into());
+        }
+        let resource = response.resources.first().unwrap();
+        Agent::from_resource(resource.clone())
+    }
+
+    pub fn from_resource(resource: Resource) -> AtomicResult<Self> {
+        let name = if let Ok(name) = resource.get(urls::NAME) {
+            Some(name.to_string())
+        } else {
+            None
+        };
+
+        return Ok(Self {
+            created_at: resource.get(urls::CREATED_AT)?.to_int()?,
+            name,
+            public_key: resource.get(urls::PUBLIC_KEY)?.to_string(),
+            private_key: None,
+            subject: resource.get_subject().into(),
+        });
+    }
+
     /// Creates a new Agent, generates a new Keypair.
     pub fn new(name: Option<&str>, store: &impl Storelike) -> AtomicResult<Agent> {
         let keypair = generate_keypair()?;

lib/src/collections.rs

@@ -1,10 +1,8 @@
 //! Collections are dynamic resources that refer to multiple resources.
 //! They are constructed using a [Query]
 use crate::{
-    agents::ForAgent,
-    errors::AtomicResult,
-    storelike::{Query, ResourceCollection},
-    urls, Resource, Storelike, Value,
+    agents::ForAgent, errors::AtomicResult, storelike::ResourceCollection, urls, Query, Resource,
+    Storelike, Value,
 };
 
 const DEFAULT_PAGE_SIZE: usize = 30;

lib/src/db.rs

@@ -27,10 +27,11 @@ use crate::{
     email::{self, MailMessage},
     endpoints::{default_endpoints, Endpoint, HandleGetContext},
     errors::{AtomicError, AtomicResult},
+    query::QueryResult,
     resources::PropVals,
-    storelike::{Query, QueryResult, Storelike},
+    storelike::Storelike,
     values::SortableValue,
-    Atom, Resource,
+    Atom, Query, Resource,
 };
 
 use self::{
@@ -254,10 +255,6 @@ impl Db {
     }
 
     fn query_basic(&self, q: &Query) -> AtomicResult<QueryResult> {
-        let self_url = self
-            .get_self_url()
-            .ok_or("No self_url set, required for Queries")?;
-
         let mut subjects: Vec<String> = vec![];
         let mut resources: Vec<Resource> = vec![];
         let mut total_count = 0;

lib/src/db/query_index.rs

@@ -2,8 +2,8 @@
 //! It relies on lexicographic ordering of keys, which Sled utilizes using `scan_prefix` queries.
 
 use crate::{
-    agents::ForAgent, atoms::IndexAtom, errors::AtomicResult, storelike::Query,
-    values::SortableValue, Atom, Db, Resource, Storelike, Value,
+    agents::ForAgent, atoms::IndexAtom, errors::AtomicResult, values::SortableValue, Atom, Db,
+    Query, Resource, Storelike, Value,
 };
 use serde::{Deserialize, Serialize};
 
@@ -99,10 +99,6 @@ pub fn query_sorted_indexed(
     let mut resources: Vec<Resource> = vec![];
     let mut count = 0;
 
-    let self_url = store
-        .get_self_url()
-        .ok_or("No self_url set, required for Queries")?;
-
     let limit = q.limit.unwrap_or(std::usize::MAX);
 
     for (i, kv) in iter.enumerate() {

lib/src/email.rs

@@ -1,6 +1,6 @@
 //! [EmailAddress] with validation, [MailMessage] with sending, and [get_smtp_client] for setting up mail.
 
-use crate::{errors::AtomicResult, storelike::Query, urls, Storelike};
+use crate::{errors::AtomicResult, urls, Query, Storelike};
 use mail_send::{mail_builder::MessageBuilder, Connected, Transport};
 use serde::{Deserialize, Serialize};
 use tracing::info;

lib/src/hierarchy.rs

@@ -4,7 +4,7 @@
 
 use core::fmt;
 
-use crate::{agents::ForAgent, errors::AtomicResult, storelike::Query, urls, Resource, Storelike};
+use crate::{agents::ForAgent, errors::AtomicResult, urls, Query, Resource, Storelike};
 
 #[derive(Debug)]
 pub enum Right {

lib/src/lib.rs

@@ -16,7 +16,7 @@ See the [Atomic Data Docs](https://docs.atomicdata.dev) for more information.
 - [Value] converts Atomic Data to Rust native types
 - [Commit]s (transactions / delta's / changes / updates / versioning / history). Supports many checks, such as Schema, Authorization and more.
 - [collections] (pagination, sorting, filtering)
-- Queries (see [storelike::Query])
+- Queries (see [query::Query])
 - [hierarchy] for authorization
 - [crate::endpoints::Endpoint] for custom API endpoints
 - [config::Config] files. (requires `config` feature)
@@ -87,6 +87,7 @@ pub mod parse;
 #[cfg(feature = "db")]
 pub mod plugins;
 pub mod populate;
+pub mod query;
 pub mod resources;
 pub mod schema;
 pub mod serialize;
@@ -108,6 +109,7 @@ pub use commit::Commit;
 pub use db::Db;
 pub use errors::AtomicError;
 pub use errors::AtomicErrorType;
+pub use query::Query;
 pub use resources::Resource;
 pub use store::Store;
 pub use storelike::Storelike;

lib/src/plugins/chatroom.rs

@@ -8,9 +8,8 @@ use crate::{
     agents::ForAgent,
     commit::{CommitBuilder, CommitResponse},
     errors::AtomicResult,
-    storelike::Query,
     urls::{self, PARENT},
-    utils, Resource, Storelike, Value,
+    utils, Query, Resource, Storelike, Value,
 };
 
 // Find the messages for the ChatRoom

lib/src/plugins/mod.rs

@@ -49,3 +49,6 @@ pub mod register;
 pub mod reset_pubkey;
 pub mod search;
 pub mod versioning;
+
+// Utilities / helpers
+mod utils;

lib/src/plugins/prunetests.rs

@@ -1,8 +1,7 @@
 use crate::{
     endpoints::{Endpoint, HandleGetContext, HandlePostContext},
     errors::AtomicResult,
-    storelike::Query,
-    urls, Resource, Storelike, Value,
+    urls, Query, Resource, Storelike, Value,
 };
 
 pub fn prune_tests_endpoint() -> Endpoint {

lib/src/plugins/register.rs

@@ -12,6 +12,8 @@ use crate::{
     Resource, Storelike, Value,
 };
 
+use super::utils::return_success;
+
 pub fn register_endpoint() -> Endpoint {
     Endpoint {
       path: urls::PATH_REGISTER.to_string(),
@@ -21,8 +23,8 @@ pub fn register_endpoint() -> Endpoint {
       ].into(),
       description: "Allows new users to easily, in one request, make both an Agent and a Drive. This drive will be created at the subdomain of `name`.".to_string(),
       shortname: "register".to_string(),
-      handle: Some(construct_register_redirect),
       handle_post: None,
+      handle: Some(handle_register_name_and_email),
   }
 }
 
@@ -43,12 +45,17 @@ struct MailConfirmation {
     pub name: String,
 }
 
-#[tracing::instrument()]
-pub fn construct_register_redirect(context: HandleGetContext) -> AtomicResult<Resource> {
+#[tracing::instrument]
+pub fn handle_register_name_and_email(context: HandleGetContext) -> AtomicResult<Resource> {
+    let HandleGetContext {
+        subject,
+        store: _,
+        for_agent: _,
+    } = context;
     let mut name_option = None;
     let mut email_option: Option<EmailAddress> = None;
     let store = context.store;
-    for (k, v) in context.subject.query_pairs() {
+    for (k, v) in subject.query_pairs() {
         match k.as_ref() {
             "name" | urls::NAME => name_option = Some(v.to_string()),
             "email" => email_option = Some(EmailAddress::new(v.to_string())?),
@@ -93,14 +100,7 @@ pub fn construct_register_redirect(context: HandleGetContext) -> AtomicResult<Re
             .unwrap_or_else(|e| tracing::error!("Error sending email: {}", e));
     });
 
-    // Here we probably want to return some sort of SuccesMessage page.
-    // Not sure what that should be.
-    let mut resource = Resource::new_generate_subject(store);
-    resource.set_string(urls::DESCRIPTION.into(), "success", store)?;
-
-    // resource.set_propval(urls::, value, store)
-
-    Ok(resource)
+    return_success()
 }
 
 #[tracing::instrument()]