Пример #1
0
def login_forwarding(request, log_out=False):
    """
    login requested
    """
    if not valid_token(request):
        return token_splash_page(request)

    extra = {}
    extra.update({'title' : _('Login')})
    if "savedphrase" in extra:
        del extra["savedphrase"]
    if "just_logged_out" in extra:
        del extra["just_logged_out"]
    if "captchaerror" in extra:
        del extra["captchaerror"]
    if log_out:
        extra.update({'title' : _('You have been logged out.')})
        extra.update({'just_logged_out' : True })
    if request.method == "POST":
        # Split loginphrase in username and password. Also adds a flag to the
        # session so we can see which type of login was used.
        request.POST = loginphrase2username_password(request)
        if "captcha" in extra:
            del extra["captcha"]
    return django_login(request, extra_context=extra)
Пример #2
0
def delete_forwarding(request):
    """
    account deletion requested
    """
    if not valid_token(request):
        return token_splash_page(request)
    return delete(request)
Пример #3
0
def delete_confirm_forwarding(request):
    """
    forwarding on delete confirm request
    """
    if not valid_token(request):
        return token_splash_page(request)
    return delete_confirm(request)
Пример #4
0
def register(request):
    """Allows someone to register for the service"""
    if not valid_token(request):
        return token_splash_page(request)

    template_vars = {}
    template_path = 'registration/register.html'
    set_register_vars(request, template_vars)
    return render_to_response(template_path, template_vars,
                              context_instance=RequestContext(request))
Пример #5
0
def faq(request):
    """show faq page"""
    if not valid_token(request):
        return token_splash_page(request)

    template_path = 'content/faq.html'
    template_vars = {}
    return render_to_response(
        template_path, template_vars,
        context_instance=RequestContext(request)
    )
Пример #6
0
def get_new_captcha(request):
    """get new captcha image"""
    if not valid_token(request):
        return token_splash_page(request)

    invalidate_captcha(request)
    form = CaptchaTestForm()
    new_form = ""
    for field in form:
        new_form += str(field)
    return HttpResponse (new_form)
Пример #7
0
def logout_forwarding(request):
    """
    logout requested
    """
    if not valid_token(request):
        return token_splash_page(request)

    log_out = request.user.is_authenticated()
    if request.user.is_authenticated():
        auth_logout(request)
    return login_forwarding(request, log_out)
Пример #8
0
def membership(request):
    """show info about project membership"""
    if not valid_token(request):
        return token_splash_page(request)

    template_path = 'content/membership.html'
    template_vars = {}
    return render_to_response(
        template_path, template_vars,
        context_instance=RequestContext(request)
    )
Пример #9
0
def select_lang(request):
    """select language request"""
    if not valid_token(request):
        return token_splash_page(request)

    template_vars = {}
    template_vars['title'] = __('Select language')
    template_vars['previouspage'] = get_redirect_url(request)
    template_path = 'i18n/setlang.html'

    return render_to_response(template_path, template_vars,
                              context_instance=RequestContext(request))
Пример #10
0
def no_authenticated_user(request):
    """
    This page is shown if a user logs in but his Profile is not finished
    with being encrypted.
    """
    if not valid_token(request):
        return token_splash_page(request)

    template_path = 'not_yet_encrypted.html'
    template_vars = {}
    return render_to_response(template_path, template_vars,
                              context_instance=RequestContext(request))
Пример #11
0
def new_submit(request):
    """
    A new user submits their registration here
    """
    if not valid_token(request):
        return token_splash_page(request)

    if request.method == "POST":
        tpl_path, tpl_vars, _ = new_user(request, True)
        return render_to_response(
            tpl_path, tpl_vars,
            context_instance=RequestContext(request)
        )
    else:
        return register(request)
Пример #12
0
def delete(request, password_error=False):
    """
    account deletion
    """
    if not valid_token(request):
        return token_splash_page(request)

    if request.method == "GET" or password_error:
        template_path = 'registration/delete.html'
        template_vars = {}
        template_vars['title'] = _('Delete Profile')
        template_vars['passworderror'] = password_error
        return render_to_response(template_path, template_vars,
                                  context_instance=RequestContext(request))
    else:
        return delete_confirm(request)
Пример #13
0
def i18n_forwarding(request):
    """select display language"""
    if not valid_token(request):
        return token_splash_page(request)

    if request.user.is_authenticated():
        user_profile = request.user.get_profile()
        restore_profile_from_session(request, user_profile)
        old_lang = user_profile.display_language
        lang_code = request.POST.get('language', None)
        if lang_code and check_for_language(lang_code):
            user_profile.display_language = lang_code

        if old_lang != user_profile.display_language:
            user_profile.notify_mailmanager (
                user_profile.email,user_profile.email
            )
        user_profile.save()
        request.session["display_language"] = user_profile.display_language
    return i18n.set_language(request)
