repos

1 files changed, 101 insertions, 0 deletions

diff --git a/src/repos/repo.rs b/src/repos/repo.rs
new file mode 100644
index 0000000..0d3001f
--- /dev/null
+++ b/src/repos/repo.rs
@@ -0,0 +1,101 @@
+
+use std::{path::PathBuf};
+
+use nostr::{EventId, Event, prelude::{Nip19Event, ToBech32}, Tag};
+use nostr_sdk::{Keys};
+
+use crate::{groups::{group::{MembershipCollection, StartFinish}}, utils::load_file};
+
+use super::init::{InitializeRepo, self};
+
+/// [`Repo`] error
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    /// Error processing initialisation Repo content json - incorrect format?
+    #[error("Repo cannot be initialised from content: {0}")]
+    InitializeJson(#[from] init::Error),
+}
+
+/// Repo, acts a branch if root_repo is set
+pub struct Repo {
+    pub id: EventId,
+    pub name:Option<String>,
+    about:Option<String>,
+    picture:Option<String>,
+    pub relays:Vec<String>,
+    pub maintainers_group:MembershipCollection,
+    pub events:Vec<Event>,
+    pub root_repo: Option<EventId>,
+    hash: String, // hash of event IDs that make up this state
+}
+
+impl Repo {
+
+    pub fn new(init:&InitializeRepo, keys:&Keys) -> Result<Self,Error> {
+        let event = init.initialize(&keys);
+        Repo::new_from_event(event)
+    }
+
+    pub fn open(repo_dir_path: &PathBuf) -> Self {
+        Repo::new_from_json_event(
+            load_file(
+                repo_dir_path.join(".ngit/repo.json"),
+            )
+                .expect("repo.json load from file")
+        )
+            .expect("repo.json to produce Repo")
+    }
+
+    pub fn new_from_json_event(json_string:String) -> Result<Self,Error> {
+        let event = Event::from_json(json_string)
+            .expect("json_string to be formated as event");
+        Repo::new_from_event(event)
+    }
+
+    pub fn new_from_event(event:Event) -> Result<Self,Error> {
+        match InitializeRepo::from_json(&event.content) {
+            Err(e) => return Err(Error::InitializeJson(e)),
+            Ok(g) => {
+                let start_finish = StartFinish { start: event.created_at, finish: None };
+                // add maintainers_group
+                let mut maintainers_group = MembershipCollection::new();
+                match g.maintainers_group {
+                    None => (),
+                    Some(t) => {
+                        maintainers_group.add_group_dates(
+                            Tag::parse(t.into())
+                                .expect("maintainers_group to parse into Tag"),
+                            start_finish.clone(),
+                        )
+                    }
+                }
+                Ok(Self {
+                    id: event.id,
+                    name: g.name,
+                    about: g.about,
+                    picture: g.picture,
+                    relays: g.relays,
+                    maintainers_group,
+                    events:vec![event],
+                    root_repo:None,
+                    hash: "hash".to_string(), // hash of event IDs that make up this state
+                })
+            }
+        }        
+    }
+
+    pub fn nevent(&self) -> String {
+        let e = Nip19Event {
+            event_id: self.id.clone(),
+            relays: if self.relays.len() > 1 {
+                vec![self.relays[0].clone(),self.relays[1].clone()]
+            }
+            else if self.relays.len() == 1 {
+                vec![self.relays[0].clone()]
+            }
+            else { vec![] }
+        };
+        e.to_bech32()
+            .expect("Nip19Event to produce nevent String")
+    }
+}