Exemple #1
0
def register(request):
    if request.method == "POST":
        form = RegisterForm(request.POST)
        profile_form = ProfileForm(request.POST)

        if form.is_valid() and profile_form.is_valid():
            form_data = form.cleaned_data
            profile_form_data = profile_form.cleaned_data

            user = User.objects.create_user(username=form_data['username'],
                                            email=form_data['email'],
                                            password=form_data['password1'],
                                            first_name=form_data['first_name'],
                                            last_name=form_data['last_name'])

            Profile.objects.filter(user=user).update(
                dob=profile_form_data['dob'],
                divorced=profile_form_data['divorced'],
                divorced_number=profile_form_data['divorced_number'],
                children=profile_form_data['children'],
                children_number=profile_form_data['children_number'],
                description=profile_form_data['description'])

            return HttpResponseRedirect('/admin/')
    else:
        form = RegisterForm()
        profile_form = ProfileForm()
    context = {
        "form": form,
        "profile_form": profile_form,
    }
    return render(request, "core/register.html", context)
Exemple #2
0
def profile_edit(request, template_name="profiles/profile_edit.html"):

    helper = FormHelper()
    submit = Submit('edit','Edit')
    helper.add_input(submit)
    reset = Reset('reset','Reset')
    helper.add_input(reset)

    profile = get_object_or_404(Profile, user=request.user)
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        form.save()
        msg = 'Profile edited'
        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(reverse("profile_detail", kwargs={"username":profile.user.username }))

    return render_to_response(template_name,
        {
            "profile": profile,
            "form": form,
            "helper":helper,
        },
        context_instance=RequestContext(request)
    )
def edit_user(request):
    user = request.user
    rater = user.rater
    profile = user.profile
    if request.method == "POST":
        if "user_edit" in request.POST:
            user_form = UserForm(request.POST)
            if user_form.is_valid():
                user_form.save(commit=False)
                password = user_form.password
                user.set_password(password)
                user.save()
                messages.add_message(request, messages.SUCCESS, "You have updated your account")
        elif "rater_edit" in request.POST:
            rater_form = RaterForm(request.POST)
            if rater_form.is_valid():
                rater_form.save()
                messages.add_message(request, messages.SUCCESS, "You have updated your demographic info")
        elif "profile_edit" in request.POST:
            profile_form = ProfileForm(request.POST)
            if profile_form.is_valid():
                profile_form.save()
                messages.add_message(request, messages.SUCCESS, "You have updated your profile")

    user_form = UserForm(request.POST or None, instance=request.user)
    rater_form = RaterForm(request.POST or None, instance=request.user.rater)
    profile_form = ProfileForm(request.POST or None, instance=request.user.profile)
    return render(request, "user_edit.html", {'user_form': user_form,
                                        'rater_form': rater_form, 'profile_form':profile_form})
def add(request):
    """
    add profile, on GET returns common profile-add-page
    on POST | validates sended data, on success: redirect to show page, on fail returns to add page
    on ajax POST | on success: returns updated profile, on fail returns errors
    :param request:
    :return:
    """
    context = {}
    if request.method == "GET":
        context['form'] = ProfileForm()
        return render(request, "profiles/add.html", context)
    elif request.method == "POST":
        form = ProfileForm(request.POST)
        context['form'] = ProfileForm()
        if form.is_valid():
            profile = form.save()
            if request.is_ajax():
                return HttpResponse(serialize('json', [profile, ]).strip("[]"))
            else:
                if profile.slug:
                    return redirect(reverse("profiles.views.profile.show_by_slug", args=[profile.slug]))
                else:
                    return redirect(reverse("profiles.views.profile.show", args=[profile.pk]))
        else:
            if request.is_ajax():
                return HttpResponse(serialize('json', form.errors))
            else:
                return render(request, "profiles/add.html", context)
    return HttpResponseBadRequest()
Exemple #5
0
def setProfile(request, **kwargs):
    """用户profile设置"""
    
    template = kwargs.pop("template", settings.TEMPLATE_SETTINGS)
    
    if request.method == "POST":
        form = ProfileForm(request.POST, user=request.user)
        if form.is_valid():
            profile = form.save(request)
            if profile:
                utils.addMsg(request, messages.SUCCESS, ugettext(u"更新设置成功."))
                return HttpResponseRedirect(reverse("profiles_setting"))
            
        else:
            soup = BeautifulSoup(str(form.errors))
            utils.addMsg(request, messages.ERROR, soup.ul.li.ul.li.contents[0])
#            utils.addMsg(request, messages.ERROR, form.errors)
        
    else :
        draftProfile = request.session.get("draftProfile", None)
        form = ProfileForm(user=request.user, draftProfile=draftProfile)
        
        if draftProfile:
            request.session["draftProfile"] = None
            
    return render_to_response(template, 
        RequestContext(request, {"form": form}))  
Exemple #6
0
def signup(request):
    if request.method == 'POST':
        user_form = UserCreationForm(request.POST)
        profile_form = ProfileForm(request.POST)
        if user_form.is_valid() and profile_form.is_valid():
            user = user_form.save()
            user.save()
            name = profile_form.cleaned_data['name']
            email_id = profile_form.cleaned_data['email_id']
            profile = Profile.objects.create(user=user,
                                             name=name,
                                             email_id=email_id)
            profile.save()
            username = user_form.cleaned_data['username']
            password = user_form.cleaned_data['password1']
            user = authenticate(username=username, password=password)
            login(request, user)
            return HttpResponseRedirect(reverse('home'))
        context = {'user_form': user_form, 'profile_form': profile_form}
        return render(request, 'accounts/signup.html', context)
    else:
        user_form = UserCreationForm()
        profile_form = ProfileForm()
        context = {'user_form': user_form, 'profile_form': profile_form}
        return render(request, 'accounts/signup.html', context)
