def post(self, request, *args, **kwargs): context = super(StaffFormView, self).get_context_data(**kwargs) context['departments'] = CompanyDepartments.objects.all() profile_form = UserProfileFrom(request.POST) form = UserCreateForm(request.POST) if form.is_valid() and profile_form.is_valid(): new_user = form.save() new_user.email = request.POST.get('username') new_user.save() try: department_id = CompanyDepartments.objects.get(uuid=request.POST.get('department')) except CompanyDepartments.DoesNotExist: department_id = None user_profile = UserProfile( user_id=new_user, phone=request.POST.get('phone'), home_phone=request.POST.get('home_phone'), work_phone=request.POST.get('office_phone'), department=department_id, designation=request.POST.get('designation') ) user_profile.save() return HttpResponseRedirect("/staff-list/") else: context['form'] = form context['profile_form'] = profile_form return render(request, self.template_name, context)
def user_create(request): from hashlib import sha1 ctx = {} username = request.REQUEST.get("username") password = request.REQUEST.get("password") signature = request.REQUEST.get("signature") email = request.REQUEST.get("email", "") m = sha1() m.update(":" + username + ":" + password + ":" + settings.SHARED_SECRET + ":") if m.hexdigest() != signature: ctx["ok"] = False return ctx (user, created) = User.objects.get_or_create(username=username) user.is_active = True user.email = email user.set_password(password) user.save() pro = UserProfile() pro.user = user pro.save() p = Polity.objects.get(id=1) p.members.add(user) ctx["ok"] = True ctx["username"] = user.username ctx["id"] = user.id return ctx
def create(self, validated_data): user = User.objects.create_user(**validated_data.pop('user'), is_staff=True) _profile = UserProfile(**validated_data, user=user) _profile.save() return _profile
def create_inactive_user(self, username, email, password, first_name, last_name, career, favorite, gender, age, address, phone, city, state, country, zip, send_email=True, profile_callback=None ): """ Create a new, inactive ``User``, generate a ``RegistrationProfile`` and email its activation key to the ``User``, returning the new ``User``. By default, an activation email will be sent to the new user. To disable this, pass ``send_email=False``. """ new_user = User.objects.create_user(username, email, password) new_user.email = email new_user.first_name = first_name new_user.last_name = last_name new_user.is_active = False """ set default user_group when registration """ new_user.save() new_profile = UserProfile(user=new_user, career=career, gender=gender, age=age, address=address, phone=phone, city=city, state=state, country=country, zip=zip ) new_profile.save() registration_profile = self.create_profile(new_user) if send_email: from django.core.mail import send_mail current_site = Site.objects.get_current() subject = render_to_string('registration/activation_email_subject.txt', { 'site': current_site }) # Email subject *must not* contain newlines subject = ''.join(subject.splitlines()) fullname = new_user.last_name + " " + new_user.first_name message = render_to_string('registration/activation_email.txt', { 'activation_key': registration_profile.activation_key, 'expiration_days': settings.ACCOUNT_ACTIVATION_DAYS, 'site': current_site, 'fullname': fullname, }) send_mail(subject, message, settings.DEFAULT_FROM_EMAIL, [new_user.email]) return new_user
def populate_users(): print("Populating users...") users = [{ "username": "******", "first_name": "", "last_name": "", "email": "", "password": make_password("admin"), "is_staff": True, "is_admin": True, "is_superuser": True }, { "username": "******", "first_name": "Bobby", "last_name": "Renson", "email": "*****@*****.**", "password": make_password("test"), "is_staff": False, "is_admin": False, "is_superuser": False }, { "username": "******", "first_name": "Meghan", "last_name": "Bright", "email": "*****@*****.**", "password": make_password("test"), "is_staff": False, "is_admin": False, "is_superuser": False }, { "username": "******", "first_name": "Victoire", "last_name": "Vert", "email": "*****@*****.**", "password": make_password("test"), "is_staff": False, "is_admin": False, "is_superuser": False }] for data in users: user, created = User.objects.get_or_create(username=data['username']) if created: user.first_name = data['first_name'] user.last_name = data['last_name'] user.email = data['email'] user.password = data['password'] user.is_staff = data['is_staff'] user.is_admin = data['is_admin'] user.is_superuser = data['is_superuser'] user.save() profile = UserProfile( user=User.objects.get(username=data['username']), profile_pic="profile_images/" + data['username'].lower() + "-profile.jpg") profile.save()
def save(self, commit=True): user = super(SgzUserCreationForm, self).save(commit=False) user.email = '{}@neverland.cc'.format(user.username) if commit: user.save() profile = UserProfile(user=user) profile.save() return user
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationForm, current_app=None, extra_context=None): """ Displays the login form and handles the login action. """ redirect_to = request.POST.get(redirect_field_name, request.GET.get(redirect_field_name, '')) if request.method == "POST": form = authentication_form(request, data=request.POST) if form.is_valid(): # Ensure the user-originating redirection url is safe. if not is_safe_url(url=redirect_to, host=request.get_host()): redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL) # Okay, security check complete. Log the user in. auth_login(request, form.get_user()) # Make sure that profile exists try: UserProfile.objects.get(user=request.user) except UserProfile.DoesNotExist: profile = UserProfile() profile.user = request.user profile.save() if hasattr(settings, 'SAML_1'): # Is SAML 1.2 support enabled? if not request.user.userprofile.verified_ssn: return HttpResponseRedirect(settings.SAML_1['URL']) if hasattr(settings, 'ICEPIRATE'): # Is IcePirate support enabled? configure_external_member_db(request.user, create_if_missing=False) return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) current_site = get_current_site(request) context = { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, } if extra_context is not None: context.update(extra_context) return TemplateResponse(request, template_name, context, current_app=current_app)
def create(self, validated_data): user_data = validated_data.pop('user') # create user profile user = User.objects.create_user(**user_data) # create user profile user_profile = UserProfile(**validated_data, user=user) user_profile.save() return user_profile
def setUp(self): self.user = UserProfile(email='*****@*****.**', name='Test', url='https://test.com/postback/', password='******') self.user.save() self.obj = StatusProcess(user_profile=self.user, id_process='12345678901', status_process='Em análise') self.obj.save()
def login(request, template_name='registration/login.html', redirect_field_name=REDIRECT_FIELD_NAME, authentication_form=AuthenticationForm, current_app=None, extra_context=None): """ Displays the login form and handles the login action. """ redirect_to = request.POST.get(redirect_field_name, request.GET.get(redirect_field_name, '')) if request.method == "POST": form = authentication_form(request, data=request.POST) if form.is_valid(): # Ensure the user-originating redirection url is safe. if not is_safe_url(url=redirect_to, host=request.get_host()): redirect_to = resolve_url(settings.LOGIN_REDIRECT_URL) # Okay, security check complete. Log the user in. auth_login(request, form.get_user()) # Make sure that profile exists try: UserProfile.objects.get(user=request.user) except UserProfile.DoesNotExist: profile = UserProfile() profile.user = request.user profile.save() request.session[LANGUAGE_SESSION_KEY] = request.user.userprofile.language if hasattr(settings, 'SAML_1'): # Is SAML 1.2 support enabled? if not request.user.userprofile.user_is_verified(): return HttpResponseRedirect(settings.SAML_1['URL']) if hasattr(settings, 'ICEPIRATE'): # Is IcePirate support enabled? configure_external_member_db(request.user, create_if_missing=False) return HttpResponseRedirect(redirect_to) else: form = authentication_form(request) current_site = get_current_site(request) context = { 'form': form, redirect_field_name: redirect_to, 'site': current_site, 'site_name': current_site.name, } if extra_context is not None: context.update(extra_context) return TemplateResponse(request, template_name, context, current_app=current_app)
def forwards(self, orm): "Whitelist any user who has whitelisted projects." for project in Project.objects.all(): if project.whitelisted: # If user doesn't have a profile, create one try: profile = project.user.get_profile() except ObjectDoesNotExist: profile = UserProfile(user=project.user) # Whitelist the user's profile profile.whitelisted = True profile.save()
def process_request(self, request): if request.user.is_authenticated(): try: request.session['django_language'] = request.user.get_profile().language except AttributeError: # pass pro = UserProfile() pro.user = request.user pro.language = settings.LANGUAGE_CODE pro.save() request.session['django_language'] = pro.language else: request.session['django_language'] = "is"
def create_user(self, is_active, device_id, email=None): consumer_id = generate_unique_customer_id() password = consumer_id + settings.PASSWORD_POSTFIX user_obj = User.objects.create(username=consumer_id) user_obj.set_password(password) user_obj.is_active = is_active if email: user_obj.email = email user_obj.save(using=settings.BRAND) bituser_obj = UserProfile(user=user_obj, device_id=device_id) bituser_obj.save() return {'bituser_obj': bituser_obj}
def adduser(request, ssn=None, name=None, email=None, added=None, username=None): if ssn is None: assert(request.GET.get('key') == settings.ICEPIRATE['key']) # Parse args... ssn = ssn or request.GET.get('ssn') name = name or request.GET.get('name') email = email or request.GET.get('email') added = added or request.GET.get('added') username = username or request.GET.get('username') if added: added = datetime.strptime(added, '%Y-%m-%d %H:%M:%S') else: added = timezone.now() # Look up all the users that match users = [] if ssn: users.extend(User.objects.filter(userprofile__verified_ssn=ssn)) if username: users.extend(User.objects.filter(username=username)) if email: users.extend(User.objects.filter(email=email)) # Update or create user try: user = users[0] # Sanity checks... assert(len([u for u in users if u != user]) == 0) if user.userprofile.verified_ssn: assert(user.userprofile.verified_ssn == ssn) else: # User exist, is not verified! Just update SSN. user.userprofile.verified_ssn = ssn user.userprofile.save() except IndexError: # User does not exist. Create user, yay! if not username: username = _make_username(name, email) user = User(username=username, email=email) user.save() prof = UserProfile(user=user, verified_ssn=ssn, joined_org=added) prof.save() response_data = _icepirate_user_data(user) response_data.update({ 'reset_url': _password_reset_url(user), 'success': True}) return HttpResponse( json.dumps(response_data), content_type='application/json')
def load_users(file): print '\nimporting users' for e in json.load(file): try: user = User.objects.filter(username=e['username']).get() except User.DoesNotExist: user = User.objects.create_user(e['username'], e['email'], 'asdfgh') user.save() profile = UserProfile(user=user) profile.save() print '.', sys.stdout.flush()
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): new_user = form.save() username = new_user.username email = new_user.email password = request.POST['password1'] salt = hashlib.sha1(str(random.random())).hexdigest()[:5] activation_key = hashlib.sha1(salt + email).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) #Get user by username user = get_user_model().objects.get(username=username) # Create and save user profile new_profile = UserProfile(user=user, activation_key=activation_key, key_expires=key_expires) new_profile.save() # Send email with activation key email_subject = 'Account confirmation' email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \ 48hours http://ivebeenfound-dev2.elasticbeanstalk.com/accounts/confirm/%s" % ( username, activation_key) send_mail(email_subject, email_body, '*****@*****.**', [email], fail_silently=False) context = RequestContext(request, { 'request': request, 'user': request.user, 'email': email }) return render_to_response('public/confirm_sent.html', context_instance=context) else: pass context = RequestContext(request, { 'request': request, 'user': request.user }) return render_to_response('public/registration_form.html', context_instance=context)
def search_people(self): qu = self.request.get('q', '') index = search.Index(name='profileIndex') query = index.search(qu) profiles = [UserProfile.get_by_id(int(result.doc_id)) for result in query.results] return self.render('app/search_people_result.html', profiles=profiles, search_term=qu)
def update_members(self, year): with in_database(str(year), write=True): try: members = ws.get(url=self.WS_URL_DETAIL % (self.code, year), use_redis=False)[0]['miembros'] except KeyError: logger.warn(self.type + " " + self.code + " does not exist in WS_URL_DETAIL for year " + year) return # This happens if the webservices are not that good. for member in members: try: up = UserProfile.objects.get( rrhh_code=member['cod_persona']) except UserProfile.DoesNotExist: response = ws.get(st.WS_DOCUMENT % member['cod_persona']) document = response['numero_documento'] + response['letra'] up = UserProfile.get_or_create_user(document, document)[0].profile up.rrhh_code = member['cod_persona'] up.save() up.user.first_name = member['cod_persona__nombre'] up.user.last_name = (member['cod_persona__apellido1'] + " " + member['cod_persona__apellido2'])[:30] up.user.save() ReportMember.objects.get_or_create(user_profile=up) setattr(up.reportmember, self.type, self) up.reportmember.cce = member['cod_cce__descripcion'] up.reportmember.save()
def __init__(self, request, *args, **kwargs): super(SystemObject, self).__init__(request, admin=True, *args, **kwargs) self.manager = AdminManager() self.manager.fetchOptions = { 'active': self.requester.rData['selectedactivity'], 'activesite': self.requester.rData['activesite'] } self.urls.add = 'core.view.userprofileadmin.add_item' self.urls.edit = 'core.view.userprofileadmin.edit_item' self.urls.show_items = 'core.view.userprofileadmin.show_items' self.manager.model = UserProfile() self.manager.modelLanguage = None self.manager.form_class = AdmItemForm().__class__ self.manager.language_form_class = None self.manager.order = 'username' self.manager.debugger.filename = 'userprofileadmin.py' self.manager.moduleName = '__adm_Sheet_Files__' self.data.update({ 'filter_activity': reverse('core.view.userprofileadmin.show_items') }) toppanel = { #reverse('core.view.sheetadmin.show_items'): '__adm_Sheets__', #reverse('core.view.userprofileadmin.show_items'): '__adm_User_Profiles__' } self.data.update({'toppanel': toppanel}) self.data.update({ 'savebutton': 1, 'saveaddbutton': 1, 'copybutton': 1, 'addbutton': 1 })
def get_investigadores(self, unit, title): if unit is None: return NotImplemented unit_content = ws.get(self.WS_URL_DETAIL % (unit, self.year))[0] if unit_content["unidad"] == {}: try: unit_name = filter(lambda x: x['code'] == unit, self.unit_names)[0]['name'] except (AttributeError, KeyError): unit_name = unicode(unit) logger.warn(u"La unidad " + unit_name + u" no tiene información en " + unicode(self.year)) return [], [], unit_name investigadores = [] usuarios = [] for inv in unit_content['miembros']: inv = self._check_inves(inv) investigadores.append(inv) try: up = UserProfile.objects.get(rrhh_code=inv['cod_persona']) except UserProfile.DoesNotExist: response = ws.get(st.WS_DOCUMENT % inv['cod_persona']) document = response['numero_documento'] + response['letra'] up = UserProfile.get_or_create_user(document, document)[0].profile up.rrhh_code = inv['cod_persona'] up.save() up.user.first_name = inv['cod_persona__nombre'] up.user.last_name = (inv['cod_persona__apellido1'] + " " + inv['cod_persona__apellido2'])[:30] up.user.save() usuarios.append(up) if title is None: title = unit_content['unidad']['nombre'] return investigadores, usuarios, title
def signup(request): from forms import SignupForm if request.method == 'POST': # process signup form and create account form = SignupForm(request.POST) if form.is_valid(): user = User() user.username = form.cleaned_data['username'] user.set_password(form.cleaned_data['password1']) user.email = form.cleaned_data['email'] user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.is_active = True user.save() profile = UserProfile(paid_user=True, user=user) profile.save() # send a mail with registration details from django.template.loader import render_to_string from django.core.mail import EmailMessage email = EmailMessage('Welcome to Trackpattern', render_to_string('registration/welcome_mail.txt', {'username': user.username, 'first_name': user.first_name}), from_email='*****@*****.**', to=[user.email]) email.send() _out = {'username':user.username,'email':user.email,'first_name':user.first_name,'last_name':user.last_name,'Would you like to sign up to our mailing list to receive free information about analytics and data driven marketing?' : form.cleaned_data['question_1'],'ts':str(datetime.datetime.now())} emailtoadmin = EmailMessage('Trackpattern - New user has registered',body=json.dumps(_out),from_email="*****@*****.**",to=["*****@*****.**",'*****@*****.**']) emailtoadmin.send() #reset = True # return redirect( # 'https://trackpattern.chargify.com/h/46549/subscriptions/new/?reference=%s&first_name=%s&last_name=%s&email=%s' % ( # user.id, user.first_name, user.last_name, user.email)) login_user = authenticate(username=user.username, password=form.cleaned_data['password1']) auth_login(request, login_user) return redirect('/home/') else: form = SignupForm(initial={'question_1': True}) return render_to_response('registration/signup.html', {'form': form, }, context_instance=RequestContext(request))
def notify_followers_new_content(course): followers = UserProfile.query(UserProfile.followed_courses == course) for follower in followers: notify = Notification(text='Novo conteúdo adicionado %s' %(course.get().title), profile=follower.key, ntype='icon-warning-sign' ) notify.put()
def form_valid(self, form): ''' Creates a new user ''' team = form.save() username = form.instance.name.lower().replace(' ', '') password = password_generator(8) user = User.objects.create_user(username=username, password=password) profile = UserProfile() profile.team = team profile.user = user profile.save() self.request.session['new_user'] = {'username': username, 'password': password} return super(TeamAddView, self).form_valid(form)
def authenticate(self, oauth_token=None): if oauth_token is None: return None user_info = None try: api = TroveAPI(settings.TROVE_APP_KEY, settings.TROVE_APP_SECRET, ["photos"], oauth_token) user_info = api.get_user_info() except: return None try: trove_profile = UserProfile.objects.get(trove_user_id=user_info["trove_internal_id"]) return trove_profile.user except UserProfile.DoesNotExist: user = User() if user_info.has_key("trove_username"): user.username = user_info["trove_username"] else: user.username = user_info["trove_internal_id"] # We use the trove internal id if there is no user name user.first_name = user_info["first_name"] user.last_name = user_info["last_name"] user.save() trove_profile = UserProfile() trove_profile.trove_user_id = user_info["trove_internal_id"] trove_profile.trove_access_token_key = oauth_token.key trove_profile.trove_access_token_secret = oauth_token.secret trove_profile.user = user trove_profile.save() return user
def myregister(request): form = UserRegisterForm() if request.method == 'POST': form = UserRegisterForm(request.POST) if form.is_valid(): user = form.save() username = form.cleaned_data.get('username') email = form.cleaned_data.get('email') fname = form.cleaned_data.get('first_name') lname = form.cleaned_data.get('last_name') htmly = get_template('user/email.html') d = {'username': username} subject, from_email, to = 'Welcome', '*****@*****.**', email html_content = htmly.render(d) msg = EmailMultiAlternatives(subject, html_content, from_email, [to]) msg.attach_alternative(html_content, 'text/html') msg.send() profile = UserProfile() profile.user = user profile.fname = fname profile.lname = lname profile.save() messages.success(request, 'Your Account has been successfully created!') return redirect('login') context = {'form': form} return render(request, 'user/signup.html', context)
def register(self, request, **cleaned_data): """Register a new user, saving the User and UserProfile data.""" user = User() for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) # the password has been validated by the form user.set_password(cleaned_data["password2"]) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) print "request data: image field" img_data = request.POST.get("image") # If none or len 0, means illegal image data if img_data == None or len(img_data) == 0: pass # Decode the image data img_data = base64.b64decode(img_data) filename = "%s.png" % uuid.uuid4() # XXX make the upload path a fixed setting in models, since it's # reference in two places upload_path = "data/avatars/%s/" % user.username upload_abs_path = os.path.join(settings.MEDIA_ROOT, upload_path) if not os.path.exists(upload_abs_path): os.makedirs(upload_abs_path) full_file_name = os.path.join(upload_abs_path, filename) with open(full_file_name, "wb") as f: f.write(img_data) f.close() profile.image = full_file_name profile.save() new_user = authenticate(username=user.username, password=cleaned_data["password2"]) login(request, new_user) signals.user_activated.send(sender=self.__class__, user=new_user, request=request) return new_user
def register(self, request, **cleaned_data): '''Register a new user, saving the User and UserProfile data.''' user = User() for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) # the password has been validated by the form user.set_password(cleaned_data['password2']) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) print "request data: image field" img_data = request.POST.get("image") # If none or len 0, means illegal image data if img_data == None or len(img_data) == 0: pass # Decode the image data img_data = base64.b64decode(img_data) filename = "%s.png" % uuid.uuid4() # XXX make the upload path a fixed setting in models, since it's # reference in three places upload_path = "data/avatars/%s/" % user.username upload_abs_path = os.path.join(settings.MEDIA_ROOT, upload_path) if not os.path.exists(upload_abs_path): os.makedirs(upload_abs_path) full_file_name = os.path.join(upload_abs_path, filename) with open(full_file_name, 'wb') as f: f.write(img_data) f.close() profile.image = full_file_name profile.save() new_user = authenticate(username=user.username, password=cleaned_data['password2']) login(request, new_user) signals.user_activated.send(sender=self.__class__, user=new_user, request=request) return new_user
def profile_by_user(self, profile_id): profile = UserProfile.get_by_id(int(profile_id)) if not profile: self.abort(404) can_edit = self.logged == profile return self.render('app/profile.html', profile=profile, can_edit=can_edit)
def register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): new_user = form.save() username = new_user.username email = new_user.email password = request.POST['password1'] salt = hashlib.sha1(str(random.random())).hexdigest()[:5] activation_key = hashlib.sha1(salt+email).hexdigest() key_expires = datetime.datetime.today() + datetime.timedelta(2) #Get user by username user=get_user_model().objects.get(username=username) # Create and save user profile new_profile = UserProfile(user=user, activation_key=activation_key, key_expires=key_expires) new_profile.save() # Send email with activation key email_subject = 'Account confirmation' email_body = "Hey %s, thanks for signing up. To activate your account, click this link within \ 48hours http://ivebeenfound-dev2.elasticbeanstalk.com/accounts/confirm/%s" % (username, activation_key) send_mail(email_subject, email_body, '*****@*****.**', [email], fail_silently=False) context = RequestContext(request, {'request': request, 'user': request.user, 'email': email }) return render_to_response('public/confirm_sent.html', context_instance=context) else: pass context = RequestContext(request, {'request': request, 'user': request.user }) return render_to_response('public/registration_form.html', context_instance=context)
def protweet_registration(request): if request.method == "POST": form = ProTweetRegistrationForm(request.POST) msg = {'form': form} if form.is_valid(): correct_data = form.cleaned_data #1. Creating the User try: user = User.objects.create_user ( username = correct_data['tweet_handle'].lower(), first_name = correct_data['name'], last_name = 'none', email = correct_data['email'] ) user.set_password(correct_data['password']) user.save() except Exception, e: print 'Unable to Create User' print e return HttpResponseRedirect('/') #2. Initializing UserProfile try: user_profile = UserProfile(user = user) user_profile.save() except Exception, e: print 'Unable to Initialize UserProfile' print e #ToDo: Remove the previous failed user from db return HttpResponseRedirect('/') #3. Authentication User username = correct_data.get('tweet_handle') password = correct_data.get('password') user = authenticate(username = username, password = password) #5. Loggin in the user login(request, user) return HttpResponseRedirect('/home')
def save(self): user = User( username=self.validated_data['username'], first_name=self.validated_data['first_name'], last_name=self.validated_data['last_name'], email=self.validated_data['email'], ) password = self.validated_data['password'] password2 = self.validated_data['password2'] if password != password2: raise serializers.ValidationError( {'password': '******'}) user.set_password(password) userprofile = UserProfile(user=user, user_description="Modifie ton profil", city="Modifie ton profil") user.save() userprofile.save() return user
def signup(request): """View that handles user registration.""" if request.user.is_authenticated(): return HttpResponseRedirect("/") if request.method == "GET": form = SignupForm() # Create an empty form if the method is GET. elif request.method == "POST": form = SignupForm(request.POST) # Populate the form with POST data. if form.is_valid(): # Get the form data. username = form.cleaned_data["username"] email = form.cleaned_data["email"] password = form.cleaned_data["password"] first_name = form.cleaned_data["first_name"] last_name = form.cleaned_data["last_name"] # Create a new user and profile. user = User.objects.create_user(username, email, password) user.first_name = first_name user.last_name = last_name user.save() # Save the user. new_profile = UserProfile() new_profile.new(user, form.cleaned_data["phone"], get_remote_ip(request)) # Send an email with the confirmation link site = Site.objects.get_current() subject = "%s User Activation" % site.name body = ( "Hello, %s, and thanks for signing up for an account at %s!" "\n\nTo activate your account, click this link within 48 hours:" "\n\nhttp://%s/login/%s" % (user.username, site.domain, site.domain, new_profile.activation_key) ) send_mail(subject, body, "settings.EMAIL_HOST_USER", [user.email]) # Redirect to a confirmation page. return HttpResponseRedirect("/signup/confirmed/") # Load signup.html on GET request and POST error. return load_page(request, "signup.html", {"form": form})
class StatusProcessModelTest(TestCase): def setUp(self): self.user = UserProfile(email='*****@*****.**', name='Test', url='https://test.com/postback/', password='******') self.user.save() self.obj = StatusProcess(user_profile=self.user, id_process='12345678901', status_process='Em análise') self.obj.save() def test_create(self): self.assertTrue(StatusProcess.objects.exists()) self.assertTrue(UserProfile.objects.exists()) def test_str(self): self.assertEqual('Em análise', str(self.obj)) self.assertEqual('*****@*****.**', str(self.user))
def register(self, request, **cleaned_data): '''Register a new user, saving the User and UserProfile data.''' user = User() for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) # the password has been validated by the form user.set_password(cleaned_data['password2']) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) profile.save() new_user = authenticate(username=user.username, password=cleaned_data['password2']) login(request, new_user) signals.user_activated.send(sender=self.__class__, user=new_user, request=request) return new_user
def subscribe(request): try: data = request.POST if request.method == 'POST': if not User.objects.filter(email=data['email']): user_obj = User(username=data['email'], first_name=data['name'], email=data['email']) user_obj.save() dob_tuple = (int(data['dob'].split('/')[1]), int(data['dob'].split('/')[0])) dob = datetime.datetime.strptime(data['dob'], '%d/%m/%Y') zodiac = get_sign_from_date(dob_tuple) user_prof_obj = UserProfile(user=user_obj, zodiac=zodiac, dob=dob) user_prof_obj.save() today = time.strftime("%Y-%m-%d") zodiacs = Zodiac.objects.filter(date=today) prediction = 'None' if zodiacs: predictions = zodiacs[0].zodiac.filter( zodiac__iexact=zodiac) if predictions: prediction = predictions[0].prediction context = { 'zodiac': zodiac, 'prediction': prediction, 'today': datetime.datetime.now(), 'status': True } else: context = {'status': False} return render(request, 'core/success.html', context) else: return HttpResponseRedirect('/') except Exception as e: logger.error(traceback.format_exc()) return HttpResponseRedirect('/')
def create_foursquare_user(foursquare_id, access_token): # Since we don't have a username, just generate one username = "******" + foursquare_id fake_email = username + "@example.com" # Don't know why we have to do this user = User.objects.create_user(username=username,email=fake_email,password=None) user.save() try: user_profile = UserProfile( user = user, foursquare_id = foursquare_id, foursquare_access_token = access_token) user_profile.save() except Exception: # If profile creation fails, clean up the user too user.delete() # Reraise exception raise return user
def setup_user_account(strategy, backend, request, details, *args, **kwargs): username = details['username'].replace(' ', '') user = User.objects.get(username=username) # New user supplied email and is new if kwargs['is_new'] and details['email']: UserProfile.user_creation(user) welcome_new_user_fb_notification(details['username'], details['email']) elif not details['email']: if user.email is '' and not request.get('email', None): return HttpResponseRedirect('/request_email') elif user.email is '' and request.get('email', None): user.email = request['email'] user.save() UserProfile.user_creation(user) welcome_new_user_fb_notification(details['username'], request['email']) return {'email': request['email']} return
def register(self, request, **cleaned_data): '''Register a new user, saving the User and UserProfile data.''' # We can't use RegistrationManager.create_inactive_user() # because it doesn't play nice with saving other information # in the same transaction. user = User(is_active=False) for field in user._meta.fields: if field.name in cleaned_data: setattr(user, field.name, cleaned_data[field.name]) user.save() profile = UserProfile(user=user) for field in profile._meta.fields: if field.name in cleaned_data: setattr(profile, field.name, cleaned_data[field.name]) profile.save() registration_profile = RegistrationProfile.objects.create_profile(user) registration_profile.send_activation_email(Site.objects.get_current()) signals.user_registered.send(sender=self.__class__, user=user, request=request)
def subscribe(request): try: data = request.POST if request.method == 'POST': if not User.objects.filter(email=data['email']): user_obj = User(username=data['email'], first_name=data['name'], email=data['email']) user_obj.save() dob_tuple = (int(data['dob'].split('/')[1]),int(data['dob'].split('/')[0])) dob = datetime.datetime.strptime(data['dob'], '%d/%m/%Y') zodiac = get_sign_from_date(dob_tuple) user_prof_obj = UserProfile(user=user_obj,zodiac=zodiac,dob=dob) user_prof_obj.save() today = time.strftime("%Y-%m-%d") zodiacs = Zodiac.objects.filter(date=today) prediction = 'None' if zodiacs: predictions = zodiacs[0].zodiac.filter(zodiac__iexact=zodiac) if predictions: prediction = predictions[0].prediction context = { 'zodiac' : zodiac, 'prediction' : prediction, 'today' :datetime.datetime.now(), 'status' : True } else: context = { 'status' : False } return render(request,'core/success.html',context) else: return HttpResponseRedirect('/') except Exception as e: logger.error(traceback.format_exc()) return HttpResponseRedirect('/')
def user_profile(request, username): """ Displays the user profile of the user with the specified username. """ user = get_object_or_404(User, username=username) profile, created = UserProfile.get_or_create(user) errors = request.session.pop('form_errors', None) context = { 'profile': profile, 'form_errors': errors, 'explore': 'user_profile' } return render(request, 'core/users/user_profile.html', context)
def register(request): error_messages = list(); if request.method == 'GET': return render(request,'index/signup.html',{'error_messages':error_messages}) #email format verfication should be done in FE email = request.POST.get("email","").strip() passwd = request.POST.get("pass_confirmation", "").strip() passwd_confirm = request.POST.get("pass", "") name = request.POST.get("name", "").strip() if len(email)==0 or len(passwd)==0 or passwd != passwd_confirm: error_messages.append("Invalid email or password.") return render(request,'index/signup.html',{'error_messages':error_messages}) try: validate_email(email) except ValidationError as e: error_messages.append("Invalid email.") return render(request,'index/signup.html',{'error_messages':error_messages}) #first need to check whether email had been registered already or not if User.objects.filter(email=email).count() > 0: error_messages.append("User already exists.") return render(request,'index/signup.html',{'error_messages':error_messages}) try: user = User.objects.create_user(username=email, email=email, password=passwd) user.save() profile = UserProfile(user=user, name=name) profile.save() user = authenticate(username=email,password=passwd) login(request,user) return redirect('/') except Exception,e: raise e error_messages.append("Cannot create user."); return render(request,'index/signup.html',{'error_messages':error_messages})
def register(self): fname = self.request.get('name') email = self.request.get('email') passwd = self.request.get('passwd') registered = UserProfile.get_by_auth_id(email) if registered: errors = ['User "%s" already registered.' %registered.email] return self.render('login.html', errors=errors, username=registered.email) names = fname.split() self._create_new_user(email, email, passwd, name=names[0], last_name=' '.join(names[1:])) return self.redirect_to('dashboard')
def test_daily_norms_calculation_hemodialysis(self): user = UserFactory() profile = UserProfile(user=user, dialysis=DialysisType.Hemodialysis, date_of_birth=date(1960, 1, 1), height_cm=180, diabetes_type=DiabetesType.Type1) calculator = AdultDailyNormsCalculator(profile, urine_ml=123) self.assertEqual(calculator.calculate_potassium_mg(), 3123) self.assertEqual(calculator.calculate_proteins_mg(), 93677) self.assertEqual(calculator.calculate_sodium_mg(), 2300) self.assertEqual(calculator.calculate_phosphorus_mg(), 1000) self.assertIsNone(calculator.calculate_energy_kcal()) self.assertEqual(calculator.calculate_liquids_g(), 1123)
def test_daily_norms_calculation_dialysis_not_performed_no_cd(self): user = UserFactory() profile = UserProfile(user=user, dialysis=DialysisType.NotPerformed, date_of_birth=date(1960, 1, 1), height_cm=200, diabetes_type=DiabetesType.No) calculator = AdultDailyNormsCalculator(profile, urine_ml=455) self.assertIsNone(calculator.calculate_potassium_mg()) self.assertEqual(calculator.calculate_proteins_mg(), 59689) self.assertEqual(calculator.calculate_sodium_mg(), 2300) self.assertEqual(calculator.calculate_phosphorus_mg(), 1000) self.assertIsNone(calculator.calculate_energy_kcal()) self.assertIsNone(calculator.calculate_liquids_g())
def test_daily_norms_calculation_post_transplant(self): user = UserFactory() profile = UserProfile(user=user, dialysis=DialysisType.PostTransplant, date_of_birth=date(1960, 1, 1), height_cm=160, diabetes_type=DiabetesType.Type2) calculator = AdultDailyNormsCalculator(profile, urine_ml=None) self.assertIsNone(calculator.calculate_potassium_mg()) self.assertEqual(calculator.calculate_proteins_mg(), 45318) self.assertEqual(calculator.calculate_sodium_mg(), 2300) self.assertIsNone(calculator.calculate_phosphorus_mg()) self.assertIsNone(calculator.calculate_energy_kcal()) self.assertIsNone(calculator.calculate_liquids_g())
def forgot_password(self): email = self.request.get("email") user = UserProfile.get_by_auth_id(email) if not user: return self.render_json({'success': False, 'title': 'Sorry.', 'message': 'Nenhum usuário com o email "%s" foi encontrado.' %email}) new_password = security.generate_random_string(length=8) user.set_password(new_password) print 'New Password ======================> ', new_password user.put() deferred.defer(send_forgot_password_email, user=user, new_passwd=new_password, _queue='sendEmail') #TODO improve this queue params/conf return self.render_json({'success': True, 'title': 'Senha reiniciada.', 'message': 'Enviamos um email para %s com sua nova senha' %email})
def authenticate(self, ticket, service, request): """Verifies CAS ticket and gets or creates User object""" username, attributes = _verify(ticket, service) # If we don't have the user's document we'll not allow him to do login if (not attributes or not 'NumDocumento' in attributes or attributes['NumDocumento'] is None): st.CAS_RETRY_LOGIN = False return None # If type of account of the user isn't allow then # we will not allow him to do login if (attributes and 'TipoCuenta' in attributes and attributes['TipoCuenta'] in st.CAS_TIPO_CUENTA_NOAUT): st.CAS_RETRY_LOGIN = False return None request.session['attributes'] = attributes documento = attributes['NumDocumento'] return UserProfile.get_or_create_user(username, documento)[0]
def handle(self, *args, **options): database = (options['database'] if options['database'] is not None else 'default') with in_database(database, write=True): cvn_file = os.path.join(st_cvn.MIGRATION_ROOT, 'users_to_migrate.csv') with open(cvn_file, 'rb') as csvfile: lines = csv.reader(csvfile, dialect=st.CSV_DIALECT) for line in lines: user, created = UserProfile.get_or_create_user( username=unicode(line[0]), documento=unicode(line[1])) if created: user.first_name = line[3] user.last_name = line[4] user.save() # Reload user to have profile updated user = User.objects.get(pk=user.profile.user.pk) try: pdf_file = os.path.join(st_cvn.MIGRATION_ROOT, line[2]) upload_file = open(pdf_file) except IOError: print( u'[%s] \t \t ERROR: CVN No encontrado (%s - %s)' % (lines.line_num, line[0], line[2])) continue cvn_file = SimpleUploadedFile( upload_file.name, upload_file.read(), content_type="application/pdf") upload_file.close() try: user.profile.cvn.remove() user.profile.cvn.delete() except ObjectDoesNotExist: pass form = UploadCVNForm(initial={'cvn_file': cvn_file}, user=user) if form.is_valid(): cvn = form.save() cvn.insert_xml() print u'[%s] Usuario: %s - CVN: %s \t \t OK' % ( lines.line_num, line[0], line[2]) else: print u'[%s] \t \t ERROR: CVN No válido (%s - %s)' % ( lines.line_num, line[0], line[2])
def create_profile(sender, **kw): if 'instance' not in kw or not kw.get('created', False): return instance = kw['instance'] profile = UserProfile() profile.user = instance bc, im = create_barcode(u'USER-{0}'.format(instance.username[0]), instance.id, instance.username) profile.barcode = bc content = ContentFile(im) profile._barcode.save('{0}.png'.format(bc), content) profile.save()
def register(self): fname = self.request.get('name') email = self.request.get('email') passwd = self.request.get('passwd') if not fname or not email or not passwd: register_errors = ['Informe todos os dados.'] return self.render('login.html', register_errors=register_errors) registered = UserProfile.get_by_auth_id(email) if registered: register_errors = ['Escolha outro email.' % registered.email] return self.render('login.html', register_errors=register_errors, username=registered.email) names = fname.split() self._create_new_user(email, email, passwd, name=names[0], last_name=' '.join(names[1:])) return self.redirect('/')
def test_daily_norms_calculation_peritoneal_dialysis(self): for dialysis in (DialysisType.ManualPeritonealDialysis, DialysisType.AutomaticPeritonealDialysis): user = UserFactory() profile = UserProfile(user=user, dialysis=dialysis, date_of_birth=date(1960, 1, 1), height_cm=180, diabetes_type=DiabetesType.No) calculator = AdultDailyNormsCalculator(profile, urine_ml=None) self.assertEqual(calculator.calculate_potassium_mg(), 4000) self.assertEqual(calculator.calculate_proteins_mg(), 93677) self.assertEqual(calculator.calculate_sodium_mg(), 2300) self.assertEqual(calculator.calculate_phosphorus_mg(), 1000) self.assertIsNone(calculator.calculate_energy_kcal()) self.assertEqual(calculator.calculate_liquids_g(), 1000)
def process_request(self, request): if request.user.is_authenticated(): try: request.session['django_language'] = request.user.get_profile( ).language except AttributeError: # pass pro = UserProfile() pro.user = request.user pro.language = settings.LANGUAGE_CODE pro.save() request.session['django_language'] = pro.language else: request.session['django_language'] = "is"
def preferences(request): """ Either displays the preferences page or saves the user's preferences if GET or POST request respectively. """ profile, created = UserProfile.get_or_create(request.user) saved = False if request.method == 'POST': # users is saving their preferences form = SaveUserProfileForm(request.POST, instance=profile) if form.is_valid(): form.save() saved = True else: form = SaveUserProfileForm(instance=profile) context = { 'profile': profile, 'form': form, 'saved': saved, 'explore': 'preferences' } return render(request, 'core/accounts/preferences.html', context)
def account(request): user = request.user try: profile = UserProfile.objects.get(user=request.user) except: profile = UserProfile() profile.new(user, ip_address=get_remote_ip(request)) profile.save() form = AccountForm({"phone": profile.phone, "email": user.email}) error = "" if request.method == "POST": form = AccountForm(request.POST) if form.is_valid(): # user.email = form.cleaned_data['email'] user.save() profile.phone = form.cleaned_data["phone"] profile.save() return index(request, "Your account has successfully been edited.") else: error = form.errors return load_page(request, "account.html", {"form": form, "error": error})
def test_selenium_cambio_incorrecto_dni(self): user = UserProfile.get_or_create_user('invipas', '72693103Q')[0] user.set_password("pruebasINV1") user.is_staff = True user.is_superuser = True user.save() driver = self.driver driver.get(self.base_url + "/cas-1/login?service=http%3A%2F%2Flocalhost" "%3A8081%2Finvestigacion%2Faccounts%2Flogin" "%2F%3Fnext%3D%252Finvestigacion%252Fadmin" "%252Flogin%252F%253Fnext%253D%252F" "investigacion%252Fadmin%252F") driver.find_element_by_id("username").clear() driver.find_element_by_id("username").send_keys("invipas") driver.find_element_by_id("password").clear() driver.find_element_by_id("password").send_keys("pruebasINV1") driver.find_element_by_name("submit").click() driver.find_element_by_link_text("User profiles").click() driver.find_element_by_id("searchbar").clear() driver.find_element_by_id("searchbar").send_keys(user.username) driver.find_element_by_css_selector("input[type=\"submit\"]").click() driver.find_element_by_css_selector("tr.row1 > td.action-checkbox > " "input[name=\"_selected_action\"]" ).click() Select(driver.find_element_by_name("action") ).select_by_visible_text("Change user's DNI") driver.find_element_by_name("index").click() driver.find_element_by_id("id_new_dni").clear() driver.find_element_by_id("id_new_dni").send_keys("88888888B") driver.find_element_by_name("apply").click() try: result = driver.find_element_by_class_name("info").text except NoSuchElementException: result = '' self.assertFalse(u'Successfully changed dni.' in result) self.assertEqual("72693103Q", UserProfile.objects.get( user__username='******').documento)
def setUp(self): self.obj = UserProfile(stripe_customer_id="123456789", one_click_purchasing=True)