class ViewTeam(MethodView):
decorators = [
team_member_required(need=False), \
member_required(admin=False), \
login_required('account.login')
]
def get(self, organization, member, team, team_member):
members = get_team_members(team.id)
users = (get_user(member.uid) for member in members)
page = request.args.get('p', 1)
try:
page = int(page)
except ValueError:
raise abort(403)
data, list_page = render_activities_page(page,
t='team',
organization=organization,
team=team)
return self.render_template(
organization=organization, \
team_member=team_member, \
team=team, member=member, \
users=users, \
data=self.render_activities(data, organization, team), \
list_page=list_page, \
)
def render_activities(self, data, organization, team):
for action, original, _ in data:
if action['type'] == 'push':
yield render_push_action(action, organization, team=team)
else:
#TODO for other data
continue
class Forks(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
forks = get_repo_forks(repo.id)
return self.render_template(
organization=organization, \
member=member, \
repo=repo, \
forks=self.render_forks(organization, forks, team)
)
def render_forks(self, organization, forks, team):
for fork in forks:
view_url = get_url(organization,
fork,
view='repos.view',
team=team)
setattr(fork, 'view', view_url)
setattr(fork, 'user', get_user(fork.uid))
yield fork
class Activities(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
page = request.args.get('p', 1)
try:
page = int(page)
except ValueError:
raise abort(403)
data, list_page = render_activities_page(page, t='repo', repo=repo)
return self.render_template(
data=self.render_activities(data, organization, repo, team), \
list_page=list_page, \
member=member, repo=repo, \
organization=organization, \
admin=admin, team=team, team_member=team_member, \
)
def render_activities(self, data, organization, repo, team):
for action, original, timestamp in data:
if action['type'] == 'push':
yield render_push_action(action,
organization,
repo=repo,
team=team)
else:
#TODO for merge data
continue
class DeleteFile(MethodView):
decorators = [
repo_required(need_write=True),
member_required(admin=False),
login_required('account.login')
]
def get(self,
organization,
member,
repo,
admin,
team,
team_member,
version=None,
path=None):
if not check_obj_type(repo, path, version, 'blob'):
raise abort(403)
error = update_file(
organization, \
g.current_user, \
repo, {path: ''}, \
version, \
'%s %s' % (code.REPOS_DELETE_FILE, path)
)
if not error:
path = path.rsplit('/', 1)[0] if '/' in path else None
return redirect(repo.meta.get_view(version=version, path=path))
class Create(MethodView):
decorators = [
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member):
return self.render_template(
organization=organization, \
member=member, \
teams=self.get_joined_teams(organization)
)
def post(self, organization, member):
repopath = request.form.get('path', '')
name = request.form.get('name', '')
summary = request.form.get('summary', '')
teamname = repopath.strip('/').split('/', 1)[0]
if not check_reponame(name):
return self.render_template(
organization=organization, \
member=member, \
teams=self.get_joined_teams(organization), \
error = code.REPOS_NAME_INVALID, \
)
team = get_team_by_name(organization.id,
teamname) if teamname else None
if teamname and (not team
or not get_team_member(team.id, g.current_user.id)):
return self.render_template(
organization=organization, \
member=member, \
teams=self.get_joined_teams(organization), \
error = code.REPOS_PATH_INVALID, \
)
path = os.path.join(teamname, '%s.git' % name)
repo, error = create_repo(name,
path,
g.current_user,
organization,
team=team,
summary=summary)
if error:
return self.render_template(
organization=organization, \
member=member, \
teams=self.get_joined_teams(organization), \
error = error, \
)
return redirect(get_url(organization, repo))
def get_joined_teams(self, organization):
for team in get_teams_by_ogranization(organization.id):
if not get_team_member(team.id, g.current_user.id):
continue
yield team
class Alias(MethodView):
decorators = [login_required('account.login')]
def get(self):
error = request.args.get('error', None)
return self.render_template(error)
def post(self):
email = request.form.get('email', None)
if not check_email(email):
return self.render_template(error=code.ACCOUNT_EMAIL_INVAILD)
if get_alias_by_email(email):
return redirect(
url_for('account.alias', error=code.ACCOUNT_EMAIL_EXISTS))
url = url_for('account.verifyalias',
stub=self.encode(email),
_external=True)
send_verify_mail(email, url)
return self.render_template(send=code.ACCOUNT_EMAIL_VERIFY)
def render_template(self, error=None, send=None):
alias = get_alias_by_uid(g.current_user.id)
return MethodView.render_template(self,
alias=alias,
send=send,
error=error)
def encode(self, email):
s = TimestampSigner(config.SECRET_KEY)
e = s.sign(email)
s = URLSafeSerializer(config.SECRET_KEY)
e = s.dumps(e)
return e
class View(MethodView):
decorators = [
gist_require(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist, version='master'):
jagare = get_jagare(gist.id, gist.parent)
error, tree = jagare.ls_tree(gist.get_real_path(), version=version)
if not error:
tree, meta = tree['content'], tree['meta']
tree = render_tree(jagare,
tree,
gist,
organization,
version=version)
watcher = get_gist_watcher(g.current_user.id, gist.id)
return self.render_template(
organization=organization, \
member=member, \
error=error, \
tree=tree, \
gist=gist, \
watcher=watcher, \
)
class Login(MethodView):
decorators = [login_required(need=False), csrf_exempt]
def get(self):
login_url = url_for('account.login', **request.args)
return self.render_template(login_url=login_url)
def post(self):
login_url = url_for('account.login', **request.args)
password = request.form.get('password', None)
email = request.form.get('email', None)
check, error = check_login_info(email, password)
if not check:
return self.render_template(login_info=error, login_url=login_url)
user = get_user_by(email=email).limit(1).first()
if not user:
logger.info('no such user')
return self.render_template(login_info=code.ACCOUNT_NO_SUCH_USER,
login_url=login_url)
if not user.check_password(password):
logger.info('invaild passwd')
return self.render_template(
login_info=code.ACCOUNT_LOGIN_INFO_INVAILD,
login_url=login_url)
account_login(user)
redirect_url = request.args.get('redirect', None)
return redirect(redirect_url or url_for('index'))
class Commit(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member,
version):
jagare = get_jagare(repo.id, repo.parent)
error, commits = jagare.get_log(
repo.get_real_path(), \
size=1, start=version, \
)
if not commits:
raise abort(404)
commit = commits[0]
render_commit(commit, organization, repo)
commit['diffs'] = split_diff(commit['diff'])
return self.render_template(
member=member, repo=repo, \
organization=organization, \
admin=admin, team=team, team_member=team_member, \
commit=commit, \
)
class Blob(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member,
version, path):
watcher = get_repo_watcher(g.current_user.id, repo.id)
jagare = get_jagare(repo.id, repo.parent)
tname = team.name if team else None
content, content_type, content_length = format_content(jagare,
repo,
path,
version=version)
return self.render_template(
member=member, repo=repo, \
organization=organization, \
watcher=watcher, file_path=path, \
branches=get_branches(repo, jagare), \
content=content, \
content_length=content_length, \
content_type=content_type, \
admin=admin, team=team, team_member=team_member, \
version=version, \
path=render_path(
path, version, organization.git, tname, repo.name
)
)
class DelKey(MethodView):
decorators = [login_required('account.login')]
def get(self, kid):
key = get_key_by_id(kid)
if key and key.uid == g.current_user.id:
key.delete()
clear_key_cache(key, g.current_user)
return redirect(url_for('account.keys'))
class DelAlias(MethodView):
decorators = [login_required('account.login')]
def get(self, aid):
alias = get_alias_by_id(aid)
if alias or alias.uid == g.current_user.id:
alias.delete()
clear_alias_cache(g.current_user, alias.email, aid)
return redirect(url_for('account.alias'))
class CreateTeam(MethodView):
decorators = [
member_required(admin=False),
login_required('account.login'),
]
def get(self, organization, member):
if not self.check_permits(organization, member):
raise abort(403)
return self.render_template(
organization=organization, \
member=member, \
)
def post(self, organization, member):
if not self.check_permits(organization, member):
raise abort(403)
name = request.form.get('name', None)
display = request.form.get('display', None)
private = 1 if 'private' in request.form else 0
status = check_git(name)
if not status:
return self.render_template(
organization=organization, \
member=member, \
error=code.ORGANIZATION_GITNAME_INVALID, \
)
status = check_team_name(display)
if not status:
return self.render_template(
organization=organization, \
member=member, \
error=code.ORGANIZATION_NAME_INVALID, \
)
team, error = create_team(name,
display,
g.current_user,
organization,
private=private,
members=1)
if error:
return self.render_template(
organization=organization, \
member=member, \
error=error, \
)
return redirect(
url_for('organization.viewteam',
git=organization.git,
tname=team.name))
def check_permits(self, organization, member):
if organization.allow:
return True
if member.admin:
return True
return False
class Delete(MethodView):
decorators = [
repo_required(admin=True),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
delete_repo(organization, repo, team)
return redirect(url_for('organization.view', git=organization.git))
class Delete(MethodView):
decorators = [
gist_require(owner=True),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist):
delete_gist(g.current_user, gist, organization)
return redirect(url_for('organization.view', git=organization.git))
class Create(MethodView):
decorators = [
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member):
return self.render_template(
organization=organization, \
member=member, \
)
def post(self, organization, member):
summary = request.form.get('summary')
filenames = request.form.getlist('filename')
codes = request.form.getlist('code')
private = create_token(20) if request.form.get('private') else None
data = {}
if len(filenames) != len(codes):
raise abort(400)
for filename, content in zip(filenames, codes):
if not filename and not content:
continue
if not filename or not content:
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_WITHOUT_FILENAME if not filename else code.GIST_WITHOUT_CONTENT, \
filenames=filenames, \
codes=codes, \
)
if data.get(filename):
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_FILENAME_EXISTS, \
filenames=filenames, \
codes=codes, \
)
data[filename] = content
gist, err = create_gist(organization,
g.current_user,
summary,
data=data,
private=private,
watchers=1)
if err:
return self.render_template(
organization=organization, \
member=member, \
error=code.GIST_CREATE_FAILED, \
filenames=filenames, \
codes=codes, \
)
return redirect(get_url(organization, gist))
class Unwatch(MethodView):
decorators = [
gist_require(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist):
watcher = get_gist_watcher(g.current_user.id, gist.id)
if watcher:
delete_watcher(g.current_user, watcher, gist, organization)
return redirect(gist.meta.view)
class Watch(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
watcher = get_repo_watcher(g.current_user.id, repo.id)
if not watcher:
create_watcher(g.current_user, repo, organization, team=team)
return redirect(repo.meta.view)
class QuitTeam(MethodView):
decorators = [
team_member_required(), \
member_required(admin=False), \
login_required('account.login')
]
def post(self, organization, member, team, team_member):
quit_team(organization, team, team_member, g.current_user)
return redirect(
url_for('organization.viewteam',
git=organization.git,
tname=team.name))
class RemoveCommiter(MethodView):
decorators = [
repo_required(admin=True),
member_required(admin=False),
login_required('account.login')
]
def post(self, organization, member, repo, admin, team, team_member):
name = request.form.get('name')
user = get_user(name)
if not user or user.id == repo.uid:
return redirect(repo.meta.commiter)
commiter = get_repo_commiter(user.id, repo.id)
if user and commiter:
delete_commiter(user, commiter, repo, organization, team)
return redirect(repo.meta.commiter)
class Revisions(MethodView):
decorators = [gist_require(owner=True), member_required(admin=False), login_required('account.login')]
def get(self, organization, member, gist):
page = request.args.get('p', 1)
try:
page = int(page)
except ValueError:
raise abort(403)
jagare = get_jagare(gist.id, gist.parent)
error, revisions = jagare.get_log(gist.get_real_path(), page=page, size=config.REVISIONS_PER_PAGE)
if not revisions:
raise abort(404)
list_page = render_revisions_page(gist, page)
revisions = self.render_revisions(organization, gist, revisions, list_page)
return self.render_template(
organization=organization, \
member=member, \
error=error, \
revisions=revisions, \
gist=gist, \
list_page=list_page, \
)
def render_revisions(self, organization, gist, revisions, list_page):
for rev in revisions[:-1]:
self.render_rev(rev, organization, gist)
rev['type'] = 'update'
yield rev
rev = revisions[-1]
self.render_rev(rev, organization, gist)
rev['type'] = 'create' if not list_page.has_next else 'update'
yield rev
def render_rev(self, rev, organization, gist):
rev['view'] = get_url(organization, gist, version=rev['sha'])
rev['committer_time'] = format_time(rev['committer_time'])
author = reqcache.get(rev['author_email'])
if not author:
author = get_user_from_alias(rev['author_email'])
reqcache.set(rev['author_email'], author)
if not author:
author = Obj()
author.email = rev['author_email']
author.name = None
rev['author'] = author
rev['diff'] = render_diff(rev['diff'])
class Commiters(MethodView):
decorators = [
repo_required(admin=True),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
return self.render_template(
member=member, repo=repo, organization=organization, \
commiters=self.get_commiters(repo), \
admin=admin, team=team, team_member=team_member, \
)
def post(self, organization, member, repo, admin, team, team_member):
name = request.form.get('name')
user = get_user(name)
if not user:
return self.render_template(
member=member, repo=repo, organization=organization, \
commiters = self.get_commiters(repo), \
error=code.ACCOUNT_NO_SUCH_USER, \
admin=admin, team=team, team_member=team_member, \
)
if user.id == repo.uid:
return self.render_template(
member=member, repo=repo, organization=organization, \
commiters = self.get_commiters(repo), \
error=code.REPOS_COMMITER_EXISTS, \
admin=admin, team=team, team_member=team_member, \
)
is_member = get_organization_member(organization.id, user.id)
if not is_member:
return self.render_template(
member=member, repo=repo, organization=organization, \
commiters = self.get_commiters(repo), \
error=code.ORGANIZATION_MEMBER_NOT_EXISTS, \
admin=admin, team=team, team_member=team_member, \
)
create_commiter(user, repo, organization, team)
return redirect(repo.meta.commiter)
def get_commiters(self, repo):
commiters = get_repo_commiters(repo.id)
commiters = (get_user(commiter.uid) for commiter in commiters)
return commiters
class Fork(MethodView):
decorators = [
gist_require(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist):
private = create_token(20) if gist.private else None
fork_gist, err = create_gist(organization,
g.current_user,
gist.summary,
parent=gist,
private=private,
watchers=1)
if err:
return redirect(gist.meta.view)
return redirect(get_url(organization, fork_gist))
class Raw(MethodView):
decorators = [
gist_require(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist, path):
jagare = get_jagare(gist.id, gist.parent)
error, res = jagare.cat_file(gist.get_real_path(), path)
if error:
raise abort(error)
resp = Response(stream_with_context(res))
resp.headers['X-Accel-Buffering'] = 'no'
resp.headers['Cache-Control'] = 'no-cache'
resp.headers['Content-Type'] = res.headers.get(
'content-type', 'application/octet-stream')
return resp
class Forget(MethodView):
decorators = [login_required(need=False), csrf_exempt]
def get(self):
return self.render_template()
def post(self):
email = request.form.get('email', None)
if not check_email(email):
return self.render_template(error=code.ACCOUNT_EMAIL_INVAILD)
user = get_user_by_email(email=email)
if user:
stub = create_token(20)
forget, error = create_forget(user.id, stub)
if error:
return self.render_template(error=error)
send_forget_mail(user, forget)
return self.render_template(send=code.ACCOUNT_EMAIL_FORGET)
class Transport(MethodView):
decorators = [
repo_required(admin=True),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
return self.render_template(
member=member, repo=repo, organization=organization, \
admin=admin, team=team, team_member=team_member, \
)
def post(self, organization, member, repo, admin, team, team_member):
name = request.form.get('name')
user = get_user(name)
if not user:
return self.render_template(
member=member, repo=repo, organization=organization, \
error=code.ACCOUNT_NO_SUCH_USER, \
admin=admin, team=team, team_member=team_member, \
)
if user.id == repo.uid:
return self.render_template(
member=member, repo=repo, organization=organization, \
error=code.REPOS_CANT_TRANSPORT_SELF, \
admin=admin, team=team, team_member=team_member, \
)
is_member = get_organization_member(organization.id, user.id)
if not is_member:
return self.render_template(
member=member, repo=repo, organization=organization, \
error=code.ORGANIZATION_MEMBER_NOT_EXISTS, \
admin=admin, team=team, team_member=team_member, \
)
error = transport_repo(organization, user, repo, team)
if error:
return self.render_template(
member=member, repo=repo, organization=organization, \
error=error, \
admin=admin, team=team, team_member=team_member, \
)
return redirect(repo.meta.transport)
class Watchers(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
watchers = get_repo_watchers(repo.id)
return self.render_template(
member=member, repo=repo, organization=organization, \
watchers=self.render_watchers(watchers), \
admin=admin, team=team, team_member=team_member, \
)
def render_watchers(self, watchers):
for watcher in watchers:
setattr(watcher, 'user', get_user(watcher.uid))
yield watcher
class Fork(MethodView):
decorators = [
repo_required(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, repo, admin, team, team_member):
return self.render_template(
organization=organization, \
member=member, \
repo=repo, \
)
def post(self, organization, member, repo, admin, team, team_member):
name = request.form.get('name', '')
summary = request.form.get('summary', '')
teamname = '' if not team else team.name
if not check_reponame(name):
return self.render_template(
organization=organization, \
member=member, \
repo=repo, \
error = code.REPOS_NAME_INVALID, \
)
path = os.path.join(teamname, '%s.git' % name)
fork_repo, error = create_repo(
name, path, g.current_user, organization, \
team=team, summary=summary, parent=repo, \
default=repo.default
)
if error:
return self.render_template(
organization=organization, \
member=member, \
repo=repo, \
error = error, \
)
return redirect(get_url(organization, fork_repo))
class Watchers(MethodView):
decorators = [
gist_require(),
member_required(admin=False),
login_required('account.login')
]
def get(self, organization, member, gist):
watchers = get_gist_watchers(gist.id)
return self.render_template(
organization=organization, \
member=member, \
gist=gist, \
watchers=self.render_watchers(watchers)
)
def render_watchers(self, watchers):
for watcher in watchers:
setattr(watcher, 'user', get_user(watcher.uid))
yield watcher
class Setting(MethodView):
decorators = [login_required('account.login')]
def get(self):
return self.render_template()
def post(self):
user = g.current_user
password = request.form.get('password', None)
display = request.form.get('display', None)
city = request.form.get('city', '')
title = request.form.get('title', '')
attrs = {}
if display != user.display:
status = check_display(display)
if not status:
return self.render_template(
error=code.ACCOUNT_USERNAME_INVAILD)
attrs['display'] = display
if password:
status = check_password(password)
if not status:
return self.render_template(
error=code.ACCOUNT_PASSWORD_INVAILD)
attrs['password'] = password
attrs['city'] = city
attrs['title'] = title
error = update_account(user, **attrs)
if error:
return self.render_template(error=error)
#relogin
account_login(user)
g.current_user = get_current_user()
return self.render_template(error=code.ACCOUNT_SETTING_SUCCESS)
