Trading API

 <?php
 	/**
 	* 
 	* API-call related functions
 	*
 	*/
 	
 	class CRXzoneAPI {
 		protected $BUY = '0';
 		protected $SELL = '1';
 		protected $public_api = 'https://www.crxzone.com/API/';
 		
 		protected $api_id;
 		protected $api_key;
 		
 		public $CurrencyPairs = array();
 		public $Balances = array();
 		
 		public function __construct($api_id, $api_key) {
 			$this->api_id = $api_id;
 			$this->api_key = $api_key;
 			
 			// Init currency pairs and balances
 			$this->RefreshCurrencyPairs();
 			$this->RefreshBalances();
 		}
 		
 		/**
 		* Call the API
 		*/
 		public function Query($method = '', $args = array()) {
 			// Prepare request before send
 			$this->Prepare($args);
 			$url = $this->public_api.$method;
 			$ch = curl_init();
 			if(strtolower((substr($url,0,5))=='https')) {
 				curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
 				curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, 0);
 			}
 			curl_setopt($ch, CURLOPT_URL, $url);
 			curl_setopt($ch, CURLOPT_REFERER, $url);
 			curl_setopt($ch, CURLOPT_VERBOSE, 0);
 			curl_setopt($ch, CURLOPT_POST, 1);
 			#curl_setopt($ch, CURLOPT_FOLLOWLOCATION, 1);
 			curl_setopt($ch, CURLOPT_POSTFIELDS, $args);
 			curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (Windows; U; Windows NT 5.0; En; rv:1.8.0.2) Gecko/20070306 Firefox/1.0.0.4");
 			curl_setopt($ch, CURLOPT_HEADER, 0);
 			curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
 			curl_setopt($ch, CURLOPT_TIMEOUT, 10);
 			$result = curl_exec($ch);
 			curl_close($ch);
 			return json_decode($result);
 		}
 		
 		/**
 		* Prepare request
 		*/
 		private function Prepare(&$Params) {
 			// Sort array by key (ASC)
 			if(isset($Params['signature'])) {
 				unset($Params['signature']);
 			}
 			
 			$Params = array_reverse($Params, true);
 			$Params['APIID'] = $this->api_id;
 			$Params = array_reverse($Params, true); 
 			
 			$SortedParams = array();
 			$a1 = array_keys($Params);
 			foreach($a1 as $key) {
 				$SortedParams[strtolower($key)] = $Params[$key];
 			}
 			ksort($SortedParams);
 			
 			// Implode values and append API key
 			$Imploded = implode(":", $SortedParams).":".$this->api_key;
 			
 			$SortedParams['signature'] = md5($Imploded);
 			$Params = $SortedParams;
 		}
 		
 		/**
 		* Refresh currency pairs information
 		*/
 		public function RefreshCurrencyPairs() {
 			$CurrencyResult = $this->Query("CurrencyPairs");
 			if($CurrencyResult->IsSuccess) {
 				$this->CurrencyPairs = array();
 				foreach($CurrencyResult->Result as $Pair) {
 					$Code = $Pair->PrimaryCurrencyCode.$Pair->SecondaryCurrencyCode;
 					$this->CurrencyPairs[$Code] = array(
 						"ID" => $Pair->ID,
 						"MinimumOrderAmount" => $Pair->MinimumOrderAmount
 					);
 					$TickerResult = $this->Query("Ticker", array('currencyPairID' => $Pair->ID));
 					
 					if($TickerResult->IsSuccess) {
 						$this->CurrencyPairs[$Code]["Price"] = $TickerResult->Result->Last;
 					} else {
 						$this->CurrencyPairs[$Code]["Price"] = 0;
 					}
 					
 				}
 			} else {
 				throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$CurrencyResult->ErrorMessage);
 			}
 		}
 		
 		/**
 		* Refresh balances information
 		*/
 		public function RefreshBalances() {
 			$AccountsResult = $this->Query("Accounts");
 			
 			if($AccountsResult->IsSuccess) {
 				$this->Balances = array();
 				foreach($AccountsResult->Result as $Account) {
 					$this->Balances[$Account->CurrencyCode] = array(
 						'Available'     => $Account->Available,
 						'InOrders'      => $Account->InOrders,
 						'InWithdrawals' => $Account->InWithdrawals,
 						'TotalHold'     => $Account->InOrders + $Account->InWithdrawals
 					);
 				}
 			} else {
 				throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$AccountsResult->ErrorMessage);
 			}
 		}
 		
 		/**
 		* Get last tick for currency pair
 		*/
 		public function GetTicker($CurrencyPair) {
 			if(array_key_exists($CurrencyPair, $this->CurrencyPairs)) {
 				$PairID = $this->CurrencyPairs[$CurrencyPair]["ID"];
 				$TickerResult = $this->Query("Ticker", array('currencyPairID' => $PairID));
 				if($TickerResult->IsSuccess) {
 					return $TickerResult->Result;
 				} else {
 					throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$TickerResult->ErrorMessage);
 				}
 			} else {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
 			}
 		}
 		
 		/**
 		* Get market depth
 		*/
 		public function GetMarketDepth($CurrencyPair) {
 			if(array_key_exists($CurrencyPair, $this->CurrencyPairs)) {
 				$PairID = $this->CurrencyPairs[$CurrencyPair]["ID"];
 				$DepthResult = $this->Query("Market_Depth", array('currencyPairID' => $PairID));
 				if($DepthResult->IsSuccess) {
 					return $TickerResult->Result;
 				} else {
 					throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$TickerResult->ErrorMessage);
 				}
 			} else {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
 			}
 		}
 		
 		/**
 		* Get list of orders
 		*/
 		// $CurrencyPair
 		// $Type = Active/Closed
 		// $RecordsCount = 0;
 		// $StartIndex = 0;
 		public function GetOrdersList($CurrencyPair, $Type = 'Active', $RecordsCount = 0, $StartIndex = 0) {
 			if(!array_key_exists($CurrencyPair, $this->CurrencyPairs)) {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
 			}
 			$PairID = $this->CurrencyPairs[$CurrencyPair]["ID"];
 			$return = array();
 			switch ($Type) {
 				case 'Active':
 					$OrdersResult = $this->Query("Orders_Active", array('currencyPairID' => $PairID));
 					if($OrdersResult->IsSuccess) {
 						$Orders = array();
 						$StartIndex = ($StartIndex < 0) ? 0 : $StartIndex;
 						$OrdersTotal = count($OrdersResult->Result);
 						if($RecordsCount != 0) {
 							$Counter = 0;
 							$Index = 0;
 							foreach($OrdersResult->Result as $Order) {
 								$Index++;
 								if($StartIndex > $Index) {
 									continue;
 								}
 								if($Counter > $RecordsCount) {
 									break;
 								}
 								$Counter++;
 								$Orders[$Order->ID] = $Order;
 							}
 						} else {
 							// All orders
 							$Index = 0;
 							foreach($OrdersResult->Result as $Order) {
 								$Index++;
 								if($StartIndex > $Index) {
 									continue;
 								}
 								$Orders[$Order->ID] = $Order;
 							}
 						}
 						$return['Orders'] = $Orders;
 						$return['TotalCount'] = $OrdersTotal;
 					} else {
 						throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrdersResult->ErrorMessage);
 					}
 					break;
 				case 'Closed':
 				default:
 					$OrdersResult = $this->Query("Orders_Active", array('currencyPairID' => $PairID, 'recordsCount' => $RecordsCount, 'startIndex' => $StartIndex));
 					if($OrdersResult->IsSuccess) {
 						$Orders = array();
 						foreach($OrdersResult->Result as $Order) {
 							$Orders[$Order->ID] = $Order;
 						}
 						$return['Orders'] = $Orders;
 						$return['TotalCount'] = $OrdersResult->TotalRecordsCount;
 					} else {
 						throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrdersResult->ErrorMessage);
 					}
 					break;
 			}
 			return $return;
 		}
 		
 		/**
 		* Get order by ID
 		*/
 		public function GetOrderByID($OrderID) {
 			if(is_int($OrderID)) {
 				$OrderResult = $this->Query("Order_Get", array('orderID' => $OrderID));
 				if($OrderResult->IsSuccess) {
 					return $OrderResult->Result;
 				} else {
 					throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
 				}
 			} else {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Order ID must be Integer.');
 			}
 		}
 		
 		/**
 		* Get market depth
 		*/
 		public function CreateOrder($CurrencyPair, $Price, $Amount, $Type = 'BUY') {
 			if(array_key_exists($CurrencyPair, $this->CurrencyPairs)) {
 				$Pair = $this->CurrencyPairs[$CurrencyPair];
 				if($Amount >= $Pair['MinimumOrderAmount']) {
 					switch(strtolower($Type)) {
 						case 'SELL':
 							$OrderType = $this->SELL;
 							break;
 						case 'BUY':
 						default:
 							$OrderType = $this->BUY;
 							break;
 					}
 					$Amount = number_format($Amount, 8, '.', '');
 					$Price = number_format($Price, 8, '.', '');
 					return $OrderResult = $this->Query("Order_Create", array('amount' => $Amount, 'currencyPairID' => $Pair['ID'], 'price' => $Price, 'type' => $OrderType));
 				} else {
 					throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
 				}
 			} else {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
 			}
 		}
 		
 		/**
 		* Get market depth
 		*/
 		public function CancelOrder($OrderID) {
 			if(is_int($OrderID)) {
 				$OrderResult = $this->Query("Order_Cancel", array('orderID' => $OrderID));
 				if($OrderResult->IsSuccess) {
 					return true;
 				} else {
 					throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
 				}
 			} else {
 				throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Order ID must be Integer.');
 			}
 		}
 	}
 	
 	/**
 	* Exceptions
 	*/
 	class CRXzoneAPIException extends Exception {}
 	class CRXzoneAPIFailureException extends CRXzoneAPIException {}
 	class CRXzoneAPIInvalidParameterException extends CRXzoneAPIException {}
 ?>
				

 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Net;
 using System.IO;
 using System.Security.Cryptography;
 using System.Security.Cryptography.X509Certificates;
 using System.Net.Security;
 using Newtonsoft.Json;
 using System.Web; //Add reference to System.Web
 using Newtonsoft.Json.Linq; //"Manage NuGet packages" -> Search for "newtonsoft json". -> click "install".
 namespace CRXZone
 {
 /*
                 {//Call anonymous method
                     var method = new CRXZone.API.MethodCall(CRXZone.API.API_Methods.CurrencyPairs);
                     method.Execute();
                     Console.WriteLine(method.Result.ToString());
                 }
 
                 {//Call secured method
                     var method = new CRXZone.API.MethodCall(CRXZone.API.API_Methods.Order_Create, 21235, "API_KEY_HERE");
                     method.AddParameter("currencyPairID", 1011);
                     method.AddParameter("price", 1M);
                     method.AddParameter("amount", 100M);
                     method.AddParameter("type", 1);
                     method.Execute();
                     Console.WriteLine(method.Result.ToString());
                 }
 */
     public class API
     {
         public enum SellBuy
         {
             Sell = 1,//BID
             Buy = 0,//ASK
         }
 
         public enum API_Methods 
         {
             PaySystems,
             CurrencyPairs,
             Ticker,
             Trades,
             Market_Depth,
             Accounts,
             Order_Cancel,
             Order_Create,
             Order_Get,
             Orders_Active,
             Orders_Closed,
             Withdrawal,
             Invoice_Get,
             Invoice_Create,
             Invoices_Get,
             PaymentAddress_Create,
             PaymentAddress_Update,
             PaymentAddress_Delete,
             PaymentAddresses_Get,
         }
 
         public class MethodCall 
         {
             const string APIURL = @"https://www.crxzone.com/API/";
 
             public long? APIID { get; set; }
             public string APIKey { get; set; }
             public string MethodName { get; set; }
             public JToken Result { get; private set; }
             private Dictionary<string, string> Parameters = new Dictionary<string, string>();
             
             public MethodCall(API_Methods method, long? APIID = null, string APIKey = null) : this(method.ToString(), APIID, APIKey) { }
             public MethodCall(string methodName, long? APIID = null, string APIKey = null)
             {
                 this.MethodName = methodName;
                 this.APIID = APIID;
                 this.APIKey = APIKey;
 
                 if (this.APIID.HasValue) 
                 {
                     this.AddParameter("APIID", APIID);
                 }
             }
 
             public void AddParameter(string name, object value) 
             {
                 Parameters.Add(name, value.ToString());
             }
 
             public void AddParameter(string name, long value)
             {
                 Parameters.Add(name, value.ToString());
             }
 
 
             public void AddParameter(string name, int value)
             {
                 Parameters.Add(name, value.ToString());
             }
 
             public void AddParameter(string name, short value)
             {
                 Parameters.Add(name, value.ToString());
             }
 
             public void AddParameter(string name, byte value)
             {
                 Parameters.Add(name, value.ToString());
             }
 
             public void AddParameter(string name, float value)
             {
                 Parameters.Add(name, value.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
             }
 
             public void AddParameter(string name, decimal value)
             {
                 Parameters.Add(name, value.ToString("0.00000000", System.Globalization.CultureInfo.InvariantCulture.NumberFormat));
             }
 
             public void Execute() 
             {
                 var tmpParameters = this.Parameters.ToDictionary(c => c.Key, c => c.Value);
                 var values = tmpParameters.OrderBy(c => c.Key).Select(c => c.Value).ToList();
                 if (!string.IsNullOrEmpty(this.APIKey)) 
                 {
                     values.Add(this.APIKey);
                     var original = string.Join(":", values);
                     tmpParameters.Add("signature",API.GetMd5Hash(original));
                 }
                 string url = APIURL + MethodName + "?" + string.Join("&", tmpParameters.Select(c => HttpUtility.UrlEncode(c.Key) + "=" + HttpUtility.UrlEncode(c.Value)));
                 string result = null;
                 try
                 {
                     using (WebClient wc = new WebClient())
                     {
                         result = wc.DownloadString(url);
                     }
                 }
                 catch
                 {
                     throw new CRXzoneAPIConnectionException();
                 }
                 JObject jObj;
                 string errorMessage;
                 try
                 {
                     jObj = JObject.Parse(result);
                     errorMessage = (string)jObj["ErrorMessage"];
                 }
                 catch 
                 {
                     throw new CRXzoneAPIInvalidAnswerException(); 
                 }
                 if (!string.IsNullOrEmpty(errorMessage))
                 {
                     throw new CRXzoneAPIException(errorMessage);
                 }
                 this.Result = jObj["Result"];
 
 
             }
 
         }
 
       
         internal static string GetMd5Hash(string input)
         {
             using (var md5 = System.Security.Cryptography.MD5.Create())
             {
                 var arr = System.Text.Encoding.ASCII.GetBytes(input);
                 arr = md5.ComputeHash(arr);
                 return BitConverter.ToString(arr).Replace("-", "");
             }
         }
     }
 
     public class CRXzoneAPIConnectionException : Exception
     {
 
     }
     public class CRXzoneAPIInvalidAnswerException : Exception
     {
 
     }
 
     public class CRXzoneAPIException : Exception
     {
         public CRXzoneAPIException(string message):base(message)
         {
         }
     }
 
 }
				

 import hashlib, requests, json, sys
   
 DEBUG = True
   
 #   * API-call related functions
 class CRXzoneAPI(object):
     __BUY = '0'
     __SELL = '1'
     __public_api = 'https://www.crxzone.com/API/'
       
     __api_id = None
     __api_key = None
       
     CurrencyPairs = {};
     Balances = {};
           
     def __init__(self, api_id, api_key):
         self.__api_id = api_id
         self.__api_key = api_key
           
         self.__SESS = requests.Session()
         self.__SESS.headers.update({
             "User-Agent": "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.154 Safari/537.36",
         })
         self.__SESS.verify = False
         self.__SESS.timeout = 10
   
         # Init currency pairs and balances
         self.RefreshCurrencyPairs()
         self.RefreshBalances()
           
     # * Call the API
     def Query(self, method = '', args = {}):
         # // Prepare request before send
         self.__addSignature(args)
         url = self.__public_api + method
           
         try:        
             result = self.__SESS.post(url, headers={"Referer":url}, data=args)
             if DEBUG: print method, result.text[:500]
             return json.loads(result.text)
         except:
             if DEBUG: print method, sys.exc_info()
             return {"ErrorMessage":sys.exc_info(), "IsSuccess":False, "Result":None}
       
     # * Prepare request
     def  __addSignature(self, Params):
         if 'signature' in Params:
             del Params['signature']
           
         Params['APIID'] = self.__api_id
           
         p = {}
         for k,v in Params.items():
             p[str(k).lower()] = v
   
         Imploded = ""
         for k in sorted(p):
             Imploded += str(p[k])+":"
           
         Imploded += self.__api_key
           
         Params['signature'] = hashlib.md5(Imploded).hexdigest()
         return Params
       
     # * Refresh currency pairs information
     def RefreshCurrencyPairs(self):
         CurrencyResult = self.Query("CurrencyPairs")
         if CurrencyResult['IsSuccess']:
             self.CurrencyPairs = {}
             for Pair in CurrencyResult['Result']:
                 Code = "%s%s" % (Pair['PrimaryCurrencyCode'], Pair['SecondaryCurrencyCode'])
                 self.CurrencyPairs[Code] = {
                     "ID": Pair['ID'],
                     "MinimumOrderAmount": Pair['MinimumOrderAmount'],
                 }
                 TickerResult = self.Query("Ticker", {'currencyPairID': Pair['ID']})
                   
                 if TickerResult['IsSuccess']:
                     self.CurrencyPairs[Code]["Price"] = TickerResult['Result']['Last']
                 else:
                     self.CurrencyPairs[Code]["Price"] = 0
         else:
             # raise CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$CurrencyResult->ErrorMessage);
             raise CRXzoneAPIFailureException('RefreshCurrencyPairs API Error: %s' % (CurrencyResult['ErrorMessage'],))
           
     # * Refresh balances information
     def RefreshBalances(self):
         AccountsResult = self.Query("Accounts")
           
         if AccountsResult['IsSuccess']:
             self.Balances = {}
             for Account in AccountsResult['Result']:
                 self.Balances[Account['CurrencyCode']] = {
                     'Available'     : Account['Available'],
                     'InOrders'      : Account['InOrders'],
                     'InWithdrawals' : Account['InWithdrawals'],
                     'TotalHold'     : Account['InOrders'] + Account['InWithdrawals'],
                 }
         else:
             # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$AccountsResult->ErrorMessage);
             raise CRXzoneAPIFailureException('RefreshBalances API Error: %s' % (AccountsResult['ErrorMessage'],))
       
     # * Get last tick for currency pair
     def GetTicker(self, CurrencyPair):
         if CurrencyPair in self.CurrencyPairs:
             PairID = self.CurrencyPairs[CurrencyPair]["ID"]
             TickerResult = self.Query("Ticker", {'currencyPairID': PairID})
             if TickerResult['IsSuccess']:
                 return TickerResult['Result']
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$TickerResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('GetTicker API Error: %s' % (TickerResult['ErrorMessage'],))
         else:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
             raise CRXzoneAPIInvalidParameterException('GetTicker Error: Currency pair %s not found' % (CurrencyPair,));
       
     # * Get market depth
     def GetMarketDepth(self, CurrencyPair):
         if CurrencyPair in self.CurrencyPairs:
             PairID = self.CurrencyPairs[CurrencyPair]["ID"];
             DepthResult = self.Query("Market_Depth", {'currencyPairID': PairID})
             if DepthResult['IsSuccess']:
                 return TickerResult['Result']
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$TickerResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('GetMarketDepth API Error: %s ' % (TickerResult['ErrorMessage'],))
         else:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
             raise CRXzoneAPIInvalidParameterException('GetMarketDepth Error: Currency pair %s not found' % (CurrencyPair,))
       
     # * Get list of orders
     # // $CurrencyPair
     # // $Type = Active/Closed
     # // $RecordsCount = 0;
     # // $StartIndex = 0;
     def GetOrdersList(self, CurrencyPair, Type = 'Active', RecordsCount = 0, StartIndex = 0):
         if not CurrencyPair in self.CurrencyPairs:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
             raise CRXzoneAPIInvalidParameterException('GetOrdersList Error: Currency pair %s not found' % (CurrencyPair,))
   
         PairID = self.CurrencyPairs[CurrencyPair]["ID"]
         result = {}
         if Type == 'Active':
             OrdersResult = self.Query("Orders_Active", {'currencyPairID': PairID})
             if OrdersResult['IsSuccess']:
                 Orders = {}
                 StartIndex = 0 if StartIndex < 0 else StartIndex
                 OrdersTotal = len(OrdersResult['Result'])
                 if RecordsCount != 0:
                     Counter = 0
                     Index = 0
                     for Order in OrdersResult['Result']:
                         Index += 1
                         if StartIndex > Index:
                             continue
                         if Counter > RecordsCount:
                             break
                         Counter += 1
                         Orders[Order['ID']] = Order
                 else:
                     # // All orders
                     Index = 0
                     for Order in OrdersResult['Result']:
                         Index += 1
                         if StartIndex > Index:
                             continue
                         Orders[Order['ID']] = Order
                 result['Orders'] = Orders
                 result['TotalCount'] = OrdersTotal
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrdersResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('GetOrdersList API Error: %s' % (OrdersResult['ErrorMessage'],))
         else:
             OrdersResult = self.Query("Orders_Active", {'currencyPairID': PairID, 'recordsCount': RecordsCount, 'startIndex': StartIndex})
             if OrdersResult['IsSuccess']:
                 Orders = {}
                 for Order in OrdersResult['Result']:
                     Orders[Order['ID']] = Order
                 result['Orders'] = Orders
                 result['TotalCount'] = OrdersResult['TotalRecordsCount']
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrdersResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('GetOrdersList API Error: %s' (OrdersResult['ErrorMessage'],))
   
         return result;
       
     # * Get order by ID
     def GetOrderByID(self, OrderID):
         if isinstance(OrderID, int):
             OrderResult = self.Query("Order_Get", {'orderID': OrderID})
             if OrderResult['IsSuccess']:
                 return OrderResult['Result']
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('GetOrderByID API Error: %s' % (OrderResult['ErrorMessage'],))
         else:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Order ID must be Integer.');
             raise CRXzoneAPIInvalidParameterException('GetOrderByID Error: Order ID must be Integer.')
       
     # * Get market depth
     def CreateOrder(self, CurrencyPair, Price, Amount, Type = 'BUY'):
         if CurrencyPair in self.CurrencyPairs:
             Pair = self.CurrencyPairs[CurrencyPair]
             if Amount >= Pair['MinimumOrderAmount']:
                 if Type.upper()=='SELL':
                     OrderType = self.__SELL
                 else:
                     OrderType = self.__BUY
                 Amount = "%.8f" % Amount
                 Price = "%.8f" % Price
                 return self.Query("Order_Create", {'amount': Amount, 'currencyPairID': Pair['ID'], 'price': Price, 'type': OrderType})
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
                 # raise CRXzoneAPIFailureException('CreateOrder API Error: %s' % (OrderResult['ErrorMessage'],))
                 raise CRXzoneAPIFailureException('CreateOrder API Error: ! Amount >= Pair[MinimumOrderAmount]')
         else:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Currency pair '.$CurrencyPair.' not found');
             raise CRXzoneAPIInvalidParameterException('CreateOrder Error: Currency pair %s not found' % (CurrencyPair,))
       
     # * Get market depth
     def CancelOrder(self, OrderID):
         if isinstance(OrderID, int):
             OrderResult = self.Query("Order_Cancel", {'orderID': OrderID})
             if OrderResult['IsSuccess']:
                 return True
             else:
                 # throw new CRXzoneAPIFailureException('File: '__FILE__.' Line: '.__LINE__.' API Error: '.$OrderResult->ErrorMessage);
                 raise CRXzoneAPIFailureException('CancelOrder API Error: %s' % (OrderResult['ErrorMessage'],))
         else:
             # throw new CRXzoneAPIInvalidParameterException('File: '__FILE__.' Line: '.__LINE__.' Error: Order ID must be Integer.');
             raise CRXzoneAPIInvalidParameterException('CancelOrder Error: Order ID must be Integer.')
   
   
 #   /**
 #   * Exceptions
 #   */
 class CRXzoneAPIException(Exception):
     pass
 class CRXzoneAPIFailureException(CRXzoneAPIException):
     pass
 class CRXzoneAPIInvalidParameterException(CRXzoneAPIException):
     pass
   
   
   
 if __name__=='__main__':
     c = CRXzoneAPI(api_key='b&348fh)32k4', api_id='123456')