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