From 885c85fe95a2f1ae9f7cf554d84a8685b02f5ff5 Mon Sep 17 00:00:00 2001 From: Joel Tony Date: Thu, 12 Nov 2026 13:49:45 +0530 Subject: [PATCH] fix(tui): report autoslice slices that Kite rejected When an order from the TUI ticket is autosliced, show an error toast if Kite rejects any slice. The toast gives the failed slice count and each failed slice's reason. Slices are numbered as in the CLI: the top-level order is slice 1 and children are slices 2 onwards. Share the CLI's slice reading and wording from src/app/render.rs. The AMO retry reply is read the same way. --- CHANGELOG.md | 1 + src/app/render.rs | 66 ++++++++++++++++++++++++++++----- src/tui/app/events/mod.rs | 10 ++++- src/tui/app/events/results.rs | 18 +++++++-- src/tui/app/regressions.rs | 63 +++++++++++++++++++++++++++++-- src/tui/app/test_support.rs | 24 ++++++++++-- src/tui/data.rs | 70 +++++++++++++++++++++++++++++++++-- 7 files changed, 229 insertions(+), 23 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 00d4cca..150db3b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). - `kite orders place` refuses orders that are incomplete as written, in dry runs and with `--confirm`: a LIMIT or SL order without a positive `--price`, an SL or SL-M order without a positive `--trigger-price`, `--variety iceberg` without `--iceberg-legs`, `--variety auction` without `--auction-number`, `--validity TTL` without `--validity-ttl`, and iceberg or TTL flags given without their variety or validity. It previously printed a dry run and exited 0. - `kite orders place` and `kite orders modify` refuse a zero or negative `--quantity` and a negative `--disclosed-quantity`. +- An autoslice order placed from the TUI order ticket shows an error toast when Kite rejects a slice. The toast counts the failed slices and gives each one's reason. It previously showed only the first order ID as placed. This also covers orders the ticket slices by itself above the freeze quantity. ## [0.2.3] - 2026-11-12 diff --git a/src/app/render.rs b/src/app/render.rs index 6302354..80b672f 100644 --- a/src/app/render.rs +++ b/src/app/render.rs @@ -1314,21 +1314,17 @@ pub(crate) fn write_result(value: &Value, headline: &str, summary: &str, doc: &m return; } let slices = slices(value); - let unreadable = !value["children"].is_null() && !value["children"].is_array(); - let failed = slices.iter().filter(|slice| slice.is_err()).count(); - let headline = if unreadable { - format!("{headline}, could not read slice results") - } else if failed == 0 { - headline.to_string() - } else { - format!("{headline}, {failed} of {} slices failed", slices.len() + 1) + let warning = slice_warning(value, &slices); + let headline = match &warning { + Some(warning) => format!("{headline}, {warning}"), + None => headline.to_string(), }; let headline = if summary.is_empty() { headline } else { format!("{headline} {summary}") }; - if failed == 0 && !unreadable { + if warning.is_none() { doc.success(&headline); } else { doc.line(vec![Cell::from("!").tone(Tone::Warn), headline.into()]); @@ -1363,6 +1359,31 @@ fn slices(value: &Value) -> Vec> { children.map(slice).collect() } +/// The headline warning when a slice failed or the slices could not be read. +fn slice_warning(value: &Value, slices: &[Result]) -> Option { + if !value["children"].is_null() && !value["children"].is_array() { + return Some("could not read slice results".into()); + } + let failed = slices.iter().filter(|slice| slice.is_err()).count(); + (failed > 0).then(|| format!("{failed} of {} slices failed", slices.len() + 1)) +} + +/// The slice warning followed by each failed slice, on one line. +pub(crate) fn slice_problems(value: &Value) -> Option { + let slices = slices(value); + let warning = slice_warning(value, &slices)?; + let failed = (2..).zip(&slices).filter_map(|(number, slice)| { + let reason = slice.as_ref().err()?; + Some(format!("Slice {number} {reason}")) + }); + Some( + std::iter::once(warning) + .chain(failed) + .collect::>() + .join("; "), + ) +} + /// A child's order ID, or why Kite did not place it. fn slice(child: &Value) -> Result { let error = &child["error"]; @@ -1594,6 +1615,33 @@ mod tests { } } + #[test] + fn slice_problems_number_failed_slices_from_two() { + for value in [ + serde_json::json!({"order_id":"first"}), + serde_json::json!({"order_id":"first", "children":null}), + serde_json::json!({"order_id":"first", "children":[]}), + serde_json::json!({"order_id":"first", "children":[{"order_id":"second"}]}), + ] { + assert_eq!(slice_problems(&value), None, "{value}"); + } + assert_eq!( + slice_problems(&serde_json::json!({"order_id":"first", "children":"Rejected"})), + Some("could not read slice results".into()) + ); + assert_eq!( + slice_problems(&serde_json::json!({"order_id":"first", "children":[ + {"error":{"message":"Rejected", "error_type":"OrderException"}}, + {"order_id":"third"}, + {} + ]})), + Some( + "2 of 4 slices failed; Slice 2 failed: Rejected (OrderException); Slice 4 failed" + .into() + ) + ); + } + #[test] fn ticker_fixture_prints_a_fixed_width_line_and_reuses_quote_arithmetic() { let fixture: Value = diff --git a/src/tui/app/events/mod.rs b/src/tui/app/events/mod.rs index 3e1917e..88e018c 100644 --- a/src/tui/app/events/mod.rs +++ b/src/tui/app/events/mod.rs @@ -5,7 +5,7 @@ use super::panes::chain::today_ist; use super::{App, Book, Modal, ToastLevel}; use crate::tui::bids; use crate::tui::candles::SeriesKey; -use crate::tui::data::{self, DataEvent}; +use crate::tui::data::{self, DataEvent, OrderReply}; use crate::tui::event::AppEvent; use crate::tui::workspace::PaneId; @@ -298,7 +298,13 @@ impl App { self.pump_candles(); } DataEvent::OrderPlaced(result) => self.on_order_result("placed", result), - DataEvent::OrderModified(result) => self.on_order_result("modified", result), + DataEvent::OrderModified(result) => self.on_order_result( + "modified", + result.map(|order_id| OrderReply { + order_id, + slice_problems: None, + }), + ), DataEvent::PositionConverted(result) => self.on_position_conversion(result), DataEvent::HoldingsAuthorised(result) => self.on_holdings_authorised(result), DataEvent::OrdersCancelled(result) => self.on_orders_cancelled(&result), diff --git a/src/tui/app/events/results.rs b/src/tui/app/events/results.rs index 76878df..43f9722 100644 --- a/src/tui/app/events/results.rs +++ b/src/tui/app/events/results.rs @@ -1,17 +1,29 @@ use super::super::{App, SESSION_EXPIRED, ToastLevel}; -use crate::tui::data; +use crate::tui::data::{self, OrderReply}; impl App { pub(in crate::tui::app) fn on_order_result( &mut self, verb: &str, - result: Result, + result: Result, ) { self.pending_action = false; match result { - Ok(order_id) => { + Ok(OrderReply { + order_id, + slice_problems: None, + }) => { self.toast(ToastLevel::Success, format!("order {verb}: {order_id}")); } + Ok(OrderReply { + order_id, + slice_problems: Some(problems), + }) => { + self.toast( + ToastLevel::Error, + format!("order {verb}: {order_id}, {problems}"), + ); + } Err(err) => { self.toast( ToastLevel::Error, diff --git a/src/tui/app/regressions.rs b/src/tui/app/regressions.rs index 98178b3..8c03d87 100644 --- a/src/tui/app/regressions.rs +++ b/src/tui/app/regressions.rs @@ -1,9 +1,9 @@ use super::navigation::tests::stocked; use super::test_support::{ - H, W, ato_alert, char_key, char_key_code, master_inst, position, render, screen, server_alert, - test_app, + H, W, ato_alert, char_key, char_key_code, master_inst, mock_app, open_and_review, position, + render, screen, server_alert, test_app, }; -use super::{Modal, OrderDetailState, SearchPurpose, SearchState}; +use super::{Modal, OrderDetailState, SearchPurpose, SearchState, ToastLevel}; use crate::tui::candles::SeriesKey; use crate::tui::data::{AlertListSequence, DataEvent, Order, OrderHistoryRequest}; use crate::tui::event::AppEvent; @@ -435,3 +435,60 @@ fn order_detail_shows_the_exchange_order_id_or_why_it_is_missing() { assert!(!rejected.contains("Exch time"), "{rejected}"); assert!(rejected.contains("Insufficient funds."), "{rejected}"); } + +#[tokio::test] +async fn a_rejected_autoslice_slice_is_reported() { + let failed: serde_json::Value = serde_json::from_str(include_str!( + "../../../mock_responses/autoslice_response.json" + )) + .expect("autoslice response"); + let mut placed = failed.clone(); + placed["data"]["children"] + .as_array_mut() + .expect("children") + .remove(2); + for (reply, level, text) in [ + ( + failed, + ToastLevel::Error, + "order placed: 1914227164488687616, 1 of 5 slices failed; Slice 4 failed: Insufficient funds. Required margin is 228365.92 but available margin is 228358.50. (MarginException)", + ), + ( + placed, + ToastLevel::Success, + "order placed: 1914227164488687616", + ), + ] { + let server = httpmock::MockServer::start_async().await; + let place = server + .mock_async(|when, then| { + when.method(httpmock::Method::POST) + .path("/orders/regular") + .form_urlencoded_tuple("autoslice", "true"); + then.status(200).json_body(reply); + }) + .await; + let (mut app, mut events) = mock_app(&server); + // Above the freeze quantity the ticket sends autoslice by itself. + open_and_review(&mut app, "NSE", "INFY", 408_065, |state| { + state.autoslice = false; + state.freeze_quantity = Some(1800); + state.qty = "9000".to_string(); + state.price = "1500".to_string(); + }); + app.on_key(char_key('y')); + loop { + let event = tokio::time::timeout(std::time::Duration::from_secs(5), events.recv()) + .await + .expect("the order reply arrives") + .expect("the event channel is open"); + if matches!(event, AppEvent::Data(DataEvent::OrderPlaced(_))) { + app.on_event(event); + break; + } + } + let toast = app.toasts().back().expect("a toast"); + assert_eq!((toast.level, toast.text.as_str()), (level, text)); + place.assert_calls_async(1).await; + } +} diff --git a/src/tui/app/test_support.rs b/src/tui/app/test_support.rs index eb5443b..a7398f4 100644 --- a/src/tui/app/test_support.rs +++ b/src/tui/app/test_support.rs @@ -5,6 +5,7 @@ use super::{ use crate::tui::alerts::{self, Attribute, Operator}; use crate::tui::data::Alert; use crate::tui::data::{Holding, Order, Position}; +use crate::tui::event::AppEvent; use crate::tui::form::ControlIntent; use crate::tui::instruments::Instrument; use crate::tui::marketwatch::State as WatchState; @@ -23,15 +24,32 @@ pub(super) fn test_app() -> App { .access_token(kiteconnect::AccessToken::new("tok").unwrap()) .build() .expect("dummy client builds"); - let (events_tx, _events_rx) = mpsc::channel(8); - App::new( + app_with(client).0 +} + +/// An app whose Kite requests go to `server`, and the receiver for its events. +pub(in crate::tui::app) fn mock_app( + server: &httpmock::MockServer, +) -> (App, mpsc::Receiver) { + let client = KiteConnect::builder("test-key") + .access_token(kiteconnect::AccessToken::new("tok").unwrap()) + .base_url(server.base_url()) + .build() + .expect("mock client builds"); + app_with(client) +} + +fn app_with(client: KiteConnect) -> (App, mpsc::Receiver) { + let (events_tx, events_rx) = mpsc::channel(8); + let app = App::new( client, events_tx, WatchState::test_loaded(Vec::new()), Pad::default(), false, &Settings::default(), - ) + ); + (app, events_rx) } pub(super) fn holding( diff --git a/src/tui/data.rs b/src/tui/data.rs index 8fa5a29..a4c7ecf 100644 --- a/src/tui/data.rs +++ b/src/tui/data.rs @@ -116,6 +116,14 @@ impl CancelOrdersResult { } } +/// Kite's reply to an order write. +#[derive(Debug, PartialEq, Eq)] +pub struct OrderReply { + pub order_id: String, + /// Autoslice slices that failed or could not be read, as the CLI words them. + pub slice_problems: Option, +} + #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default)] pub struct AlertListSequence(pub u64); @@ -158,7 +166,7 @@ pub enum DataEvent { result: Result, String>, }, Instruments(Result, String>), - OrderPlaced(Result), + OrderPlaced(Result), OrderModified(Result), PositionConverted(Result<(), String>), HoldingsAuthorised(Result), @@ -714,7 +722,10 @@ pub fn spawn_place_order( let result = place_with_amo_fallback(&client, &variety, form) .await .map_err(api_write_err) - .map(|value| response_id(&value, "order_id").unwrap_or_else(|| "unknown".to_string())); + .map(|value| OrderReply { + order_id: response_id(&value, "order_id").unwrap_or_else(|| "unknown".to_string()), + slice_problems: crate::app::render::slice_problems(&value), + }); send(&tx, DataEvent::OrderPlaced(result)).await; }); } @@ -1631,7 +1642,14 @@ mod tests { ); match next_event(&mut rx).await { - DataEvent::OrderPlaced(Ok(id)) => assert_eq!(id, expected, "{data}"), + DataEvent::OrderPlaced(Ok(reply)) => assert_eq!( + reply, + super::OrderReply { + order_id: expected.to_string(), + slice_problems: None, + }, + "{data}" + ), other => panic!("{data}: unexpected {other:?}"), } regular.assert_calls_async(1).await; @@ -1798,6 +1816,52 @@ mod tests { amo.assert_calls(1); } + #[tokio::test] + async fn an_amo_retry_reports_failed_autoslice_slices_too() { + let server = MockServer::start_async().await; + let regular = server.mock(|when, then| { + when.method(POST) + .path("/orders/regular") + .form_urlencoded_tuple("autoslice", "true"); + then.status(400) + .header("content-type", "application/json") + .body(SWITCH_TO_AMO); + }); + let amo = server.mock(|when, then| { + when.method(POST) + .path("/orders/amo") + .form_urlencoded_tuple("autoslice", "true") + .body_includes("tag=switch_to_amo"); + then.status(200) + .header("content-type", "application/json") + .body(include_str!("../../mock_responses/autoslice_response.json")); + }); + let (tx, mut rx) = mpsc::channel(1); + + super::spawn_place_order( + connect_client(&server), + tx, + "regular".to_string(), + vec![("autoslice".to_string(), "true".to_string())], + ); + + match next_event(&mut rx).await { + DataEvent::OrderPlaced(Ok(reply)) => assert_eq!( + reply, + super::OrderReply { + order_id: "1914227164488687616".to_string(), + slice_problems: Some( + "1 of 5 slices failed; Slice 4 failed: Insufficient funds. Required margin is 228365.92 but available margin is 228358.50. (MarginException)" + .to_string() + ), + } + ), + other => panic!("unexpected {other:?}"), + } + regular.assert_calls(1); + amo.assert_calls(1); + } + #[tokio::test] async fn amo_retry_failure_is_returned() { let server = MockServer::start();