def update_profile(request):
    submitted = False
    try:
        inst = Researcher.objects.get(user=request.user)
    except ObjectDoesNotExist:
        inst = Academic.objects.get(user=request.user)

    if request.method == 'POST':
        profile_form = ProfileForm(data=request.POST, instance=inst)
        if profile_form.is_valid():
            profile = profile_form.save(commit=False)
            profile.user= request.user

            if 'pic' in request.FILES:
                profile.pic= request.FILES['pic']

            profile.save()

            submitted=True

        else:
            print profile_form.errors
        
    else:
        profile_form = ProfileForm(instance=inst)
    
    return render(request, 'update_profile.html', {'profile_form': profile_form, 'submitted': submitted})
Exemple #8
0
def _profile_change(request, name, website, location):
    if request.method == 'POST':
        profile_form = ProfileForm(request.POST, instance=request.user.get_profile())
        if profile_form.is_valid():
            profile = profile_form.save()
            return profile
    return False
Exemple #9
0
def profile_edit(request, template_name="profiles/profile_edit.html"):

    helper = FormHelper()
    submit = Submit('edit', 'Edit')
    helper.add_input(submit)
    reset = Reset('reset', 'Reset')
    helper.add_input(reset)

    profile = get_object_or_404(Profile, user=request.user)
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        form.save()
        msg = 'Profile edited'
        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(
            reverse("profile_detail",
                    kwargs={"username": profile.user.username}))

    return render_to_response(template_name, {
        "profile": profile,
        "form": form,
        "helper": helper,
    },
                              context_instance=RequestContext(request))
Exemple #10
0
def edit_profile(req):
    if req.user.profile.car:
        form = ProfileForm(
            initial={
                'hometown': req.user.profile.hometown,
                'major': req.user.profile.major,
                'phone_number': req.user.profile.phone_number,
                'affiliation': req.user.profile.affiliation,
                'org_email': req.user.profile.org_email,
                'car_make': req.user.profile.car.make,
                'car_model': req.user.profile.car.model,
                'plate': req.user.profile.car.plate,
                'venmo': req.user.profile.venmo,
                'bio': req.user.profile.bio
            })
    else:
        form = ProfileForm(
            initial={
                'hometown': req.user.profile.hometown,
                'major': req.user.profile.major,
                'phone_number': req.user.profile.phone_number,
                'affiliation': req.user.profile.affiliation,
                'org_email': req.user.profile.org_email,
                'venmo': req.user.profile.venmo,
                'bio': req.user.profile.bio
            })
    context = {
        'title': 'CarTrek -- Edit Profile',
        'organizations': Organization.objects.all(),
        'form': form,
    }
    return render(req, 'edit.html', context=context)
Exemple #11
0
def profile_edit(request, user_id):
    user = get_object_or_404(User, id=user_id)
    profile_instance = user.get_profile()
    profile_form = ProfileForm(instance = profile_instance)
    default_icon = Icon.objects.get(name='home')
    if profile_instance.location_id is not None:
        point = MaapPoint.objects.get(id=profile_instance.location_id)
        point_form = InlinePointForm(instance=point)
    else:
        point_form = InlinePointForm
        point = None
                
    if request.method == 'POST':
        profile_form = ProfileForm(request.POST, instance=profile_instance)
        if point:
            point_form = InlinePointForm(request.POST, instance=point)
        else:
            point_form = point_form(request.POST)

        if profile_form.is_valid():
            profile = profile_form.save(commit=False)
            
        if point_form.is_valid():
            point = point_form.save(commit=False)
            point.name = profile.name
            point.creator = request.user
            point.editor = request.user
            point.icon = default_icon

            
        try :
            point.save()
            success = True
        except:
            success = False

        if success:
            profile.user = user            
            profile.location = point
            profile.location_id = point.id
            
        try:
            profile.save()
            success = success and True
        except:
            success = False
            
        if success:
            return redirect('profile_detail', username = user.username)
        
    return simple.direct_to_template(
        request, 
        'profiles/profile_form.html',
        extra_context={
            'form':profile_form,
            'inline_form':point_form,
            'user':user
        }
    )  
Exemple #12
0
def change_profile_photos(request, pk):
    if request.method == 'POST':
        user = User.objects.get(pk=pk)
        owner = {"owner": user}
        form = ProfileForm(request.FILES, owner)
        if form.is_valid():
            form.save()
            return redirect('posts:homepage')
Exemple #13
0
def profile(request):
    template = 'profile.html'
    if request.method == 'POST':
        form = ProfileForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('index')
    else:
        form = ProfileForm
    return render(request, template, {'form': form})
Exemple #14
0
 def test_change_user_profile_information(self):
     """
     Submit valid data through the ProfileForm, and ensure that it was
     validated by the form.
     """
     form_data = {
         "profile_image": self.new_profile_img,
         "description": "Hi! I'm Meepy!",
     }
     profile_form = ProfileForm(instance=self.user, data=form_data)
     self.assertTrue(profile_form.is_valid())
Exemple #15
0
 def test_bad_url(self):        
     form = ProfileForm(instance=self.profile_one)
     # include a bad url to force an error
     data = {
         "name": "John Smith",
         "about": "John likes wine",
         "location": "France maybe!",
         "website": "httpasd://python.org"            
     }
     form = ProfileForm(data)
     self.assertEquals(False, form.is_valid())
Exemple #16
0
def edit(request):
  profile = UserProfile.objects.get(user=request.user)
  # Is this a POST method? If so, validate and save
  if request.method == 'POST':
    form = ProfileForm(request.POST, instance=profile)
    if form.is_valid():
      form.save()
      messages.success(request, 'Your profile was updated successfully.')
  else:
    form = ProfileForm(instance=profile)

  return { 'form': form }
Exemple #17
0
    def test_create_profile_form_with_mandatory_fields_filled(self):
        form = ProfileForm({
            'first_name': 'test',
            'last_name': 'test',
            'email_address': '*****@*****.**',
            'phone_number': '123 456 789',
            'street_address1': '5 test street',
            'town_or_city': 'test city',
            'country': 'test country'
        })

        self.assertTrue(form.is_valid())
