def completed(request):
"""
Will complete authentictaion to TeamSpeak
"""
url = GLOBAL_URL + "/auth/complete"
request_teamspeak_auth = requests.post(url,
headers=global_headers(request))
if request_teamspeak_auth.status_code == 404:
try:
detail = request_teamspeak_auth.json()["detail"]
except KeyError:
pass
else:
if detail == "Could not find corresponding teamspeak client":
return render(request, "teamspeak/notfound.html")
if request_teamspeak_auth.status_code != 201:
return render_error(request_teamspeak_auth)
request_character_url = SNI_URL + "user/" + str(request.session["user_id"])
request_character = requests.get(request_character_url,
headers=global_headers(request))
if request_character.status_code != 200:
return render_error(request_character)
return render(request, 'teamspeak/completed.html',
{"tickered_name": request_character.json()["tickered_name"]})
def home(request):
"""
Will display all the coalitions registered on the SNI
"""
request_coalitions = requests.get(GLOBAL_URL,
headers=global_headers(request))
if request_coalitions.status_code != 200:
return render_error(request_coalitions)
coalition_list = request_coalitions.json()
coalition_dict = {}
for coalition in coalition_list:
request_coalition_details = requests.get(
f"{GLOBAL_URL}/{coalition['coalition_id']}",
headers=global_headers(request))
if request_coalition_details.status_code != 200:
return render_error(request_coalition_details)
coalition_details = request_coalition_details.json()
coalition_dict[coalition['coalition_id']] = coalition_details
coalition_dict[coalition['coalition_id']]['members'] = len(
coalition_details['member_alliances'] +
coalition_details['member_corporations'])
return render(
request, 'coalition/home.html', {
"coalition_list": coalition_dict,
"new_coalition": request.GET.get("new_coa"),
"deleted_coalition": request.GET.get("del_coa"),
"clearance_level": get_clearance_level(request)
})
def contracts_details(request, character_id, contract_id):
"""
Displays informations on a contract
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
url = SNI_URL + f"esi/latest/characters/{character_id}/contracts/"
json = {"on_behalf_of": request.session["user_id"], "all_pages": True}
request_contracts = requests.get(url, headers=global_headers(request), json=json)
if request_contracts.status_code != 200:
return render_error(request_contracts)
for contract in request_contracts.json()["data"]:
if contract["contract_id"] == contract_id:
if contract["type"] != "courier":
request_contract_items = requests.get(url+f"{contract_id}/items/", headers=global_headers(request), json=json)
if request_contract_items.status_code != 200:
return render_error(request_contract_items)
contract["contract_items"] = request_contract_items.json()["data"]
return render(request, 'character/contracts-details.html', {
"character": request_name.json(),
"character_id": character_id,
"contract": contract,
})
return render(request, "404.html")
def remove_corporation(request, coalition_id, corporation_id):
"""
Removes a corporation from the coalition
"""
url = f"{GLOBAL_URL}/{coalition_id}"
headers = global_headers(request)
headers.update({"Content-type": "application/json"})
data = "{\"remove_member_corporations\": [\"" + str(
corporation_id) + "\"]}"
request_remove = requests.put(url, headers=headers, data=data)
if request_remove.status_code != 200:
return render_error(request_remove)
request_corporation_name = post_universe_names(corporation_id)
if request_corporation_name.status_code != 200:
return render_error(request_corporation_name)
corproation_name = request_corporation_name.json()[0]["name"]
params = urlencode({"rem_corp": corproation_name})
return_url = reverse("coalition-sheet", args=[coalition_id]) + "?" + params
return redirect(return_url)
def sheet(request, corp_id):
"""
Information sheet on a corporation
"""
request_corp = requests.get(GLOBAL_URL + f"/{corp_id}",
headers=global_headers(request))
if request_corp.status_code != 200:
return render_error(request_corp)
esi_request_corp = get_corporations_corporation_id(corp_id)
if esi_request_corp.status_code != 200:
return render_error(esi_request_corp)
esi_corp = esi_request_corp.json()
esi_corp["tax_rate"] *= 100
return render(
request, "corporation/sheet.html", {
"corporation": request_corp.json(),
"esi": esi_corp,
"corporation_id": corp_id,
"corporation_name": esi_request_corp.json()["name"],
"scopes": ESI_SCOPES,
"changed_scopes": request.GET.get("changed_scopes"),
})
def add(request, coalition_id):
"""
Add a new member to the coalition (alliance or corporation)
"""
url = f"{GLOBAL_URL}/{coalition_id}"
headers = global_headers(request)
headers.update({"Content-type": "application/json"})
request_member_id = post_universe_ids(request.POST.get("member"))
if request_member_id.status_code != 200:
return render_error(request_alliance_id)
if "alliances" in request_member_id.json():
t = "alliance"
alliance_id = request_member_id.json()["alliances"][0]["id"]
data = "{\"add_member_alliances\": [\"" + str(alliance_id) + "\"]}"
elif "corporations" in request_member_id.json():
t = "coproration"
corporation_id = request_member_id.json()["corporations"][0]["id"]
data = "{\"add_member_corporations\": [\"" + str(
corporation_id) + "\"]}"
else:
params = urlencode({"not_found": request.POST.get("alliance")})
return_url = reverse("coalition-sheet", args=[coalition_id
]) + "?" + params
return redirect(return_url)
request_new = requests.put(url, headers=headers, data=data)
if request_new.status_code == 404: # case when the alliance isn't know by the backend yet
if t == "alliance":
request_fetch = requests.post(SNI_URL + f"alliance/{alliance_id}",
headers=global_headers(request))
else:
request_fetch = requests.post(SNI_URL +
f"corporation/{corporation_id}",
headers=global_headers(request))
if request_fetch.status_code != 200:
return render_error(request_fetch)
request_new = requests.put(
url, headers=headers, data=data) # tries again to add the alliance
if request_new.status_code != 200:
return render_error(request_new)
params = urlencode({"new_member": request.POST.get("member")})
return_url = reverse("coalition-sheet", args=[coalition_id]) + "?" + params
return redirect(return_url)
def auth_invite(request):
"""
Retrives a state code, deduct scopes from it and ask for a login url with the specific scopes
"""
esi_scopes = ESI_SCOPES
esi_scopes.sort()
code = request.POST.get("code")
hex_scopes = int(code.split(":")[0], 16)
# stolen from https://github.com/altaris/seat-navy-issue/blob/master/sni/esi/scope.py
scopes = set()
index = 0
for scope in esi_scopes:
if hex_scopes & (2**index) > 0:
scopes.add(scope)
index += 1
headers = {"Authorization": f"Bearer {SNI_DYNAMIC_TOKEN}"}
json = {"scopes": list(scopes), "state_code": code}
url = SNI_URL + "token/use/from/dyn"
r = requests.post(url, headers=headers, json=json)
if r.status_code != 200:
return render_error(r)
response = redirect(r.json()["login_url"])
response.set_cookie("state_code", r.json()["state_code"],
max_age=300) # the login must be made in 5 minutes
return response
def sni_callback(request):
"""
Handles the request when the SNI send back the informations and redirect to the character page of
the character that just logged in.
"""
get_dic = request.GET
try:
state_code = request.COOKIES["state_code"]
except KeyError:
return HttpResponse("No state code foud")
if state_code == get_dic["state_code"]:
request.session["user_token"] = get_dic["user_token"]
headers = {
"accept": "application/json",
"Authorization": f"Bearer {get_dic['user_token']}"
}
request_token = requests.get(SNI_URL + "token", headers=headers)
if request_token.status_code != 200:
return render_error(request_token)
request.session["user_id"] = request_token.json(
)["owner"]["character_id"]
return redirect(
f"/character/{request_token.json()['owner']['character_id']}")
else:
redirect("/")
def create(request):
"""
Create a new group
This link should only be accessed by a redirection from group/new
note: maybe use a post or something to make sure the group isn't created several times?
"""
headers = global_headers(request)
headers.update({"Content-type": "application/json"})
data = "{\"group_name\":\"" + request.GET.get("name") + "\"}"
request_create_group = requests.post(GLOBAL_URL,
headers=headers,
data=data)
print(request_create_group)
print(request_create_group.json())
if request_create_group.status_code != 201:
return render_error(request_create_group)
return_url = reverse("group-home")
params = urlencode({"new_group": request.GET.get("name")})
url = f"{return_url}?{params}"
return redirect(url)
def change_scopes(request, corp_id):
"""
Changing corporation mandatory scopes with a specific list
"""
scopes = []
for key in request.POST:
if key in ESI_SCOPES:
scopes.append(key)
if len(scopes) > 0:
data = "{\"mandatory_esi_scopes\": [\"" + "\",\"".join(scopes) + "\"]}"
else:
data = "{\"mandatory_esi_scopes\": []}"
request_change = requests.put(GLOBAL_URL + f"/{corp_id}",
headers=global_headers(
request,
{"Content-type": "application/json"}),
data=data)
if request_change.status_code != 200:
return render_error(request_change)
params = urlencode({"changed_scopes": "true"})
return_url = reverse("corporation-sheet", args=[corp_id]) + "?" + params
return redirect(return_url)
def locations(request, character_id):
"""
Displays characters location history
"""
url = HISTORY_URL + f"{character_id}/location"
headers = global_headers(request)
request_locations = requests.get(url, headers=headers)
if request_locations.status_code != 200:
return render_error(request_locations)
locations = list()
for i in range(len(request_locations.json())):
if len(request_locations.json()[i]["timestamp"]) == 26:
date_str = datetime.datetime.strptime(request_locations.json()[i]["timestamp"][:-7], "%Y-%m-%dT%H:%M:%S").__str__()
elif len(request_locations.json()[i]["timestamp"]) == 19:
date_str = datetime.datetime.strptime(request_locations.json()[i]["timestamp"], "%Y-%m-%dT%H:%M:%S").__str__()
else:
data_str = request_locations.json()[i]["timestamp"]
locations.append((request_locations.json()[i], date_str))
return render(request, "character/locations.html",{
"character_id": character_id,
"locations": locations,
})
def mails(request, character_id):
"""
Displays character mails
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
request_mails = requests.get(SNI_URL+f"esi/history/characters/{character_id}/mail", headers=global_headers(request))
if request_mails.status_code != 200:
return render_error(request_mails)
return render(request, 'character/mails.html', {
"character": request_name.json(),
"character_id": character_id,
"mails": request_mails.json(),
})
def tracking(request, coalition_id):
"""
Display the tracking of the coalition members
"""
request_coa = requests.get(GLOBAL_URL + f"/{coalition_id}",
headers=global_headers(request))
if request_coa.status_code != 200:
return render_error(request_coa)
url = GLOBAL_URL + f"/{coalition_id}/tracking"
request_track = requests.get(url, headers=global_headers(request))
if request_track.status_code != 200:
return render_error(request_track)
return render(request, "coalition/tracking.html", {
"coalition": request_coa.json(),
"tracking": request_track.json(),
})
def tracking(request, ally_id):
"""
Alliance tracking
"""
url = GLOBAL_URL+f"/{ally_id}/tracking"
request_track = requests.get(url, headers=global_headers(request))
if request_track.status_code != 200:
return render_error(request_track)
request_alliance = requests.get(GLOBAL_URL+f"/{ally_id}", headers=global_headers(request))
if request_alliance.status_code != 200:
return render_error(request_alliance)
return render(request, "alliance/tracking.html", {
"tracking": request_track.json(),
"alliance_id": ally_id,
"alliance_name": request_alliance.json()["alliance_name"],
})
def get_clearance_level(request):
"""Return the clearance level for curent user"""
url = SNI_URL + f"user/{request.session['user_id']}"
request_user = requests.get(url, headers=global_headers(request))
if request_user.status_code != 200:
return render_error(request_user)
return request_user.json()["clearance_level"]
def sni(request, character_id):
"""
Will display the SNI details for a character
"""
#Get data from SNI backend
url = f"{GLOBAL_URL}/{character_id}"
request_sni = requests.get(url, headers=global_headers(request))
if request_sni.status_code != 200:
return render_error(request_sni)
character = request_sni.json()
# Get corporation details
if character["corporation"]:
corp_id = character["corporation"]
corp_name = IdToName.get_name(corp_id, 'corporations')
character["corporation"] = {
"id": character["corporation"],
"name": corp_name
}
else:
character["corporation"] = {"name": ""}
# Get alliance details
if character["alliance"]:
alliance_name = IdToName.get_name(character["alliance"], 'alliances')
character["alliance"] = {
"id": character["alliance"],
"name": alliance_name,
}
else:
character["alliance"] = {"name": ""}
# Get coalition details
resolved_coalition = list()
if character["coalitions"]:
for coalition in character["coalitions"]:
url_coalition = f"{SNI_URL}coalition/{coalition}"
request_coalition = requests.get(url_coalition, headers=global_headers(request))
resolved_coalition.append({
"id": coalition,
"name": request_coalition.json()["coalition_name"]
})
#character["coalitions"][coalition] = request_coalition.json()["coalition_name"]
character["coalitions"] = resolved_coalition
return render(request, 'character/sni.html', {
"character_id": character_id,
"character_name": character["character_name"],
"character": character,
})
def tracking(request, corp_id):
"""
Tracking of the corp membres tokens
"""
url = GLOBAL_URL + f"/{corp_id}/tracking"
request_track = requests.get(url, headers=global_headers(request))
if request_track.status_code != 200:
return render_error(request_track)
request_corp = get_corporations_corporation_id(corp_id)
if request_corp.status_code != 200:
return render_error(request_corp)
return render(
request, "corporation/tracking.html", {
"tracking": request_track.json(),
"corporation_id": corp_id,
"corporation_name": request_corp.json()["name"],
})
def contracts(request, character_id):
"""
Displays character contracts
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
url = SNI_URL + f"esi/latest/characters/{character_id}/contracts/"
json = {"on_behalf_of": request.session["user_id"], "all_pages": True}
request_contracts = requests.get(url, headers=global_headers(request), json=json)
if request_contracts.status_code != 200:
return render_error(request_contracts)
return render(request, 'character/contracts.html', {
"character": request_name.json(),
"character_id": character_id,
"contracts": request_contracts.json()["data"],
})
def wallet_transactions(request, character_id):
"""
Displays a character transactions list
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
transactions_url = SNI_URL + f"esi/latest/characters/{character_id}/wallet/transactions/"
json = {"all_pages": True, "on_behalf_of": request.session.get("user_id")}
request_wallet_transactions = requests.get(transactions_url, headers=global_headers(request), json=json)
if request_wallet_transactions.status_code != 200:
return render_error(request_wallet_transactions)
return render(request, 'character/transactions.html', {
"character": request_name.json(),
"character_id": character_id,
"transactions": request_wallet_transactions.json()["data"],
})
def wallet_journal(request, character_id):
"""
Displays character journal
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
journal_url = SNI_URL + f"esi/latest/characters/{character_id}/wallet/journal/"
data = {"all_pages": True, "on_behalf_of": request.session.get("user_id")}
request_wallet_journal = requests.get(journal_url, headers=global_headers(request), json=data)
if request_wallet_journal.status_code != 200:
return render_error(request_wallet_journal)
return render(request, 'character/journal.html', {
"character": request_name.json(),
"character_id": character_id,
"journal": request_wallet_journal.json()["data"],
})
def mails_details(request, character_id, mail_id):
"""
Displays informations on a mail
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
json = {"on_behalf_of": request.session["user_id"]}
request_mail_info = requests.get(SNI_URL+f"esi/latest/characters/{character_id}/mail/{mail_id}/", headers=global_headers(request), json=json)
if request_mail_info.status_code != 200:
return render_error(request_mail_info)
mail = BeautifulSoup(request_mail_info.json()["data"]["body"].replace("<br>", "\n"), "html.parser")
return render(request, 'character/mails-details.html', {
"character": request_name.json(),
"character_id": character_id,
"mail": mail.get_text(),
})
def guest(request, corp_id):
"""
Displays the guest users of the corporation
"""
request_guest = requests.get(GLOBAL_URL + f"/{corp_id}/guest",
headers=global_headers(request))
if request_guest.status_code != 200:
return render_error(request_guest)
request_corp_name = post_universe_names(corp_id)
if request_corp_name.status_code != 200:
return render_error(request_corp_name)
return render(
request, "corporation/guest.html", {
"guests": request_guest.json(),
"corporation_id": corp_id,
"corporation_name": request_corp_name.json()[0]["name"],
"state_code": request.GET.get("state_code")
})
def home(request):
"""
Corporation home
"""
request_corp = requests.get(GLOBAL_URL, headers=global_headers(request))
if request_corp.status_code != 200:
return render_error(request_corp)
return render(request, "corporation/home.html", {
"corporations": request_corp.json(),
})
def guest_new(request, corp_id):
"""
Will issue a state code that can be used to authentificate and be recognized as a guest of the corproation
"""
request_code = requests.post(GLOBAL_URL + f"/{corp_id}/guest",
headers=global_headers(request))
if request_code.status_code != 200:
return render_error(request_code)
print(request_code.json()["state_code"])
params = urlencode({"state_code": request_code.json()["state_code"]})
return_url = reverse("corporation-guest", args=[corp_id]) + "?" + params
return redirect(return_url)
def change_scopes_all(request, ally_id):
"""
Changing alliance mandatory scopes by applying them all
"""
data = "{\"mandatory_esi_scopes\": [\"" + "\",\"".join(ESI_SCOPES) + "\"]}"
request_change = requests.put(GLOBAL_URL+f"/{ally_id}", headers=global_headers(request, {"Content-type":"application/json"}), data=data)
if request_change.status_code != 200:
return render_error(request_change)
params = urlencode({"changed_scopes": "true"})
return_url = reverse("alliance-sheet", args=[ally_id]) + "?" + params
return redirect(return_url)
def home(request):
"""
Home view for the administration part
"""
request_jobs = requests.get(GLOBAL_URL, headers=global_headers(request))
if request_jobs.status_code != 200:
return render_error(request_jobs)
return render(request, 'admin/home.html', {
"jobs": request_jobs.json(),
})
def home(request):
"""
Alliance home view
"""
request_ally = requests.get(GLOBAL_URL, headers=global_headers(request))
if request_ally.status_code != 200:
return render_error(request_ally)
return render(request, "alliance/home.html", {
"alliances": request_ally.json(),
})
def skills(request, character_id):
"""
Displays character skils
"""
request_name = esi.get_character_information(character_id)
if request_name.status_code != 200:
return render_error(request_name)
return render(request, 'character/skills.html', {
"character": request_name.json(),
"character_id": character_id,
})
def home(request):
if (user_token := request.session.get("user_token")):
headers = {"Authorization": f"Bearer {user_token}"}
url = SNI_URL + "token"
request_token = requests.get(url, headers=headers)
if request_token.status_code != 200:
return render_error(request_token)
return redirect(
reverse("character-sheet",
args=[request_token.json()["owner"]["character_id"]]))
def delete(request, group_id):
"""
Deletes a group
"""
url = f"{GLOBAL_URL}/{group_id}"
request_group = requests.get(
url, headers=global_headers(request)) # stores group params
if request_group.status_code != 200:
return render_error(request_group)
request_delete_group = requests.delete(url,
headers=global_headers(request))
if request_delete_group.status_code != 200:
return render_error(request_delete_group)
params = urlencode({"del_group": request_group.json()["group_name"]})
return_url = f"{reverse('group-home')}?{params}"
return redirect(return_url)