Пример #14
0
def validate_captcha(request):
    """validate captcha"""
    if not valid_token(request):
        return token_splash_page(request)
  
    # extract captcha data from request
    test = deepcopy(request.POST)
    cid = request.GET.get("captchaid", "")
    ctext = request.GET.get("captchatext", "")
    test.__setitem__('captcha_0', cid)
    test.__setitem__('captcha_1', ctext)

    captcha_form = CaptchaTestForm (test)
    
    if not captcha_form.is_valid():
        invalidate_captcha(request)
        return HttpResponse("fail")
    else:
        save_valid_captcha(request)
        return HttpResponse("win")
Пример #15
0
def home(request):
    """show home page"""
    if not valid_token(request):
        return token_splash_page(request)

    # copied from i18n - required to give users their language
    # after entering a token
    if request.method == 'POST':
        next_page = request.REQUEST.get('next', None)
        if not next_page:
            next_page = request.META.get('HTTP_REFERER', None)
        if not next_page:
            next_page = '/'
        response = http.HttpResponseRedirect(next_page)
        # give users the token which they have just entered as a cookie
        if not has_valid_token_cookie(request):
            response.set_cookie(
                "prj_token", value=request.POST.get('token', None),
                secure = settings.SESSION_COOKIE_SECURE,
                httponly = settings.SESSION_COOKIE_HTTPONLY)
        lang_code = request.POST.get('language', None)
        if lang_code and check_for_language(lang_code):
            if hasattr(request, 'session'):
                request.session['django_language'] = lang_code
            else:
                response.set_cookie(
                    settings.LANGUAGE_COOKIE_NAME, value=lang_code, 
                    secure = settings.SESSION_COOKIE_SECURE,
                    httponly = settings.SESSION_COOKIE_HTTPONLY)
    else:
        template_path = 'content/index.html'
        template_vars = {'title' : _('Welcome to STIGMERGY!'), 'quote' : True}
        response = render_to_response(
            template_path, template_vars,
            context_instance=RequestContext(request)
        )

    return response
Пример #16
0
def delete_confirm(request):
    """
    confirm a delete request
    """
    if not valid_token(request):
        return token_splash_page(request)

    if request.POST.has_key('yes'):
        login_phrase = request.POST.get("password","")
        password = get_password_from_loginphrase(login_phrase)
        if request.user.check_password(password):
            template_path = 'registration/delete_confirm.html'
            template_vars = {}
            template_vars['title'] = _('Profile Deleted')
            user = request.user
            auth_logout(request)
            user.prj_delete()
            return render_to_response(template_path, template_vars,
                                      context_instance=RequestContext(request))
        else:
            return delete(request, password_error=_("Wrong password."))
    else:
        return redirect('/')
Пример #17
0
def user_forwarding(request, friend_id):
    """friend profile request"""
    if not valid_token(request):
        return token_splash_page(request)
    return user(request, friend_id)
Пример #18
0
def profile_forwarding(request):
    """Own profile pages"""
    if not valid_token(request):
        return token_splash_page(request)
    return profile(request)
Пример #19
0
def user(request, friend_id):
    """show friend profile"""
    if not valid_token(request):
        return token_splash_page(request)

    template_vars = {}
    user_ = request.user
    profile_ = user.get_profile()
    restore_profile_from_session(request, profile_)
    local_friends = profile_.friend_list(request.session, friend_type="local")
    remote_friends = profile_.friend_list(request.session, friend_type="remote")

    template_vars['user'] = user_
    template_vars['profile'] = profile_
    template_vars['localFriends'] = local_friends
    template_vars['remoteFriends'] = remote_friends
    template_vars['friend_id'] = friend_id

    found = False
    friend = None
    for frnd in local_friends:
        if frnd.profile.id == friend_id:
            template_vars['friend'] = frnd
            friend = frnd
            found = True
            friend_type = "local"
            break
    if not found:
        for i, frnd in enumerate(remote_friends):
            if frnd.profile.id == friend_id:
                template_vars['match_lang'] = profile.get_global_token(i)
                template_vars['friend'] = frnd
                friend = frnd
                found = True
                friend_type = "global"
                break
      
    if not found and friend_id == profile.id:
        class XFriend(object):
            """temporary friend class"""
            def __init__(self, prf):
                """init xfriend instance"""
                self.profile = prf
        me_as_friend = XFriend(profile_)
        template_vars['ownPage'] = True
        template_vars['friend'] = me_as_friend
        friend_type = choice(["global", "local"])
        friend = me_as_friend
        found = True

    if found:
        template_vars['uniqueLanguages'] = friend.profile.getUniqueLanguages()
        template_vars['ownUniqueLanguages'] = profile_.getUniqueLanguages()

        template_path = 'user/user_found.html'
        template_vars['title'] = __('Friend') + ' ' + \
            friend.profile.human_public_name()
        template_vars['use_maps_single'] = True
        template_vars['friendType'] = friend_type
        template_vars['cityDict'] = {
           'latitude' : friend.profile.latitude,
           'longitude' : friend.profile.longitude,
        }
    else:
        template_vars['title'] = \
            __('Friend %(friend_id)s not found') % {'friend_id' : friend_id}
        template_path = 'user/user_not_found.html'

    return render_to_response(
        template_path, template_vars,
        context_instance=RequestContext(request)
    )
