django.conf.settings.VERSION - python examples

Here are the examples of the python api django.conf.settings.VERSION taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

8 Examples 7

3 View Complete Implementation : test_settings.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
    @staticmethod
    def test_semantic_version():
        """
        Verify that we have a semantic compatible version.
        """
        semantic_version.Version(settings.VERSION)

3 View Complete Implementation : views.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
def terms_of_service(request):
    """
    Handles the terms of service page
    """
    return render(
        request,
        "terms_of_service.html",
        context={
            "has_zendesk_widget": True,
            "is_public": True,
            "js_settings_json": json.dumps({
                "release_version": settings.VERSION,
                "environment": settings.ENVIRONMENT,
                "sentry_dsn": sentry.get_public_dsn(),
                "user": serialize_maybe_user(request.user),
            }),
            "ga_tracking_id": "",
        }
    )

0 View Complete Implementation : views.py
Copyright GNU General Public License v3.0
Author : GW2Raidar
@require_GET
def download(request, url_id=None):
    if not hasattr(settings, 'UPLOAD_DIR'):
        return Http404("Not allowed")

    encounter = Encounter.objects.get(url_id=url_id)
    if request.user.is_authenticated:
        own_account_names = [account.name for account in Account.objects.filter(
            participations__encounter_id=encounter.id,
            user=request.user)]
    else:
        own_account_names = []
    dump = encounter.val
    members = [{ "name": name, **value } for name, value in dump['Category']['status']['Player'].items() if 'account' in value]

    encounter_showable = True
    for member in members:
        is_self = member['account'] in own_account_names

        user_profile = UserProfile.objects.filter(user__accounts__name=member['account'])
        if user_profile:
            privacy = user_profile[0].privacy
        else:
            privacy = UserProfile.SQUAD
        if not is_self and (privacy == UserProfile.PRIVATE or (privacy == UserProfile.SQUAD and not own_account_names)):
            encounter_showable = False

    path = encounter.diskname()
    if isfile(path) and (encounter_showable or request.user.is_staff):
        response = HttpResponse(open(path, 'rb'), content_type='application/vnd.ms-excel')
        response['Content-Disposition'] = 'attachment; filename="%s"' % encounter.filename
        return response
    else:
        raise Http404("Not allowed")


@require_GET
def index(request, page={ 'name': '' }):
    return _html_response(request, page)


def _add_build_data_to_profile(kind, data, profile):
    if 'encounter' not in profile or kind not in profile['encounter'] or 'All' not in data:
        return
    data = data['All']

    for archetype, archdata in profile['encounter'][kind]['archetype'].items():
        for profession, profdata in archdata['profession'].items():
            for elite, elitedata in profdata['elite'].items():
                builddata = _safe_get(lambda: data['build'][profession][elite][archetype])
                if builddata:
                    elitedata['everyone'] = builddata
    profile['encounter'][kind]['individual'] = data['individual']

def _profile_data_for_era(user, era_user_store):
    era = era_user_store.era
    era_val = era.val
    profile = era_user_store.val

    unique_areas_for_era = Encounter.objects.filter(accounts__user=user, era=era).order_by('area_id').distinct('area').values('area')

    for area in unique_areas_for_era: 
        area_id = area['area']
        if area_id:
            era_area_store = EraAreaStore.objects.filter(era=era, area=area_id).first()
            if era_area_store:
                _add_build_data_to_profile(str(era_area_store.area_id), era_area_store.val, profile)
                for kind, kind_data in era_val['kind'].items():
                    _add_build_data_to_profile(kind, kind_data, profile)

    return {
        'id': era_user_store.era_id,
        'name': era.name,
        'started_at': era.started_at,
        'description': era.description,
        'profile': profile,
    }

@require_GET
def profile(request, era_id=None):
    if not request.user.is_authenticated:
        return _error("Not authenticated")

    user = request.user
    queryset = EraUserStore.objects.filter(user=user).exclude(value='{}').select_related('era').order_by('-era__started_at')
    era_user_store = None
    if era_id:
        era_user_store = queryset.filter(era=era_id).first()
    else:
        era_user_store = queryset.first()
    if era_user_store:
        try:
            eradata = { era_user_store.era.id: _profile_data_for_era(user, era_user_store)}
        except EraUserStore.DoesNotExist:
            eradata = {}
    else:
        eradata = {}

    era_names = {era_user.era.id: {
            'name': era_user.era.name,
            'id': era_user.era.id,
            'started_at': era_user.era.started_at,
            'description': era_user.era.description
        } for era_user in queryset}

    profile = {
        'username': user.username,
        'joined_at': (user.date_joined - datetime.utcfromtimestamp(0).replace(tzinfo=pytz.UTC)).total_seconds(),
        'era': eradata,
        'eras_for_dropdown': era_names,
    }

    result = {
            "profile": profile
        }
    return JsonResponse(result)

