def post(self):
""" Resource that creates a new user """
args = user_parser.parse_args()
email = args['email']
password = args['password']
if not email:
result = {'message': 'Email cannot be blank'}
return result, 400
if re.match(r"(^[a-zA-Z0-9_.]+@[a-zA-Z0-9-]+\.[a-z]+$)",
email) and len(password) > 6:
userbyemail = User.get_by_email(email)
if not userbyemail:
try:
user = User.create(**user_parser.parse_args())
if user:
result = {'message': 'User has succesfully registered'}
return result, 201
except Exception:
result = {
'message': 'Something went wrong when saving user'
}
return result, 500
else:
result = {'message': 'User already exists'}
return result, 409
result = {
'message':
'Incorrect credentials. Email should be correct. Password should be more than 6 characters'
}
return result, 400
def get(self, current_user, user_id=None, username=None):
""" Resource that gets a user by id"""
user = None
print(user_id)
if username is not None:
user = User.get_by_username(username)
else:
user = User.get_by_id(user_id)
if not user:
abort(404, {"message": "User does not exist"})
return user
def merge(self, merger, message_header, message_body):
# TODO: Use User only
if merger and isinstance(merger, basestring):
merger = User(merger)
if not isinstance(merger, User):
raise Exception("User is needed to merge pull")
env = make_git_env(merger)
worktree = self.temp_dir
merge_commit_sha = None
try:
if self.pull.is_up_to_date():
return ''
from_sha = self.from_sha
to_sha = self.to_sha
repo = self.pull.pull_clone(worktree)
if self.from_local:
ref = self.pull.pull_fetch_local(repo)
else:
ref = self.pull.pull_fetch_remote(repo)
repo.merge(ref, message_header, message_body, no_ff=True, _env=env)
repo.push('origin', self.pull.to_ref)
merge_commit_sha = self.sha(self.pull.to_ref)
self.pull._save_merged(merger.name, from_sha, to_sha)
finally:
shutil.rmtree(worktree)
return merge_commit_sha
def get_git_path_info(path):
path_split = path.split("/")
git_name = path_split[1]
# raw path: project_id.git
if git_name.endswith('.git'):
project = Project.get_by_name(git_name[:-4])
if project:
path_split[1] = "%s.git" % project.id
return '/'.join(path_split)
else:
owner_name, git_name = path_split[1:3]
# user project: user/project.git
user = User.get_by_name(owner_name)
if user:
project = Project.get_by_name_and_owner(git_name[:-4], user.id)
if project:
path_split[1] = ""
path_split[2] = "%s.git" % project.id
return '/'.join(path_split[1:])
return
# org project: org/project.git
org = Organization.get_by_name(owner_name)
if org:
project = Project.get_by_name_and_owner(git_name[:-4], user.id)
if project:
path_split[1] = ""
path_split[2] = "%s.git" % project.id
return '/'.join(path_split[1:])
def get_git_path_info(path):
path_split = path.split("/")
git_name = path_split[1]
# raw path: project_id.git
if git_name.endswith('.git'):
project = Project.get_by_name(git_name[:-4])
if project:
path_split[1] = "%s.git" % project.id
return '/'.join(path_split)
else:
owner_name, git_name = path_split[1:3]
# user project: user/project.git
user = User.get_by_name(owner_name)
if user:
project = Project.get_by_name_and_owner(git_name[:-4], user.id)
if project:
path_split[1] = ""
path_split[2] = "%s.git" % project.id
return '/'.join(path_split[1:])
return
# org project: org/project.git
org = Organization.get_by_name(owner_name)
if org:
project = Project.get_by_name_and_owner(git_name[:-4], user.id)
if project:
path_split[1] = ""
path_split[2] = "%s.git" % project.id
return '/'.join(path_split[1:])
def decorated_function(*args, **kwargs):
token = None
if 'Authorization' in request.headers:
auth_header = request.headers['Authorization']
try:
token = auth_header.split(" ")[1]
except IndexError:
return make_response(
jsonify({'message': 'Provide a valid auth token'}), 403)
if not token:
return make_response(jsonify({'message': 'Token is missing'}), 401)
try:
decode_response = User.decode_auth_token(token)
current_user = User.query.filter_by(id=decode_response).first()
if current_user:
g.user = current_user
else:
return make_response(
jsonify({
'message':
"Integrity credentials for provided token are lacking."
}), 401)
except:
message = 'Invalid token'
if isinstance(decode_response, str):
message = decode_response
return make_response(
jsonify({
'status': 'Failed',
'message': message
}), 401)
return f(current_user, *args, **kwargs)
def _q_index(request):
session = request.session
tdt = {}
tdt['session'] = session
tdt['current_user'] = User.get_by(id=session.user) if session else None
if request.method == 'POST':
session.set_user(None)
return request.redirect('/')
return st('logout.html', **tdt)
def api_list_user(users):
rs = []
for username in users:
user = User.get_by_name(username)
rs.append({'username': user.username,
'avatar_url': user.avatar_url,
'email': user.email,
'url': user.url, })
return rs
def owner_name(self):
from code.models.user import User
from code.models.organization import Organization
if self.kind == KIND_USER:
user = User.get_by(id=self.owner_id)
return user.name
else:
org = Organization.get_by(id=self.owner_id)
return org.name
def owner_name(self):
from code.models.user import User
from code.models.organization import Organization
if self.kind == KIND_USER:
user = User.get_by(id=self.owner_id)
return user.name
else:
org = Organization.get_by(id=self.owner_id)
return org.name
def __init__(self, repo, commit):
self.repo = repo
self._commit = commit
self.type = 'commit'
self.repo_name = repo.name
parent = commit['parent'][0] if commit['parent'] else None
self.parent = parent
self.parents = commit['parent']
message = ("%s\n\n%s" % (
commit['message'],
remove_unknown_character(commit['body']))
).strip()
self.message = message
self.message_header = commit['message']
self.message_body = commit['body']
self.sha = commit['sha']
self.tree = commit['tree']
author_name = commit['author']['name']
self.author_name = author_name
author_email = email_normalizer(author_name, commit['author']['email'])
self.author_email = author_email
self.email = author_email
# FIXME: user
#author = User(name=author_name, email=author_email)
author = User.get_by_name(author_name)
self.author = author
author_date = datetime.fromtimestamp(commit['author']['time'],
FixedOffset(commit['author']['offset']))
author_timestamp = str(commit['author']['time'])
self.author_time = author_date
self.author_timestamp = author_timestamp
self.time = author_date
committer_name = commit['committer']['name']
committer_email = email_normalizer(
committer_name, commit['committer']['email'])
# FIXME: user
#committer = User(name=committer_name, email=committer_email)
committer = User.get_by_name(committer_name)
self.committer = committer
committer_date = datetime.fromtimestamp(commit['committer']['time'],
FixedOffset(commit['committer']['offset']))
self.committer_time = committer_date
def __init__(self, repo, commit):
self.repo = repo
self._commit = commit
self.type = 'commit'
self.repo_name = repo.name
parent = commit['parent'][0] if commit['parent'] else None
self.parent = parent
self.parents = commit['parent']
message = ("%s\n\n%s" %
(commit['message'], remove_unknown_character(
commit['body']))).strip()
self.message = message
self.message_header = commit['message']
self.message_body = commit['body']
self.sha = commit['sha']
self.tree = commit['tree']
author_name = commit['author']['name']
self.author_name = author_name
author_email = email_normalizer(author_name, commit['author']['email'])
self.author_email = author_email
self.email = author_email
# FIXME: user
#author = User(name=author_name, email=author_email)
author = User.get_by_name(author_name)
self.author = author
author_date = datetime.fromtimestamp(
commit['author']['time'], FixedOffset(commit['author']['offset']))
author_timestamp = str(commit['author']['time'])
self.author_time = author_date
self.author_timestamp = author_timestamp
self.time = author_date
committer_name = commit['committer']['name']
committer_email = email_normalizer(committer_name,
commit['committer']['email'])
# FIXME: user
#committer = User(name=committer_name, email=committer_email)
committer = User.get_by_name(committer_name)
self.committer = committer
committer_date = datetime.fromtimestamp(
commit['committer']['time'],
FixedOffset(commit['committer']['offset']))
self.committer_time = committer_date
def _q_index(request):
tdt = dict()
if request.method == "POST":
name = request.get_form_var('name')
password = request.get_form_var('password')
email = request.get_form_var('email')
description = request.get_form_var('description')
user = User.add(name=name,
password=password,
description=description,
email=email)
if user:
tdt['user'] = user
session = request.session
session.set_user(user.id)
return request.redirect('/')
users = User.gets_by()
tdt['users'] = users
return st('users/index.html', **tdt)
def _q_index(request):
if request.method == 'POST':
name = request.get_form_var('login')
password = request.get_form_var('password')
user = User.get_by_name(name)
if user and user.validate_password(password):
session = request.session
session.set_user(user.id)
return request.redirect('/')
return st('login.html')
def _q_index(request):
tdt = dict()
session = request.session
current_user = User.get_by(session.user) if session else None
if current_user and request.method == "POST":
name = request.get_form_var('name')
description = request.get_form_var('description')
p = Project.add(name=name,
description=description,
owner_id=current_user.id,
creator_id=current_user.id)
if p:
return request.redirect('projects/%s' % p.name)
tdt['project'] = p
return st('projects/index.html', **tdt)
projects = Project.gets_by()
tdt['projects'] = projects
tdt['current_user'] = User.get_by(id=session.user) if session else None
return st('projects/index.html', **tdt)
def api_list_user(users):
rs = []
for username in users:
user = User.get_by_name(username)
rs.append({
'username': user.username,
'avatar_url': user.avatar_url,
'email': user.email,
'url': user.url,
})
return rs
def _q_lookup(request, name):
if name in ['static', 'js', 'css']:
return StaticUI(request, name)
user = User.get_by_name(name)
if user:
return UserUI(user)
org = Organization.get_by_name(name)
if org:
return OrganizationUI(org)
raise TraversalError
def _q_lookup(self, request, name):
from code.views.api.v1.users import UserUI
from code.views.api.v1.organizations import OrganizationUI
user = User.get_by_name(name)
if user:
return UserUI(user)
org = Organization.get_by_name(name)
if org:
return OrganizationUI(org)
raise TraversalError
def put(self, token):
"""
Get the user's reset email
:return:
"""
args = user_parser.parse_args()
password = args['password']
if len(password) > 6:
email = User.decode_auth_token(token)
user = User.get_by_email(email)
if user:
try:
user.update(**args)
except IndexError:
result = {'message': 'Server error on resetting password.'}
return result, 500
result = {'message': 'Password has been reset successfully.'}
return result, 200
result = {'message': 'User does not exist anymore.'}
return result, 400
result = {'message': 'Password should not be less than 6 characters.'}
return result, 400
def _q_lookup(self, request, name):
from code.views.api.v1.users import UserUI
from code.views.api.v1.organizations import OrganizationUI
user = User.get_by_name(name)
if user:
return UserUI(user)
org = Organization.get_by_name(name)
if org:
return OrganizationUI(org)
raise TraversalError
def __init__(self, header):
self.login = None
self.passwd = None
self.user = None
try:
auth_type, auth_string = header.split()
login, passwd = b64decode(auth_string).split(':')
self.login = login
self.passwd = passwd
self.user = User.get_by_name(login)
except ValueError:
pass
except TypeError:
pass
def __init__(self, header):
self.login = None
self.passwd = None
self.user = None
try:
auth_type, auth_string = header.split()
login, passwd = b64decode(auth_string).split(':')
self.login = login
self.passwd = passwd
self.user = User.get_by_name(login)
except ValueError:
pass
except TypeError:
pass
def get(self, current_user, user_id=None, username=None, title=None):
""" Resource that gets a list of categories """
# Find user that category goes with
user = None
if user_id:
user = User.get_by_id(user_id)
else:
user = User.get_by_username(username)
if not user:
abort(404, { "message": "User does not exist" })
# Get the user's categories
categories = Category.query.filter_by(user_id=user.id)
args = category_collection_parser.parse_args()
# fancy url argument query filtering!
if args['title'] is not None:
categories = Category.query.filter(Category.title.ilike(
'%' + args['title'] + '%')).filter(Category.user_id == g.user.id)
if not categories:
abort(404, { "message": "No categories to display." })
return categories
def post(self):
""" Resource that signs in a user """
args = user_parser.parse_args()
email = args['email']
username = args['username']
password = args['password']
if re.match(r"[^@]+@[^@]+\.[^@]+", email) and len(password) > 6:
user = User.get_by_email(email)
if user and user.check_password(password):
token = user.encode_auth_token(user.id)
result = {
'message': 'User has signed in successfully.',
'token': token.decode("utf-8"),
'userid': user.id
}
return result, 200
result = {'message': 'User does not exist or incorrect password.'}
return result, 400
result = {'message': 'Wrong email or password'}
return result, 400
def post(self):
"""
Post the user's reset email
:return:
"""
args = user_parser.parse_args()
recovery_email = args['email']
if re.match(r"[^@]+@[^@]+\.[^@]+", recovery_email):
user = User.get_by_email(recovery_email)
if user:
token = user.encode_recovery_token(recovery_email)
recovery_token = token.decode("utf-8")
recover_url = api.url_for(UserPasswordResetResource,
token=token,
_external=True)
try:
msg = Message("Reset password Token",
sender="*****@*****.**",
recipients=[recovery_email])
msg.html = "<h3> Hi there, </h3>" \
"<hr/>" \
"<p>Click on this link to reset your password" \
"Recover url: " '<p>''<strong>' + recover_url +'</strong>''</p>' \
'<p> You will not be able to use this url in the next 24 Hours.' \
'Please reset your password before then.</p>' \
"<hr/>" \
"<h5>Yummy recipes password.</h5>"
with current_app.app_context():
mail.send(msg)
result = {'message': 'Recovery email has been sent.'}
return result, 200
except Exception as e:
return {"error": str(e)}, 400
result = {
'message':
'User with email {} does not exist.'.format(recovery_email)
}
return result, 400
result = {'message': 'Wrong email entered.'}
return result, 400
def get(self):
"""
Try to logout a user using a token
:return:
"""
args = parser.parse_args()
auth_header = args['Authorization']
if auth_header:
try:
auth_token = auth_header.split(" ")[1]
except IndexError:
result = {'message': 'Provide a valid authentication token'}
return result, 403
else:
decoded_token_response = User.decode_auth_token(auth_token)
if not isinstance(decoded_token_response, str):
token = Token(auth_token)
token.save()
result = {'message': 'Successfully logged out'}
return result, 200
result = {'message': decoded_token_response}
return result, 401
result = {'message': 'Provide an authorization header'}
return result, 403
def _q_index(request):
tdt = {}
session = request.session
tdt['session'] = session
tdt['current_user'] = User.get_by(id=session.user) if session else None
return st("index.html", **tdt)
def _q_index(self, request):
tdt = dict()
session = request.session
tdt['project'] = self.project
tdt['current_user'] = User.get_by(id=session.user) if session else None
return st('/projects/repo.html', **tdt)
def _q_index(request):
tdt = dict()
session = request.session
tdt['users'] = User.gets_by()
tdt['current_user'] = User.get_by(id=session.user) if session else None
return st('projects/new.html', **tdt)
