def _add_user(self, userdata): email = userdata['Email'] username = userdata['Username'] user_exists = User.objects.filter( models.Q(email=email) | models.Q(username=username)) email_exists = EmailAddress.objects.filter(email=email) if user_exists or email_exists: print('Skipping user {} <{}>'.format(username, email)) else: user = User( username=username, email=email, date_joined=userdata['Creation date'], password="******" + userdata['Password hash'], ) user.save() email = EmailAddress( user=user, email=userdata['Email'], verified=True, primary=True, ) email.save()
def sync_user(user, userdata): """Overwrite user details with data from the remote auth server""" for k in ['email', 'first_name', 'last_name']: if getattr(user, k) != userdata[k]: setattr(user, k, userdata[k]) user.save() try: from allauth.account.models import EmailAddress except ImportError: return # Sync email address list for e in user.emailaddress_set.all(): if e.email not in userdata['email_addresses']: e.delete() for e in userdata['email_addresses']: if user.emailaddress_set.filter(email=e).exists(): continue emailaddress = EmailAddress(email=e) emailaddress.save() user.emailaddress_set.add(emailaddress)
def add_new_emails(sender, request, response, user, **kwargs): if "sociallogin" not in kwargs: return if not getattr(kwargs["sociallogin"], "autoconnect", False): return for e in kwargs["sociallogin"].email_addresses: try: existing = EmailAddress.objects.get(email__iexact=e.email.lower()) except EmailAddress.DoesNotExist: new = EmailAddress(email=e.email, verified=e.verified, primary=False, user=user) new.save() continue if existing.user != user: # TODO: what if this email is verified but the existing # email is unverified? Can this user steal it? continue elif e.verified and not existing.verified: existing.verified = True existing.save()
def verify_user(self): """Verify instance user account using django-allauth constructs""" account_emailaddresse = EmailAddress() account_emailaddresse.email = '*****@*****.**' account_emailaddresse.verified = True account_emailaddresse.user_id = self.user.id account_emailaddresse.save()
def handle(self, *args, **options): passwd = getpass.getpass("Enter password:"******"User with such email/username already exists.") u = user_model.objects.create_superuser(options['name'], options['email'], passwd) u.save() email_entity = EmailAddress(email=options['email'], verified=True, primary=True, user=u) email_entity.save() email_confirmation_entity = EmailConfirmation( email_address=email_entity, created=timezone.now() - datetime.timedelta(days=1), sent=timezone.now() - datetime.timedelta(hours=12), key=str(uuid.uuid4()).replace('-', '')) email_confirmation_entity.save() self.stdout.write( 'Successfully created superuser {0} with confirmed email address {1}' .format(options['name'], options['email']))
def update_profile(request): profile = request.user.profile if request.method == 'POST': form = UserProfileForm(request.POST, instance=profile) if form.is_valid(): profile = form.save() user = request.user if user.email is None or user.email == '': if form.cleaned_data['email'].strip() != '': user.email = form.cleaned_data['email'] user.first_name = form.cleaned_data['first_name'] user.last_name = form.cleaned_data['last_name'] user.save() print "email: " + str(user.email) print str(user.email.strip()) != '' if user.email is not None and str(user.email.strip()) != '': try: email_address = EmailAddress.objects.get(user=user) email_address.email = user.email except EmailAddress.DoesNotExist: email_address = EmailAddress(user=user, email=user.email, primary=True) email_address.save() return redirect(profile.get_absolute_url()) else: form = UserProfileForm(instance=profile) return render(request, 'profile/edit.html', { 'user': request.user, 'form': form, })
def mutate_and_get_payload(self, root, info, **input): user = info.context.user require_login_and_permission(user, 'costasiella.add_account') # verify email unique query_set = get_user_model().objects.filter(email=input['email']) #Don't insert duplicate records in the DB. If this records exist, fetch and return it if query_set.exists(): raise Exception( _('An account is already registered with this e-mail address')) account = get_user_model()(first_name=input['first_name'], last_name=input['last_name'], email=input['email'], username=input['email']) account.save() # Insert Allauth email address email_address = EmailAddress(user=account, email=account.email, verified=True, primary=True) email_address.save() # Insert Teacher profile account_teacher_profile = AccountTeacherProfile(account=account) account_teacher_profile.save() return CreateAccount(account=account)
def verify_user(self): """Verify instance user account using django-allauth constructs""" account_emailaddresse = EmailAddress() account_emailaddresse.email = '*****@*****.**' account_emailaddresse.verified = True account_emailaddresse.user_id = self.user.id account_emailaddresse.save()
def handle(self, *args, **options): # attempt to load username from command-line options # username can come from command-line flag OR from interactive input self._username = options.get(self.UserModel.USERNAME_FIELD) try: with transaction.atomic(): # let the base class handle all the user-creation details super().handle(*args, **options) # now try to create the validated EmailAddress object user = self.UserModel.objects.get(username=self._username) # overriding the value of is_superuser set by parent (always True in parent) user.is_superuser = options[ADMIN] # create a verified primary EmailAddress for the user email_address = EmailAddress(user=user, email=user.email, verified=True, primary=True) email_address.save() user.save() if options["verbosity"] >= 1: self.stdout.write( 'Simulated email address verification for user "%s"' % self._username) except Exception as e: raise CommandError(e)
def _add_fake_data_to_courses(self, num): # create a pool of instructors instructor_data = [ {'first_name': 'first', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'}, {'first_name': 'second', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'}, {'first_name': 'third', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'}, {'first_name': 'fourth', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'}, {'first_name': 'fifth', 'last_name': 'user', 'username': '******', 'email': '*****@*****.**'}, ] instructors = [] for instructor_datum in instructor_data: user = User.objects.create_user(instructor_datum['username'], email=instructor_datum['email'], password="******") email_address = EmailAddress(user=user, email=instructor_datum['email'], verified=True, primary=True) user.first_name = instructor_datum['first_name'] user.last_name = instructor_datum['last_name'] user.save() email_address.save() instructors.append(user) for idx in xrange(num): course = Course( instructor=instructors[idx % len(instructor_data)], title='sample title ' + str(idx), slug='sample-title-' + str(idx), description=('sample description ' + str(idx) + '\t') * 25, is_public = True if idx % 2 == 0 else False, popularity=0 ) course.save() self._generate_course_pages(course)
def post(self, request, pk=None): if not pk: return redirect(reverse("dashboard")) client = Usuario.objects.get(pk=pk) form = ExtraInfoForm(request.POST, instance=client) if form.is_valid(): state = State.objects.get_or_create(uf=request.POST.get('state'), cod_ibge=request.POST.get('cod_ibge'))[0] city = City.objects.get_or_create(name=request.POST.get('city'), latitude=request.POST.get('latitude'),longitude=request.POST.get('longitude'), state=state, cod_ibge=state.cod_ibge)[0] neighborhood = Neighborhood.objects.get_or_create(description=request.POST.get('neighborhood'), city=city)[0] place = Place.objects.get_or_create(zip_code=request.POST.get('zip_code'), city=city, latitude=city.latitude, longitude=city.longitude, neighborhood=neighborhood)[0] address = Address() address.street = request.POST.get('street') address.number = request.POST.get('number') address.complement = request.POST.get('complement') address.reference_point = request.POST.get('reference_point') address.place = place address.neighborhood = neighborhood address.city = city address.state = state address.latitude = city.latitude address.longitude = city.longitude address.save() # UPDATING CLIENT client = form.save(commit=False) client.address = address client.save() # ACTIVATING USER user = client.user user.is_active = True user.save() # ALLAUTH EMAIL try: auth_email = EmailAddress.objects.get(user=client.user, email=client.email) except: auth_email = EmailAddress() auth_email.user = client.user auth_email.email = client.email auth_email.save() # SENDING EMAIL CONFIRMATION auth_email.send_confirmation() response = { 'status': 'success', 'message':'Usuário criado com sucesso', 'redirect':reverse("account_login") } return JsonResponse(response, status=200) return JsonResponse({'status': 'form_error', 'message':'Favor preencher todos os campos'}, status=400)
def email(save=False, **kwargs): if 'user' not in kwargs: kwargs['user'] = user(save=True) if 'email' not in kwargs: kwargs['email'] = '%s@%s.com' % (random_str(), random_str()) email = EmailAddress(**kwargs) if save: email.save() return email
def email(save=False, **kwargs): if 'user' not in kwargs: kwargs['user'] = user(save=True) if 'email' not in kwargs: kwargs['email'] = '%s@%s.com' % (random_str(), random_str()) email = EmailAddress(**kwargs) if save: email.save() return email
def email(save=False, **kwargs): if "user" not in kwargs: kwargs["user"] = user(save=True) if "email" not in kwargs: kwargs["email"] = "%s@%s.com" % (get_random_string(), get_random_string()) email = EmailAddress(**kwargs) if save: email.save() return email
def create_token_signal(sender, instance=None, created=False, **kwargs): if created: if instance.is_superuser: email = EmailAddress(user=instance, verified=True, email=instance.email, primary=True) email.save() Token.objects.create(user=instance)
def email(save=False, **kwargs): if 'user' not in kwargs: kwargs['user'] = user(save=True) if 'email' not in kwargs: kwargs['email'] = '{0!s}@{1!s}.com'.format(get_random_string(), get_random_string()) email = EmailAddress(**kwargs) if save: email.save() return email
def _on_populate_user(sender, user=None, ldap_user=None, **_kwargs): if user._state.adding: user.save() try: email = EmailAddress.objects.get(user=user, email=user.email) email.verified = True except ObjectDoesNotExist: email = EmailAddress(user=user, email=user.email, verified=True) if not EmailAddress.objects.filter(user=user, primary=True).exists(): email.primary = True email.save()
def test_valid_form(self): email = EmailAddress(user=self.user, email=self.user.email, verified=True, primary=True) email.save() form = { 'login': self.user.email, 'password': '******', } response = self.client.post( reverse('account_login'), form, follow=True ) self.assertRedirects(response, reverse('dashboard'))
def _save_email_addresses(self, request): adapter = get_adapter() # user.email may not be listed as an EmailAddress ... user = self.account.user try: primary_email_address = EmailAddress.objects.get(user=user, primary=True) except EmailAddress.DoesNotExist: primary_email_address = None if (user.email and (user.email.lower() not in [e.email.lower() for e in self.email_addresses])): # ... so let's append it email_address \ = EmailAddress(user=user, email=user.email, verified=adapter.is_email_verified(request, user.email), primary=(not primary_email_address)) if not primary_email_address: primary_email_address = email_address self.email_addresses.append(email_address) for email_address in self.email_addresses: # Pick up only valid ones... email = valid_email_or_none(email_address.email) if not email: continue # ... and non-conflicting ones... if (account_settings.UNIQUE_EMAIL and EmailAddress.objects.filter(email__iexact=email).exists()): continue if email_address.primary: if not primary_email_address: primary_email_address = email_address else: email_address.primary = False email_address.user = user email_address.verified \ = (email_address.verified or adapter.is_email_verified(request, email_address.email)) email_address.save() if primary_email_address and ( not user.email or primary_email_address.email.lower() != user.email.lower()): user.email = primary_email_address.email user.save() adapter.stash_email_verified(request, None)
def test_unsubscribe(self, client, user): email = EmailAddress(user=user, email=user.email) email.save() user.settings["email"] = {"marketing": True} user.save() payload = {**PAYLOAD, "data[email]": user.email} response = client.post("/mailchimp/webhook/?key=123", data=payload) user.refresh_from_db() assert not user.settings["email"]["marketing"] assert response.status_code == 200
def create_user_email(sender, instance, **kwargs): if instance.is_manager: email_address_object = EmailAddress.objects.filter( user=instance).first() if email_address_object: email_address_object.email = instance.email else: email_address_object = EmailAddress(user=instance, email=instance.email, verified=True, primary=True) email_address_object.save()
def save(self): email = self.cleaned_data["email"] user = User(username=self.cleaned_data["username"], is_ff=True, email=email) password = self.cleaned_data["password1"] user.set_password(password) user.save() email_obj = EmailAddress(user=user, email=email, verified=True, primary=True) email_obj.save() return user
def _save_email_addresses(self, request): adapter = get_adapter() # user.email may not be listed as an EmailAddress ... user = self.account.user try: primary_email_address = EmailAddress.objects.get(user=user, primary=True) except EmailAddress.DoesNotExist: primary_email_address = None if (user.email and (user.email.lower() not in [e.email.lower() for e in self.email_addresses])): # ... so let's append it email_address \ = EmailAddress(user=user, email=user.email, verified=adapter.is_email_verified(request, user.email), primary=(not primary_email_address)) if not primary_email_address: primary_email_address = email_address self.email_addresses.append(email_address) for email_address in self.email_addresses: # Pick up only valid ones... email = valid_email_or_none(email_address.email) if not email: continue # ... and non-conflicting ones... if (account_settings.UNIQUE_EMAIL and EmailAddress.objects.filter(email__iexact=email).exists()): continue if email_address.primary: if not primary_email_address: primary_email_address = email_address else: email_address.primary = False email_address.user = user email_address.verified \ = (email_address.verified or adapter.is_email_verified(request, email_address.email)) email_address.save() if primary_email_address and (not user.email or primary_email_address.email.lower() != user.email.lower()): user.email = primary_email_address.email user.save() adapter.stash_email_verified(request, None)
def _create_user(self, user_form, full_name): password = user_form.cleaned_data['password1'] fm_email = user_form.cleaned_data['email'] user = user_form.save() user.first_name = full_name user.set_password(password) user.username = fm_email.replace("@", "").replace(".", "") user.save() email = EmailAddress(user=user, email=user.email, verified=True, primary=True) email.save() return user
def test_form_with_valid_username(self): # Should error as we only accept email addresses now email = EmailAddress(user=self.user, email=self.user.email, verified=True, primary=True) email.save() form = { 'login': self.user.username, 'password': '******', } response = self.client.post( reverse('account_login'), form, follow=True ) self.assertEqual(response.status_code, 200) self.assertIn('Enter a valid email address', response.content)
def form_valid(self, form): user = form.save(commit=False) fm_email = form.cleaned_data['email'] user.username = fm_email.replace("@", "").replace(".", "") user.save() email = EmailAddress(user=user, email=user.email, verified=True, primary=True) email.save() employee = Employees(user=user, administrator=True) employee.save() company = Company.objects.get(slug=self.kwargs.get('company_slug')) company.user.add(employee) company.save() return super(AddAdministratorView, self).form_valid(form)
def save_model(self, request, obj, form, change): data = dict(email=obj.email) user = User.objects.filter(email=data['email']) if user.exists() is False: obj.save() serializer = CustomUserCreateSerializer(data=data) serializer.is_valid(raise_exception=True) serializer.save() email_address = EmailAddress() email_address.user = user[0] email_address.verified = True email_address.primary = True email_address.email = data['email'] email_address.save() else: obj.save()
def create_superuser(self, username, password, **extra_fields): email = '*****@*****.**' user = self.create_user(username, password=password, email=email, **extra_fields) user.is_admin = True user.is_active = True user.is_verified = True user.set_password(password) user.save(using=self._db) # Now add this user's email address to EmailAddress table # Otherwise, user won't be able to login. email_address = EmailAddress() email_address.user = user email_address.verified = True email_address.primary = True email_address.email = email email_address.save() return user
def post_user_signed_up_checkinvitation(request, user, *args, **kwargs): Invitation = get_invitation_model() try: invite = Invitation.objects.get(email=user.email) except: logger.info("User is not an invited user. Register as admin") """ is_admin is true is_organisation_default is true userorganization is blank """ else: """ is_admin is true is_organisation_default is true userorganization is blank """ try: inviter_user = User.objects.get(pk=invite.inviter_id) except: logger.critical( "Error setting up invited user - Inviter user not found") else: user.userorganization = inviter_user.userorganization user.is_admin = False user.is_team_member = True user.is_organisation_default = False try: user.save() except: logger.critical("Error updating invited users") else: try: emailAddress = EmailAddress.objects.get(email=user.email) except: emailAddress = EmailAddress() emailAddress.user = user.pk emailAddress.email = user.email emailAddress.verified = True emailAddress.primary = True try: emailAddress.save() except: logger.critical("Error setting up verified email") else: logger.info("Invited users - email already verified.")
def new_user(email, username=''): User = get_user_model() if username: assert is_username_unique(username) else: basename = email.split('@')[0] username = make_unique_username(basename) if User.objects.filter(email=email): raise ValueError('Email "{}" not unique.'.format(email)) user = User(username=username, email=email) user.save() # Set up email for allauth. ea = EmailAddress(user=user, email=email, primary=True, verified=False) ea.user = user ea.save() return user
def create_superuser(self, email, password, **extra_fields): """ Creates and saves a superuser with the given email and password. """ user = self.create_user( email, password=password, **extra_fields, ) user.is_superuser = True user.is_staff = True user.save(using=self._db) new_allauth_email = EmailAddress() new_allauth_email.user = user new_allauth_email.email = email new_allauth_email.verified = True new_allauth_email.primary = True new_allauth_email.save() return user
def test_expired_email_verify_link(self): verified_count = EmailAddress.objects.filter(verified=True).count() # create a user user = self.create_user('username', '*****@*****.**', 'password') # create an unverified email address email = EmailAddress(user=user, email=user.email, verified=False, primary=True) email.save() # create and email confirmation object confirmation = self._create_confirmation( email, datetime.now(tz) - timedelta(days=10) ) response = self.client.post(reverse('account_confirm_email', args=(confirmation.key,))) self.assertEqual(response.status_code, 404) new_verified_count = EmailAddress.objects.filter(verified=True).count() self.assertEqual(verified_count, new_verified_count)
def post(self, request): context = {} serializer = serializers.RegisterSerializer(data=request.data) message = {} if serializer.is_valid(): if Usuario.objects.filter(email=serializer.data['email']).exists(): message = {'status': 'error', 'message': 'Email já cadastrado.'} return Response(message,status=500) else: try: user = Usuario.objects.create_user(serializer.data['email'], serializer.data['password']) user.nome = serializer.data['nome_completo'] user.nomecomleto = serializer.data['nome_completo'] user.is_active = True user.token = binascii.b2a_hex(os.urandom(15)) user.save() except Exception as e: user.delete() message = {'status': 'error', 'message': str(e)} return Response(message,status=500) try: email_address = EmailAddress() email_address.verified = False email_address.user = user email_address.email = user.email email_address.save() except Exception as e: user.delete() email_address.delete() message = {'status': 'error', 'message': str(e)} return Response(message,status=500) message = {'status':'success'} return Response(message,status=200) else: message = {'status':'error'} return Response(message,status=400)
def handle(self, *args, **options): passwd = getpass.getpass("Enter password:"******"User with such email/username already exists.") u = user_model.objects.create_superuser( options['name'], options['email'], passwd ) u.save() email_entity = EmailAddress( email=options['email'], verified=True, primary=True, user=u ) email_entity.save() email_confirmation_entity = EmailConfirmation( email_address=email_entity, created=timezone.now() - datetime.timedelta(days=1), sent=timezone.now() - datetime.timedelta(hours=12), key=str(uuid.uuid4()).replace('-', '') ) email_confirmation_entity.save() self.stdout.write( 'Successfully created superuser {0} with confirmed email address {1}'.format( options['name'], options['email'] ) )
def obj_create(self, bundle, request=None, **kwargs): password = bundle.data['password'] email = bundle.data['email'] try: username = email bundle.obj = User.objects.create_user(username, email, password) email_address = EmailAddress(user=bundle.obj, email=email, verified=True, primary=True) email_address.save() #print "Success" #student = Student(user = bundle.obj) #print student #student.save() #try: # student.gpa = bundle.data['gpa'] # student.save() #except ValueError: # pass #try: # student.zip_code = bundle.data['zip_code'] # student.save() #except ValueError: # pass #bundle.obj = User(username = username, email = email, password = password) #bundle.obj.save() except IntegrityError: raise BadRequest('That username already exists') return bundle
def obj_create(self, bundle, request = None, **kwargs): password = bundle.data['password'] email = bundle.data['email'] try: username = email bundle.obj = User.objects.create_user(username, email, password) email_address = EmailAddress(user = bundle.obj, email = email, verified = True, primary = True) email_address.save() #print "Success" #student = Student(user = bundle.obj) #print student #student.save() #try: # student.gpa = bundle.data['gpa'] # student.save() #except ValueError: # pass #try: # student.zip_code = bundle.data['zip_code'] # student.save() #except ValueError: # pass #bundle.obj = User(username = username, email = email, password = password) #bundle.obj.save() except IntegrityError: raise BadRequest('That username already exists') return bundle
def add_users_to_semester(request, pk=None): sem_users = UserSemester.objects.filter(semester_id=pk) if request.method == 'POST': form = AddUsersToSemesterForm(request.POST, request.FILES) if form.is_valid(): semester_obj = Semester.objects.get(id=int(pk)) file_handle = request.FILES['file'] user_list_record = file_handle.get_records() user_titles_array = file_handle.get_array()[0] mandatory_titles = settings.STUDENTS_MANDATORY_FIELDS message = 'your Excel file does not have these titles:' excel_titles = [] for key, value in mandatory_titles.items(): if value not in user_titles_array: message = message + (' ' + value + ',') excel_titles.append(value) if len(excel_titles) == 0: user_creation_error = '' user_add_sem_error = '' sem_user_added = [ ] # list of users that already existed and were added to semester sem_user_created = [ ] # list of newly created users and added to semester already_existing_users = [] for student in user_list_record: prepared_dict = { 'student_no': student[mandatory_titles['student_no']], 'email': student[mandatory_titles['email']], 'first_name': student[mandatory_titles['first_name']], 'last_name': student[mandatory_titles['last_name']], 'username': student[mandatory_titles['username']], 'password': User.objects.make_random_password() } empty_valued_titles, filled_value_titles = divide_empty_and_full_dic_values( prepared_dict) if len(empty_valued_titles) > 0: messages.error( request, ('The record with title \"{0}\" and' ' value \"{1}\" has an empty value ' 'for one or more mandatary field/fields').format( filled_value_titles[0][0], filled_value_titles[0][1])) continue elif not validate_email( student[mandatory_titles['email']]): messages.error(request, ( 'System could not save the ' 'record with email \"{0}\" because the email address does not have' 'a valid format').format( student[mandatory_titles['email']])) continue error_message = '\"{0}({1})\", '.format( prepared_dict['email'], prepared_dict['student_no']) try: obj = User.objects.get( student_no=prepared_dict['student_no'], email=prepared_dict['email'], username=prepared_dict['username']) semester_user_obj, created = UserSemester.objects.get_or_create( user=obj, semester=semester_obj) if created: sem_user_added.append(semester_user_obj) else: already_existing_users.append(semester_user_obj) except User.DoesNotExist: try: obj = User.objects.create( first_name=prepared_dict['first_name'], last_name=prepared_dict['last_name'], student_no=prepared_dict['student_no'], email=prepared_dict['email'], username=prepared_dict['username'], password=prepared_dict['password']) new_email = EmailAddress( user=obj, email=prepared_dict['email'], verified=True, primary=True) new_email.save() except IntegrityError: user_creation_error += error_message except Error: user_creation_error += error_message else: try: reset_pass_form = ResetPasswordForm({ 'email': prepared_dict['email'], 'name': 'Asghar' }) if reset_pass_form.is_valid(): reset_pass_form.save(request) semester_user_obj = UserSemester.objects.create( user=obj, semester=semester_obj) sem_user_created.append(semester_user_obj) except IntegrityError: user_add_sem_error += error_message except Error: user_add_sem_error += error_message create_specific_messages(request, user_creation_error, user_add_sem_error, sem_user_created, already_existing_users, user_list_record, semester_obj, sem_user_added) else: messages.error(request, message) new_form = AddUsersToSemesterForm() semester = Semester.objects.get(pk=pk) return render(request, 'management/upload_users.html', { 'form': new_form, 'semester': semester, 'users': sem_users }) else: semester = Semester.objects.get(pk=pk) form = AddUsersToSemesterForm() return render(request, 'management/upload_users.html', { 'form': form, 'semester': semester, 'users': sem_users })
def post(self, request): type = request.data.get('type') if type is None: return Response( { "success": False, "message": "type param describing email or phone is missing." }, status=400) if type == 'email': data = { "username": request.data.get("username"), "email": request.data.get("email"), "password": request.data.get("password") } user = SignupWithEmailSerializer(data=data) elif type == 'phone': data = { "username": request.data.get("username"), "phone_number": request.data.get("phone_number"), "password": request.data.get("password") } user = SignUpWithPhoneSerializer(data=data) else: return Response( { "success": False, "message": "Invalid type param provided." }, status=400) if user.is_valid(): if type == 'phone': instance = User(username=data.get('username'), phone_number=data.get('phone_number')) elif type == 'email': instance = User(username=data.get('username'), email=data.get('email')) instance.set_password(data.get('password')) instance.save() if type == 'email': emails = EmailAddress(user=instance, email=instance.email, primary=True) emails.save() token = TokenModel.objects.create(user_id=instance.id) code = VerificationCodeGenerator.random_with_N_digits(5) code_for_user = VerificationCode(user=instance, code=code) response = SendVerificationCode.send_code(code, type, instance) error = None if response.get('success'): message = "Verification Code Sent" else: message = "Unable to send verification Code" error = response.get('message') code_for_user.save() return Response({ "success": True, "message": message, "error": error }) return Response({"success": False, "message": user.errors}, status=400)
def save(self, commit=True): user = super().save(commit) user_email = EmailAddress(user=user, email=self.cleaned_data['email']) user_email.send_confirmation() user_email.save() return user
import os import sys #SCRIPT TO CREATE PROFILES, AFTER CREATING USERS #FOR CREATING USERS UNCOMMENT THE CODE COMMENTRD AND VICEVERSA os.environ['DJANGO_SETTINGS_MODULE'] = 'pichrr.settings' import django from django.contrib.auth.models import User from allauth.account.models import EmailAddress if __name__ == '__main__': django.setup() usernames = ['theHulk', 'tonyStark', 'capt_America', 'Thor', 'blackWidow', 'hawkEye', 'loki', 'deadPool'] passwords = ['theHulk', 'tonyStark', 'capt_America', 'Thor', 'blackWidow', 'hawkEye', 'loki', 'deadPool'] for i in range(len(usernames)): email = usernames[i]+'@gmail.com' user = User.objects.create_user(username = usernames[i], password = passwords[i], email = email) user.save() email_address = EmailAddress(user=user,email=email, verified=True, primary=True) email_address.save()
with open('members.csv') as csvfile: member_csv = csv.reader(csvfile) for row in member_csv: if row[5] == "*****@*****.**": user = User.objects.get(email='*****@*****.**') else: user = User() user.email = row[5] user.save() email = EmailAddress() email.user = user email.email = row[5] email.verified = True email.save() address = Address() address.user = user address.street = row[8] address.unit = row[9] address.city = row[10] address.state = row[11] address.postal_code = row[12] address.phone_number = row[13] address.save() member = Member() member.user = user member.first_name = row[6] member.last_name = row[7]
from django.contrib.sites.models import Site from django.contrib.auth.models import User from allauth.account.models import EmailAddress site = Site.objects.get(id=1) site.domain = os.getenv('SITE_DOMAIN') site.name = os.getenv('SITE_NAME') site.save() uname = os.getenv("SITE_ADMIN_NAME") if not User.objects.filter(username=uname).exists(): email_addr = os.getenv("SITE_ADMIN_EMAIL") passwd = os.getenv("SITE_ADMIN_PASSWORD") user = User.objects.create_superuser(uname, email_addr, passwd) av = EmailAddress(user=user, email=email_addr, verified=True) av.save() print("Super user `{name}` created.".format(name=uname)) uname = os.getenv("PROJ_ADMIN_NAME") if not User.objects.filter(username=uname).exists(): email_addr = os.getenv("PROJ_ADMIN_EMAIL") passwd = os.getenv("PROJ_ADMIN_PASSWORD") projAdmin = User.objects.create_user(uname, email=email_addr, password=passwd) projAdmin.is_staff=True projAdmin.save() av = EmailAddress(user=projAdmin, email=email_addr, verified=True) av.save() print("projects upload user `{name}` created.".format(name=uname)) if not User.objects.filter(username='******').exists(): User.objects.create_user('guest', password=str(random()))