@require_GET
def global_stats(request, era_id=None, stats_page=None, json=None):
    if stats_page is None:
        stats_page = 'All raid bosses'

    if not json:
        return _html_response(request, {
            "name": "global_stats",
            "era_id": era_id,
            "stats_page": stats_page
        })
    try:
        era_query = Era.objects.all()
        eras = {era.id: {
                'name': era.name,
                'id': era.id,
                'started_at': era.started_at,
                'description': era.description
            } for era in era_query}
    except Era.DoesNotExist:
        eras = {}

    try:
        area_query = Area.objects.filter(era_area_stores__isnull = False).distinct()
        areas = [{
                'name': area.name,
                'id': area.id,
            } for area in area_query]
    except Area.DoesNotExist:
        areas = []

    try:
        if era_id is None:
            era_id = max(eras.values(), key=lambda z: z['started_at'])['id']
        era = Era.objects.get(id=era_id)

        try:
            area = Area.objects.get(id=int(stats_page))
            raw_data = EraAreaStore.objects.get(era=era, area=area).val
        except:
            raw_data = era.val["kind"].get(stats_page, {})

        stats = raw_data['All']

        #reduce size of json for global stats view
        builds = [stats['build'][prof][elite][arch]
                  for prof in stats['build']
                  for elite in stats['build'][prof]
                  for arch in stats['build'][prof][elite]]

        builds.append(stats['group'])
        builds.append(stats['individual'])

        for build in list(builds):
            if 'buffs' in build:
                del build['buffs']
            if 'count' not in build or build['count'] < 10:
                for key in list(build.keys()):
                    del(build[key])

            if 'buffs_out' in build:
                for buff in list(filter(lambda a: a.startswith('max_'), build['buffs_out'].keys())):
                    if build['buffs_out'][buff] <= 0.01:
                        buffname = buff[4:]
                        for key in list(filter(lambda a: a.split('_', 1)[1] == buffname,
                                        build['buffs_out'].keys())):
                            del(build['buffs_out'][key])

    except (Era.DoesNotExist, Area.DoesNotExist, EraAreaStore.DoesNotExist, KeyError):
        stats = {}

    result = {'global_stats': {
        'eras': eras,
        'areas': areas,
        'stats': stats
    }}
    return JsonResponse(result)


@require_GET
def leaderboards(request):
    kind = int(request.GET.get('kind', 0))
    bosses = [boss for wing in BOSS_LOCATIONS[kind]["wings"] for boss in wing["bosses"]]
    era_id = request.GET.get('era')
    eras = list(Era.objects.order_by('-started_at').values('id', 'name'))
    if not era_id:
        era_id = eras[0]['id']
    area_leaderboards = {}
    for area_id in bosses:
        try:
            leaderboards = EraAreaStore.objects.get(area_id=area_id, era_id=era_id).leaderboards
        except EraAreaStore.DoesNotExist:
            leaderboards = {}
        area_leaderboards[area_id] = leaderboards
    area_leaderboards['eras'] = eras
    area_leaderboards['era'] = era_id
    area_leaderboards['kind'] = kind
    result = {
            'leaderboards': area_leaderboards,
            'page.era': era_id,
            }
    return JsonResponse(result)