Exemple #18
0
def checkout_success(request, order_number):
    """
    Handle successful checkouts
    """
    order = get_object_or_404(Order, order_number=order_number)
    template = render_to_string('checkout/confirmation_emails/order_email.txt',
                                {'order': order})

    email = EmailMessage(
        'Your order has been received',
        template,
        settings.EMAIL_HOST_USER,
        [order.email],
    )
    email.fail_silently = False
    email.send()

    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)

    if request.user.is_authenticated:
        profile = Profile.objects.get(user=request.user)
        # Bind user profile object to the order
        order.profile = profile
        order.save()

        if save_info:
            profile_data = {
                'default_phone_number': order.phone_number,
                'default_town_or_city': order.town_or_city,
                'default_street_address1': order.street_address1,
                'default_street_address2': order.street_address2,
                'default_county': order.county,
                'default_postcode': order.postcode,
                'default_country': order.country,
            }
            profile_form = ProfileForm(profile_data, instance=profile)
            if profile_form.is_valid():
                profile_form.save()

    messages.success(
        request, f'Order successfully processed! \
        Your order number is {order_number}. A confirmation \
        email will be sent to {order.email}.')

    if 'cart' in request.session:
        del request.session['cart']
    context = {
        'order': order,
    }

    return render(request, 'checkout/checkout_success.html', context)
Exemple #19
0
def post_profile(request, cipher_text):
    try:
        profile = Profile.objects.get(cipher_text=cipher_text)
    except Profile.DoesNotExist:
        profile = Profile(cipher_text=cipher_text)
    profile_form = ProfileForm(request.POST, instance=profile)
    if profile_form.is_valid():
        # TODO reverse geocoding of address by geo location
        # TODO update oDesk profile
        profile_form.save()
        return {'status': 'ok'}
    else:
        logging.error(profile_form.errors)
        return HttpResponseBadRequest()
Exemple #20
0
def usersignup(request):
    form = UserSignup()
    profile_form = ProfileForm()
    if request.method == 'POST':
        form = UserSignup(request.POST)
        profile_form = ProfileForm(request.POST, request.FILES)
        if form.is_valid() and profile_form.is_valid():
            user = form.save()
            profile = profile_form.save(commit=False)
            profile.owner = user
            profile.save()
            profile_form.save_m2m()
            user.set_password(user.password)
            user.save()

            login(request, user)
            messages.success(request, "Successfully signed up!")
            return redirect("profile", pk=profile.pk)
        messages.error(request, form.errors)
        messages.error(request, profile_form.errors)
        return redirect("signup")
    context = {
        "form": form,
        'profile_form': profile_form,
    }
    return render(request, 'signup.html', context)
Exemple #21
0
def checkout_success(request, order_number):
    """
    Render successful order view with the order summary
    displayed and a message that thge order was successfully
    proccessed.
    """
    # Display a success message
    order = get_object_or_404(Order, order_number=order_number)
    save_details = request.session.get('save_details')

    if request.user.is_authenticated:
        #  If user has logged in, attach their profile to the order
        profile = Profile.objects.get(user=request.user)
        order.user_profile = profile
        order.save()

        # If the user has ticked 'save_details', save them in the profile
        if save_details:
            user_details = {
                'user_phone_number': order.phone_number,
                'user_address_line_1': order.address_line_1,
                'user_address_line_2': order.address_line_2,
                'user_city': order.city,
                'user_region': order.region,
                'user_country': order.country,
                'user_postcode': order.postcode,
            }
            profile_form = ProfileForm(user_details, instance=profile)
            if profile_form.is_valid():
                profile_form.save()

    # Calculate discount applied if any
    discount = round((order.subtotal - (order.total - order.delivery_cost)) /
                     order.subtotal * 100, 0)

    # delete cart contents
    if 'cart' in request.session:
        del request.session['cart']

    if 'delivery' in request.session:
        del request.session['delivery']

    template = 'checkout/checkout_success.html'
    context = {
        'order': order,
        'discount': discount,
    }

    return render(request, template, context)
Exemple #22
0
 def _test_bad_country(self):
     form = ProfileForm(instance=self.profile_one)
     # include a bad country to force an error
     data = {
         "name": "John Smith",
         "about": "John likes wine",
         "location": "Paris",
         "website": "http://python.org",
         "street_address": "80, bd Auguste-Blanqui",
         "street_address_two": "Cedex 13",
         "city": "Paris",
         "postal_code": "75707",
         "country": "FA",    # wrong: France is "FR", there is no "FA"
     }
     form = ProfileForm(data)
     self.assertEquals(False, form.is_valid())
def profile_edit(request, template_name="profiles/profile_edit.html"):

    profile = request.user.get_profile()
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        form.save()
#        msg = 'Profile edited'
#        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(reverse("profile_detail", kwargs={"username":profile.username }))

    return render(request, template_name,
        {
            "profile": profile,
            "form": form,
        })
Exemple #24
0
def profile_edit(request):
    title = "Update Profile"
    profile, created = Profile.objects.get_or_create(user=request.user)
    form = ProfileForm(request.POST or None,
                       request.FILES or None,
                       instance=profile)
    if form.is_valid():
        instance = form.save(commit=False)
        instance.user = request.user
        instance.save()
        return redirect("profile_user")
    context = {
        "form": form,
        "title": title,
    }
    return render(request, "forms.html", context)
 def post(self, request, *args, **kwargs):
     user = self.request.user
     profile_form = ProfileForm(request.POST,
                                      request.FILES,
                                      instance=user.profile)
     if not (profile_form.is_valid()):
         messages.error(request, "There was a problem with the form. "
                        "Please check the details.")
         profile_form = ProfileForm(instance=user.profile)
         return super(EditProfile, self).get(request,
                                             profile_form=profile_form)
     profile = profile_form.save(commit=False)
     profile.user = user
     profile.save()
     messages.success(request, "Profile details saved!")
     return redirect("smriti:home")
