Example #1
0
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)
Example #2
0
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)
Example #3
0
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))
Example #4
0
    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)
Example #5
0
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))
Example #6
0
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))
Example #7
0
    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
Example #8
0
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')
Example #9
0
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')
Example #10
0
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()    
Example #11
0
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()    
Example #12
0
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")
Example #13
0
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")
Example #14
0
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)
Example #15
0
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)
Example #16
0
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})
Example #17
0
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'
Example #18
0
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")
Example #19
0
    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
Example #20
0
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))
Example #21
0
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})
Example #22
0
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)
Example #23
0
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")
Example #24
0
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("/")
Example #25
0
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")
Example #26
0
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")
Example #27
0
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")
Example #28
0
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")
Example #29
0
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")
Example #30
0
    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
Example #31
0
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)
Example #32
0
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")
Example #33
0
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)
Example #34
0
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")
Example #35
0
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")
Example #36
0
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))
Example #37
0
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")
Example #38
0
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")
Example #39
0
    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
Example #40
0
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("/")
Example #41
0
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")
Example #42
0
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")
Example #43
0
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")
Example #44
0
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")
Example #45
0
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)
Example #46
0
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))
Example #47
0
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))
Example #48
0
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))
Example #49
0
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")
Example #50
0
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))
Example #51
0
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))
Example #52
0
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()
Example #53
0
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)
Example #54
0
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))