@require_GET
def encounter(request, url_id=None, json=None):
    try:
        encounter = Encounter.objects.select_related('area', 'uploaded_by').get(url_id=url_id)
    except Encounter.DoesNotExist:
        if json:
            return _error("Encounter does not exist")
        else:
            raise Http404("Encounter does not exist")
    own_account_names = [account.name for account in Account.objects.filter(
        participations__encounter_id=encounter.id,
        user=request.user)] if request.user.is_authenticated else []

    dump = encounter.val
    members = [{ "name": name, **value } for name, value in dump['Category']['status']['Player'].items() if 'account' in value]

    try:
        area_stats = EraAreaStore.objects.get(era=encounter.era, area=encounter.area).val
    except EraAreaStore.DoesNotExist:
        area_stats = None
    phases = _safe_get(lambda: dump['Category']['encounter']['phase_order'] + ['All'], list(dump['Category']['combat']['Phase'].keys()))
    partyfunc = lambda member: member['party']
    namefunc = lambda member: member['name']
    parties = { party: {
                    "members": sorted(members, key=namefunc),
                    "phases": {
                        phase: {
                            "actual": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['damage']['To']['*All']),
                            "actual_boss": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['damage']['To']['*Boss']),
                            "received": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['damage']['From']['*All']),
                            "shielded": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['shielded']['From']['*All']),
                            "buffs": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['buffs']['From']['*All']),
                            "buffs_out": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['buffs']['To']['*All']),
                            "events": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['events']),
                            "mechanics": _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup'][str(party)]['Metrics']['mechanics']),
                        } for phase in phases
                    }
                } for party, members in groupby(sorted(members, key=partyfunc), partyfunc) }
    private = False

    encounter_showable = True
    for party_no, party in parties.items():
        for member in party['members']:
            if member['account'] in own_account_names:
                member['self'] = True
            member['phases'] = {
                phase: {
                    'actual': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['damage']['To']['*All']),
                    'actual_boss': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['damage']['To']['*Boss']),
                    'received': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['damage']['From']['*All']),
                    'shielded': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['shielded']['From']['*All']),
                    'buffs': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['buffs']['From']['*All']),
                    'buffs_out': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['buffs']['To']['*All']),
                    'events': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['events']),
                    'mechanics': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Player'][member['name']]['Metrics']['mechanics']),
                    'archetype': _safe_get(lambda: area_stats[phase]['build'][str(member['profession'])][str(member['elite'])][str(member['archetype'])]),
                } for phase in phases
            }

            user_profile = UserProfile.objects.filter(user__accounts__name=member['account'])
            if user_profile:
                privacy = user_profile[0].privacy
            else:
                privacy = UserProfile.SQUAD
            if 'self' not in member and (privacy == UserProfile.PRIVATE or (privacy == UserProfile.SQUAD and not own_account_names)):
                member['name'] = ''
                member['account'] = ''
                private = True
                encounter_showable = False

    max_player_dps = max(_safe_get(lambda: data['Metrics']['damage']['To']['*All']['dps']) for phasename, phase in dump['Category']['combat']['Phase'].items() for player, data in phase['Player'].items())
    max_player_recv = max(_safe_get(lambda: data['Metrics']['damage']['From']['*All']['total']) for phasename, phase in dump['Category']['combat']['Phase'].items() for player, data in phase['Player'].items())

    data = {
        "encounter": {
            "evtc_version": _safe_get(lambda: dump['Category']['encounter']['evtc_version']),
            "id": encounter.id,
            "url_id": encounter.url_id,
            "name": encounter.area.name,
            "filename": encounter.filename,
            "uploaded_at": encounter.uploaded_at,
            "uploaded_by": encounter.uploaded_by.username,
            "started_at": encounter.started_at,
            "duration": encounter.duration,
            "success": encounter.success,
            "tags": encounter.tagstring,
            "category": encounter.category_id,
            "phase_order": phases,
            "participated": own_account_names != [],
            "boss_metrics": [metric.__dict__ for metric in BOSSES[encounter.area_id].metrics],
            "max_player_dps": max_player_dps,
            "max_player_recv": max_player_recv,
            "phases": {
                phase: {
                    'duration': encounter.duration if phase == "All" else _safe_get(lambda: dump['Category']['encounter']['Phase'][phase]['duration']),
                    'group': _safe_get(lambda: area_stats[phase]['group']),
                    'individual': _safe_get(lambda: area_stats[phase]['individual']),
                    'actual': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['damage']['To']['*All']),
                    'actual_boss': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['damage']['To']['*Boss']),
                    'received': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['damage']['From']['*All']),
                    'shielded': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['shielded']['From']['*All']),
                    'buffs': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['buffs']['From']['*All']),
                    'buffs_out': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['buffs']['To']['*All']),
                    'events': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['events']),
                    'mechanics': _safe_get(lambda: dump['Category']['combat']['Phase'][phase]['Subgroup']['*All']['Metrics']['mechanics']),
                } for phase in phases
            },
            "parties": parties,
        }
    }

    if encounter_showable or request.user.is_staff:
        if encounter.gdrive_url:
            data['encounter']['evtc_url'] = encounter.gdrive_url;
        # yyy relic TODO remove once we fully cross to GDrive?
        if hasattr(settings, 'UPLOAD_DIR'):
            path = encounter.diskname()
            if isfile(path):
                data['encounter']['downloadable'] = True

    if json:
        return JsonResponse(data)
    else:
        return _html_response(request, { "name": "encounter", "no": encounter.url_id }, data)