Exemple #26
0
def edit(request):
    """
    Edits profile data.
    """
    profile = Profile.objects.get(user=request.user)
    if request.method == 'POST':
        form = ProfileForm(request.POST)
        if form.is_valid():
            form.save(profile)
            logger.info("%s - profile-edit: user '%s', form %s" % (request.META.get('REMOTE_ADDR'), request.user, form.cleaned_data))
            request.user.message_set.create(message=_('Profile updated.'))
            return HttpResponseRedirect(reverse('profile-show'))
    form = ProfileForm(profile.get_init_data())
    dict_data['form'] = form
    return render_to_response('profiles/edit_form.html', dict_data,
                              context_instance=RequestContext(request))
Exemple #27
0
 def _test_bad_country(self):
     form = ProfileForm(instance=self.profile_one)
     # include a bad country to force an error
     data = {
         "name": "John Smith",
         "about": "John likes wine",
         "location": "Paris",
         "website": "http://python.org",
         "street_address": "80, bd Auguste-Blanqui",
         "street_address_two": "Cedex 13",
         "city": "Paris",
         "postal_code": "75707",
         "country": "FA",    # wrong: France is "FR", there is no "FA"
     }
     form = ProfileForm(data)
     self.assertEquals(False, form.is_valid())
Exemple #28
0
def profile_edit(request, template_name="profiles/profile_edit.html"):

    profile = request.user.get_profile()
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        form.save()
        #        msg = 'Profile edited'
        #        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(
            reverse("profile_detail", kwargs={"username": profile.username}))

    return render(request, template_name, {
        "profile": profile,
        "form": form,
    })
Exemple #29
0
 def test_valid_profile(self):
     form = ProfileForm(instance=self.profile_one)
     # include a bad country to force an error
     data = {
         "name": "John Smith",
         "about": "John likes wine",
         "location": "Paris",
         "website": "http://python.org",
         "street_address": "80, bd Auguste-Blanqui",
         "street_address_two": "Cedex 13",
         "city": "Paris",
         "postal_code": "75707",
         "country": "FR",
         "date_of_birth": "1986-05-05",
     }
     form = ProfileForm(data)
     self.assertEquals(True, form.is_valid(), 'Form errors: %s' % form.errors)
Exemple #30
0
def update_profile_form(request,username) :
    """ Get a prefilled basic form for the profile """
    other_user = get_object_or_404(User,username=username)
    p = other_user.get_profile()
    if not has_access(request.user,p,'Profile.Viewer') :
        raise PlusPermissionsNoAccessException(Profile,p.pk,'update_profile_form')
    else :
        profile_form = ProfileForm(request.POST, p)
Exemple #31
0
def register(request):
    '''
    TO DO:
    Authenticate email
    '''
    if request.method == 'POST':
        formUser = UserForm(data=request.POST)
        formProfile=ProfileForm(data=request.POST)
        if formUser.is_valid() and formProfile.is_valid():
            password1=formUser.cleaned_data['password']
            password2=request.POST.get('password2')
            first_name=formUser.cleaned_data['first_name']
            last_name=formUser.cleaned_data['last_name']
            email=formUser.cleaned_data['email']
            if(password1!=password2):
                return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile,'passwordError':'passwordError'})
            if User.objects.filter(username = email).exists():
                return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile, 'error_message':'error_message'})
            user = formUser.save()
            user.set_password(user.password)
            user.is_active = False
            user.first_name=first_name
            user.last_name=last_name
            user.email=email
            user.username=email
    
            body=formProfile.cleaned_data['body']
            birthDate=formProfile.cleaned_data['birthDate']
            gender=formProfile.cleaned_data['gender']
            city=formProfile.cleaned_data['city']
            country=formProfile.cleaned_data['country']
            address=formProfile.cleaned_data['address']
            postalCode=formProfile.cleaned_data['postalCode']
            phoneNumber=formProfile.cleaned_data['phoneNumber']
            try:
                image = request.FILES['image']
            except:
                image=""
            user.save()
            newProfile=Profile(user=user,body=body,birthDate=birthDate,gender=gender,city=city,address=address,postalCode=postalCode,phoneNumber=phoneNumber,country=country,image=image)
            newProfile.save()
            return HttpResponseRedirect('/profiles/login')
    else:
        formUser = UserForm()
        formProfile=ProfileForm()
    return render(request, 'register.html', {'formUser': formUser, 'formProfile':formProfile})
Exemple #32
0
 def test_valid_profile(self):
     form = ProfileForm(instance=self.profile_one)
     # include a bad country to force an error
     data = {
         "name": "John Smith",
         "about": "John likes wine",
         "location": "Paris",
         "website": "http://python.org",
         "street_address": "80, bd Auguste-Blanqui",
         "street_address_two": "Cedex 13",
         "city": "Paris",
         "postal_code": "75707",
         "country": "FR",
         "date_of_birth": "1986-05-05",
     }
     form = ProfileForm(data)
     self.assertEquals(True, form.is_valid(), 'Form errors: %s' % form.errors)
Exemple #33
0
def checkout_success(request, order_number):
    """
    handle successful checkouts
    """
    # for use with profiles
    save_info = request.session.get('save_info')
    # the "=order_number" comes from view prams
    order = get_object_or_404(Order, order_number=order_number)

    if request.user.is_authenticated:
        profile = UserProfile.objects.get(user=request.user)
        # attatch order to profile
        order.user_profile = profile
        order.save()

        # update info if box ticked
        if save_info:
            profile_data = {
                # keys match user profile model
                'default_name': order.full_name,
                'default_email': order.email,
                'default_contact_number': order.phone_number,
                'default_street_address1': order.street_address1,
                'default_street_address2': order.street_address2,
                'default_town': order.town_or_city,
                'default_postcode': order.postcode,
                # spelling consistant with model
                'default_counrty': order.country,
            }
            user_profile_form = ProfileForm(profile_data, instance=profile)
            if user_profile_form.is_valid():
                user_profile_form.save()

    messages.success(
        request, f'Your order has been processed. \
            Your order number is: {order_number}. A confirmation email is\
            on its way to {order.email}')

    if 'basket' in request.session:
        del request.session['basket']

    template = 'checkout/checkout_success.html'
    context = {'order': order}

    return render(request, template, context)
