def test_order_txn(self):
order = Order(full_name='Test',
phone_number='012345',
country='gb',
postcode='ab123')
order.save()
user = User(email='*****@*****.**', first_name='Test', last_name='Case')
user.save()
ticket = Ticket(requester=user, title='Title')
ticket.save()
transaction = OrderTransaction(order=order, ticket=ticket, cost=2.2)
transaction.save()
print('TestCheckoutModels: OrderTransaction - test_order_txn \n \
Expected: {0}, Actual: {1} \n \
Expected: {2}, Actual: {3} \n \
Expected: {4}, Actual: {5} \n \
Expected: {6}, Actual: {7} \n \
Expected: {8}, Actual: {9}'.format(
'Test', transaction.order.full_name, '012345',
transaction.order.phone_number, user, transaction.ticket.requester,
'Title', transaction.ticket.title, '2.2', transaction.cost))
self.assertEqual(transaction.order.full_name, 'Test')
self.assertEqual(transaction.order.phone_number, '012345')
self.assertEqual(transaction.ticket.requester, user)
self.assertEqual(transaction.ticket.title, 'Title')
self.assertEqual(transaction.cost, 2.2)
def perform_create(self, serializer):
serializer.save()
sender = UserDetails(user=User(user_id=serializer.data['sender_id']))
recipient = UserDetails(user=User(
user_id=serializer.data['recipient_id']))
print(sender)
print(recipient)
try:
conversion = Conversation.objects.get(sender=sender,
recipient=recipient)
conversion.unseen_message += 1
conversion.save()
except Conversation.DoesNotExist as e:
conversion = Conversation(
sender=sender,
recipient=recipient,
last_message=serializer.data['message'],
)
conversion.save()
try:
conversion = Conversation.objects.get(sender=recipient,
recipient=sender)
conversion.unseen_message += 1
conversion.last_message = serializer.data['message']
conversion.save()
except Conversation.DoesNotExist as e:
conversation = Conversation(
sender=recipient,
recipient=sender,
last_message=serializer.data['message'],
unseen_message=1)
conversation.save()
def test_can_increase_upvote_size(self):
"""
Test to check that add_suggestion/comment_upvote_to_database
increases the length of the upvote table by 1
"""
original_update_table = Upvote.objects.all()
original_update_table_length = len(original_update_table)
new_user = User(username="******",
email="*****@*****.**",
password="******")
new_user.save()
suggestions = Suggestion.objects.all()
suggestion = choice(suggestions)
add_suggestion_upvote_to_database(new_user, suggestion)
upvote_table_after_suggestion_upvote = Upvote.objects.all()
upvote_table_after_suggestion_upvote_length = len(
upvote_table_after_suggestion_upvote)
self.assertEqual((original_update_table_length + 1),
upvote_table_after_suggestion_upvote_length)
comments = Comment.objects.all()
comment = choice(comments)
add_comment_upvote_to_database(new_user, comment)
upvote_table_after_comment_upvote = Upvote.objects.all()
upvote_table_after_comment_upvote_length = len(
upvote_table_after_comment_upvote)
self.assertEqual((upvote_table_after_suggestion_upvote_length + 1),
upvote_table_after_comment_upvote_length)
def save(self, commit=True):
# Save the provided password in hashed format
User = super(UserCreationForm, self).save(commit=False)
User.set_password(self.cleaned_data["password1"])
if commit:
User.save()
return User
async def post(self, *args, **kwargs) -> Response:
json_body = await self.deserialize_body()
user = User()
username = json_body.get('username')
if username:
user.username = username
else:
raise HTTPException(status_code=400,
detail='A valid `username` is required.')
organization_id = json_body.get('organization')
try:
organization = self.db_session.query(Organization).filter_by(
id=organization_id).one()
user.organization = organization
except (NoResultFound, ValueError, TypeError):
raise HTTPException(status_code=404,
detail='Related Organization not found.')
self.db_session.add(user)
self.db_session.commit()
result = await self.serialize(data=user)
return await self.to_response(result, status_code=201)
class UserLoginTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.test_user_password = "******"
self.test_user = User(email="*****@*****.**")
self.test_user.set_password(self.test_user_password)
self.test_user.save()
self.access_token = Token(token="test_access_token")
self.test_user.token_set.add(self.access_token)
def test_user_login_with_valid_credentials(self):
post_data = {
'email': "*****@*****.**",
'password': "******",
}
resp = self.client.post('/users/login/',
data=json.dumps(post_data),
content_type='application/json')
resp_data = json.loads(resp.content)
self.assertEqual(200, resp.status_code)
self.assertEqual("test_access_token", resp_data['access_token'])
def test_user_login_with_bad_password(self):
post_data = {
'email': "*****@*****.**",
'password': "******",
}
resp = self.client.post('/users/login/',
data=json.dumps(post_data),
content_type='application/json')
self.assertEqual(404, resp.status_code)
class UserLoginTestCase(TestCase):
def setUp(self):
self.factory = RequestFactory()
self.test_user_password = "******"
self.test_user = User(email="*****@*****.**")
self.test_user.set_password(self.test_user_password)
self.test_user.save()
self.access_token = Token(token="test_access_token")
self.test_user.token_set.add(self.access_token)
def test_user_login_with_valid_credentials(self):
post_data = {
'email': "*****@*****.**",
'password': "******",
}
resp = self.client.post('/users/login/',
data=json.dumps(post_data),
content_type='application/json')
resp_data = json.loads(resp.content)
self.assertEqual(200, resp.status_code)
self.assertEqual("test_access_token", resp_data['access_token'])
def test_user_login_with_bad_password(self):
post_data = {
'email': "*****@*****.**",
'password': "******",
}
resp = self.client.post('/users/login/',
data=json.dumps(post_data),
content_type='application/json')
self.assertEqual(404, resp.status_code)
class getUserProjectTestCase(TestCase):
def setUp(self):
#initial information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "asfja"
self.user.isConfirmed = True
self.user.save()
self.emptyProjectUser = User()
self.emptyProjectUser.userName = "******"
self.emptyProjectUser.password = "******"
self.emptyProjectUser.email = "1312"
self.emptyProjectUser.isConfirmed = False
self.emptyProjectUser.save()
self.project1 = Project()
self.project1.project_name = "project1"
self.project1.creator_id = self.user
self.project1.save()
self.project2 = Project()
self.project2.project_name = "project2"
self.project2.creator_id = self.user
self.project2.save()
def test_normal(self):
self.assertTrue(getUserProject(self.user)['isSuccessful'])
def test_empty_project(self):
self.assertEqual(getUserProject(self.emptyProjectUser)['projects'], [])
class DocTest(TestCase):
def setUp(self):
self.user = User(username="******", password="******")
self.user.save()
self.doc = Doc(
name="test",
user=self.user,
text="A little text")
self.doc.save()
def test_text_hash(self):
one = 'one'
two = 'two'
hash_one = sha224(one).hexdigest()
hash_two = sha224(two).hexdigest()
self.doc.text = one
self.doc.save()
self.assertEqual(self.doc.text_hash, hash_one)
self.doc.text = two
self.doc.save()
self.assertEqual(self.doc.text_hash, hash_two)
class PasswordResetCompleteViewTest(TestCase):
url = reverse('accounts:password_reset_complete')
@classmethod
def setUpTestData(self):
self.user = User(email=EMAIL,
username=USERNAME,
is_active=True,
is_verified=True,
accepted_tos=True)
self.user.set_password(PASSWORD)
self.user.save()
# def test_right_template_is_used(self):
# session = self.client.session
# session['can_view_password_reset_done'] = True
# session.save()
# response = self.client.get(self.url, follow=True)
# self.assertTemplateUsed(response, 'accounts/password_reset_complete.html')
def test_direct_access_redirects_to_password_reset(self):
reset_url = reverse('accounts:password_reset')
done_url = reverse('accounts:password_reset_complete')
response = self.client.get(done_url)
self.assertRedirects(response, reset_url)
def save(self, commit=True):
function = super(FunctionRegisterForm, self).save(commit=False)
function.ministry = self.ministry
function.save()
po = self.data['people']
pov = self.data['people_value']
po = po.split(', ')
pov = pov.split(', ')
po = [{'key': l, 'value': v} for l, v in zip(po, pov)]
for i in po:
if i is not None and i['value'] != "":
us = User() if i['key'] == "" else get_object_or_404(
User, pk=int(i["key"]))
if us.pk is None:
us = User.addDefault(i['value'])
function.people.add(us)
fn = self.data['overload']
fnv = self.data['overload_value']
fn = fn.split(', ')
fnv = fnv.split(', ')
fn = [{'ley': l, 'value': v} for l, v in zip(fn, fnv)]
for i in fn:
if i is not None and i['value'] != "":
fn = get_object_or_404(Function, pk=int(i["key"]))
if fn:
function.overload.add(fn)
if commit:
function.save()
return function
class saveChainTestCase(TestCase):
def setUp(self):
#initial information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "email"
self.user.is_confirmed = True
self.user.save()
self.project = project()
self.project.project_name = "project"
self.project.creator = self.user
self.project.save()
self.chain1 = chain()
self.chain1.name = "chain1"
self.chain1.id = 1
self.chain1.sequence = "1_2_3"
self.chain1.project = self.project
self.chain1.save()
self.client = Client()
def test_chainId_not_exist(self):
self.saveResponse = self.client.post('/home/updateChain',{'chain':'1_2','id':3})
self.realResult = JSONDecoder().decode(self.saveResponse.content)
self.assertEqual(self.realResult['isSuccessful'],False)
def test_chainId_exist(self):
self.saveResponse = self.client.post('/home/updateChain',{'chain':'1_2','id':1})
self.realResult = JSONDecoder().decode(self.saveResponse.content)
self.assertEqual(self.realResult['isSuccessful'],True)
def test_forum_comment(self):
user = User(email='*****@*****.**', first_name='Test', last_name='Case')
user.save()
topic = ForumTopic(topic_title='Test')
topic.save()
comment = ForumComment(forum_topic=topic,
author=user,
comment='my comment')
comment.save()
reply = ForumCommentReply(forum_comment=comment,
author=user,
comment='my reply')
reply.save()
print('TestForumModels: ForumComment - test_forum_comment \n \
Expected: {0}, Actual: {1} \n \
Expected: {2}, Actual: {3} \n \
Expected: {4}, Actual: {5} \n \
Expected: {6}, Actual: {7}'.format(
'Test', comment.forum_topic.topic_title, 'my comment',
comment.comment, '*****@*****.**', comment.author.email, 'my reply',
reply.comment))
self.assertEqual(comment.forum_topic.topic_title, 'Test')
self.assertEqual(comment.comment, 'my comment')
self.assertEqual(comment.author.email, '*****@*****.**')
self.assertEqual(reply.comment, 'my reply')
def handle(self, *args, **options):
poll_object = json.load(options['file'])
poll = VotingPoll(
title=options['title'],
description=options['description'],
admin=WhaleUser.objects.get(id=options['user_id']),
preference_model=poll_object['preferenceModel']['id'],
closing_date=date.today())
poll.save()
self.stdout.write(
self.style.SUCCESS('Successfully created poll "%s"' % poll.id))
candidates = []
for c in poll_object['candidates']:
candidates.append(Candidate(poll=poll, candidate=c))
candidates[-1].save()
self.stdout.write(
self.style.SUCCESS('Successfully added %d candidates' %
len(candidates)))
for v in poll_object['votes']:
voter = User(nickname=v['name'])
voter.save()
for i, sc in enumerate(v['values']):
VotingScore(candidate=candidates[i], voter=voter,
value=sc).save()
self.stdout.write(
self.style.SUCCESS('Successfully added %d votes' %
len(poll_object['votes'])))
def delete_images(self, user: accounts_models.User,
id_image: int) -> accounts_models.User:
"""
Delete one image assigned to profile user, this method raises a exception if the id of image
not exits in database
:param user: user weedmatch.
:type user: Model User
:param id_image: id of image profile.
:type id_image: integer
:return: Model User
:raises: ValueError
"""
if user is None or user.is_active is False:
raise ValueError('{"detail":"' + str(
_("In order to perform this operation, your account must be active"
)) + '"}')
try:
image = accounts_models.ImageProfile.objects.get(id=id_image,
user_id=user.id)
except accounts_models.ImageProfile.DoesNotExist:
raise ValueError('{"detail":"' +
str(_("There is no such image on your profile")) +
'"}')
if user.image == str(image.image_profile):
user.image = ""
user.save()
os.remove(
os.path.join(settings.MEDIA_ROOT, str(image.image_profile.name)))
image.delete()
user.count_delete()
return user
def done(self, form_list, form_dict, **kwargs):
event = form_dict.get('create_event', None)
event = event.save(commit=False)
venue = form_dict.get('create_venue', None)
if venue:
venue = venue.save(commit=False)
venue.user = User.create_placeholder_user(venue.name)
venue.region = self.request.region
venue.save()
event.venue = venue
# TODO Replace with real email addresses
send_mail(
'New Venue Created',
'A new venue has been added to the site. You can see it at %s'
% venue.get_absolute_url(),
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
event.user = User.create_placeholder_user(event.name)
event.region = self.request.region
event.save()
# TODO Replace Event real email addresses
send_mail(
'New Event Created',
'A new event has been added to the site. You can see it at %s' %
event.get_absolute_url(),
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
return HttpResponseRedirect(event.get_absolute_url())
def add_patient(request):
response = {}
try:
first_name = request.GET['first_name']
last_name = request.GET['last_name']
password = request.GET['password']
birthday = request.GET['birthday']
gender = request.GET['gender']
email = request.GET['email']
phone = request.GET['phone']
postcode = request.GET['postcode']
address = request.GET['address']
practice = request.GET['practice']
user = User(first_name=first_name,
last_name=last_name,
password=make_password(password),
birthday=birthday,
gender=gender,
useremail=email,
phone_number=phone,
postcode=postcode,
address=address,
practice=practice,
is_active=0,
user_type='PA')
user.save()
response['status'] = 'success'
except Exception:
response['status'] = 'error'
return HttpResponse(json.dumps(response), content_type="application/json")
def save(self):
#user = super(CompanionForm, self).save()
userprofile = super(CompanionForm, self).save()
if not userprofile.account and self.account:
userprofile.account = self.account
userprofile.save()
#try:
# user_profile = user.userprofile
#except:
# user_profile = UserProfile(first_name=user.first_name, last_name=user.last_name, email=user.email, account=acct, user=user)
# data = self.cleaned_data
#
# user_profile.phone = data.get('phone')
# user_profile.mobile_phone = data.get('mobile_phone')
# user_profile.date_of_birth = data.get('date_of_birth')
# user_profile.weight = data.get('weight')
# user_profile.save()
try:
user = userprofile.user
user.first_name = userprofile.first_name
user.last_name = userprofile.last_name
user.email = userprofile.email
except:
user = User(userprofile=userprofile, first_name=userprofile.first_name, last_name=userprofile.last_name, email=userprofile.email, account=self.account)
user.save()
return userprofile
def test_display_name(self):
"""Test that User.display_name uses first_name or username."""
bob = User(username='******')
self.assertEqual('bob', bob.display_name)
bob.first_name = 'Robert'
self.assertEqual('Robert', bob.display_name)
def upload_images(self, user: accounts_models.User,
data: dict) -> accounts_models.User:
"""
the user can upload images for his profile, if he has not assigned a still the first image
to upload he will be placed in profile, this method raises exception if the user try
upload a seventh image
:param user: user weedmatch.
:type user: Model User.
:param data: user data.
:type data: dict
:return: Model User
:raises: ValueError
"""
if user is None or user.is_active is False:
raise ValueError('{"detail":"' + str(
_("In order to perform this operation, your account must be active"
)) + '"}')
if not data.get('image'):
raise ValueError(
'{"detail":"' +
str(_("The profile image field can not be empty")) + '"}')
if user.count_image < 6:
images_profile = accounts_models.ImageProfile.objects.create(
user_id=user.id, image_profile=data.get('image'))
if not user.image:
user.assign_image_profile(str(images_profile.image_profile))
user.count_increment()
else:
raise ValueError('{"detail":"' + str(
_("You can not upload more than 6 images in your profile, you must delete some"
)) + '"}')
return user
class TestLecture(TestCase):
def setUp(self):
self.batch = Batch.objects.create(number=1, start_date=date.today())
self.course = Course.objects.create(name="Advanced Python")
self.professor = User(username='******',
email='*****@*****.**',
is_staff=True)
self.professor.set_password('123')
self.professor.save()
self.instance = CourseInstance.objects.create(
course=self.course,
professor=self.professor,
batch=self.batch,
lecture_utc_time=timezone.now(),
lecture_weekday='0')
def test_lecture_was_created(self):
"""Should create a Lecture model when only required data is given"""
Lecture.objects.create(title="Flask", course_instance=self.instance)
self.assertEqual(Lecture.objects.count(), 1)
def test_lecture_was_created_all_parameters(self):
"""Should create a Lecture model when all fields are given"""
lecture = Lecture.objects.create(title="Flask",
date=timezone.now(),
video_url="www.youtube.com",
slides_url="www.rmotr.com",
content="The flask framework",
course_instance=self.instance)
self.assertEqual(Lecture.objects.count(), 1)
self.assertIn(lecture.title, "Flask")
class formatProjectListTestCase(TestCase):
def setUp(self):
#initial information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "asfja"
self.user.is_confirmed = True
self.user.save()
self.project1 = project()
self.project1.project_name = "project1"
self.project1.creator = self.user
self.project1.save()
self.project2 = project()
self.project2.project_name = "project2"
self.project2.creator = self.user
self.project2.save()
def test_list_exist(self):
self.projectList = project.objects.filter(creator=self.user, is_deleted=False)
# construct the predict result
#print formatProjectList(self.projectList)
self.predictResult = list()
self.p1 = {
'id':1L,
'name':unicode(self.project1.project_name,"utf-8"),
'creator':unicode(self.user.username,"utf-8"),
'function':None,
'track':None,
}
def handle(self, *args, **options):
poll_object = json.load(options['file'])
poll = VotingPoll(
title=options['title'],
description=options['description'],
admin=WhaleUser.objects.get(id=options['user_id']),
preference_model=poll_object['preferenceModel']['id'],
closing_date = date.today()
)
poll.save()
self.stdout.write(self.style.SUCCESS('Successfully created poll "%s"' % poll.id))
candidates = []
for c in poll_object['candidates']:
candidates.append(Candidate(
poll=poll,
candidate=c))
candidates[-1].save()
self.stdout.write(self.style.SUCCESS('Successfully added %d candidates' % len(candidates)))
for v in poll_object['votes']:
voter = User(nickname=v['name'])
voter.save()
for i, sc in enumerate(v['values']):
VotingScore(
candidate=candidates[i],
voter=voter,
value=sc).save()
self.stdout.write(self.style.SUCCESS('Successfully added %d votes' % len(poll_object['votes'])))
def setUp(self):
# Create client and data for new user
self._client = APIClient()
self._admin = User(**ADMIN_USER_DATA)
self._admin.set_password(ADMIN_USER_DATA['password'])
self._admin.save()
self._user = User(**NEW_USER_DATA)
self._user.set_password(NEW_USER_DATA['password'])
self._user.save()
self._client.login(email=ADMIN_USER_DATA['email'],
password=ADMIN_USER_DATA['password'])
create_url = reverse('person-list')
self._data = NEW_PERSON_DATA.copy()
self._data['user'] = self._user.pk
response = self._client.post(create_url, self._data,
format='json')
try:
self._content_data = json.loads(response.content)
except ValueError:
raise AssertionError(
_(u'Invalid response content format, not a JSON'))
self._person_id = self._content_data.get('id')
if not self._person_id:
raise AssertionError(_(u'Not a Person ID in data'))
class getUserProjectTestCase(TestCase):
def setUp(self):
#initial information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "asfja"
self.user.is_confirmed = True
self.user.save()
self.emptyProjectUser = User()
self.emptyProjectUser.username = "******"
self.emptyProjectUser.password = "******"
self.emptyProjectUser.email = "1312"
self.emptyProjectUser.is_confirmed = False
self.emptyProjectUser.save()
self.project1 = project()
self.project1.project_name = "project1"
self.project1.creator = self.user
self.project1.save()
self.project2 = project()
self.project2.project_name = "project2"
self.project2.creator = self.user
self.project2.save()
def test_normal(self):
self.assertTrue(getUserProject(self.user)['isSuccessful'])
def test_empty_project(self):
self.assertEqual(getUserProject(self.emptyProjectUser)['projects'],[])
def safe_mutate(cls, root, info, **kwargs):
code = kwargs.pop('invitation_code', None)
host = None
if code:
try:
host = User.objects.get(invitation_code=code)
except User.DoesNotExist:
return cls.error(invitation_code=['کد نامعتبر است.'])
first_name = kwargs.get('first_name')
last_name = kwargs.get('last_name')
phone = kwargs.get('phone')
password = kwargs.get('password')
user = User(first_name=first_name,
last_name=last_name,
username=phone,
phone=phone,
password=password)
user.generate_code()
try:
user.full_clean()
except ValidationError as e:
e.error_dict.pop('username', None)
raise e
user.send_code_by_sms()
user.save()
if host:
Invitation(host, None).reward(user)
return cls(user=user)
class formatProjectListTestCase(TestCase):
def setUp(self):
#initial information into temperory database
self.user = User()
self.user.userName = "******"
self.user.password = "******"
self.user.email = "asfja"
self.user.isConfirmed = True
self.user.save()
self.project1 = Project()
self.project1.project_name = "project1"
self.project1.creator_id = self.user
self.project1.save()
self.project2 = Project()
self.project2.project_name = "project2"
self.project2.creator_id = self.user
self.project2.save()
def test_list_exist(self):
self.projectList = Project.objects.filter(creator_id=self.user)
# construct the predict result
#print formatProjectList(self.projectList)
self.predictResult = list()
self.p1 = {
'id': 1L,
'name': unicode(self.project1.project_name, "utf-8"),
'creator': unicode(self.user.userName, "utf-8"),
'function': None,
'track': None,
}
def setUp(self):
self.user = User(username=USERNAME,
email=EMAIL,
is_active=True,
is_verified=True)
self.user.set_password(PASSWORD)
self.user.save()
def register(request):
if request.method == 'POST':
user_name = request.POST['UserName']
email = request.POST['Email']
Image = request.POST['Image']
password = request.POST['Password']
reenterpassword = request.POST['Reenter password']
if password == reenterpassword:
if User.objects.filter(user=user_name).exists():
messages.info(request, "user taken")
return redirect('accounts:register')
elif User.objects.filter(email=email).exists():
messages.info(request, "email taken")
return redirect('accounts:register')
else:
user = User(user=user_name, email=email, password=password)
user.save()
messages.info(request, 'user created')
else:
messages.info(request, "Password Incorrect")
return redirect('accounts:register')
return redirect(
'/') #here URL is same but by method identify GET or Post
else:
return render(request, 'accounts/signup.html')
def test_user_string_representation(self):
user = User(email='*****@*****.**',
name='Someone',
password='******')
user.save()
self.assertEqual(str(user), user.email)
def update_user_score(user: User, submission: Submission) -> bool:
"""
Given a tested submission with score, update the user's score IF:
1. He has not submitted for the given challenge before
2. He has submitted for the given challenge before but with a lower score
Returns a boolean whether the score was updated or not
"""
max_prev_score = Submission.objects.filter(challenge=submission.challenge, author=user) \
.exclude(id=submission.id) \
.all() \
.aggregate(Max('result_score'))['result_score__max']
if max_prev_score is None or max_prev_score < submission.result_score:
score_improvement = None
if max_prev_score is None:
# The user does not have any previous submissions, so we update his score
score_improvement = submission.result_score
else:
# The user has submitted a better-scoring solution. Update his score
score_improvement = submission.result_score - max_prev_score
user_subcat_progress: UserSubcategoryProficiency = user.fetch_subcategory_proficiency(
submission.challenge.category_id)
user_subcat_progress.user_score += score_improvement
user_subcat_progress.save()
user.score += score_improvement
user.save()
# try to update the user's proficiency
updated_proficiency = user_subcat_progress.try_update_proficiency()
return True
return False
def assing_image_profile(self, user: accounts_models.User,
id_image: int) -> accounts_models.User:
"""
Assigned a image for profile user, this image can see for all user in weedmtach, this method
raise a exception if id of image not exist in database
:param user: user weedmtach
:type user: Model User
:param id_image: id of image profile
:type id_image: integer
:return: Model User
:raise: ValueError
"""
if user is None or user.is_active is False:
raise ValueError('{"detail":"' + str(
_("In order to perform this operation, your account must be active"
)) + '"}')
try:
image = accounts_models.ImageProfile.objects.get(id=id_image,
user_id=user.id)
except accounts_models.ImageProfile.DoesNotExist:
raise ValueError('{"detail":"' +
str(_("There is no such image on your profile")) +
'"}')
user.assign_image_profile(str(image.image_profile))
return user
def update_distance(self, user: accounts_models.User,
data: dict) -> accounts_models.User:
"""
A user can change the distance in which people appear in the public feed 420.
this method raise a exception when the distance they are not numbers or exceed the limits.
:param user: user weedmatch.
:type user: Model User.
:param data: distance
:type data: ditc
:return: Model User.
:raises: ValueError
"""
if user is None or user.is_active is False:
raise ValueError('{"user":"******"In order to perform this operation, your account must be active"
)) + '"}')
if not data.get('distance'):
raise ValueError('{"detail":"' +
str(_("The distance field can not be empty")) +
'"}')
if not re.match("[0-9]+", data.get("distance")):
raise ValueError('{"detail":"' +
str(_("The distance value can only be numbers")) +
'"}')
data["distance"] = int(data.get("distance"))
validator = accounts_validations.ProfileUserDistance(data)
if validator.validate() is False:
errors = validator.errors()
for value in errors:
errors[value] = validator.change_value(errors[value])
raise ValueError(errors)
user.distance = data.get('distance')
user.save()
return user
def update_user(self, user: User, user_information: dict):
if user_information:
user.update(
email=user_information['email'],
lastname=user_information['last_name'],
firstname=user_information['first_name']
)
def create(self, data):
user = UserModel(
email=data['email'],
)
user.set_password(data['password'])
user.save()
return user
def test_user_save_ok(self):
user = User(user_id=self.user_id,
user_name=self.user_name,
password=self.password)
user.save()
user_instance = User.objects.get(user_id=self.user_id)
self.assertEqual(self.user_name, user_instance.user_name)
def setUpTestData(self):
self.user = User(email=EMAIL,
username=USERNAME,
is_active=True,
is_verified=True,
accepted_tos=True)
self.user.set_password(PASSWORD)
self.user.save()
def create_comment(self, username='', password='', title='', comment=''):
user = User(username=username)
user.set_password(password)
user.save()
daily = Daily.objects.create(user=user, title=title)
daily.save()
comment = Comment.objects.create(user=user, daily=daily, comment=comment)
comment.save()
def import_users(self):
cols = [
'id',
'jabber',
'url',
'signatura',
'nick',
'heslo',
'email',
'zobrazit_mail',
'prava',
'lastlogin',
'more_info',
'info',
'rok',
'real_name',
]
self.cursor.execute('SELECT COUNT(*) FROM users WHERE prava > 0')
self.logger.set_sub_progress(u"Užívatelia", self.cursor.fetchall()[0][0])
self.cursor.execute('SELECT ' + (', '.join(cols)) + ' FROM users WHERE prava > 0')
user_objects = []
for user in self.cursor:
self.logger.step_sub_progress()
user_dict = self.decode_cols_to_dict(cols, user)
user = {
'pk': user_dict['id'],
'username': user_dict['nick'][:30],
'email': user_dict['email'][:75],
'password': user_dict['heslo'],
'is_active': False,
'last_login': self.first_datetime_if_null(user_dict['lastlogin']),
'jabber': self.empty_if_null(user_dict['jabber']),
'url': self.empty_if_null(user_dict['url']),
'signature': self.empty_if_null(user_dict['signatura']),
'display_mail': self.empty_if_null(user_dict['zobrazit_mail']),
'distribution': self.empty_if_null(user_dict['more_info']),
'info': self.empty_if_null(user_dict['info']),
'year': user_dict['rok'],
}
if user_dict['real_name']:
space_pos = user_dict['real_name'].find(' ')
if space_pos == -1:
user['first_name'] = user_dict['real_name']
else:
user['first_name'] = user_dict['real_name'][:space_pos]
user['last_name'] = user_dict['real_name'][space_pos + 1:]
if user_dict['prava'] > 0:
user['is_active'] = True
if user_dict['prava'] > 1:
user['is_staff'] = True
if user_dict['prava'] > 2:
user['is_superuser'] = True
user_object = User(**user)
user_object.set_password(user['password'])
user_objects.append(user_object)
User.objects.bulk_create(user_objects)
connections['default'].cursor().execute('SELECT setval(\'auth_user_id_seq\', (SELECT MAX(id) FROM auth_user) + 1);')
self.logger.finish_sub_progress()
def save(self, email):
name = self.name.data
username = self.username.data
password = self.password.data
email = email
user = User(name=name, username=username, password=password, email=email)
user.save()
return user
def create_user():
user = User()
user.username = request.form.get('username', None)
user.first_name = request.form.get('first_name', '')
user.last_name = request.form.get('last_name', '')
user.email = request.form.get('email', '')
user.account = request.form.get('account', None)
user.set_password(request.form.get('password', ''))
user.save()
return redirect(url_for('accounts.users'))
def create_user():
try:
username = raw_input("Username: "******"Email: ").strip()
while True:
password = getpass("Password: "******" (confirm): ")
if password_confirm == password:
break
else:
print("Passwords do not match... Try again...")
u = User(username=username)
u.email = email
# check for org
org = Organization.get_by_name("default")
if not org:
org = Organization()
org.name = "default"
org.owner = u.uuid
org.save()
u.organization = Organization.get_by_name("default").uuid
u.set_password(password)
u.add_role("admin")
u.save()
print("User created/updated successfully...")
except KeyboardInterrupt:
pass
def authenticate(self, openid_key, request):
steamid64 = openid_key.split("/")[-1]
try:
user = User.objects.get(steam_id = steamid64)
# TODO schedule webapi call
except User.DoesNotExist:
user = User()
user.steam_id = steamid64
user.save()
# TODO force synchronous webapi call
return user
def post(self):
context = self.get_context()
form = context.get('login_user_form')
if form.validate():
try:
user = User.objects.get(email=form.email.data)
except DoesNotExist:
user = User(email=form.email.data)
if 'X-Forwarded-For' in request.headers:
remote_addr = request.headers.getlist("X-Forwarded-For")[0].rpartition(' ')[-1]
else:
remote_addr = request.remote_addr or 'untrackable'
old_current_login, new_current_login = user.current_login_at, datetime.utcnow()
old_current_ip, new_current_ip = user.current_login_ip, remote_addr
user.last_login_at = old_current_login or new_current_login
user.current_login_at = new_current_login
user.last_login_ip = old_current_ip or new_current_ip
user.current_login_ip = new_current_ip
user.login_count = user.login_count + 1 if user.login_count else 1
user.save()
login_user(user)
flash("Logged in user")
return redirect(url_for('pages.home'))
else:
flash_errors(form)
return render_template('home.html', **context)
class getChainLengthTestCase(TestCase):
def setUp(self):
self.client = Client()
#initial information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "email"
self.user.is_confirmed = True
self.user.save()
self.project = project()
self.project.project_name = "project"
self.project.creator = self.user
self.project.save()
self.chain1 = chain()
self.chain1.name = "chain1"
self.chain1.id = 1
self.chain1.sequence = "1_2_3_4_5"
self.chain1.project = self.project
self.chain1.save()
self.chain2 = chain()
self.chain2.name = "chain2"
self.chain2.id = 2
self.chain2.sequence = ""
self.chain2.project = self.project
self.chain2.save()
self.chain3 = chain()
self.chain3.name = "chain3"
self.chain3.id = 3
self.chain3.sequence = "1"
self.chain3.project = self.project
self.chain3.save()
self.chain4 = chain()
self.chain4.name = "chain4"
self.chain4.id = 4
self.chain4.sequence = "1__5"
self.chain4.project = self.project
self.chain4.save()
def test_normalLen_chain(self):
self.lenResponse = self.client.get('/home/getChainLength',{'id':1})
self.realResult = JSONDecoder().decode(self.lenResponse.content)
self.assertEqual(self.realResult['length'],5)
def test_oneLen_chain(self):
self.lenResponse = self.client.get('/home/getChainLength',{'id':3})
self.realResult = JSONDecoder().decode(self.lenResponse.content)
self.assertEqual(self.realResult['length'],1)
class UserTestCase(GraphQLTest):
def setUp(self):
self.maxDiff = None
self.user = User(
username='******',
email='*****@*****.**'
)
self.user.set_password('patricio')
self.user.save(request=None)
self.user_2 = User(
username='******',
email='*****@*****.**'
)
self.user_2.set_password('patricia')
self.user_2.save(request=None)
def _do_login(self, username='******', password='******'):
response = self.graphql({
'query': '''
mutation M($auth: AuthenticateInput!) {
authenticate(input: $auth) {
clientMutationId,
viewer {
me {
username
isAuthenticated
}
}
}
}
''',
'variables': {
'auth': {
'clientMutationId': 'mutation2',
'username': username,
'password': password,
}
}
})
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json(), {
'data': {
'authenticate': {
'viewer': {
'me': {
'username': username,
'isAuthenticated': True
},
},
'clientMutationId': 'mutation2'
},
}
})
self.assertTrue('sessionid' in response.cookies)
return response
def _do_login_2(self, username='******', password='******'):
return self._do_login(username, password)
def setUp(self):
self.maxDiff = None
self.user = User(
username='******',
email='*****@*****.**'
)
self.user.set_password('patricio')
self.user.save(request=None)
self.user_2 = User(
username='******',
email='*****@*****.**'
)
self.user_2.set_password('patricia')
self.user_2.save(request=None)
def decorated(*args, **kwargs):
api_key = None
if 'apikey' in request.form:
api_key = request.form.get('apikey')
elif 'X-Api-Key' in request.headers.keys():
api_key = request.headers.get('X-Api-Key')
# validate
if not api_key:
data = {'error': messages.NO_API_KEY}
return generate_api_response(data, 401)
user = User.get_by_api_key(api_key=api_key)
organization = Organization.get_by_api_key(api_key=api_key)
if not user and not organization:
data = {'error': messages.INVALID_API_KEY}
return generate_api_response(data, 401)
requested_org = kwargs.get('organization','')
# check that user is active
if user:
session['user'] = user
# allow admins to see all orgs
if user.is_admin():
session['organization'] = Organization.get_by_name(requested_org)
else:
session['organization'] = Organization.get_by_uuid(user.organization)
if not user.active:
data = {'error': messages.ACCOUNT_INACTIVE}
return generate_api_response(data, 403)
if organization:
session['organization'] = organization
# check that user is authorized for the desired organization
if requested_org and requested_org != session.get('organization').name.lower():
data = {'error': messages.ACCESS_DENIED}
return generate_api_response(data, 403)
return f(*args, **kwargs)
def allTags(request):
uid = request.session.get('user')
#if user not connected
if uid is None:
#if not request.user.is_authenticated():
return sign_in(request)
else:
uid = request.session.get('user')
usr = User.get_by_id(uid)
## retrieve all tags slug based on user
all_tags = Tag.objects.filter(share__author=usr).order_by('-tag_count').annotate(tag_count=models.Count('share'))
return render_to_response('all_tags.html', {
'user':usr,
'all_tags': all_tags,
# 'shares': shares
}, context_instance=RequestContext(request),)
def test_create_delete_user(self):
username = self.test_user_username
email = self.test_user_email
password = self.test_user_password
self.assertTrue(create_user(username, email, password))
self.assertTrue(User.get_by_username(self.test_user_username))
self.assertTrue(delete_user(username))
def TagList(request, tag):
uid = request.session.get('user')
#if user not connected
if uid is None:
#if not request.user.is_authenticated():
return sign_in(request)
else:
uid = request.session.get('user')
usr = User.get_by_id(uid)
## retrieve tags slug based on user
shares = usr.shares.filter(taggit__slug=tag).order_by('-created_at')
#shares = Share.objects.filter(taggit__name=tag, author=user).select_related().get()
return render_to_response('tag_list.html', {
'user':usr,
'tag_list': shares
}, context_instance=RequestContext(request),)
def test_creating_new_user(self):
user = User()
user.username = "******"
user.email = "*****@*****.**"
user.set_password("test")
user.full_clean()
user.save()
all_users = User.objects.all()
self.assertEqual(len(all_users), 1)
user_from_database = all_users[0]
self.assertEquals(user_from_database, user)
def create_user(username=None, email=None, password=None):
u = User()
u.username = username
u.email = email
u.set_password(password)
u.save()
return True
class createNewDeviceTestCase(TestCase):
def setUp(self):
#initail information into temperory database
self.user = User()
self.user.username = "******"
self.user.password = "******"
self.user.email = "email"
self.user.is_confirmed = True
self.user.save()
self.project = project()
self.project.id = 1
self.project.project_name = "project"
self.project.creator = self.user
self.project.save()
self.client = Client()
def test_no_login_createDevice(self):
self.response = self.client.post('/home/newDevice',{'name':'newChain','id':1})
#response.content is The body of the response, as a string.
#This is the final page content as rendered by the view,
# or any error message.
# self.response.content is a string ,need to
self.result = JSONDecoder().decode(self.response.content)
self.assertEqual(self.result['isSuccessful'],False)
def test_createDevice_afterLogin(self):
#modify the value in session
self.engine = import_module(settings.SESSION_ENGINE)
self.session = self.engine.SessionStore()
self.session['username'] = '******'
self.session['isLoggedIn'] = True
self.session.save()
self.client.cookies[settings.SESSION_COOKIE_NAME] = self.session.session_key
#get the real response
self.createResponse = self.client.post('/home/newDevice',{'name':'newChain','id':1})
# convert the result string to dict object
self.realResult = JSONDecoder().decode(self.createResponse.content)
self.predictResult = {
unicode('isSuccessful',"utf-8"):True,
unicode('name',"utf-8"):unicode('newChain',"utf-8"),
unicode('id',"utf-8"):unicode('1',"utf-8")
}
self.assertEqual(cmp(self.realResult,self.predictResult),0)
def handle(self, *args, **options):
print('Starting...')
print('======= SUMMARY =======')
with open(options['filepath'], 'r') as f:
reader = smartcsv.reader(f, columns=CSV_STRUCTURE)
counter = 0
for row in reader:
user = User(**row)
# generate random password
password = self.get_random_passwd()
user.set_password(password)
user.save()
print('{}\t{}'.format(user.username, password))
counter += 1
print('=======================')
print('Finished creating {} users.'.format(counter))
def setUp(self):
self.factory = RequestFactory()
self.test_user_password = "******"
self.test_user = User(email="*****@*****.**")
self.test_user.set_password(self.test_user_password)
self.test_user.save()
self.access_token = Token(token="test_access_token")
self.test_user.token_set.add(self.access_token)
def delete_user(username=None):
u = User.get_by_username(username)
ret_val = False
if u:
u.remove()
ret_val = True
return ret_val
def setUp(self):
# Create client and data for new user
self._client = APIClient()
self._admin = User(**ADMIN_USER_DATA)
self._admin.set_password(ADMIN_USER_DATA['password'])
self._admin.save()
self._client.login(email=ADMIN_USER_DATA['email'],
password=ADMIN_USER_DATA['password'])
def create(self, validated_data):
user = User()
user.set_password(validated_data["password"])
user.email = validated_data['email']
user.first_name = validated_data['first_name']
user.last_name = validated_data['last_name']
user.phone_number = validated_data['phone_number']
return user