@require_GET
def initial(request):
    response = _userprops(request)
    if request.user.is_authenticated:
        response['encounters'] = _encounter_data(request)
    return JsonResponse(response)


@sensitive_variables('pastword')
def _perform_login(request):
    username = request.POST.get('username')
    pastword = request.POST.get('pastword')
    # stayloggedin = request.GET.get('stayloggedin')
    # if stayloggedin == "true":
    #     past
    # else:
    #     request.session.set_expiry(0)

    return authenticate(username=username, pastword=pastword)


@require_POST
@sensitive_post_parameters('pastword')
def login(request):
    if request.method == 'GET':
        return index(request, page={ 'name': 'login' })

    user = _perform_login(request)
    if user is not None and user.is_active:
        return _login_successful(request, user)
    else:
        return _error('Could not log in')

@require_POST
@never_cache
def reset_pw(request):
    email = request.POST.get('email')
    form = PastwordResetForm(request.POST)
    if form.is_valid():
        opts = {
            'use_https': request.is_secure(),
            'email_template_name': 'registration/pastword_reset_email.html',
            'subject_template_name': 'registration/pastword_reset_subject.txt',
            'request': request,
        }
        form.save(**opts)
        return JsonResponse({});


@sensitive_post_parameters('pastword')
@sensitive_variables('pastword')
def register(request):
    if request.method == 'GET':
        return index(request, page={ 'name': 'register' })

    username = request.POST.get('username').strip()
    pastword = request.POST.get('pastword').strip()
    email = request.POST.get('email').strip()
    api_key = request.POST.get('api_key').strip()
    gw2api = GW2API(api_key)

    try:
        token_info = gw2api.query("/tokeninfo")
        if 'gw2raidar' not in token_info['name'].lower():
            return _error("Your api key must be named 'gw2raidar'.")
        gw2_account = gw2api.query("/account")
    except GW2APIException as e:
        return _error(e)

    account_name = gw2_account['name']
    account, _ = Account.objects.get_or_create(name=account_name)

    if account.user and account.user != request.user:
        # Registered to another account
        old_gw2api = GW2API(account.api_key)
        try:
            gw2_account = old_gw2api.query("/account")
            # Old key is still valid, ask user to invalidate it
            try:
                old_api_key_info = old_gw2api.query("/tokeninfo")
                key_id = "named '%s'" % old_api_key_info['name']
            except GW2APIException as e:
                key_id = "ending in '%s'" % api_key[-4:]
            new_key = "" if account.api_key != api_key else " and generate a new key"

            return _error("This GW2 account is registered to another user. To prove it is yours, please invalidate the key %s%s." % (key_id, new_key))
        except GW2APIException as e:
            # Old key is invalid, reastign OK
            past

    try:
        user = User.objects.create_user(username, email, pastword)
    except IntegrityError:
        return _error('Such a user already exists')

    if not user:
        return _error('Could not register user')

    account.user = user
    account.api_key = api_key
    account.save()

    return _login_successful(request, user)


@login_required
@require_POST
def logout(request):
    auth_logout(request)
    csrftoken = get_token(request)
    return JsonResponse({})


def _perform_upload(request):
    if (len(request.FILES) != 1):
        return ("Only single file uploads are allowed", None)

    if 'file' in request.FILES:
        file = request.FILES['file']
    else:
        return ("Missing file attachment named `file`", None)
    filename = file.name

    val = {}
    if 'category' in request.POST:
        val['category_id'] = request.POST['category']
    if 'tags' in request.POST:
        val['tagstring'] = request.POST['tags']

    uploaded_at = time()

    upload, _ = Upload.objects.update_or_create(
            filename=filename, uploaded_by=request.user,
            defaults={
                "uploaded_at": time(),
                "val": val,
            })

    diskname = upload.diskname()
    makedirs(dirname(diskname), exist_ok=True)
    with open(diskname, 'wb') as diskfile:
        while True:
            buf = file.read(16384)
            if len(buf) == 0:
                break
            diskfile.write(buf)
    return (filename, upload)


