def edit_signature(request, sigtracker_id):
logger.debug("edit_optimer called by user %s for optimer id %s" % (request.user, sigtracker_id))
sig = get_object_or_404(sigtracker, id=sigtracker_id)
if request.method == 'POST':
form = SignatureForm(request.POST)
logger.debug("Received POST request containing update sigtracker form, is valid: %s" % form.is_valid())
if form.is_valid():
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
sig.ident = form.cleaned_data['ident']
sig.system = form.cleaned_data['system']
sig.destination = form.cleaned_data['destination']
sig.sigtype = form.cleaned_data['sigtype']
sig.status = form.cleaned_data['status']
sig.notes = form.cleaned_data['notes']
sig.eve_character = character
logger.info("User %s updating sigtracker id %s " % (request.user, sigtracker_id))
sig.save()
logger.debug("Detected no changes between sigtracker id %s and supplied form." % sigtracker_id)
return HttpResponseRedirect("/sigtracker/")
else:
data = {
'ident': sig.ident,
'system': sig.system,
'destination': sig.destination,
'sigtype': sig.sigtype,
'status': sig.status,
'notes': sig.notes,
}
form = SignatureForm(initial= data)
return render_to_response('registered/signatureupdate.html', {'form':form}, context_instance=RequestContext(request))
def add_signature_view(request):
logger.info("add_signature_view called by user %s" % request.user)
if request.method == 'POST':
form = SignatureForm(request.POST)
logger.info("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
#Get Current Time
post_time = timezone.now()
# Get character
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
# handle valid form
sig = sigtracker()
sig.ident = form.cleaned_data['ident']
sig.system = form.cleaned_data['system']
sig.destination = form.cleaned_data['destination']
sig.sigtype = form.cleaned_data['sigtype']
sig.status = form.cleaned_data['status']
sig.notes = form.cleaned_data['notes']
sig.create_time = post_time
sig.eve_character = character
sig.save()
return HttpResponseRedirect("/sigtracker/")
else:
logger.info("Returning new SignatureForm")
form = SignatureForm()
render_items = {'form': form}
return render_to_response('registered/addsignature.html', render_items, context_instance=RequestContext(request))
def reset_teamspeak3_perm(request):
logger.debug("reset_teamspeak3_perm called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Deleting TS3 user for user %s" % request.user)
Teamspeak3Manager.delete_user(authinfo.teamspeak3_uid)
remove_all_syncgroups_for_service(request.user, "teamspeak3")
if check_if_user_has_permission(request.user, "blue_member"):
logger.debug("Generating new permission key for blue user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_blue_permissionkey(authinfo.teamspeak3_uid, character.character_name,
character.corporation_ticker)
else:
logger.debug("Generating new permission key for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_permissionkey(authinfo.teamspeak3_uid, character.character_name,
character.corporation_ticker)
# if blank we failed
if result != "":
AuthServicesInfoManager.update_user_teamspeak3_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
update_teamspeak3_groups(request.user)
logger.info("Successfully reset TS3 permission key for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user)
return HttpResponseRedirect("/")
def group_request_add(request, group_id):
logger.debug("group_request_add called by user %s for group id %s" % (request.user, group_id))
group = Group.objects.get(id=group_id)
if not GroupManager.joinable_group(group):
logger.warning("User %s attempted to join group id %s but it is not a joinable group" %
(request.user, group_id))
messages.warning(request, _("You cannot join that group"))
return redirect('auth_groups')
if not request.user.has_perm('groupmanagement.request_groups') and not group.authgroup.public:
# Does not have the required permission, trying to join a non-public group
logger.warning("User %s attempted to join group id %s but it is not a public group" %
(request.user, group_id))
messages.warning(request, "You cannot join that group")
return redirect('auth_groups')
if group.authgroup.open:
logger.info("%s joining %s as is an open group" % (request.user, group))
request.user.groups.add(group)
return redirect("auth_groups")
auth_info = AuthServicesInfo.objects.get(user=request.user)
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(auth_info.main_char_id)
grouprequest.leave_request = False
grouprequest.save()
logger.info("Created group request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
messages.success(request, _('Applied to group %(group)s.') % {"group": group})
return redirect("auth_groups")
def add_timer_view(request):
if request.method == 'POST':
form = TimerForm(request.POST)
if form.is_valid():
# Get character
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
corporation = EveManager.get_corporation_info_by_id(character.corporation_id)
# handle valid form
timer = Timer()
timer.name = form.cleaned_data['name']
timer.system = form.cleaned_data['system']
timer.planet_moon = form.cleaned_data['planet_moon']
timer.structure = form.cleaned_data['structure']
timer.fleet_type = form.cleaned_data['fleet_type']
timer.eve_time = form.cleaned_data['eve_time']
timer.important = form.cleaned_data['important']
timer.eve_character = character
timer.eve_corp = corporation
timer.user = request.user
timer.save()
return HttpResponseRedirect("/timers/")
else:
form = TimerForm()
render_items = {'form': form}
return render_to_response('registered/addtimer.html', render_items, context_instance=RequestContext(request))
def srp_fleet_add_view(request):
logger.debug("srp_fleet_add_view called by user %s" % request.user)
completed = False
completed_srp_code = ""
if request.method == 'POST':
form = SrpFleetMainForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
authinfo = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain()
srp_fleet_main.fleet_name = form.cleaned_data['fleet_name']
srp_fleet_main.fleet_doctrine = form.cleaned_data['fleet_doctrine']
srp_fleet_main.fleet_time = form.cleaned_data['fleet_time']
srp_fleet_main.fleet_srp_code = random_string(8)
srp_fleet_main.fleet_commander = character
srp_fleet_main.save()
completed = True
completed_srp_code = srp_fleet_main.fleet_srp_code
logger.info("Created SRP Fleet %s by user %s" % (srp_fleet_main.fleet_name, request.user))
messages.success(request, _('Created SRP fleet %(fleetname)s.') % {"fleetname": srp_fleet_main.fleet_name})
else:
logger.debug("Returning blank SrpFleetMainForm")
form = SrpFleetMainForm()
render_items = {'form': form, "completed": completed, "completed_srp_code": completed_srp_code}
return render(request, 'registered/srpfleetadd.html', context=render_items)
def add_timer_view(request):
if request.method == 'POST':
form = TimerForm(request.POST)
if form.is_valid():
# Get character
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
corporation = EveManager.get_corporation_info_by_id(character.corporation_id)
# calculate future time
future_time = datetime.timedelta(days=form.cleaned_data['days_left'], hours=form.cleaned_data['hours_left'], minutes=form.cleaned_data['minutes_left'])
current_time = datetime.datetime.utcnow()
eve_time = current_time + future_time
# handle valid form
timer = Timer()
timer.details = form.cleaned_data['details']
timer.system = form.cleaned_data['system']
timer.planet_moon = form.cleaned_data['planet_moon']
timer.structure = form.cleaned_data['structure']
timer.objective = form.cleaned_data['objective']
timer.eve_time = eve_time
timer.important = form.cleaned_data['important']
timer.eve_character = character
timer.eve_corp = corporation
timer.user = request.user
timer.save()
return HttpResponseRedirect("/timers/")
else:
form = TimerForm()
render_items = {'form': form}
return render_to_response('registered/addtimer.html', render_items, context_instance=RequestContext(request))
def activate_teamspeak3(request):
logger.debug("activate_teamspeak3 called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
if check_if_user_has_permission(request.user, "blue_member"):
logger.debug(
"Adding TS3 user for blue user %s with main character %s" %
(request.user, character))
result = Teamspeak3Manager.add_blue_user(character.character_name,
character.corporation_ticker)
else:
logger.debug("Adding TS3 user for user %s with main character %s" %
(request.user, character))
result = Teamspeak3Manager.add_user(character.character_name,
character.corporation_ticker)
# if its empty we failed
if result[0] is not "":
AuthServicesInfoManager.update_user_teamspeak3_info(
result[0], result[1], request.user)
logger.debug(
"Updated authserviceinfo for user %s with TS3 credentials. Updating groups."
% request.user)
update_teamspeak3_groups(request.user)
logger.info("Succesfully activated TS3 for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to activate TS3 for user %s" %
request.user)
return HttpResponseRedirect("/dashboard")
def add_optimer_view(request):
logger.debug("add_optimer_view called by user %s" % request.user)
if request.method == 'POST':
form = opForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
# Get Current Time
post_time = timezone.now()
# Get character
auth_info = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
# handle valid form
op = optimer()
op.doctrine = form.cleaned_data['doctrine']
op.system = form.cleaned_data['system']
op.location = form.cleaned_data['location']
op.start = form.cleaned_data['start']
op.duration = form.cleaned_data['duration']
op.operation_name = form.cleaned_data['operation_name']
op.fc = form.cleaned_data['fc']
op.details = form.cleaned_data['details']
op.create_time = post_time
op.eve_character = character
op.save()
logger.info("User %s created op timer with name %s" % (request.user, op.operation_name))
messages.success(request, _('Created operation timer for %(opname)s.') % {"opname": op.operation_name})
return redirect("/optimer/")
else:
logger.debug("Returning new opForm")
form = opForm()
render_items = {'form': form}
return render(request, 'registered/addoperation.html', context=render_items)
def disable_alliance_member(user, char_id):
remove_member_permission(user, 'member')
remove_user_from_group(user, settings.DEFAULT_AUTH_GROUP)
remove_user_from_group(user,
generate_corp_group_name(
EveManager.get_character_by_id(char_id).corporation_name))
deactivate_services(user)
def srp_fleet_add_view(request):
logger.debug("srp_fleet_add_view called by user %s" % request.user)
completed = False
completed_srp_code = ""
if request.method == 'POST':
form = SrpFleetMainForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain()
srp_fleet_main.fleet_name = form.cleaned_data['fleet_name']
srp_fleet_main.fleet_doctrine = form.cleaned_data['fleet_doctrine']
srp_fleet_main.fleet_time = form.cleaned_data['fleet_time']
srp_fleet_main.fleet_srp_code = random_string(8)
srp_fleet_main.fleet_commander = character
srp_fleet_main.save()
completed = True
completed_srp_code = srp_fleet_main.fleet_srp_code
logger.info("Created SRP Fleet %s by user %s" % (srp_fleet_main.fleet_name, request.user))
else:
logger.debug("Returning blank SrpFleetMainForm")
form = SrpFleetMainForm()
render_items = {'form': form, "completed": completed, "completed_srp_code": completed_srp_code}
return render_to_response('registered/srpfleetadd.html', render_items, context_instance=RequestContext(request))
def add_timer_view(request):
if request.method == 'POST':
form = TimerForm(request.POST)
if form.is_valid():
# Get character
auth_info = AuthServicesInfoManager.get_auth_service_info(
request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
corporation = EveManager.get_corporation_info_by_id(
character.corporation_id)
# handle valid form
timer = Timer()
timer.name = form.cleaned_data['name']
timer.system = form.cleaned_data['system']
timer.planet_moon = form.cleaned_data['planet_moon']
timer.structure = form.cleaned_data['structure']
timer.fleet_type = form.cleaned_data['fleet_type']
timer.eve_time = form.cleaned_data['eve_time']
timer.important = form.cleaned_data['important']
timer.eve_character = character
timer.eve_corp = corporation
timer.user = request.user
timer.save()
return HttpResponseRedirect("/timers/")
else:
form = TimerForm()
render_items = {'form': form}
return render_to_response('registered/addtimer.html',
render_items,
context_instance=RequestContext(request))
def srp_fleet_add_view(request):
completed = False
completed_srp_code = ""
if request.method == 'POST':
form = SrpFleetMainForm(request.POST)
if form.is_valid():
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain()
srp_fleet_main.fleet_name = form.cleaned_data['fleet_name']
srp_fleet_main.fleet_doctrine = form.cleaned_data['fleet_doctrine']
srp_fleet_main.fleet_time = form.cleaned_data['fleet_time']
srp_fleet_main.fleet_srp_code = random_string(8)
srp_fleet_main.fleet_commander = character
srp_fleet_main.save()
completed = True
completed_srp_code = srp_fleet_main.fleet_srp_code
else:
form = SrpFleetMainForm()
render_items = {'form': form, "completed": completed, "completed_srp_code": completed_srp_code}
return render_to_response('registered/srpfleetadd.html', render_items, context_instance=RequestContext(request))
def edit_optimer(request, optimer_id):
logger.debug("edit_optimer called by user %s for optimer id %s" % (request.user, optimer_id))
op = get_object_or_404(optimer, id=optimer_id)
if request.method == 'POST':
form = opForm(request.POST)
logger.debug("Received POST request containing update optimer form, is valid: %s" % form.is_valid())
if form.is_valid():
auth_info = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
op.doctrine = form.cleaned_data['doctrine']
op.system = form.cleaned_data['system']
op.location = form.cleaned_data['location']
op.start = form.cleaned_data['start']
op.duration = form.cleaned_data['duration']
op.operation_name = form.cleaned_data['operation_name']
op.fc = form.cleaned_data['fc']
op.details = form.cleaned_data['details']
op.eve_character = character
logger.info("User %s updating optimer id %s " % (request.user, optimer_id))
op.save()
messages.success(request, _('Saved changes to operation timer for %(opname)s.') % {"opname": op.operation_name})
return redirect("auth_optimer_view")
else:
data = {
'doctrine': op.doctrine,
'system': op.system,
'location': op.location,
'start': op.start,
'duration': op.duration,
'operation_name': op.operation_name,
'fc': op.fc,
'details': op.details,
}
form = opForm(initial=data)
return render(request, 'registered/optimerupdate.html', context={'form': form})
def group_request_leave(request, group_id):
logger.debug("group_request_leave called by user %s for group id %s" % (request.user, group_id))
group = Group.objects.get(id=group_id)
if not GroupManager.joinable_group(group):
logger.warning("User %s attempted to leave group id %s but it is not a joinable group" %
(request.user, group_id))
messages.warning(request, _("You cannot leave that group"))
return redirect('auth_groups')
if group not in request.user.groups.all():
logger.debug("User %s attempted to leave group id %s but they are not a member" %
(request.user, group_id))
messages.warning(request, _("You are not a member of that group"))
return redirect('auth_groups')
if group.authgroup.open:
logger.info("%s leaving %s as is an open group" % (request.user, group))
request.user.groups.remove(group)
return redirect("auth_groups")
auth_info = AuthServicesInfo.objects.get(user=request.user)
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
logger.info("Created group leave request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
messages.success(request, _('Applied to leave group %(group)s.') % {"group": group})
return redirect("auth_groups")
def timer_view(request):
logger.debug("timer_view called by user %s" % request.user)
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
char = EveManager.get_character_by_id(auth_info.main_char_id)
if char:
corp = EveManager.get_corporation_info_by_id(char.corporation_id)
else:
corp = None
if corp:
corp_timers = Timer.objects.all().filter(corp_timer=True).filter(
eve_corp=corp)
else:
corp_timers = []
timer_list = Timer.objects.all()
closest_timer = None
if timer_list:
closest_timer = \
sorted(list(Timer.objects.all().filter(corp_timer=False)), key=lambda d: (timezone.now()))[0]
logger.debug("Determined closest timer is %s" % closest_timer)
render_items = {
'timers': Timer.objects.all().filter(corp_timer=False),
'corp_timers': corp_timers,
'closest_timer': closest_timer
}
return render_to_response('registered/timermanagement.html',
render_items,
context_instance=RequestContext(request))
def group_membership_list(request, group_id):
logger.debug("group_membership_list called by user %s for group id %s" % (request.user, group_id))
try:
group = Group.objects.get(id=group_id)
# Check its a joinable group i.e. not corp or internal
# And the user has permission to manage it
if not GroupManager.joinable_group(group) or not GroupManager.can_manage_group(request.user, group):
logger.warning("User %s attempted to view the membership of group %s but permission was denied" %
(request.user, group_id))
raise PermissionDenied
except ObjectDoesNotExist:
raise Http404("Group does not exist")
members = list()
for member in group.user_set.all().order_by('username'):
authinfo = AuthServicesInfo.objects.get(user=member)
members.append({
'user': member,
'main_char': EveManager.get_character_by_id(authinfo.main_char_id)
})
render_items = {'group': group, 'members': members}
return render(request, 'registered/groupmembers.html', context=render_items)
def group_request_add(request, group_id):
logger.debug("group_request_add called by user %s for group id %s" %
(request.user, group_id))
group = Group.objects.get(id=group_id)
if not GroupManager.joinable_group(group):
logger.warning(
"User %s attempted to join group id %s but it is not a joinable group"
% (request.user, group_id))
messages.warning(request, "You cannot join that group")
return redirect('auth_groups')
if group.authgroup.open:
logger.info("%s joining %s as is an open group" %
(request.user, group))
request.user.groups.add(group)
return redirect("auth_groups")
auth_info = AuthServicesInfo.objects.get(user=request.user)
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(
auth_info.main_char_id)
grouprequest.leave_request = False
grouprequest.save()
logger.info("Created group request for user %s to group %s" %
(request.user, Group.objects.get(id=group_id)))
messages.success(request, 'Applied to group %s.' % group)
return redirect("auth_groups")
def timer_view(request):
logger.debug("timer_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get(user=request.user)
char = EveManager.get_character_by_id(auth_info.main_char_id)
if char:
corp = EveManager.get_corporation_info_by_id(char.corporation_id)
else:
corp = None
if corp:
corp_timers = Timer.objects.all().filter(corp_timer=True).filter(eve_corp=corp)
else:
corp_timers = []
timer_list = Timer.objects.filter(corp_timer=False)
closest_timer = None
if timer_list:
closest_timer = \
sorted(list(Timer.objects.all().filter(corp_timer=False)), key=lambda d: (timezone.now()))[0]
logger.debug("Determined closest timer is %s" % closest_timer)
render_items = {'timers': Timer.objects.all().filter(corp_timer=False),
'corp_timers': corp_timers,
'closest_timer': closest_timer,
'future_timers': Timer.objects.all().filter(corp_timer=False).filter(
eve_time__gte=datetime.datetime.now()),
'past_timers': Timer.objects.all().filter(corp_timer=False).filter(
eve_time__lt=datetime.datetime.now())}
return render(request, 'registered/timermanagement.html', context=render_items)
def timer_view(request):
logger.debug("timer_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get(user=request.user)
char = EveManager.get_character_by_id(auth_info.main_char_id)
if char:
corp = EveManager.get_corporation_info_by_id(char.corporation_id)
else:
corp = None
if corp:
corp_timers = Timer.objects.all().filter(corp_timer=True).filter(
eve_corp=corp)
else:
corp_timers = []
timer_list = Timer.objects.filter(corp_timer=False)
render_items = {
'timers':
Timer.objects.all().filter(corp_timer=False),
'corp_timers':
corp_timers,
'future_timers':
Timer.objects.all().filter(corp_timer=False).filter(
eve_time__gte=datetime.datetime.now()),
'past_timers':
Timer.objects.all().filter(corp_timer=False).filter(
eve_time__lt=datetime.datetime.now())
}
return render(request,
'registered/timermanagement.html',
context=render_items)
def srp_request_view(request, fleet_srp):
completed = False
no_srp_code = False
srp_code = ""
if SrpFleetMain.objects.filter(fleet_srp_code=fleet_srp).exists() is False:
no_srp_code = True
if request.method == 'POST':
form = SrpFleetUserRequestForm(request.POST)
if form.is_valid():
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain.objects.get(fleet_srp_code=fleet_srp)
srp_request = SrpUserRequest()
srp_request.killboard_link = form.cleaned_data['killboard_link']
srp_request.additional_info = form.cleaned_data['additional_info']
srp_request.character = character
srp_request.srp_fleet_main = srp_fleet_main
srp_request.save()
completed = True
else:
form = SrpFleetUserRequestForm()
render_items = {'form': form, "completed": completed, "no_srp_code": no_srp_code}
return render_to_response('registered/srpfleetrequest.html', render_items, context_instance=RequestContext(request))
def group_request_leave(request, group_id):
logger.debug("group_request_leave called by user %s for group id %s" %
(request.user, group_id))
group = Group.objects.get(id=group_id)
if not GroupManager.joinable_group(group):
logger.warning(
"User %s attempted to leave group id %s but it is not a joinable group"
% (request.user, group_id))
messages.warning(request, _("You cannot leave that group"))
return redirect('auth_groups')
if group not in request.user.groups.all():
logger.debug(
"User %s attempted to leave group id %s but they are not a member"
% (request.user, group_id))
messages.warning(request, _("You are not a member of that group"))
return redirect('auth_groups')
if group.authgroup.open:
logger.info("%s leaving %s as is an open group" %
(request.user, group))
request.user.groups.remove(group)
return redirect("auth_groups")
auth_info = AuthServicesInfo.objects.get(user=request.user)
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(
auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
logger.info("Created group leave request for user %s to group %s" %
(request.user, Group.objects.get(id=group_id)))
messages.success(request,
_('Applied to leave group %(group)s.') % {"group": group})
return redirect("auth_groups")
def reset_teamspeak3_perm(request):
logger.debug("reset_teamspeak3_perm called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Deleting TS3 user for user %s" % request.user)
Teamspeak3Manager.delete_user(authinfo.teamspeak3_uid)
if check_if_user_has_permission(request.user, "blue_member"):
logger.debug("Generating new permission key for blue user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_blue_permissionkey(authinfo.teamspeak3_uid, character.character_name,
character.corporation_ticker)
else:
logger.debug("Generating new permission key for user %s with main character %s" % (request.user, character))
result = Teamspeak3Manager.generate_new_permissionkey(authinfo.teamspeak3_uid, character.character_name,
character.corporation_ticker)
# if blank we failed
if result != "":
AuthServicesInfoManager.update_user_teamspeak3_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user)
update_teamspeak3_groups.delay(request.user)
logger.info("Successfully reset TS3 permission key for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user)
return HttpResponseRedirect("/")
def click_fatlink_view(request, hash, fatname):
# Take IG-header data and register the fatlink if not existing already.
# use obj, created = Fat.objects.get_or_create()
# onload="CCPEVE.requestTrust('http://www.mywebsite.com')"
if 'HTTP_EVE_TRUSTED' in request.META and request.META[
'HTTP_EVE_TRUSTED'] == "Yes":
# Retrieve the latest fatlink using the hash.
try:
fatlink = Fatlink.objects.filter(hash=hash)[0]
valid = True
if (timezone.now() - fatlink.fatdatetime) < datetime.timedelta(
seconds=(fatlink.duration * 60)):
active = True
character = EveManager.get_character_by_id(
request.META['HTTP_EVE_CHARID'])
if character:
fat = Fat()
fat.system = request.META['HTTP_EVE_SOLARSYSTEMNAME']
if 'HTTP_EVE_STATIONNAME' in request.META:
fat.station = request.META['HTTP_EVE_STATIONNAME']
else:
fat.station = "No Station"
fat.shiptype = request.META['HTTP_EVE_SHIPTYPENAME']
fat.fatlink = fatlink
fat.character = character
fat.user = character.user
try:
fat.full_clean()
fat.save()
context = {'trusted': True, 'registered': True}
except ValidationError as e:
messages = []
for errorname, message in e.message_dict.items():
messages.append(message[0].decode())
context = {'trusted': True, 'errormessages': messages}
else:
context = {
'character_id': request.META['HTTP_EVE_CHARID'],
'character_name': request.META['HTTP_EVE_CHARNAME']
}
return render_to_response(
'public/characternotexisting.html',
context,
context_instance=RequestContext(request))
else:
context = {'trusted': True, 'expired': True}
except ObjectDoesNotExist:
context = {'trusted': True}
else:
context = {'trusted': False, 'fatname': fatname}
return render_to_response('public/clickfatlinkview.html',
context,
context_instance=RequestContext(request))
def activate_ipboard_forum(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
result = IPBoardManager.add_user(character.character_name, request.user.email)
if result[0] != "":
AuthServicesInfoManager.update_user_ipboard_info(result[0], result[1], request.user)
update_ipboard_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def activate_blue_mumble(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
result = MumbleManager.create_blue_user(character.corporation_ticker, character.character_name)
# if its empty we failed
if result[0] is not "":
AuthServicesInfoManager.update_user_mumble_info(result[0], result[1], request.user)
update_mumble_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def activate_jabber(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
info = OpenfireManager.add_user(character.character_name)
# If our username is blank means we already had a user
if info[0] is not "":
AuthServicesInfoManager.update_user_jabber_info(info[0], info[1], request.user)
update_jabber_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def add_timer_view(request):
logger.debug("add_timer_view called by user %s" % request.user)
if request.method == 'POST':
form = TimerForm(request.POST)
logger.debug("Request type POST contains form valid: %s" %
form.is_valid())
if form.is_valid():
# Get character
auth_info = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
corporation = EveManager.get_corporation_info_by_id(
character.corporation_id)
logger.debug(
"Determined timer add request on behalf of character %s corporation %s"
% (character, corporation))
# calculate future time
future_time = datetime.timedelta(
days=form.cleaned_data['days_left'],
hours=form.cleaned_data['hours_left'],
minutes=form.cleaned_data['minutes_left'])
current_time = timezone.now()
eve_time = current_time + future_time
logger.debug(
"Determined timer eve time is %s - current time %s, adding %s"
% (eve_time, current_time, future_time))
# handle valid form
timer = Timer()
timer.details = form.cleaned_data['details']
timer.system = form.cleaned_data['system']
timer.planet_moon = form.cleaned_data['planet_moon']
timer.structure = form.cleaned_data['structure']
timer.objective = form.cleaned_data['objective']
timer.eve_time = eve_time
timer.important = form.cleaned_data['important']
timer.corp_timer = form.cleaned_data['corp_timer']
timer.eve_character = character
timer.eve_corp = corporation
timer.user = request.user
timer.save()
logger.info("Created new timer in %s at %s by user %s" %
(timer.system, timer.eve_time, request.user))
messages.success(
request,
_('Added new timer in %(system)s at %(time)s.') % {
"system": timer.system,
"time": timer.eve_time
})
return redirect("/timers/")
else:
logger.debug("Returning new TimerForm")
form = TimerForm()
render_items = {'form': form}
return render(request, 'registered/addtimer.html', context=render_items)
def srp_request_view(request, fleet_srp):
logger.debug("srp_request_view called by user %s for fleet srp code %s" % (request.user, fleet_srp))
completed = False
no_srp_code = False
if SrpFleetMain.objects.filter(fleet_srp_code=fleet_srp).exists() is False:
no_srp_code = True
logger.error("Unable to locate SRP Fleet using code %s for user %s" % (fleet_srp, request.user))
if request.method == 'POST':
form = SrpFleetUserRequestForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
authinfo = AuthServicesInfo.objects.get_or_create(user=request.user)[0]
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain.objects.get(fleet_srp_code=fleet_srp)
post_time = timezone.now()
srp_status = "Pending"
srp_request = SrpUserRequest()
srp_request.killboard_link = form.cleaned_data['killboard_link']
srp_request.additional_info = form.cleaned_data['additional_info']
srp_request.character = character
srp_request.srp_fleet_main = srp_fleet_main
srp_request.srp_status = srp_status
try:
srp_kill_link = srpManager.get_kill_id(srp_request.killboard_link)
(srp_kill_data, ship_value) = srpManager.get_kill_data(srp_kill_link)
except ValueError:
logger.debug("User %s Submitted Invalid Killmail Link %s or server could not be reached" % (
request.user, srp_request.killboard_link))
# THIS SHOULD BE IN FORM VALIDATION
messages.error(request,
"Your SRP request Killmail link is invalid. Please make sure you are using zKillboard.")
return redirect("auth_srp_management_view")
srp_ship_name = srpManager.get_ship_name(srp_kill_data)
srp_request.srp_ship_name = srp_ship_name
kb_total_loss = ship_value
srp_request.kb_total_loss = kb_total_loss
srp_request.post_time = post_time
srp_request.save()
completed = True
logger.info("Created SRP Request on behalf of user %s for fleet name %s" % (
request.user, srp_fleet_main.fleet_name))
messages.success(request, 'Submitted SRP request for your %s.' % srp_ship_name)
else:
logger.debug("Returning blank SrpFleetUserRequestForm")
form = SrpFleetUserRequestForm()
render_items = {'form': form, "completed": completed, "no_srp_code": no_srp_code}
return render(request, 'registered/srpfleetrequest.html', context=render_items)
def click_fatlink_view(request, token, hash, fatname):
try:
fatlink = Fatlink.objects.filter(hash=hash)[0]
if (timezone.now() - fatlink.fatdatetime) < datetime.timedelta(seconds=(fatlink.duration * 60)):
character = EveManager.get_character_by_id(token.character_id)
if character:
# get data
c = token.get_esi_client(Location='v1', Universe='v2')
location = c.Location.get_characters_character_id_location(character_id=token.character_id).result()
ship = c.Location.get_characters_character_id_ship(character_id=token.character_id).result()
location['solar_system_name'] = \
c.Universe.get_universe_systems_system_id(system_id=location['solar_system_id']).result()[
'name']
if location['station_id']:
location['station_name'] = \
c.Universe.get_universe_stations_station_id(station_id=location['station_id']).result()['name']
elif location['structure_id']:
c = token.get_esi_client(Universe='v1')
location['station_name'] = \
c.Universe.get_universe_structures_structure_id(structure_id=location['structure_id']).result()[
'name']
else:
location['station_name'] = "No Station"
ship['ship_type_name'] = EveManager.get_itemtype(ship['ship_type_id']).name
fat = Fat()
fat.system = location['solar_system_name']
fat.station = location['station_name']
fat.shiptype = ship['ship_type_name']
fat.fatlink = fatlink
fat.character = character
fat.user = character.user
try:
fat.full_clean()
fat.save()
messages.success(request, _('Fleet participation registered.'))
except ValidationError as e:
err_messages = []
for errorname, message in e.message_dict.items():
err_messages.append(message[0].decode())
messages.error(request, ' '.join(err_messages))
else:
context = {'character_id': token.character_id,
'character_name': token.character_name}
return render(request, 'fleetactivitytracking/characternotexisting.html', context=context)
else:
messages.error(request, _('FAT link has expired.'))
except (ObjectDoesNotExist, KeyError):
logger.exception("Failed to process FAT link.")
messages.error(request, _('Invalid FAT link.'))
return redirect('auth_fatlink_view')
def activate_jabber(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
info = OpenfireManager.add_user(character.character_name)
# If our username is blank means we already had a user
if info[0] is not "":
AuthServicesInfoManager.update_user_jabber_info(
info[0], info[1], request.user)
update_jabber_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
authserviceinfo = AuthServicesInfo.objects.get(user=user)
if settings.DEBUG:
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_corporation_id_by_id(
authserviceinfo.main_char_id)
# NPC corps return as None
if main_alliance_id is None or int(main_alliance_id) != int(settings.ALLIANCE_ID):
if settings.DEBUG:
print 'Not in Corp'
SlackManager.send_director('API ERROR: ' + user.username +
' Not in corp.\n\tServices disabled.\n\tAPI removed.')
remove_user_all_groups(user)
deactivate_services(user)
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
else:
if settings.DEBUG:
print 'Bad API Deleting character and api for ' + user.username
SlackManager.send_director('API ERROR: Bad API for user ' + user.username +
'\n\tServices disabled.\n\tAPI removed.')
remove_user_all_groups(user)
deactivate_services(user)
EveManager.delete_characters_by_api_id(api_key_pair.api_id, user.id)
EveManager.delete_api_key_pair(api_key_pair.api_id, user.id)
else:
if settings.DEBUG:
print 'No main_char_id set'
def activate_forum(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
result = Phpbb3Manager.add_user(character.character_name, request.user.email, ['REGISTERED'])
# if empty we failed
if result[0] != "":
AuthServicesInfoManager.update_user_forum_info(result[0], result[1], request.user)
update_forum_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def group_request_leave(request, group_id):
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
grouprequest = GroupRequest()
grouprequest.status = 'pending'
grouprequest.group = Group.objects.get(id=group_id)
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
return HttpResponseRedirect("/groups")
def srp_request_view(request, fleet_srp):
logger.debug("srp_request_view called by user %s for fleet srp code %s" % (request.user, fleet_srp))
completed = False
no_srp_code = False
if SrpFleetMain.objects.filter(fleet_srp_code=fleet_srp).exists() is False:
no_srp_code = True
logger.error("Unable to locate SRP Fleet using code %s for user %s" % (fleet_srp, request.user))
if request.method == 'POST':
form = SrpFleetUserRequestForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
authinfo = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain.objects.get(fleet_srp_code=fleet_srp)
post_time = timezone.now()
srp_request = SrpUserRequest()
srp_request.killboard_link = form.cleaned_data['killboard_link']
srp_request.additional_info = form.cleaned_data['additional_info']
srp_request.character = character
srp_request.srp_fleet_main = srp_fleet_main
try:
srp_kill_link = srpManager.get_kill_id(srp_request.killboard_link)
(ship_type_id, ship_value) = srpManager.get_kill_data(srp_kill_link)
except ValueError:
logger.debug("User %s Submitted Invalid Killmail Link %s or server could not be reached" % (
request.user, srp_request.killboard_link))
# THIS SHOULD BE IN FORM VALIDATION
messages.error(request,
_("Your SRP request Killmail link is invalid. Please make sure you are using zKillboard."))
return redirect("auth_srp_management_view")
srp_ship_name = EveManager.get_itemtype(ship_type_id).name
srp_request.srp_ship_name = srp_ship_name
kb_total_loss = ship_value
srp_request.kb_total_loss = kb_total_loss
srp_request.post_time = post_time
srp_request.save()
completed = True
logger.info("Created SRP Request on behalf of user %s for fleet name %s" % (
request.user, srp_fleet_main.fleet_name))
messages.success(request, _('Submitted SRP request for your %(ship)s.') % {"ship": srp_ship_name})
else:
logger.debug("Returning blank SrpFleetUserRequestForm")
form = SrpFleetUserRequestForm()
render_items = {'form': form, "completed": completed, "no_srp_code": no_srp_code}
return render(request, 'registered/srpfleetrequest.html', context=render_items)
def activate_ipboard_forum(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
result = IPBoardManager.add_user(character.character_name,
request.user.email)
if result[0] != "":
AuthServicesInfoManager.update_user_ipboard_info(
result[0], result[1], request.user)
update_ipboard_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def update_discord_nickname(self, pk):
user = User.objects.get(pk=pk)
logger.debug("Updating discord nickname for user %s" % user)
authserviceinfo = AuthServicesInfo.objects.get(user=user)
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
logger.debug("Updating user %s discord nickname to %s" % (user, character.character_name))
try:
DiscordOAuthManager.update_nickname(authserviceinfo.discord_uid, character.character_name)
except:
logger.exception("Discord nickname sync failed for %s, retrying in 10 mins" % user)
raise self.retry(countdown=60 * 10)
logger.debug("Updated user %s discord nickname." % user)
def group_request_leave(request, group_id):
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
grouprequest = GroupRequest()
grouprequest.status = 'pending'
grouprequest.group = Group.objects.get(id=group_id)
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(
auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
return HttpResponseRedirect("/groups")
def update_discord_nickname(self, pk):
user = User.objects.get(pk=pk)
logger.debug("Updating discord nickname for user %s" % user)
authserviceinfo = AuthServicesInfo.objects.get(user=user)
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
logger.debug("Updating user %s discord nickname to %s" % (user, character.character_name))
try:
DiscordOAuthManager.update_nickname(authserviceinfo.discord_uid, character.character_name)
except:
logger.exception("Discord nickname sync failed for %s, retrying in 10 mins" % user)
raise self.retry(countdown=60 * 10)
logger.debug("Updated user %s discord nickname." % user)
def edit_timer(request, timer_id):
logger.debug("edit_timer called by user %s for timer id %s" % (request.user, timer_id))
timer = get_object_or_404(Timer, id=timer_id)
if request.method == 'POST':
form = TimerForm(request.POST)
logger.debug("Received POST request containing updated timer form, is valid: %s" % form.is_valid())
if form.is_valid():
auth_info = AuthServicesInfo.objects.get(user=request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
corporation = EveManager.get_corporation_info_by_id(character.corporation_id)
logger.debug(
"Determined timer edit request on behalf of character %s corporation %s" % (character, corporation))
# calculate future time
future_time = datetime.timedelta(days=form.cleaned_data['days_left'], hours=form.cleaned_data['hours_left'],
minutes=form.cleaned_data['minutes_left'])
current_time = datetime.datetime.utcnow()
eve_time = current_time + future_time
logger.debug(
"Determined timer eve time is %s - current time %s, adding %s" % (eve_time, current_time, future_time))
timer.details = form.cleaned_data['details']
timer.system = form.cleaned_data['system']
timer.planet_moon = form.cleaned_data['planet_moon']
timer.structure = form.cleaned_data['structure']
timer.objective = form.cleaned_data['objective']
timer.eve_time = eve_time
timer.important = form.cleaned_data['important']
timer.corp_timer = form.cleaned_data['corp_timer']
timer.eve_character = character
timer.eve_corp = corporation
logger.info("User %s updating timer id %s " % (request.user, timer_id))
messages.success(request, _('Saved changes to the timer.'))
timer.save()
return redirect("auth_timer_view")
else:
current_time = timezone.now()
td = timer.eve_time - current_time
tddays, tdhours, tdminutes = td.days, td.seconds // 3600, td.seconds // 60 % 60
data = {
'details': timer.details,
'system': timer.system,
'planet_moon': timer.planet_moon,
'structure': timer.structure,
'objective': timer.objective,
'important': timer.important,
'corp_timer': timer.corp_timer,
'days_left': tddays,
'hours_left': tdhours,
'minutes_left': tdminutes,
}
form = TimerForm(initial=data)
return render(request, 'registered/timerupdate.html', context={'form': form})
def activate_forum(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
result = Phpbb3Manager.add_user(character.character_name,
request.user.email, ['REGISTERED'])
# if empty we failed
if result[0] != "":
AuthServicesInfoManager.update_user_forum_info(result[0], result[1],
request.user)
update_forum_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def group_request_leave(request, group_id):
logger.debug("group_request_leave called by user %s for group id %s" % (request.user, group_id))
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
grouprequest = GroupRequest()
grouprequest.status = 'pending'
grouprequest.group = Group.objects.get(id=group_id)
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
logger.info("Created group leave request for user %s to group %s" % (request.user, Group.objects.get(id=group_id)))
return HttpResponseRedirect("/groups")
def srp_request_view(request, fleet_srp):
logger.debug("srp_request_view called by user %s for fleet srp code %s" % (request.user, fleet_srp))
completed = False
no_srp_code = False
srp_code = ""
if SrpFleetMain.objects.filter(fleet_srp_code=fleet_srp).exists() is False:
no_srp_code = True
logger.error("Unable to locate SRP Fleet using code %s for user %s" % (fleet_srp, request.user))
if request.method == 'POST':
form = SrpFleetUserRequestForm(request.POST)
logger.debug("Request type POST contains form valid: %s" % form.is_valid())
if form.is_valid():
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
srp_fleet_main = SrpFleetMain.objects.get(fleet_srp_code=fleet_srp)
post_time = timezone.now()
srp_status = "Pending"
srp_request = SrpUserRequest()
srp_request.killboard_link = form.cleaned_data['killboard_link']
srp_request.additional_info = form.cleaned_data['additional_info']
srp_request.character = character
srp_request.srp_fleet_main = srp_fleet_main
srp_request.srp_status = srp_status
try:
srp_kill_link = srpManager.get_kill_id(srp_request.killboard_link)
(srp_kill_data, ship_value) = srpManager.get_kill_data(srp_kill_link)
except ValueError:
logger.debug("User %s Submitted Invalid Killmail Link %s or server could not be reached" % (request.user, srp_request.killboard_link))
notify(request.user, "Your SRP request Killmail Link Failed Validation", message="Your SRP request Killmail link %s is invalid. Please make sure your using zKillboard." % srp_request.killboard_link, level="danger")
return HttpResponseRedirect("/srp")
srp_ship_name = srpManager.get_ship_name(srp_kill_data)
srp_request.srp_ship_name = srp_ship_name
kb_total_loss = ship_value
srp_request.kb_total_loss = kb_total_loss
srp_request.post_time = post_time
srp_request.save()
completed = True
logger.info("Created SRP Request on behalf of user %s for fleet name %s" % (request.user, srp_fleet_main.fleet_name))
else:
logger.debug("Returning blank SrpFleetUserRequestForm")
form = SrpFleetUserRequestForm()
render_items = {'form': form, "completed": completed, "no_srp_code": no_srp_code}
return render_to_response('registered/srpfleetrequest.html', render_items, context_instance=RequestContext(request))
def activate_teamspeak3(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
if check_if_user_has_permission(request.user, "blue_member"):
result = Teamspeak3Manager.add_blue_user(character.character_name, character.corporation_ticker)
else:
result = Teamspeak3Manager.add_user(character.character_name, character.corporation_ticker)
# if its empty we failed
if result[0] is not "":
AuthServicesInfoManager.update_user_teamspeak3_info(result[0], result[1], request.user)
update_teamspeak3_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def activate_discourse(request):
logger.debug("activate_discourse called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding discourse user for user %s with main character %s" % (request.user, character))
result = DiscourseManager.add_user(character.character_name, request.user.email)
if result[0] != "":
AuthServicesInfoManager.update_user_discourse_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with discourse credentials. Updating groups." % request.user)
update_discourse_groups.delay(request.user.pk)
logger.info("Successfully activated discourse for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccessful attempt to activate forum for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def run_api_refresh():
users = User.objects.all()
for user in users:
# Check if the api server is online
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
print 'Running update on user: '******'Running on ' + api_key_pair.api_id + ':' + api_key_pair.api_key
if EveApiManager.api_key_is_valid(
api_key_pair.api_id, api_key_pair.api_key):
# Update characters
characters = EveApiManager.get_characters_from_api(
api_key_pair.api_id, api_key_pair.api_key)
EveManager.update_characters_from_list(
characters)
valid_key = True
else:
EveManager.delete_characters_by_api_id(
api_key_pair.api_id, user)
EveManager.delete_api_key_pair(
api_key_pair.api_id, api_key_pair.api_key)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(
authserviceinfo.main_char_id)
corp = EveManager.get_corporation_info_by_id(
character.corporation_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(
authserviceinfo.main_char_id)
if main_alliance_id == settings.ALLIANCE_ID:
pass
elif corp is not None:
if corp.is_blue is not True:
deactivate_services(user)
else:
deactivate_services(user)
else:
# nuke it
deactivate_services(user)
else:
print 'No main_char_id set'
def activate_jabber(request):
logger.debug("activate_jabber called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding jabber user for user %s with main character %s" % (request.user, character))
info = OpenfireManager.add_user(character.character_name)
# If our username is blank means we already had a user
if info[0] is not "":
AuthServicesInfoManager.update_user_jabber_info(info[0], info[1], request.user)
logger.debug("Updated authserviceinfo for user %s with jabber credentials. Updating groups." % request.user)
update_jabber_groups.delay(request.user.pk)
logger.info("Succesfully activated jabber for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate jabber for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def activate_market(request):
logger.debug("activate_market called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding market user for user %s with main character %s" % (request.user, character))
result = marketManager.add_user(character.character_name, request.user.email, authinfo.main_char_id, character.character_name)
# if empty we failed
if result[0] != "":
AuthServicesInfoManager.update_user_market_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with market credentials." % request.user)
logger.info("Succesfully activated market for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate market for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def activate_jabber(request):
logger.debug("activate_jabber called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding jabber user for user %s with main character %s" % (request.user, character))
info = OpenfireManager.add_user(character.character_name)
# If our username is blank means we already had a user
if info[0] is not "":
AuthServicesInfoManager.update_user_jabber_info(info[0], info[1], request.user)
logger.debug("Updated authserviceinfo for user %s with jabber credentials. Updating groups." % request.user)
update_jabber_groups(request.user)
logger.info("Succesfully activated jabber for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate jabber for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def activate_ipboard_forum(request):
logger.debug("activate_ipboard_forum called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding ipboard user for user %s with main character %s" % (request.user, character))
result = IPBoardManager.add_user(character.character_name, request.user.email)
if result[0] != "":
AuthServicesInfoManager.update_user_ipboard_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with ipboard credentials. Updating groups." % request.user)
update_ipboard_groups(request.user)
logger.info("Succesfully activated ipboard for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate ipboard for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def activate_ipboard_forum(request):
logger.debug("activate_ipboard_forum called by user %s" % request.user)
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
# Valid now we get the main characters
character = EveManager.get_character_by_id(authinfo.main_char_id)
logger.debug("Adding ipboard user for user %s with main character %s" % (request.user, character))
result = IPBoardManager.add_user(character.character_name, request.user.email)
if result[0] != "":
AuthServicesInfoManager.update_user_ipboard_info(result[0], result[1], request.user)
logger.debug("Updated authserviceinfo for user %s with ipboard credentials. Updating groups." % request.user)
update_ipboard_groups.delay(request.user.pk)
logger.info("Succesfully activated ipboard for user %s" % request.user)
return HttpResponseRedirect("/services/")
logger.error("Unsuccesful attempt to activate ipboard for user %s" % request.user)
return HttpResponseRedirect("/dashboard")
def activate_mumble(request):
authinfo = AuthServicesInfoManager.get_auth_service_info(request.user)
character = EveManager.get_character_by_id(authinfo.main_char_id)
if check_if_user_has_permission(request.user, "blue_member"):
result = MumbleManager.create_blue_user(character.corporation_ticker,
character.character_name)
else:
result = MumbleManager.create_user(character.corporation_ticker,
character.character_name)
# if its empty we failed
if result[0] is not "":
AuthServicesInfoManager.update_user_mumble_info(
result[0], result[1], request.user)
update_mumble_groups(request.user)
return HttpResponseRedirect("/services/")
return HttpResponseRedirect("/dashboard")
def edit_signature(request, sigtracker_id):
logger.debug("edit_optimer called by user %s for optimer id %s" %
(request.user, sigtracker_id))
sig = get_object_or_404(sigtracker, id=sigtracker_id)
if request.method == 'POST':
form = SignatureForm(request.POST)
logger.debug(
"Received POST request containing update sigtracker form, is valid: %s"
% form.is_valid())
if form.is_valid():
auth_info = AuthServicesInfoManager.get_auth_service_info(
request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
sig.ident = form.cleaned_data['ident']
sig.system = form.cleaned_data['system']
sig.destination = form.cleaned_data['destination']
sig.lifetime_status = form.cleaned_data['lifetime_status']
sig.mass_status = form.cleaned_data['mass_status']
sig.ships_size = form.cleaned_data['ships_size']
sig.through_dest = form.cleaned_data['through_dest']
sig.notes = form.cleaned_data['notes']
sig.eve_character = character
logger.info("User %s updating sigtracker id %s " %
(request.user, sigtracker_id))
sig.save()
logger.debug(
"Detected no changes between sigtracker id %s and supplied form." %
sigtracker_id)
return HttpResponseRedirect("/sigtracker/")
else:
data = {
'ident': sig.ident,
'system': sig.system,
'destination': sig.destination,
'lifetime_status': sig.lifetime_status,
'mass_status': sig.mass_status,
'ships_size': sig.ships_size,
'through_dest': sig.through_dest,
'notes': sig.notes,
}
form = SignatureForm(initial=data)
return render_to_response('registered/signatureupdate.html',
{'form': form},
context_instance=RequestContext(request))
def edit_optimer(request, optimer_id):
logger.debug("edit_optimer called by user %s for optimer id %s" %
(request.user, optimer_id))
op = get_object_or_404(optimer, id=optimer_id)
if request.method == 'POST':
form = opForm(request.POST)
logger.debug(
"Received POST request containing update optimer form, is valid: %s"
% form.is_valid())
if form.is_valid():
auth_info = AuthServicesInfoManager.get_auth_service_info(
request.user)
character = EveManager.get_character_by_id(auth_info.main_char_id)
op.doctrine = form.cleaned_data['doctrine']
op.system = form.cleaned_data['system']
op.location = form.cleaned_data['location']
op.start = form.cleaned_data['start']
op.duration = form.cleaned_data['duration']
op.operation_name = form.cleaned_data['operation_name']
op.fc = form.cleaned_data['fc']
op.details = form.cleaned_data['details']
op.eve_character = character
logger.info("User %s updating optimer id %s " %
(request.user, optimer_id))
op.save()
logger.debug(
"Detected no changes between optimer id %s and supplied form." %
optimer_id)
return HttpResponseRedirect("/optimer/")
else:
data = {
'doctrine': op.doctrine,
'system': op.system,
'location': op.location,
'start': op.start,
'duration': op.duration,
'operation_name': op.operation_name,
'fc': op.fc,
'details': op.details,
}
form = opForm(initial=data)
return render_to_response('registered/optimerupdate.html', {'form': form},
context_instance=RequestContext(request))
def dashboard_view(request):
logger.debug("dashboard_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get(user=request.user)
apikeypairs = EveManager.get_api_key_pairs(request.user.id)
sso_validation = settings.API_SSO_VALIDATION or False
api_chars = []
if apikeypairs:
for api in apikeypairs:
api_chars.append({
'id': api.api_id,
'sso_verified': api.sso_verified if sso_validation else True,
'characters': EveCharacter.objects.filter(api_id=api.api_id),
})
context = {
'main': EveManager.get_character_by_id(auth_info.main_char_id),
'apis': api_chars,
'api_sso_validation': settings.API_SSO_VALIDATION or False,
}
return render(request, 'registered/dashboard.html', context=context)
def group_request_add(request, group_id):
logger.debug("group_request_add called by user %s for group id %s" %
(request.user, group_id))
group = Group.objects.get(id=group_id)
if OpenGroup.objects.filter(group=group).exists():
logger.info("%s joining %s as is an open group" %
(request.user, group))
request.user.groups.add(group)
return HttpResponseRedirect("/groups")
auth_info = AuthServicesInfoManager.get_auth_service_info(request.user)
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(
auth_info.main_char_id)
grouprequest.leave_request = False
grouprequest.save()
logger.info("Created group request for user %s to group %s" %
(request.user, Group.objects.get(id=group_id)))
return HttpResponseRedirect("/groups")
def group_request_leave(request, group_id):
logger.debug("group_request_leave called by user %s for group id %s" %
(request.user, group_id))
group = Group.objects.get(id=group_id)
if OpenGroup.objects.filter(group=group).exists():
logger.info("%s leaving %s as is an open group" %
(request.user, group))
request.user.groups.remove(group)
return redirect("auth_groups")
auth_info = AuthServicesInfo.objects.get_or_create(user=request.user)[0]
grouprequest = GroupRequest()
grouprequest.status = _('Pending')
grouprequest.group = group
grouprequest.user = request.user
grouprequest.main_char = EveManager.get_character_by_id(
auth_info.main_char_id)
grouprequest.leave_request = True
grouprequest.save()
logger.info("Created group leave request for user %s to group %s" %
(request.user, Group.objects.get(id=group_id)))
messages.success(request, 'Applied to leave group %s.' % group)
return redirect("auth_groups")
