1use std::{ops::RangeInclusive, sync::Arc, time::Duration};
2
3use anyhow::{anyhow, bail};
4use bitflags::bitflags;
5use client::{Client, ZED_SERVER_URL};
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 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, Toast, 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}
50
51bitflags! {
52 #[derive(Debug, Clone, PartialEq)]
53 struct InvalidStateFlags: u8 {
54 const EmailAddress = 0b00000001;
55 const CharacterCount = 0b00000010;
56 }
57}
58
59#[derive(Debug, Clone, PartialEq)]
60enum CannotSubmitReason {
61 InvalidState { flags: InvalidStateFlags },
62 AwaitingSubmission,
63}
64
65#[derive(Debug, Clone, PartialEq)]
66enum SubmissionState {
67 CanSubmit,
68 CannotSubmit { reason: CannotSubmitReason },
69}
70
71pub struct FeedbackModal {
72 system_specs: SystemSpecs,
73 feedback_editor: View<Editor>,
74 email_address_editor: View<Editor>,
75 submission_state: Option<SubmissionState>,
76 dismiss_modal: bool,
77 character_count: i32,
78}
79
80impl FocusableView for FeedbackModal {
81 fn focus_handle(&self, cx: &AppContext) -> FocusHandle {
82 self.feedback_editor.focus_handle(cx)
83 }
84}
85impl EventEmitter<DismissEvent> for FeedbackModal {}
86
87impl ModalView for FeedbackModal {
88 fn on_before_dismiss(&mut self, cx: &mut ViewContext<Self>) -> bool {
89 self.update_email_in_store(cx);
90
91 if self.dismiss_modal {
92 return true;
93 }
94
95 let has_feedback = self.feedback_editor.read(cx).text_option(cx).is_some();
96 if !has_feedback {
97 return true;
98 }
99
100 let answer = cx.prompt(PromptLevel::Info, "Discard feedback?", &["Yes", "No"]);
101
102 cx.spawn(move |this, mut cx| async move {
103 if answer.await.ok() == Some(0) {
104 this.update(&mut cx, |this, cx| {
105 this.dismiss_modal = true;
106 cx.emit(DismissEvent)
107 })
108 .log_err();
109 }
110 })
111 .detach();
112
113 false
114 }
115}
116
117impl FeedbackModal {
118 pub fn register(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) {
119 let _handle = cx.view().downgrade();
120 workspace.register_action(move |workspace, _: &GiveFeedback, cx| {
121 let markdown = workspace
122 .app_state()
123 .languages
124 .language_for_name("Markdown");
125
126 let project = workspace.project().clone();
127 let is_local_project = project.read(cx).is_local();
128
129 if !is_local_project {
130 const TOAST_ID: usize = 0xdeadbeef;
131
132 workspace.show_toast(
133 Toast::new(
134 TOAST_ID,
135 "You can only submit feedback in your own project.",
136 ),
137 cx,
138 );
139 return;
140 }
141
142 cx.spawn(|workspace, mut cx| async move {
143 let markdown = markdown.await.log_err();
144 let buffer = project
145 .update(&mut cx, |project, cx| {
146 project.create_buffer("", markdown, cx)
147 })?
148 .expect("creating buffers on a local workspace always succeeds");
149
150 workspace.update(&mut cx, |workspace, cx| {
151 let system_specs = SystemSpecs::new(cx);
152
153 workspace.toggle_modal(cx, move |cx| {
154 FeedbackModal::new(system_specs, project, buffer, cx)
155 });
156 })?;
157
158 anyhow::Ok(())
159 })
160 .detach_and_log_err(cx);
161 });
162 }
163
164 pub fn new(
165 system_specs: SystemSpecs,
166 project: Model<Project>,
167 buffer: Model<Buffer>,
168 cx: &mut ViewContext<Self>,
169 ) -> Self {
170 let email_address_editor = cx.new_view(|cx| {
171 let mut editor = Editor::single_line(cx);
172 editor.set_placeholder_text("Email address (optional)", cx);
173
174 if let Ok(Some(email_address)) = KEY_VALUE_STORE.read_kvp(DATABASE_KEY_NAME) {
175 editor.set_text(email_address, cx)
176 }
177
178 editor
179 });
180
181 let feedback_editor = cx.new_view(|cx| {
182 let mut editor = Editor::for_buffer(buffer, Some(project.clone()), cx);
183 editor.set_placeholder_text(
184 "You can use markdown to organize your feedback with code and links.",
185 cx,
186 );
187 editor.set_show_gutter(false, cx);
188 editor.set_show_copilot_suggestions(false);
189 editor.set_vertical_scroll_margin(5, cx);
190 editor
191 });
192
193 cx.subscribe(&feedback_editor, |this, editor, event: &EditorEvent, cx| {
194 if *event == EditorEvent::Edited {
195 this.character_count = editor
196 .read(cx)
197 .buffer()
198 .read(cx)
199 .as_singleton()
200 .expect("Feedback editor is never a multi-buffer")
201 .read(cx)
202 .len() as i32;
203 cx.notify();
204 }
205 })
206 .detach();
207
208 Self {
209 system_specs: system_specs.clone(),
210 feedback_editor,
211 email_address_editor,
212 submission_state: None,
213 dismiss_modal: false,
214 character_count: 0,
215 }
216 }
217
218 pub fn submit(&mut self, cx: &mut ViewContext<Self>) -> Task<anyhow::Result<()>> {
219 let feedback_text = self.feedback_editor.read(cx).text(cx).trim().to_string();
220 let email = self.email_address_editor.read(cx).text_option(cx);
221
222 let answer = cx.prompt(
223 PromptLevel::Info,
224 "Ready to submit your feedback?",
225 &["Yes, Submit!", "No"],
226 );
227 let client = cx.global::<Arc<Client>>().clone();
228 let specs = self.system_specs.clone();
229 cx.spawn(|this, mut cx| async move {
230 let answer = answer.await.ok();
231 if answer == Some(0) {
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 };
308 let json_bytes = serde_json::to_vec(&request)?;
309 let request = Request::post(feedback_endpoint)
310 .header("content-type", "application/json")
311 .body(json_bytes.into())?;
312 let mut response = http_client.send(request).await?;
313 let mut body = String::new();
314 response.body_mut().read_to_string(&mut body).await?;
315 let response_status = response.status();
316 if !response_status.is_success() {
317 bail!("Feedback API failed with error: {}", response_status)
318 }
319 Ok(())
320 }
321
322 fn update_submission_state(&mut self, cx: &mut ViewContext<Self>) {
323 if self.awaiting_submission() {
324 return;
325 }
326
327 let mut invalid_state_flags = InvalidStateFlags::empty();
328
329 let valid_email_address = match self.email_address_editor.read(cx).text_option(cx) {
330 Some(email_address) => Regex::new(EMAIL_REGEX).unwrap().is_match(&email_address),
331 None => true,
332 };
333
334 if !valid_email_address {
335 invalid_state_flags |= InvalidStateFlags::EmailAddress;
336 }
337
338 if !FEEDBACK_CHAR_LIMIT.contains(&self.character_count) {
339 invalid_state_flags |= InvalidStateFlags::CharacterCount;
340 }
341
342 if invalid_state_flags.is_empty() {
343 self.submission_state = Some(SubmissionState::CanSubmit);
344 } else {
345 self.submission_state = Some(SubmissionState::CannotSubmit {
346 reason: CannotSubmitReason::InvalidState {
347 flags: invalid_state_flags,
348 },
349 });
350 }
351 }
352
353 fn update_email_in_store(&self, cx: &mut ViewContext<Self>) {
354 let email = self.email_address_editor.read(cx).text_option(cx);
355
356 cx.spawn(|_, _| async move {
357 match email {
358 Some(email) => {
359 KEY_VALUE_STORE
360 .write_kvp(DATABASE_KEY_NAME.to_string(), email)
361 .await
362 .ok();
363 }
364 None => {
365 KEY_VALUE_STORE
366 .delete_kvp(DATABASE_KEY_NAME.to_string())
367 .await
368 .ok();
369 }
370 }
371 })
372 .detach();
373 }
374
375 fn valid_email_address(&self) -> bool {
376 !self.in_invalid_state(InvalidStateFlags::EmailAddress)
377 }
378
379 fn valid_character_count(&self) -> bool {
380 !self.in_invalid_state(InvalidStateFlags::CharacterCount)
381 }
382
383 fn in_invalid_state(&self, flag: InvalidStateFlags) -> bool {
384 match self.submission_state {
385 Some(SubmissionState::CannotSubmit {
386 reason: CannotSubmitReason::InvalidState { ref flags },
387 }) => flags.contains(flag),
388 _ => false,
389 }
390 }
391
392 fn awaiting_submission(&self) -> bool {
393 matches!(
394 self.submission_state,
395 Some(SubmissionState::CannotSubmit {
396 reason: CannotSubmitReason::AwaitingSubmission
397 })
398 )
399 }
400
401 fn can_submit(&self) -> bool {
402 matches!(self.submission_state, Some(SubmissionState::CanSubmit))
403 }
404
405 fn cancel(&mut self, _: &menu::Cancel, cx: &mut ViewContext<Self>) {
406 cx.emit(DismissEvent)
407 }
408}
409
410impl Render for FeedbackModal {
411 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
412 self.update_submission_state(cx);
413
414 let submit_button_text = if self.awaiting_submission() {
415 "Submitting..."
416 } else {
417 "Submit"
418 };
419
420 let open_community_repo =
421 cx.listener(|_, _, cx| cx.dispatch_action(Box::new(OpenZedCommunityRepo)));
422
423 v_flex()
424 .elevation_3(cx)
425 .key_context("GiveFeedback")
426 .on_action(cx.listener(Self::cancel))
427 .min_w(rems(40.))
428 .max_w(rems(96.))
429 .h(rems(32.))
430 .p_4()
431 .gap_2()
432 .child(Headline::new("Share Feedback"))
433 .child(
434 Label::new(if self.character_count < *FEEDBACK_CHAR_LIMIT.start() {
435 format!(
436 "Feedback must be at least {} characters.",
437 FEEDBACK_CHAR_LIMIT.start()
438 )
439 } else {
440 format!(
441 "Characters: {}",
442 *FEEDBACK_CHAR_LIMIT.end() - self.character_count
443 )
444 })
445 .color(if self.valid_character_count() {
446 Color::Success
447 } else {
448 Color::Error
449 }),
450 )
451 .child(
452 div()
453 .flex_1()
454 .bg(cx.theme().colors().editor_background)
455 .p_2()
456 .border()
457 .rounded_md()
458 .border_color(cx.theme().colors().border)
459 .child(self.feedback_editor.clone()),
460 )
461 .child(
462 v_flex()
463 .gap_1()
464 .child(
465 h_flex()
466 .bg(cx.theme().colors().editor_background)
467 .p_2()
468 .border()
469 .rounded_md()
470 .border_color(if self.valid_email_address() {
471 cx.theme().colors().border
472 } else {
473 cx.theme().status().error_border
474 })
475 .child(self.email_address_editor.clone()),
476 )
477 .child(
478 Label::new("Provide an email address if you want us to be able to reply.")
479 .size(LabelSize::Small)
480 .color(Color::Muted),
481 ),
482 )
483 .child(
484 h_flex()
485 .justify_between()
486 .gap_1()
487 .child(
488 Button::new("community_repository", "Community Repository")
489 .style(ButtonStyle::Transparent)
490 .icon(IconName::ExternalLink)
491 .icon_position(IconPosition::End)
492 .icon_size(IconSize::Small)
493 .on_click(open_community_repo),
494 )
495 .child(
496 h_flex()
497 .gap_1()
498 .child(
499 Button::new("cancel_feedback", "Cancel")
500 .style(ButtonStyle::Subtle)
501 .color(Color::Muted)
502 .on_click(cx.listener(move |_, _, cx| {
503 cx.spawn(|this, mut cx| async move {
504 this.update(&mut cx, |_, cx| cx.emit(DismissEvent))
505 .ok();
506 })
507 .detach();
508 })),
509 )
510 .child(
511 Button::new("submit_feedback", submit_button_text)
512 .color(Color::Accent)
513 .style(ButtonStyle::Filled)
514 .on_click(cx.listener(|this, _, cx| {
515 this.submit(cx).detach();
516 }))
517 .tooltip(move |cx| {
518 Tooltip::text("Submit feedback to the Zed team.", cx)
519 })
520 .when(!self.can_submit(), |this| this.disabled(true)),
521 ),
522 ),
523 )
524 }
525}
526
527// TODO: Testing of various button states, dismissal prompts, etc. :)