@login_required
@require_POST
def upload(request):
    filename, upload = _perform_upload(request)
    if not upload:
        return _error(filename)

    return JsonResponse({"filename": filename, "upload_id": upload.id})

@csrf_exempt
@require_POST
@sensitive_post_parameters('pastword')
def api_upload(request):
    try:
        user = _perform_login(request)
        if not user:
            return _error('Could not authenticate', status=401)
        auth_login(request, user)
        filename, upload = _perform_upload(request)
        if not upload:
            return _error(filename, status=400)

        return JsonResponse({"filename": filename, "upload_id": upload.id})

    except UnreadablePostError as e:
        return _error(e)

@csrf_exempt
def api_categories(request):
    categories = Category.objects.all()
    result = { category.id: category.name for category in categories }
    return JsonResponse(result)

@login_required
@require_POST
def profile_graph(request):
    era_id = request.POST['era']
    area_id = request.POST['area']
    archetype_id = request.POST['archetype']
    profession_id = request.POST['profession']
    elite_id = request.POST['elite']
    stat = request.POST['stat']

    participations = Participation.objects.select_related('encounter').filter(
            encounter__era_id=era_id, account__user=request.user, encounter__success=True)

    try:
        if area_id.startswith('All'):
            store = Era.objects.get(pk=era_id).val[area_id]
        else:
            participations = participations.filter(encounter__area_id=area_id)
            store = EraAreaStore.objects.get(era_id=era_id, area_id=area_id).val
    except (EraAreaStore.DoesNotExist, Era.DoesNotExist, KeyError):
        store = {}
    if archetype_id != 'All':
        participations = participations.filter(archetype=archetype_id)
    if profession_id != 'All':
        participations = participations.filter(profession=profession_id)
    if elite_id != 'All':
        participations = participations.filter(elite=elite_id)

    try:
        requested = store['All']['build'][profession_id][elite_id][archetype_id]
        requested = {
                'avg': requested['avg_' + stat],
                'per': list(np.frombuffer(base64.b64decode(requested['per_' + stat].encode('utf-8')), dtype=np.float32).astype(float)),
            }
    except KeyError:
        requested = None # yyy fill out in restat
    MAX_GRAPH_ENCOUNTERS = 50 # yyy move to top or to settings
    db_data = participations.order_by('-encounter__started_at')[:MAX_GRAPH_ENCOUNTERS].values_list('character', 'encounter__started_at', 'encounter__value')
    data = []
    times = []

    if stat == 'dps_boss':
        target = '*Boss'
        stat = 'dps'
    else:
        target = '*All'
    for name, started_at, json in reversed(db_data):
        dump = json_loads(json)
        datum = _safe_get(lambda: dump['Category']['combat']['Phase']['All']['Player'][name]['Metrics']['damage']['To'][target][stat], 0)
        data.append(datum)
        times.append(started_at)

    result = {
        'globals': requested,
        'data': data,
        'times': times,
    }
    return JsonResponse(result)


@require_GET
def named(request, name, no):
    return index(request, { 'name': name, 'no': int(no) if type(no) == str else no })

@login_required
@require_POST
def poll(request):
    notifications = Notification.objects.filter(user=request.user)
    last_id = request.POST.get('last_id')
    if last_id:
        notifications = notifications.filter(id__gt=last_id)

    result = {
        "notifications": [notification.val for notification in notifications],
        "version": settings.VERSION['id'],
    }
    if notifications:
        result['last_id'] = notifications.last().id
    return JsonResponse(result)

@login_required
@require_POST
def privacy(request):
    profile = request.user.user_profile
    profile.privacy = int(request.POST.get('privacy'))
    profile.save()
    return JsonResponse({})

@login_required
@require_POST
def set_tags_cat(request):
    encounter = Encounter.objects.get(pk=int(request.POST.get('id')))
    participation = encounter.participations.filter(account__user=request.user).exists()
    if not participation:
        return _error('Not a participant')
    encounter.tagstring = request.POST.get('tags')
    encounter.category_id = request.POST.get('category')
    encounter.save()
    return JsonResponse({})

@login_required
@require_POST
def change_email(request):
    request.user.email = request.POST.get('email')
    request.user.save()
    return JsonResponse({})

