def fill_db(self): for i in range(0, 30): usr = User(username='******' + str(i), password='******' + str(i), first_name='User') usr.save() prof = Profile(avatar='avatar.jpeg', user=usr) prof.save() try: tbag = Tag.objects.get(name='Bucket' + str(i % 20)) tbag.popularity += 1 except Exception: tbag = Tag(name='Bucket' + str(i % 20), popularity=1) tbag.save() quest = Question(title=str(i) + 'bucket', text='see my bucket, I have a' + str(10000 - i) + ' bucket remains', author=prof, votes=i) quest.save() quest.liked.add(prof) quest.tag.add(tbag) for j in range(0, 20): ans = Answer(text='Test answer' + str(i), author=prof, question=quest) ans.votes = int(((i + j) * 6) % 40) ans.save() ans.voted.add(prof)
def test_mention_event(self): user = User({"username": "******", "ext_id": "test"}) user.save() other_user = User({"username": "******", "ext_id": "other"}) other_user.save() p = Question({ "title": "test title", "body": "test body, @test is mentioned", "tags": ["test-tag"], "author_id": user._id }) p.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 0) a = p.create_answer({ "author_id": other_user._id, "body": "this @test mention should create an event" }) a.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 2) # new comment event and mention event found_mention_event = False for event in events: if isinstance(event, MentionEvent): found_mention_event = True self.assertEqual(event.author_id, other_user._id) self.assertEqual(event.post_id, a._id) self.assertTrue(found_mention_event)
def _fill_user(self): print('FILLING USER MODEL...') for ix in range(500): temp_user = User(username='******'.format(ix + 1), registration_date=timezone.now(), rating=np.random.normal(scale=50), path='user{}'.format(ix + 1)) temp_user.save() print('ADDED {} USERS.'.format(User.objects.count()))
def generateUsers(n): import urllib2, hashlib nickWords = [ "Void", "Facelessness", "OMG", "_xxxMLGxxx_", "lox", "zeus", "warlock", "murlock", "YoLo", "YoYo", "rwl_lll_rl", "Flash", "Batman", "Bat", "mobile", "rang", "l33t", "h@xx0r", "Orange", "Annoying", "Apple", "Hey", "dummy", "stuff", "annoy", "word", "Shadow", "Ivan", "Vladimir", "ROFL", "Enigma", "Rubick", "cube", "Cube", "Horadirc", "Deckard", "Kain", "user", "version", "test", "hello", "world", "master", "HealBot", "Loatheb", "jinxed" ] + [""] * 5 nameWords = [ "Ivan", "Leah", "Deckard", "Tyrael", "Nova", "Sarah", "Jim", "Tassadar", "Zeratul", "Azmodan" ] + [""] * 10 surnameWords = [ "Chrono", "Kain", "ArchangelOfJustice", "Terra", "Kerrigan", "Raynor", "SaviorOfTemplar", "LordOfSin" ] + [""] * 9 for i in range(n): username = random.choice(nickWords) + random.choice(nickWords) + str( random.randint(i, i * 10 + 10)) password = ''.join([ random.choice("qwertyuiopasdfghjklzxcvbnm!@1234567890") for t in range(16) ]) email = random.choice(nickWords) + random.choice( username) + '@' + random.choice(["mail.ru"] + ["mailinator.com"] * 10) firstName = random.choice(nameWords) lastName = random.choice(surnameWords) avatarSize = 100 gravatarUrl = "http://www.gravatar.com/avatar/" + hashlib.md5( email.lower()).hexdigest() + "?" gravatarUrl += "d=identicon&s=100" av = urllib2.urlopen(gravatarUrl) tmpFile = open("tmp", "w") tmpFile.write(av.read()) tmpFile.close() av = open("tmp", "r") av = File(av) usr = User(username=username, password=password, email=email, first_name=firstName, last_name=lastName) usr.save() usrAccount = UserAccount(user=usr, avatar=av, rating=random.randint(1, 10)) usrAccount.save() av.close() if i % 5 == 0: print i
def drop(self): fx_users = User.find({"username": re.compile(r"^fx_test_user")}) user_ids = [u._id for u in fx_users] ctx.log.info("dropping fixture comments") Comment.destroy_many({"author_id": {"$in": user_ids}}) ctx.log.info("dropping fixture answers") Answer.destroy_many({"author_id": {"$in": user_ids}}) ctx.log.info("dropping fixture questions") Question.destroy_many({"author_id": {"$in": user_ids}}) ctx.log.info("dropping fixture users") User.destroy_many({"username": re.compile(r"^fx_test_user")})
def suggest(): import re query = {} prefix = request.values.get("prefix") if prefix: try: prefix = re.compile("^" + prefix) query = { "$or": [ { "username": prefix }, { "first_name": prefix }, { "last_name": prefix }, ] } except re.error: pass users = User.find(query).sort("username", 1).limit(10) users = [ user.to_dict(fields=["username", "first_name", "last_name"]) for user in users ] return json_response({"data": users})
def cmd_start(self, message): ctx.log.debug("running command 'start' by request from %s", message.chat.to_dict()) if message.chat.type != "private": self.send_message( message.chat.id, "Hey there! Unfortunately I'm not capable of working in groups. " "Please add me privately") return chat = Chat.find_one({ "chat_id": message.chat.id, "network_type": "telegram" }) if chat is None: user = User.find_by_telegram_id(message.chat.username) if user is None: return self._new_user_message(message) chat = Chat({ "chat_id": message.chat.id, "user_id": user._id, "network_type": "telegram" }) chat.save() return self._new_user_confirmed_message(message)
def get_current_user(self) -> Union[User, None]: if ctx.envtype == 'development': username = os.getenv("DEV_USER") if username is not None: return User.get(username) user = self._get_user_from_x_api_auth_token( ) or self._get_user_from_session() return user
def oauth_callback(): code = request.values.get("code") state = request.values.get("state") if not code: raise AuthenticationError("no code from provider") if not state: raise AuthenticationError("no state from provider") tokens = state.split(":") if len(tokens) != 2: raise AuthenticationError( "invalid state from provider. expected <provider>:<origin>") provider_name, origin = tokens provider = BaseProvider.get_provider(provider_name) token = provider.acquire_token(code) user_data = provider.get_user_data(token) user = User.find_one({"ext_id": user_data["ext_id"]}) if not user: user = User(user_data) user.fixup_username() user.save() session["user_id"] = user._id session.modified = True path = ctx.cfg.get("base_uri", "http://localhost:8080/") return redirect(f"{path}#{origin}")
def search(): query = request.values.get("q") if query is None: raise InputDataError("'q' param is missing") posts = paginated(search_posts(query), transform=transform) author_ids = {ObjectId(x["author_id"]) for x in posts["data"]} authors = User.find({"_id": {"$in": list(author_ids)}}).all() return json_response({"results": posts, "authors": {"data": authors}})
def test_reg(req): if req.method == "POST": name = req.POST['name'].strip() pwd = req.POST['password'].strip() email = req.POST['email'].strip() if name and pwd and email: rf = RegForm({'name': name, 'password': pwd, 'email': email}) if rf.is_valid(): if User.objects.filter(name = name).count() == 0: u = User(name = name, email = email, password = hashlib.sha1(pwd).hexdigest(), reg_date = datetime.datetime.now(), raiting = 0) u.save() req.session['name'] = u.id return HttpResponse('{"status": "ok"}') else: return HttpResponse('{"status": "error", "code": "1"}') else: return HttpResponse('{"status": "error", "code": "2"}') #Uncorrect data return HttpResponse('{"status": "error", "code": "3"}') # Other error
def create_users(self): ctx.log.info("creating fixture users") self.users = [] data = requests.get(f"https://randomuser.me/api/?results={USERS_COUNT}").json() i = 1 for user_data in data["results"]: username = f"fx_test_user_{i}" user = User.get(username) if not user: user = User.create( username=username, ext_id=username, first_name=user_data["name"]["first"], last_name=user_data["name"]["last"], avatar_url=user_data["picture"]["thumbnail"], email=user_data["email"] ) user.save() self.users.append(user) i += 1
def test_question_new_answer_event(self): user = User({"username": "******", "ext_id": "test"}) user.save() other_user = User({"username": "******", "ext_id": "other"}) other_user.save() p = Question({ "title": "test title", "body": "test body, needs to be long", "tags": ["test-tag", "test-tag2"], "author_id": user._id }) p.save() self.run_tasks() Event.destroy_all() a = p.create_answer({ "body": "this is a self-answer, should not generate events", "author_id": user._id }) a.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 0) a = p.create_answer({ "body": "this is an answer by somebody else", "author_id": other_user._id }) a.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 1) event: QuestionNewAnswerEvent = events[0] self.assertEqual(event.question_id, p._id) self.assertEqual(event.answer_id, a._id) self.assertEqual(event.author_id, other_user._id)
def test_post_comment_event(self): user = User({"username": "******", "ext_id": "test"}) user.save() other_user = User({"username": "******", "ext_id": "other"}) other_user.save() p = Question({ "title": "test title", "body": "test body, needs to be long", "tags": ["test-tag", "test-tag2"], "author_id": user._id }) p.save() self.run_tasks() Event.destroy_all() c = p.create_comment({ "body": "this is a self-comment, should not generate events", "author_id": user._id }) c.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 0) c = p.create_comment({ "body": "this is a real comment, should generate an event", "author_id": other_user._id }) c.save() self.run_tasks() events = user.get_new_events() self.assertEqual(events.count(), 1) event: PostNewCommentEvent = events[0] self.assertEqual(event.post_id, p._id) self.assertEqual(event.comment_id, c._id) self.assertEqual(event.author_id, other_user._id)
def setUp(self) -> None: User.destroy_all() self.user1 = User({"username": "******", "ext_id": "user1"}) self.user1.save() self.user1.create_auth_token() self.user2 = User({"username": "******", "ext_id": "user2"}) self.user2.save() self.user2.create_auth_token() self.moderator = User({ "username": "******", "ext_id": "mod", "moderator": True }) self.moderator.save() self.moderator.create_auth_token()
def list_users(ids): ids = ids.split(",") ids = [resolve_id(id_) for id_ in ids] items = User.find( {"$or": [ { "_id": { "$in": ids } }, { "username": { "$in": ids } }, ]}) items = [user.to_dict(USER_FIELDS) for user in items] return {"data": items}
def index(): u: User = get_user_from_app_context() if "_sort" in request.values: srt = request.values["_sort"] else: srt = "rating" sortExpr = SORT_MAP.get(srt) if sortExpr is None: raise ApiError(f"unknown sort operator \"{srt}\"") if get_boolean_request_param("_mine"): if u: # only mine posts query = {"author_id": u._id} else: # nothing to show, user is not logged in query = {"_id": NilObjectId} else: # otherwise show all not deleted posts query = { "$or": [ { "deleted": False }, ] } if u: # if user is logged in, he can view his own deleted posts query["$or"].append({"author_id": u._id}) questions = Question.find(query).sort(sortExpr) results = paginated( questions, transform=default_transform(fields=QUESTION_LIST_FIELDS)) author_ids = set() for q in results["data"]: author_ids.add(resolve_id(q["author_id"])) authors = User.find({"_id": {"$in": list(author_ids)}}) return json_response({"questions": results, "authors": {"data": authors}})
def cmd_start(self, event): chat_dsc = event["payload"]["chat"] ctx.log.debug("running command 'start' by request from %s", chat_dsc) if chat_dsc["type"] != "private": self.send_message(chat_dsc["chatId"], "Hey there! Unfortunately I'm not capable of working in groups. " "Please add me privately") return chat = Chat.find_one({"chat_id": chat_dsc["chatId"], "network_type": "icq"}) if chat is None: user = User.find_by_icq_id(event["payload"]["from"]["userId"]) if user is None: return self._new_user_message(event) chat = Chat({ "chat_id": chat_dsc["chatId"], "user_id": user._id, "network_type": "icq" }) chat.save() return self._new_user_confirmed_message(event)
def users_unsubscribe(user_id): current: User = get_user_from_app_context() user = User.get(user_id, "user not found") current.unsubscribe_from_user(user) return users_subscription()
def generate_users(cnt): names = [ 'john', 'peter', 'kolya', 'misha', 'pasha', 'ilja', 'trump', 'derek' ] snames = ['obama', 'trum', 'ivanov', 'prtrov', 'lomov', 'morgan'] mails = ['ya', 'ma', 'go'] nsize = len(names) ssize = len(snames) msize = len(mails) imgs = os.listdir('/home/hase/technopark/web/AskZaytsev/scripts/test_img') imgsc = len(imgs) for i in range(0, cnt): print(i) fname = names[random.randint(0, nsize - 1)] sname = snames[random.randint(0, ssize - 1)] email = names[random.randint( 0, nsize - 1)] + '@' + mails[random.randint(0, msize - 1)] + '.ru' pwd = str(random.randint(10000, 1000000)) u = User() u.username = fname + ' ' + sname + str(i) u.password = pwd u.email = email u.first_name = fname u.last_name = sname u.is_active = True u.is_superuser = False u.save() img = imgs[random.randint(0, imgsc - 1)] print(img) p = Profile(user=u, avatar=img) p.save() print(p.avatar)
def _get_user_from_session() -> Union[User, None]: user_id = session.get("user_id") if user_id: user = User.get(user_id) return user return None
def setUp(self) -> None: super(TestEvent, self).setUp() Event.destroy_all() BasePost.destroy_all() User.destroy_all() self.clear_queue()
def test_tag_new_post_event(self): u = User({"username": "******", "ext_id": "test"}) u.save() u.subscribe_to_tag("test-tag") u.subscribe_to_tag("test-tag2") u.subscribe_to_tag("test-tag3") p = Question({ "title": "test title", "body": "test body, needs to be long", "tags": ["test-tag", "test-tag2"], "author_id": u._id }) p.save() self.run_tasks() events = u.get_new_events() self.assertEqual(events.count(), 0) other_user = User({"username": "******", "ext_id": "other"}) other_user.save() p = Question({ "title": "test title", "body": "test body, needs to be long", "tags": ["test-tag", "test-tag2"], "author_id": other_user._id }) p.save() self.run_tasks() events = u.get_new_events() self.assertEqual(events.count(), 1) event: TagNewQuestionEvent = events[0] # only subscribed tags are listed in event self.assertCountEqual(event.tags, ["test-tag", "test-tag2"]) self.assertEqual(event.question_id, p._id)
def setUpClass(cls): super(TestPost, cls).setUpClass() cls.user = User({"username": "******", "ext_id": "test_user"}) cls.user.save()
class HTTPAPITestCase(MongoMockTest): @classmethod def setUpClass(cls) -> None: force_init_app() super().setUpClass() User.ensure_indexes() cls.app = app def setUp(self) -> None: User.destroy_all() self.user1 = User({"username": "******", "ext_id": "user1"}) self.user1.save() self.user1.create_auth_token() self.user2 = User({"username": "******", "ext_id": "user2"}) self.user2.save() self.user2.create_auth_token() self.moderator = User({ "username": "******", "ext_id": "mod", "moderator": True }) self.moderator.save() self.moderator.create_auth_token() @staticmethod def run_tasks(): for task in ctx.queue.tasks: wrk.run_task(task) @staticmethod def clear_task_queue(): for task in ctx.queue.tasks: try: wrk.run_task(task) except: pass @property def client(self): return self.app.flask.test_client() def request(self, method, path, headers=None, user=None, json=None): if headers is None: headers = {} if user is not None: headers["X-Api-Auth-Token"] = user.get_auth_token().token kwargs = {"headers": headers, "method": method} if json is not None: kwargs["json"] = json headers["Content-Type"] = "application/json" return self.client.open(path, **kwargs) def get(self, path, user=None): return self.request("GET", path, user=user) def post(self, path, user=None, json=None): return self.request("POST", path, user=user, json=json) def patch(self, path, user=None, json=None): return self.request("PATCH", path, user=user, json=json) def put(self, path, user=None, json=None): return self.request("PUT", path, user=user, json=json) def delete(self, path, user=None, json=None): return self.request("DELETE", path, user=user, json=json)
def handle(self, *args, **options): for i in range(10): user = User(username=self.text_gen(), password=self.text_gen(100) + "?") user.save() self.stdout.write(self.style.SUCCESS('Successfully created user ' + user.username + ' with pass' + user.password))
def setUpClass(cls) -> None: force_init_app() super().setUpClass() User.ensure_indexes() cls.app = app