1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
use std::collections::HashMap;
use action_system::{action::ActionContext, macros::action_gen};
use serde::{Deserialize, Serialize};
use tcp_connection::error::TcpTargetError;
use vcs_data::data::local::{
modified_status::sign_vault_modified,
workspace_analyzer::{FromRelativePathBuf, ToRelativePathBuf},
};
use crate::{
remote_actions::{
auth_member, check_connection_instance, get_current_sheet_name, try_get_vault,
},
write_and_return,
};
pub type OperationArgument = (EditMappingOperations, Option<ToRelativePathBuf>);
#[derive(Serialize, Deserialize, PartialEq, Eq, Clone)]
pub enum EditMappingOperations {
Move,
Erase,
}
#[derive(Serialize, Deserialize, Default)]
pub enum EditMappingActionResult {
Success,
// Fail
AuthorizeFailed(String),
EditNotAllowed,
MappingNotFound(FromRelativePathBuf),
InvalidMove(InvalidMoveReason),
#[default]
Unknown,
}
#[derive(Serialize, Deserialize)]
pub enum InvalidMoveReason {
MoveOperationButNoTarget(FromRelativePathBuf),
ContainsDuplicateMapping(ToRelativePathBuf),
}
#[derive(Serialize, Deserialize, Clone)]
pub struct EditMappingActionArguments {
pub operations: HashMap<FromRelativePathBuf, OperationArgument>,
}
/// This Action only modifies Sheet Mapping and
/// does not interfere with the actual location of local files or Local Mapping
#[action_gen]
pub async fn edit_mapping_action(
ctx: ActionContext,
args: EditMappingActionArguments,
) -> Result<EditMappingActionResult, TcpTargetError> {
let instance = check_connection_instance(&ctx)?;
// Auth Member
let (member_id, is_host_mode) = match auth_member(&ctx, instance).await {
Ok(id) => id,
Err(e) => {
return Ok(EditMappingActionResult::AuthorizeFailed(e.to_string()));
}
};
// Check sheet
let (sheet_name, is_ref_sheet) =
get_current_sheet_name(&ctx, instance, &member_id, true).await?;
// Can modify Sheet when not in reference sheet or in Host mode
let can_modify_sheet = !is_ref_sheet || is_host_mode;
if !can_modify_sheet {
return Ok(EditMappingActionResult::EditNotAllowed);
}
if ctx.is_proc_on_remote() {
let vault = try_get_vault(&ctx)?;
let mut sheet = vault.sheet(&sheet_name).await?;
// Precheck
for (from_path, (operation, to_path)) in args.operations.iter() {
// Check mapping exists
if !sheet.mapping().contains_key(from_path) {
write_and_return!(
instance,
EditMappingActionResult::MappingNotFound(from_path.clone())
);
}
// Move check
if operation == &EditMappingOperations::Move {
// Check if target exists
if let Some(to_path) = to_path {
// Check if target is duplicate
if sheet.mapping().contains_key(to_path) {
write_and_return!(
instance,
EditMappingActionResult::InvalidMove(
InvalidMoveReason::ContainsDuplicateMapping(to_path.clone())
)
);
}
} else {
write_and_return!(
instance,
EditMappingActionResult::InvalidMove(
InvalidMoveReason::MoveOperationButNoTarget(from_path.clone())
)
);
}
}
}
// Process
for (from_path, (operation, to_path)) in args.operations {
match operation {
// During the Precheck phase, it has been ensured that:
// 1. The mapping to be edited for the From path indeed exists
// 2. The location of the To path is indeed empty
// 3. In Move mode, To path can be safely unwrapped
// Therefore, the following unwrap() calls are safe to execute
EditMappingOperations::Move => {
let mapping = sheet.mapping_mut().remove(&from_path).unwrap();
let to_path = to_path.unwrap();
sheet
.add_mapping(to_path, mapping.id, mapping.version)
.await?;
}
EditMappingOperations::Erase => {
sheet.mapping_mut().remove(&from_path).unwrap();
}
}
}
// Write
sheet.persist().await?;
write_and_return!(instance, EditMappingActionResult::Success);
}
if ctx.is_proc_on_local() {
let result = instance
.lock()
.await
.read::<EditMappingActionResult>()
.await?;
if matches!(result, EditMappingActionResult::Success) {
sign_vault_modified(true).await;
}
return Ok(result);
}
Ok(EditMappingActionResult::Success)
}
|
