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