def proxied_invited_signup( request, invite, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None ): # request.user is the user who has invited / authorized the signup if success_url is None: success_url = get_default_redirect(request) display_name = "Visitor" sponsor = request.user # the actual user who authorized this acceptance if request.method == "POST": form = form_class(request.POST) if form.is_valid(): username = form.cleaned_data["username"] password = form.cleaned_data["password1"] invite.invited.become_member(username, accepted_by=sponsor, password=password) user = authenticate(username=username, password=password) auth_login(request, user) user.message_set.create( message=ugettext("Successfully logged in as %(username)s.") % {"username": user.username} ) # Now, what happens if this invite came with a group? if invite.group: group = secure_wrap(invite.group, sponsor) group.add_member(user) return HttpResponseRedirect(success_url) else: form = form_class() applicant = invite.invited if applicant: form.data["email_address"] = applicant.email_address form.data["first_name"] = "" form.data["last_name"] = "" form.data["username"] = "" display_name = "" else: form.email_address = "" form.username = "" request.user = request.old_user return render_to_response( template_name, {"form": form, "submit_url": request.build_absolute_uri(), "display_name": display_name}, context_instance=RequestContext(request), )
def profile_field(request, other_user, classname, fieldname, *args, **kwargs) : """ Get the value of one field from the user profile, so we can write an ajaxy editor """ print "In profile_field" print "username %s, classname %s, fieldname %s" % (other_user.username,classname,fieldname) p = secure_wrap(other_user.get_profile(), request.user) if classname == 'Profile' : return one_model_field(request, p, ProfileForm, fieldname, kwargs.get('default', ''),[p.user]) elif classname == 'HostInfo' : return one_model_field(request, p.get_host_info(), HostInfoForm, fieldname, kwargs.get('default', ''), [p.user])
def profile(request, username, template_name="profiles/profile.html"): other_user = get_object_or_404(User, username=username) other_user.save() p = other_user.get_profile() p.save() if request.user.is_authenticated(): is_friend = Friendship.objects.are_friends(request.user, other_user) is_following = Following.objects.is_following(request.user, other_user) other_friends = Friendship.objects.friends_for_user(other_user) if request.user == other_user: is_me = True else: is_me = False else: other_friends = [] is_friend = False is_me = False is_following = False if is_friend: invite_form = None previous_invitations_to = None previous_invitations_from = None else: if request.user.is_authenticated() and request.method == "POST": if request.POST["action"] == "invite": invite_form = InviteFriendForm(request.user, request.POST) if invite_form.is_valid(): invite_form.save() else: invite_form = InviteFriendForm(request.user, { 'to_user': username, 'message': ugettext("Let's be friends!"), }) if request.POST["action"] == "accept": # @@@ perhaps the form should just post to friends and be redirected here invitation_id = request.POST["invitation"] try: invitation = FriendshipInvitation.objects.get(id=invitation_id) if invitation.to_user == request.user: invitation.accept() request.user.message_set.create(message=_("You have accepted the friendship request from %(from_user)s") % {'from_user': invitation.from_user}) is_friend = True other_friends = Friendship.objects.friends_for_user(other_user) except FriendshipInvitation.DoesNotExist: pass else: invite_form = InviteFriendForm(request.user, { 'to_user': username, 'message': ugettext("Let's be friends!"), }) previous_invitations_to = FriendshipInvitation.objects.filter(to_user=other_user, from_user=request.user) previous_invitations_from = FriendshipInvitation.objects.filter(to_user=request.user, from_user=other_user) if is_me: if request.method == "POST": if request.POST["action"] == "update": profile_form = ProfileForm(request.POST, instance=other_user.get_profile()) if profile_form.is_valid(): profile = profile_form.save(commit=False) profile.user = other_user profile.save() else: profile_form = ProfileForm(instance=other_user.get_profile()) else: profile_form = ProfileForm(instance=other_user.get_profile()) else: profile_form = None interests = get_tags(tagged=other_user.get_profile(), tagged_for=other_user, tag_type='interest') skills = get_tags(tagged = other_user.get_profile(), tagged_for=other_user, tag_type='skill') needs = get_tags(tagged = other_user.get_profile(), tagged_for=other_user, tag_type='need') profile = other_user.get_profile() user = request.user if not user.is_authenticated(): user = get_anon_user() user_type = ContentType.objects.get_for_model(other_user) other_user_tweets = Tweet.objects.filter(sender_type=user_type, sender_id=other_user.id).order_by("-sent") # other_user if other_user_tweets : latest_status = other_user_tweets[0] dummy_status = DisplayStatus( defaultfilters.safe( defaultfilters.urlize(latest_status.html())), defaultfilters.timesince(latest_status.sent) ) else : dummy_status = DisplayStatus('No status', '') profile = secure_wrap(profile, user) try: profile.get_all_sliders perms_bool = True except PlusPermissionsNoAccessException: perms_bool = False profile = TemplateSecureWrapper(profile) search_type = 'profile_list' search_types = narrow_search_types() search_types_len = len(search_types) search_type_label = search_types[0][1][2] return render_to_response(template_name, { "profile_form": profile_form, "is_me": is_me, "is_friend": is_friend, "is_following": is_following, "other_user": other_user, "profile":profile, "other_friends": other_friends, "invite_form": invite_form, "previous_invitations_to": previous_invitations_to, "previous_invitations_from": previous_invitations_from, "head_title" : "%s" % other_user.get_profile().get_display_name(), "head_title_status" : dummy_status, "host_info" : other_user.get_profile().get_host_info(), "skills" : skills, "needs" : needs, "interests" : interests, "other_user_tweets" : other_user_tweets, "permissions":perms_bool, "search_type":search_type, "search_type_label":search_type_label, "search_types_len":search_types_len }, context_instance=RequestContext(request))
def proxied_signup( request, application, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None ): # request.user is the user who has invited / authorized the signup if success_url is None: success_url = get_default_redirect(request) # because this is a signup request that has an application object, we expect the application display_name = "Visitor" sponsor = request.user # the actual user who authorized this acceptance if request.method == "POST": form = form_class(request.POST) if form.is_valid(): username = form.cleaned_data["username"] password = form.cleaned_data["password1"] application.applicant.become_member(username, accepted_by=sponsor, password=password) user = authenticate(username=username, password=password) auth_login(request, user) user.message_set.create( message=ugettext("Successfully logged in as %(username)s.") % {"username": user.username} ) # Now, what happens if this application or invite came with a group? if application.group: group = secure_wrap(application.group, sponsor) group.add_member(user) # application.delete() return HttpResponseRedirect(success_url) else: form = form_class() applicant = application.get_inner().applicant if applicant: form.data["email_address"] = applicant.email_address form.data["first_name"] = applicant.first_name form.data["last_name"] = applicant.last_name form.data["username"] = applicant.first_name.lower().strip() + "." + applicant.last_name.lower().strip() # normalize and uniquify display_name = form.data["first_name"] + " " + form.data["last_name"] else: form.email_address = "" form.username = "" # the outstanding issue is how to make sure that the form we're rendering comes back here # ie. with the hmac, let's pass it down as a "submit_url" # we must now switch back to the original user (probably Anon) back ... otherwise it thinks we're # logged in as the proxy, which circumvents showing the signup form request.user = request.old_user return render_to_response( template_name, {"form": form, "submit_url": request.build_absolute_uri(), "display_name": display_name}, context_instance=RequestContext(request), )
def proxied_signup(request, application, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None): # if we've got here, we already know that this function was called # with request.user as the agent who's inviting / authorizing this new member # so we don't need to explicitly test. if success_url is None: success_url = get_default_redirect(request) # because this is a signup request that has an application object, we expect the application display_name = "Visitor" sponsor = request.user # the actual user who authorized this acceptance if request.method == "POST": form = form_class(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password1'] application.applicant.become_member(username, accepted_by=sponsor, password = password) user = authenticate(username=username, password=password) display_name = application.applicant.get_display_name() auth_login(request, user) user.message_set.create( message=ugettext("Successfully logged in as %(username)s.") % { 'username': user.username }) # Now, what happens if this application or invite came with a group? if application.group : group = secure_wrap(application.group, sponsor) group.add_member(user) #application.delete() return HttpResponseRedirect(success_url) else : print form.errors else: form = form_class() try : applicant = application.get_inner().applicant form.email_address = applicant.email_address form.username = "******" % (applicant.first_name, applicant.last_name) display_name = form.username except : form.email_address = '' form.username = '' # the outstanding issue is how to make sure that the form we're rendering comes back here # ie. with the hmac, let's pass it down as a "submit_url" # we must now get the original user (probably Anon) back ... otherwise it thinks we're # logged in as the proxy, which circumvents showing the signup form request.user = request.old_user return render_to_response(template_name, { "form": form, "submit_url" : request.build_absolute_uri(), "display_name" : display_name }, context_instance=RequestContext(request))
def profile(request, username, template_name="profiles/profile.html"): #trellis.callInEventLoop(hello, "Tom") is_me = False user = request.user if request.user.is_authenticated() : if user.username == username : is_me = True else : user = get_anon_user() other_user = secure_wrap(get_object_or_404(User, username=username),user) is_following = Following.objects.is_following(request.user, other_user.get_inner()) p = other_user.get_inner().get_profile() profile = secure_wrap(p,user) profile.user # trigger permission exception if no access can_change_avatar = False try : profile.change_avatar can_change_avatar = True except PlusPermissionsNoAccessException : pass interests = get_tags(tagged=other_user.get_inner().get_profile(), tagged_for=other_user.get_inner(), tag_type='interest') skills = get_tags(tagged = other_user.get_inner().get_profile(), tagged_for=other_user.get_inner(), tag_type='skill') needs = get_tags(tagged = other_user.get_inner().get_profile(), tagged_for=other_user.get_inner(), tag_type='need') user_type = ContentType.objects.get_for_model(other_user) # new style statuses tweets = FeedItem.feed_manager.get_from(other_user.get_inner()).order_by("-sent") if tweets : latest_status = tweets[0] status_since = defaultfilters.timesince(latest_status.sent) else: status_since = '' status_type = 'profile' try: profile.get_all_sliders perms_bool = True except PlusPermissionsNoAccessException: perms_bool = False profile = TemplateSecureWrapper(profile) search_type = 'profile_list' search_types = narrow_search_types() search_types_len = len(search_types) search_type_label = search_types[0][1][2] host_info = p.get_host_info() host_info = secure_wrap(host_info, user, interface_names=['Viewer', 'Editor']) see_host_info = False try : host_info.user see_host_info = True except : pass # can't see host_info host_info = TemplateSecureWrapper(host_info) hubs = other_user.get_inner().hubs() non_hub_groups = [(g.group_app_label() + ':group', g) for g in other_user.get_inner().groups.filter(level='member').exclude(id__in=hubs)] hubs = [(g.group_app_label() + ':group', g) for g in hubs] see_about = is_me or show_section(profile, ('about',)) see_contacts = is_me or show_section(profile,('mobile','home','work','fax','website','address','email_address')) see_links = is_me links = get_links_for(other_user,RequestContext(request)) if links : see_links = True can_tag = profile.has_interface('Profile.Editor') template_args = { "is_me": is_me, "is_following": is_following, "other_user": other_user.get_inner(), # XXX - should fix this get_inner "profile":profile, "can_change_avatar":can_change_avatar, "head_title" : "%s" % profile.get_display_name(), "status_type" : status_type, "status_since" : status_since, "host_info" : host_info, "skills" : skills, "needs" : needs, "interests" : interests, "other_user_tweets" : tweets, "permissions":perms_bool, "non_hub_groups":non_hub_groups, "hubs":hubs, "search_type":search_type, "search_types":search_types, "search_type_label":search_type_label, "search_types_len":search_types_len, "host_info":host_info, "see_host_info":see_host_info, "see_about":see_about, "see_contacts":see_contacts, "see_links":see_links, "other_user_class":user_type.id, "other_user_id":other_user.id, "can_tag":can_tag, } labels = {'MAIN_HUB_LABEL':_('Main %s')%settings.HUB_NAME, 'MAIN_HUB_DEFAULT':_("No %s selected")%settings.HUB_NAME} template_args.update(labels) return render_to_response(template_name, template_args, context_instance=RequestContext(request))
def proxied_invited_signup(request, invite, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None): # request.user is the user who has invited / authorized the signup if success_url is None: success_url = get_default_redirect(request) display_name = "Visitor" sponsor = request.user # the actual user who authorized this acceptance if request.method == "POST": form = form_class(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password1'] invite.invited.become_member(username, accepted_by=sponsor, password=password) user = authenticate(username=username, password=password) auth_login(request, user) user.message_set.create( message=ugettext("Successfully logged in as %(username)s.") % {'username': user.username}) # Now, what happens if this invite came with a group? if invite.group: group = secure_wrap(invite.group, sponsor) group.add_member(user) return HttpResponseRedirect(success_url) else: form = form_class() applicant = invite.invited if applicant: form.data['email_address'] = applicant.email_address form.data['first_name'] = '' form.data['last_name'] = '' form.data['username'] = '' display_name = '' else: form.email_address = '' form.username = '' request.user = request.old_user return render_to_response(template_name, { "form": form, "submit_url": request.build_absolute_uri(), "display_name": display_name }, context_instance=RequestContext(request))
def proxied_signup(request, application, form_class=SignupForm, template_name="account/accepted_signup.html", success_url=None): # request.user is the user who has invited / authorized the signup if success_url is None: success_url = get_default_redirect(request) # because this is a signup request that has an application object, we expect the application display_name = "Visitor" sponsor = request.user # the actual user who authorized this acceptance if request.method == "POST": form = form_class(request.POST) if form.is_valid(): username = form.cleaned_data['username'] password = form.cleaned_data['password1'] application.applicant.become_member(username, accepted_by=sponsor, password=password) user = authenticate(username=username, password=password) auth_login(request, user) user.message_set.create( message=ugettext("Successfully logged in as %(username)s.") % {'username': user.username}) # Now, what happens if this application or invite came with a group? if application.group: group = secure_wrap(application.group, sponsor) group.add_member(user) #application.delete() return HttpResponseRedirect(success_url) else: form = form_class() applicant = application.get_inner().applicant if applicant: form.data['email_address'] = applicant.email_address form.data['first_name'] = applicant.first_name form.data['last_name'] = applicant.last_name form.data['username'] = applicant.first_name.lower().strip( ) + '.' + applicant.last_name.lower().strip() #normalize and uniquify display_name = form.data['first_name'] + ' ' + form.data[ 'last_name'] else: form.email_address = '' form.username = '' # the outstanding issue is how to make sure that the form we're rendering comes back here # ie. with the hmac, let's pass it down as a "submit_url" # we must now switch back to the original user (probably Anon) back ... otherwise it thinks we're # logged in as the proxy, which circumvents showing the signup form request.user = request.old_user return render_to_response(template_name, { "form": form, "submit_url": request.build_absolute_uri(), "display_name": display_name }, context_instance=RequestContext(request))
try : status = FeedItem.feed_manager.get_status(sender) status_since = defaultfilters.timesince(status.sent) status_text = status.short except FeedItem.DoesNotExist, e : status_since = '' status_text = '' path = context['request'].path can_update_status = False if sender.__class__.__name__ == 'User' : from apps.plus_permissions.default_agents import get_anon_user if sender.username != get_anon_user().username : secure = secure_wrap(sender.get_profile(), user) can_update_status = secure.has_interface('Profile.Editor') else : try : sender.get_inner() secure = sender except : secure = secure_wrap(sender, user) can_update_status = secure.has_interface(secure.get_inner().__class__.__name__ + '.Editor') return { 'sender':sender, 'current_user':user, 'path':path,