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 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 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 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 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 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 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 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 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 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 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 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.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}
return render_to_response('registered/timermanagement.html', render_items, context_instance=RequestContext(request))
def timer_view(request):
logger.debug("timer_view called by user %s" % request.user)
auth_info = AuthServicesInfo.objects.get_or_create(user=request.user)[0]
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 run_api_refresh():
users = User.objects.all()
logger.debug("Running api refresh on %s users." % len(users))
for user in users:
# Check if the api server is online
logger.debug("Running api refresh for user %s" % user)
if EveApiManager.check_if_api_server_online():
api_key_pairs = EveManager.get_api_key_pairs(user.id)
logger.debug("User %s has api key pairs %s" % (user, api_key_pairs))
if api_key_pairs:
valid_key = False
authserviceinfo = AuthServicesInfo.objects.get(user=user)
logger.debug("User %s has api keys. Proceeding to refresh." % user)
if authserviceinfo.main_char_id:
if authserviceinfo.main_char_id != "":
#preserve old corp ID for corp change test on members
oldcorp_id = 0
if EveManager.get_character_by_id(authserviceinfo.main_char_id):
oldcorp_id = EveCharacter.objects.get(character_id=authserviceinfo.main_char_id).corporation_id
logger.debug("Determined user %s current main corp id %s" % (user, oldcorp_id))
for api_key_pair in api_key_pairs:
logger.debug("Running update on api key %s" % api_key_pair.api_id)
if EveApiManager.api_key_is_valid(api_key_pair.api_id, api_key_pair.api_key):
#check to ensure API key meets min spec
logger.info("Determined api key %s is still active." % api_key_pair.api_id)
still_valid = True
if authserviceinfo.is_blue:
if settings.BLUE_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
logger.info("Determined api key %s for blue user %s is no longer type account as requred." % (api_key_pair.api_id, user))
still_valid = False
if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
logger.info("Determined api key %s for blue user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
still_valid = False
else:
if settings.MEMBER_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
logger.info("Determined api key %s for user %s is no longer type account as required." % (api_key_pair.api_id, user))
still_valid = False
if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
logger.info("Determined api key %s for user %s no longer meets minimum access mask as required." % (api_key_pair.api_id, user))
still_valid = False
if still_valid is not True:
logger.debug("API key %s has failed validation; it and its characters will be deleted." % api_key_pair.api_id)
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:
logger.info("Determined api key %s still meets requirements." % api_key_pair.api_id)
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
new_character = False
for char in characters.result:
# Ensure we have a model for all characters on key
if not EveManager.check_if_character_exist(characters.result[char]['name']):
new_character = True
logger.debug("API key %s has a new character on the account: %s" % (api_key_pair.api_id, characters.result[char]['name']))
if new_character:
logger.debug("Creating new character %s from api key %s" % (characters.result[char]['name'], api_key_pair.api_id))
EveManager.create_characters_from_list(characters, user, api_key_pair.api_key)
valid_key = True
else:
logger.debug("API key %s is no longer active; it and its characters will be deleted." % api_key_pair.api_id)
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)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
logger.debug("User %s has valid api key, checking main character %s" % (user, character))
if character is not None and EveManager.check_if_corporation_exists_by_id(character.corporation_id):
corp = EveManager.get_corporation_info_by_id(character.corporation_id)
main_corp_id = EveManager.get_charater_corporation_id_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(authserviceinfo.main_char_id)
logger.debug("User %s main character %s has corp %s with alliance id %s" % (user, character, corp, main_alliance_id))
if (settings.IS_CORP and main_corp_id == settings.CORP_ID) or (not settings.IS_CORP and main_alliance_id == settings.ALLIANCE_ID):
logger.debug("User %s corp or alliance meets membership requirements. Ensuring has required permissions and groups." % user)
if not check_if_user_has_permission(user, "member"):
#transition from none or blue to member
if check_if_user_has_permission(user, "blue_member"):
#strip blue status
logger.debug("Removing user %s blue permission and group to prepare for member transition." % user)
remove_member_permission(user, "blue_member")
remove_user_from_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(False, user)
#add to auth group
add_member_permission(user, "member")
add_user_to_group(user, settings.DEFAULT_AUTH_GROUP)
#add to required corp group
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
logger.info("User %s transitioned to full member during api refresh." % user)
elif corp.corporation_id != oldcorp_id:
#changed corps, both corps auth'd, need to change group assignment
logger.debug("User %s main character changed corp from id %s to %s, both meet membership requirements. Updating corp group." % (user, oldcorp_id, corp.corporation_id))
oldcorp = EveCorporationInfo.objects.get(corporation_id=oldcorp_id)
remove_user_from_group(user, generate_corp_group_name(oldcorp.corporation_name))
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
#reset services to force new mumble names and group assignments
deactivate_services(user)
logger.info("User %s transferred corps from member to member. Reassigned groups." % user)
elif corp is not None:
logger.debug("User %s main corp %s does not meet membership requirements." % (user, corp))
if corp.is_blue is not True:
if check_if_user_has_permission(user, "member"):
#transition from member to nobody
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.info("User %s no longer member: main has left member corp/alliance." % user)
elif check_if_user_has_permission(user, "blue_member"):
#transition from blue to nobody
disable_blue_member(user)
logger.info("User %s no longer blue: main has left blue entities." % user)
else:
#stay nobody, make sure no services
deactivate_services(user)
logger.debug("Ensured non-member %s has no services." % user)
else:
if check_if_user_has_permission(user, "member"):
#remove auth member to prepare for member to blue transition
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.debug("Removed user %s member group/permissions to transition to blue." % user)
if not check_if_user_has_permission(user, "blue_member"):
#perform nobody to blue transition
add_member_permission(user, "blue_member")
add_user_to_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(True, user)
logger.info("User %s transitioned to blue member during api refresh." % user)
else:
# disable accounts with missing corp model (not blue or member)
if check_if_user_has_permission(user, "member"):
disable_alliance_member(user, authserviceinfo.main_char_id)
logger.info("User %s disabled (previously member) as unable to check missing corp model." % user)
elif check_if_user_has_permission(user, "blue_member"):
disable_blue_member(user)
logger.info("User %s disabled (previously blue) as unable to check missing corp model." % user)
else:
deactivate_services(user)
logger.debug("Ensured non-member %s has no services." % user)
else:
# nuke it, the hard way
disable_expired_member(user)
logger.info("User %s disabled due to missing main character or corp model." % user)
else:
# disable accounts with invalid keys
disable_expired_member(user)
logger.info("User %s has no valid api keys and has been disabled." % user)
else:
logger.warn("User %s has no main character id, unable to validate membership.")
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 = 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)
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))
timer.save()
logger.debug(
"Detected no changes between timer id %s and supplied form." %
timer_id)
return HttpResponseRedirect("/timers/")
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_to_response('registered/timerupdate.html', {'form': form},
context_instance=RequestContext(request))
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):
#check to ensure API key meets min spec
still_valid = True
if authserviceinfo.is_blue:
if settings.BLUE_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if not EveApiManager.check_blue_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
else:
if settings.MEMBER_API_ACCOUNT:
if not EveApiManager.check_api_is_type_account(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if not EveApiManager.check_api_is_full(api_key_pair.api_id, api_key_pair.api_key):
still_valid = False
if still_valid is not True:
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:
# Update characters
characters = EveApiManager.get_characters_from_api(api_key_pair.api_id,
api_key_pair.api_key)
EveManager.update_characters_from_list(characters)
new_character = False
for char in characters.result:
# Ensure we have a model for all characters on key
if not EveManager.check_if_character_exist(characters.result[char]['name']):
new_character = True
if new_character:
EveManager.create_characters_from_list(characters, user, api_key_pair.api_key)
valid_key = True
else:
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)
if valid_key:
# Check our main character
character = EveManager.get_character_by_id(authserviceinfo.main_char_id)
if character is not None and EveManager.check_if_corporation_exists_by_id(character.corporation_id):
corp = EveManager.get_corporation_info_by_id(character.corporation_id)
main_corp_id = EveManager.get_charater_corporation_id_by_id(authserviceinfo.main_char_id)
main_alliance_id = EveManager.get_charater_alliance_id_by_id(authserviceinfo.main_char_id)
if (settings.IS_CORP and main_corp_id == settings.CORP_ID) or (not settings.IS_CORP and main_alliance_id == settings.ALLIANCE_ID):
if not check_if_user_has_permission(user, "member"):
#transition from none or blue to member
if check_if_user_has_permission(user, "blue_member"):
#strip blue status
remove_member_permission(user, "blue_member")
remove_user_from_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(False, user)
#add to auth group
add_member_permission(user, "member")
add_user_to_group(user, settings.DEFAULT_AUTH_GROUP)
#add to required corp group
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
elif corp.corporation_id != oldcorp_id:
#changed corps, both corps auth'd, need to change group assignment
oldcorp = EveCorporationInfo.objects.get(corporation_id=oldcorp_id)
remove_user_from_group(user, generate_corp_group_name(oldcorp.corporation_name))
add_user_to_group(user, generate_corp_group_name(character.corporation_name))
#reset services to force new mumble names and group assignments
deactivate_services(user)
elif corp is not None:
if corp.is_blue is not True:
if check_if_user_has_permission(user, "member"):
#transition from member to nobody
disable_alliance_member(user, authserviceinfo.main_char_id)
elif check_if_user_has_permission(user, "blue_member"):
#transition from blue to nobody
disable_blue_member(user)
else:
#stay nobody, make sure no services
deactivate_services(user)
else:
if check_if_user_has_permission(user, "member"):
#remove auth member to prepare for member to blue transition
disable_alliance_member(user, authserviceinfo.main_char_id)
if not check_if_user_has_permission(user, "blue_member"):
#perform nobody to blue transition
add_member_permission(user, "blue_member")
add_user_to_group(user, settings.DEFAULT_BLUE_GROUP)
AuthServicesInfoManager.update_is_blue(True, user)
else:
# disable accounts with missing corp model (not blue or member)
if check_if_user_has_permission(user, "member"):
disable_alliance_member(user, authserviceinfo.main_char_id)
elif check_if_user_has_permission(user, "blue_member"):
disable_blue_member(user)
else:
deactivate_services(user)
else:
# nuke it, the hard way
disable_expired_member(user)
else:
# disable accounts with invalid keys
disable_expired_member(user)
else:
print 'No main_char_id set'