Exemple #34
0
def profile(request):
    
    profile = get_object_or_404(Profile, owner=request.user)

    if request.method == 'POST':
        form = ProfileForm(request.POST, instance=profile)
        if form.is_valid():
            form.save()
            messages.success(request, ('Your details have been saved'))
        else:
            messages.error(request, ('An error occured, please check your form.'))
            return redirect(reverse('profile'))
                           
    else:
        form = ProfileForm(instance=profile)

    recent_orders = profile.orders.all().order_by('-date')[:3]
    

    context = {
        'form': form,
        'orders': recent_orders,
    }

    return render(request, 'profile.html', context)
def newProfile(request):
	user = request.user.username
	user_profile = Profile.objects.filter(username=user, completed=True)

	# Check if logged in user already has a completed profile
	if user_profile.count() > 0:
		return HttpResponseRedirect('/swt/')

	profile = Profile.objects.get(username=user)

	if request.POST:
		form = ProfileForm(request.POST, instance=profile)
			
		if form.is_valid():
			form.save()
			
			# Create hash name for profile image
			signer = Signer()
			img_hash = signer.sign('p-img-' + user)
		
			data = form.cleaned_data
			
			if data['profile_pic'] == '':
				folder = '/home/phoenix470/swt/media/static/assets/uploaded_files'
				imgurl = 'http://terryshoemaker.files.wordpress.com/2013/03/placeholder1.jpg'
				urllib.urlretrieve(imgurl, folder + '/' + img_hash + '.jpg')
			else:
				folder = '/home/phoenix470/swt/media/static/assets/uploaded_files'
				imgurl = data['profile_pic']
				urllib.urlretrieve(imgurl, folder + '/' + img_hash + '.jpg')
				
			profile.completed = True
			profile.save()

			return HttpResponseRedirect('/swt/')
	else:
		form = ProfileForm()

	args = {}
	args.update(csrf(request))
	
	args['form'] = form

	return render_to_response('profile-new.html', args)
Exemple #36
0
 def get(self, request, pk):
     order = Order.objects.filter(id=pk,
                                  cart__user=request.user,
                                  accepted=False).aggregate(
                                      Sum('cart__cartitem__price_sum'))
     form = ProfileForm(instance=Profile.objects.get(user=request.user))
     return render(request, 'shop/checkout.html', {
         "order": order,
         "form": form
     })
Exemple #37
0
def checkout_success(request, order_number):
    """
    A view to confirm a successful checkout
    """
    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)

    if request.user.is_authenticated:
        currentprofile = Profile.objects.get(user=request.user)
        # Attach the user's profile to the order
        order.user_profile = currentprofile
        order.save()

        # Save the user's info
        if save_info:
            profile_data = {
                'default_full_name': order.full_name,
                'default_email': order.email,
                'default_phone_number': order.phone_number,
                'default_street_address': order.street_address,
                'default_address2': order.address2,
                'default_country': order.country,
                'default_town_or_city': order.town_or_city,
                'default_postcode': order.postcode,
            }
            user_profile_form = ProfileForm(profile_data,
                                            instance=currentprofile)
            if user_profile_form.is_valid():
                user_profile_form.save()

    messages.success(
        request, f'Success! Your orser is now processed! \
        Your order number is {order_number}.')

    if 'bag' in request.session:
        del request.session['bag']

    template = 'checkout/checkout_success.html'
    context = {
        'order': order,
    }

    return render(request, template, context)
def checkout_success(request, order_number):
    """
    Show user the checkout success page if an order is successfully
    placed and gives them feedback. This view will also link orders
    to the user profile who submit it if they are logged in.
    """
    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)

    if request.user.is_authenticated:
        profile = Profile.objects.get(user=request.user)
        # Link the order to user profile
        order.user_profile = profile
        order.save()

        # Saves user info as defualt (can be viewed on Profile Page)
        if save_info:
            profile_data = {
                'default_phone_number': order.phone_number,
                'default_country': order.country,
                'default_postcode': order.postcode,
                'default_town_or_city': order.town_or_city,
                'default_street_address1': order.street_address1,
                'default_street_address2': order.street_address2,
                'default_county': order.county,
            }
            profile_form = ProfileForm(profile_data, instance=profile)
            if profile_form.is_valid():
                profile_form.save()

    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)
    messages.success(request, 'Order successful')

    if 'bag' in request.session:
        del request.session['bag']

    template = 'checkout/checkout_success.html'
    context = {
        'order': order,
    }

    return render(request, template, context)
Exemple #39
0
def profile_edit(request,username=None):
    profile = request.user.get_profile()
    form = ProfileForm(instance=profile)
    form.initial['username'] = profile.user.username
    if request.method=="POST":
        form = ProfileForm(request.POST,request.FILES,instance=profile)
        form.initial['username'] = profile.user.username
        form.initial = request.POST
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(form.instance.get_absolute_url())
    return render_to_response("profiles/profile_create.html",{"form":form},context_instance=RequestContext(request))
