def get(self, request): get_current_user(request.user.id) transaction_form = self.form_class() context = {'form': transaction_form} return render(request, self.template_name, context)
def get(self, request): get_current_user(request.user.id) GDAX = GDAXApi() accounts = GDAX.get_accounts() # if price > crypto_price['price']: # stop = 'loss' # elif price < crypto_price['price']: # stop = 'entry' # order = GDAX.create_order() # print(accounts) account_info = {} for account in accounts: if account["currency"] == "USD": continue account_info[str(account["currency"])] = account["id"] print(account_info, "account_info") # now get the account address context = {'accounts': accounts} return render(request, 'cryptoclient/buy-sell-accounts.html', context)
def get(self, request): get_current_user(request.user.id) purchaseorderform = self.form_class() GDAX = GDAXApi() accounts = GDAX.get_accounts() crypto_pairs = GDAX.get_crypto_pairs() crypto_price = GDAX.get_current_data('BTC-USD') # print(crypto_price) # print("XOXOXOXOXOXOXOOXOXOXOXOXO") all_open_orders = GDAX.get_all_open_orders() binance = BinanceAPI() ping = binance.ping() print(ping, "yesornowes") context = { 'accounts': accounts, 'form': purchaseorderform, 'crypto_pairs': crypto_pairs, 'open_orders': all_open_orders, # 'LTC_close_data':json.dumps(LTC_close_data) } return render(request, 'cryptoclient/buy-sell.html', context)
def get(self, request): get_current_user(request.user.id) send_form = self.form_class() context = {"form": send_form} return render(request, 'cryptoclient/swap-crypto-send-money.html', context)
def post(self, request): # now = datetime.datetime.now() # now_plus_2_years = now + datetime.timedelta(weeks = 100) # new_years_2019 = datetime.datetime(2019, 1, 1) get_current_user(request.user.id) print("this is before the request") user = User.objects.get(id=request.user.id) # current_user = get_user_model() # print(current_user) form = self.form_class(request.POST) # user = get_object_or_404(User, pk=request.user.id) print(user) # form1 = self.form_class() # print(request.POST, "request") # print("right before form") print('right before form') if form.is_valid(): cb_api_key = request.POST['cb_api_key'] cb_secret_key = request.POST['cb_secret_key'] gdax_api_key = request.POST['gdax_api_key'] gdax_secret_key = request.POST['gdax_secret_key'] gdax_passphrase = request.POST['gdax_passphrase'] coinigy_api_key = request.POST['coinigy_api_key'] coinigy_api_secret = request.POST['coinigy_api_secret'] binance_api_key = request.POST['binance_api_key'] binance_api_secret = request.POST['binance_api_secret'] user_cred = UserCredentials() user_cred.cb_api_key = request.POST['cb_api_key'] user_cred.cb_secret_key = request.POST['cb_secret_key'] user_cred.gdax_api_key = request.POST['gdax_api_key'] user_cred.gdax_secret_key = request.POST['gdax_secret_key'] user_cred.gdax_passphrase = request.POST['gdax_passphrase'] user_cred.coinigy_api_key = request.POST['coinigy_api_key'] user_cred.coinigy_api_secret = request.POST['coinigy_api_secret'] user_cred.binance_api_key = request.POST['binance_api_key'] user_cred.binance_api_secret = request.POST['binance_api_secret'] user_cred.user = user user_cred.save() print("WEWEWEWEWEWEWE") # save_address(request.user.id) return redirect('cryptoclient:submit-key') else: context = {'form': form1} return render(request, 'cryptoclient/submit-keys.html', context)
def get(self, request): print(request.user, type(request.user)) get_current_user(request.user.id) form = self.form_class() print(request.user.id, "user_id") context = {'form': form} return render(request, 'cryptoclient/submit-keys.html', context)
def get(self, request): get_current_user(request.user.id) cryptotocryptoform = self.form_class() market_order_form = self.form_class2() binance = Binance2Auth() tickers = binance.get_all_tickers() print(tickers) # coinigy = CoinigyAPI() # history = coinigy.list_history_data() # print(history) # orders = coinigy.list_orders() # print(orders) # auth = coinigy.list_accounts() # # print(auth['data'][0]) # auth_id, exch_id, = coinigy.get_auth_and_exch_id() # # print(auth_id,exch_id) # balances = coinigy.list_balances() # exchanges = coinigy.list_exchanges() # markets = coinigy.list_markets() # order_type, price_type = coinigy.get_ordertype_pricetype_id() order_types = {'1': 'Buy', '2': 'Sell'} price_types = {'3': 'Limit', '6': 'Stop Limit'} # print(order_type, price_type) # exchanges = exchanges['data'] # print(exchanges, 'exchange') # print(markets, 'market') # exch_code = '' # for exchange in exchanges: # if exchange['exch_name'] == 'Binance': # exch_code = exchange['exch_code'] # coins = shapeshift.get_coins() # rate = shapeshift.get_rate('btc_ltc') # create_order = coinigy.create_order(auth_id, exch_id, ) # create_order(self, auth_id, exch_id, mkt_id, order_type_id,price_type_id,limit_price, order_quantity): context = { # 'auth':auth['data'][0], # 'balances':balances['data'], 'form': cryptotocryptoform, 'market_form': market_order_form, # 'orders':orders['data'] } return render(request, 'cryptoclient/swap-crypto.html', context)
def get(self, request): get_current_user(request.user.id) # save_address(request.user.id) auth = Wallet() accounts = auth.get_accounts() print(accounts) list_wallets = auth.list_wallets() context = {"wallets": list_wallets['data']} return render(request, 'cryptoclient/wallet-list.html', context)
def post(self, request): get_current_user(request.user.id) walletcreationform = self.form_class(request.POST) if walletcreationform.is_valid(): name = request.POST["name"] auth = Wallet() address = auth.create_wallet(name) return redirect(self.success_url) else: return render(request, self.template_name, {'form': walletcreationform})
def get(self, request): get_current_user(request.user.id) GDAX = GDAXApi() # accounts = GDAX.get_accounts() # print(accounts) auth = Wallet() accounts = auth.get_accounts() print(accounts['data']) transfer_form = self.form_class() context = {'form': transfer_form} return render(request, self.template_name, context)
def post(self, request): get_current_user(request.user.id) form = self.form_class(request.POST) if form.is_valid(): order_id = request.POST['orderId'] symbol = request.POST['symbol'] GDAX = GDAXApi() GDAX.cancel_order(order_id) return redirect('cryptoclient:buy-sell-order') else: return HttpResponse('Didnt Work')
def get(self, request): get_current_user(request.user.id) auth = Wallet() list_wallets = auth.list_wallets() list_wallets = list_wallets['data'] # print(list_wallets, "list_wallets") # print(list_wallets) list_address = auth.get_addresses() # print(list_address) context = {"addresses": list_address, "wallets": list_wallets} return render(request, self.template_name, context)
def get(self, request): get_current_user(request.user.id) binance = BinanceAPI() binance2 = Binance2Auth() form = self.form_class() orders2 = binance2.get_open_orders() print(orders2) # orders = binance.get_current_open_orders() # print(orders) context = {'orders': orders2, 'form': form} return render(request, 'cryptoclient/swap-crypto-orders.html', context)
def get(self, request): get_current_user(request.user.id) coinigy = CoinigyAPI() binance2 = Binance2Auth() crypto_list = binance2.every_crypto_binance() balances = coinigy.list_balances() # print(balances) balances = balances['data'] print(balances) list_of_only_holding_symbol = [] for item in balances: list_of_only_holding_symbol.append(item['balance_curr_code']) final_list = [] for crypto in crypto_list: if crypto in list_of_only_holding_symbol: for item in balances: if item['balance_curr_code'] == crypto: balance_current = item['balance_amount_avail'] balance_total = item['balance_amount_total'] temporary_dict = { 'crypto': crypto, 'balance_current': balance_current, 'balance_total': balance_total } final_list.append(temporary_dict) else: temporary_dict = { 'crypto': crypto, 'balance_current': "0.00000", 'balance_total': "0.00000" } final_list.append(temporary_dict) context = {'final_list': balances} return render(request, 'cryptoclient/swap-crypto-address.html', context)
def post(self, request): get_current_user(request.user.id) swapcryptoform = self.form_class(request.POST) if swapcryptoform.is_valid(): address = request.POST['to_address'] amount = request.POST['amount'] currency = request.POST['currency'] print(address, amount, currency) binance = Binance2Auth() send_form = binance.withdraw_binance(currency, address, amount) return redirect('cryptoclient:swap-crypto') else: return HttpResponse('Didnt Work')
def get(self, request): print("just got into the data") get_current_user(request.user.id) GDAX = GDAXApi() start = date(2017, 12, 4).isoformat() end = date(2018, 7, 3).isoformat() # print(start, end) # style.use('ggplot') granularity = '86400' LTC_candle_data = GDAX.get_candle_data(start, end, granularity, 'LTC-USD') # ETH_candle_data = GDAX.get_candle_data(start, end, granularity, 'ETH-USD') # LTC_candle_data = GDAX.get_candle_data(start, end, granularity, 'LTC-USD') # print(ETH_candle_data) # print(BTC_candle_data) LTC_close_data = GDAX.get_close_data(LTC_candle_data) # ETH_close_data = GDAX.get_close_data(ETH_candle_data) # LTC_close_data = GDAX.get_close_data(LTC_candle_data) # print(LTC_candle_data) # ltc_json = GDAX.to_json(LTC_close_data) # print(ETH_close_data) # GDAX.to_csv(BTC_close_data, 'BTC-USD') # GDAX.to_csv(ETH_close_data, 'ETH-USD') # GDAX.to_csv(LTC_close_data, 'LTC-USD') # url(r'^crypto/buy-sell/data$', views.BuySellDataView.as_view(), name="buy-sell-data"), # print(ltc_json) crypto_json = {} LTC_close_data.insert(0, 'LTC') # ETH_close_data.insert(0, 'ETH') # LTC_close_data.insert(0, 'LTC') # print(LTC_close_data) # crypto_json['LTC'] = LTC_close_data crypto_json['LTC'] = LTC_close_data # crypto_json['ETH'] = ETH_close_data # print(ltc_json) print(crypto_json, "wow") return JsonResponse(crypto_json)
def get(self, request): get_current_user(request.user.id) GDAX = GDAXApi() form = self.form_class() all_open_orders = GDAX.get_all_open_orders() # if price > crypto_price['price']: # stop = 'loss' # elif price < crypto_price['price']: # stop = 'entry' # order = GDAX.create_order() print(all_open_orders) context = {'form': form, 'open_orders': all_open_orders} return render(request, 'cryptoclient/buy-sell-order.html', context)
def get(self, request): get_current_user(request.user.id) print('line33') GDAX = GDAXApi() bitcoin_data, ethereum_data = GDAX.market_data() print('over here') BTC_data = GDAX.get_24_hour_data('BTC-USD') ETH_data = GDAX.get_24_hour_data('ETH-USD') print('line 39') print(BTC_data) context = { 'bitcoin_data': bitcoin_data, 'ethereum_data': ethereum_data, 'BTC_daily': BTC_data, 'ETH_daily': ETH_data } return render(request, 'cryptoclient/option.html', context)
def post(self, request): get_current_user(request.user.id) auth = Wallet() gdax = GDAXApi() data = request.POST wallettransactionform = self.form_class(request.POST) list_wallets = auth.list_wallets() list_wallets = list_wallets['data'] print(list_wallets) print(data) if data['currency'] == "1": crypto = 'BTC' elif data['currency'] == "2": crypto = 'ETH' elif data['currency'] == "3": crypto = 'BCH' elif data['currency'] == "4": crypto = 'LTC' for wallet in list_wallets: if wallet['currency'] == crypto: account_id = wallet['id'] if wallettransactionform.is_valid(): address = data['to_address'] amount = data['amount'] print(address, amount) auth.send_money(address, amount, crypto, account_id) # print(send_money) return redirect('cryptoclient:wallet-list') else: return render(request, self.template_name, {'form': wallettransactionform})
def post(self, request): get_current_user(request.user.id) deleteform = self.form_class(request.POST) print(request.POST) binance = BinanceAPI() binance2 = Binance2Auth() # orders = binance.get_current_open_orders() # print(orders) # return HttpResponse("YES") if deleteform.is_valid(): order_id = request.POST['orderId'] symbol = request.POST['symbol'] # binance.delete_order(order_id) binance2.cancel_order(order_id, symbol) return redirect('cryptoclient:swap-crypto-order') else: return HttpResponse('Didnt Work')
def post(self, request): get_current_user(request.user.id) print(request.body, "here") parsed_body = request.body.decode('ascii') print(parsed_body) split_body = parsed_body.split("&") print(split_body) requested_pair_data = split_body[1] requested_pair = requested_pair_data.split("=") just_requested_pair = requested_pair[1] print(just_requested_pair) coinigy = CoinigyAPI() binance = Binance2Auth() binance_orders = UserBinanceOrders() # auth_id, exch_id, = coinigy.get_auth_and_exch_id() order_types = coinigy.get_ordertype_pricetype_id() order_type_id = order_types['data']['order_types'] # price_type_id = order_types['data']['price_types'] # not going to allow limit trading. price_type_id = '3' # print('XOXOXOXOXOXOXO') # print(order_types['data'], 'order_type') # exchanges = coinigy.list_exchanges() # print(exchanges, 'exchange') # print(markets, 'market') # exchange = exchanges['data'] # exch_code = '' # for item in exchange: # if item['exch_name'] == 'Binance': # exch_code = item['exch_code'] # pairs = coinigy.list_markets(exch_code) # print(pairs) cryptotocryptoform = self.form_class(request.POST) obj = User.objects.get(pk=request.user.id) # print(request.POST, 'post req') if cryptotocryptoform.is_valid(): # order = coinigy.create_order(auth_id, exch_id, mkt_id, order_type_id, price_type_id, limit_price, order_quantity) user_pair_data = str(request.POST['pair']) limit_price = request.POST['price'] price_type_id = request.POST['price_type'] order_quantity = request.POST['order_quantity'] order_type_id = request.POST['order_type'] print(order_type_id, type(order_type_id)) order_type_id1 = '' if order_type_id == '1': order_type_id1 = 'Buy' if order_type_id == '2': order_type_id1 = 'Sell' print(order_type_id1, type(order_type_id1)) # mkt_id = '' # # print(pairs['data'], 'print') # print(pairs) # for item in pairs['data']: # # print(item) # if user_pair_data == str(item['mkt_name']): # mkt_id = item['mkt_id'] # # print(mkt_id,'mkt_id') print(order_type_id1, price_type_id, type(order_type_id1), type(price_type_id), "______________________") if order_type_id1 == 'Buy' and price_type_id == 'Limit': binance.create_buylimit_order(user_pair_data, order_quantity, limit_price) binance_orders.crypto_pair = user_pair_data binance_orders.order_type = price_type_id binance_orders.buyorsell = order_type_id1 binance_orders.price = limit_price binance_orders.amount = order_quantity binance_orders.user = obj binance_orders.exchange = "Binance" binance_orders.save() print('executed') elif order_type_id1 == 'Sell' and price_type_id == 'Limit': binance.create_selllimit_order(user_pair_data, order_quantity, limit_price) binance_orders.crypto_pair = user_pair_data binance_orders.order_type = price_type_id binance_orders.buyorsell = order_type_id1 binance_orders.price = limit_price binance_orders.amount = order_quantity binance_orders.exchange = "Binance" binance_orders.user = obj binance_orders.save() print('executed') elif order_type_id1 == 'Buy' and price_type_id == 'Market': price = binance.create_buymarket_order(user_pair_data, order_quantity) binance_orders.crypto_pair = user_pair_data binance_orders.order_type = price_type_id binance_orders.buyorsell = order_type_id1 binance_orders.price = price binance_orders.amount = order_quantity binance_orders.exchange = "Binance" binance_orders.user = obj binance_orders.save() print('executed') elif order_type_id1 == 'Sell' and price_type_id == 'Market': price = binance.create_sellmarket_order( user_pair_data, order_quantity) binance_orders.crypto_pair = user_pair_data binance_orders.order_type = price_type_id binance_orders.buyorsell = order_type_id1 binance_orders.exchange = "Binance" binance_orders.price = price binance_orders.amount = order_quantity binance_orders.user = obj binance_orders.save() print('executed') # print(auth_id, exch_id, mkt_id, order_type_id, price_type_id, limit_price, order_quantity, "right before order creation") # order = coinigy.create_order(int(auth_id), int(exch_id), int(mkt_id), int(order_type_id), price_type_id, float(limit_price), float(order_quantity)) # print(order) # order = binance.create_limit_order(user_pair_data, order_quantity, limit_price) # print(order) return redirect('cryptoclient:swap-crypto') # elif ChartForm.is_valid(): else: return HttpResponse('Didnt Work')
def get(self, request): get_current_user(request.user.id) coinigy = CoinigyAPI() binance2 = Binance2Auth() gdax = GDAXApi() # tickers = binance2.get_all_tickers() list_of_main_cryptos = ['BTC', 'ETH', 'LTC', 'ETC'] # for item in tickers: # # print(item) # symbol = item['symbol'] # # print(symbol) balances = coinigy.list_balances() # print(balances) crypto_list = binance2.every_crypto_binance() list_of_final_balances = [] for item in list_of_main_cryptos: address = binance2.get_deposit_address(item) cryptoaddress = {'crypto': item, 'address': address} list_of_final_balances.append(cryptoaddress) time.sleep(1) # address = binance2.get_deposit_address(item) # print(item, type(address), address, "hererereerer") # user_address = UserAddresses() # if address['success'] == False: # continue # else: # print(address) # print(item, address['address'], len(address['address'])) # user_address.crypto = item # user_address.address = address['address'] # user_address.save() # time.sleep(3) # print(balances,"right here") # list_of_balances = balances['data'] # print(list_of_balances, 'list_of_balances') # list_of_crypto_balance_symbol = [] # for balance in list_of_balances: # list_of_crypto_balance_symbol.append(balance['balance_curr_code']) # # print(list_of_balances) # user_addresses = UserAddresses.objects.filter(address__lte=20) # list_of_crypto_addresses = [] # list_of_no_addresses = [] # # print(list_of_crypto_balances) # for item in list_of_crypto_balance_symbol: # cryptoaddress = user_addresses.filter(crypto=item) # print(cryptoaddress) # # print(cryptoaddress) # if cryptoaddress.exists(): # cryptoaddress = cryptoaddress[0] # list_of_crypto_addresses.append(cryptoaddress) # else: # list_of_no_addresses.append(item) # print(list_of_no_addresses) # list_of_final = [] # for item in list_of_balances: # if item in list_of_no_addresses: # returnvalue = list_of_balances.pop() # # print(list_of_balances) # print(list_of_crypto_addresses, 'crypto_addresses') # for item in range(0, len(list_of_balances)-1): # current_crypto = list_of_balances[item] # print(current_crypto, "sdssds") # print(list_of_balances[item]['balance_amount_avail']) # available = list_of_balances[item]['balance_amount_avail'] # total = list_of_balances[item]['balance_amount_total'] # final_list = { # 'crypto': list_of_crypto_balances[item], # 'address': list_of_crypto_addresses[item].address, # 'current_holding': available, # 'total_holding': total # } # list_of_final.append(final_list) # # list_of_excluded = UserAddresses. # final_list_excluded = "" # # for item in list_of_final: # # addresses = UserAddresses.objects.exclude(crypto=item) # # final_list_excluded = ad # for item in range(0,len(list_of_final)-1): # if len(final_list_excluded) == 0: # addresses = UserAddresses.objects.exclude(crypto=list_of_final[item]) # final_list_excluded = addresses # final_list_excluded = final_list_excluded.exclude(crypto=list_of_final[item]) # print(final_list_excluded) # list_of_excluded = [] # for item in range(0, len(final_list_excluded)-1): # user_address = final_list_excluded[item] # list_of_excluded.append(user_address) # zero = '0.0000' context = { 'balances': balances, 'user_addresses': list_of_final_balances, # 'list_of_excluded': list_of_excluded, # 'zero': zero } return render(request, 'cryptoclient/swap-crypto-wallet.html', context)
def post(self, request): get_current_user(request.user.id) auth = Wallet() accounts = auth.get_accounts() print(accounts) GDAX = GDAXApi() data = request.POST # print(request.POST) cb_accounts = GDAX.list_cb_accounts() print(cb_accounts, "hererere") transfer_form = self.form_class(request.POST) # get coinbase accounts # match the accounts with the currency they chose coinbase_account_id = request.POST['currency'] if coinbase_account_id == "1": coinbase_account_id = "BTC" elif coinbase_account_id == "2": coinbase_account_id = "ETH" elif coinbase_account_id == "3": coinbase_account_id = "BCH" elif coinbase_account_id == "4": coinbase_account_id = "LTC" # accounts = GDAX.get_accounts() # print(accounts) for account in accounts['data']: print(account['currency']) if coinbase_account_id == account['currency']: print(coinbase_account_id) coinbase_account_id = account['id'] print(coinbase_account_id) if transfer_form.is_valid(): amount = request.POST['amount'] amount = float(amount) currency = request.POST['currency'] if currency == "1": currency = "BTC" elif currency == "2": currency = "ETH" elif currency == "3": currency = "BCH" elif currency == "4": currency = "LTC" print(currency, "currency") transaction_type = request.POST['transaction'] if transaction_type == "1": GDAX.withdraw_to_coinbase(amount, currency, coinbase_account_id) print("got here") elif transaction_type == "2": GDAX.deposit_to_gdax(amount, currency, coinbase_account_id) return redirect('cryptoclient:wallet-list') else: return HttpResponse("Your form is broken")
def get(self, request): # list_of_all_ids = [litecoin_id, bitcoin_id, bitcoin_cash_id, ethereum_id, usd_id] # list_of_all_binance_pairs = ['BCC/BTC', 'BTC/USDT', 'BCC/USDT', ] get_current_user(request.user.id) obj = User.objects.get(pk=request.user.id) # all_gdax_orders = UserGdaxOrders.objects.all() all_binance_orders = UserBinanceOrders.objects.all() # print(all_binance_orders) # current_user_gdax_orders = all_gdax_orders.filter(user=obj) current_user_binance_orders = all_binance_orders.filter(user=obj) print(current_user_binance_orders) # list_of_all_pastbuysell_transactions = [] # auth = Wallet() # gdax = GDAXApi() # list_of_all_GDAX_pairs = ["BTC-USD", "ETH-USD", "LTC-USD"] # for item in list_of_all_GDAX_pairs: # fills = gdax.list_fills(item) # print(fills) # binance = BinanceAPI() # coinigy = CoinigyAPI() # balances = coinigy.list_balances() # balances = balances['data'] # # binance_data = binance.get_past_trades() # # print(binance_data) # ticker_data = binance.ticker() # # print(ticker_data, "thisthisthisthis") # ticker_list = [] # for ticker in ticker_data: # ticker_list.append(ticker['symbol']) # print(ticker_list) # for ticker in ticker_list: # trades = binance.old_trades(ticker) # print(trades) # these are just the pastbuysell # all_transactions = auth.get_all_transactions() # all_accounts = auth.get_accounts() # # print(all_accounts, "all accounts") # litecoin_id = all_accounts['data'][2]['id'] # bitcoin_id = all_accounts['data'][4]['id'] # bitcoin_cash_id = all_accounts['data'][0]['id'] # ethereum_id = all_accounts['data'][3]['id'] # usd_id = all_accounts['data'][1]['id'] # list_of_all_ids = [litecoin_id, bitcoin_id, bitcoin_cash_id, ethereum_id] # for crypto_id in list_of_all_ids: # transactions = auth.get_all_transactions(crypto_id) # number_of_transaction = len(transactions['data']) # for transaction in range(0, number_of_transaction-1): # # print(transactions['data'], "RIGHT HERE") # list_of_all_pastbuysell_transactions.append(transactions['data'][transaction]) # print(list_of_all_pastbuysell_transactions, "alltransaction") # newlist = sorted(list_of_all_pastbuysell_transactions, key=lambda k: k['created_at'], reverse=True) # # print(newlist, "right here") # litecoin_transactions = auth.get_all_transactions(litecoin_id) # bitcoin_transactions = auth.get_all_transactions(bitcoin_id) # bitcoin_cash_transactions = auth.get_all_transactions(bitcoin_cash_id) # ethereum_transactions = auth.get_all_transactions(ethereum_id) # usd_transactions = auth.get_all_transactions(usd_id) # # print(litecoin_transactions['data'], "litecoin transasction") # total_account_value = auth.get_total_account_value() # primary_account = auth.get_primary_account() # primary_transactions = get_primary_transactions() # print(all_transactions, 'ALL TRANSACTIONS') # print(primary_transactions, 'ALL PRIMARY') # primary_account.refresh() # balance = primary_account.balance # context = {'primary_account':primary_account, 'all_transactions':all_transactions, 'primary_transactions':primary_transactions} print(current_user_binance_orders) # current_user_binance_orders = current_user_binance_orders.reverse() # final_list = [] # for item in current_user_binance_orders: # final_list.append(item) # print(final_list) # final_list = final_list.reverse() # print(final_list) current_user_binance_orders = current_user_binance_orders.reverse()[:5] context = {'past_orders': current_user_binance_orders} return render(request, 'cryptoclient/profile.html', context)
def post(self, request): get_current_user(request.user.id) purchaseorderform = self.form_class(request.POST) GDAX = GDAXApi() test = type(request.POST['order_type']) # print(test) another_str = int(request.POST['order_type']) # print(another_str) # print(request.POST) obj = User.objects.get(pk=request.user.id) if request.POST['order_type'] == "1": order_type = 'market' elif request.POST['order_type'] == "2": order_type = 'limit' if request.POST['order_side'] == "1": order_side = 'buy' elif request.POST['order_side'] == "2": order_side = 'sell' if request.POST['crypto_pair'] == "1": crypto_pair = 'BTC-USD' elif request.POST['crypto_pair'] == "2": crypto_pair = 'ETH-USD' elif request.POST['crypto_pair'] == "3": crypto_pair = 'BCH-USD' elif request.POST['crypto_pair'] == "4": crypto_pair = 'LTC-USD' price = request.POST['price'] amount = request.POST['amount'] # print(order_type, order_side, crypto_pair, price, amount, "POST") # print(order_type,"type", order_side,"buyorsell") gdax_orders = UserBinanceOrders() if purchaseorderform.is_valid(): if order_type == "limit": order = GDAX.create_limit_order(order_side, price, crypto_pair, amount, order_type) gdax_orders.crypto_pair = crypto_pair gdax_orders.order_type = order_type gdax_orders.buy_or_sell = order_side gdax_orders.price = float(order) gdax_orders.amount = float(amount) gdax_orders.exchange = "GDAX" gdax_orders.user = obj gdax_orders.save() print(order, "limit") elif order_type == "market": # print(order_side, order_type, crypto_pair, amount, order1, price) # print(type(order_side), type(order_type), type(crypto_pair), type(amount), type(order1), type(price)) order1 = GDAX.create_market_order(order_side, order_type, crypto_pair, amount) # print(order_side, order_type, crypto_pair, amount, order1, price) # print(type(order_side), type(order_type), type(crypto_pair), type(amount), type(order1), type(price)) gdax_orders.crypto_pair = crypto_pair gdax_orders.order_type = order_type gdax_orders.buy_or_sell = order_side gdax_orders.price = float(order1) gdax_orders.amount = float(amount) gdax_orders.exchange = "GDAX" gdax_orders.user = obj gdax_orders.save() # print(order, "market") return redirect('cryptoclient:buy-sell') else: print('form is broken') return redirect('cryptoclient:buy-sell')
def get(self, request): get_current_user(request.user.id) walletcreationform = self.form_class() context = {"form": walletcreationform} return render(request, self.template_name, context)