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 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 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")