Пример #20
0
def drop_friend_forwarding(request):
    """drop request"""
    if not valid_token(request):
        return token_splash_page(request)
    return drop_friend(request)
Пример #21
0
def drop_friend(request):
    """drop contact"""
    if not valid_token(request):
        return token_splash_page(request)
Пример #22
0
def new_login(request):
    """ 
    Careful - this function does not use django's login/logout functions
    intelligently. Bugs are likely to arise from here.
    """
    if not valid_token(request):
        return token_splash_page(request)

    if match(settings.ID_REGEX, request.user.username):
        # the user already has the new passphrase. Don't let him change it.
        return HttpResponseRedirect(reverse('user.views.profileForwarding'))

    template_path = 'registration/new_login.html'
    template_vars = {}
    template_vars['title'] = _('IMPORTANT')

    # Restore the user's session. If he tries to visit any other page,
    # he will remain logged out.
    if "savedSession" in request.session:
        for key, value in request.session["savedSession"].items(): 
            request.session[key] = value
        if SESSION_KEY in request.session:
            request.user = User.objects.get(id=request.session[SESSION_KEY])
        del request.session["savedSession"]
    user = request.user

    # Don't let people visit this page without logging in.
    # Copied from django.contrib.auth.decorators.user_passes_test
    if not user.is_authenticated():
        login_url = None
        path = request.build_absolute_uri()
        # If the login url is the same scheme and net location then just
        # use the path as the "next" url.
        login_scheme, login_netloc = urlparse.urlparse(login_url or
                                                       settings.LOGIN_URL)[:2]
        current_scheme, current_netloc = urlparse.urlparse(path)[:2]
        if ((not login_scheme or login_scheme == current_scheme) and
            (not login_netloc or login_netloc == current_netloc)):
            path = request.get_full_path()
        return redirect_to_login(path, login_url, REDIRECT_FIELD_NAME)

    user_profile = user.get_profile()
    if request.method == "POST":
        loginphrase_entered = request.POST.get("loginphrase","").upper()
        loginphrase = request.session.get("temploginphrase","")
        if loginphrase_entered == loginphrase:
            # The user received the passphrase and has hopefully written it
            # down. Because now we are changing his credentials.
            user.username = user_profile.id
            password = get_password_from_loginphrase(loginphrase)
            encrypt_unencrypted_profile(user_profile, password)
            user.email = user_profile.get_anonymous_email()
            user.set_password(password)
            user.save()
            populate_session(request, password)
            return HttpResponseRedirect(
                reverse('user.views.profileForwarding')
            )

    loginphrase = user_profile.generateNewLoginPhrase()
    template_vars['loginphrase'] = loginphrase
    request.session['temploginphrase'] = loginphrase

    # Delete the user's session: Stop the user from going to his profile pages
    # before he has entered the passphrase.
    saved_session = {}
    for key, value in request.session._session.items(): 
        saved_session[key] = value
    auth_logout(request)
    request.session["savedSession"] = saved_session
    template_vars['savedSession'] = saved_session

    return render_to_response(template_path, template_vars,
                              context_instance=RequestContext(request))
