def register(request): if request.method == 'POST': form = UserCreationForm(request.POST) pform = UserProfileForm(request.POST) if form.is_valid() and pform.is_valid(): import logging logger = logging.getLogger('django.request') logger.info('New registered user\n'+str(request).replace('\n','\n\t')) new_user = form.save() pform.instance.user = new_user pform.save() if pform.instance.fladRequest: from django.core.mail import send_mail send_mail('FLAD request', '{} requested to use FLAD.'.format(new_user.username), '*****@*****.**', ['*****@*****.**'], fail_silently=True) #Set FLAD test configuration for all new users from myflq.models import FLADconfig fc=FLADconfig(user=new_user,FLAD="forensic.ugent.be/flax", FLADname="testname",FLADkey="testkey") fc.save() return HttpResponseRedirect("/") else: form = UserCreationForm() pform = UserProfileForm() return render(request, "registration/register.html", { 'form': form, 'pform': pform, })
def register(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.username = user.email user.set_password(user.password) user.save() # Since we need to set the user attribute ourselves, we set commit=False. # This delays saving the model until we're ready to avoid integrity problems. profile = profile_form.save(commit=False) profile.user = user profile.email = user.email profile.first_name = user.first_name profile.last_name = user.last_name profile.save() registered = True else: print user_form.errors, profile_form.errors # Not a HTTP POST, so we render our form using two ModelForm instances. else: user_form = UserForm() profile_form = UserProfileForm() return render(request, 'main/home.html', {'user_form': user_form, 'profile_form': profile_form} )
def profile_settings(request, username): context = RequestContext(request) content_user = check_and_set_user(request, username) context.content_user = content_user profile, created = UserProfile.objects.get_or_create(user=content_user) if request.method == 'POST': form = UserProfileForm(request.POST, instance=profile) if form.is_valid(): # get user # user.email = cleaned_email form.instance.user.email = form.cleaned_data['email'] form.instance.user.save() form.save() # todo: add string rep. of settings to see what changed audit = {} audit_log( Actions.PROFILE_SETTINGS_UPDATED, request.user, content_user, _("Profile settings updated."), audit, request) return HttpResponseRedirect(reverse( public_profile, kwargs={'username': request.user.username} )) else: form = UserProfileForm( instance=profile, initial={"email": content_user.email}) return render_to_response("settings.html", {'form': form}, context_instance=context)
def restore_object(self, attrs, instance=None): def _get_first_last_names(name): name_split = name.split() first_name = name_split[0] last_name = u'' if len(name_split) > 1: last_name = u' '.join(name_split[1:]) return first_name, last_name params = copy.deepcopy(attrs) username = attrs.get('user.username', None) password = attrs.get('user.password', None) name = attrs.get('name', None) email = attrs.get('user.email', None) if username: params['username'] = username if email: params['email'] = email if password: params.update({'password1': password, 'password2': password}) if instance: form = UserProfileForm(params, instance=instance) # form.is_valid affects instance object for partial updates [PATCH] # so only use it for full updates [PUT], i.e shallow copy effect if not self.partial and form.is_valid(): instance = form.save() # get user if email: instance.user.email = form.cleaned_data['email'] if name: first_name, last_name = _get_first_last_names(name) instance.user.first_name = first_name instance.user.last_name = last_name if email or name: instance.user.save() return super( UserProfileSerializer, self).restore_object(attrs, instance) #return instance # TODO: updates form = RegistrationFormUserProfile(params) if form.is_valid(): first_name, last_name = _get_first_last_names(name) new_user = User(username=username, first_name=first_name, last_name=last_name, email=email) new_user.set_password(password) new_user.save() created_by = self.context['request'].user profile = UserProfile( user=new_user, name=attrs.get('name', u''), created_by=created_by, city=attrs.get('city', u''), country=attrs.get('country', u''), organization=attrs.get('organization', u''), home_page=attrs.get('home_page', u''), twitter=attrs.get('twitter', u'')) return profile else: self.errors.update(form.errors) return attrs
def register(request): # A boolean value for telling the template whether the registration was successful. # Set to False initially. Code changes value to True when registration succeeds. registered = False # If it's a HTTP POST, we're interested in processing form data. if request.method == 'POST': # Attempt to grab information from the raw form information. # Note that we make use of both UserForm and UserProfileForm. user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) # If the two forms are valid... if user_form.is_valid() and profile_form.is_valid(): # Save the user's form data to the database. user = user_form.save() # Now we hash the password with the set_password method. # Once hashed, we can update the user object. user.set_password(user.password) user.save() # Now sort out the UserProfile instance. # Since we need to set the user attribute ourselves, we set commit=False. # This delays saving the model until we're ready to avoid integrity problems. profile = profile_form.save(commit=False) profile.user = user # Did the user provide a profile picture? # If so, we need to get it from the input form and put it in the UserProfile model. if 'picture' in request.FILES: profile.picture = request.FILES['picture'] # Now we save the UserProfile model instance. profile.save() # Update our variable to tell the template registration was successful. registered = True # Invalid form or forms - mistakes or something else? # problems to the terminal. # They'll also be shown to the user. else: print user_form.errors, profile_form.errors # Not a HTTP POST, so we render our form using two ModelForm instances. # These forms will be blank, ready for user input. else: user_form = UserForm() profile_form = UserProfileForm() # Render the template depending on the context. return render(request, 'main/register.html', {'user_form': user_form, 'profile_form': profile_form, 'registered': registered} )
def profile_settings(request, username): context = RequestContext(request) content_user = check_and_set_user(request, username) context.content_user = content_user profile, created = UserProfile.objects.get_or_create(user=content_user) if request.method == "POST": form = UserProfileForm(request.POST, instance=profile) if form.is_valid(): form.save() return HttpResponseRedirect(reverse(public_profile, kwargs={"username": request.user.username})) else: form = UserProfileForm(instance=profile) return render_to_response("settings.html", {"form": form}, context_instance=context)
def profile(request): user_form = EditUserForm(instance=request.user) profile_form = UserProfileForm(instance=request.user.get_profile()) if request.method == 'POST': user_form = EditUserForm(request.POST, instance=request.user) profile_form = UserProfileForm(request.POST, instance=request.user.get_profile()) if user_form.is_valid() and profile_form.is_valid(): user_form.save() profile_form.save() return redirect('talent', request.user.username) return render_to_response('profile.html', { 'user_form': user_form, 'profile_form': profile_form, }, RequestContext(request))
def patient_profile(request): """ RENDERS PATIENT PROFILE TO BE UPDATED """ user_form = UserProfileForm(request.POST or None, instance=request.user) patient_form = PatientForm(request.POST or None, instance=request.user.user_category.patient) if patient_form.is_valid() and user_form.is_valid(): user_form.save() patient_form.save() messages.success(request, "successfully updated") sleep(1) return HttpResponseRedirect(reverse("main:home")) else: pass return render(request, "patient_form.html", {"user_form":user_form, "patient_form":patient_form})
def doctor_profile(request): """ RENDERS DOCTOR PROFILE PAGE TO BE UPDATED """ user_form = UserProfileForm(request.POST or None, instance=request.user) doctor_form = DoctorForm(request.POST or None, instance=request.user.user_category.doctor) if doctor_form.is_valid() and user_form.is_valid(): user_form.save() doctor_form.save() messages.success(request, "successfully updated") sleep(1) return HttpResponseRedirect(reverse("main:home")) else: pass return render(request, "doctor_form.html", {"user_form":user_form, "doctor_form":doctor_form})
def edit_profile(request): profile = request.user.get_profile() user_form = UserForm(instance=request.user) userprofile_form = UserProfileForm(instance=profile) if request.method == 'POST': user_form = UserForm(request.POST, instance=request.user) userprofile_form = UserProfileForm(request.POST, instance=profile) if user_form.is_valid() and userprofile_form.is_valid(): #assert False, (user_form.cleaned_data, request.user, user_form.save()) user_form.save() userprofile_form.save() return redirect('sesion') return render_to_response('editprofile.html', { 'user_form': user_form, 'userprofile_form': userprofile_form, }, RequestContext(request))
def register(request): if request.method == 'POST': form = UserCreationForm(request.POST) pform = UserProfileForm(request.POST) if form.is_valid() and pform.is_valid(): import logging logger = logging.getLogger('django.request') logger.info('New registered user\n' + str(request).replace('\n', '\n\t')) new_user = form.save() pform.instance.user = new_user pform.save() if pform.instance.fladRequest: from django.core.mail import send_mail send_mail('FLAD request', '{} requested to use FLAD.'.format( new_user.username), '*****@*****.**', ['*****@*****.**'], fail_silently=True) #Set FLAD test configuration for all new users from myflq.models import FLADconfig fc = FLADconfig(user=new_user, FLAD="forensic.ugent.be/flax", FLADname="testname", FLADkey="testkey") fc.save() return HttpResponseRedirect("/") else: form = UserCreationForm() pform = UserProfileForm() return render(request, "registration/register.html", { 'form': form, 'pform': pform, })
def home_submit(request): user = User.objects.get(pk=1) if request.method == 'POST': keywordform = KeywordForm(data=request.POST, prefix='keyword') userform = UserForm(data=request.POST, instance=user) userprofileform = UserProfileForm(data=request.POST, instance=user.userprofile, prefix='userprofile') if keywordform.is_valid(): keywordform.save() if userprofileform.is_valid(): user = userform.save() profile = userprofileform.save() result = {'status': 'Update Succesfull'} return HttpResponseRedirect('/')
def test_home_page_returns_correct_html(self): from django.contrib.auth.forms import UserCreationForm from main.forms import UserProfileForm request = HttpRequest() response = homepage(request) expected_html = render_to_string('main/home.html', { 'userform': UserCreationForm(), 'profileform': UserProfileForm() }) self.assertEqual(response.content.decode(), expected_html)
def register(request): registered = False if request.method == 'POST': user_form = UserForm(request.POST) profile_form = UserProfileForm(request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user profile.save() registered = True else: print(user_form.errors, profile_form.errors) else: user_form = UserForm() profile_form = UserProfileForm() context_dict={} context_dict['user_form'] = user_form context_dict['profile_form'] = profile_form context_dict['registered'] = registered response = render(request, 'main/signup.html', context_dict) return response
def restore_object(self, attrs, instance=None): def _get_first_last_names(name): name_split = name.split() first_name = name_split[0] last_name = u'' if len(name_split) > 1: last_name = u' '.join(name_split[1:]) return first_name, last_name params = copy.deepcopy(attrs) username = attrs.get('user.username', None) password = attrs.get('user.password', None) name = attrs.get('name', None) email = attrs.get('user.email', None) if username: params['username'] = username if email: params['email'] = email if password: params.update({'password1': password, 'password2': password}) if instance: form = UserProfileForm(params, instance=instance) # form.is_valid affects instance object for partial updates [PATCH] # so only use it for full updates [PUT], i.e shallow copy effect if not self.partial and form.is_valid(): instance = form.save() # get user if email: instance.user.email = form.cleaned_data['email'] if name: first_name, last_name = _get_first_last_names(name) instance.user.first_name = first_name instance.user.last_name = last_name if email or name: instance.user.save() return super(UserProfileSerializer, self).restore_object(attrs, instance) #return instance # TODO: updates form = RegistrationFormUserProfile(params) if form.is_valid(): first_name, last_name = _get_first_last_names(name) new_user = User(username=username, first_name=first_name, last_name=last_name, email=email) new_user.set_password(password) new_user.save() created_by = self.context['request'].user profile = UserProfile(user=new_user, name=attrs.get('name', u''), created_by=created_by, city=attrs.get('city', u''), country=attrs.get('country', u''), organization=attrs.get('organization', u''), home_page=attrs.get('home_page', u''), twitter=attrs.get('twitter', u'')) return profile else: self.errors.update(form.errors) return attrs
def register(request): context_dict = {} registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(request.POST, request.FILES) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save() user.set_password(user.password) user.save() profile = profile_form.save(commit=False) profile.user = user if 'profile_picture' in request.FILES: profile.profile_picture = request.FILES['profile_picture'] profile.save() registered = True else: user_form = UserForm() profile_form = UserProfileForm() context_dict['user_form'] = user_form context_dict['profile_form'] = profile_form context_dict['registered'] = registered return render(request, 'main/register.html', context_dict)
def register(request): registered = False if request.method == 'POST': user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) if user_form.is_valid() and profile_form.is_valid(): user = user_form.save( commit=False) # don't save it in the database yet user.set_password( user.password ) # set_password function ensures hashing before saving user.is_active = False user.save() profile = profile_form.save( commit=False) # don't save it in the database yet profile.user = user # sets the one to one relationship profile.activationCode = randint(1000, 9999) if 'profilePicture' in request.FILES: profile.profilePicture = request.FILES['profilePicture'] registered = True profile.save() # emailing the user using a html template. if the template doesn't work, a txt file gets used as an alternative subject = 'Welcome! - Intelligent Q&A Forums' email_to = [user.email] with open(settings.BASE_DIR + "/main/templates/main/authentication/sign_up_email.txt" ) as temp: sign_up_email = temp.read() email = EmailMultiAlternatives(subject=subject, body=sign_up_email, from_email=settings.EMAIL_HOST_USER, to=email_to) html = get_template( "main/authentication/sign_up_email.html").render({ 'user': user, 'activationCode': profile.activationCode }) email.attach_alternative(html, "text/html") email.send() else: user_form = UserForm() profile_form = UserProfileForm() return render( request, 'main/authentication/registration.html', { 'user_form': user_form, 'profile_form': profile_form, 'registered': registered })
def homepage(request): from django.contrib.auth.forms import UserCreationForm from main.forms import UserProfileForm registered = False uform = UserCreationForm() pform = UserProfileForm() if request.method == 'POST': uform = UserCreationForm(request.POST) pform = UserProfileForm(request.POST) if uform.is_valid() and pform.is_valid(): new_user = uform.save() pform.instance.user = new_user pform.save() return redirect('/?registration=success') if request.method == 'GET' and 'registration' in request.GET: registered = True return render(request, 'main/home.html', {'userform': uform, 'profileform': pform, 'registered': registered})
def edit_profile(request): context = RequestContext(request) context_dict = {} old_profile = get_object_or_404(Researcher, user=request.user) if request.method == 'POST': profile_form = UserProfileForm(data=request.POST) if profile_form.is_valid(): if 'profile_picture' in request.FILES: old_profile.profile_picture = request.FILES['profile_picture'] old_profile.website = profile_form.cleaned_data["website"] old_profile.display_name = profile_form.cleaned_data[ "display_name"] old_profile.organization = profile_form.cleaned_data[ "organization"] old_profile.save() return HttpResponseRedirect( reverse("view_profile", kwargs={"userId": request.user.id})) else: profile_form = UserProfileForm(instance=old_profile) context_dict['profile_form'] = profile_form return render_to_response('main/edit_profile.html', context_dict, context)
def profile_settings(request, username): context = RequestContext(request) content_user = check_and_set_user(request, username) context.content_user = content_user profile, created = UserProfile.objects.get_or_create(user=content_user) if request.method == 'POST': form = UserProfileForm(request.POST, instance=profile) if form.is_valid(): form.save() return HttpResponseRedirect(reverse(public_profile, kwargs={'username': request.user.username})) else: form = UserProfileForm(instance=profile) return render_to_response("settings.html", { 'form': form }, context_instance=context)
def user_update(request): # Like before, get the request's context. context = RequestContext(request) user = request.user user_profile = UserProfile.objects.get(user=user.id) if request.method == 'POST': user_form = UserUpdateForm(data=request.POST, instance=user) profile_form = UserProfileForm(data=request.POST, instance=user_profile) if (user_form.is_valid() and profile_form.is_valid()): user_form.save() profile_form.save() return HttpResponseRedirect(reverse('index')) else: user_form = UserUpdateForm(instance=user) profile_form = UserProfileForm(instance=user_profile) return render_to_response('main/edit_profile.html', { 'user_form': user_form, 'profile_form': profile_form }, context)
def account_settings(request): user = request.user userprofile = UserProfile.objects.get(user=user) userprofileform = UserProfileForm(instance=userprofile) userform = UserForm(instance=user) if request.method == 'POST': userprofileform = UserProfileForm(data=request.POST, files=request.FILES, instance=userprofile) userform = UserForm(request.POST, instance=user) if userform.is_valid() and userprofileform.is_valid(): userprofileform.save() userform.save() return HttpResponseRedirect(reverse('settings')) context = {'userprofileform': userprofileform, 'userform': userform} return render(request, 'accounts/account_settings.html', context)
def homepage(request): from django.contrib.auth.forms import UserCreationForm from main.forms import UserProfileForm registered = False uform = UserCreationForm() pform = UserProfileForm() if request.method == 'POST': uform = UserCreationForm(request.POST) pform = UserProfileForm(request.POST) if uform.is_valid() and pform.is_valid(): new_user = uform.save() pform.instance.user = new_user pform.save() return redirect('/?registration=success') if request.method == 'GET' and 'registration' in request.GET: registered = True return render(request, 'main/home.html', { 'userform': uform, 'profileform': pform, 'registered': registered })
def registration(request): # Like before, get the request's context. context = RequestContext(request) # A boolean value for telling the template whether the registration was successful. # Set to False initially. Code changes value to True when registration succeeds. registered = False # If it's a HTTP POST, we're interested in processing form data. if request.method == 'POST': # Attempt to grab information from the raw form information. # Note that we make use of both UserForm and UserProfileForm. user_form = UserForm(data=request.POST) profile_form = UserProfileForm(data=request.POST) user_type_form = UserTypeForm(data=request.POST) # If the two forms are valid... if user_form.is_valid() and profile_form.is_valid( ) and user_type_form.is_valid(): # Save the user's form data to the database. user = user_form.save() # Now we hash the password with the set_password method. # Once hashed, we can update the user object. user.set_password(user.password) user.save() nickname = profile_form.cleaned_data['nickname'] # Now sort out the Student instance. # Since we need to set the user attribute ourselves, we set commit=False. # This delays saving the model until we're ready to avoid integrity problems. user_type = user_type_form.cleaned_data['user_type'] user_type = int(user_type) #user_type = 1 if user_type: profile = Student(nickname=nickname) else: profile = Instructor(nickname=nickname) profile.user = user # Add the personal calendar for the user calendar = Calendar(name=user.username + "'s personal calendar") calendar.save() profile.cal = calendar profile.school = None # Now we save the Student model instance. profile.save() # Update our variable to tell the template registration was successful. registered = True # Invalid form or forms - mistakes or something else? # Print problems to the terminal. # They'll also be shown to the user. else: print user_form.errors, profile_form.errors, user_type_form.errors # Not a HTTP POST, so we render our form using two ModelForm instances. # These forms will be blank, ready for user input. else: user_form = UserForm() profile_form = UserProfileForm() user_type_form = UserTypeForm() # Render the template depending on the context. return render_to_response( 'main/register.html', { 'user_form': user_form, 'profile_form': profile_form, 'user_type_form': user_type_form, 'registered': registered }, context)
def test_userProfile_create_form_valid(self): form = UserProfileForm(data={ 'profilePicture': None # a display photo is not compulsory }) self.assertTrue(form.is_valid())