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 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: authserviceinfo, c = AuthServicesInfo.objects.get_or_create(user=user) logger.debug("User %s has api keys. Proceeding to refresh." % user) for api_key_pair in api_key_pairs: try: refresh_api(api_key_pair) except evelink.api.APIError as e: if int(e.code) >= 500: logger.error("EVE API servers encountered error %s updating %s" % (e.code, api_key_pair)) elif int(e.code) == 221: logger.warn("API server hiccup %s while updating %s" % (e.code, api_key_pair)) else: logger.info("API key %s failed update with error code %s" % (api_key_pair.api_id, e.code)) 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) notify(user, "API Key Deleted", message="Your API key ID %s failed validation with code %s. It and its associated characters have been deleted." % (api_key_pair.api_id, e.code), level="danger") # Check our main character if EveCharacter.objects.filter(character_id=authserviceinfo.main_char_id).exists() is False: logger.info("User %s main character id %s missing model. Clearning main character." % (user, authserviceinfo.main_char_id)) authserviceinfo.main_char_id = '' authserviceinfo.save() notify(user, "Main Character Reset", message="Your specified main character no longer has a model.\nThis could be the result of an invalid API\nYour main character ID has been reset.", level="warn") set_state(user)
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 test_refresh_api_characters(self, get_characters_from_api, validate_api): # Arrange provider = mock.MagicMock() provider.get_alliance.return_value = Alliance(provider, 22222, 'Test Alliance', 'TEST', [11111], 11111) provider.get_corp.return_value = Corporation(provider, 11111, 'Test Corp', 'HERP', 12345, [12345, 23456], 22222) mock_api_data = [ Character(provider, 12345, 'testchar1', 11111, 22222), Character(provider, 23456, 'Will beAdded', 11111, 22222) ] get_characters_from_api.return_value = mock_api_data validate_api.return_value = True EveManager.create_character_obj(mock_api_data[0], self.user, '0118999') EveManager.create_character_obj(Character(provider, 34567, 'deletedcharacter', 11111, 22222), self.user, '0118999') # Act tasks.refresh_api(self.api_key) # Assert self.assertTrue(EveCharacter.objects.filter(character_id='12345').exists()) self.assertTrue(EveCharacter.objects.filter(character_id='23456').exists()) self.assertFalse(EveCharacter.objects.filter(character_id='34567').exists()) args, kwargs = validate_api.call_args self.assertEqual(args[0], self.api_key.api_id) self.assertEqual(args[1], self.api_key.api_key) self.assertEqual(args[2], self.api_key.user)
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 hr_application_management_view(request): logger.debug("hr_application_management_view called by user %s" % request.user) personal_app = None corp_applications = None if request.user.is_superuser: logger.debug("User %s is superuser: returning all applications." % request.user) corp_applications = HRApplication.objects.all() else: # Get the corp the member is in auth_info = AuthServicesInfo.objects.get(user=request.user) if auth_info.main_char_id != "": try: main_corp_id = EveManager.get_charater_corporation_id_by_id(auth_info.main_char_id) main_alliance_id = EveManager.get_charater_alliance_id_by_id(auth_info.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): main_char = EveCharacter.objects.get(character_id=auth_info.main_char_id) if EveCorporationInfo.objects.filter(corporation_id=main_char.corporation_id).exists(): corp = EveCorporationInfo.objects.get(corporation_id=main_char.corporation_id) corp_applications = HRApplication.objects.filter(corp=corp).filter(approved_denied=None) else: corp_applications = None else: corp_applications = None except: logger.error("Unable to determine user %s main character id %s corp. Returning no corp hrapplications." % (request.user, auth_info.main_char_id)) corp_applications = None context = {'personal_apps': HRApplication.objects.all().filter(user=request.user), 'applications': corp_applications, 'search_form': HRApplicationSearchForm()} return render_to_response('registered/hrapplicationmanagement.html', context, context_instance=RequestContext(request))
def synchronize_eveapis(user=None): seat_all_keys = SeatManager.get_all_seat_eveapis() userinfo = None # retrieve only user-specific api keys if user is specified if user: keypars = EveManager.get_api_key_pairs(user) try: userinfo = SeatManager.check_user_status(user.seat.username) except ObjectDoesNotExist: pass else: # retrieve all api keys instead keypars = EveManager.get_all_api_key_pairs() if keypars: for keypar in keypars: if keypar.api_id not in seat_all_keys.keys(): #Add new keys logger.debug("Adding Api Key with ID %s" % keypar.api_id) ret = SeatManager.exec_request('key', 'post', key_id=keypar.api_id, v_code=keypar.api_key) logger.debug(ret) else: # remove it from the list so it doesn't get deleted in the last step seat_all_keys.pop(keypar.api_id) if not userinfo: # TODO: should the following be done only for new keys? # Check the key's user status logger.debug("Retrieving user name from Auth's SeAT users database") try: if keypar.user.seat.username: logger.debug("Retrieving user %s info from SeAT users database" % keypar.user.seat.username) userinfo = SeatManager.check_user_status(keypar.user.seat.username) except ObjectDoesNotExist: pass if userinfo: try: # If the user has activated seat, assign the key to him. logger.debug("Transferring Api Key with ID %s to user %s with ID %s " % ( keypar.api_id, keypar.user.seat.username, userinfo['id'])) ret = SeatManager.exec_request('key/transfer/{}/{}'.format(keypar.api_id, userinfo['id']), 'get') logger.debug(ret) except ObjectDoesNotExist: logger.debug("User does not have SeAT activated, could not assign key to user") if bool(seat_all_keys) and not user and hasattr(settings, 'SEAT_PURGE_DELETED') and settings.SEAT_PURGE_DELETED: # remove from SeAT keys that were removed from Auth for key, key_user in iteritems(seat_all_keys): # Remove the key only if it is an account or character key ret = SeatManager.exec_request('key/{}'.format(key), 'get') logger.debug(ret) try: if (ret['info']['type'] == "Account") or (ret['info']['type'] == "Character"): logger.debug("Removing api key %s from SeAT database" % key) ret = SeatManager.exec_request('key/{}'.format(key), 'delete') logger.debug(ret) except KeyError: pass
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 update_corp(id): corp = EveCorporationInfo.objects.get(corporation_id=id) logger.debug("Updating corp %s" % corp) corpinfo = EveApiManager.get_corporation_information(corp.corporation_id) if corpinfo: alliance = None if EveAllianceInfo.objects.filter(alliance_id=corpinfo['alliance']['id']).exists(): alliance = EveAllianceInfo.objects.get(alliance_id=corpinfo['alliance']['id']) EveManager.update_corporation_info(corpinfo['id'], corpinfo['members']['current'], alliance, corp.is_blue) elif EveApiManager.check_if_corp_exists(corp.corporation_id) is False: logger.info("Corp %s has closed. Deleting model" % corp) corp.delete()
def api_key_removal(request, api_id): logger.debug("api_key_removal called by user %s for api id %s" % (request.user, api_id)) authinfo = AuthServicesInfo.objects.get(user=request.user) EveManager.delete_api_key_pair(api_id, request.user.id) EveManager.delete_characters_by_api_id(api_id, request.user.id) messages.success(request, _('Deleted API key %(apiid)s') % {"apiid": api_id}) logger.info("Succesfully processed api delete request by user %s for api %s" % (request.user, api_id)) if not EveCharacter.objects.filter(character_id=authinfo.main_char_id).exists(): authinfo.main_char_id = '' authinfo.save() set_state(request.user) return redirect("auth_dashboard")
def api_key_removal(request, api_id): logger.debug("api_key_removal called by user %s for api id %s" % (request.user, api_id)) authinfo = AuthServicesInfo.objects.get(user=request.user) EveManager.delete_api_key_pair(api_id, request.user.id) EveManager.delete_characters_by_api_id(api_id, request.user.id) messages.success(request, 'Deleted API key %s' % api_id) logger.info("Succesfully processed api delete request by user %s for api %s" % (request.user, api_id)) if not EveCharacter.objects.filter(character_id=authinfo.main_char_id).exists(): authinfo.main_char_id = None authinfo.save() set_state(request.user) return redirect("auth_dashboard")
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 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_or_create( user=request.user)[0] 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 %s at %s.' % (timer.system, 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 api_key_removal(request, api_id): logger.debug("api_key_removal called by user %s for api id %s" % (request.user, api_id)) authinfo = AuthServicesInfo.objects.get_or_create(user=request.user)[0] EveManager.delete_api_key_pair(api_id, request.user.id) EveManager.delete_characters_by_api_id(api_id, request.user.id) messages.success(request, 'Deleted API key %s' % api_id) logger.info("Succesfully processed api delete request by user %s for api %s" % (request.user, api_id)) if EveCharacter.objects.filter(character_id=authinfo.main_char_id).exists(): return redirect("auth_api_key_management") else: authinfo.main_char_id = None authinfo.save() set_state(request.user) return redirect("auth_characters")
def synchronize_eveapis(user=None): seat_all_keys = SeatManager.get_all_seat_eveapis() userinfo = None # retrieve only user-specific api keys if user is specified if user: auth, c = AuthServicesInfo.objects.get_or_create(user=user.id) keypars = EveManager.get_api_key_pairs(user) if auth.seat_username: userinfo = SeatManager.check_user_status(auth.seat_username) else: # retrieve all api keys instead keypars = EveManager.get_all_api_key_pairs() if keypars: for keypar in keypars: if keypar.api_id not in seat_all_keys.keys(): #Add new keys logger.debug("Adding Api Key with ID %s" % keypar.api_id) ret = SeatManager.exec_request('key', 'post', key_id=keypar.api_id, v_code=keypar.api_key) logger.debug(ret) else: # remove it from the list so it doesn't get deleted in the last step seat_all_keys.pop(keypar.api_id) if not userinfo: # TODO: should the following be done only for new keys? # Check the key's user status logger.debug("Retrieving user name from Auth's SeAT users database") auth, c = AuthServicesInfo.objects.get_or_create(user=keypar.user) if auth.seat_username: logger.debug("Retrieving user %s info from SeAT users database" % auth.seat_username) userinfo = SeatManager.check_user_status(auth.seat_username) if userinfo: # If the user has activated seat, assign the key to him. logger.debug("Transferring Api Key with ID %s to user %s with ID %s " % (keypar.api_id, auth.seat_username, userinfo['id'])) ret = SeatManager.exec_request('key/transfer/' + keypar.api_id + '/' + userinfo['id'], 'get') logger.debug(ret) if bool(seat_all_keys) & (not user): # remove from SeAT keys that were removed from Auth for key, key_user in seat_all_keys.iteritems(): # Remove the key only if it is an account or character key ret = SeatManager.exec_request('key/'+key, 'get') logger.debug(ret) try: if (ret['info']['type'] == "Account") or (ret['info']['type'] == "Character"): logger.debug("Removing api key %s from SeAT database" % key) ret = SeatManager.exec_request('key' + "/" + key, 'delete') logger.debug(ret) except KeyError: pass
def hr_application_management_view(request): logger.debug("hr_application_management_view called by user %s" % request.user) personal_app = None corp_applications = None if request.user.is_superuser: logger.debug("User %s is superuser: returning all applications." % request.user) corp_applications = HRApplication.objects.all() else: # Get the corp the member is in auth_info = AuthServicesInfo.objects.get(user=request.user) if auth_info.main_char_id != "": try: main_corp_id = EveManager.get_charater_corporation_id_by_id( auth_info.main_char_id) main_alliance_id = EveManager.get_charater_alliance_id_by_id( auth_info.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): main_char = EveCharacter.objects.get( character_id=auth_info.main_char_id) if EveCorporationInfo.objects.filter( corporation_id=main_char.corporation_id).exists(): corp = EveCorporationInfo.objects.get( corporation_id=main_char.corporation_id) corp_applications = HRApplication.objects.filter( corp=corp).filter(approved_denied=None) else: corp_applications = None else: corp_applications = None except: logger.error( "Unable to determine user %s main character id %s corp. Returning no corp hrapplications." % (request.user, auth_info.main_char_id)) corp_applications = None context = { 'personal_apps': HRApplication.objects.all().filter(user=request.user), 'applications': corp_applications, 'search_form': HRApplicationSearchForm() } return render_to_response('registered/hrapplicationmanagement.html', context, 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 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 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 activate_seat(request): logger.debug("activate_seat called by user %s" % request.user) # Valid now we get the main characters character = EveManager.get_main_character(request.user) logger.debug("Checking SeAT for inactive users with the same username") stat = SeatManager.check_user_status(character.character_name) if stat == {}: logger.debug("User not found, adding SeAT user for user %s with main character %s" % (request.user, character)) result = SeatManager.add_user(character.character_name, request.user.email) else: logger.debug("User found, resetting password") username = SeatManager.enable_user(stat["name"]) password = SeatManager.update_user_password(username, request.user.email) result = [username, password] # if empty we failed if result[0] and result[1]: SeatUser.objects.update_or_create(user=request.user, defaults={'username': result[0]}) logger.debug("Updated SeatUser for user %s with SeAT credentials. Adding eve-apis..." % request.user) SeatTasks.update_roles.delay(request.user.pk) logger.info("Successfully activated SeAT for user %s" % request.user) messages.add_message(request, messages.SUCCESS, _('Successfully activated your %(service)s account.') % SERVICE_NAME) SeatManager.synchronize_eveapis(request.user) credentials = { 'username': request.user.seat.username, 'password': result[1], } return render(request, 'registered/service_credentials.html', context={'credentials': credentials, 'service': 'SeAT'}) messages.add_message(request, messages.ERROR, _('Failed to activate your %(service)s account, please contact your administrator.') % SERVICE_NAME) logger.error("Unsuccessful attempt to activate seat for user %s" % request.user) return redirect("auth_services")
def activate_ips4(request): logger.debug("activate_ips4 called by user %s" % request.user) character = EveManager.get_main_character(request.user) logger.debug("Adding IPS4 user for user %s with main character %s" % (request.user, character)) result = Ips4Manager.add_user(character.character_name, request.user.email) # if empty we failed if result[0] != "" and not Ips4Tasks.has_account(request.user): ips_user = Ips4User.objects.create(user=request.user, id=result[2], username=result[0]) logger.debug( "Updated authserviceinfo for user %s with IPS4 credentials." % request.user) # update_ips4_groups.delay(request.user.pk) logger.info("Successfully activated IPS4 for user %s" % request.user) messages.success(request, 'Activated IPSuite4 account.') credentials = { 'username': result[0], 'password': result[1], } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'IPSuite4' }) else: logger.error("Unsuccessful attempt to activate IPS4 for user %s" % request.user) messages.error( request, 'An error occurred while processing your IPSuite4 account.') return redirect("auth_services")
def activate_jabber(request): logger.debug("activate_jabber called by user %s" % request.user) character = EveManager.get_main_character(request.user) 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 "": OpenfireUser.objects.update_or_create(user=request.user, defaults={'username': info[0]}) logger.debug( "Updated authserviceinfo for user %s with jabber credentials. Updating groups." % request.user) OpenfireTasks.update_groups.delay(request.user.pk) logger.info("Successfully activated jabber for user %s" % request.user) messages.success(request, 'Activated jabber account.') credentials = { 'username': info[0], 'password': info[1], } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'Jabber' }) else: logger.error("Unsuccessful attempt to activate jabber for user %s" % request.user) messages.error( request, 'An error occurred while processing your jabber account.') return redirect("auth_services")
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 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 clean(self): super(UpdateKeyForm, self).clean() if 'api_id' in self.cleaned_data and 'api_key' in self.cleaned_data: if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']): logger.debug("UpdateKeyForm failed cleaning as API id %s already exists." % self.cleaned_data['api_id']) raise forms.ValidationError(u'API key already exist') if EveApiManager.api_key_is_valid(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: raise forms.ValidationError(u'API key is invalid') chars = EveApiManager.get_characters_from_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']).result states = [] states.append(self.user_state) for char in chars: evechar = EveCharacter() evechar.character_name = chars[char]['name'] evechar.corporation_id = chars[char]['corp']['id'] evechar.alliance_id = chars[char]['alliance']['id'] state = determine_membership_by_character(evechar) logger.debug("API ID %s character %s has state %s" % (self.cleaned_data['api_id'], evechar, state)) states.append(state) if 'MEMBER' in states: if EveApiManager.validate_member_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: raise forms.ValidationError(u'API must meet member requirements') if 'BLUE' in states: if EveApiManager.validate_blue_api(self.cleaned_data['api_id'], self.cleaned_data['api_key']) is False: raise forms.ValidationError(u'API must meet blue requirements') return self.cleaned_data
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 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 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_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 activate_teamspeak3(request): logger.debug("activate_teamspeak3 called by user %s" % request.user) authinfo = AuthServicesInfo.objects.get(user=request.user) character = EveManager.get_main_character(request.user) ticker = character.corporation_ticker if authinfo.state == BLUE_STATE: logger.debug("Adding TS3 user for blue user %s with main character %s" % (request.user, character)) # Blue members should have alliance ticker (if in alliance) if EveAllianceInfo.objects.filter(alliance_id=character.alliance_id).exists(): alliance = EveAllianceInfo.objects.filter(alliance_id=character.alliance_id)[0] ticker = alliance.alliance_ticker result = Teamspeak3Manager.add_blue_user(character.character_name, ticker) else: logger.debug("Adding TS3 user for user %s with main character %s" % (request.user, character)) result = Teamspeak3Manager.add_user(character.character_name, ticker) # if its empty we failed if result[0] is not "": Teamspeak3User.objects.update_or_create(user=request.user, defaults={'uid': result[0], 'perm_key': result[1]}) logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user) logger.info("Successfully activated TS3 for user %s" % request.user) messages.success(request, 'Activated TeamSpeak3 account.') return redirect("auth_verify_teamspeak3") logger.error("Unsuccessful attempt to activate TS3 for user %s" % request.user) messages.error(request, 'An error occurred while processing your TeamSpeak3 account.') return redirect("auth_services")
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) if not Teamspeak3Tasks.has_account(request.user): return redirect("auth_services") authinfo = AuthServicesInfo.objects.get(user=request.user) character = EveManager.get_main_character(request.user) logger.debug("Deleting TS3 user for user %s" % request.user) Teamspeak3Manager.delete_user(request.user.teamspeak3.uid) if authinfo.state == BLUE_STATE: logger.debug( "Generating new permission key for blue user %s with main character %s" % (request.user, character)) result = Teamspeak3Manager.generate_new_blue_permissionkey(request.user.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(request.user.teamspeak3.uid, character.character_name, character.corporation_ticker) # if blank we failed if result[0] != "": Teamspeak3User.objects.update_or_create(user=request.user, defaults={'uid': result[0], 'perm_key': result[1]}) logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user) Teamspeak3Tasks.update_groups.delay(request.user.pk) logger.info("Successfully reset TS3 permission key for user %s" % request.user) messages.success(request, 'Reset TeamSpeak3 permission key.') else: logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user) messages.error(request, 'An error occurred while processing your TeamSpeak3 account.') return redirect("auth_services")
def reset_teamspeak3_perm(request): logger.debug("reset_teamspeak3_perm called by user %s" % request.user) if not Teamspeak3Tasks.has_account(request.user): return redirect("auth_services") authinfo = AuthServicesInfo.objects.get(user=request.user) character = EveManager.get_main_character(request.user) logger.debug("Deleting TS3 user for user %s" % request.user) with Teamspeak3Manager() as ts3man: ts3man.delete_user(request.user.teamspeak3.uid) if authinfo.state == BLUE_STATE: logger.debug( "Generating new permission key for blue user %s with main character %s" % (request.user, character)) result = ts3man.generate_new_blue_permissionkey(request.user.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 = ts3man.generate_new_permissionkey(request.user.teamspeak3.uid, character.character_name, character.corporation_ticker) # if blank we failed if result[0] != "": Teamspeak3User.objects.update_or_create(user=request.user, defaults={'uid': result[0], 'perm_key': result[1]}) logger.debug("Updated authserviceinfo for user %s with TS3 credentials. Updating groups." % request.user) Teamspeak3Tasks.update_groups.delay(request.user.pk) logger.info("Successfully reset TS3 permission key for user %s" % request.user) messages.success(request, 'Reset TeamSpeak3 permission key.') else: logger.error("Unsuccessful attempt to reset TS3 permission key for user %s" % request.user) messages.error(request, 'An error occurred while processing your TeamSpeak3 account.') return redirect("auth_services")
def clean(self): if EveManager.check_if_api_key_pair_exist(self.cleaned_data['api_id']): raise forms.ValidationError(u'API key already exist') check_blue = False try: check_blue = self.cleaned_data['is_blue'] except: pass if check_blue: if settings.BLUE_API_ACCOUNT: if not EveApiManager.check_api_is_type_account(self.cleaned_data['api_id'], self.cleaned_data['api_key']): raise forms.ValidationError(u'API not of type account') if not EveApiManager.check_blue_api_is_full(self.cleaned_data['api_id'], self.cleaned_data['api_key']): raise forms.ValidationError(u'API supplied is too restricted. Minimum access mask is ' + str(settings.BLUE_API_MASK)) else: if settings.MEMBER_API_ACCOUNT: if not EveApiManager.check_api_is_type_account(self.cleaned_data['api_id'], self.cleaned_data['api_key']): raise forms.ValidationError(u'API not of type account') if not EveApiManager.check_api_is_full(self.cleaned_data['api_id'], self.cleaned_data['api_key']): raise forms.ValidationError(u'API supplied is too restricted. Minimum access mask is ' + str(settings.MEMBER_API_MASK)) return self.cleaned_data
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 reset_smf_password(request): logger.debug("reset_smf_password called by user %s" % request.user) character = EveManager.get_main_character(request.user) if SmfTasks.has_account(request.user) and character is not None: result = SmfManager.update_user_password(request.user.smf.username, character.character_id) # false we failed if result != "": logger.info("Successfully reset smf password for user %s" % request.user) messages.success(request, 'Reset SMF password.') credentials = { 'username': request.user.smf.username, 'password': result, } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'SMF' }) logger.error("Unsuccessful attempt to reset smf password for user %s" % request.user) messages.error(request, 'An error occurred while processing your SMF account.') return redirect("auth_services")
def activate_forum(request): logger.debug("activate_forum called by user %s" % request.user) # Valid now we get the main characters character = EveManager.get_main_character(request.user) logger.debug("Adding phpbb user for user %s with main character %s" % (request.user, character)) result = Phpbb3Manager.add_user(character.character_name, request.user.email, ['REGISTERED'], character.character_id) # if empty we failed if result[0] != "": Phpbb3User.objects.update_or_create(user=request.user, defaults={'username': result[0]}) logger.debug( "Updated authserviceinfo for user %s with forum credentials. Updating groups." % request.user) Phpbb3Tasks.update_groups.delay(request.user.pk) logger.info("Successfully activated forum for user %s" % request.user) messages.success(request, 'Activated forum account.') credentials = { 'username': result[0], 'password': result[1], } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'Forum' }) else: logger.error("Unsuccessful attempt to activate forum for user %s" % request.user) messages.error( request, 'An error occurred while processing your forum account.') return redirect("auth_services")
def reset_forum_password(request): logger.debug("reset_forum_password called by user %s" % request.user) if Phpbb3Tasks.has_account(request.user): character = EveManager.get_main_character(request.user) result = Phpbb3Manager.update_user_password( request.user.phpbb3.username, character.character_id) # false we failed if result != "": logger.info("Successfully reset forum password for user %s" % request.user) messages.success(request, 'Reset forum password.') credentials = { 'username': request.user.phpbb3.username, 'password': result, } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'Forum' }) logger.error("Unsuccessful attempt to reset forum password for user %s" % request.user) messages.error(request, 'An error occurred while processing your forum account.') return redirect("auth_services")
def activate_xenforo_forum(request): logger.debug("activate_xenforo_forum called by user %s" % request.user) character = EveManager.get_main_character(request.user) logger.debug("Adding XenForo user for user %s with main character %s" % (request.user, character)) result = XenForoManager.add_user(character.character_name, request.user.email) # Based on XenAPI's response codes if result['response']['status_code'] == 200: XenforoUser.objects.update_or_create( user=request.user, defaults={'username': result['username']}) logger.info( "Updated user %s with XenForo credentials. Updating groups." % request.user) messages.success(request, 'Activated XenForo account.') credentials = { 'username': result['username'], 'password': result['password'], } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'XenForo' }) else: logger.error("Unsuccessful attempt to activate xenforo for user %s" % request.user) messages.error( request, 'An error occurred while processing your XenForo account.') return redirect("auth_services")
def set_forum_password(request): logger.debug("set_forum_password called by user %s" % request.user) if request.method == 'POST': logger.debug("Received POST request with form.") form = ServicePasswordForm(request.POST) logger.debug("Form is valid: %s" % form.is_valid()) if form.is_valid() and Phpbb3Tasks.has_account(request.user): password = form.cleaned_data['password'] logger.debug("Form contains password of length %s" % len(password)) character = EveManager.get_main_character(request.user) result = Phpbb3Manager.update_user_password( request.user.phpbb3.username, character.character_id, password=password) if result != "": logger.info("Successfully set forum password for user %s" % request.user) messages.success(request, 'Set forum password.') else: logger.error( "Failed to install custom forum password for user %s" % request.user) messages.error( request, 'An error occurred while processing your forum account.') return redirect("auth_services") else: logger.debug("Request is not type POST - providing empty form.") form = ServicePasswordForm() logger.debug("Rendering form for user %s" % request.user) context = {'form': form, 'service': 'Forum'} return render(request, 'registered/service_password.html', context=context)
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 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 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 activate_market(request): logger.debug("activate_market called by user %s" % request.user) character = EveManager.get_main_character(request.user) if character is not None: 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, character.character_id, character.character_name) # if empty we failed if result[0] != "": MarketUser.objects.create(user=request.user, username=result[0]) logger.debug( "Updated authserviceinfo for user %s with market credentials." % request.user) logger.info("Successfully activated market for user %s" % request.user) messages.success(request, 'Activated Alliance Market account.') credentials = { 'username': result[0], 'password': result[1], } return render(request, 'registered/service_credentials.html', context={ 'credentials': credentials, 'service': 'Alliance Market' }) logger.error("Unsuccessful attempt to activate market for user %s" % request.user) messages.error( request, 'An error occurred while processing your Alliance Market account.') return redirect("auth_services")
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 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 update_alliance(id): alliance = EveAllianceInfo.objects.get(alliance_id=id) corps = EveCorporationInfo.objects.filter(alliance=alliance) logger.debug("Updating alliance %s with %s member corps" % (alliance, len(corps))) allianceinfo = EveApiManager.get_alliance_information(alliance.alliance_id) if allianceinfo: EveManager.update_alliance_info(allianceinfo['id'], allianceinfo['executor_id'], allianceinfo['member_count'], alliance.is_blue) for corp in corps: if corp.corporation_id in allianceinfo['member_corps'] is False: logger.info("Corp %s no longer in alliance %s" % (corp, alliance)) corp.alliance = None corp.save() populate_alliance(alliance.alliance_id, blue=alliance.is_blue) elif EveApiManager.check_if_alliance_exists(alliance.alliance_id) is False: logger.info("Alliance %s has closed. Deleting model" % alliance) alliance.delete()
def characters_view(request): logger.debug("characters_view called by user %s" % request.user) render_items = { 'characters': EveManager.get_characters_by_owner_id(request.user.id), 'authinfo': AuthServicesInfo.objects.get_or_create(user=request.user)[0] } return render(request, 'registered/characters.html', context=render_items)
def dashboard_view(request): render_items = { 'characters': EveManager.get_characters_by_owner_id(request.user.id), 'authinfo': AuthServicesInfoManager.get_auth_service_info(request.user) } return render_to_response('registered/dashboard.html', render_items, context_instance=RequestContext(request))