def register_function():
post_data = json.loads(request.data)
username = post_data["username"]
email = post_data["email"]
password = post_data["password"]
if not userutils.check_mail(email):
return json.dumps(
{
"status": "error",
"result": "please check your email"
}
)
if len(str(password)) < 4:
return json.dumps(
{
"status": "error",
"result": "please get some serious password"
}
)
user = User.objects(username=username).first()
if user:
return json.dumps(
{
"status": "error",
"result": "this username already taken, sorry"
}
)
if not username:
return json.dumps(
{
"status": "error",
"result": "please provide a username, it's required'"
}
)
user = User.objects(email=email).first()
if user:
return json.dumps(
{
"status": "error",
"result": "this email address already registered, sorry"
}
)
user = User(username=username, email=email)
user.password = userutils.encrypt(password)
user.slug = userutils.make_slug(username)
user.register_date = datetime.now()
user.save()
login_user(user)
return json.dumps(
{
"status": "success",
"result": "registeration successful"
}
)
async def post(self):
result = {'success': False, 'reason': None, 'data': None}
req_json = json.loads(self.request.body)
username = req_json['user_name']
email = req_json['email']
password = req_json['password']
phone = req_json['phone']
occupation = req_json['occupation']
address = req_json['address']
same_name_user = User.objects(username=username).first()
if same_name_user is not None:
result['reason'] = 'Username %s has already been existed' % (
username, )
self.write(json.dumps(result))
self.finish()
same_email_user = User.objects(email=email).first()
if same_email_user is not None:
result['reason'] = 'Email addr %s has already been registered' % (
email, )
self.write(json.dumps(result))
self.finish()
password = self._md5(password)
_ = await User.create(username=username,
email=email,
password=password,
phone=phone,
occupation=occupation,
address=address)
result['success'] = True
self.write(json.dumps(result))
self.finish()
def login_function():
post_data = json.loads(request.data)
username = post_data["username"]
password = post_data["password"]
remember_me = post_data["remember_me"]
user = User.objects(username=username).first()
if not user:
return json.dumps(
{
"status": "error",
"result": "we couldn't find that user, sorry!'"
}
)
pwd_hash = user["password"]
if userutils.check_password(password, pwd_hash):
if remember_me:
login_user(user, remember=True)
else:
login_user(user)
return json.dumps(
{
"status": "success",
"result": "user logged in"
}
)
else:
return json.dumps(
{
"status": "error",
"result": "password seems to be incorrect, sorry!"
}
)
def forgot_password():
""" The forgot password endpoint
Attempt to create an url to be sent for password reset
@return: The json answer {'success': true} upon successful email generation
and sending or an error description. If no mailgun configuration is
provided abort with 404 (not found) status code
"""
if not app.mailgun_client:
abort(404)
users = User.objects(email=request.form['email'])
if users.count() == 0:
return jsonify(error='Unknown email')
user = users.first()
if PasswordRenewToken.objects(user=user).count() > 0:
renew_token = PasswordRenewToken.objects(user=user).first()
hashed = b64encode(str(renew_token.id))
else:
renew_token = PasswordRenewToken(user=user)
renew_token.save()
hashed = b64encode(str(renew_token.id))
reset_link = url_for('password_reset', token=hashed, _external=True)
answer = send_password_reset(
app.mailgun_client, app.config['MAILGUN_MAILING_ADDRESS'], user.email,
render_template('email/forgot-password.txt', link=reset_link),
render_template('email/forgot-password.html', link=reset_link))
if answer.status_code == 200:
return jsonify(success=True)
else:
return jsonify(error='Unable to send mail')
async def post(self, *args, **kwargs):
result = {'success': False, 'reason': None, 'data': None}
req_data = json.loads(self.request.body)
user_name = req_data['user_name']
password = req_data['password']
next_url = req_data['next_url']
user = User.objects(username=user_name).first()
if not user:
result['reason'] = 'username %s is not existed' % (user_name, )
self.write(json.dumps(result))
self.finish()
password = self._md5(password)
if password != user.password:
result['reason'] = 'password is not correct'
self.write(json.dumps(result))
self.finish()
self._session['user_name'] = user_name
self._session.save()
result['success'] = True
result['data'] = {'next': next_url}
self.write(json.dumps(result))
self.finish()
def save_post():
post_data = json.loads(request.data)
url = post_data["url"]
json_data = make_readable(url)
title = post_data["title"]
slug = userutils.make_slug(title)
author = User.objects(username=current_user.username).first()
p = Post(title=title, slug=slug)
p.saved_date = datetime.now()
p.thumbnail = post_data["thumbnail"]
p.url = url
p.author = author
p.content = json_data["content"]
p.excerpt = json_data["excerpt"]
p.domain = post_data["domain"]
p.save()
q.enqueue(insert_new_relation, p)
author.posts.append(p)
author.save()
return "ok"
def __init__(self, username, recepients):
"""
Arguments:
- `username`:
- `recepients`:
"""
self._username = username
self._recepients = self.parse_recepients(recepients)
self._user = User.objects(username=self._username).first()
def __init__(self, username, recepients):
"""
Arguments:
- `username`:
- `recepients`:
"""
self._username = username
self._recepients = self.parse_recepients(recepients)
self._user = User.objects(username=self._username).first()
def get(self):
user = request.authorization
uid = User.objects(username=user['username']).to_json()
user = User.objects.get(username=user['username'])
# testing celery by sending a mail asynchronously
content = "celery test mail"
subject = "celery test"
# task = send_mail.delay(content,[user.email],subject)
task = send_mail.apply_async(args=[content, user.email, subject],
countdown=60)
return Response(uid, mimetype="application/json", status=200)
def get(self, page_no):
users = User.objects()
# The pagination method returns non json pagination object
users = Pagination(users, page=int(page_no), per_page=2)
# this gives list of user object
users = users.items
# using marshmallow to serialize
obj = SudoUser(many=True)
users = obj.dump(users)
# using dumps to convert to json object
users = json.dumps(users)
# print(users)
return Response(users, mimetype="application/json", status=200)
def profile():
user = get_user()
unsorted_freqs = User.objects(
username=user.username
).item_frequencies(field="tags")
freqs = sorted(
unsorted_freqs.items(), key=operator.itemgetter(1),
reverse=True
)
posts = Post.objects(author=user).order_by("-saved_date")
posts = set_time_zones(posts)
return render_template('profile.html', user=user, posts=posts, freqs=freqs)
def delete_post():
post_data = json.loads(request.data)
post_id = post_data["postId"]
post = Post.objects(id=post_id).first()
author = User.objects(username=current_user.username).first()
if post.author != author:
return json.dumps({"status": "not-allowed"})
Relation.objects(post1=post).delete()
Relation.objects(post2=post).delete()
Post.objects(id=post_id).delete()
return json.dumps({"status": "success"})
def login():
#if g.user is not None and g.user.is_authenticated:
# return redirect('/index')
form = LoginForm()
if form.validate_on_submit():
user = User.objects(username=form.username.data, password=form.password.data).first()
if user:
session['remember_me'] = form.remember_me.data
login_user(user)
return redirect( url_for('index'))
else:
flash("lalalal")
return render_template('login.html' ,
title = 'Sign In',
form = form)
def generate_token(email, password):
""" Generate a authentication token if given credentials are correct
@param email: user's email address
@param password: user's password
@return: an authentication token upon correct login or None
"""
user = User.objects(email=email).first()
if user:
if str(bcrypt.hashpw(password.encode('utf-8'),
user.password.encode('utf-8'))) == user.password:
return check_user_token(user)
else:
return None
else:
return None
def signup():
""" Signup endpoint
Attempt to register a user to the website
@return: A json response containing an email field upon success or an
error description
"""
if not Config.EMAIL_REGEX.match(request.form['email']):
return jsonify(error='Invalid email address')
elif User.objects(email=request.form['email']).count() > 0:
return jsonify(error='Already registered email')
else:
user = User.create_and_store(request.form['email'],
request.form['password'])
return jsonify(email=user.email)
def request_beta_access():
""" request beta access endpoint
Attempt to add the user to the beta request list
@return: {'success': true} upon successful subscription or an error
description
"""
email = request.form['email']
if not Config.EMAIL_REGEX.match(email):
return jsonify(error='Invalid email address')
if User.objects(email=email).count() == 0 and BetaRequest.objects(
email=email).count() == 0:
BetaRequest(email=email, code=request.form['promo_code']).save()
return jsonify(success=True)
else:
return jsonify(error='Already registered')
def save_post_pdf():
post_data = request.form
title = post_data.get("title")
slug = userutils.make_slug(title)
author = User.objects(username=current_user.username).first()
print post_data.get("domain")
if not title:
return "please provide a title"
p = Post(title=title, slug=slug)
p.saved_date = datetime.now()
p.thumbnail = post_data.get("thumbnail")
p.url = post_data.get("url")
p.author = author
p.content = ""
p.excerpt = ""
p.post_type = "pdf"
p.domain = post_data.get("domain")
p.save()
return redirect('/user/profile')
def load_user(user_id): # return User.query.get(int(id)) # print user_id return User.objects(id=user_id).first()
def test_empty_mongo(self):
self.assertEquals(User.objects().count(), 0)
self.assertEquals(Token.objects().count(), 0)
def load_user(username):
return User.objects(username=username).first()
def get_user():
if current_user.is_authenticated():
user = User.objects(username=current_user.username).first()
return user
else:
return None
def test_empty_mongo(self):
self.assertEquals(User.objects().count(), 0)
self.assertEquals(Token.objects().count(), 0)
