1use serde::{Deserialize, Serialize};
8use std::collections::BTreeMap;
9use std::fs;
10use std::path::PathBuf;
11
12use crate::state::app_meta_dir;
13
14#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
15pub struct ProjectCollaborator {
16 pub project_id: String,
17 pub project_name: String,
18 pub member_did: String,
19 #[serde(default)]
20 pub display_name: String,
21 pub role: String,
23 pub added_at: u64,
24}
25
26#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
28pub struct LocalProject {
29 pub id: String,
30 pub name: String,
31 #[serde(default)]
32 pub description: String,
33 pub created_at: u64,
34 #[serde(default = "default_source_local")]
36 pub source: String,
37}
38
39fn default_source_local() -> String {
40 "local".into()
41}
42
43#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
45pub struct ProjectSummary {
46 pub id: String,
47 pub name: String,
48 pub member_count: usize,
49 pub source: String,
50}
51
52fn path() -> PathBuf {
53 app_meta_dir().join("project_collaborators.json")
54}
55
56fn projects_path() -> PathBuf {
57 app_meta_dir().join("coop_projects.json")
58}
59
60fn load() -> Vec<ProjectCollaborator> {
61 fs::read_to_string(path())
62 .ok()
63 .and_then(|t| serde_json::from_str(&t).ok())
64 .unwrap_or_default()
65}
66
67fn save(rows: &[ProjectCollaborator]) -> Result<(), String> {
68 let p = path();
69 if let Some(parent) = p.parent() {
70 fs::create_dir_all(parent).map_err(|e| e.to_string())?;
71 }
72 fs::write(
73 p,
74 serde_json::to_string_pretty(rows).map_err(|e| e.to_string())?,
75 )
76 .map_err(|e| e.to_string())
77}
78
79fn now() -> u64 {
80 std::time::SystemTime::now()
81 .duration_since(std::time::UNIX_EPOCH)
82 .map(|d| d.as_secs())
83 .unwrap_or(0)
84}
85
86pub fn list(project_id: Option<&str>) -> Vec<ProjectCollaborator> {
88 let all = load();
89 match project_id {
90 Some(id) if !id.is_empty() => all.into_iter().filter(|c| c.project_id == id).collect(),
91 _ => all,
92 }
93}
94
95pub fn add(
97 project_id: &str,
98 project_name: &str,
99 member_did: &str,
100 display_name: &str,
101 role: &str,
102) -> Result<ProjectCollaborator, String> {
103 let project_id = project_id.trim();
104 let member_did = member_did.trim();
105 if project_id.is_empty() || member_did.is_empty() {
106 return Err("project_id and member_did are required".into());
107 }
108 let role = match role.trim().to_ascii_lowercase().as_str() {
109 "steward" => "steward",
110 "observer" => "observer",
111 "agent" => "agent",
112 _ => "contributor",
113 };
114 let mut all = load();
115 all.retain(|c| !(c.project_id == project_id && c.member_did == member_did));
116 let row = ProjectCollaborator {
117 project_id: project_id.to_string(),
118 project_name: project_name.trim().to_string(),
119 member_did: member_did.to_string(),
120 display_name: display_name.trim().to_string(),
121 role: role.to_string(),
122 added_at: now(),
123 };
124 all.push(row.clone());
125 save(&all)?;
126 Ok(row)
127}
128
129pub fn remove(project_id: &str, member_did: &str) -> Result<(), String> {
131 let mut all = load();
132 let before = all.len();
133 all.retain(|c| !(c.project_id == project_id && c.member_did == member_did));
134 if all.len() == before {
135 return Err("collaborator not found".into());
136 }
137 save(&all)
138}
139
140fn load_projects() -> Vec<LocalProject> {
141 fs::read_to_string(projects_path())
142 .ok()
143 .and_then(|t| serde_json::from_str(&t).ok())
144 .unwrap_or_default()
145}
146
147fn save_projects(rows: &[LocalProject]) -> Result<(), String> {
148 let p = projects_path();
149 if let Some(parent) = p.parent() {
150 fs::create_dir_all(parent).map_err(|e| e.to_string())?;
151 }
152 fs::write(
153 p,
154 serde_json::to_string_pretty(rows).map_err(|e| e.to_string())?,
155 )
156 .map_err(|e| e.to_string())
157}
158
159pub fn create_local_project(name: &str, description: &str) -> Result<LocalProject, String> {
161 let name = name.trim();
162 if name.is_empty() {
163 return Err("project name is required".into());
164 }
165 let mut all = load_projects();
166 if let Some(existing) = all.iter().find(|p| p.name.eq_ignore_ascii_case(name)) {
167 return Ok(existing.clone());
168 }
169 let id = format!("local-{}", now());
170 let proj = LocalProject {
171 id: id.clone(),
172 name: name.to_string(),
173 description: description.trim().to_string(),
174 created_at: now(),
175 source: "local".into(),
176 };
177 all.push(proj.clone());
178 save_projects(&all)?;
179 let profile = crate::user_profile::load_profile();
181 let self_did = if profile.public_did.is_empty() {
182 crate::user_profile::resolve_public_did(&profile)
183 } else {
184 profile.public_did.clone()
185 };
186 if !self_did.is_empty() {
187 let _ = add(&id, name, &self_did, &profile.display_name, "steward");
188 }
189 Ok(proj)
190}
191
192pub fn register_wellfair_project(
194 id: &str,
195 name: &str,
196 description: &str,
197) -> Result<LocalProject, String> {
198 let id = id.trim();
199 let name = name.trim();
200 if id.is_empty() || name.is_empty() {
201 return Err("id and name required".into());
202 }
203 let mut all = load_projects();
204 all.retain(|p| p.id != id);
205 let proj = LocalProject {
206 id: id.to_string(),
207 name: name.to_string(),
208 description: description.trim().to_string(),
209 created_at: now(),
210 source: "wellfair".into(),
211 };
212 all.push(proj.clone());
213 save_projects(&all)?;
214 Ok(proj)
215}
216
217pub fn list_project_summaries() -> Vec<ProjectSummary> {
219 let mut by_id: BTreeMap<String, ProjectSummary> = BTreeMap::new();
220 for p in load_projects() {
221 let n = list(Some(&p.id)).len();
222 by_id.insert(
223 p.id.clone(),
224 ProjectSummary {
225 id: p.id,
226 name: p.name,
227 member_count: n,
228 source: p.source,
229 },
230 );
231 }
232 for c in load() {
233 by_id
234 .entry(c.project_id.clone())
235 .and_modify(|s| {
236 if s.name.is_empty() && !c.project_name.is_empty() {
237 s.name = c.project_name.clone();
238 }
239 })
241 .or_insert_with(|| ProjectSummary {
242 id: c.project_id.clone(),
243 name: if c.project_name.is_empty() {
244 c.project_id.clone()
245 } else {
246 c.project_name.clone()
247 },
248 member_count: 0,
249 source: "roster".into(),
250 });
251 }
252 for s in by_id.values_mut() {
254 s.member_count = list(Some(&s.id)).len();
255 }
256 let mut out: Vec<_> = by_id.into_values().collect();
257 out.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
258 out
259}
260
261#[cfg(test)]
262mod tests {
263 use super::*;
264
265 #[test]
266 fn add_list_remove() {
267 let pid = format!("board-test-{}", now());
268 let did = format!("did:test:{}", now());
269 let row = add(&pid, "Test Project", &did, "Alice", "contributor").expect("add");
270 assert_eq!(row.project_id, pid);
271 assert!(list(Some(&pid)).iter().any(|c| c.member_did == did));
272 remove(&pid, &did).expect("remove");
273 assert!(!list(Some(&pid)).iter().any(|c| c.member_did == did));
274 }
275
276 #[test]
277 fn create_local_project_and_summaries() {
278 let name = format!("CoopTest-{}", now());
279 let p = create_local_project(&name, "desc").expect("create");
280 assert!(!p.id.is_empty());
281 let again = create_local_project(&name, "desc").expect("idempotent");
282 assert_eq!(p.id, again.id);
283 let sums = list_project_summaries();
284 assert!(sums.iter().any(|s| s.name == name));
285 }
286}