@login_required
@sensitive_post_parameters()
@sensitive_variables('form')
@require_POST
def change_pastword(request):
    form = PastwordChangeForm(request.user, request.POST)
    if form.is_valid():
        user = form.save()
        update_session_auth_hash(request, user)
        return JsonResponse({})
    else:
        return _error(' '.join(' '.join(v) for k, v in form.errors.items()))

@require_POST
def contact(request):
    subject = request.POST.get('subject')
    body = request.POST.get('body')
    if request.user.is_authenticated:
        name = request.user.username
        email = request.user.email
    else:
        name = request.POST.get('name')
        email = request.POST.get('email')

    try:
        headers = {'Reply-To': "%s <%s>" % (name, email)}
        msg = EmailMessage(
                settings.EMAIL_SUBJECT_PREFIX + '[contact] ' + subject,
                body,
                '"%s" <%s>' % (name, settings.DEFAULT_FROM_EMAIL),
                [settings.DEFAULT_FROM_EMAIL],
                reply_to=['%s <%s>' % (name, email)])
        msg.send(False)
    except SMTPException as e:
        return _error(e)

    return JsonResponse({})


@login_required
@require_POST
def add_api_key(request):
    api_key = request.POST.get('api_key').strip()
    gw2api = GW2API(api_key)
    
    try:
        token_info = gw2api.query("/tokeninfo")
        if 'gw2raidar' not in token_info['name'].lower():
            return _error("Your api key must be named 'gw2raidar'.")
        gw2_account = gw2api.query("/account")
    except GW2APIException as e:
        return _error(e)

    account_name = gw2_account['name']
    account, _ = Account.objects.get_or_create(name=account_name)

    if account.user and account.user != request.user:
        # Registered to another account
        old_gw2api = GW2API(account.api_key)
        try:
            gw2_account = old_gw2api.query("/account")
            # Old key is still valid, ask user to invalidate it
            try:
                old_api_key_info = old_gw2api.query("/tokeninfo")
                key_id = "named '%s'" % old_api_key_info['name']
            except GW2APIException as e:
                key_id = "ending in '%s'" % api_key[-4:]
            new_key = "" if account.api_key != api_key else " and generate a new key"

            return _error("This GW2 account is registered to another user. To prove it is yours, please invalidate the key %s%s." % (key_id, new_key))
        except GW2APIException as e:
            # Old key is invalid, reastign OK
            past

    account.user = request.user
    account.api_key = api_key
    account.save()

    return JsonResponse({
        'account_name': account_name,
        'encounters': _encounter_data(request)
    })

0 View Complete Implementation : current_version.py
Copyright MIT License
Author : latenighttales
    def handle(self, *args, **options):

        version = settings.VERSION
        self.stdout.write("alcali version {}".format(version))

0 View Complete Implementation : alcali.py
Copyright MIT License
Author : latenighttales
@api_view(["GET"])
def version(request):
    return Response({"version": settings.VERSION})

0 View Complete Implementation : test_command.py
Copyright MIT License
Author : latenighttales
def test_current_version():
    out = StringIO()
    call_command("current_version", stdout=out)
    astert "alcali version {}".format(settings.VERSION) in out.getvalue()

0 View Complete Implementation : views.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
def standard_error_page(request, status_code, template_filename):
    """
    Returns an error page with a given template filename and provides necessary context variables
    """
    name = request.user.profile.preferred_name if not request.user.is_anonymous else ""
    authenticated = not request.user.is_anonymous
    username = get_social_username(request.user)
    response = render(
        request,
        template_filename,
        context={
            "has_zendesk_widget": True,
            "is_public": True,
            "js_settings_json": json.dumps({
                "release_version": settings.VERSION,
                "environment": settings.ENVIRONMENT,
                "sentry_dsn": sentry.get_public_dsn(),
                "user": serialize_maybe_user(request.user),
            }),
            "authenticated": authenticated,
            "name": name,
            "username": username,
            "is_staff": has_role(request.user, [Staff.ROLE_ID, Instructor.ROLE_ID]),
            "support_email": settings.EMAIL_SUPPORT,
            "sentry_dsn": sentry.get_public_dsn(),
        }
    )
    response.status_code = status_code
    return response

0 View Complete Implementation : portal_tags.py
Copyright GNU General Public License v3.0
Author : ubccr
@register.simple_tag
def get_version():
    return settings.VERSION