1use std::{ops::RangeInclusive, sync::Arc, time::Duration};
2
3use anyhow::{anyhow, bail};
4use client::{Client, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
5use db::kvp::KEY_VALUE_STORE;
6use editor::{Editor, EditorEvent};
7use futures::AsyncReadExt;
8use gpui::{
9 div, red, rems, serde_json, AppContext, DismissEvent, Div, EventEmitter, FocusHandle,
10 FocusableView, Model, PromptLevel, Render, Task, View, ViewContext,
11};
12use isahc::Request;
13use language::Buffer;
14use project::Project;
15use regex::Regex;
16use serde_derive::Serialize;
17use ui::{prelude::*, Button, ButtonStyle, IconPosition, Tooltip};
18use util::ResultExt;
19use workspace::{ModalView, Workspace};
20
21use crate::{system_specs::SystemSpecs, GiveFeedback, OpenZedCommunityRepo};
22
23// For UI testing purposes
24const SEND_SUCCESS_IN_DEV_MODE: bool = true;
25const SEND_TIME_IN_DEV_MODE: Duration = Duration::from_secs(2);
26
27// Temporary, until tests are in place
28#[cfg(debug_assertions)]
29const DEV_MODE: bool = true;
30
31#[cfg(not(debug_assertions))]
32const DEV_MODE: bool = false;
33
34const DATABASE_KEY_NAME: &str = "email_address";
35const EMAIL_REGEX: &str = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b";
36const FEEDBACK_CHAR_LIMIT: RangeInclusive<i32> = 10..=5000;
37const FEEDBACK_SUBMISSION_ERROR_TEXT: &str =
38 "Feedback failed to submit, see error log for details.";
39
40#[derive(Serialize)]
41struct FeedbackRequestBody<'a> {
42 feedback_text: &'a str,
43 email: Option<String>,
44 metrics_id: Option<Arc<str>>,
45 installation_id: Option<Arc<str>>,
46 system_specs: SystemSpecs,
47 is_staff: bool,
48 token: &'a str,
49}
50
51#[derive(PartialEq)]
52enum FeedbackModalState {
53 CanSubmit,
54 DismissModal,
55 AwaitingSubmissionResponse,
56}
57
58pub struct FeedbackModal {
59 system_specs: SystemSpecs,
60 feedback_editor: View<Editor>,
61 email_address_editor: View<Editor>,
62 character_count: i32,
63 state: FeedbackModalState,
64}
65
66impl FocusableView for FeedbackModal {
67 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
68 self.feedback_editor.focus_handle(cx)
69 }
70}
71impl EventEmitter<DismissEvent> for FeedbackModal {}
72
73impl ModalView for FeedbackModal {
74 fn on_before_dismiss(&mut self, cx: &mut ViewContext<Self>) -> bool {
75 if self.state == FeedbackModalState::DismissModal {
76 return true;
77 }
78
79 let has_feedback = self.feedback_editor.read(cx).text_option(cx).is_some();
80 if !has_feedback {
81 return true;
82 }
83
84 let answer = cx.prompt(PromptLevel::Info, "Discard feedback?", &["Yes", "No"]);
85
86 cx.spawn(move |this, mut cx| async move {
87 if answer.await.ok() == Some(0) {
88 this.update(&mut cx, |this, cx| {
89 this.state = FeedbackModalState::DismissModal;
90 cx.emit(DismissEvent)
91 })
92 .log_err();
93 }
94 })
95 .detach();
96
97 false
98 }
99}
100
101impl FeedbackModal {
102 pub fn register(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
103 let _handle = cx.view().downgrade();
104 workspace.register_action(move |workspace, _: &GiveFeedback, cx| {
105 let markdown = workspace
106 .app_state()
107 .languages
108 .language_for_name("Markdown");
109
110 let project = workspace.project().clone();
111
112 cx.spawn(|workspace, mut cx| async move {
113 let markdown = markdown.await.log_err();
114 let buffer = project
115 .update(&mut cx, |project, cx| {
116 project.create_buffer("", markdown, cx)
117 })?
118 .expect("creating buffers on a local workspace always succeeds");
119
120 workspace.update(&mut cx, |workspace, cx| {
121 let system_specs = SystemSpecs::new(cx);
122
123 workspace.toggle_modal(cx, move |cx| {
124 FeedbackModal::new(system_specs, project, buffer, cx)
125 });
126 })?;
127
128 anyhow::Ok(())
129 })
130 .detach_and_log_err(cx);
131 });
132 }
133
134 pub fn new(
135 system_specs: SystemSpecs,
136 project: Model<Project>,
137 buffer: Model<Buffer>,
138 cx: &mut ViewContext<Self>,
139 ) -> Self {
140 let email_address_editor = cx.build_view(|cx| {
141 let mut editor = Editor::single_line(cx);
142 editor.set_placeholder_text("Email address (optional)", cx);
143
144 if let Ok(Some(email_address)) = KEY_VALUE_STORE.read_kvp(DATABASE_KEY_NAME) {
145 editor.set_text(email_address, cx)
146 }
147
148 editor
149 });
150
151 // Moved here because providing it inline breaks rustfmt
152 let placeholder_text =
153 "You can use markdown to organize your feedback with code and links.";
154
155 let feedback_editor = cx.build_view(|cx| {
156 let mut editor = Editor::for_buffer(buffer, Some(project.clone()), cx);
157 editor.set_placeholder_text(placeholder_text, cx);
158 // editor.set_show_gutter(false, cx);
159 editor.set_vertical_scroll_margin(5, cx);
160 editor
161 });
162
163 cx.subscribe(
164 &feedback_editor,
165 |this, editor, event: &EditorEvent, cx| match event {
166 EditorEvent::Edited => {
167 this.character_count = editor
168 .read(cx)
169 .buffer()
170 .read(cx)
171 .as_singleton()
172 .expect("Feedback editor is never a multi-buffer")
173 .read(cx)
174 .len() as i32;
175 cx.notify();
176 }
177 _ => {}
178 },
179 )
180 .detach();
181
182 Self {
183 system_specs: system_specs.clone(),
184 feedback_editor,
185 email_address_editor,
186 state: FeedbackModalState::CanSubmit,
187 character_count: 0,
188 }
189 }
190
191 pub fn submit(&mut self, cx: &mut ViewContext<Self>) -> Task<anyhow::Result<()>> {
192 let feedback_text = self.feedback_editor.read(cx).text(cx).trim().to_string();
193 let email = self.email_address_editor.read(cx).text_option(cx);
194
195 let answer = cx.prompt(
196 PromptLevel::Info,
197 "Ready to submit your feedback?",
198 &["Yes, Submit!", "No"],
199 );
200 let client = cx.global::<Arc<Client>>().clone();
201 let specs = self.system_specs.clone();
202 cx.spawn(|this, mut cx| async move {
203 let answer = answer.await.ok();
204 if answer == Some(0) {
205 match email.clone() {
206 Some(email) => {
207 KEY_VALUE_STORE
208 .write_kvp(DATABASE_KEY_NAME.to_string(), email)
209 .await
210 .ok();
211 }
212 None => {
213 KEY_VALUE_STORE
214 .delete_kvp(DATABASE_KEY_NAME.to_string())
215 .await
216 .ok();
217 }
218 };
219
220 this.update(&mut cx, |this, cx| {
221 this.state = FeedbackModalState::AwaitingSubmissionResponse;
222 cx.notify();
223 })
224 .log_err();
225
226 let res =
227 FeedbackModal::submit_feedback(&feedback_text, email, client, specs).await;
228
229 match res {
230 Ok(_) => {
231 this.update(&mut cx, |this, cx| {
232 this.state = FeedbackModalState::DismissModal;
233 cx.notify();
234 cx.emit(DismissEvent)
235 })
236 .ok();
237 }
238 Err(error) => {
239 log::error!("{}", error);
240 this.update(&mut cx, |this, cx| {
241 let prompt = cx.prompt(
242 PromptLevel::Critical,
243 FEEDBACK_SUBMISSION_ERROR_TEXT,
244 &["OK"],
245 );
246 cx.spawn(|_, _cx| async move {
247 prompt.await.ok();
248 })
249 .detach();
250
251 this.state = FeedbackModalState::CanSubmit;
252 cx.notify();
253 })
254 .log_err();
255 }
256 }
257 }
258 })
259 .detach();
260
261 Task::ready(Ok(()))
262 }
263
264 async fn submit_feedback(
265 feedback_text: &str,
266 email: Option<String>,
267 zed_client: Arc<Client>,
268 system_specs: SystemSpecs,
269 ) -> anyhow::Result<()> {
270 if DEV_MODE {
271 smol::Timer::after(SEND_TIME_IN_DEV_MODE).await;
272
273 if SEND_SUCCESS_IN_DEV_MODE {
274 return Ok(());
275 } else {
276 return Err(anyhow!("Error submitting feedback"));
277 }
278 }
279
280 let feedback_endpoint = format!("{}/api/feedback", *ZED_SERVER_URL);
281 let telemetry = zed_client.telemetry();
282 let metrics_id = telemetry.metrics_id();
283 let installation_id = telemetry.installation_id();
284 let is_staff = telemetry.is_staff();
285 let http_client = zed_client.http_client();
286 let request = FeedbackRequestBody {
287 feedback_text: &feedback_text,
288 email,
289 metrics_id,
290 installation_id,
291 system_specs,
292 is_staff: is_staff.unwrap_or(false),
293 token: ZED_SECRET_CLIENT_TOKEN,
294 };
295 let json_bytes = serde_json::to_vec(&request)?;
296 let request = Request::post(feedback_endpoint)
297 .header("content-type", "application/json")
298 .body(json_bytes.into())?;
299 let mut response = http_client.send(request).await?;
300 let mut body = String::new();
301 response.body_mut().read_to_string(&mut body).await?;
302 let response_status = response.status();
303 if !response_status.is_success() {
304 bail!("Feedback API failed with error: {}", response_status)
305 }
306 Ok(())
307 }
308
309 fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
310 cx.emit(DismissEvent)
311 }
312}
313
314impl Render for FeedbackModal {
315 type Element = Div;
316
317 fn render(&mut self, cx: &mut ViewContext<Self>) -> Self::Element {
318 let valid_email_address = match self.email_address_editor.read(cx).text_option(cx) {
319 Some(email_address) => Regex::new(EMAIL_REGEX).unwrap().is_match(&email_address),
320 None => true,
321 };
322
323 let valid_character_count = FEEDBACK_CHAR_LIMIT.contains(&self.character_count);
324
325 let awaiting_submission_response =
326 self.state == FeedbackModalState::AwaitingSubmissionResponse;
327
328 let allow_submission =
329 valid_character_count && valid_email_address && !awaiting_submission_response;
330
331 let submit_button_text = if awaiting_submission_response {
332 "Submitting..."
333 } else {
334 "Submit"
335 };
336
337 let open_community_repo =
338 cx.listener(|_, _, cx| cx.dispatch_action(Box::new(OpenZedCommunityRepo)));
339
340 // Moved this here because providing it inline breaks rustfmt
341 let provide_an_email_address =
342 "Provide an email address if you want us to be able to reply.";
343
344 v_stack()
345 .elevation_3(cx)
346 .key_context("GiveFeedback")
347 .on_action(cx.listener(Self::cancel))
348 .min_w(rems(40.))
349 .max_w(rems(96.))
350 .h(rems(32.))
351 .p_4()
352 .gap_4()
353 .child(v_stack().child(
354 // TODO: Add Headline component to `ui2`
355 div().text_xl().child("Share Feedback"),
356 ))
357 .child(
358 Label::new(if self.character_count < *FEEDBACK_CHAR_LIMIT.start() {
359 format!(
360 "Feedback must be at least {} characters.",
361 FEEDBACK_CHAR_LIMIT.start()
362 )
363 } else {
364 format!(
365 "Characters: {}",
366 *FEEDBACK_CHAR_LIMIT.end() - self.character_count
367 )
368 })
369 .color(if valid_character_count {
370 Color::Success
371 } else {
372 Color::Error
373 }),
374 )
375 .child(
376 div()
377 .flex_1()
378 .bg(cx.theme().colors().editor_background)
379 .p_2()
380 .border()
381 .rounded_md()
382 .border_color(cx.theme().colors().border)
383 .child(self.feedback_editor.clone()),
384 )
385 .child(
386 div()
387 .child(
388 h_stack()
389 .bg(cx.theme().colors().editor_background)
390 .p_2()
391 .border()
392 .rounded_md()
393 .border_color(if valid_email_address {
394 cx.theme().colors().border
395 } else {
396 red()
397 })
398 .child(self.email_address_editor.clone()),
399 )
400 .child(
401 h_stack()
402 .justify_between()
403 .gap_1()
404 .child(
405 Button::new("community_repo", "Community Repo")
406 .style(ButtonStyle::Transparent)
407 .icon(Icon::ExternalLink)
408 .icon_position(IconPosition::End)
409 .icon_size(IconSize::Small)
410 .on_click(open_community_repo),
411 )
412 .child(
413 h_stack()
414 .gap_1()
415 .child(
416 Button::new("cancel_feedback", "Cancel")
417 .style(ButtonStyle::Subtle)
418 .color(Color::Muted)
419 .on_click(cx.listener(move |_, _, cx| {
420 cx.spawn(|this, mut cx| async move {
421 this.update(&mut cx, |_, cx| {
422 cx.emit(DismissEvent)
423 })
424 .ok();
425 })
426 .detach();
427 })),
428 )
429 .child(
430 Button::new("send_feedback", submit_button_text)
431 .color(Color::Accent)
432 .style(ButtonStyle::Filled)
433 .on_click(cx.listener(|this, _, cx| {
434 this.submit(cx).detach();
435 }))
436 .tooltip(move |cx| {
437 Tooltip::with_meta(
438 "Submit feedback to the Zed team.",
439 None,
440 provide_an_email_address,
441 cx,
442 )
443 })
444 .when(!allow_submission, |this| this.disabled(true)),
445 ),
446 ),
447 ),
448 )
449 }
450}
451
452// TODO: Maybe store email address whenever the modal is closed, versus just on submit, so users can remove it if they want without submitting
453// TODO: Testing of various button states, dismissal prompts, etc.