Exemple #40
0
def user_register(request):
    if request.method == "GET":
        user_form = UserForm()
        profile_form = ProfileForm()
    elif request.method == "POST":
        user_form = UserForm(request.POST)
        profile_form = ProfileForm(request.POST)
        if user_form.is_valid() and profile_form.is_valid():
            user = user_form.save(commit=False)  # setting password done in forms.py
            user.alias = user.username
            user.save()
            # extra password thing
            # password = user.password # The form doesn't know to call this special method on user.
            # user.set_password(password)
            # user.save() # You must call authenticate before login. :(
            # end extra password thing
            profile = profile_form.save(commit=False)
            if Location.objects.count() > 0:
                profile.location = Location.objects.all()[0]
            profile.user = user
            profile.save()
            user = authenticate(username=request.POST['username'],
                                password=request.POST['password'])
            login(request, user)
            messages.add_message(
                request, messages.SUCCESS,
                "Congratulations, {}, on creating your new account! You are now logged in.".format(
                    user.username))
            send_mail("Welcome to Share Lockers","""\
{},

Your account on sharelockers.come has been created! \
We look forward to seeing what you have to share. \
You might start by stocking some items to sell, or by adding items you have \
at home which you would be willing to sell.

-ShareLockers Team""".format(user.username),
                    settings.EMAIL_HOST_USER, [user.email], fail_silently=settings.EMAIL_SILENT)
            return redirect('view_index')
    return render(request, "profiles/register.html", {'user_form': user_form,
                                                      'profile_form': profile_form,
                                                      })
Exemple #41
0
def checkout_success(request, order_number):
    """
    Handle successful checkouts
    """
    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)

    if request.user.is_authenticated:
        profile = Profile.objects.get(user=request.user)
        # Attach the user's profile to the order
        order.profile = profile
        order.save()

        # Save the user's info
        if save_info:
            profile_data = {
                'profile_full_name': order.full_name,
                'profile_phone_number': order.phone_number,
                'profile_country': order.country,
                'profile_postcode': order.postcode,
                'profile_town_or_city': order.town_or_city,
                'profile_address_line1': order.address_line1,
                'profile_address_line2': order.address_line2,
                'profile_county': order.county,
            }
            user_profile_form = ProfileForm(profile_data, instance=profile)
            if user_profile_form.is_valid():
                user_profile_form.save()

    messages.success(
        request, f'Order successfully processed! A confirmation \
        email will be sent to {order.email}.')

    if 'cart' in request.session:
        del request.session['cart']

    template = 'checkout/checkout_success.html'
    context = {
        'order': order,
    }

    return render(request, template, context)
Exemple #42
0
def checkout_success(request, order_number):
    """ Handle Successful checkouts """

    save_info = request.session.get('save_info')
    order = get_object_or_404(Order, order_number=order_number)
    user = request.user

    if user.is_authenticated:
        profile = UserProfile.objects.get(user=user)
        # Attach the user's profile to the order
        order.user_profile = profile
        order.save()

        # Save user info if seleceted
        if save_info:
            profile_data = {
                'default_full_name': order.full_name,
                'default_phone_number': order.phone_number,
                'default_street_address1': order.street_address1,
                'default_street_address2': order.street_address2,
                'default_town_city': order.town_city,
                'default_postcode': order.postcode,
                'default_county': order.county,
                'default_country': order.country,
            }
            user_profile_form = ProfileForm(profile_data, instance=profile)
            if user_profile_form.is_valid():
                user_profile_form.save()

    messages.success(
        request, f'Order successfully processed \
        Your order number is {order_number}. A confirmation emial \
            will be sent to {order.email}.')

    if 'basket' in request.session:
        del request.session['basket']

    context = {
        'order': order,
    }

    return render(request, 'checkout/checkout_success.html', context)
Exemple #43
0
def my_profile_view(request):
    profile = Profile.objects.get(user=request.user)
    print(request.POST)
    print(request.FILES)
    form = ProfileForm(request.POST or None,
                       request.FILES or None,
                       instance=profile)
    confirm = False

    if request.method == "POST":
        if form.is_valid:
            form.save()
            confirm = True

    context = {
        'profile': profile,
        'form': form,
        'confirm': confirm,
    }
    return render(request, 'profiles/main.html', context)
Exemple #44
0
def profile_edit(request, template_name="profiles/profile_edit.html"):

    profile = request.user.get_profile()
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        form.save()
        msg = 'Profile edited'
        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(reverse("profile_detail", kwargs={"github_account":profile.github_account }))
        
    # TODO - move this to a template
    github_account = """
    <div 
        id="div_id_github_account" 
        class="ctrlHolder"><label for="id_github_account" >Github account</label><strong>{0}</strong></div>
    """.format(profile.github_account)
        
    helper = FormHelper()
    helper.form_class = "profile-edit-form"
    helper.layout = Layout(
        Fieldset(
            '',
            HTML(github_account),
            'bitbucket_url',
            'google_code_url',
            'email',
        ),
        ButtonHolder(
            Submit('edit', 'Edit', css_class="awesome forestgreen"),
        )
    )        

    return render_to_response(template_name,
        {
            "profile": profile,
            "form": form,
            "helper":helper,
        },
        context_instance=RequestContext(request)
    )
Exemple #45
0
def profile(request, template_name="profiles/edit_profile.html"):
    user = request.user
    profile = user.profile

    def update_profile():
        profile_form = ProfileForm(data=request.POST,
                                   instance=request.user.get_profile())
        if profile_form.is_valid():
            profile_form.save()
            messages.success(request, 'Profile updated.')

    def update_skills():
        #f**k capitals
        tag_list = request.POST.get('skills_text').lower().split(',')
        for tag in tag_list:
            if tag and tag != '':
                #f*****g excess whitespace man
                tag = tag_clean(tag)
                skill, created = Skill.objects.get_or_create(name=tag)
                profile.skills.add(skill)
        psf = ProfileSkillsForm(request.POST)
        if psf.is_valid():
            skills_list = Skill.objects.filter(
                id__in=psf.cleaned_data.get('skills'))
            for skill in skills_list:
                profile.skills.add(skill)
        profile.save()
        messages.success(request, 'Skills updated.')

    if request.method == "POST":
        origin = request.POST.get('origin')
        if origin == "profile":
            update_profile()
        else:  #origin == "skill":
            update_skills()
    profile_form = ProfileForm(instance=request.user.get_profile())
    skill_form = ProfileSkillsForm()
    skills = profile.skills.all()
    events = Event.objects.filter(creator=user)
    start = datetime.now()
    end = start + timedelta(days=30)
    office_hours = reduce(lambda x, y: x + y,
                          [e.get_occurrences(start, end)
                           for e in events]) if events else []
    return direct_to_template(
        request, template_name, {
            'skill_form': skill_form,
            'profile_form': profile_form,
            'profile': profile,
            'skills': skills,
            'editable': True,
            'office_hours': office_hours
        })
