Merge pull request #93 from ChipaDevTeam/copilot/add-pending-order-cancellation

Add pending-order cancellation API and enable multi in-flight pending orders

Author: theshadow76

BinaryOptionsToolsV2/python/BinaryOptionsToolsV2/pocketoption/asynchronous.py

@@ -491,9 +491,9 @@ async def get_pending_deals(self) -> List[Dict]:
         """
         return json.loads(await self.client.get_pending_deals())
 
-    async def open_pending_order(
-        self,
-        open_type: int,
+    async def open_pending_order(
+        self,
+        open_type: int,
         amount: float,
         asset: str,
         open_time: int,
@@ -518,10 +518,20 @@ async def open_pending_order(
         Returns:
             Dict: The created pending order details.
         """
-        order = await self.client.open_pending_order(
-            open_type, amount, asset, open_time, open_price, timeframe, min_payout, command
-        )
-        return json.loads(order)
+        order = await self.client.open_pending_order(
+            open_type, amount, asset, open_time, open_price, timeframe, min_payout, command
+        )
+        return json.loads(order)
+
+    async def cancel_pending_order(self, ticket: str) -> Dict:
+        """Cancels a pending order by ticket UUID."""
+        result = await self.client.cancel_pending_order(ticket)
+        return json.loads(result)
+
+    async def cancel_pending_orders(self, tickets: List[str]) -> List[Dict]:
+        """Cancels multiple pending orders by ticket UUID."""
+        result = await self.client.cancel_pending_orders(tickets)
+        return json.loads(result)
 
     async def closed_deals(self) -> List[Dict]:
         """Retrieves a list of all closed/completed deals.

BinaryOptionsToolsV2/python/BinaryOptionsToolsV2/pocketoption/synchronous.py

@@ -391,9 +391,9 @@ def get_pending_deals(self) -> List[Dict]:
         with self._lock:
             return self.loop.run_until_complete(self._client.get_pending_deals())
 
-    def open_pending_order(
-        self,
-        open_type: int,
+    def open_pending_order(
+        self,
+        open_type: int,
         amount: float,
         asset: str,
         open_time: int,
@@ -420,12 +420,22 @@ def open_pending_order(
         """
         with self._lock:
             return self.loop.run_until_complete(
-                self._client.open_pending_order(
-                    open_type, amount, asset, open_time, open_price, timeframe, min_payout, command
-                )
-            )
-
-    def closed_deals(self) -> List[Dict]:
+                self._client.open_pending_order(
+                    open_type, amount, asset, open_time, open_price, timeframe, min_payout, command
+                )
+            )
+
+    def cancel_pending_order(self, ticket: str) -> Dict:
+        """Cancels a pending order by ticket UUID."""
+        with self._lock:
+            return self.loop.run_until_complete(self._client.cancel_pending_order(ticket))
+
+    def cancel_pending_orders(self, tickets: List[str]) -> List[Dict]:
+        """Cancels multiple pending orders by ticket UUID."""
+        with self._lock:
+            return self.loop.run_until_complete(self._client.cancel_pending_orders(tickets))
+
+    def closed_deals(self) -> List[Dict]:
         "Returns a list of all the closed deals as dictionaries"
         with self._lock:
             return self.loop.run_until_complete(self._client.closed_deals())

BinaryOptionsToolsV2/rust/src/pocketoption.rs

@@ -391,6 +391,51 @@ impl RawPocketOption {
         })
     }
 
+    pub fn cancel_pending_order<'py>(
+        &self,
+        py: Python<'py>,
+        ticket: String,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let client = self.client.clone();
+        let ticket = Uuid::parse_str(&ticket).map_err(|_| {
+            BinaryErrorPy::InvalidParameter(format!("Invalid ticket UUID: {}", ticket))
+        })?;
+
+        future_into_py(py, async move {
+            let res = client
+                .cancel_pending_order(ticket)
+                .await
+                .map_err(BinaryErrorPy::from)?;
+            let result = serde_json::to_string(&res).map_err(BinaryErrorPy::from)?;
+            Ok(result)
+        })
+    }
+
+    pub fn cancel_pending_orders<'py>(
+        &self,
+        py: Python<'py>,
+        tickets: Vec<String>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        let client = self.client.clone();
+        let tickets = tickets
+            .into_iter()
+            .map(|ticket| {
+                Uuid::parse_str(&ticket).map_err(|_| {
+                    BinaryErrorPy::InvalidParameter(format!("Invalid ticket UUID: {}", ticket))
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        future_into_py(py, async move {
+            let res = client
+                .cancel_pending_orders(tickets)
+                .await
+                .map_err(BinaryErrorPy::from)?;
+            let result = serde_json::to_string(&res).map_err(BinaryErrorPy::from)?;
+            Ok(result)
+        })
+    }
+
     pub fn closed_deals<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         let client = self.client.clone();
         future_into_py(py, async move {

crates/binary_options_tools/examples/pending_trades_example.rs

@@ -77,6 +77,7 @@ fn create_test_pending_order(req_id: Uuid) -> PendingOrder {
         timeframe: 60,
         min_payout: 85,
         command: 0,
+        status: None,
         date_created: "2024-01-01 10:00:00".to_string(),
         id: 12345,
     }
@@ -265,6 +266,7 @@ async fn example_concurrent_pending_orders() -> PocketResult<()> {
                 timeframe: 60,
                 min_payout: 85,
                 command: 0,
+                status: None,
                 date_created: "2024-01-01 10:00:00".to_string(),
                 id: (1000 + i) as u64,
             };
@@ -304,6 +306,7 @@ async fn example_concurrent_pending_orders() -> PocketResult<()> {
                 timeframe: 60,
                 min_payout: 85,
                 command: 0,
+                status: None,
                 date_created: "2024-01-01 10:00:00".to_string(),
                 id: (1000 + i) as u64,
             };