import json import os import random import re import threading import time import traceback import urllib from hashlib import md5 from urllib.parse import urlencode import requests import unidecode from bs4 import BeautifulSoup from django.db import close_old_connections from django.db.models import Subquery, OuterRef, Count, IntegerField, Value, F, Q from django.db.models.functions import Coalesce, Abs from django.utils import timezone # from accounts.console_bot_settings import discharge_bad_players_asset_id from accounts.models import FifaAccountRequest, MuleAccounts, CloseWebAppSnipes, CloseWebAppTransfers, PlayerCard, \ FifaAccountSearch, ConsoleBotSetting, SniperPlayerCard from futplus.settings import BASE_DIR, TIME_ZONE from sbc import FIFA_REPORT_TOKEN, ARZBAZI_REPORT_GROUP_ID, \ ARZBAZI_REPORT_TOPIC_PLAYERS_NOT_FOUND_THREAD_MESSAGE_ID, ONE_DAY_SECONDS from sbc.models import SBCWorker, SBCTargetFilter from sbc.public_methods import get_next_price_grade, get_previous_price_grade, delete_sold_items, sell_items, \ set_sub_log, set_sbc_status, get_round_price, get_player_fifa_name_by_id, new_print, \ save_account_request, get_player_data_by_asset_id, calculate_player_tax, ThreadWithReturnValue, get_card_from_mydgn, \ focus_on_ps, get_card_from_game_currency, cancel_buy_card, u7buy_trade_api, get_card_from_buyut, user_agent, \ set_main_log from accounts.web_login_utils import logout_login from sbc.sbc_solver import SBCSolver import sniper from sniper.models import DischargeUsableCard, SniperTradeItemLog, DischargeMode3SpecialPlayers, StartDischargeBot, \ MuleDischargeMode2, DischargeMode2 from utils.ea_settings import fifa_23_address, futbin_address, fifa_host from utils.realy_public_methods import get_db_time, telegram_send_message_fifa_account class DischargeRunner(SBCSolver): def web_app_discharge_with_snipe_first(self, transfer: CloseWebAppSnipes): while True: try: delete_sold_items(self.se, self.main_dic['header'], self.server_key) time.sleep(0.5) self.update_credit() self.fifa_account.refresh_from_db() credit = self.fifa_account.credit # buy_now_price = get_previous_price_grade(get_previous_price_grade( # get_previous_price_grade(transfer.player_price))) buy_now_price = get_next_price_grade(get_next_price_grade(get_next_price_grade( get_next_price_grade(get_next_price_grade(transfer.player_min_price_from_futbin))))) if credit < buy_now_price: MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return False except: try: new_print(self.fifa_account, 'error 68 : ', traceback.format_exc()) self.get_new_sid() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( last_sid=self.sid, last_nucleus=self.nucleus_id, last_persona=self.persona_id) except: login_result = logout_login(self, self.sbc_worker, self.fifa_account, ) if login_result.get('status_bool') is False: MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( error=True, error_description=login_result.get('reason')) def web_app_discharge_with_snipe(self, transfer: CloseWebAppSnipes, count, account_number, micr_reduction_count: int, first_account): dis_3 = timezone.localtime() sender_account = first_account temp_count = 0 while True: temp_count += 1 if temp_count > 2: new_print(self.fifa_account, 'checked and must done bot 4') return '' try: dis_4 = timezone.localtime() buy_now_price = get_next_price_grade(get_next_price_grade(get_next_price_grade( get_next_price_grade(get_next_price_grade(transfer.player_min_price_from_futbin))))) # buy_now_price = get_previous_price_grade(get_previous_price_grade( # get_previous_price_grade(get_previous_price_grade(transfer.player_price)))) # buy_now_price = self.get_round_price(transfer.player_price * 1.5) main_start_price = get_previous_price_grade(buy_now_price) previous_player_price = get_previous_price_grade(main_start_price) # for i in range(int(account_number) + random.randint(1, 5)): for i in range(micr_reduction_count): previous_player_price = get_previous_price_grade(previous_player_price) if previous_player_price < 250: previous_player_price = 250 next_buy_now_price = get_next_price_grade(buy_now_price) for i in range(count): next_buy_now_price = get_next_price_grade(next_buy_now_price) # link = f'{fifa_23_address/transfermarket?num=21&start=%s&type=player&maskedDefId=%s&lev=gold&maxb=%s' % \ # (0, transfer.player_asset_id,buy_now_price)' search_start_time = timezone.localtime() # new_print(self.fifa_account, 'search time : ', timezone.localtime()) # link = f'{fifa_23_address/transfermarket?num=21&start=%s&type=player&maskedDefId=%s&lev=gold&micr=%s¯=%s&minb=%s&maxb=%s' % \ # (0, transfer.player_asset_id, previous_player_price, # get_next_price_grade(transfer.player_price), buy_now_price, # next_buy_now_price) payload = { 'num': 21, 'start': 0, 'type': 'player', 'maskedDefId': transfer.player_asset_id, 'lev': 'gold', 'micr': previous_player_price, 'macr': main_start_price, 'minb': buy_now_price, 'maxb': next_buy_now_price, } if transfer.player_rarity_ids: payload.update({'rarityIds': transfer.player_rarity_ids}) # if transfer.player_rarity_ids in [134, 65, 11, 30, 161, 111]: if transfer.player_rarity_ids > 3: payload.pop('lev', None) search_link = f'{fifa_23_address}/transfermarket?' + str(urlencode(payload)) # link = f'{fifa_23_address/transfermarket?num=21&start=%s&type=player&maskedDefId=%s&lev=gold&micr=%s¯=%s&minb=%s&maxb=%s' % \ # (0, transfer.player_asset_id, # previous_player_price, main_start_price, # buy_now_price, next_buy_now_price) # link = f'{fifa_23_address/transfermarket?num=21&start=0&type=player&maskedDefId=231478&lev=gold&micr=4500¯=4600&minb=9100&maxb=9200' resp = self.search_player(0, 0, '', link=search_link, safe=False) json_resp = resp.json() auction_info = json_resp['auctionInfo'] # todo : save request after discharge done # save_account_request( # fifa_account=self.fifa_account, # link=search_link, # ) if len(auction_info) == 0: new_print(self.fifa_account, 'len auction info = ', len(auction_info), ' time ', timezone.localtime(), ' search time : ', search_start_time, ' search link : ', search_link, ' dis 3 , ', dis_3, ' dis 4 ', dis_4) return False for player in auction_info: # if player['expires'] < 3590: # new_print(self.fifa_account,"similar found *** ,player['expires'] =", player['expires']) # new_print(self.fifa_account,'trade id = ', player['tradeId'], 'start price = ', player['startingBid'], # 'buy now price = ', player['buyNowPrice'], 'expires = ', player['expires']) # break # break if 3550 < player['expires'] < 3601: data = json.dumps({"bid": player['buyNowPrice']}) bid_start_time = timezone.localtime() bid_resp = self.bid_trade(player['tradeId'], data, safe=False) bid_end_time = timezone.localtime() new_print( self.fifa_account, 'search_number count : ', self.fifa_account.account_search.filter( search_time__gt=timezone.localtime() - timezone.timedelta(hours=24)).count(), ' search start time : ', search_start_time, ' search link : ', search_link ) new_print(self.fifa_account, "similar found *** ,player['expires'] =", player['expires'], ' bid start time : ', bid_start_time, ' bid end time : ', bid_end_time) new_print(self.fifa_account, 'trade id = ', player['tradeId'], 'start price = ', player['startingBid'], 'buy now price = ', player['buyNowPrice'], 'expires = ', player['expires']) new_print(self.fifa_account, 'discharge bid resp : ', bid_resp.text) new_print(sender_account, f"receiver_log {self.fifa_account.id}: similar found *** ," " player['expires'] =", player['expires'], ' trade id = ', player['tradeId'], 'start price = ', player['startingBid'], ' buy now price = ', player['buyNowPrice'], ' bid resp : ', bid_resp.text, ' count : ', count ) # transfer.refresh_from_db() transfer.second_side_found_target = True transfer.winner_account_data = f'acc num:{account_number} count:{count}' transfer.save(update_fields=['second_side_found_target', 'winner_account_data']) if (bid_resp.text.find('Permission Denied') == -1 and bid_resp.text != '' and bid_resp.text != 'You are not allowed to bid on this trade'): new_print(self.fifa_account, 'item bought') new_print(sender_account, f'receiver_log {self.fifa_account.id}: item bought', ' count : ', count) # transfer.refresh_from_db() transfer.second_side_done = True transfer.winner_account = self.fifa_account transfer.save(update_fields=['second_side_done', 'winner_account']) # transfer.error = False # transfer.error_desc = '' # need this sleep because other worker maybe set it true time.sleep(10) transfer.refresh_from_db() transfer.second_side_done = True transfer.winner_account = self.fifa_account transfer.error = False transfer.error_desc = '' transfer.save() time.sleep(2) try: self.item_put_for_sale(player['itemData']['id'], player['tradeId'], 0, start_price=get_previous_price_grade( get_previous_price_grade(transfer.player_price)), buy_now_price=get_previous_price_grade( transfer.player_price)) new_print(self.fifa_account, 'after putting for sale') try: sell_items_last_3_hours = FifaAccountRequest.objects.using('logs_pgbouncer').filter( fifa_account=self.fifa_account, link=f'{fifa_23_address}/trade/sold', create_time__gt=timezone.localtime() - timezone.timedelta(hours=3) ) if sell_items_last_3_hours.count() > 0: new_print(self.fifa_account, 'sell items not work now , just every 3 hour') else: time.sleep(0.5) sell_items(self, self.sbc_worker, self.fifa_account) delete_sold_items(self.se, self.main_dic['header'], self.server_key) except: new_print(self.fifa_account, 'error 67 : ', traceback.format_exc()) except: new_print(self.fifa_account, 'error 66 : ', traceback.format_exc()) new_print(self.fifa_account, 'job is done') return else: transfer.refresh_from_db() if not transfer.second_side_done: transfer.error = True transfer.error_desc = 'missed' transfer.save() new_print(self.fifa_account, 'missed item', ' count : ', count) new_print(sender_account, f'receiver_log {self.fifa_account.id}: missed item') return # time.sleep(2) except: self.sbc_worker.refresh_from_db() if self.sbc_worker.must_done: new_print(self.fifa_account, 'checked and must done bot') return '' try: new_print(self.fifa_account, 'error 65 : ', traceback.format_exc()) self.get_new_sid() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( last_sid=self.sid, last_nucleus=self.nucleus_id, last_persona=self.persona_id) except: login_result = logout_login(self, self.sbc_worker, self.fifa_account, ) if login_result.get('status_bool') is False: MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( error=True, error_description=login_result.get('reason')) def web_app_inject_staff(self, transfer: CloseWebAppTransfers): if not transfer.player_asset_id: new_print(self.fifa_account, 'not have any asset id transfer id = ', transfer.id) transfer.error = True transfer.web_app_is_on_it = False transfer.second_account = self.fifa_account transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return '' start = 0 self.inject_or_discharge_web_app_start_things() temp_count = 0 while True: temp_count += 1 if temp_count > 2: new_print(self.fifa_account, 'checked and must done bot 3') transfer.refresh_from_db() transfer.web_app_is_on_it = False transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return '' try: delete_sold_items(self.se, self.main_dic['header'], self.server_key) time.sleep(0.5) self.update_credit() self.fifa_account.refresh_from_db() credit = self.fifa_account.credit if credit < transfer.buy_now_price: transfer.web_app_is_on_it = False transfer.save() new_print(self.fifa_account, 'transfer id = ', transfer.id, 'need credit = ', transfer.buy_now_price, 'my credit = ', credit) MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return '' link = f'{fifa_23_address}/transfermarket?num=21&start=%s&type=player&maskedDefId=%s&lev=gold&micr=%s¯=%s&minb=%s&maxb=%s' % \ (start, transfer.player_asset_id, transfer.start_price, get_next_price_grade(transfer.start_price), transfer.buy_now_price, get_next_price_grade(transfer.buy_now_price)) # link = f'{fifa_23_address/transfermarket?num=21&start=0&type=player&maskedDefId=231478&lev=gold&micr=4500¯=4600&minb=9100&maxb=9200' resp = self.search_player(0, 0, '', link=link) try: json_resp = resp.json() except: if json_resp == 'sid': transfer.error = True transfer.web_app_is_on_it = False transfer.second_account = self.fifa_account transfer.save() MuleAccounts.objects.filter( fifa_account=self.fifa_account ).update(in_use=False, error=True, error_description='high search') return '' auction_info = json_resp['auctionInfo'] different_by_seconds = (timezone.localtime() - transfer.put_for_sale_time).total_seconds() different_by_seconds = 3600 - different_by_seconds new_print(self.fifa_account, 'different_by_seconds 2 = ', different_by_seconds) if different_by_seconds < 5: transfer.web_app_is_on_it = False transfer.second_account = self.fifa_account transfer.error = True transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return if len(auction_info) == 0: new_print(self.fifa_account, 'len auction info = ', len(auction_info)) transfer.web_app_is_on_it = False transfer.error = True transfer.second_account = self.fifa_account transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return for player in auction_info: new_print(self.fifa_account, 'trade id = ', player['tradeId'], 'start price = ', player['startingBid'], 'buy now price = ', player['buyNowPrice'], 'expires = ', player['expires']) if player['expires'] > 3600: new_print(self.fifa_account, "player['expires'] = ", player['expires']) transfer.web_app_is_on_it = False transfer.error = True transfer.second_account = self.fifa_account transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return if (player['startingBid'] == transfer.start_price and player['buyNowPrice'] == transfer.buy_now_price): new_print(self.fifa_account, "similar found *** ,player['expires'] =", player['expires']) diff_sec = 60 if transfer.need_to_care: diff_sec = 30 if different_by_seconds - diff_sec < player['expires'] < different_by_seconds + diff_sec: data = '{"bid":%d}' % player['buyNowPrice'] bid_resp = self.bid_trade(player['tradeId'], data) new_print(self.fifa_account, bid_resp.text) if (bid_resp.text.find('Permission Denied') == -1 and bid_resp.text != '' and bid_resp.text != 'You are not allowed to bid on this trade'): new_print(self.fifa_account, 'item bought') transfer.second_side_done = True transfer.web_app_is_on_it = False transfer.second_account = self.fifa_account transfer.save() time.sleep(2) try: self.item_put_for_sale(player['itemData']['id'], player['tradeId'], 0, start_price=get_previous_price_grade( get_previous_price_grade(transfer.start_price)), buy_now_price=get_previous_price_grade( transfer.start_price)) try: delete_sold_items(self.se, self.main_dic['header'], self.server_key) except: new_print(self.fifa_account, 'error 64 : ', traceback.format_exc()) except: new_print(self.fifa_account, 'error 63 : ', traceback.format_exc()) new_print(self.fifa_account, 'after putting for sale') MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) transfer.put_for_sale_time = timezone.localtime() transfer.save() new_print(self.fifa_account, 'job is done') return start += 20 time.sleep(2) except: self.sbc_worker.refresh_from_db() if self.sbc_worker.must_done: transfer.refresh_from_db() transfer.web_app_is_on_it = False transfer.save() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) new_print(self.fifa_account, 'checked and must done bot') return '' try: new_print(self.fifa_account, 'error 62 : ', traceback.format_exc()) self.get_new_sid() MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( last_sid=self.sid, last_nucleus=self.nucleus_id, last_persona=self.persona_id) except: login_result = logout_login(self, self.sbc_worker, self.fifa_account, ) if login_result.get('status_bool') is False: MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( error=True, error_description=login_result.get('reason')) def inject_or_discharge_web_app_start_things(self): if not self.main_dic.get('header'): self.set_this_staff_to_pass_logout_login() new_print(self.fifa_account, 'self.fifa_account.id = ', self.fifa_account.id) mule_account = MuleAccounts.objects.get(fifa_account=self.fifa_account) self.sid = mule_account.last_sid self.nucleus_id = mule_account.last_nucleus self.persona_id = mule_account.last_persona self.main_dic['header'] = { 'Content-Type': 'application/json', 'Origin': 'https://www.ea.com', 'Referer': 'https://www.ea.com/', 'User-Agent': user_agent, 'X-UT-SID': self.sid, 'Accept': '*/*', 'Accept-Encoding': 'gzip, deflate, br', 'Accept-Language': 'en-US,en;q=0.5', 'Connection': 'keep-alive', 'Host': fifa_host, } def discharge_with_mode2(self, current_coins, sell_all=False, coins_to=20000): new_print(self.fifa_account, 'discharge with mode 2') set_main_log(self.sbc_worker, 'discharge 2 started') set_sub_log(self.sbc_worker, 'discharge started') set_sbc_status(self.sbc_worker, 'discharging 2 ...') self.public_moves.console_open_ultimate() bad_asset_ids = [] while current_coins > coins_to and self.fifa_account.run_discharge: self.public_moves.go_to_state('ps4_main', 'transfer_market') if current_coins - coins_to < 20000: new_print(self.fifa_account, 'can not find low item price , ', current_coins - coins_to) return StartDischargeBot.objects.create(fifa_account=self.fifa_account, discharge_mode=2) close_old_connections() for iie in [0, 1, 2, 3]: new_print(self.fifa_account, 'selecting mule for discharge. counter : ', iie) card_data = None if iie == 0: deactive_mule = MuleDischargeMode2.objects.filter( Q(in_use=False) | Q(Q(is_api=True) & Q(site_name='buyut')), is_active=True ).order_by('priority', 'last_run_time').first() elif iie == 1: deactive_mule = MuleDischargeMode2.objects.exclude( Q(is_api=True, site_name='buyut') | Q(site_name='game_currency') ).filter( in_use=False, is_active=True ).order_by('priority').first() elif iie == 2: deactive_mule = MuleDischargeMode2.objects.filter( is_api=True, site_name='buyut', is_active=True ).order_by('priority', 'last_run_time').first() else: deactive_mule = MuleDischargeMode2.objects.exclude( Q(site_name='buyut') | Q(site_name='game_currency') ).filter( in_use=False, is_active=True ).order_by('priority').first() if not deactive_mule: new_print(self.fifa_account, 'no deactive mule found') continue else: deactive_mule.in_use = True deactive_mule.last_run_time = timezone.localtime() deactive_mule.last_fifa_account_used = self.fifa_account deactive_mule.save(update_fields=['in_use', 'last_run_time', 'last_fifa_account_used']) try: new_print(self.fifa_account, 'selecting discharge mode for discharge.') if deactive_mule.site_name == 'mydgn': thread_1 = ThreadWithReturnValue( target=get_card_from_mydgn, kwargs={ 'parent_instance': self, 'fifa_account': self.fifa_account, 'deactive_mule': deactive_mule, 'credit': current_coins - (coins_to + 1000), 'bad_asset_ids': bad_asset_ids}, raise_on_exception=True, ) focus_on_ps(fifa_account=self.fifa_account) thread_1.start() time.sleep(10) while thread_1.is_alive(): # new_print(fifa_account, 'console web pc waiting sbc solver end , pressing left and right') self.public_moves.ps4_buttons.square() time.sleep(10) try: card_data = thread_1.join() except: new_print(self.fifa_account, 'traceback error 116 ', traceback.format_exc()) # card_data = get_card_from_mydgn( # self, self.fifa_account, deactive_mule, current_coins - (coins_to + 1000), # bad_asset_ids=bad_asset_ids) elif deactive_mule.site_name == 'buyut': thread_1 = ThreadWithReturnValue( target=get_card_from_buyut, kwargs={ 'parent_instance': self, 'fifa_account': self.fifa_account, 'deactive_mule': deactive_mule, 'credit': current_coins - (coins_to + 1000), 'bad_asset_ids': bad_asset_ids}, raise_on_exception=True, ) focus_on_ps(fifa_account=self.fifa_account) thread_1.start() time.sleep(10) while thread_1.is_alive(): self.public_moves.ps4_buttons.square() time.sleep(10) try: card_data = thread_1.join() except: new_print(self.fifa_account, 'traceback error 117 ', traceback.format_exc()) # card_data = get_card_from_buyut( # self, self.fifa_account, deactive_mule, # current_coins - (coins_to + 1000), bad_asset_ids=bad_asset_ids) elif deactive_mule.site_name == 'game_currency': thread_1 = ThreadWithReturnValue( target=get_card_from_game_currency, kwargs={ 'parent_instance': self, 'fifa_account': self.fifa_account, 'deactive_mule': deactive_mule, 'credit': current_coins - (coins_to + 1000), 'bad_asset_ids': bad_asset_ids}, raise_on_exception=True, ) focus_on_ps(fifa_account=self.fifa_account) thread_1.start() time.sleep(10) while thread_1.is_alive(): self.public_moves.ps4_buttons.square() time.sleep(10) try: card_data = thread_1.join() except: new_print(self.fifa_account, 'traceback error 118 ', traceback.format_exc()) # card_data = get_card_from_buyut( # self, self.fifa_account, deactive_mule, # current_coins - (coins_to + 1000), bad_asset_ids=bad_asset_ids) else: raise Exception('unknown mule site name') # deactive_mule.refresh_from_db() if not card_data: deactive_mule.in_use = False deactive_mule.last_run_time = timezone.localtime() deactive_mule.save(update_fields=['in_use', 'last_run_time']) if card_data: break except: new_print(self.fifa_account, 'excption in get card : ', traceback.format_exc()) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) return if not deactive_mule: new_print(self.fifa_account, 'no deactive mule found') return 'no deactive mule found' new_print(self.fifa_account, 'card data : ', card_data, ' mule : ', deactive_mule, ' site : ', deactive_mule.site_name) if card_data: if not card_data.get('asset_id') and card_data.get('futbin_link'): resp2 = self.use_cloud_scraper(card_data.get('futbin_link')) asset_id = re.search('data-baseid="(\d+)"', resp2.text).group(1) elif card_data.get('asset_id'): asset_id = card_data.get('asset_id') test_asset_id = get_player_data_by_asset_id(asset_id) if not test_asset_id[0]: player_data_result = self.get_player_data_from_futbin_with_name( player_name=card_data.get('name'), player_rate=card_data.get('level'), resource_id=card_data.get('resource_id'), player_known_as=card_data.get('name'), ) asset_id = player_data_result.get('asset_id') test_asset_id = get_player_data_by_asset_id(asset_id) if not test_asset_id[0]: new_print(self.fifa_account, 'unknown asset id 2 : ', asset_id, 'bad asset ids : ', bad_asset_ids) bad_asset_ids.append(card_data.get('asset_id')) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) cancel_buy_card(self.fifa_account, deactive_mule=deactive_mule, card_data=card_data) continue # raise Exception('unknown asset id 2') else: cancel_buy_card(self.fifa_account, deactive_mule=deactive_mule, card_data=card_data) deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save() raise Exception('unknown asset id') time.sleep(2) player_info = get_player_data_by_asset_id(asset_id) try: player_card, created = PlayerCard.objects.get_or_create( asset_id=asset_id, rating=player_info[4], ) except: player_card = PlayerCard.objects.filter( asset_id=asset_id, rating=player_info[4], ).first() # futbin_price_result = self.get_price_from_futbin_and_futwiz(card_data.get('resource_id')) try: player_cache_name = f"futbin_player_with_name_{str(card_data.get('resource_id'))}" futbin_data = self.players_log_cache.get(player_cache_name) if futbin_data and futbin_data.get('local_time_stamp') > (time.time() - 700): new_print( self.fifa_account, 'discharge2 , this item was selected from futbin less than 10 minute ago', ' , so use old data again : ', futbin_data) futbin_price_result = futbin_data else: futbin_price_result = self.get_player_data_from_futbin_with_name( player_name=card_data.get('name'), player_rate=card_data.get('level'), resource_id=card_data.get('resource_id'), rare=card_data.get('rare') ) if futbin_price_result.get('update_time_stamp'): self.players_log_cache.set(player_cache_name, futbin_price_result, timeout=ONE_DAY_SECONDS) except: new_print(self.fifa_account, 'error on get data from redis , : ', traceback.format_exc()) futbin_price_result = self.get_player_data_from_futbin_with_name( player_name=card_data.get('name'), player_rate=card_data.get('level'), resource_id=card_data.get('resource_id'), rare=card_data.get('rare') ) if futbin_price_result.get('first_price'): card_data_avg_price = futbin_price_result.get('first_price') else: card_data_avg_price = get_round_price(card_data.get('avg_price')) site_card_avg_price = get_round_price(card_data.get('avg_price')) player_final_name = player_info[0] if player_info[1]: player_final_name = player_info[1] player_card.name = player_final_name player_card.unicode_name = unidecode.unidecode(player_final_name.lower()) if not player_card.price: player_card.price = card_data_avg_price player_card.update_time = timezone.localtime() player_card.save() # different_by_seconds = (timezone.localtime() - timezone.localtime()+timezone.timedelta(seconds=card_data.get('left_time_ea_in_sec'))).total_seconds() # different_by_seconds = 3600 - different_by_seconds new_print(self.fifa_account, 'different_by_seconds = ', card_data.get('left_time_ea_in_sec')) if not self.fifa_account.run_discharge: new_print(self.fifa_account, 'discharge deactive . stop work.') cancel_buy_card(self.fifa_account, deactive_mule=deactive_mule, card_data=card_data) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) return open_transfer = DischargeMode2.objects.create( fifa_account=self.fifa_account, mule=deactive_mule, player_name=player_final_name, player_rating=card_data.get('level'), player_asset_id=asset_id, start_price=card_data.get('start_price'), end_price=card_data.get('end_price'), avg_price=get_previous_price_grade(card_data_avg_price), site_price=site_card_avg_price, income_credit=card_data.get('income_credit') ) # card_insert_time = (timezone.localtime() + timezone.timedelta(seconds=card_data.get('left_time_ea_in_sec')) # ) - timezone.timedelta(seconds=3600) system_time = get_db_time(timezone_=TIME_ZONE) card_expire_time = timezone.make_aware(system_time.fromtimestamp(int(card_data.get('expire_time_stamp')))) buy_timeout_time = timezone.localtime() + timezone.timedelta(minutes=4, seconds=30) contracts_count = card_data.get('contracts') owners_count = card_data.get('owners') for nnt in range(3): search_and_bid_result = self.public_moves.console_search_player_and_bid( player=player_card, search_start_price=card_data.get('start_price'), search_buy_now_price=card_data.get('end_price'), max_change_grade=1, wait_for_list=True, # start_price=card_data.get('start_price'), # buy_now_price=card_data.get('end_price'), # todo : expire_time is actuly put_for_sale_time. fix it to real item expire time # expire_time=card_insert_time, expire_time=card_expire_time, # expire_time=timezone.localtime() + timezone.timedelta(seconds=card_data.get('left_time_ea_in_sec')), wait_for_fix_name=False, buy_timeout_time=buy_timeout_time, contract_count=contracts_count, owner_count=owners_count, ) if search_and_bid_result.get('result') is True or search_and_bid_result.get('result') in ['player name not found', 'need_check_credit']: break close_old_connections() if str(search_and_bid_result.get('result')) in ['sid', 'not_bought', 'player name not found', 'need_check_credit']: new_print(self.fifa_account, 'error in second side 2 , search result = ', search_and_bid_result) # open_transfer.refresh_from_db() open_transfer.status = 'not_bought' open_transfer.error_description = str(search_and_bid_result.get('result')) open_transfer.save(update_fields=['status', 'error_description']) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) cancel_buy_card(self.fifa_account, deactive_mule=deactive_mule, card_data=card_data) break elif search_and_bid_result.get('result') is True: if deactive_mule.site_name == 'mydgn': if deactive_mule.is_api: timestamp = time.time() api_hash = md5( ('cons' + str(deactive_mule.api_user_name) + str(timestamp) + str( deactive_mule.api_secret_key)).encode() ).hexdigest() boutght_resp = requests.post('https://api.mydgn.com/status', json={ 'user': deactive_mule.api_user_name, 'platform': 'cons', 'timestamp': timestamp, 'hash': api_hash, 'transactionID': card_data.get('mydgn_id'), 'status': 'bought', 'emailHash': md5(deactive_mule.user_name.encode()).hexdigest() }) else: mydgn_session = card_data.get('mydgn_session') mydgn_id = card_data.get('mydgn_id') custom_header = mydgn_session.headers.__dict__ custom_header.update({ 'X-Csrf-Token': card_data.get('csrf_token') }) boutght_resp = mydgn_session.post( f'https://www.mydgn.com/auctions/bought/{mydgn_id}', json={"platform_name": "console"}, headers=custom_header) new_print(self.fifa_account, 'after buy item. has start price 3. post resp : ', boutght_resp.text) elif deactive_mule.site_name == 'buyut': if deactive_mule.is_api: timestamp = time.time() buy_status = 'bought' transaction_id = card_data.get('transaction_id') api_hash_2 = md5( (str(deactive_mule.api_user_name) + str(transaction_id) + buy_status + md5(self.fifa_account.user_name.encode()).hexdigest() + str(timestamp) + str(deactive_mule.api_secret_key)).encode() ).hexdigest() boutght_resp = requests.post(u7buy_trade_api, data={ 'user': deactive_mule.api_user_name, 'transactionId': transaction_id, 'status': buy_status, 'timestamp': timestamp, 'hash': api_hash_2, 'emailHash': md5(self.fifa_account.user_name.encode()).hexdigest(), 'request': 'status', }) time.sleep(5) else: mydgn_session = card_data.get('mydgn_session') boutght_resp = mydgn_session.post( f'https://www.u7buyut.com/buy-players-bought.html') new_print(self.fifa_account, 'after buy item. has start price 3. post resp : ', boutght_resp.text[:10000]) elif deactive_mule.site_name == 'game_currency': # if deactive_mule.is_api: # host_address = 'https://api.gamecurrency.net' # else: # host_address = 'https://api.dev.gamecurrency.co' # host_address = 'https://fifa.gamecurrency.co' host_address = card_data.get('origin_host') or 'https://fifa.gamecurrency.co' boutght_resp = requests.patch( f'{host_address}/v1/fifa/trades/{card_data.get("mydgn_id")}/', params={'status': 'checking'}, headers={'Authorization': f'Bearer {deactive_mule.api_secret_key}'}) new_print(self.fifa_account, 'after buy item. has start price 3. post resp : ', boutght_resp.text) # open_transfer.refresh_from_db() try: bought_json = boutght_resp.json() if bought_json.get('status') == 'success' or bought_json.get('code') == 200 or ( deactive_mule.site_name == 'game_currency' and boutght_resp.status_code == 200): open_transfer.status = 'success' else: open_transfer.status = 'failed' open_transfer.save(update_fields=['status']) except: new_print(self.fifa_account, 'error 111 : ', traceback.format_exc()) open_transfer.status = 'failed' open_transfer.save(update_fields=['status']) for i in range(3): new_print(self.fifa_account, 'sell item press square 3') self.public_moves.ps4_buttons.square() time.sleep(2) self.public_moves.get_screen_shot() if not self.public_moves.has_image(os.path.join( BASE_DIR, f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_sign.png'), 'screen_shot_tmp.jpg'): self.public_moves.ps4_buttons.cross() time.sleep(2) else: break new_print(self.fifa_account, 'discharge successful , list transferred item') set_main_log(self.sbc_worker, 'discharge 2 successful') # new_start_price = get_round_price(card_data_avg_price * .9) gppg = get_previous_price_grade new_start_price = gppg(gppg(gppg(card_data_avg_price))) if not self.public_moves.list_on_transfer_market( start_price=new_start_price, buy_now_price=get_previous_price_grade(card_data_avg_price), second=True): new_print(self.fifa_account, 'could not list item') new_print(self.fifa_account, 'transfer completed successful') current_coins -= card_data.get('end_price') - card_data_avg_price # self.sbc_worker.refresh_from_db() # self.sbc_worker.status_change_time = timezone.localtime() # self.sbc_worker.save() set_sbc_status(self.sbc_worker, '') # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) # todo : remove bellow after test complete new_print(self.fifa_account, 'dont buy multiple card for now') break # else: new_print(self.fifa_account, 'somthing wrong , search result : ', search_and_bid_result) # open_transfer.refresh_from_db() # todo : cancel trade if not bought open_transfer.status = 'not_bought' open_transfer.save(update_fields=['status']) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) # current_coins -= open_transfer.buy_now_price time.sleep(5) self.console_close_ultimate() self.update_credit() self.fifa_account.refresh_from_db() current_coins = self.fifa_account.credit self.public_moves.console_open_ultimate() break else: new_print(self.fifa_account, 'can not find any card with ', current_coins - (coins_to + 1000)) # deactive_mule.refresh_from_db() deactive_mule.in_use = False deactive_mule.save(update_fields=['in_use']) return 'no card found' return # def discharge_coin(self, current_coins, sell_all=False, coins_to=20000): def discharge_with_mode3(self, current_coins, sell_all=False, coins_to=20000): new_print(self.fifa_account, 'discharging mode 3 ... coins = ', current_coins, ' coins to : ', coins_to) set_main_log(self.sbc_worker, 'discharge 3 started') set_sub_log(self.sbc_worker, 'discharge 3 started') set_sbc_status(self.sbc_worker, 'discharging 3 ...') discharge_with_mode3_lowest_target_price = ConsoleBotSetting.objects.get( name='discharge_with_mode3_lowest_target_price').int_value discharge_with_mode3_highest_target_price = ConsoleBotSetting.objects.get( name='discharge_with_mode3_highest_target_price').int_value discharge_with_mode3_card_max_allowed_tax = ConsoleBotSetting.objects.get( name='discharge_with_mode3_card_max_allowed_tax').int_value # if current_coins < 1000: # new_print(self.fifa_account,'cant discharge, current coins =', current_coins) # self.console_close_ultimate() # return True # keep_coin = 20000 # if sell_all: # keep_coin = 1500 keep_coin = coins_to need_to_close = False if current_coins >= keep_coin: need_to_close = True self.public_moves.console_open_ultimate() discharge_mode3_interval_hours = ConsoleBotSetting.objects.get( name='discharge_mode3_interval_hours').int_value mules_discharge_mode3_interval_hours = ConsoleBotSetting.objects.get( name='mules_discharge_mode3_interval_hours').int_value while current_coins >= keep_coin: close_old_connections() StartDischargeBot.objects.create(fifa_account=self.fifa_account, discharge_mode=3) successful_transfer = CloseWebAppTransfers.objects.filter( second_account=self.fifa_account, error=False, second_side_done=True, web_app_start_time__gt=timezone.localtime() - timezone.timedelta(hours=discharge_mode3_interval_hours) ).first() if successful_transfer: new_print(self.fifa_account, 'this account already has success transfer') return {'status_bool': True, 'status': 'success', 'error': 'already has success transfer'} open_transfer = CloseWebAppTransfers.objects.filter( second_account=self.fifa_account, error=False, second_side_done=False).first() if not open_transfer: new_print(self.fifa_account, 'no open transfer related to this account found,' ' try to search in canceled cards') canceled_transfer = CloseWebAppTransfers.objects.filter( create_time__gt=timezone.localtime() - timezone.timedelta(minutes=50), create_time__lt=timezone.localtime() - timezone.timedelta(minutes=20), second_side_done=False, first_side_done=True, error=False, buy_now_price__lt=self.fifa_account.credit, ).first() if canceled_transfer: new_print(self.fifa_account, 'found canceled transfer, try to done, ', canceled_transfer) canceled_transfer.error = True canceled_transfer.error_description = 'moved new account' canceled_transfer.save(update_fields=['error', 'error_description']) open_transfer = CloseWebAppTransfers.objects.create( player_name=canceled_transfer.player_name, player_rating=canceled_transfer.player_rating, player_asset_id=canceled_transfer.player_asset_id, player_rare=canceled_transfer.player_rare, start_price=canceled_transfer.start_price, buy_now_price=canceled_transfer.buy_now_price, web_list_start_price=canceled_transfer.web_list_start_price, web_list_buy_now_price=canceled_transfer.web_list_buy_now_price, for_discharge=canceled_transfer.for_discharge, first_side_done=canceled_transfer.first_side_done, second_side_done=canceled_transfer.second_side_done, first_account=canceled_transfer.first_account, second_account=self.fifa_account, player_min_price=canceled_transfer.player_min_price, player_max_price=canceled_transfer.player_max_price, put_for_sale_time=canceled_transfer.put_for_sale_time, web_app_start_time=canceled_transfer.web_app_start_time, web_app_is_on_it=canceled_transfer.web_app_is_on_it, ) new_print(self.fifa_account, 'failed transfer move to new account, failed : ', canceled_transfer, ' new : ', open_transfer) if open_transfer: selected_mule_account = MuleAccounts.objects.filter(fifa_account=open_transfer.first_account).last() count = 0 while True: if count > 120: new_print(self.fifa_account, 'first side too long ... will break it') open_transfer.error = True open_transfer.save(update_fields=['error']) selected_mule_account.in_use = False selected_mule_account.last_used = timezone.localtime() selected_mule_account.save(update_fields=['in_use', 'last_used']) break count += 1 time.sleep(5) open_transfer.refresh_from_db() if open_transfer.first_side_done: new_print(self.fifa_account, 'first side done ...') try: player_card, created = PlayerCard.objects.get_or_create( asset_id=open_transfer.player_asset_id, rare=open_transfer.player_rare, rating=open_transfer.player_rating) except: player_card = PlayerCard.objects.filter( asset_id=open_transfer.player_asset_id, rare=open_transfer.player_rare, rating=open_transfer.player_rating, # name=open_transfer.player_name ).first() player_card.name = open_transfer.player_name player_card.unicode_name = unidecode.unidecode(open_transfer.player_name.lower()) # player_card.price = open_transfer.start_price player_card.save() system_time = get_db_time(timezone_=TIME_ZONE) different_by_seconds = ( timezone.make_aware(system_time) - open_transfer.put_for_sale_time).total_seconds() different_by_seconds = 3600 - different_by_seconds new_print(self.fifa_account, 'different_by_seconds 3 = ', different_by_seconds) gppg = get_previous_price_grade for nnt in [1, 2, 3]: search_and_bid_result = self.public_moves.console_search_player_and_bid( player=player_card, # search_start_price=open_transfer.start_price, search_start_price=open_transfer.web_list_start_price, search_buy_now_price=open_transfer.buy_now_price, max_change_grade=1, wait_for_list=True, # special='gold_rare', start_price=gppg(gppg(gppg(open_transfer.start_price))), buy_now_price=gppg(gppg(open_transfer.start_price)), expire_time=open_transfer.put_for_sale_time + timezone.timedelta(seconds=3600), # player_min_price=open_transfer.player_min_price, # player_max_price=open_transfer.player_max_price ) if search_and_bid_result.get('result') is True: break else: new_print(self.fifa_account, 'try to buy item for discharge but failed , try again , ', ' faield result : ', search_and_bid_result) if str(search_and_bid_result.get('result')) in ['sid', 'not_bought']: new_print(self.fifa_account, 'error in second side') open_transfer.error = True open_transfer.save(update_fields=['error']) selected_mule_account.in_use = False selected_mule_account.last_used = timezone.localtime() selected_mule_account.save(update_fields=['in_use', 'last_used']) # break return {'status_bool': False, 'status': 'failed', 'error': str(search_and_bid_result.get('result'))} elif search_and_bid_result.get('result') is True: new_print(self.fifa_account, 'after buy item. has start price 2.') open_transfer.second_side_done = True open_transfer.save(update_fields=['second_side_done']) current_coins -= open_transfer.buy_now_price set_sbc_status(self.sbc_worker, None, update_time=True) selected_mule_account.fifa_account.credit = selected_mule_account.fifa_account.credit + ( open_transfer.buy_now_price - (open_transfer.buy_now_price * .1)) selected_mule_account.fifa_account.save(update_fields=['credit']) selected_mule_account.in_use = False selected_mule_account.last_used = timezone.localtime() selected_mule_account.save(update_fields=['in_use', 'last_used']) set_main_log(self.sbc_worker, 'discharge 3 successful') for i in range(3): new_print(self.fifa_account, 'sell item press square 2') self.public_moves.ps4_buttons.square() time.sleep(2) self.public_moves.get_screen_shot() if not self.public_moves.has_image(os.path.join( BASE_DIR, f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_sign.png'), 'screen_shot_tmp.jpg'): self.public_moves.ps4_buttons.cross() time.sleep(2) else: break new_start_price = get_round_price(open_transfer.start_price * .9) # for ii in range(10): # new_start_price = gppg(new_start_price) if not self.public_moves.list_on_transfer_market( new_start_price, gppg(gppg(open_transfer.start_price)), second=True): new_print(self.fifa_account, 'could not list item') new_print(self.fifa_account, 'transfer completed successful') # self.sbc_worker.refresh_from_db() # self.sbc_worker.status_change_time = timezone.localtime() # self.sbc_worker.save() # break return {'status_bool': True, 'status': 'success'} else: new_print(self.fifa_account, 'somthing wrong , search result : ', search_and_bid_result) open_transfer.error = True open_transfer.save(update_fields=['error']) selected_mule_account.in_use = False selected_mule_account.last_used = timezone.localtime() selected_mule_account.save(update_fields=['in_use', 'last_used']) # current_coins -= open_transfer.buy_now_price time.sleep(5) self.console_close_ultimate() # time.sleep(10) # logout_login(self, self.sbc_worker, self.fifa_account) # self.update_credit() # self.fifa_account.refresh_from_db() # current_coins = self.fifa_account.credit # self.public_moves.console_open_ultimate() # time.sleep(30) # self.public_moves.go_to_state('search_players', 'transfer_list') # time.sleep(3) # break return {'status_bool': False, 'status': 'failed', 'error': 'unknown'} if open_transfer.error: new_print(self.fifa_account, 'error in first side ...') selected_mule_account.in_use = False selected_mule_account.last_used = timezone.localtime() selected_mule_account.save(update_fields=['in_use', 'last_used']) # break return {'status_bool': False, 'status': 'failed', 'error': 'unknown'} # try: # console_coin = self.public_moves.read_coin() # if current_coins <= int(console_coin): # current_coins = console_coin # except: # pass continue else: new_print(self.fifa_account, 'no open transfer found, create new.') if current_coins < discharge_with_mode3_lowest_target_price: new_print(self.fifa_account, 'coin is below ', discharge_with_mode3_lowest_target_price) return {'status_bool': False, 'status': 'failed', 'error': 'low credit'} # buy_now_price = current_coins - coins_to buy_now_price = current_coins target_price = get_round_price(buy_now_price * 1.8) # if buy_now_price < 4500: # target_price = buy_now_price / 3 # elif buy_now_price < 10000: # target_price = buy_now_price / 2 if target_price < 1000: target_price = 1000 last_30_min_discharge = CloseWebAppTransfers.objects.filter( create_time__gt=timezone.localtime() - timezone.timedelta(minutes=12), second_side_done=True ) mule_account = MuleAccounts.objects.exclude( fifa_account__in=last_30_min_discharge.values('first_account') ).exclude( last_used__gt=timezone.localtime() - timezone.timedelta(minutes=10) ).filter( Q(fifa_account__delete_console_reason=None) | Q(fifa_account__delete_console_reason=''), in_use=False, error=False, fifa_account__need_captcha=False, # deleted=True, # fifa_account__user_name__in=['lesmodawiz@outlook.com', 'kumzuwuqob@outlook.com'] # todo : uncomment below investors__in=[self.fifa_account.console.investor], deleted=False, fifa_account__credit__gte=int(discharge_with_mode3_lowest_target_price * .8) ).annotate( search_count_24_hour=Coalesce(Subquery( FifaAccountSearch.objects.filter( fifa_account__id=OuterRef('fifa_account__id'), search_time__gt=timezone.localtime() - timezone.timedelta(hours=mules_discharge_mode3_interval_hours) ).values('fifa_account').annotate( search_counter=Count('id', output_field=IntegerField()) ).values('search_counter'), output_field=IntegerField() ), Value(0)), credit_diff=Abs(F('fifa_account__credit') - int(buy_now_price * .7)) ).filter( search_count_24_hour__lt=ConsoleBotSetting.objects.get( name='account_high_search_count').int_value - 4 ).order_by('credit_diff').first() if mule_account: new_print(self.fifa_account, 'selected mule for discharge with pod snipe : ', mule_account) # mule_account.refresh_from_db() mule_account.in_use = True mule_account.last_used = timezone.localtime() mule_account.save(update_fields=['last_used', 'in_use']) if target_price > mule_account.fifa_account.credit: new_print(self.fifa_account, 'mule credit = ', mule_account.fifa_account.credit, 'mule fifa id = ', mule_account.fifa_account.id) target_price = mule_account.fifa_account.credit player_target_price = calculate_player_price_for_injection2( inject_coin=current_coins-coins_to, account_coin=current_coins-coins_to, max_player_price=min(discharge_with_mode3_highest_target_price, mule_account.fifa_account.credit - 1000) ) new_print(self.fifa_account, 'target_price = ', target_price, ' player_target_price : ', player_target_price, ' buy_now_price : ', buy_now_price) special_targets = DischargeMode3SpecialPlayers.objects.filter(first_price__lt=int(player_target_price['player_price'])).order_by('-first_price') targets = [] if special_targets: targets = [] for iii in list(special_targets)[:10]: check_result = self.check_card_for_discharge3( futbin_player_id=iii.futbin_id, player_price=player_target_price['player_price']) if check_result and not check_result.get('error'): check_result['special_target_id'] = iii.id targets.append(check_result) else: bad_player_reason = check_result.get('error') if bad_player_reason: iii.last_fifa_account_used = self.fifa_account iii.bad_for_discharge_reason = bad_player_reason iii.save(update_fields=['bad_for_discharge_reason']) new_print(self.fifa_account, 'check result not found , try to get from futbin ,', ' futbin id : ', iii.futbin_id) check_result = self.get_price_from_futbin_and_futwiz(iii.futbin_id, wait_on_error=10) time.sleep(2) if check_result: iii.player_name = str(check_result.get('display_name')) iii.price_list = str(check_result.get('futbin_price_list')) iii.first_price = int(check_result.get('first_price') or 0) iii.update_time = timezone.localtime() iii.save(update_fields=['player_name', 'price_list', 'first_price', 'update_time']) targets = targets + self.get_futbin_player_card_with_price(player_target_price['player_price']) new_print(self.fifa_account, 'final players for next step : ', targets) # ps_prp = '2,55' # if target_price > 100000: # ps_prp = '2,60' # link = 'https://www.futbin.com/players?page=1&ps_price=0-%s&ps_prp=%s&version=gold&sort=ps_price&order=desc' % ( # target_price, ps_prp) # resp = self.use_cloud_scraper(link).text # soup = BeautifulSoup(resp, "html.parser") # targets = soup.find_all(class_="player_img") found = False for target in targets: bad_for_discharge = False # target_asset_part = (target['data-original']) # target_asset_part = target_asset_part[::-1] # target_asset_begin = target_asset_part.find('.') + 1 # target_asset_end = target_asset_part.find('/', target_asset_begin) # target_asset_id = (target_asset_part[target_asset_begin:target_asset_end])[::-1] target_asset_id = target['asset_id'] error_for_this_player = CloseWebAppTransfers.objects.filter( player_asset_id=target_asset_id, error=True, put_for_sale_time__gt=timezone.localtime() - timezone.timedelta(minutes=30)).exclude( buy_now_price=0 ).first() if error_for_this_player: new_print(self.fifa_account, ' error_for_this_player ', error_for_this_player, ' player : ', target, ' continue') # bad_for_discharge = True continue search_result2 = self.get_data_from_furbin_with_target_information(target.get('futbin_player_id')) time.sleep(2) bad_player = search_result2.get('bad_player') rate = search_result2.get('player_rating') target_asset_id = search_result2.get('asset_id') rare = search_result2.get('rare_id') player_price = search_result2.get('first_price') futbin_min_price = search_result2.get('futbin_min_price') if bad_player: new_print(self.fifa_account, 'player has other cards , player ', target) bad_for_discharge = True # player_price, updated_time, first_price, futbin_min_price, futbin_max_price = self.get_price_from_futbin_and_futwiz( # target_asset_id) futbin_result = self.get_price_from_futbin_and_futwiz(target.get('futbin_player_id')) time.sleep(2) # price = futbin_result.get('price', 0) # updated_time = futbin_result.get('update_time') # todo : fix bellow line , use first price instead of price , but need to search in console fixed with rating or rare futbin_first_price = futbin_result.get('price', 0) or futbin_result.get('first_price', 0) # futbin_min_price = futbin_result.get('futbin_min_price') futbin_max_price = futbin_result.get('futbin_max_price') player_price = futbin_first_price if not bad_for_discharge: # if player_price > target_price: if player_price > player_target_price['player_price']: new_print(self.fifa_account, 'player_price = ', player_price, 'target_price = ', target_price, ' player target price : ', player_target_price, 'target , continue') continue # if not bad_for_discharge: # update_time_is_ok = self.check_player_locally(target_asset_id, updated_time) # if not update_time_is_ok: # new_print(self.fifa_account, 'update_time_is_ok', update_time_is_ok) # bad_for_discharge = True new_price = None buy_now_price, player_card, player_name = self.get_data_for_putting_for_sale_in_console( player_price, rate, target_asset_id, rare, futbin_resource_id=target.get('futbin_player_id')) if not player_name: new_print(self.fifa_account, 'player name cant be empty , seems need to update players.json, continue') telegram_send_message_fifa_account( self.fifa_account, FIFA_REPORT_TOKEN, f'search item for discharge\n account: {self.fifa_account}\nplayer name cant be empty, need to update players.json', chat_id=ARZBAZI_REPORT_GROUP_ID, message_thread_id=ARZBAZI_REPORT_TOPIC_PLAYERS_NOT_FOUND_THREAD_MESSAGE_ID ) continue if buy_now_price > current_coins: buy_now_price = get_round_price(current_coins) if not bad_for_discharge: # change_grade = 4 # if player_price > 40000: # change_grade = 20 change_grade = 2 console_search_price_result = self.console_search_price( player_card, force_manual=1, change_grade=change_grade) new_print(self.fifa_account, 'new_price = ', new_price, ' console search price : ', console_search_price_result) if str(console_search_price_result) in ['sid', 'search not result', 'too many change grade']: bad_for_discharge = True elif isinstance(console_search_price_result, int): new_price = console_search_price_result # gnpg = get_next_price_grade # # if not bad_for_discharge and player_price < 40000: # player_name = get_player_fifa_name_by_id(player_card.asset_id) # if not self.public_moves.search_player( # player_name, player_card.rating, # player_card.asset_id, # max_buy_now=gnpg(gnpg(gnpg(gnpg(new_price)))), # special=player_card.special_name, reset_data=0): # new_print(self.fifa_account, 'couldnt search 4 grade higher player price') # bad_for_discharge = True # # if not bad_for_discharge: # if self.public_moves.has_search_result(): # # result_count = self.public_moves.get_live_search_count() # result_count = 11 # new_print(self.fifa_account, 'has search result , count : ', result_count) # time.sleep(1) # self.public_moves.ps4_buttons.circle() # else: # result_count = 0 # new_print(self.fifa_account, 'no card found with this price , press cross') # self.public_moves.ps4_buttons.cross() # time.sleep(1) # new_print(self.fifa_account, 'result_count = ', result_count) # if result_count < 10: # new_print(self.fifa_account, 'player price is not certain') # bad_for_discharge = True if bad_for_discharge: new_print(self.fifa_account, 'item bad for discharge , ', target) if player_price < 24000: CloseWebAppTransfers.objects.create( player_name=player_name, player_rating=rate, player_rare=rare, player_asset_id=target_asset_id, error=True, second_account=self.fifa_account, start_price=player_price) continue # player_price = get_next_price_grade(new_price) # player_price = new_price # temp_buy_now_price = get_round_price((player_price * 3) / 2) # temp_buy_now_price = get_round_price(player_price * 1.5) # if (current_coins > temp_buy_now_price) and (buy_now_price < temp_buy_now_price): # buy_now_price = temp_buy_now_price calculated_data = calculate_player_price_with_tax(new_price or futbin_first_price) if calculated_data.get('list_buy_now_price') >= int(futbin_max_price or 0): new_print(self.fifa_account, 'player max price less than list_buy_now_price : ', 'calculated ', calculated_data, ' max price : ', int(futbin_max_price or 0)) continue new_print(self.fifa_account, 'calculated data : ', calculated_data) found = True transfer = CloseWebAppTransfers.objects.create(first_account=mule_account.fifa_account) transfer.player_name = player_name transfer.player_rating = rate transfer.player_rare = rare transfer.player_asset_id = target_asset_id # todo : list start price must be another price. start price with min price, maybe someone bid item transfer.start_price = new_price or futbin_first_price transfer.buy_now_price = calculated_data.get('list_buy_now_price') if calculated_data.get('list_buy_now_price') > (self.fifa_account.credit - coins_to): new_print(self.fifa_account, 'account credit less than calculated , ', self.fifa_account.credit, ' -- ', calculated_data.get('list_buy_now_price')) transfer.buy_now_price = get_round_price(self.fifa_account.credit - coins_to) if calculated_data.get('list_buy_now_price') > int(futbin_max_price or 0): new_print(self.fifa_account, 'list buy now price can not be more than max price', calculated_data.get('list_buy_now_price'), ' max price : ', futbin_max_price) transfer.buy_now_price = int(futbin_max_price or 0) transfer.web_list_start_price = calculated_data.get('list_start_price') transfer.for_discharge = True transfer.second_account = self.fifa_account transfer.save() mule_account.in_use = True mule_account.last_used = timezone.localtime() mule_account.save(update_fields=['last_used', 'in_use']) new_print(self.fifa_account, 'target inserted to database ... , target ', target, ' transfer : ', transfer, ' calculated_data ', calculated_data, ' mule account : ', mule_account) break if not found: mule_account.in_use = False mule_account.last_used = timezone.localtime() mule_account.save(update_fields=['last_used', 'in_use']) new_print(mule_account.fifa_account, 'mule used but not player found w8 2 mins , ', self.fifa_account) new_print(self.fifa_account, 'no player found w8 2 mins') time.sleep(120) else: new_print(self.fifa_account, 'no mule account found , wait for 120 secs') time.sleep(120) return {'status_bool': False, 'status': 'failed', 'error': 'no mule found'} if need_to_close: self.console_close_ultimate() else: new_print(self.fifa_account, 'need to sleep for 120 secs') time.sleep(120) return {'status_bool': False, 'status': 'failed', 'error': 'unknown result'} def web_app_discharge_mode3_staff(self, transfer: CloseWebAppTransfers): new_print(self.fifa_account, 'web_app_discharge_pod_snipe_staff started to buy item and sell it.', ' transfer : ', transfer) self.inject_or_discharge_web_app_start_things() self.main_dic['bid_controller_count'] = 0 temp_count = 0 while True: temp_count += 1 if temp_count > 2: new_print(self.fifa_account, 'checked and must done bot 3') transfer.refresh_from_db() transfer.error = True transfer.web_app_is_on_it = False transfer.save(update_fields=['error', 'web_app_is_on_it']) return '' try: if temp_count >= 1: login_status = logout_login(self, self.sbc_worker, self.fifa_account) new_print(self.fifa_account, 'login result : ', login_status) if not (login_status.get('status_bool') is True): new_print(self.fifa_account, 'error in login result : ', login_status) transfer.error = True transfer.web_app_is_on_it = False transfer.save(update_fields=['error', 'web_app_is_on_it']) MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return self.update_credit() self.fifa_account.refresh_from_db() new_print(self.fifa_account, 'mule account credit =', self.fifa_account.credit) if self.fifa_account.credit < transfer.start_price: new_print(self.fifa_account, 'mule credit less than start price , ', self.fifa_account.credit, ' start price : ', transfer.start_price) transfer.error = True transfer.web_app_is_on_it = False transfer.save(update_fields=['error', 'web_app_is_on_it']) MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return bought_trade = self.search_player_and_bid( transfer.player_asset_id, transfer.start_price, 5, rating=transfer.player_rating, rare=transfer.player_rare, trade_mode=3) if not bought_trade: new_print(self.fifa_account, 'couldnt buy this item 1') bought_trade = self.search_player_and_bid( transfer.player_asset_id, get_next_price_grade(transfer.start_price), 5, rating=transfer.player_rating, rare=transfer.player_rare, trade_mode=3) if not bought_trade: new_print(self.fifa_account, 'couldnt buy this item 2') transfer.error = True transfer.web_app_is_on_it = False transfer.save(update_fields=['error', 'web_app_is_on_it']) MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) return time.sleep(1) new_print(self.fifa_account, 'item bought successful') bought_trade_id = bought_trade['itemData']['id'] link = f'{fifa_23_address}/marketdata/item/pricelimits?itemIdList={bought_trade_id}' resp = self.se.get(link, headers=self.main_dic['header']) save_account_request( fifa_account=self.fifa_account, link=f'{fifa_23_address}/marketdata/item/pricelimits?itemIdList=%s', ) # new_print(self.fifa_account, link) new_print(self.fifa_account, 'link :', link, ' resp = ', resp.text) js_resp = resp.json() min_price = js_resp[0]['minPrice'] max_price = js_resp[0]['maxPrice'] if transfer.web_list_start_price > max_price or transfer.buy_now_price > max_price: new_print(self.fifa_account, 'how start price or buy price is more than max price', ', something wrong ', transfer.start_price, ' - ', transfer.web_list_start_price, ' buy price : ', transfer.buy_now_price, ' max_price ', max_price, ' transfer : ', transfer) transfer.error = True transfer.buy_now_price = get_previous_price_grade(max_price) transfer.web_list_start_price = get_previous_price_grade(get_previous_price_grade(max_price)) transfer.save(update_fields=['error', 'buy_now_price', 'web_list_start_price']) new_print(self.fifa_account, 'min_price = ', min_price, 'max_price = ', max_price) time.sleep(0.5) self.item_put_for_sale(bought_trade['itemData']['id'], bought_trade['tradeId'], 0, # start_price=transfer.start_price, start_price=transfer.web_list_start_price, buy_now_price=transfer.buy_now_price) transfer.first_side_done = True transfer.web_app_is_on_it = False transfer.put_for_sale_time = timezone.localtime() transfer.player_min_price = min_price transfer.player_max_price = max_price transfer.save(update_fields=['first_side_done', 'web_app_is_on_it', 'put_for_sale_time', 'player_min_price', 'player_max_price']) new_print(self.fifa_account, 'item put for sale successful') try: # delete_sold_items(self.se, self.main_dic['header'], self.server_key) # save_account_request( # fifa_account=self.fifa_account, # link=f'{fifa_23_address}/trade/sold', # ) sell_items(self, self.sbc_worker, self.fifa_account) except: pass MuleAccounts.objects.filter(fifa_account=self.fifa_account).update(in_use=False) new_print(self.fifa_account, 'in_use set false successfully') return except: new_print(self.fifa_account, 'error 69 : ', traceback.format_exc()) self.sbc_worker.refresh_from_db() if self.sbc_worker.must_done: # transfer.refresh_from_db() transfer.error = True transfer.web_app_is_on_it = False transfer.save(update_fields=['error', 'web_app_is_on_it']) new_print(self.fifa_account, 'checked and must done bot') return '' # try: # # self.get_new_sid() # MuleAccounts.objects.filter(fifa_account=self.fifa_account).update( # last_sid=self.main_dic['sid'], last_nucleus=self.nucleus_id, # last_persona=self.persona_id) # except: # self.logout_login() def get_data_for_putting_for_sale_in_console(self, player_price, rate, target_asset_id, rare, futbin_resource_id=0): player_name = get_player_fifa_name_by_id(target_asset_id) new_print(self.fifa_account, 'get data for put sale in console , player name = ', player_name, ' player price : ', player_price) buy_now_price = player_price * 1.5 if player_price < 1500: buy_now_price = player_price * 3 elif player_price < 5000: buy_now_price = player_price * 2 buy_now_price = get_round_price(buy_now_price) try: player_card, created = PlayerCard.objects.get_or_create(asset_id=target_asset_id, rating=rate, rare=rare) new_print(self.fifa_account, 'player card created : ', player_card, ' -- ', target_asset_id, ' -- ', rate, ' -- ', player_name, ' , ', ' created : ', created, ' -- ', player_price) if player_price: player_card.price = player_price player_card.update_time = timezone.localtime() except: player_card = PlayerCard.objects.filter(asset_id=target_asset_id, rating=rate, rare=rare).first() player_card.unicode_name = unidecode.unidecode(player_name.lower()) player_card.name = player_name if futbin_resource_id and not player_card.futbin_resource_id: player_card.futbin_resource_id = futbin_resource_id # if player_price: # player_card.price = player_price # player_card.update_time = timezone.localtime() player_card.save() # todo : return rare too return buy_now_price, player_card, player_name def get_data_from_furbin_with_target_information(self, futbin_id, rare_type=None): # todo : after futbin update , this method need to update # target_asset_part = (target['data-original']) # target_asset_part = target_asset_part[::-1] # target_asset_begin = target_asset_part.find('.') + 1 # target_asset_end = target_asset_part.find('/', target_asset_begin) # target_asset_id = (target_asset_part[target_asset_begin:target_asset_end])[::-1] # parent_elem = target.parent.parent.parent # target_link = parent_elem['data-url'] # # new_print(self.fifa_account, 'futbin target data : ', target_asset_id, target_link) # parent_childs = parent_elem.findAll("td", recursive=False) # rate_elem = parent_childs[2] # rate_span = rate_elem.find('span') # rate = rate_span.text bad_player = False resp2 = self.use_cloud_scraper(f'{futbin_address}/player/{futbin_id}/a').text soup = BeautifulSoup(resp2, "html.parser") player_asset_id = int(soup.find('th', text='ID').parent.find('td').text) player_card_wrapper = soup.find(class_='player-card-wrapper') player_futbin_id = player_card_wrapper['data-id'] player_rating = soup.find(class_='playercard-25-rating').text display_name = player_card_wrapper.find('div', attrs={'title': True})['title'] player_wrapper_image = player_card_wrapper.find('img', class_='playercard-25-base-img') if not player_wrapper_image: player_wrapper_image = player_card_wrapper.find('img', class_='playercard-25-special-img') try: player_image_url = player_card_wrapper.find('img')['src'] current_player_rare = int(re.search( 'hd/(\d+)_', str(urllib.parse.unquote(player_image_url)) ).group(1)) except: current_player_rare = 2 player_resource_id = re.search(r'/players/(.+)\.png', urllib.parse.unquote( player_wrapper_image['src'])) if player_resource_id: player_resource_id = player_resource_id.group(1) player_resource_id = ''.join([ii for ii in player_resource_id if ii.isdigit()]) else: player_resource_id = 0 # player_versions = soup.find(class_="player-versions") # player_rare = re.search('data-rare-type=\"(.+)\" ', resp2).group(1) player_rare = int(re.search( 'hd/(\d+)_', str(urllib.parse.unquote(player_card_wrapper.find('img')['src'])) ).group(1)) # data_baseid = re.search('data-baseid="(\d+)"', resp2) # if data_baseid: # target_asset_id = data_baseid.group(1) new_print(self.fifa_account, 'player data : rate = ', player_rating, ' rare = ', player_rare, ' asset id = ', player_asset_id) card_info = None for iie in soup.find_all(class_='price-box'): # if 'price-box' in iie['class'] and 'player-price-not-ps' in iie['class'] and 'hidden' not in iie['class']: if ('price-box' in iie['class'] and 'player-price-not-ps' in iie['class'] and 'price-box-original-player' in iie['class']): card_info = iie break if not card_info.find(class_='lowest-price-1'): new_print(self.fifa_account, 'bad player , has not price') bad_player = 'has not price' if not bad_player: try: current_version = re.search( r'hd/([^.]+)\.png', str(urllib.parse.unquote(player_card_wrapper.find('img')['src'])) ).group(1) # pversions = player_versions.find( pversions = soup.find( class_='player-header-card-section' ).find_all( lambda tag: 'player-card-wrapper' in tag.get('class', []) and 'hidden' in tag.get('class', []) ) if pversions: # gold_cards_info = [] other_rarities = [] for pversion in pversions: card_version = re.search( r'hd/([^.]+)\.png', str(urllib.parse.unquote(pversion.find('img')['src'])) ).group(1) # a_elem = pversion.find('a') # player_image_url = pversion.find('img')['src'] other_rarities.append(card_version) # player_rare_tmp = int(re.search( # 'hd/(\d+)_', str(urllib.parse.unquote(player_image_url)) # ).group(1)) # # player_rare_tmp = a_elem['data-rare-type'] # player_level_tmp =re.search( # 'hd/(\d+)_(.+).png', str(urllib.parse.unquote(player_image_url)) # ).group(2) # gold_cards_info.append(f"{player_level_tmp} {player_rare_tmp}") # if not rare_type and a_elem['data-level'] == 'gold' and player_rare_tmp <= 1: # new_print(self.fifa_account, '####### another gold card founded') # bad_player = True # break # elif rare_type and player_level_tmp == 'gold' and player_rare_tmp == int(player_rare): # new_print(self.fifa_account, '####### another rare card founded') # bad_player = True # break # new_print(self.fifa_account, 'gold cards info : ', gold_cards_info) if current_version in other_rarities: new_print(self.fifa_account, 'same rarities found . bad for discharge ', current_version, ' -- ', other_rarities) bad_player = 'same rarity' else: new_print(self.fifa_account, 'player hasnt any other card') except: new_print(self.fifa_account, 'player hasnt any other card 2 ', traceback.format_exc()) output_data = self.get_price_from_futbin_and_futwiz(futbin_id, page_source=resp2) if not output_data.get('first_price'): new_print(self.fifa_account, 'player has no price , set as bad player') bad_player = 'has not price' else: output_data = {} output_data.update({ 'asset_id': player_asset_id, 'resource_id': player_resource_id, 'player_name': display_name, 'player_rating': player_rating, 'bad_player': bool(bad_player), 'rare_id': int(player_rare), 'bad_for_discharge': bool(bad_player), 'bad_for_discharge_reason': bad_player, }) return output_data def discharge_with_snipe(self, current_coins, sell_all=False, coins_to=10000): new_print(self.fifa_account, 'discharging with snipe ... coins = ', current_coins) set_sub_log(self.sbc_worker, 'discharge started') set_sbc_status(self.sbc_worker, 'discharging ...') self.public_moves.console_open_ultimate() loop_keeper = [current_coins, 0] while current_coins > coins_to and self.fifa_account.run_discharge: discharge_lowest_target_price = ConsoleBotSetting.objects.get( name='discharge_with_snipe_lowest_target_price').int_value discharge_highest_target_price = ConsoleBotSetting.objects.get( name='discharge_with_snipe_highest_target_price').int_value force_discharge_lowest_target_price = ConsoleBotSetting.objects.get( name='force_discharge_lowest_target_price').int_value discharge_with_snipe_card_max_allowed_tax = ConsoleBotSetting.objects.get( name='discharge_with_snipe_card_max_allowed_tax').str_value discharge_with_snipe_lowest_buy_now_price = ConsoleBotSetting.objects.get( name='discharge_with_snipe_lowest_buy_now_price').int_value try: # current_time = timezone.datetime.fromisoformat( # requests.get('http://142.132.177.244:8000/accounts/get-local-timezone/').json().get( # 'local_timezone') # ) current_time = get_db_time(timezone_=TIME_ZONE) except: new_print(self.fifa_account, 'can`t read current time : ', traceback.format_exc()) current_time = timezone.localtime() started_bots = StartDischargeBot.objects.filter( discharge_mode=1, create_time__gt=current_time - timezone.timedelta(seconds=30) ).count() if started_bots > 3: new_print(self.fifa_account, 'started bot for discharge in 30 sec : ', started_bots) return True else: StartDischargeBot.objects.create(fifa_account=self.fifa_account, discharge_mode=1) if current_coins - coins_to < discharge_lowest_target_price and sell_all is False: new_print(self.fifa_account, 'discharge done, current coins = ', current_coins, ' sell all = ', sell_all, ' lowest target = ', discharge_lowest_target_price) self.public_moves.console_close_ultimate(need_get_new_sid=False) return True # elif current_coins - coins_to < 10000 and sell_all is True: elif current_coins - coins_to < force_discharge_lowest_target_price and sell_all is True: new_print(self.fifa_account, 'discharge done 2 , current coins =', current_coins, ' coins_to ', coins_to, ' lowest target = ', force_discharge_lowest_target_price) self.public_moves.console_close_ultimate(need_get_new_sid=False) return True set_sub_log(self.sbc_worker, 'waiting in queue') new_print(self.fifa_account, 'waiting in queue') count_working_on_webs = CloseWebAppSnipes.objects.filter(first_side_ready=True, error=False, second_side_done=False).count() if count_working_on_webs >= 6: random_sleep = random.randint(10, 100) new_print(self.fifa_account, 'maximum snipers capacity reached .sleep for %s seconds' % random_sleep) time.sleep(random_sleep) continue ready_mule_accounts = MuleAccounts.objects.filter( fifa_account__credit__gt=discharge_with_snipe_lowest_buy_now_price, in_use=False, error=False, fifa_account__need_captcha=False, investors__in=[self.fifa_account.console.investor], deleted=False, ).annotate( search_count_24_hour=Coalesce(Subquery( FifaAccountSearch.objects.filter( fifa_account__id=OuterRef('fifa_account__id'), search_time__gt=timezone.localtime() - timezone.timedelta(hours=24) ).values('fifa_account').annotate( search_counter=Count('id', output_field=IntegerField()) ).values('search_counter'), output_field=IntegerField() ), Value(0)) ).filter(search_count_24_hour__lt=self.account_high_search_count).order_by('last_used') if ready_mule_accounts.count() < 10: random_sleep = random.randint(10, 100) new_print(self.fifa_account, 'need more mules .sleep for %s seconds' % random_sleep) time.sleep(random_sleep) continue set_sub_log(self.sbc_worker, 'getting a target') new_print(self.fifa_account, 'must discharge coin', current_coins, coins_to) # if current_coins - ((float(current_coins) * 15) / 100) > 1000: # target_price = current_coins - ((float(current_coins) * 15) / 100) # else: # target_price = 1000 target_price = current_coins - coins_to ps_prp = '10,90' if target_price > discharge_highest_target_price: target_price = discharge_highest_target_price # if target_price > 25000: # ps_prp = '25,60' # link = 'https://www.futbin.com/players?page=1&ps_price=0-%s&ps_prp=%s&version=gold_rare&sort=ps_price&order=desc' % ( # target_price, ps_prp) base_link = f'https://www.futbin.com/players?page=1&ps_price={discharge_lowest_target_price}-{target_price}&sort=ps_price&order=desc' players_links = { 'gold_rare': { 'url': base_link + '&version=gold_rare', 'name': 'gold_rare', 'targets': [], 'futbin_version': 'gold_rare', 'active': True, }, 'team_of_week': { 'url': base_link + '&version=if_gold', 'name': 'team_of_week', 'targets': [], 'futbin_version': 'if_gold', 'active': False, }, 'fantasy_fut': { 'url': base_link + '&version=fantasy_fc', 'name': 'fantasy_fut', 'targets': [], 'futbin_version': 'fantasy', 'active': False, }, 'team_of_the_season_moment': { 'url': base_link + '&version=totssfn', 'name': 'team_of_the_season_moment', 'targets': [], 'futbin_version': 'totssfn', 'active': False, }, 'team_of_the_season': { 'url': base_link + '&version=tots', 'name': 'team_of_the_season', 'targets': [], 'futbin_version': 'tots', 'active': False, }, 'fut_birthday': { 'url': base_link + '&version=fut-bd', 'name': 'fut_birthday', 'targets': [], 'futbin_version': 'fut-bd', 'active': False, }, 'shapeshifters': { 'url': base_link + '&version=shapeshifters', 'name': 'shapeshifters', 'targets': [], 'futbin_version': 'shapeshifters', 'active': False, }, 'toty': { 'url': base_link + '&version=toty', 'name': 'toty', 'targets': [], 'futbin_version': '', 'active': False, }, 'tots_live': { 'url': base_link + '&version=tots_live', 'name': 'tots_live', 'targets': [], 'futbin_version': 'tots_live', 'active': False, } } for iir in players_links.values(): if not iir.get('active'): new_print(self.fifa_account, 'version ', iir.get('futbin_version'), ' is not active , continue') continue pl_link = iir.get('url') resp_5 = self.use_cloud_scraper(pl_link) time.sleep(5) soup_5 = BeautifulSoup(resp_5.text, "html.parser") link_targets = [] for iii in soup_5.find_all(class_='player-row'): link_targets.append(re.search('player/(\d+)/', iii.find('a')['href']).group(1)) iir.update({'targets': link_targets}) # todo : uncomment bellow after fix other filters # link_all_targets = f'https://www.futbin.com/players?page=1&pos_type=all&ps_price={discharge_lowest_target_price}-{target_price}&sort=ps_price&version=shapeshifters,fut-bd,tots,totssfn,fantasy,if_gold,gold&order=desc' link_all_targets = base_link + '&version=' + ','.join([ iint.get('futbin_version') for iint in players_links.values() if iint.get('active') ]) resp_3 = self.use_cloud_scraper(link_all_targets).text time.sleep(5) soup_3 = BeautifulSoup(resp_3, "html.parser") # all_targets = soup_3.find_all(class_="player_img") all_targets = [] for iii in soup_3.find_all(class_='player-row'): all_targets.append(re.search('player/(\d+)/', iii.find('a')['href']).group(1)) targets = list(all_targets) if len(targets) == 0: new_print(self.fifa_account, 'no target found w8 120 secs') # todo : remove break after players price comes up break # if current_coins < 5000: # new_print(self.fifa_account, 'coin under 5000') # return # time.sleep(120) # continue # special_targets = SniperPlayerCard.objects.filter(use_console_discharge=True) # targets = list(special_targets) + targets bad_targets_asset_id = [] t_bought = 0 # target_type = 'normal' for target in targets: use_targe_and_filter = False target_filter = None self.fifa_account.refresh_from_db() if self.fifa_account.run_discharge is False: break if False and isinstance(target, SniperPlayerCard): new_print(self.fifa_account, 'discharge target is sniper player card , ', target) target_type = 'special' card_info = get_player_data_by_asset_id(player_asset_id=target.player_card.asset_id) # player_price, update_time, fp, futbin_min_price, futbin_max_price = self.get_player_price_from_futbin_web_app( futbin_result = self.get_player_price_from_futbin_web_app( player_name=target.player_card.name, player_rate=target.player_card.rating, player_known_as=card_info[1], player_rare=target.player_card.rare, player_f=card_info[2], player_l=card_info[3], player_asset_id=target.player_card.asset_id ) player_price = futbin_result.get('price') futbin_min_price = futbin_result.get('futbin_min_price') rate = target.player_card.rating target_asset_id = target.player_card.asset_id rare = target.player_card.rare player_price = int(player_price) if player_price == 0: new_print(self.fifa_account, 'player price is 0. will change target') continue if futbin_min_price < target.min_price: futbin_min_price = target.min_price elif target: new_print(self.fifa_account, 'discharge with snipe and filter , ', target) if target in players_links.get('gold_rare', {}).get('targets'): search_result = self.get_data_from_furbin_with_target_information( target, rare_type=False) else: search_result = self.get_data_from_furbin_with_target_information( target, rare_type=True) bad_player = search_result.get('bad_player') rate = search_result.get('player_rating') target_asset_id = search_result.get('asset_id') rare = search_result.get('rare_id') player_price = search_result.get('first_price') futbin_min_price = search_result.get('futbin_min_price') if bad_player: new_print(self.fifa_account, 'player has other cards 33.') continue # card_info = get_player_data_by_asset_id(player_asset_id=target_asset_id) # # player_price, update_time, fp, futbin_min_price, futbin_max_price = self.get_player_price_from_futbin_web_app( # futbin_result = self.get_player_price_from_futbin_web_app( # player_name=card_info[0], # player_rate=rate, # player_known_as=card_info[1], # player_rare=rare, # player_f=card_info[2], player_l=card_info[3], # player_asset_id=target_asset_id # ) # player_price = futbin_result.get('price') # futbin_min_price = futbin_result.get('futbin_min_price') # rate = target.player_card.rating # target_asset_id = target_asset_id # rare = target.player_card.rare player_price = int(player_price) if player_price == 0: new_print(self.fifa_account, 'player price is 0. will change target') time.sleep(2) continue # todo : market get crazy . after fix remove below if # if int(target_asset_id) not in [190871, 158023, 240130]: # # if int(target_asset_id) not in [190871, 158023]: # new_print(self.fifa_account, # 'player not messi or neymar. will change target, asset id : ', target_asset_id) # time.sleep(2) # continue # target_type = 'team_of_the_week' use_targe_and_filter = True if target in players_links.get('gold_rare', {}).get('targets'): target_filter = SBCTargetFilter(rarity_ids=rare, level='gold', buy_now_price=player_price) else: target_filter = SBCTargetFilter(rarity_ids=rare, level='', buy_now_price=player_price) else: new_print(self.fifa_account, 'target is not in targets , will go next.') time.sleep(2) continue if int(target_asset_id) in DischargeUsableCard.objects.filter( allowed_use_console_discharge=False ).values_list('asset_id', flat=True): new_print(self.fifa_account, 'this player is not allowed for discharge') time.sleep(2) continue if not DischargeUsableCard.objects.filter(asset_id=int(target_asset_id)): card_info_2 = get_player_data_by_asset_id(player_asset_id=target_asset_id) DischargeUsableCard.objects.create( asset_id=int(target_asset_id), player_name=card_info_2[0], allowed_use_console_discharge=True) if int(target_asset_id) in []: new_print(self.fifa_account, 'this player is bad for discharge') time.sleep(2) continue if player_price < 200 or futbin_min_price < 150: new_print(self.fifa_account, 'player price from futbin is : ', player_price, ' - ', futbin_min_price, ' and can not buy it') continue if calculate_player_tax(int(player_price), int(futbin_min_price)) > float(discharge_with_snipe_card_max_allowed_tax): new_print(self.fifa_account, f'this player {target_asset_id} has too many tax : ', calculate_player_tax(int(player_price), int(futbin_min_price)), ' allowed tax : ', discharge_with_snipe_card_max_allowed_tax) continue else: # todo : remove bellow and else new_print(self.fifa_account, 'player tax is : ', calculate_player_tax(int(player_price), int(futbin_min_price)), ' - player_price ', player_price, ' futbin_min_price ', futbin_min_price) if player_price > get_previous_price_grade(get_previous_price_grade(current_coins)): new_print(self.fifa_account, 'player_price = ', player_price, 'get_previous_price_grade(current_coins) = ', get_previous_price_grade(current_coins)) continue buy_now_price, player_card, player_name = self.get_data_for_putting_for_sale_in_console( player_price, rate, target_asset_id, rare) g_n_p_g = get_next_price_grade buy_now_price = g_n_p_g(g_n_p_g(g_n_p_g(g_n_p_g(g_n_p_g(futbin_min_price))))) # todo : market get crazy . after fix remove below if if target: if buy_now_price < discharge_with_snipe_lowest_buy_now_price: new_print(self.fifa_account, 'player buy now price is less than discharge_with_snipe_lowest_buy_now_price , ', 'so set discharge_with_snipe_lowest_buy_now_price as buy now price', buy_now_price, ' -- ', discharge_with_snipe_lowest_buy_now_price) buy_now_price = discharge_with_snipe_lowest_buy_now_price futbin_min_price = discharge_with_snipe_lowest_buy_now_price g_p_p_g = get_previous_price_grade for mmmm in range(5): futbin_min_price = g_p_p_g(futbin_min_price) if player_card: target_cards = SniperTradeItemLog.objects.filter( player_card=player_card ).exclude( # todo : fix bellow. this bellow added because fail item in catcher and receiver make two miss buy_now_price=F('price') ) last_10_target_cards_hour = target_cards.filter(id__in=target_cards.filter( action_time__gte=timezone.localtime() - timezone.timedelta(minutes=60*4), ).order_by('-id').values_list('id', flat=True)[:20]) missed_count_hour = last_10_target_cards_hour.filter(status=0).count() # success_count_hour = last_10_target_cards_hour.filter(status=1).count() # missed_count_hour = target_cards.filter( # action_time__gte=timezone.localtime() - timezone.timedelta(minutes=60), # status=0, # ).count() # success_count_hour = target_cards.filter( # action_time__gte=timezone.localtime() - timezone.timedelta(minutes=60), # status=1 # ).count() # if missed_count_hour >= 5 and (missed_count_hour / success_count_hour) > .2: if missed_count_hour >= 6: bad_targets_asset_id.append(target_asset_id) new_print(self.fifa_account, f'card {target_asset_id} has more than 3 missed in last 2 hour', ' automatic change card for snip' ) # new_print(self.fifa_account, # f'card {target_asset_id} has more than 5 missed in last hour or more than 20%', # ' automatic change card for snip' # ) continue # missed_count = target_cards.filter( # action_time__gte=timezone.localtime() - timezone.timedelta(hours=48), # status=0 # ).count() # success_count = target_cards.filter( # action_time__gte=timezone.localtime() - timezone.timedelta(hours=48), # status=1 # ).count() # if success_count and missed_count > 3 and (missed_count / success_count) > .3: # bad_targets_asset_id.append(target_asset_id) # new_print(self.fifa_account, # f'card {target_asset_id} has {missed_count / success_count} miss rate', # ' automatic change card for snip' # ) # continue if ready_mule_accounts.filter(fifa_account__credit__gt=buy_now_price).count() < 1: new_print(self.fifa_account, f'can not find enough mules with this credit {buy_now_price}') continue # buy_now_price = get_previous_price_grade(get_previous_price_grade(get_previous_price_grade(get_previous_price_grade(player_price)))) # buy_now_price = self.get_round_price(player_price * 1.5) set_sub_log(self.sbc_worker, 'bid and list the target') new_print(self.fifa_account, 'bid and list the target with price : ', player_price) search_and_bid_result = self.public_moves.console_search_player_and_bid( player=player_card, start_price=get_previous_price_grade(buy_now_price), buy_now_price=buy_now_price, max_change_grade=3, wait_for_list=True, # special='gold_rare', target_filter=target_filter, use_target_and_filter=use_targe_and_filter, ) # search_and_bid_result = self.public_moves.console_search_player_and_bid(player=player_card, start_price=player_price, # buy_now_price=buy_now_price, # max_change_grade=3, wait_for_list=True) if str(search_and_bid_result.get('result')) in ['sid', 'not_bought', 'player name not found', 'need_check_credit']: new_print(self.fifa_account, 'could not buy the player') continue elif search_and_bid_result.get('result') is True: new_print(self.fifa_account, 'after buy item. has start price.') for i in range(3): new_print(self.fifa_account, 'sell item press square 1') self.public_moves.ps4_buttons.square() time.sleep(2) self.public_moves.get_screen_shot() if not self.public_moves.has_image(os.path.join( BASE_DIR, f'utils/{self.fifa_account.platform}_controls/list_on_transfer_market_sign.png'), 'screen_shot_tmp.jpg'): self.public_moves.ps4_buttons.cross() time.sleep(2) else: break if not self.public_moves.list_on_transfer_market( get_previous_price_grade(buy_now_price), buy_now_price, second=True, wait_for_list=True): new_print(self.fifa_account, 'could not list item') return False transfer_data = CloseWebAppSnipes.objects.create( player_name=player_name, player_rating=rate, player_asset_id=target_asset_id, player_price=player_price, player_min_price_from_futbin=futbin_min_price, first_account=self.fifa_account, player_rarity_ids=rare, ) # todo : .select_related('first_account') t_bought = 1 transfer_data.first_side_ready = True transfer_data.save(update_fields=['first_side_ready']) self.fifa_account.refresh_from_db() self.fifa_account.can_kill_by_mother = False self.fifa_account.save(update_fields=['can_kill_by_mother']) new_print(self.fifa_account, 'first side is ready') current_coins -= player_price set_sub_log(self.sbc_worker, 'waiting for snipers') start_waiting = timezone.localtime() web_app_worker = self.get_discharge_web_side_worker_part_one(transfer_data) while True: time.sleep(5) transfer_data.refresh_from_db() self.fifa_account.refresh_from_db() if transfer_data.error: new_print(self.fifa_account, 'error happened , will break transfer') self.public_moves.ps4_buttons.circle() break if start_waiting < timezone.localtime() - timezone.timedelta(minutes=15): new_print(self.fifa_account, 'waiting more than 15 minute so close it : ', start_waiting) transfer_data.error = True transfer_data.error_desc = 'more than 15 min' transfer_data.save() self.public_moves.ps4_buttons.circle() break if self.fifa_account.run_discharge is False: new_print(self.fifa_account, 'run discharge stopped , break') transfer_data.error = True transfer_data.error_desc = 'more than 15 min' transfer_data.save() self.public_moves.ps4_buttons.circle() break stuck_discharge = CloseWebAppSnipes.objects.filter( id__lt=transfer_data.id, insert_time__gt=timezone.localtime() - timezone.timedelta(minutes=15), player_asset_id=target_asset_id, error=False, second_side_done=False, ).last() if stuck_discharge: new_print(self.fifa_account, 'already stuck discharge , ', stuck_discharge) time.sleep(20) continue # if transfer_data.second_side_ready: if web_app_worker is not False: transfer_data.first_side_done = True transfer_data.save(update_fields=['first_side_done']) second_side_ready_time = timezone.localtime() # new_print(self.fifa_account, 'second side is ready , ', timezone.localtime()) self.public_moves.ps4_buttons.cross(sleep_after=0.01) try: part_two_thread = ThreadWithReturnValue( target=self.get_discharge_web_side_worker_part_two, kwargs={ 'transfer': web_app_worker.get('transfer'), 'workers': web_app_worker.get('discharge_workers'), 'first_account': web_app_worker.get('first_account'), }, raise_on_exception=True) part_two_thread.start() except: new_print(self.fifa_account, 'exception in discharge part two : ', traceback.format_exc()) new_print(self.fifa_account, 'second side is ready , ', second_side_ready_time, ' sell item cross pressed , time : ', timezone.localtime(), ) # time.sleep(.1) # self.public_moves.ps4_buttons.cross() # try: # self.get_discharge_web_side_worker_part_two( # transfer=web_app_worker.get('transfer'), # workers=web_app_worker.get('discharge_workers'), # ) # except: # new_print(self.fifa_account, 'exception in discharge part two : ', # traceback.format_exc()) time.sleep(1) if self.public_moves.wait_for_image(os.path.join( BASE_DIR, f'utils/{self.fifa_account.platform}_controls/item_transfer_sucess.png')): self.public_moves.ps4_buttons.cross() time.sleep(3) current_coins += buy_now_price - ((buy_now_price * 5) / 100) new_print(self.fifa_account, 'calculated coins = ', current_coins) time.sleep(15) # transfer_data.refresh_from_db() # if (transfer_data.error == True and # transfer_data.error_desc == 'missed' and # not transfer_data.second_side_found_target): # set_sbc_status(self.sbc_worker, 'missed without snatched') # time.sleep(3600 * 2) self.public_moves.ps4_buttons.circle() time.sleep(2) self.public_moves.go_to_state('search_players', 'transfer_list') if self.public_moves.just_find_state() == 'transfer_list': # self.public_moves.ps4_buttons.l2() self.public_moves.ps4_buttons.r2() time.sleep(1) # if self.first_list: # time.sleep(5) # self.public_moves.ps4_buttons.cross() # self.first_list = False # time.sleep(10) transfer_data.refresh_from_db() SniperTradeItemLog.objects.create( fifa_account=transfer_data.first_account, player_card=player_card, action_time=timezone.localtime(), buy_now_price=futbin_min_price, price=player_price, status=int(not transfer_data.error), ) set_sbc_status(self.sbc_worker, None, update_time=True) # self.sbc_worker.refresh_from_db() # self.sbc_worker.status_change_time = timezone.localtime() # self.sbc_worker.save() break time.sleep(10) self.fifa_account.refresh_from_db() self.fifa_account.can_kill_by_mother = True if current_coins < 0: current_coins = 1000 self.fifa_account.credit = current_coins self.fifa_account.save(update_fields=['credit', 'can_kill_by_mother']) new_print(self.fifa_account, 'transfer completed , current coins : ', current_coins) set_sub_log(self.sbc_worker, 'transfer completed state') break if bad_targets_asset_id and not t_bought: new_print( self.fifa_account, f'want buy item but all found item is bad items : {bad_targets_asset_id} ,' ) # try: # console_coin = self.public_moves.read_coin() # new_print(self.fifa_account, 'console coin = ', console_coin) # if int(console_coin) < coins_to: # current_coins = console_coin # except: # pass if loop_keeper[0] == current_coins and loop_keeper[1] > 2: new_print(self.fifa_account, 'it is looklike its stuck in loop, so break it') break loop_keeper = [current_coins, loop_keeper[1] + 1] self.public_moves.console_close_ultimate(need_get_new_sid=False) set_sbc_status(self.sbc_worker, 'discharge complete') def get_discharge_web_side_worker_part_one(self, transfer): def get_worker(): new_print(transfer.first_account, 'get workers , need a worker 2') gn = get_next_price_grade buy_now_price = gn(gn(gn(gn(gn(gn(transfer.player_min_price_from_futbin)))))) accounts = MuleAccounts.objects.filter( fifa_account__credit__gt=buy_now_price, in_use=False, error=False, fifa_account__need_captcha=False, investors__in=[transfer.first_account.console.investor], deleted=False, ).annotate( search_count_24_hour=Coalesce(Subquery( FifaAccountSearch.objects.filter( fifa_account__id=OuterRef('fifa_account__id'), search_time__gt=timezone.localtime() - timezone.timedelta(hours=24) ).values('fifa_account').annotate( search_counter=Count('id', output_field=IntegerField()) ).values('search_counter'), output_field=IntegerField() ), Value(0)) ).filter( search_count_24_hour__lt=ConsoleBotSetting.objects.get(name='account_high_search_count').int_value - 4 ).order_by('last_used') for account in accounts: new_print(transfer.first_account, 'want to create worker with : ', account.fifa_account) sbc_worker = SBCWorker.objects.filter( fifa_account=account.fifa_account, running_platform='inject').first() if not sbc_worker: sbc_worker, created = SBCWorker.objects.get_or_create( fifa_account=account.fifa_account, running_platform='inject') sbc_worker.first_xi = True sbc_worker.puzzle_master = True sbc_worker.manual_loyal = True sbc_worker.save() if sbc_worker.has_error: account.error = True account.error_description = sbc_worker.error_description account.save() else: new_print(transfer.first_account, 'account = ', account.fifa_account.user_name, 'will participate in ', transfer.player_price) account.last_used = timezone.localtime() account.in_use = True account.save() new_print(transfer.first_account, 'worker id = ', sbc_worker.id) return sbc_worker new_print(transfer.first_account, 'get disccharge web app side part one') for iie in [0, 1, 2]: discharge_worker = None worker = get_worker() if not worker: new_print(transfer.first_account, 'no worker found 2') time.sleep(120) continue worker.last_run_time = timezone.localtime() worker.must_done = False worker.save(update_fields=['last_run_time', 'must_done']) fifa_account = worker.fifa_account fifa_account.refresh_from_db() fifa_account.last_run_time = timezone.localtime() fifa_account.need_captcha = 0 fifa_account.active = 1 fifa_account.save(update_fields=['last_run_time', 'need_captcha', 'active']) sbc_solver_item = DischargeRunner(worker.id, fifa_account.id, fifa_account.user_name, fifa_account.password, fifa_account.platform, worker.manual_loyal, use_public_moves=False) try: login_result = logout_login(sbc_solver_item, worker, fifa_account, ) if login_result.get('status_bool') is False: MuleAccounts.objects.filter(fifa_account=worker.fifa_account, error=True, error_description=login_result).update(in_use=False) continue new_print(transfer.first_account, 'run discharge after login : ', login_result) except Exception as e: new_print(transfer.first_account, 'error 33_1 : ', traceback.format_exc()) MuleAccounts.objects.filter(fifa_account=worker.fifa_account).update(in_use=False) continue # handle_end_bot() fifa_account.refresh_from_db() # print('fifa_account.active', fifa_account.active) new_print(transfer.first_account, 'fifa account active') if not fifa_account.active: MuleAccounts.objects.filter(fifa_account=worker.fifa_account).update(in_use=False) continue if not sbc_solver_item.web_app_discharge_with_snipe_first: new_print(transfer.first_account, 'account first things failed') MuleAccounts.objects.filter(fifa_account=worker.fifa_account).update(in_use=False) continue transfer.refresh_from_db() new_print(transfer.first_account, 'worker append') discharge_worker = sbc_solver_item break if not discharge_worker: return False transfer.refresh_from_db() if transfer.error is True: MuleAccounts.objects.filter(fifa_account=discharge_worker.fifa_account).update(in_use=False) return 'transfer error' all_accounts = str(discharge_worker.fifa_account.id) + ' ' transfer.refresh_from_db() transfer.all_accounts_ids = all_accounts transfer.second_side_ready = True transfer.second_side_ready_time = timezone.localtime() transfer.save(update_fields=['all_accounts_ids', 'second_side_ready', 'second_side_ready_time']) return {'status_bool': True, 'transfer': transfer, 'discharge_workers': [discharge_worker], 'first_account': transfer.first_account} def get_discharge_web_side_worker_part_two(self, transfer, workers, first_account): dis_1 = timezone.localtime() done = False count = 0 micr_reduction_count = 1 thread_list = [] # transfer.refresh_from_db() dis_2 = None while True: account_number = 0 for sbc_solver_item in workers: # transfer.refresh_from_db() if transfer.second_side_done or transfer.error: done = True break # todo : change thread to celery task dis_2 = timezone.localtime() sbc_solver_item.web_app_discharge_with_snipe( transfer=transfer, count=count, account_number=account_number, micr_reduction_count=micr_reduction_count, first_account=first_account) # th = threading.Thread(target=sbc_solver_item.web_app_discharge_with_snipe, kwargs={ # 'transfer': transfer, 'count': count, 'account_number': account_number, # 'micr_reduction_count': micr_reduction_count, # }) # th.daemon = True # th.start() # thread_list.append(th) # time.sleep(0.07) time.sleep(0.3) account_number += 1 micr_reduction_count += 1 if done: break count += 1 # if count >= 5: # todo : reduce bellow count if count >= 1: break time.sleep(15) new_print(transfer.first_account, 'set accounts in_use to false , dis 1 : ', dis_1, ' dis 2 : ', dis_2) for sbc_solver_item in workers: MuleAccounts.objects.filter(fifa_account=sbc_solver_item.fifa_account).update(in_use=False) try: sbc_solver_item.main_dic['driver'].close() except: pass sbc_solver_item.fifa_account.refresh_from_db() sbc_solver_item.fifa_account.active = False sbc_solver_item.fifa_account.save() del workers new_print(transfer.first_account, 'transfer job is done .... ') transfer.refresh_from_db() if not transfer.second_side_done: transfer.error = True transfer.error_desc = 'missed' transfer.save(update_fields=['error', 'error_desc']) new_print(transfer.first_account, 'transfer missed') time.sleep(10) for thread in thread_list: thread.join() del thread def get_futbin_player_card_with_price( self, player_price, limit_players=5, exclude_futbin_ids=None, proxy_ip=None, proxy_port=None, proxy_user=None, proxy_pass=None): players = [] exclude_ids = [] if exclude_futbin_ids: exclude_ids = exclude_futbin_ids.split(',') players_tree_rows = [] for iiin in range(1, 3): # todo : in new fifa uncomment bellow and remove next line # search_link = f'https://www.futbin.com/players?page={iiin}&ps_prp=10,70&version=gold_all&order=desc&ps_price=0-{player_price}&sort=ps_price&pos_type=all' if player_price > 5000: ps_prp = '10,70' else: ps_prp = '5,70' # search_link = f'https://www.futbin.com/players?page={iiin}&ps_prp={ps_prp}&order=desc&ps_price=0-{player_price}&sort=ps_price&pos_type=all' search_link = f'https://www.futbin.com/players?page={iiin}&ps_prp={ps_prp}&order=desc&ps_price=0-{player_price}&sort=ps_price&pos_type=all&?version=if_gold' if player_price < 10000: search_link += '&version=gold' search_result = self.use_cloud_scraper(link=search_link) soup = BeautifulSoup(search_result.content, 'html.parser') new_print(self.fifa_account, 'get card search link : ', search_link, ' proxies : ', proxy_ip, proxy_port) players_table = soup.find(class_='players-table') if players_table: for row_item in players_table.find_all(class_='player-row'): players_tree_rows.append(row_item) time.sleep(2) if not players_tree_rows: new_print(self.fifa_account, 'no players row , check page response') for row_index, row in enumerate(players_tree_rows): futbin_player_id = re.search(r'player/(\d+)/', row.find('a').get('href')).group(1) player_changed_price = row.find(class_='price-diff') if futbin_player_id in exclude_ids: new_print(self.fifa_account, 'this item in exclude : ', futbin_player_id, ' -- ', exclude_ids, ' current selected players : ', players) continue if not player_changed_price: new_print(self.fifa_account, 'this player has not changed price , so this maybe expired , continue .' ' player id : ', futbin_player_id, ' current selected players : ', players) continue # player_data = self.get_price_from_futbin_and_futwiz(futbin_player_id, wait_on_error=10) # player_data.update({'futbin_player_id': futbin_player_id}) # time.sleep(1) # player_update_time_stamp = player_data.get('update_time_stamp') # # todo : reduce bellow time to 600 in start of fifa # if player_update_time_stamp and player_update_time_stamp > (time.time() - 600): # pass # else: # new_print(self.fifa_account, 'update time is more than 10 minute ago , try another', # ' player id : ', futbin_player_id, ' update time : ', player_data.get('update_time'), # ' update time_stamp : ', player_update_time_stamp, ' current selected players : ', players) # continue # player_data_price_list = player_data.get('futbin_price_list') # # player_data['vendor_buy_price'] = int(player_data.get('price_list', [0])[0].replace(',', '')) # # todo : remove next line and uncomment next # if not player_data_price_list: # new_print(self.fifa_account, 'price list not exists , try another , player id : ', # futbin_player_id, ' current selected players : ', players) # continue # player_data['vendor_buy_price'] = int(player_data_price_list[0].replace(',', '')) # player_data['vendor_force_sell_price'] = get_next_price_grade(get_previous_price_grade(int(player_data.get('first_price')))) # # player_data['vendor_buy_price'] = player_data.get('price') # # player_data['vendor_buy_price'] = player_data.get('first_price') # if player_data.get('vendor_buy_price') > player_price: # new_print(self.fifa_account, 'price is more than current coin , continue . player id : ', # futbin_player_id, ' current selected players : ', players) # continue # # # player_data_first_price = player_data.get('vendor_buy_price') # player_first_price = player_data.get('first_price') # gnpg = get_next_price_grade # if player_data_first_price and player_data_price_list: # player_last_price = int(player_data_price_list[-1].replace(',', '')) # # new_print(self.fifa_account, 'player prices : ', player_last_price, # # ' -- ', int(player_data_first_price*1.02)) # # if player_last_price > int(player_data_first_price*1.02) and row_index < 15: # # new_print(self.fifa_account, 'player first and last prices have a big difference.' # # ' last price : ', player_last_price, # # ' -- ', int(player_data_first_price*1.02)) # # continue # if player_last_price == 0: # new_print(self.fifa_account, 'player last price is 0 , price list : ', player_data_price_list) # continue # # # # using bellow if futbin update time has bugged # # if player_first_price < 300000 and gnpg(gnpg(player_first_price)) < player_data_first_price: # # new_print(self.fifa_account, 'player first and second price has many difrrent ', player_data) # # continue # # elif player_first_price >= 300000 and (player_first_price * 1.02) < player_data_first_price: # # new_print(self.fifa_account, 'player first and second price has many difrrent 2 , ', player_data) # # continue # # # # # # next_grades_price = player_data_first_price # # # todo : change bellow range to 2 in start of fifa # # for iiiii in range(10): # # next_grades_price = get_next_price_grade(next_grades_price) # # todo : remove next line in new fifa # # if next_grades_price < int(player_data_price_list[-1].replace(',', '')): # # if False: # # new_print(self.fifa_account, 'first price two many different with last price , try another card. ', # # ' player id : ', futbin_player_id, ' first price : ', player_data_first_price, # # ' last price : ', int(player_data_price_list[-1].replace(',', '')), # # ' next grades price : ', next_grades_price) # # continue # # # todo : remove next line in new fifa # # elif False: # # # elif int(player_data_price_list[-1].replace(',', '')) == 0: # # new_print(self.fifa_account,'first price two many different with last price , try another card 2. ', # # ' player id : ', futbin_player_id, ' first price : ', player_data_first_price, # # ' last price : ', int(player_data_price_list[-1].replace(',', '')), # # ' next grades price : ', next_grades_price) # # continue # elif not player_data_price_list: # new_print(self.fifa_account, 'player data list is empty , try another. futbin id : ', # futbin_player_id, ' current selected players : ', players) # continue # card_buy_price = player_data_first_price # for ii in range(4): # card_buy_price = get_previous_price_grade(card_buy_price) # if card_buy_price <= (player_data.get('futbin_min_price') or 0): # new_print(self.fifa_account, 'card price equal to min price , try another card. ', # ' current selected players : ', players) # continue # result_2 = calculate_player_price_with_tax(player_data.get('vendor_buy_price')) # player_data.update(result_2) # if player_data.get('futbin_max_price') <= player_data.get('list_buy_now_price'): # new_print(self.fifa_account, 'card price equal to max price, try another card. max price : ', # player_data.get('futbin_max_price'), # 'list buy now price : ', player_data.get('list_buy_now_price'), # ' current selected players : ', players) # continue # if result_2.get('list_buy_now_price') <= 1000: # new_print(self.fifa_account, 'list price can not lower than 1000, try another card. player id : ', # futbin_player_id, ' current selected players : ', players) # continue # if player_data.get('price'): # players.append(player_data) check_card_result = self.check_card_for_discharge3( futbin_player_id=futbin_player_id, player_price=player_price) if check_card_result and not check_card_result.get('error'): players.append(check_card_result) if len(players) >= limit_players: break return players def check_card_for_discharge3(self, futbin_player_id, player_price): player_data = self.get_price_from_futbin_and_futwiz(futbin_player_id, wait_on_error=10) player_data.update({'futbin_player_id': futbin_player_id}) time.sleep(1) player_update_time_stamp = player_data.get('update_time_stamp') # todo : reduce bellow time to 600 in start of fifa if player_update_time_stamp and player_update_time_stamp > (time.time() - 600): pass else: new_print(self.fifa_account, 'update time is more than 10 minute ago , try another', ' player id : ', futbin_player_id, ' update time : ', player_data.get('update_time'), ' update time_stamp : ', player_update_time_stamp) return {'error': 'high update time'} player_data_price_list = player_data.get('futbin_price_list') # player_data['vendor_buy_price'] = int(player_data.get('price_list', [0])[0].replace(',', '')) # todo : remove next line and uncomment next if not player_data_price_list: new_print(self.fifa_account, 'price list not exists , try another , player id : ', futbin_player_id, ) return {'error': 'price list empty'} player_data['vendor_buy_price'] = int(player_data_price_list[0].replace(',', '')) player_data['vendor_force_sell_price'] = get_next_price_grade( get_previous_price_grade(int(player_data.get('first_price')))) # player_data['vendor_buy_price'] = player_data.get('price') # player_data['vendor_buy_price'] = player_data.get('first_price') if player_data.get('vendor_buy_price') > player_price: new_print(self.fifa_account, 'price is more than current coin , continue . player id : ', futbin_player_id) return {} # player_data_first_price = player_data.get('vendor_buy_price') player_first_price = player_data.get('first_price') gnpg = get_next_price_grade if player_data_first_price and player_data_price_list: player_last_price = int(player_data_price_list[-1].replace(',', '')) # new_print(self.fifa_account, 'player prices : ', player_last_price, # ' -- ', int(player_data_first_price*1.02)) # if player_last_price > int(player_data_first_price*1.02) and row_index < 15: # new_print(self.fifa_account, 'player first and last prices have a big difference.' # ' last price : ', player_last_price, # ' -- ', int(player_data_first_price*1.02)) # continue if player_last_price == 0: new_print(self.fifa_account, 'player last price is 0 , price list : ', player_data_price_list) return {'error': 'last price zero'} # # using bellow if futbin update time has bugged # if player_first_price < 300000 and gnpg(gnpg(player_first_price)) < player_data_first_price: # new_print(self.fifa_account, 'player first and second price has many difrrent ', player_data) # continue # elif player_first_price >= 300000 and (player_first_price * 1.02) < player_data_first_price: # new_print(self.fifa_account, 'player first and second price has many difrrent 2 , ', player_data) # continue # # # next_grades_price = player_data_first_price # # todo : change bellow range to 2 in start of fifa # for iiiii in range(10): # next_grades_price = get_next_price_grade(next_grades_price) # todo : remove next line in new fifa # if next_grades_price < int(player_data_price_list[-1].replace(',', '')): # if False: # new_print(self.fifa_account, 'first price two many different with last price , try another card. ', # ' player id : ', futbin_player_id, ' first price : ', player_data_first_price, # ' last price : ', int(player_data_price_list[-1].replace(',', '')), # ' next grades price : ', next_grades_price) # continue # # todo : remove next line in new fifa # elif False: # # elif int(player_data_price_list[-1].replace(',', '')) == 0: # new_print(self.fifa_account,'first price two many different with last price , try another card 2. ', # ' player id : ', futbin_player_id, ' first price : ', player_data_first_price, # ' last price : ', int(player_data_price_list[-1].replace(',', '')), # ' next grades price : ', next_grades_price) # continue elif not player_data_price_list: new_print(self.fifa_account, 'player data list is empty , try another. futbin id : ', futbin_player_id) return {'error': 'price data empty'} card_buy_price = player_data_first_price for ii in range(4): card_buy_price = get_previous_price_grade(card_buy_price) if card_buy_price <= (player_data.get('futbin_min_price') or 0): new_print(self.fifa_account, 'card price equal to min price , try another card. ') return {'error': 'price equal min'} result_2 = calculate_player_price_with_tax(player_data.get('vendor_buy_price')) player_data.update(result_2) if player_data.get('futbin_max_price') <= player_data.get('list_buy_now_price'): new_print(self.fifa_account, 'card price equal to max price, try another card. max price : ', player_data.get('futbin_max_price'), 'list buy now price : ', player_data.get('list_buy_now_price')) return {'error': 'price equal max'} if result_2.get('list_buy_now_price') <= 1000: new_print(self.fifa_account, 'list price can not lower than 1000, try another card. player id : ', futbin_player_id) return {} if not player_data.get('price'): new_print(self.fifa_account, 'player item has not price , so try another. player id : ', futbin_player_id, ' player data : ', result_2) return {} return player_data def calculate_player_price_for_injection(inject_coin, account_coin, max_player_price=0): account_coin = int(account_coin) inject_coin = int(inject_coin) inject_coin_with_tax = int(inject_coin) + int(inject_coin * .19) player_price = (inject_coin_with_tax * 100) / 45 if player_price > account_coin: player_price = account_coin - 1000 if max_player_price and player_price > max_player_price: player_price = max_player_price return {'player_price': int(player_price)} def calculate_player_price_for_injection2(inject_coin, account_coin, max_player_price=0): account_coin = int(account_coin) inject_coin = int(inject_coin) max_price_with_tax = account_coin - 1000 # if max_player_price: # max_price_with_tax = min(max_price_with_tax, max_player_price) player_price_without_tax = (inject_coin * 100) / 45 if player_price_without_tax * 1.19 > max_price_with_tax: player_price_without_tax = max_price_with_tax / 1.19 if max_player_price: player_price_without_tax = min(player_price_without_tax, max_player_price) while calculate_player_price_with_tax(player_price_without_tax).get('list_buy_now_price') > max_price_with_tax: player_price_without_tax = get_round_price(get_previous_price_grade(player_price_without_tax)) player_price_without_tax = max(player_price_without_tax, 0) player_price = int(player_price_without_tax) return {'player_price': int(player_price)} def calculate_player_price_with_tax(player_price): futbin_player_price = int(player_price) list_price = get_round_price(futbin_player_price + int(futbin_player_price * .45)) tax = int(list_price * .05) transferred_coin = list_price - futbin_player_price - tax list_price_lower = futbin_player_price for ii in range(random.randint(3, 10)): list_price_lower = get_next_price_grade(list_price_lower) return {'player_price': futbin_player_price, 'list_buy_now_price': list_price, 'list_start_price': list_price_lower, 'tax': tax, 'transferred_coin': transferred_coin}