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 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 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 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 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 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 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 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 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 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 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):
"""
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 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 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 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)
def guest_delete(request, corp_id, user_id):
"""
Delete a user from the guests of a corporation
"""
request_delete = requests.delete(GLOBAL_URL +
f"/{corp_id}/guest/{user_id}",
headers=global_headers(request))
if request_delete.status_code != 200:
return render_error(request_delete)
params = urlencode({"delete_guest": "true"})
return_url = reverse("corporation-guest", args=[corp_id]) + "?" + params
return redirect(return_url)
def delete(request, coalition_id):
"""
Deletes a coaliton
"""
url = f"{GLOBAL_URL}/{coalition_id}"
request_coalition = requests.get(
url, headers=global_headers(request)) # stores coalition params
if request_coalition.status_code != 200:
return render_error(request_coalition)
request_delete_coalition = requests.delete(url,
headers=global_headers(request))
if request_delete_coalition.status_code != 200:
return render_error(request_delete_coalition)
params = urlencode({"del_coa": request_coalition.json()["coalition_name"]})
return_url = f"{reverse('coalition-home')}?{params}"
return redirect(return_url)
def sheet(request, ally_id):
"""
Alliance sheet
"""
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/sheet.html",{
"changed_scopes": request.GET.get("changed_scopes"),
"alliance_id": ally_id,
"alliance": request_alliance.json(),
"alliance_name": request_alliance.json()["alliance_name"],
"scopes": ESI_SCOPES,
})
def scopes_none(request, coalition_id):
"""
Update coalition required scopes by removing them all
"""
headers = global_headers(request, {"Content-type": "application/json"})
data = "{\"mandatory_esi_scopes\": []}"
request_change_scopes = requests.put(GLOBAL_URL + f"/{coalition_id}",
headers=headers,
data=data)
if request_change_scopes.status_code != 200:
return render_error(request_change_scopes)
params = urlencode({"changed_scopes": "true"})
return_url = reverse("coalition-sheet", args=[coalition_id]) + "?" + params
return redirect(return_url)
def home(request):
"""
Will start authentictaion to TeamSpeak
"""
url = GLOBAL_URL + "/auth/start"
request_teamspeak_auth = requests.post(url,
headers=global_headers(request))
if request_teamspeak_auth.status_code != 200:
return render_error(request_teamspeak_auth)
teamspeak_auth = request_teamspeak_auth.json()
return render(request, 'teamspeak/home.html',
{"teamspeak_auth": teamspeak_auth})
def submit(request):
"""
Submits a job to the scheduler
"""
callable_name = request.POST["callable_name"]
url = f"{GLOBAL_URL}/{callable_name}"
request_submit = requests.post(url, headers=global_headers(request))
if request_submit.status_code != 200:
return render_error(request_submit)
params = urlencode({'sub_job': callable_name})
return_url = reverse("admin-home") + "?" + params
return redirect(return_url)
def home(request):
"""
Home view of discord
"""
url = SNI_URL + "discord/auth/start"
request_auth_code = requests.post(url, headers=global_headers(request))
if request_auth_code.status_code == 200:
return render(request, 'discord/home.html',
{"request_code": request_auth_code.json()})
elif request_auth_code.status_code == 404:
return render(request, 'discord/notactive.html')
else:
return render_error(request_auth_code)
def home(request):
"""
Will display all the characters registered on the SNI
"""
request_characters = requests.get(GLOBAL_URL, headers=global_headers(request))
if request_characters.status_code != 200:
return render_error(request_characters)
character_list = request_characters.json()
# Remove root from the list as it is not a truly valid character
root = next((item for item in character_list if item["character_name"] == "root"), None)
if root != None:
character_list.remove(root)
return render(request, 'character/home.html', {"character_list": character_list})
def ticker(request, coalition_id):
"""
Change a coalition ticker
"""
url = f"{GLOBAL_URL}/{coalition_id}"
headers = global_headers(request)
headers.update({"Content-type": "application/json"})
data = "{\"ticker\":\"" + request.POST.get("ticker") + "\"}"
request_ticker = requests.put(url, headers=headers, data=data)
if request_ticker.status_code != 200:
return render_error(request_ticker)
params = urlencode({"new_ticker": request.POST.get("ticker")})
return_url = reverse("coalition-sheet", args=[coalition_id]) + "?" + params
return redirect(return_url)
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 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"],
})