Пример #23
0
def edit(request, clicked):
    """edit profile"""
    if not valid_token(request):
        return token_splash_page(request)

    template_vars = {}
    if request.method == "POST":
        loginphrase = request.POST.get("password","")
        password = get_password_from_loginphrase(loginphrase)
        if request.user.check_password(password):
            if edit_captcha_ok(request):
                validation_errors =  contactinfo_errors(request) or \
                                     aboutme_errors(request) or \
                                     location_errors(request) or \
                                     language_errors(request) or \
                                     email_errors(request) or None
                if validation_errors:
                    validation_errors = ([contactinfo_errors(request)] + \
                                         [aboutme_errors(request)] + \
                                         [location_errors(request)] + \
                                         [language_errors(request)] + \
                                         [email_errors(request)])
                    for val_error in validation_errors:
                        if val_error is not None:
                            template_vars[val_error[-1]] = val_error[2]
                else:
                    save_edited_info(request)
                    # Get the newly encrypted data into the session again
                    populate_session(request, password)
                    return HttpResponseRedirect(
                        reverse('user.views.profile_forwarding')
                    )
            else:
                template_vars["captchaerror"] = True
                template_vars["captcha"] = CaptchaTestForm(request.POST)
        else:
            template_vars["passworderror"] = __("Wrong passphrase.")
    else:
        if edit_needs_captcha(request):
            template_vars["captcha"] = CaptchaTestForm()
            
    template_vars['contact_info'] = request.POST.get("contact_info", False)
    template_vars['about_me'] = request.POST.get("about_me", False)
    template_vars['email'] = request.POST.get("email", False)
    template_vars['user'] = request.user
    profile_ = request.user.get_profile()
    restore_profile_from_session(request, profile_)
    template_vars['profile'] = profile_

    for num, lang in enumerate(profile_.get_langs_spoken()):
        template_vars['lang_'+str(num)] = \
            request.POST.get("lang_" + str(num), lang)

    template_vars['use_maps_single'] = True
    template_vars['cityDict'] = {
        'latitude' : request.POST.get("latitude", profile_.latitude),
        'longitude' : request.POST.get("longitude", profile_.longitude),
    }
    template_vars["clicked"] = clicked
    template_vars['title'] = __('Edit the information about you')
    template_path = "user/edit_profile.html"

    return render_to_response(template_path, template_vars,
                              context_instance=RequestContext(request))
Пример #24
0
def profile(request):
    """show profile"""
    if not valid_token(request):
        return token_splash_page(request)

    user_ = request.user
    profile_ = user_.get_profile()
    restore_profile_from_session(request, profile_)

    # show the page in the user's language
    response = display_in_native_language(request, profile_)
    if response:
        return response

    template_path = 'user/profile.html'
    template_vars = {}
    template_vars['title'] = __('My Profile')

    if request.method == "POST":
        if settings.VERBOSE:
            print "POST on the profile. this is a Drop-attempt"
        password = request.POST.get("loginphrase", "")
        dropped_fid = request.POST.get('dropped_fid', None)
        reason = request.POST.get('reason', "")
        comment = request.POST.get('comment', "")
        reason_map = {
            "unresponsive":"nice",
            "differences":"middle",
            "rude":"bad",
        }
        if settings.VERBOSE:
            print "Trying to drop %s for reason %s with comment\n%s" \
                % (dropped_fid, reason, comment)

        if user.check_password(password):
            if dropped_fid is not None and reason in reason_map:
                reason = reason_map[reason]
                dropped = profile_.defriend(dropped_fid, reason, comment)
                if dropped:
                    populate_session(request, password)
                    if dropped_fid in request.session:
                        del request.session[dropped_fid]
                    template_vars['droppedFriend'] = dropped_fid
                    template_vars['message'] = \
                        __('Your contact has been dropped. '
                            'We will find you another one soon.')
                    if settings.VERBOSE:
                        print "Drop successful."

        elif settings.VERBOSE:
            print "Drop failed: Wrong password"

    template_vars['user'] = user_
    template_vars['profile'] = profile_
    template_vars['localFriends'] = \
        profile_.friend_list(request.session, friend_type="local") + \
        request.session.get("display_local", [])
    template_vars['remoteFriends'] = \
        profile_.friend_list(request.session, friend_type="remote") + \
        request.session.get("display_remote", [])
    template_vars['ownUniqueLanguages'] = \
        set(profile_.get_unique_languages())
    template_vars['newFriends'] = request.session.get("new_friends", [])
    template_vars['use_maps_multiple'] = True

    if request.session.get("changes_saved", False):
        template_vars['success_message'] = __("Changes saved.")
        del request.session['changes_saved']

    if settings.VERBOSE:
        print "============SESSION DUMP============"
        for key, value in request.session.items():
            print key, smart_str(value)

    return render_to_response(
        template_path, template_vars,
        context_instance=RequestContext(request)
    )
Пример #25
0
def edit_forwarding(request, clicked):
    """edit profile request"""
    if not valid_token(request):
        return token_splash_page(request)

    return edit(request, clicked)