Exemple #46
0
def edit(request, username):
    user = get_object_or_404(User, username=username)
    if request.user != user:
        return http.HttpResponseForbidden()
    try:
        profile = user.get_profile()
    except Profile.DoesNotExist:
        raise http.Http404
    form = ProfileForm(instance=profile)
    if request.method == 'POST':
        form = ProfileForm(instance=profile, data=request.POST,
                           files=request.FILES)
        if form.is_valid():
            form.save()
            return http.HttpResponseRedirect(reverse('profiles_show', kwargs={
                'username': profile.user.username
            }))
    return render_to_response('profiles/edit.html', {
        'form': form,
        'profile': profile,
    }, context_instance=RequestContext(request))
Exemple #47
0
def create_profile(req):
    if req.user.groups.filter(name='adults').exists():
        return redirect('browse')
    context = {
        'title': 'CarTrek -- Create Profile',
        'organizations': Organization.objects.all(),
        'form': ProfileForm(initial={
            'phone_number': '',
            'org_email': 'none',
        }),
    }
    return render(req, 'create.html', context=context)
Exemple #48
0
def create_profile(request):
    """
    Create a profile for the current User, if one doesn't already
    exist.

    If the User already has a profile, as determined by
    `request.user.profile`, a redirect will be issued to the
    `profiles.views.edit_profile` view. If no profile model has
    been specified in the `AUTH_PROFILE_MODULE` setting,
    `django.contrib.auth.models.SiteProfileNotAvailable` will be
    raised.
    """
    try:
        profile_obj = request.user.profile
        return redirect("profiles_edit_profile")
    except ObjectDoesNotExist:
        pass

    form = ProfileForm(request.POST or None,
                       request.FILES or None,
                       request=request)
    if form.is_valid():
        profile_obj = form.save(commit=False)
        profile_obj.user = request.user
        profile_obj.save()

        if hasattr(form, "save_m2m"):
            form.save_m2m()
        return redirect("profiles_my")
    return {"form": form}
Exemple #49
0
def model_profile_upload(request):
    if request.method == 'POST':
        form = ProfileForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
            return redirect('profile')
    else:
        form = ProfileForm()
    return render(request, 'model_profile_upload.html', {
        'form': form
    })
def update(request, id):
    """
    updates profile by id, on GET returns common profile-update-page
    on POST | validates sended data, on success: redirect to show page, on fail returns to update page
    on ajax POST | on success: returns updated profile, on fail returns errors
    :param request:
    :param id:
    :return:
    """
    profile = get_object_or_404(Profile, pk=id)
    context = {
        'profile': profile
    }

    # # if user is admin, check has he access for that profile
    # if hasattr(request.user, 'is_admin') and request.user.is_admin:
    #     if request.user.is_superuser or request.user.profile.profiles.filter(pk=profile.id).count():
    #         return render_show_view(profile)

    if request.method == "GET":
        context['form'] = ProfileForm(instance=profile)
        return render(request, "profiles/update.html", context)
    elif request.method == "POST":
        form = ProfileForm(request.POST, instance=profile)
        if form.is_valid():
            profile = form.save()
            if request.is_ajax():
                return HttpResponse(serialize('json', [profile, ]).strip("[]"))
            else:
                if profile.slug:
                    return redirect(reverse("profiles.views.profile.show_by_slug", args=[profile.slug]))
                else:
                    return redirect(reverse("profiles.views.profile.show", args=[profile.pk]))
        else:
            if request.is_ajax():
                return render(request, "profiles/update.html", context)
            else:
                return HttpResponse(serialize('json', form.errors))
    return HttpResponse()
Exemple #51
0
    def test_form_instructor_labels(self):
        '''
        Test labels are tailored
        to instructor if user is instructor
        '''
        profile = UserProfile.objects.get(user__username='******')
        login_successful = self.client.login(username=profile.user.username,
                                             password='******')
        self.assertTrue(login_successful)

        form = ProfileForm(instance=profile)
        self.assertEqual(form.fields['profile_description'].label,
                         ('Instructor Studio Info'))
Exemple #52
0
def profile_edit(request, template_name="profiles/profile_edit.html"):

    profile = request.user.get_profile()
    form = ProfileForm(request.POST or None, instance=profile)

    if form.is_valid():
        print form.instance.__dict__
        form.save()
        msg = 'Profile edited'
        messages.add_message(request, messages.INFO, msg)
        return HttpResponseRedirect(reverse("profile_detail", kwargs={"github_account": profile.github_account}))

    # TODO - move this to a template
    github_account = """
    <div
        id="div_id_github_account"
        class="ctrlHolder"><label for="id_github_account" >Github account</label><strong>{0}</strong></div>
    """.format(profile.github_account)

    helper = FormHelper()
    helper.form_class = "profile-edit-form"
    helper.layout = Layout(
        Fieldset(
            '',
            HTML(github_account),
            'bitbucket_url',
            'google_code_url',
        ),
        ButtonHolder(
            Submit('edit', 'Edit', css_class="awesome forestgreen"),
        )
    )

    return render(request, template_name,
        {
            "profile": profile,
            "form": form,
            "helper": helper,
        })
