def handle(self, **options):
json_path = options['json_path']
keys = json.load(open(json_path, 'r'))
for k in keys:
print(f'[add user by key] {k}')
user = apiCall('user', '', 'profile', k)
if 'apiError' in user:
print(user)
continue
# create/update player in the database
player = Player.objects.filter(tId=user.get('player_id')).first()
new_player = False
if player is None:
print('[add user by key] create new player')
player = Player.objects.create(tId=int(user.get('player_id')))
new_player = True
print('[add user by key] update player')
player.addKey(k)
# player.key = p.get('key')
player.active = True
player.lastActionTS = tsnow()
updatePlayer(player)
print('[add user by key] save player')
player.save()
def getPlayer(tId, skipUpdate=False, forceUpdate=False):
from player.models import Player
from player.functions import updatePlayer
# get cache
player = cache.get(f'player_{tId}')
print(f"[getPlayer] cached {player}")
# if player in cache and no update force return cache directly
if player is not None and not forceUpdate:
return player
# skip update
if skipUpdate:
# set cache
player = Player.objects.filter(tId=tId).first()
cache.set(f'player_{tId}', player, 3600)
return player
player, _ = Player.objects.get_or_create(tId=tId)
player.lastActionTS = tsnow()
player.active = True
if tsnow() - player.lastUpdateTS > 3600 or forceUpdate:
updatePlayer(player)
player.save()
# set cache
cache.set(f'player_{tId}', player, 3600)
return player
def login(request):
try:
print('[view.yata.login] START')
if request.method == 'POST':
p = request.POST
print('[view.yata.login] API call with key: {}'.format(p.get('key')))
try:
user = apiCall('user', '', 'profile', p.get('key'))
if 'apiError' in user:
print('[view.yata.login] API error: {}'.format(user))
context = user
return render(request, 'yata/login.html', context)
except BaseException as e:
context = {'apiError': e}
return render(request, 'yata/login.html', context)
# create/update player in the database
player = Player.objects.filter(tId=user.get('player_id')).first()
print('[view.yata.login] get player from database: {}'.format(player))
if player is None:
print('[view.yata.login] create new player')
player = Player.objects.create(tId=int(user.get('player_id')))
print('[view.yata.login] update player')
player.addKey(p.get('key'))
# player.key = p.get('key')
player.active = True
player.lastActionTS = tsnow()
updatePlayer(player)
print('[view.yata.login] save player')
player.save()
print('[view.yata.login] create session')
request.session['player'] = {'tId': player.tId, 'name': str(player), 'login': True}
check = json.loads(p.get('check'))
if check:
print('[view.yata.login] set session to expirate in 1 month')
# request.session.set_expiry(31536000) # 1 year
request.session.set_expiry(2592000) # 1 month
else:
print('[view.yata.login] set session to expirate when browser closes')
request.session.set_expiry(0) # logout when close browser
context = {"player": player}
return render(request, 'yata/login.html', context)
# if not post
else:
return returnError(type=403, msg="You need to post. Don\'t try to be a smart ass.")
# return returnError(type=403, msg="You might want to log in.")
except Exception:
return returnError()
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 getPlayer(tId):
from player.models import Player
from player.functions import updatePlayer
from django.http import HttpResponseForbidden
from django.template.loader import render_to_string
player, _ = Player.objects.get_or_create(tId=tId)
player.lastActionTS = tsnow()
player.active = True
if tsnow() - player.lastUpdateTS > 3600:
updatePlayer(player)
player.save()
return player
def handle(self, **options):
# update players info
print("[command.player.updateplayers] UPDATE PLAYERS")
players = Player.objects.filter(validKey=True)
n = len(players)
for i, player in enumerate(players):
try:
updatePlayer(player, i=i + 1, n=n)
except BaseException as e:
print(f"[command.player.updateplayers]: {e}")
print(traceback.format_exc())
del players
# compute rank
print("[command.player.updateplayers] COMPUTE RANKS")
for i, player in enumerate(
Player.objects.exclude(tId=-1).only(
"awardsScor", "awardsRank").order_by('-awardsScor')):
print("[command.player.updateplayers] #{}: {} {:.4f}".format(
i + 1, player, player.awardsScor / 10000.))
player.awardsRank = i + 1
player.save()
# compute hof graph
print("[command.player.updateplayers] COMPUTE HOF GRAPH")
hofGraph = []
for i, player in enumerate(
Player.objects.exclude(awardsScor=0).only("awardsScor")):
print("[command.player.updateplayers] #{}: {} {:.4f}".format(
i + 1, player, player.awardsScor / 10000.))
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()
def getPlayer(tId, skipUpdate=False, forceUpdate=False):
from player.models import Player
from player.functions import updatePlayer
from django.http import HttpResponseForbidden
from django.template.loader import render_to_string
if skipUpdate:
return Player.objects.filter(tId=tId).first()
player, _ = Player.objects.get_or_create(tId=tId)
player.lastActionTS = tsnow()
player.active = True
if tsnow() - player.lastUpdateTS > 3600 or forceUpdate:
updatePlayer(player)
player.save()
return player
def login(request):
try:
print('[view.yata.login] START')
if request.method == 'POST':
p = request.POST
print('[view.yata.login] API call with key: {}'.format(
p.get('key')))
try:
# user = apiCall('user', '', 'profile,bars', p.get('key'))
user = apiCall('user', '', 'profile', p.get('key'))
if 'apiError' in user:
print('[view.yata.login] API error: {}'.format(user))
context = user
context['login'] = True
return render(request, 'header.html', context)
elif user['player_id'] in user_bans:
context = {
"apiError":
f'[YATA User ban] {user_bans[user["player_id"]]}'
}
context['login'] = True
return render(request, 'header.html', context)
except BaseException as e:
context = {'apiError': e, 'login': True}
return render(request, 'header.html', context)
# create/update player in the database
player = Player.objects.filter(tId=user.get('player_id')).first()
print('[view.yata.login] get player from database: {}'.format(
player))
new_player = False
if player is None:
print('[view.yata.login] create new player')
player = Player.objects.create(tId=int(user.get('player_id')))
new_player = True
print('[view.yata.login] update player')
player.addKey(p.get('key'))
# player.key = p.get('key')
player.active = True
player.lastActionTS = tsnow()
updatePlayer(player)
print('[view.yata.login] save player')
player.save()
print('[view.yata.login] create session')
request.session['player'] = {
'tId': player.tId,
'name': str(player)
}
request.session.set_expiry(7776000) # 3 months
context = {
"player": player,
"new_player": new_player,
'login': True
}
return render(request, 'header.html', context)
# if not post
else:
return returnError(
type=403,
msg="You need to post. Don\'t try to be a smart ass.")
# return returnError(type=403, msg="You might want to log in.")
except Exception as e:
return returnError(exc=e, session=request.session)
def supervise(request, shareId=False):
try:
if request.session.get('player') or shareId:
player = getPlayer(request.session.get("player", {}).get("tId", -1))
message = False
if shareId:
company = Company.objects.filter(shareId=shareId).first()
if company is None:
return returnError(type=404, msg="Shared company {} not found.".format(shareId))
else:
# get player and company
company = Company.objects.filter(tId=player.companyId).first()
if company is None and not player.companyDi:
context = {"player": player, "compcat": True, "view": {"supervise": True}}
page = 'company/content-reload.html' if request.method == 'POST' else 'company.html'
return render(request, page, context)
elif company is None:
updatePlayer(player)
company = Company.objects.filter(tId=player.companyId).first()
error, message = company.update_info()
# update company
if ((tsnow() - company.timestamp) > 3600 or request.POST.get("type") == "update-data"):
error, message = company.update_info()
# add employees requirements and potential efficiency on the fly
company_positions = company.company_description.position_set.all()
employees = company.employee_set.all().order_by("-effectiveness_total")
# prepare effectiveness matrix
ws_eff_matrix = []
company.effectiveness_ws_act = 0
hrm = 1.1 if company.director_hrm else 0.9
# modify employees positions on the fy if simu
employees_simu = {}
if request.POST.get("type", False) == "employees-simu":
for k, v in json.loads(request.POST.get("employees_position_simu", "{}")).items():
e = employees.filter(tId=k).first()
if e is None:
continue
if e.position != v:
employees_simu[k] = v
# get all current positions
positions = [company_positions.filter(name=employees_simu.get(str(e.tId), e.position)).first() for e in employees]
# loop over employees
now = tsnow()
for employee in employees:
employee.last_action_relative = now - employee.last_action
employee.position = employees_simu.get(str(employee.tId), employee.position)
position = company_positions.filter(name=employee.position).first()
employee.man_required = 0 if position is None else position.man_required
employee.int_required = 0 if position is None else position.int_required
employee.end_required = 0 if position is None else position.end_required
# compute ws_eff matrix (each row is an employee, each column is a position)
sta = [employee.manual_labor, employee.intelligence, employee.endurance]
ws_eff_matrix_row = []
for p in positions:
# compute S and P
req = [p.man_required, p.int_required, p.end_required]
# test if not unassined
if sum(req):
Pi = req.index(max(req))
Si = req.index(min([s for s in req if s]))
P = hrm * sta[Pi] / float(req[Pi])
S = hrm * sta[Si] / float(req[Si])
ws_eff = min(45, 45 * P) + 5*math.log2(max(P, 1)) + min(45, 45 * S) + 5*math.log2(max(S, 1)) + employee.effectiveness_merits
else:
ws_eff = 0
ws_eff_matrix_row.append(ws_eff)
# use simu value if necessary
if p.name == employee.position and employees_simu.get(str(employee.tId), False):
employee.effectiveness_total -= employee.effectiveness_working_stats
employee.effectiveness_working_stats = ws_eff
employee.effectiveness_total += employee.effectiveness_working_stats
employee.simu = True
t = employee.effectiveness_total
n = employee.effectiveness_addiction + employee.effectiveness_inactivity
employee.effectiveness_potential = 100 * (t + n) / max(t, 1)
company.effectiveness_ws_act += employee.effectiveness_working_stats
ws_eff_matrix.append(ws_eff_matrix_row)
try:
ws_eff_matrix = numpy.array(ws_eff_matrix)
row_ind, col_ind = scipy.optimize.linear_sum_assignment(ws_eff_matrix, maximize=True)
company.effectiveness_ws_max = round(ws_eff_matrix[row_ind, col_ind].sum())
company.effectiveness_ws_err = round(100 * (company.effectiveness_ws_act)/company.effectiveness_ws_max)
company.employees_suggestion = [[list(employees)[i].name, list(employees)[i].tId, positions[j].name, ws_eff_matrix[i, j], list(employees)[i].effectiveness_working_stats] for i, j in zip(row_ind, col_ind)]
except BaseException as e:
company.effectiveness_ws_max = 0
company.effectiveness_ws_err = 0
company.employees_suggestion = []
pass
# send employees if simu
if request.POST.get("type", False) == "employees-simu":
context = {"company": company, "company_positions": company_positions, "employees": employees}
return render(request, "company/supervise/employees.html", context)
# send employees if show details
if request.POST.get("type", False) == "show-details":
company_data = company.companydata_set.filter(timestamp=request.POST.get("timestamp")).first()
if company_data is not None:
employees = json.loads(company_data.employees)
return render(request, "company/supervise/details.html", {"company_data": company_data, "employees": employees})
# get company data
company_data = company.companydata_set.all().order_by("-timestamp")
company_data_p = Paginator(company_data, 7)
if request.GET.get('page_d') is not None:
return render(request, "company/supervise/logs.html", {"company_data_p": company_data_p.get_page(request.GET.get('page_d'))})
# get company stock
company_stock = company.companystock_set.all().order_by("-timestamp")
company_stock_p = Paginator(company_stock, 25)
if request.GET.get('page_s') is not None:
return render(request, "company/supervise/stock.html", {"company_stock_p": company_stock_p.get_page(request.GET.get('page_s'))})
# create employee graph
# current employees [id, name]
employee_graph_headers = [[str(e.tId), f'{e.name} [{e.tId}]'] for e in employees]
employee_graph_data = []
for data in company_data:
d = json.loads(data.employees)
tmp_data = [data.timestamp, []]
for e_id, e_name in employee_graph_headers:
to_append = [d.get(e_id, {}).get("effectiveness_total", "undefined"), d.get(e_id, {}).get("position", "undefined")]
if to_append[0] == 0:
to_append[0] = "undefined"
tmp_data[1].append(to_append)
employee_graph_data.append(tmp_data)
employees_graph = {"header": employee_graph_headers, "data": employee_graph_data}
company.save()
context = {"player": player,
"share": shareId,
"company": company,
"company_positions": company_positions,
"company_data": company_data,
"company_data_p": company_data_p.get_page(1),
"company_stock": company_stock,
"company_stock_p": company_stock_p.get_page(1),
"employees": employees,
"employees_graph": employees_graph,
"compcat": True,
"view": {"supervise": True}}
if message:
sub = "Sub" if request.method == 'POST' else ""
if error:
if "apiErrorString" in message:
context["errorMessage" + sub] = f'Company: API error {message["apiErrorString"]}, data not updated'
elif "error" in message:
context["errorMessage" + sub] = f'Company: {message["error"]}'
else:
context["validMessage" + sub] = "Company data has been updated."
page = 'company/content-reload.html' if request.method == 'POST' else 'company.html'
return render(request, page, context)
else:
return returnError(type=403, msg="You might want to log in.")
except Exception as e:
return returnError(exc=e, session=request.session)
