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