Exemple #53
0
def edit_profile(request, username):
    """
    Displays a form to edit the current user's profile.

    This page should only be assessible to the profile's owner. If the form is
    valid, the profile is updated and the view redirects to the profile
    consultation view.

    :param request: request object
    :param username: login name of the user whom profile is to be edited
    """

    user = get_object_or_404(User, username=username)
    # The following line should reject any illegitimate accesses :
    if request.user != user:
        raise PermissionDenied

    user_profile = get_object_or_404(Profile, user=user.id)

    profile_edition_form = ProfileForm(
        request.POST or None,
        request.FILES or None,
        instance=user_profile)

    if profile_edition_form.is_valid():
        profile_edition_form.save()
        messages.success(request, u'Votre profil a bien été mis à jour.')

    elif request.POST:
        messages.error(request, u'Erreur lors de la modification du profil.')

    return render_to_response(
        "profile_edition.html",
        {
            'request': request,
            'profile_edition_form': profile_edition_form,
        },
        context_instance=RequestContext(request))
Exemple #54
0
def profile(request, username, template_name="profiles/profile.html"):
    other_user = get_object_or_404(User, username=username)
    profile = other_user.get_profile()
    try:
        cal = Calendar.objects.get(pk=1)
    except Calendar.DoesNotExist:
        cal = Calendar(name="Community Calendar")
        cal.save()
    if request.user.is_authenticated():
        if request.user == other_user:
            is_me = True
        else:
            is_me = False
    else:
        is_me = False
    
    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

    return render_to_response(template_name, {
        "profile_form": profile_form,
        "is_me": is_me,
        "other_user": other_user,
        "profile": profile,
        "calendar": cal,
    }, context_instance=RequestContext(request))
Exemple #55
0
def profile_edit(request):
	page_title = "Edit Profile"
	profile, created = Profile.objects.get_or_create(user=request.user)
	form = ProfileForm(request.POST or None, request.FILES or None, instance=profile)

	projects = Project.objects.filter(user=request.user)
	projects_count = projects.count()
	form.fields["featured_project"].queryset = projects

	if form.is_valid():
		instance = form.save(commit=False)
		instance.user = request.user
		instance.save()
		return redirect ("profile_user")

	context = {
	'profile': profile,
	'form': form, 
	'page_title': page_title,
	'projects_count': projects_count,
	}

	return render(request, 'profile_settings.html', context)
def view_register(request):
    if request.method == "GET":
        user_form = UserForm()
        profile_form = ProfileForm()
        rater_form = RaterForm()
    elif request.method == "POST":
        user_form = UserForm(request.POST)
        rater_form = RaterForm(request.POST)
        profile_form = ProfileForm(request.POST)
        if user_form.is_valid() and rater_form.is_valid():
            user = user_form.save()
            rater = rater_form.save(commit=False)
            rater.user = user
            profile = profile_form.save(commit=False)
            profile.user = user
            profile.age = rater.age
            profile.gender = rater.gender
            profile.save()
            rater.save()

            password = user.password
            # The form doesn't know to call this special method on user.
            user.set_password(password)
            user.save()

            # You must call authenticate before login. :(
            user = authenticate(username=user.username,
                                password=password)
            login(request, user)
            messages.add_message(
                request,
                messages.SUCCESS,
                "Congratulations, {}, on creating your new account! You are now logged in.".format(
                    user.username))
            return redirect('/')
    return render(request, "profiles/register.html", {'user_form': user_form,
                                                   'rater_form': rater_form})
Exemple #57
0
def create(request):
    try:
        request.user.get_profile()
        return http.HttpResponseRedirect(reverse('profiles_show', kwargs={
            'username': request.user.username
        }))
    except Profile.DoesNotExist:
        pass
    form = ProfileForm()
    if request.method == 'POST':
        form = ProfileForm(request.POST, request.FILES)
        if form.is_valid():
            profile = form.save(commit=False)
            profile.user = request.user
            hashed_email = hashlib.md5(
                request.user.email.lower().strip()).hexdigest()
            profile.hashed_email = hashed_email
            profile.save()
            return http.HttpResponseRedirect(reverse('profiles_show', kwargs={
                'username': profile.user.username,
            }))
    return render_to_response('profiles/create.html', {
        'form': form,
    }, context_instance=RequestContext(request))
def editProfile(request):
	user = request.user.username
	profile = Profile.objects.get(username=user)

	if request.POST:
		form = ProfileForm(request.POST, request.FILES, instance=profile)
		
		if form.is_valid():
			form.save()
			
			# create hash name for profile image
			signer = Signer()
			img_hash = signer.sign('p-img-' + user)
			
			data = form.cleaned_data
			
			if data['profile_pic'] == '':
				folder = '/home/phoenix470/swt/media/static/assets/uploaded_files'
				imgurl = 'http://terryshoemaker.files.wordpress.com/2013/03/placeholder1.jpg'
				urllib.urlretrieve(imgurl, folder + '/' + img_hash + '.jpg')
			else:
				folder = '/home/phoenix470/swt/media/static/assets/uploaded_files'
				imgurl = data['profile_pic']
				urllib.urlretrieve(imgurl, folder + '/' + img_hash + '.jpg')
			
			return HttpResponseRedirect('/swt/profiles/')

	else:
		form = ProfileForm(instance=profile)

	args = {}
	args.update(csrf(request))

	args['form'] = form

	return render_to_response('profile-edit.html', args)
def settings(request):
    if request.method == "POST":
        p = Profile.objects.get(user=request.user)
        if p is None:
            p = Profile(user=request.user)

        form = ProfileForm(request.POST, request.FILES, instance=p)
        if form.is_valid():
            form.save()
            return redirect(reverse("settings"))
        else:
            return render(request, "profiles/settings.html", {"f": form})
    else:
        p = Profile.objects.get(user=request.user)
        if p is None:
            form = ProfileForm()
        else:
            form = ProfileForm(instance=p)
        return render(request, "profiles/settings.html", {"f": form})
Exemple #60
0
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))