def handle(self, *args, **options):
count = options['count']
if count > 5000:
raise CommandError('Can\'t be more than 5000 users')
users = User.objects.filter(username__startswith=USERNAME_PREFIX)
if (
users.count() >= count > 0 and
users.first().username.startswith(VERSIONED_PREFIX)
):
self.stdout.write('Already enough users in the system')
return
deleted_count, _ = users.delete()
if deleted_count:
self.stdout.write('Deleted {} records'.format(deleted_count))
if count == 0:
return
url = API_URL.format(count=options['count'])
response = requests.get(url)
data = response.json()
for i, res in enumerate(data['results']):
dob = datetime.strptime(res['dob'].split()[0], "%Y-%m-%d").date()
gender = {
'male': User.MALE,
'female': User.FEMALE
}[res['gender']]
phone = ''.join(c for c in res['phone'] if c in '1234567890')
user = User(
gender=gender,
birthday=dob,
phone=phone,
profile_complete=True,
bio=BIOS[i % len(BIOS)],
email=res['email'],
first_name=res['name']['first'].capitalize(),
last_name=res['name']['last'].capitalize(),
username=VERSIONED_PREFIX + res['login']['username'],
)
user.set_password(res['login']['password'])
img_url = res['picture']['large']
img_filename = img_url.split('/')[-1]
img_temp = NamedTemporaryFile(delete=True)
img_temp.write(requests.get(img_url).content)
img_temp.flush()
user.img.save(img_filename, File(img_temp))
user.save()
self.stdout.write(self.style.SUCCESS(
'Successfully added "{}" random users'.format(options['count'])
))
def create(self, validate_data):
user = User(
email = validate_data.get('email'),
first_name = validate_data.get('first_name'),
last_name = validate_data.get('last_name')
)
user.set_password(validate_data.get('password'))
user.save()
return user
def test_create_relationship(self):
child = User(username='******')
child.save()
parent = User.objects.get(username='******')
created = create_relationship(parent, child)
eq_(True, created)
eq_(child.node.parent, parent.node)
def test_invite_count(self):
u1 = User(username='******',
password='******',
email='*****@*****.**')
u2 = User(username='******',
password='******',
first_name='123',
email='*****@*****.**')
t = Team(name='team')
u1.save()
u2.save()
t.save()
i1 = Invite(team=t, user=u1)
i2 = Invite(team=t, user=u2)
i1.save()
i2.save()
invite_count = Invite.objects.all().count()
self.assertEqual(invite_count, 2)
def setUp(self):
user = User(email='*****@*****.**',
name='Alberto MartÃnez',
phone='4491231230',
gender='Masculino',
username='******')
user.set_password('eCmcUX&K&jJB')
user.save()
self.user = user
def test_valid_last_name(self):
u = User(username='******',
password='******',
last_name='friend',
email='*****@*****.**')
u.save()
users = User.objects.all()
if (users.filter(username='******')):
self.assertTrue(all(c.isalpha() for c in u.last_name))
def test_invalid_last_name(self):
u = User(username='******',
password='******',
last_name='123',
email='*****@*****.**')
u.save()
users = User.objects.all()
if (users.filter(username='******')):
self.assertFalse(any(c.isalpha() for c in u.last_name))
def save(self):
print(self.data)
user = User(email=self.validated_data['email'],
name=self.validated_data['name'],
lastname=self.validated_data['lastname'])
password = self.validated_data['password']
user.set_password(password)
user.save()
return user
def test_user_was_expired(self):
date = timezone.now() - timezone.timedelta(days=1)
user = User(name=gen_name(),
username=gen_username(),
email=gen_email(),
role=self.role,
date_expired=date)
self.assertTrue(user.is_expired)
def test_get_full_name(self):
"""
get_short_name() should return User first_name
"""
user = User(first_name='jason',
last_name='swett',
email='*****@*****.**')
self.assertEqual(user.get_full_name(), 'jason swett')
def setUp(self):
self.user = User(email='*****@*****.**')
self.user.save()
self.full_request_data = {
'first_name': 'Tommy',
'last_name': 'Wiseau',
'date_of_birth': '10-10-1979',
'mobile_phone': '+48691070500',
}
def create(self, validated_data):
profile_data = validated_data.pop('profile')
password = validated_data.pop('password')
user = User(**validated_data)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user, **profile_data)
return user
def test_view_returns_user_if_it_exists(self):
default = User(username='******', email='*****@*****.**')
default.save()
kwargs = {'username': '******'}
request = RequestFactory().get('/any-user-detail')
response = self.DummyView.as_view()(request, **kwargs)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data['object'], default)
self.assertEqual(response.context_data['user'], default)
def user_add_view(request):
if request.POST.get('book_id'):
user = User.objects.get(id=request.POST.get('book_id'))
if not request.POST.get('mobile'):
user.phone = None
else:
user.phone = request.POST.get('mobile')
if request.POST.get('address'):
user.address = request.POST.get('address')
else:
user.address = None
if request.POST.get('over'):
user.overview = request.POST.get('over')
else:
user.overview = None
if request.POST.get('active'):
user.is_active = request.POST.get('active')
else:
user.is_active = 'True'
user.save()
return HttpResponseRedirect('/admin')
else:
if request.POST.get('name') and request.POST.get('email'):
user = User()
user.email = request.POST.get('email')
if request.POST.get('username'):
user.username = request.POST.get('username')
else:
user.username = '******'
user.name = request.POST.get('name')
if not request.POST.get('mobile'):
user.phone = None
else:
user.phone = request.POST.get('mobile')
user.is_active = 'True'
if request.POST.get('address'):
user.address = request.POST.get('address')
else:
user.address = None
if request.POST.get('over'):
user.overview = request.POST.get('over')
else:
user.overview = None
if request.POST.get('create'):
user.date_joined = request.POST.get('create')
else:
user.date_joined = datetime.datetime.now()
if request.POST.get('last'):
user.last_login = request.POST.get('last')
else:
user.last_login = None
user.save()
return HttpResponseRedirect('/admin')
else:
return HttpResponseRedirect('/admin')
return HttpResponseRedirect('/admin')
def setUp(self):
super(TestAdminUser, self).setUp()
self.user = User(
username='******',
email='*****@*****.**',
is_staff=True,
)
self.user.set_password('password')
self.user.save()
def authenticate_credentials(self, payload):
payload.pop("exp", None)
payload.pop("orig_iat", None)
payload.pop("username", None)
payload["id"] = payload.pop("user_id", None)
user = User(**payload)
if not user.is_active:
raise exceptions.AuthenticationFailed("User account is disabled.")
return user
def login():
setExits()
g.user = g.get('user', None)
next = request.args.get('next', request.form.get('next', ''))
if g.user is not None:
#flash("Already Logged in...")
return redirect('/')
if 'reset' in request.args:
#Try to find the user record that requested a reset
rec = User(g.db).select_one(where='access_token = "{}"'.format(
request.args.get('reset', '')).strip())
if rec and rec.access_token_expires > time():
userNameOrEmail = rec.username
if not userNameOrEmail:
userNameOrEmail = rec.email
setUserStatus(userNameOrEmail, rec.id)
return redirect(url_for('user.edit'))
else:
flash("That reset request has expired")
return redirect('/')
if not request.form:
if 'loginTries' not in session:
session['loginTries'] = 0
if request.form:
if 'loginTries' not in session:
#Testing that user agent is keeping cookies.
#If not, there is no point in going on... Also, could be a bot.
return render_template('login/no-cookies.html')
result = authenticate_user(request.form["userNameOrEmail"],
request.form['password'])
if result != 0:
session['loginTries'] = 0
if result == -1:
flash("Your account is inactive")
return render_template('/login/inactive.html')
#import pdb;pdb.set_trace()
if next:
return redirect(next)
return redirect('/') #logged in...
else:
flash("Invalid User Name or Password")
if 'loginTries' not in session:
session['loginTries'] = 0
#remember howmany times the user has tried to log in
session['loginTries'] = session['loginTries'] + 1
#slow down login attempts
if session['loginTries'] > 5:
sleep(session['loginTries'] / .8)
return render_template('login/login.html', form=request.form, next=next)
def create(self, validated_data):
user = User(
email=validated_data['email'],
is_staff=False,
is_active=True,
)
user.set_password(validated_data['password'])
user.save()
return user
def setUp(self):
self.user = User(username="******",
email="*****@*****.**",
first_name="Bruce",
last_name="Wayne")
self.user.save()
self.user_password = "******"
self.user.set_password(self.user_password)
self.user.save()
def create(self, validated_data):
print(validated_data)
username = validated_data['username']
email = validated_data['email']
password = validated_data['password']
user_obj = User(username=username, email=email)
user_obj.set_password(password)
user_obj.save()
return validated_data
def setUp(self):
user = User(
email='*****@*****.**',
first_name='Testing',
last_name='Testing',
username='******'
)
user.set_password('admin123')
user.save()
def create_user(self, user_item):
user = User(source=User.SOURCE_LDAP)
try:
self.save_user(user, user_item)
except Exception as e:
logger.error(e, exc_info=True)
return False, str(e)
else:
return True, None
def setUp(self):
self.owner = User(email="*****@*****.**")
self.is_published = False
self.template_name = "test"
self.template = open("./serializers.py")
self.template_model = Template(name=self.template_name,
url=self.template,
owner=self.owner,
is_published=self.is_published)
def mutate(self, info, username, password, email):
user = User(
username=username,
email=email,
)
user.set_password(password)
user.save()
return CreateUser(user=user)
def test_alert_body_change_to_null(self):
u = User(username='******',
password='******',
email='*****@*****.**')
u.save()
a = Alert(user=u, body='this is a test message')
a.save()
a.body = ''
self.assertEqual(a.body, '')
def test_alert_read_toggle_false(self):
u = User(username='******',
password='******',
email='*****@*****.**')
u.save()
a = Alert(user=u, read=True)
a.save()
a.read = False
self.assertEqual(a.read, False)
def testfields(self):
user = User()
user.email = "TestItem"
user.firstname = "Some test desc"
user.lastname = "Gadgets"
user.save()
record = User.objects.get(pk=1)
self.assertEqual(record,user)
def create(self, validated_data):
user = User(
email=validated_data['email'],
currency=validated_data['currency'],
money=validated_data['money'],
)
user.set_password(validated_data['password'])
user.save()
return user
def handle(self, *args, **options):
BookRent.objects.all().delete()
Book.objects.all().delete()
Category.objects.all().delete()
curr = Currency.get_default_currency()
reg, _ = Category.objects.get_or_create(name="Regular",
amount=1.0,
changed_amount=1.5,
period_limit=2,
currency=curr)
fic, _ = Category.objects.get_or_create(
name="Fiction",
amount=4.5,
changed_amount=5,
currency=curr,
period_limit=3,
)
nov, _ = Category.objects.get_or_create(name="Novel",
amount=1.5,
changed_amount=2.0,
currency=curr,
period_limit=2)
cats = [reg, fic, nov]
now = timezone.now()
try:
User.objects.get(username="******").delete()
except User.DoesNotExist:
pass
user = User(username="******",
is_staff=True,
is_active=True,
is_superuser=True,
last_login=now,
date_joined=now,
user_role=1)
user.set_password("qwerty")
user.save()
fake = Faker()
Book.objects.bulk_create([
Book(title=fake.sentence(), category=random.choice(cats))
for _ in range(10_000)
])
books = Book.objects.filter(title__startswith="Abl")
print(f"Create {books.count()} rents")
for book in books:
rent = BookRent.objects.create(book=book,
customer=user,
status=BookRent.Status.RENTED)
rent.created = now - timedelta(days=2)
rent.save()
def sign_up(request):
_form = RegisterForm()
messages = None
if request.POST:
_form = RegisterForm(request.POST)
messages = list()
if _form.is_valid():
print _form.cleaned_data
try:
user = User.objects.get(email=_form.cleaned_data['email'])
messages.append('This email already used!')
except ObjectDoesNotExist:
user = User(email=_form.cleaned_data['email'],
password=make_password(
_form.cleaned_data['password2']),
is_active=False)
user.save()
token = default_token_generator.make_token(user)
uid = urlsafe_base64_encode(force_bytes(user.pk))
template = loader.get_template(
'account/partial/confirm_email.html')
protocol = 'https://' if request.is_secure() else 'http://'
contexts = {
'link':
protocol + request.get_host() +
reverse('users:users_confirm',
kwargs={
'uidb64': uid,
'token': token
})
}
response = template.render(contexts, request)
print contexts
thread = threading.Thread(
target=send_email_notification,
args=(
'Activating profile | MyBrands.kg',
response,
[user.email],
))
thread.start()
messages.append(
'We sent message with activation link on your email!')
else:
messages.append(
'Somethings goes wrong... Please check the form for correctness of the filled data'
)
messages.append(_form.error_messages)
params = {'form': _form, 'messages': messages}
params.update(generate_view_params(request))
return render(request, 'account/register.html', params)
