def get(self):
if self.request.get("error"):
self.redirect("/")
return
auth_code = self.request.params["code"]
try:
credentials = SIGNIN_FLOW.step2_exchange(auth_code)
user_id = credentials.id_token["sub"]
user_email = credentials.id_token["email"]
logging.debug("Got credentials %s for user %s", credentials.to_json(), user_email)
if user_id:
user = User.get_user_from_id(user_id)
if not user:
User.create_user(user_id, user_email)
logging.debug("Adding to task queue for user email %s", user_email)
#taskqueue.add(url="/worker/fetchEmails", params={ 'user_id': user_id, 'user_email': user_email})
self.session["user_id"] = user_id
self.session["user_email"] = user_email
User.store_credentials_for_user_id(user_id, credentials)
taskqueue.add(url="/worker/fetchEmails", params={ 'user_id': user_id, 'user_email': user_email})
token = jwt.encode({'user_id': user_id}, MobileJWTSecret)
self.redirect("/settings?token="+token)
return
except FlowExchangeError:
self.send_error(401, 'Failed to exchange authorization code')
return
self.redirect("/settings")
def addUser():
request_data = request.get_json()
username = str(request_data["username"])
password = str(request_data["password"])
User.createUser(username, password)
get_token()
response = Response("", status=201, mimetype="application/json")
return response
def register():
form = RegisterForm(request.form)
if request.method == 'POST' and form.validate():
name = form.name.data
email = form.email.data
username = form.username.data
password = form.password.data
User.createUser(name, email, username, password)
flash('You are now registered and can log in', 'success')
return redirect('\login')
return render_template('register.html', form=form)
def login():
if request.method == "POST":
email = request.form['email']
passwd = request.form['password']
# Create login logic and proceed with the authentication
user_class = User()
user_class.id = email
flask_login.login_user(user_class)
return redirect('/protected')
def create_user():
request_data = request.get_json()
if (validUserObject(request_data)):
User.createUser(request_data['username'], request_data['password'])
response = Response("", status=201, mimetype='application/json')
return response
else:
invalidBookObjectErrorMsg = {
"error":
"Invalid User Object passed in request",
"helpString":
"Data passed in similar to this {'username': '******', 'password': '******' }"
}
response = Response(json.dumps(invalidBookObjectErrorMsg),
status=400,
mimetype='application/json')
return response
def verify_password(username_or_token, password):
# first try to authenticate by token
user = User.verify_auth_token(username_or_token)
if not user:
# try to authenticate with username/password
user = User.query.filter_by(Login=username_or_token).first()
if not user or not user.verify_password(password):
return False
g.user = user
return True
def __init__(self):
"""Initialize the server manager object.
The parameters are passed on to the init function of server manager
"""
self.user = User("")
self.usermanager = UserManager()
self.absolutePath = os.path.dirname(
os.path.abspath(inspect.getfile(inspect.currentframe())))
self.fileManager = FileManager(self.absolutePath)
super().__init__()
def insert(cls, entry, content, user, remote_addr):
comment = Comment(
entry = entry,
entry_index = entry.index,
content=content,
user = user,
site_user_id = User.getSiteUserId(user),
ip = remote_addr
).put()
return comment
def post(self):
username = self.request.get("username")
password = self.request.get("password")
verify = self.request.get("verify")
email = self.request.get("email")
validCheck = verifySignup(username,password,verify,email)
if validCheck.verify():
password = h.makePasswordHash(password)
if email:
user = User(username=username,password=password,email=email)
else:
user = User(username=username,password=password)
user.put()
self.response.headers.add_header('Set-Cookie', 'username=%s; Path=/'%str(h.makeSecureCookie(username)))
if user.is_saved():
self.redirect('/blog/welcome')
else:
self.renderFront(username,"","",email,validCheck.errors)
def get_token():
request_data = request.get_json()
username = str(request_data['username'])
password = str(request_data['password'])
match = User.username_password_match(username, password)
if match:
expiration_date = datetime.datetime.utcnow() + datetime.timedelta(seconds=100)
token = jwt.encode({'exp': expiration_date}, app.config['SECRET_KEY'], algorithm='HS256')
return token
else:
return Response('', 401, mimetype='application/json')
def register():
try:
data = json.loads(request.data)
if not User.objects(email=data['email']):
user_profile = User(userid=str(ObjectId()), email=data['email'], firstname=data['firstname'], lastname=data['lastname'])
user_profile.set_password(data['password'])
user_profile.save()
return jsonify(result={'token': user_profile.generate_token()}), 200
return jsonify(result={'message':'Email already in use'}), 409
except KeyError:
return jsonify(result={'message':'Error in request. Please try again.'}), 400
def get():
try:
user_token = request.headers.get('Authorization')
auth_token = User.verify_token(user_token)
if auth_token == 401:
return jsonify(result={'message': 'Invalid token'}), 401
user_profile = User.objects.get(userid=auth_token)
if user_profile:
print user_profile
return jsonify(result={'profile': user_profile.get_profile()}), 200
return jsonify(result={'message': 'Error in request'}), 400
except KeyError:
return jsonify(result={'message':'Error in request'}), 400
def get_token():
request_data = request.get_json()
username = str(request_data["username"])
password = str(request_data["password"])
match = User.username_password_match(username, password)
if match:
expiration_date = datetime.datetime.utcnow() + datetime.timedelta(seconds=300)
token = jwt.encode(
{"exp": expiration_date}, app.config["SECRET_KEY"], algorithm="HS256"
)
return token
else:
return Response("", 401, mimetype="application/json")
def get_token():
request_data = request.get_json()
username = str(request_data["username"])
password = str(request_data["password"])
match = User.usernamePasswordMatch(username, password)
if request.method == "POST":
if match:
expiration_date = datetime.datetime.utcnow() + datetime.timedelta(seconds=10000)
token = jwt.encode({"exp": expiration_date}, app.config["SECRET_KEY"], algorithm="HS256")
return token
#return render_template("mainpage.html", username=username, match=match)
else:
return Response("", 401, mimetype="application/json")
else:
return render_template("mainpage.html", username=username, match=match)
def register():
try:
userId = str(uuid.uuid4())
firstName = request.json['firstName']
lastName = request.json['lastName']
email = request.json['email']
password = request.json['password']
hashed_password = generate_password_hash(password, method='sha256')
user = User(userId, firstName, lastName, email, hashed_password)
db.session.add(user)
db.session.commit()
return get_user_schema.jsonify(user)
except:
return {"msg": "Something went wrong"}, 500
def get_token():
if request.method == 'POST':
# Get Form Fields
username = request.form['username']
password = request.form['password']
match = User.username_password_match(username, password)
if match:
# Passed
session['logged_in'] = True
session['username'] = username
flash('You are now logged in', 'success')
return redirect(url_for('dashboard'))
else:
error = 'Invalid login'
return render_template('login.html', error=error)
return render_template('login.html')
def handle_updates(self):
update = bottle_request.json
print("\n\nNEW UPDATE\n{}\n\n".format(update)) #just for log
if (update.get("callback_query")): #handle button click
requests.get(
self.api_base_url + "answerCallbackQuery",
{'callback_query_id': update.get("callback_query").get("id")})
user_id = update.get("callback_query").get("from").get("id")
if (update.get("callback_query").get("data") == "google-pressed"):
self.show_url(
update.get("callback_query").get("message").get(
"chat").get("id"),
update.get("callback_query").get("message").get(
"message_id"))
else:
self.send_message_to_specific_person(
user_id,
update.get("callback_query").get("data"))
return
user_id = update.get("message").get("from").get("id")
user = self.users_list.get(user_id)
if (user):
MongoDB.newInteractionFromUser(user_id)
if (not user.greeted):
self.start_the_chat(user)
return
elif (not user.received_inicial_message):
self.send_initial_message(user)
else:
self.send_message_to_specific_person(
user_id,
"A partir daqui eu ainda nao sei o que fazer hehehe desculpa"
)
else:
# setup users
MongoDB.insertNewUser(update.get("message").get("from"))
first_name = update.get("message").get("from").get("first_name")
last_name = update.get("message").get("from").get("last_name")
username = update.get("message").get("from").get("username")
user = User(user_id, first_name, last_name, username)
self.users_list[user_id] = user
# greet user
self.start_the_chat(user)
return {"status": "up"}
def new_user():
login = request.json.get('Login')
password = request.json.get('password')
if login is None or password is None:
abort(400) # missing arguments
if User.query.filter_by(Login=login).first() is not None:
abort(400) # existing user
user = User(Login=login)
user.hash_password(password)
user.FirstName = request.json.get('FirstName')
user.LastName = request.json.get('LastName')
user.CreationDate = datetime.utcnow()
db.session.add(user)
db.session.commit()
user_dict = user.dict_format()
formatted_result = dict(User=user_dict)
return jsonify(result=formatted_result)
def get_token():
if request.method == 'POST':
# Get Form Fields
username = request.form['username']
password = request.form['password']
match = User.username_password_match(username, password)
if match:
# Passed
session['logged_in'] = True
session['username'] = username
flash('You are now logged in', 'success')
expiration_date = datetime.datetime.utcnow() + datetime.timedelta(
seconds=900)
token = jwt.encode({'exp': expiration_date},
app.config['SECRET_KEY'],
algorithm='HS256')
return redirect('\dashboard')
else:
error = 'Invalid login'
return render_template('login.html', error=error)
return render_template('login.html')
def insert(cls, title, link, content, menu_id, user, remote_addr ):
def txn():
entry_index = EntryIndex.get_by_key_name('entry')
if entry_index is None:
entry_index = EntryIndex(key_name='entry')
new_index = entry_index.max_index
entry_index.max_index += 1
entry_index.put()
new_entry = Entry(key_name = 'entry'+str(new_index),
parent = entry_index,
index = new_index,
title = title,
content = content,
menu_id = menu_id,
user = user,
comment_count = 0,
ip = remote_addr,
link=link,
created_on=datetime.datetime.now(),
updated_on=datetime.datetime.now())
new_entry.put()
return new_entry
if link != "" and link.find("http") == -1 :
link = "http://" + link
new_entry = db.run_in_transaction(txn)
site_user_id = User.getSiteUserId(user)
new_entry.site_user_id = site_user_id
new_entry.put()
PagingCursorMasterKey.clearModelKey("Entry")
return new_entry
def get_token():
request_data = request.get_json()
username = str(request_data['username'])
password = str(request_data['password'])
match = User.username_password_match(username, password)
if match:
expiration_date = datetime.datetime.utcnow() + datetime.timedelta(
seconds=600)
token = jwt.encode({'exp': expiration_date},
app.config['SECRET_KEY'],
algorithm='HS256')
return token
else:
#return Response('', 401, mimetype='application/json')
invalidUser = {
"error": "invalid Login Credentials ",
"helpString": "Verify api username and password "
}
response = Response(json.dumps(invalidUser),
status=401,
mimetype='application/json')
return response
def post(self):
username = self.request.get("username")
password = self.request.get("password")
verify = self.request.get("verify")
email = self.request.get("email")
validCheck = verifySignup(username, password, verify, email)
if validCheck.verify():
password = h.makePasswordHash(password)
if email:
user = User(username=username, password=password, email=email)
else:
user = User(username=username, password=password)
user.put()
self.response.headers.add_header(
'Set-Cookie',
'username=%s; Path=/' % str(h.makeSecureCookie(username)))
if user.is_saved():
self.redirect('/blog/welcome')
else:
self.renderFront(username, "", "", email, validCheck.errors)
def getUserCredentials(self, username):
"""Get user data for specified username
Parameters:
------------------------------------------
username : string
username to fetch data
Return : User
returns the User Data Model for the specified username
"""
user = User(username)
with open(self.user_db) as u_file:
for cnt, line in enumerate(u_file):
if cnt > 0:
attr = line.split(',')
if attr[0] == username:
user.privilege = attr[2].strip("\t\r\n")
user.password = attr[1]
user.rootDirectory = "/User/" + username
user.currentDirectory = user.rootDirectory
break
return user
from flask import Flask, request, Response, jsonify
import jwt
import datetime, json
from UserModel import User
from ConversationModel import *
from functools import wraps
from HotorBot import *
from settings import *
user = User()
conv = Conversation()
app.config['SECRET_KEY'] = 'marcos'
def token_required(func):
@wraps(func)
def wrapper(*args, **kwargs):
token = request.args.get('token')
try:
jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
except:
return jsonify({'Error': 'Provide a valid JWT.'}), 401
return func(*args, **kwargs)
return wrapper
def getJWT():
exp_date = datetime.datetime.utcnow() + datetime.timedelta(minutes=30)
token = jwt.encode({'exp': exp_date},
app.config['SECRET_KEY'],
from UserModel import db, User
db.drop_all()
db.create_all()
User.createUser('test', 'pass')
User.createUser('abc', '123')
db.session.commit()
def load_user(user_id):
user = User()
user.id = user_id
return user
def get_users():
return jsonify({'users': User.getAllUsers()})
