def handle(self, **options):
# update players info
print(f"[CRON {logdate()}] START players")
ts_threshold = tsnow() - 3600
players = Player.objects.filter(
validKey=True,
lastUpdateTS__lt=ts_threshold).order_by("lastUpdateTS")
n = len(players)
for i, player in enumerate(players):
try:
updatePlayer(player, i=i + 1, n=n)
except BaseException as e:
print(f"[CRON {logdate()}]: {e}")
print(traceback.format_exc())
del players
# compute rank
# print(f"[CRON {logdate()}] COMPUTE RANKS")
# for i, player in enumerate(Player.objects.exclude(tId=-1).only("awardsScor", "awardsRank").order_by('-awardsScor')):
# print(f"[CRON {logdate()}] #{}: {} {:.4f}".format(i + 1, player.nameAligned(), player.awardsScor / 10000.))
# player.awardsRank = i + 1
# player.save()
# compute hof graph
print(f"[CRON {logdate()}] COMPUTE HOF GRAPH")
hofGraph = []
for i, player in enumerate(
Player.objects.exclude(awardsScor=0).only("awardsScor")):
print(
f"[CRON {logdate()}] #{i + 1}: {player.nameAligned()} {player.awardsScor / 10000.:.4f}"
)
hofGraph.append(float(player.awardsScor / 10000.0))
bins = numpy.logspace(-2, 2, num=101)
bins[0] = 0
histo, _ = numpy.histogram(hofGraph, bins=bins)
cBins = [0.5 * float(a + b) for a, b in zip(bins[:-1], bins[1:])]
hofGraph = [[float(x), int(y),
float(xm), float(xp), 0]
for x, y, xm, xp in zip(cBins, histo, bins[:-1], bins[1:])]
hofGraph[0][4] = hofGraph[0][1]
for i in range(len(hofGraph) - 1):
hofGraph[i + 1][4] = hofGraph[i + 1][1] + hofGraph[i][4]
hof = AwardsData.objects.first()
hof.hofHistogram = json.dumps(hofGraph)
hof.save()
print(f"[CRON {logdate()}] CLEAN AWARDS CACHE")
TmpReq.objects.filter(timestamp__lt=(tsnow() - 3600)).delete()
print(f"[CRON {logdate()}] END")
def update_specs(self):
client = requests.session()
client.headers.update({
"Authorization": f"Bearer {self.token}",
'Content-Type': 'application/json'
})
response = client.get(f'{self.endpoint}/v2/droplets')
payload = json.loads(response.content.decode('utf-8'))["droplets"]
timestamp = int(tsnow() / 86400) * 86400
total_price = 0
for droplet in payload:
droplet_id = droplet["id"]
defaults = {
"name": droplet["name"],
"vpc_uuid": droplet["vpc_uuid"],
"vcpus": droplet["vcpus"],
"memory": droplet["memory"],
"disk": droplet["disk"],
"transfer": droplet["size"]["transfer"],
"size": json.dumps(droplet["size"]),
"image": json.dumps(droplet["image"])
}
self.dropletspec_set.update_or_create(dropletid=droplet_id,
timestamp=timestamp,
defaults=defaults)
total_price += droplet["size"]["price_monthly"]
return total_price
def getCrimes(request):
try:
# check if API key is valid with api call
key = request.GET.get("key", False)
if not key:
return JsonResponse({"error": {"code": 2, "error": "No keys provided"}}, status=400)
call = apiCall('user', '', '', key=key)
if "apiError" in call:
return JsonResponse({"error": {"code": 4, "error": call["apiErrorString"]}}, status=400)
# check if can get faction
factionId = call.get("faction", {}).get("faction_id")
faction = Faction.objects.filter(tId=factionId).first()
if faction is None:
return JsonResponse({"error": {"code": 2, "error": f"Can't find faction {factionId} in YATA database"}}, status=400)
# update crimes
faction.updateCrimes()
# get members
members = {}
for member in faction.member_set.all():
if member.nnb:
members[str(member.tId)] = {"NNB": member.nnb, "equivalent_arsons": member.arson, "ce_rank": member.crimesRank}
else:
members[str(member.tId)] = {"NNB": None, "equivalent_arsons": None, "ce_rank": member.crimesRank}
return JsonResponse({"members": members, "timestamp": tsnow()}, status=200)
except BaseException as e:
return JsonResponse({"error": {"code": 1, "error": str(e)}}, status=500)
def handle(self, **options):
ymA = datetime.datetime.today().strftime('%Y %m')
ymB = (datetime.datetime.now() -
datetime.timedelta(days=4)).strftime('%Y %m')
print(ymA, ymB)
# list all json reports
for report_file in glob.glob(settings.MEDIA_ROOT +
'/analytics/*.json'):
# get name and type
report_section, report_period = [
r.replace('-', ' ') for r in report_file.replace(
'.json', '').split('/')[-1].split('_')
]
if re.search(ymA + r'\s\d{2}',
report_period) is None and re.search(
ymB + r'\s\d{2}', report_period) is None:
continue
# open report
report = json.load(open(report_file, 'r'))
# get date (from when the report is created)
# date_string = report["general"]["date_time"]
# date = datetime.datetime.strptime(date_string, "%Y-%m-%d %H:%M:%S %z")
# report_timestamp = int(datetime.datetime.timestamp(date))
# get date (from the period)
date = datetime.datetime.strptime(report_period, "%Y %m %d")
report_timestamp = int(datetime.datetime.timestamp(date))
# get data for db
defaults = {
"report_timestamp": report_timestamp,
"last_update": tsnow()
}
# general information
for k in [
'total_requests', 'valid_requests', 'failed_requests',
'unique_visitors', 'bandwidth'
]:
defaults[k] = report["general"][k]
# visitors
defaults["visitors_metadata"] = report["visitors"]["metadata"]
defaults["visitors_data"] = report["visitors"]["data"]
# requests
defaults["requests_metadata"] = report["requests"]["metadata"]
defaults["requests_data"] = report["requests"]["data"]
_, create = Analytics.objects.update_or_create(
report_section=report_section,
report_period=report_period,
defaults=defaults)
print(report_section, "/", report_period, "->", create)
def loot(request):
try:
# payload = cache.get(f"api_loot", False)
# if payload:
# print("[api.loot] get loot (cache)")
# return JsonResponse(payload, status=200)
# if getattr(request, 'limited', False):
# return JsonResponse({"error": {"code": 3, "error": "Too many requests (10 calls / hour)"}}, status=429)
# get time
ts = tsnow()
# get npcs
npcs = {
npc.tId: npc.hospitalTS
for npc in NPC.objects.filter(show=True).order_by('hospitalTS')
}
# by default next update is in an hour
next_update = ts + DEFAULT_UPDATE
for id, hosp_out in npcs.items():
# check if not to be ignored (IGNORE_TIME seconds after loot level)
if ts + IGNORE_TIME < hosp_out + UPDATE_LEVEL:
next_update = hosp_out + UPDATE_LEVEL + UPDATE_TIME
break
debug = {
"hosp_out":
{k: timestampToDate(v, fmt=True)
for k, v in npcs.items()},
"next_update":
timestampToDate(next_update, fmt=True),
"timestamp":
timestampToDate(ts, fmt=True),
"message":
"This field is temporary to help debug cloudflare cache system. Don't use it in your code."
}
payload = {
"hosp_out": npcs,
"next_update": next_update,
"timestamp": ts,
"debug": debug
}
print("[api.loot] get loot (computed)")
# cache.set("api_loot", payload, 600)
return JsonResponse(payload, status=200)
except BaseException as e:
return JsonResponse({"error": {
"code": 1,
"error": str(e)
}},
status=500)
def get_efficiency(self, h=48):
# compute efficiency
old = tsnow() - h * 3600
size_ts = h * 3600 // (5 * 60)
tss = [0] * size_ts
stocks = AbroadStocks.objects.filter(item=self.item, country_key=self.country_key, timestamp__gt=old)
for stock in stocks:
i = min(size_ts * (stock.timestamp - old) // (h * 3600), size_ts - 1)
tss[i] = 1
return [len(stocks), 100 * sum(tss) / float(size_ts)]
def nextLoot(request):
try:
# get smaller due time
to_late = tsnow() - (15 + 210) * 60
next = NPC.objects.filter(show=True).filter(
hospitalTS__gt=to_late).order_by('hospitalTS').first()
if next is None:
return {"nextLoot": ["All level V", 0, 0]}
ts = max(next.lootTimings(lvl=4)["ts"], 0)
return {"nextLoot": [next.name, next.tId, ts]}
except BaseException:
return {"nextLoot": ["Error", 0, 0]}
def nextLoot(request):
try:
nl = cache.get("context_processor_loot")
if nl is None:
print("[context_processor] loot (compute)")
to_late = tsnow() - (15 + 210) * 60
next = NPC.objects.filter(show=True).filter(hospitalTS__gt=to_late).order_by('hospitalTS').first()
nl = ["All level V", 0, 0] if next is None else [next.name, next.tId, max(next.lootTimings(lvl=4)["ts"], 0)]
cache.set("context_processor_loot", nl, 3600)
else:
print("[context_processor] loot (cache)")
return {"nextLoot": nl}
except BaseException:
return {"nextLoot": ["Error", 0, 0]}
def scheduleTimings(self):
# get all ts
now = tsnow()
all_timestamps = [now - now % 3600 + (i + 1) * 3600 for i in range(24)]
# get scheduled attacks
scheduled_attacks = self.scheduledattack_set.all()
schedule = {}
for ts in all_timestamps:
scheduled = scheduled_attacks.filter(timestamp=ts).first()
if scheduled is None:
schedule[ts] = [0, ts - now]
else:
schedule[ts] = [scheduled.vote, ts - now]
return schedule
def exportStocks(request):
try:
# if getattr(request, 'limited', False):
# return JsonResponse({"error": {"code": 3, "error": "Too many requests (10 calls / hour)"}}, status=429)
stocks = AbroadStocks.objects.filter(last=True)
countries = {
"mex": {},
"cay": {},
"can": {},
"haw": {},
"uni": {},
"arg": {},
"swi": {},
"jap": {},
"chi": {},
"uae": {},
"sou": {},
}
for k in countries:
c_stocks = stocks.filter(country_key=k)
if len(c_stocks):
countries[k] = {
"update": c_stocks.first().timestamp,
"stocks": [s.payloadLight() for s in c_stocks]
}
else:
countries[k] = {"update": 0, "stocks": []}
payload = {"stocks": countries, "timestamp": tsnow()}
return JsonResponse(payload, status=200)
except BaseException as e:
return JsonResponse({"error": {
"code": 1,
"error": str(e)
}},
status=500)
def handle(self, **options):
print(f"[CRON {logdate()}] START donations")
paypal = PayPal.objects.last().get_balance()
droplet = Droplet.objects.first()
droplet_month_cost = droplet.update_specs()
droplet = droplet.get_balance()
# timestamp = int(tsnow() / 3600) * 3600
timestamp = int(tsnow() / 86400) * 86400
d = {
"paypal_balance": paypal["balance"],
"paypal_currency": paypal["currency"],
"droplet_account_balance": droplet["account_balance"],
"droplet_month_to_date_usage": droplet["month_to_date_usage"],
"droplet_month_to_date_balance": droplet["month_to_date_balance"],
"droplet_month_cost": str(droplet_month_cost)
}
Balance.objects.update_or_create(timestamp=timestamp, defaults=d)
print(f"[CRON {logdate()}] END")
def loot(request):
try:
if getattr(request, 'limited', False):
return JsonResponse(
{
"error": {
"code": 3,
"error": "Too many requests (10 calls / hour)"
}
},
status=429)
# get time
ts = tsnow()
# get npcs
npcs = {
npc.tId: npc.hospitalTS
for npc in NPC.objects.filter(show=True).order_by('hospitalTS')
}
# by default next update is in an hour
next_update = ts + DEFAULT_UPDATE
for id, hosp_out in npcs.items():
# check if not to be ignored (IGNORE_TIME seconds after loot level)
if ts + IGNORE_TIME < hosp_out + UPDATE_LEVEL:
next_update = hosp_out + UPDATE_LEVEL + UPDATE_TIME
break
payload = {"hosp_out": npcs, "next_update": next_update}
return JsonResponse(payload, status=200)
except BaseException as e:
return JsonResponse({"error": {
"code": 1,
"error": str(e)
}},
status=500)
def abroadStocks(request):
try:
if request.method == "POST":
item_id = request.POST.get('item_id', False)
country_key = request.POST.get('country_key', False)
old = tsnow() - 48 * 3600
stocks = AbroadStocks.objects.filter(
country_key=country_key, item__tId=item_id,
timestamp__gt=old).order_by("-timestamp")
if stocks is None:
context = {'item': None, "graph": []}
return render(request, 'bazaar/abroad/graph.html', context)
# get clients statistics
clients = dict({})
for stock in stocks:
if stock.client == "":
continue
if stock.client not in clients:
clients[stock.client] = 0
clients[stock.client] += 1
clients = {
c: [i, n]
for i, (c, n) in enumerate(
sorted(clients.items(), key=lambda x: -x[1]))
}
# graph = [[timestampToDate(s.timestamp), s.quantity, s.cost, s.client, clients.get(s.client)[0], clients.get(s.client)[1]] for s in stocks]
# average the prices
floatTS = stocks.first().timestamp
avg_val = [0, 0, 0] # ts, quantity, cost
n = 0
graph = []
for s in stocks:
n += 1
avg_val[0] += s.timestamp
avg_val[1] += s.quantity
if (floatTS - s.timestamp) > 5 * 60:
floatTS = s.timestamp
line = [
timestampToDate(avg_val[0] // n), avg_val[1] // n,
avg_val[2] // n
]
graph.append(line)
avg_val = [0, 0, 0]
n = 0
# record last point
if n > 0:
line = [
timestampToDate(avg_val[0] // n), avg_val[1] // n,
avg_val[2] // n
]
graph.append(line)
stock = stocks.first()
context = {
'stock':
stocks.first(),
'graph':
graph,
'x': [
timestampToDate(tsnow() - 48 * 3600),
timestampToDate(tsnow() - 24 * 3600),
timestampToDate(tsnow())
]
}
return render(request, 'bazaar/abroad/graph.html', context)
else:
message = "You might want to log in." if request.method == "POST" else "You need to post. Don\'t try to be a smart ass."
return returnError(type=403, msg=message)
except Exception as e:
return returnError(exc=e, session=request.session)
def abroad(request):
try:
# build up filters list
from bazaar.countries import countries as country_list
from bazaar.countries import types as type_list
country_list["all"] = {"name": "All", "n": 0}
type_list["all"] = {"name": "All", "n": 0}
# get player and page
if request.session.get('player'):
tId = request.session["player"].get("tId")
else:
tId = -1
player = Player.objects.filter(tId=tId).first()
page = 'bazaar/content-reload.html' if request.method == 'POST' else "bazaar.html"
# get filters
filters = request.session.get('stocks-filters', {
"countries": "all",
"types": ["all"]
})
if not isinstance(filters["types"], list):
filters["types"] = ["all"]
# set filters
if request.POST.get("filter", False) and request.POST.get("key"):
page = "bazaar/abroad/list.html"
post_filter = request.POST.get("filter")
post_key = request.POST.get("key")
if post_filter in "types" and post_key in type_list:
if post_key != "all":
if "all" in filters[post_filter]:
filters[post_filter].remove("all")
if post_key in filters[post_filter]:
filters[post_filter].remove(post_key)
else:
filters[post_filter].append(post_key)
if not len(filters[post_filter]) or post_key == "all":
filters[post_filter] = ["all"]
elif post_filter in "countries" and post_key in country_list:
filters[post_filter] = post_key if post_key != filters[
post_filter] else "all"
request.session["stocks-filters"] = filters
# old stocks
old = tsnow() - 48 * 3600
AbroadStocks.objects.filter(timestamp__lt=old).delete()
stocks = AbroadStocks.objects.filter(last=True)
bd = BazaarData.objects.first()
if bd is None:
clients = {}
else:
clients = json.loads(bd.clientsStats)
if filters["countries"] != "all":
stocks = stocks.filter(country_key=filters["countries"])
if "all" not in filters["types"]:
stocks = stocks.filter(item__tType__in=filters["types"])
# add fields
for stock in stocks:
stock.profit = stock.item.tMarketValue - stock.cost
stock.profitperhour = round(30 * stock.profit /
stock.get_country()["fly_time"])
stock.update = tsnow() - stock.timestamp
context = {
"player": player,
"filters": filters,
"country_list": country_list,
"type_list": type_list,
"stocks": stocks,
"clients": sorted(clients.items(), key=lambda x: -x[1][0]),
"bazaarcat": True,
"view": {
"abroad": True
}
}
return render(request, page, context)
except Exception as e:
del request.session["stocks-filters"]
return returnError(exc=e, session=request.session)
def importStocks(request):
try:
if request.method != 'POST':
return JsonResponse(
{"error": {
"code": 2,
"error": "POST request needed"
}},
status=400)
payload = json.loads(request.body)
# check mandatory keys
for key in ["country", "items"]:
if key not in payload:
return JsonResponse(
{
"error": {
"code": 2,
"error": f'Missing \'{key}\' key in payload"'
}
},
status=400)
# check items length
if not len(payload["items"]):
return JsonResponse(
{"error": {
"code": 2,
"error": "Empty items list"
}},
status=400)
# check country:
country_key = str(payload["country"]).lower().strip()[:3]
if country_key not in countries:
return JsonResponse(
{
"error": {
"code": 2,
"error": f'Unknown country key \'{country_key}\''
}
},
status=400)
country = countries[country_key]["name"]
items = payload["items"]
# uid = int(payload.get("uid", 0)) if str(payload.get("uid", 0)).isdigit() else 0
client_name = payload.get("client", "unknown").strip()
client_version = payload.get("version", "0.0")
timestamp = tsnow()
# convert list to dict and check keys
# for all keys to be int
if isinstance(items, list):
items_list = items
items = dict({})
for item in items_list:
for key in ["id", "quantity", "cost"]:
if not str(item.get(key)).isdigit():
return JsonResponse(
{
"error": {
"code":
2,
"error":
f'Wrong {key} for item object: {item.get(key)}'
}
},
status=400)
items[int(item["id"])] = {
"cost": int(item["cost"]),
"quantity": int(item["quantity"])
}
elif isinstance(items, dict):
# cast to int the keys
cast_to_int = []
for item_id, item in items.items():
if not str(item_id).isdigit():
return JsonResponse(
{
"error": {
"code": 2,
"error": f'Wrong item id {item_id}'
}
},
status=400)
for key in ["quantity", "cost"]:
if not str(item.get(key)).isdigit():
return JsonResponse(
{
"error": {
"code": 2,
"error":
f'Wrong item {key} for item {item_id}'
}
},
status=400)
item = {
"cost": int(item["cost"]),
"quantity": int(item["quantity"])
}
if not isinstance(item_id, int):
cast_to_int.append(item_id)
# cast to int the keys
for k in cast_to_int:
items[int(k)] = items[k]
del items[k]
else:
return JsonResponse(
{"error": {
"code": 2,
"error": "Expecting a POST request"
}},
status=400)
# get all unique items from this country
distinct_items = [
k['item_id'] for k in AbroadStocks.objects.filter(
country_key=country_key).values('item_id').distinct()
]
# add items not in db
# for all keys and values to be int
for k in items:
if k not in distinct_items:
distinct_items.append(k)
stocks = dict({})
for item_id in distinct_items:
item = items.get(item_id, False)
cost = 0
quantity = 0
if item:
cost = item["cost"]
quantity = item["quantity"]
else:
lastItem = AbroadStocks.objects.filter(
item_id=item_id,
country_key=country_key).order_by("-timestamp").first()
cost = 0 if lastItem is None else lastItem.cost
quantity = 0
stocks[item_id] = {
"country": country,
"country_key": country_key,
"client": "{} [{}]".format(client_name, client_version),
"timestamp": timestamp,
"cost": cost,
"quantity": quantity
}
client, _ = VerifiedClient.objects.get_or_create(
name=client_name, version=client_version)
client.update_author(payload)
if client.verified:
for k, v in stocks.items():
item = Item.objects.filter(tId=k).first()
if item is None:
return JsonResponse(
{
"error": {
"code": 2,
"error": f"Item {k} not found in database"
}
},
status=400)
AbroadStocks.objects.filter(item=item,
country_key=v["country_key"],
last=True).update(last=False)
v["last"] = True
item.abroadstocks_set.create(**v)
# clear cloudflare cache
r = clear_cf_cache(["https://yata.yt/api/v1/travel/export/"])
print("[api.travel.import] clear cloudflare cache", r)
return JsonResponse(
{"message": f"The stocks have been updated with {client}"},
status=200)
else:
msg = f'Your client \'{client_name} [{client_name}]\' made a successful request but has not been added to the official API list. If you feel confident it\'s working correctly contact Kivou [2000607] to start updating the database.'
return JsonResponse({"message": msg, "stocks": stocks}, status=200)
except BaseException as e:
return JsonResponse({"error": {
"code": 1,
"error": str(e)
}},
status=500)
def livechain(request):
try:
# check if API key is valid with api call
key = request.GET.get("key", False)
if not key:
return JsonResponse(
{"error": {
"code": 2,
"error": "No keys provided"
}},
status=400)
call = apiCall('faction', '', 'chain,basic', key=key)
if "apiError" in call:
return JsonResponse(
{"error": {
"code": 4,
"error": call["apiErrorString"]
}},
status=400)
# create basic payload
payload = call["chain"]
payload["faction_id"] = call["ID"]
payload["faction_name"] = call["name"]
# check if can get faction
factionId = call.get("ID", 0)
faction = Faction.objects.filter(tId=factionId).first()
if faction is None:
payload["yata"] = {
"error": f"Can't find faction {factionId} in YATA database"
}
return JsonResponse({
"chain": payload,
"timestamp": tsnow()
},
status=200)
# get live report
livechain = faction.chain_set.filter(tId=0).first()
if livechain is None:
# chain not there (needs API call data)
if payload["current"] < 10:
pass
livechain = faction.chain_set.create(tId=0,
live=True,
chain=payload["current"],
start=payload["start"],
end=tsnow())
livechain.report = True
livechain.computing = True
livechain.cooldown = False
livechain.status = 1
livechain.addToEnd = 10
livechain.assignCrontab()
livechain.save()
payload["yata"] = {
"error": f"Start computing live report for faction {factionId}"
}
return JsonResponse({
"chain": payload,
"timestamp": tsnow()
},
status=200)
elif not livechain.report:
# if chain already there but not started
livechain.report = True
livechain.live = True
livechain.computing = True
livechain.cooldown = False
livechain.status = 1
livechain.addToEnd = 10
livechain.assignCrontab()
livechain.save()
payload["yata"] = {
"error": f"Start computing live report for faction {factionId}"
}
return JsonResponse({
"chain": payload,
"timestamp": tsnow()
},
status=200)
graphs = json.loads(livechain.graphs)
graphSplit = graphs.get("hits", "").split(',')
graphSplitCrit = graphs.get("crit", "").split(',')
graphSplitStat = graphs.get("members", "").split(',')
if len(graphSplit) > 1 and len(graphSplitCrit) > 1:
# compute average time for one bar
bins = (int(graphSplit[-1].split(':')[0]) - int(
graphSplit[0].split(':')[0])) / float(60 *
(len(graphSplit) - 1))
graph = {
'hits': [],
'members': [],
'stats': {
'bin_size': bins * 60,
'critical_hits_ratio': int(bins) / 5
}
}
cummulativeHits = 0
x = numpy.zeros(len(graphSplit))
y = numpy.zeros(len(graphSplit))
for i, (line,
lineCrit) in enumerate(zip(graphSplit, graphSplitCrit)):
splt = line.split(':')
spltCrit = lineCrit.split(':')
cummulativeHits += int(splt[1])
graph['hits'].append([
int(splt[0]),
int(splt[1]), cummulativeHits,
int(spltCrit[0]),
int(spltCrit[1]),
int(spltCrit[2])
])
x[i] = int(splt[0])
y[i] = cummulativeHits
# y = ax + b (y: hits, x: timestamp)
a, b, _, _, _ = stats.linregress(x[-2:], y[-2:])
a = max(a, 0.00001)
try:
ETA = int((livechain.getNextBonus() - b) / a)
except BaseException as e:
ETA = "unable to compute EAT ({})".format(e)
graph['stats']['current_eta'] = ETA
graph['stats']['current_hit_rate'] = a
graph['stats']['current_intercept'] = b
a, b, _, _, _ = stats.linregress(x, y)
try:
ETA = int((livechain.getNextBonus() - b) / a)
except BaseException as e:
ETA = "unable to compute EAT ({})".format(e)
graph['stats']['global_hit_rate'] = a
graph['stats']['global_intercept'] = b
if len(graphSplitStat) > 1:
for line in graphSplitStat:
splt = line.split(':')
graph['members'].append([float(splt[0]), int(splt[1])])
payload["yata"] = graph
payload["yata"]["last"] = livechain.last
payload["yata"]["update"] = livechain.update
else:
payload["yata"] = {"error": f"No enough data"}
return JsonResponse({
"chain": payload,
"timestamp": tsnow()
},
status=200)
except BaseException as e:
return JsonResponse({"error": {
"code": 1,
"error": str(e)
}},
status=500)
def getAwards(self, userInfo=dict({}), force=False):
from awards.models import AwardsData
from awards.functions import AWARDS_CAT
from awards.functions import createAwards
# get torn awards
awardsTorn = AwardsData.objects.first().loadAPICall()
error = False
if self.tId > 0:
if not len(userInfo):
dbInfo = self.tmpreq_set.filter(type="awards").first()
if dbInfo is not None:
userInfo = json.loads(dbInfo.req)
else:
userInfo = dict({})
error = {
'apiError': "Your data can't be found in the database."
}
if not len(userInfo) or force:
req = apiCall(
'user', '',
'personalstats,crimes,education,battlestats,workstats,perks,gym,networth,merits,profile,medals,honors,icons,bars,weaponexp,hof',
self.getKey())
if 'apiError' not in req:
self.awardsUpda = tsnow()
defaults = {"req": json.dumps(req), "timestamp": tsnow()}
try:
self.tmpreq_set.update_or_create(type="awards",
defaults=defaults)
except BaseException as e:
self.tmpreq_set.filter(type="awards").delete()
self.tmpreq_set.update_or_create(type="awards",
defaults=defaults)
userInfo = req
error = False
else:
error = req
medals = awardsTorn["medals"]
honors = awardsTorn["honors"]
remove = [k for k, v in honors.items() if v["type"] == 1]
for k in remove:
del honors[k]
myMedals = userInfo.get("medals_awarded", [])
myHonors = userInfo.get("honors_awarded", [])
awards = dict()
summaryByType = dict({})
for type in AWARDS_CAT:
awardsTmp, awardsSummary = createAwards(awardsTorn, userInfo, type)
summaryByType[type.title()] = awardsSummary["All awards"]
awards.update(awardsTmp)
# get pinned
pinnedAwards = {k: dict({}) for k in json.loads(self.awardsPinn)}
# delete completed pinned awared
todel = []
for aid in pinnedAwards:
if aid[0] == "m" and aid[2:].isdigit() and int(
aid[2:]) in myMedals:
todel.append(aid)
if aid[0] == "h" and aid[2:].isdigit() and int(
aid[2:]) in myHonors:
todel.append(aid)
for aid in todel:
del pinnedAwards[aid]
self.awardsPinn = json.dumps([k for k in pinnedAwards])
i = len(pinnedAwards)
for type, awardsTmp in awards.items():
for id in pinnedAwards:
if id in awardsTmp:
pinnedAwards[id] = awardsTmp[id]
i -= 1
if not i:
break
summaryByType["AllAwards"] = {
"nAwarded": len(myHonors) + len(myMedals),
"nAwards": len(honors) + len(medals)
}
summaryByType["AllHonors"] = {
"nAwarded": len(myHonors),
"nAwards": len(honors)
}
summaryByType["AllMedals"] = {
"nAwarded": len(myMedals),
"nAwards": len(medals)
}
rScorePerso = 0.0
for k, v in awardsTorn["honors"].items():
if v.get("achieve", 0) == 1:
rScorePerso += v.get("rScore", 0)
for k, v in awardsTorn["medals"].items():
if v.get("achieve", 0) == 1:
rScorePerso += v.get("rScore", 0)
awardsPlayer = {
"userInfo":
userInfo,
"awards":
awards,
"pinnedAwards":
pinnedAwards,
"summaryByType":
dict({
k: v
for k, v in sorted(summaryByType.items(),
key=lambda x: x[1]['nAwarded'],
reverse=True)
})
}
if self.tId > 0 and not error:
self.awardsScor = int(rScorePerso * 10000)
self.awardsNumb = len(myMedals) + len(myHonors)
self.save()
return awardsPlayer, awardsTorn, error
def handle(self, **options):
keys_id = [2000607]
keys = [k.value for k in Key.objects.filter(tId__in=keys_id)]
n_calls_max = 50
delta_t_max = 60
n_calls = 0
ts_start = tsnow()
while True:
n_calls += 1
delta_t = tsnow() - ts_start
# test if too many api calls
if n_calls > n_calls_max:
print(
f"too many api calls, sleeping {delta_t_max - delta_t} seconds"
)
time.sleep(delta_t_max - delta_t)
n_calls = 0
delta_t = 0
ts_start = tsnow()
# print(f"Call number {n_calls} in {delta_t} seconds (iteration ({i}))")
for n, key in enumerate(keys):
randomID = random.randrange(100000, 2300000)
string = f"Use key {n} for id {randomID:07d}"
player = apiCall("user",
randomID,
"profile,personalstats,timestamp",
key,
verbose=False)
if 'apiError' in player:
print(string + "\tIgnore")
continue
dogtags = {
"target_id":
player.get("player_id", 0),
"name":
player.get("name", "???"),
"rank":
player.get("rank", "???"),
"level":
player.get("level", 0),
"age":
player.get("age", 0),
"defendslost":
player.get("personalstats", {}).get("defendslost", 0),
"attackswon":
player.get("personalstats", {}).get("attackswon", 0),
"last_action":
player.get("last_action", {}).get("timestamp", 0),
"last_update":
player.get("timestamp"),
}
_, create = DogTags.objects.get_or_create(
target_id=dogtags["target_id"], defaults=dogtags)
if create:
print(string + "\tTarget created")
else:
print(string + "\tTarget already exists")
