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 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