def test_destroy_hook(self):
url = "http://this.is.other.url"
prj = self._prj()
hook = CodeDoubanHook.add(url, prj.id)
hooked_project = CodeDoubanProject.get(hook.project_id)
assert len(hooked_project.hooks) == 1
hooked_project = CodeDoubanProject.get(hook.project_id)
hook.destroy()
assert len(hooked_project.hooks) == 0
def unwatch(request):
user = request.user
if not user:
return request.redirect("/")
errors = ""
if request.method == "POST":
proj_id = request.get_form_var('proj_id')
CodeDoubanProject.del_watch(proj_id, user.name)
project = CodeDoubanProject.get(proj_id)
return request.redirect('/%s/' % project.name)
proj_id = request.get_form_var('proj_id') or ""
project = CodeDoubanProject.get(proj_id)
action = "unwatch"
return st('watch.html', **locals())
def unwatch(request):
user = request.user
if not user:
return request.redirect("/")
errors = ""
if request.method == "POST":
proj_id = request.get_form_var('proj_id')
CodeDoubanProject.del_watch(proj_id, user.name)
project = CodeDoubanProject.get(proj_id)
return request.redirect('/%s/' % project.name)
proj_id = request.get_form_var('proj_id') or ""
project = CodeDoubanProject.get(proj_id)
action = "unwatch"
return st('watch.html', **locals())
def _make_cmd(self):
assert self.temp_dir
sphinx_builder = self.config.get('builder', self.builder) # noqa TODO rm self.builder when no more old config
assert sphinx_builder in [
'pickle', 'html'], "sphinx builder %s unknown" % sphinx_builder
options = []
prj = CodeDoubanProject.get(self.project_id)
default_options = {
'master_doc': self.masterdoc,
'source_suffix': '.rst',
'html_short_title': prj.name,
}
options_dict = default_options.copy()
if self.config:
options_dict.update(self.config)
for k, v in options_dict.items():
options.extend(['-D', '%s=%s' % (k, v)])
cmd = [
'sphinx-build',
'-a', # -- write all files; default is to only write new and changed files
'-E', # -- don't use a saved environment, always read all files
'-b', sphinx_builder, # -- builder to use
'-D', 'project=%s' % prj.name,
# -- override a setting in configuration
]
cmd += options
cmd += ['-d', os.path.join(self.temp_dir, SPHINX_BUILD_DOCTREES)] # -- path for the cached environment and doctree files
cmd += ['-q']
if self._has_sphinx_conf():
cmd += ['-c', self.temp_dir] # -- path where configuration file (conf.py) is located
else:
cmd += ['-C'] # No conf.py file
cmd += [self.temp_dir, self._path(tmp=True)]
return cmd
def async_comment_to_pr(data):
''' commit comment rewrite to pr '''
type_ = data.get('type')
if type_ not in ('commit_comment', 'commit_linecomment'):
return
comment = data.get('comment')
ref = comment.get('ref')
author = comment.get('author')
content = comment.get('content')
proj_id = comment.get('project_id')
comment_uid = comment.get('comment_uid')
proj = CodeDoubanProject.get(proj_id)
prs = proj.open_family_pulls
anchor = comment_uid
for pr in prs:
if ref in pr.get_commits_shas():
content = COMMENT_TEMPLATE.format(content=content,
domain=DOMAIN,
proj=proj.name,
sha=ref,
anchor=anchor)
ticket = Ticket.get_by_projectid_and_ticketnumber(
pr.to_proj.id, pr.ticket_id)
ticket.add_comment(content, author)
def __init__(self, ticket):
self.project = CodeDoubanProject.get(ticket.project_id)
self.proj_name = self.project.name
self.ticket_id = ticket.ticket_number
self.ticket = ticket
self.pullreq = PullRequest.get_by_proj_and_ticket(
self.project.id, self.ticket_id)
def __init__(self, data):
NotificationDispatcher.__init__(self, data)
self._comment = data.get('comment')
# TODO: get commit author by sha # ...现在应该是 None
self._commit_author = data.get('commit_author')
self._is_line_comment = data.get('is_line_comment') # no use
self._proj = CodeDoubanProject.get(self._comment.project_id)
def test_add_hook(self):
url = "http://this.is.a.url"
prj = self._prj()
hook = CodeDoubanHook.add(url, prj.id)
hooked_project = CodeDoubanProject.get(hook.project_id)
assert hooked_project
assert hook.__dict__ == hooked_project.hooks[0].__dict__
def __init__(self, data):
NotificationDispatcher.__init__(self, data)
self._comment = data.get('comment')
# TODO: get commit author by sha # ...现在应该是 None
self._commit_author = data.get('commit_author')
self._is_line_comment = data.get('is_line_comment') # no use
self._proj = CodeDoubanProject.get(self._comment.project_id)
def _builders_list(project_id):
prj = CodeDoubanProject.get(project_id)
if not prj.conf['docs']:
return [DEFAULT_BUILDER]
blds = [(v.get('sort'), k) for k, v in prj.conf['docs'].items()]
blds = sorted(blds)
blds = [_[1] for _ in blds]
return blds
def _builders_list(project_id):
prj = CodeDoubanProject.get(project_id)
if not prj.conf['docs']:
return [DEFAULT_BUILDER]
blds = [(v.get('sort'), k) for k, v in prj.conf['docs'].items()]
blds = sorted(blds)
blds = [_[1] for _ in blds]
return blds
def __init__(self, project_id, ticket_number, hl_description):
self.ticket = Ticket.get_by_projectid_and_ticketnumber(
project_id, ticket_number)
self.ticket_project = CodeDoubanProject.get(self.ticket.project_id)
self.author = User(self.ticket.author)
self.ticket_url = self.ticket.url
self.hl_description = hl_description if hl_description \
else self.ticket.description
def __init__(self, builder, project_id):
self.builder = builder
self.project_id = project_id
prj = CodeDoubanProject.get(project_id)
self.docs_dir = os.path.join(get_repo_root(),
prj.name + DOC_EXT, builder)
self.config = _builder_conf(project_id, builder)
self.dir = self.config['dir']
self.temp_dir = None
self.temp_dir_root = None
def _get_project_by_id(id):
project = {}
_project = CodeDoubanProject.get(id)
_author = _get_user_by_name(_project.owner_id)
project = dict(
id=_project.id,
name=_project.name,
owner=_author,
)
return project
def __init__(self, builder, project_id):
self.builder = builder
self.project_id = project_id
prj = CodeDoubanProject.get(project_id)
self.docs_dir = os.path.join(get_repo_root(), prj.name + DOC_EXT,
builder)
self.config = _builder_conf(project_id, builder)
self.dir = self.config['dir']
self.temp_dir = None
self.temp_dir_root = None
def __init__(self, id, project_id, sha, state, target_url, description, time, author):
self.project_id = project_id
self.sha = sha
self.id = id
self.state = state
self.target_url = target_url
self.description = description
self.time = time
self.author = author
self.project = CodeDoubanProject.get(self.project_id)
def __init__(self, id, project_id, sha, state, target_url, description,
time, author):
self.project_id = project_id
self.sha = sha
self.id = id
self.state = state
self.target_url = target_url
self.description = description
self.time = time
self.author = author
self.project = CodeDoubanProject.get(self.project_id)
def _builder_conf(project_id, builder_name):
prj = CodeDoubanProject.get(project_id)
if not prj.conf.get('docs'):
return {'dir': builder_name}
conf = prj.conf['docs'].get(builder_name, False)
if not conf:
return {'dir': builder_name}
if 'dir' not in conf:
conf['dir'] = builder_name # When no explicit dir, use the name
if 'checkout_root' not in conf:
conf['checkout_root'] = SPHINX_DEFAULT_CHECKOUT_ROOT
return conf
def _builder_conf(project_id, builder_name):
prj = CodeDoubanProject.get(project_id)
if not prj.conf.get('docs'):
return {'dir': builder_name}
conf = prj.conf['docs'].get(builder_name, False)
if not conf:
return {'dir': builder_name}
if 'dir' not in conf:
conf['dir'] = builder_name # When no explicit dir, use the name
if 'checkout_root' not in conf:
conf['checkout_root'] = SPHINX_DEFAULT_CHECKOUT_ROOT
return conf
def add_fork_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name, owner_id=project.owner_id, summary=project.summary,
product=project.product, fork_from=project.fork_from,
intern_banned=project.intern_banned)
if _project:
fork_from_project = CodeDoubanProject.get(project.fork_from)
_project.update(project.summary,
project.product,
name,
fork_from_project.intern_banned)
return _project
def add_fork_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
fork_from=project.fork_from,
intern_banned=project.intern_banned)
if _project:
fork_from_project = CodeDoubanProject.get(project.fork_from)
_project.update(project.summary, project.product, name,
fork_from_project.intern_banned)
return _project
def search_a_phrase(cls,
phrase,
from_=0,
size=20,
project_id=None,
sort_data=None,
language=None):
highlight_data = {"fields": {"content": {"number_of_fragments": 0}}}
filter_list = []
# FIXME: use project_id field
project = CodeDoubanProject.get(project_id) if project_id else None
if project:
filter_list.append({"term": {"project.raw": project.name}})
if language:
filter_list.append({"term": {"language.raw": language}})
if filter_list:
filter_data = {"and": filter_list}
else:
filter_data = None
if not sort_data:
if project_id:
sort_data = ['rank', '_score']
else:
sort_data = [
"rank",
"_score",
{
"project_rank": "desc"
},
{
"last_updated": "desc"
},
]
facets_data = {"language": {"terms": {"field": "language.raw"}}}
result = SearchEngine.search_a_phrase('src',
phrase,
from_,
size,
sort_data=sort_data,
filter_data=filter_data,
highlight_data=highlight_data,
facets_data=facets_data)
return result
def _export_docs_tree(project_id, tree_hash, temp_dir):
_call = CodeDoubanProject.get(project_id).git.call
debug('Exporting docs tree')
_call('read-tree --empty')
try:
_call('read-tree %s' % tree_hash)
except GytError as e:
if 'failed to unpack tree object' in e.args[2]:
return False, 'failed to unpack tree object'
else:
raise
# TODO use gyt repo to handle worktree
_call('--work-tree %s checkout-index --force -a' % temp_dir)
debug('Checked out the docs content work-tree')
return True, ''
def _export_docs_tree(project_id, tree_hash, temp_dir):
_call = CodeDoubanProject.get(project_id).git.call
debug('Exporting docs tree')
_call('read-tree --empty')
try:
_call('read-tree %s' % tree_hash)
except GytError as e:
if 'failed to unpack tree object' in e.args[2]:
return False, 'failed to unpack tree object'
else:
raise
# TODO use gyt repo to handle worktree
_call('--work-tree %s checkout-index --force -a' % temp_dir)
debug('Checked out the docs content work-tree')
return True, ''
def search_a_phrase(cls, phrase, from_=0, size=20, project_id=None,
sort_data=None, language=None):
highlight_data = {
"fields": {
"content": {"number_of_fragments": 0}
}
}
filter_list = []
# FIXME: use project_id field
project = CodeDoubanProject.get(project_id) if project_id else None
if project:
filter_list.append({"term": {"project.raw": project.name}})
if language:
filter_list.append({"term": {"language.raw": language}})
if filter_list:
filter_data = {"and": filter_list}
else:
filter_data = None
if not sort_data:
if project_id:
sort_data = ['rank', '_score']
else:
sort_data = [
"rank",
"_score",
{"project_rank": "desc"},
{"last_updated": "desc"},
]
facets_data = {
"language": {
"terms": {
"field": "language.raw"
}
}
}
result = SearchEngine.search_a_phrase('src', phrase, from_, size,
sort_data=sort_data,
filter_data=filter_data,
highlight_data=highlight_data,
facets_data=facets_data)
return result
def post(self, request):
content = request.data.get("content")
if content is None:
raise api_errors.MissingFieldError('content')
doc_project = self.team.doc_project
project = CodeDoubanProject.get(content)
if not project:
return {'content': doc_project and doc_project.name}
team_projects = TeamProject.gets_by(team_id=self.team.id)
team_project = team_projects[0] if team_projects else None
if team_project:
team_project.project_id = project.id
team_project.save()
else:
TeamProject.create(team_id=self.team.id, project_id=project.id)
return {'content': project.name}
def repo_watch_receiver(sender, **kw):
proj_id = kw.get('project_id')
author = kw.get('author')
project = CodeDoubanProject.get(proj_id)
uid = 'repo-watch-%s-%s' % (project.id, author)
data = {
'uid': uid,
'author': author,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_watch'
}
feeds = get_related_feeds(author)
for feed in feeds:
feed.add_action(data)
def repo_watch_receiver(sender, **kw):
proj_id = kw.get('project_id')
author = kw.get('author')
project = CodeDoubanProject.get(proj_id)
uid = 'repo-watch-%s-%s' % (project.id, author)
data = {
'uid': uid,
'author': author,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_watch'
}
feeds = get_related_feeds(author)
for feed in feeds:
feed.add_action(data)
def repo_create_receiver(sender, **kw):
proj_id = kw.get('project_id')
owner_id = kw.get('creator')
project = CodeDoubanProject.get(proj_id)
uid = 'repo-create-%s-%s' % (project.id, owner_id)
data = {
'uid': uid,
'author': owner_id,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_create'
}
feeds = get_related_feeds(owner_id)
for feed in feeds:
feed.add_action(data)
def __init__(self, id='', last_updated_str='', hl_description=''):
self.id = str(id)
self.project = CodeDoubanProject.get(id)
self.name = self.project.name
self.owner = User(self.project.owner_name)
self.last_updated = datetime.strptime(
last_updated_str, DATE_FORMAT) if last_updated_str \
else self.project.time
self.create_time = self.project.time
self.description = self.project.summary
self.url = self.project.url
self.language = self.project.language
self.fork_from = self.project.get_forked_from()
self.forked_count = CodeDoubanProject.get_forked_count(self.project.id)
self.watched_count = CodeDoubanProject.get_watched_count(
self.project.id)
self.hl_description = hl_description or self.description
def repo_watch_receiver(sender, **kw):
proj_id = kw.get("project_id")
author = kw.get("author")
project = CodeDoubanProject.get(proj_id)
uid = "repo-watch-%s-%s" % (project.id, author)
data = {
"uid": uid,
"author": author,
"url": project.url,
"name": project.name,
"desc": project.summary,
"date": datetime.now(),
"type": "repo_watch",
}
feeds = get_related_feeds(author)
for feed in feeds:
feed.add_action(data)
def repo_create_receiver(sender, **kw):
proj_id = kw.get("project_id")
owner_id = kw.get("creator")
project = CodeDoubanProject.get(proj_id)
uid = "repo-create-%s-%s" % (project.id, owner_id)
data = {
"uid": uid,
"author": owner_id,
"url": project.url,
"name": project.name,
"desc": project.summary,
"date": datetime.now(),
"type": "repo_create",
}
feeds = get_related_feeds(owner_id)
for feed in feeds:
feed.add_action(data)
def repo_create_receiver(sender, **kw):
proj_id = kw.get('project_id')
owner_id = kw.get('creator')
project = CodeDoubanProject.get(proj_id)
uid = 'repo-create-%s-%s' % (project.id, owner_id)
data = {
'uid': uid,
'author': owner_id,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_create'
}
feeds = get_related_feeds(owner_id)
for feed in feeds:
feed.add_action(data)
def __init__(self, id='', last_updated_str='', hl_description=''):
self.id = str(id)
self.project = CodeDoubanProject.get(id)
self.name = self.project.name
self.owner = User(self.project.owner_name)
self.last_updated = datetime.strptime(
last_updated_str, DATE_FORMAT) if last_updated_str \
else self.project.time
self.create_time = self.project.time
self.description = self.project.summary
self.url = self.project.url
self.language = self.project.language
self.fork_from = self.project.get_forked_from()
self.forked_count = CodeDoubanProject.get_forked_count(self.project.id)
self.watched_count = CodeDoubanProject.get_watched_count(
self.project.id)
self.hl_description = hl_description or self.description
def telchar(self, request):
proj_id = self.proj_id
user = request.user
project = CodeDoubanProject.get(proj_id)
url = TELCHAR_URL
if project.is_owner(user):
is_disable = request.get_form_var('close', '')
if is_disable:
hook = CodeDoubanHook.get_by_url(url)
if hook:
hook.destroy()
status = 0
else:
CodeDoubanHook.add(url, proj_id)
status = 1
return {'r': 0, 'status': status}
return {'r': 1}
def repo_fork_receiver(sender, **kw):
proj_id = kw.get('project_id')
author = kw.get('author')
project = CodeDoubanProject.get(proj_id)
forked_from = project.get_forked_from()
uid = 'repo-fork-%s-%s' % (forked_from.id, project.id)
data = {
'uid': uid,
'author': author,
'forked_from_name': forked_from.name,
'forked_from_url': forked_from.url,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_fork'
}
feeds = get_related_feeds(author, extra_receivers=[forked_from.owner_id])
for feed in feeds:
feed.add_action(data)
def repo_fork_receiver(sender, **kw):
proj_id = kw.get("project_id")
author = kw.get("author")
project = CodeDoubanProject.get(proj_id)
forked_from = project.get_forked_from()
uid = "repo-fork-%s-%s" % (forked_from.id, project.id)
data = {
"uid": uid,
"author": author,
"forked_from_name": forked_from.name,
"forked_from_url": forked_from.url,
"url": project.url,
"name": project.name,
"desc": project.summary,
"date": datetime.now(),
"type": "repo_fork",
}
feeds = get_related_feeds(author, extra_receivers=[forked_from.owner_id])
for feed in feeds:
feed.add_action(data)
def repo_fork_receiver(sender, **kw):
proj_id = kw.get('project_id')
author = kw.get('author')
project = CodeDoubanProject.get(proj_id)
forked_from = project.get_forked_from()
uid = 'repo-fork-%s-%s' % (forked_from.id, project.id)
data = {
'uid': uid,
'author': author,
'forked_from_name': forked_from.name,
'forked_from_url': forked_from.url,
'url': project.url,
'name': project.name,
'desc': project.summary,
'date': datetime.now(),
'type': 'repo_fork'
}
feeds = get_related_feeds(author, extra_receivers=[forked_from.owner_id])
for feed in feeds:
feed.add_action(data)
def _make_cmd(self):
assert self.temp_dir
sphinx_builder = self.config.get(
'builder',
self.builder) # noqa TODO rm self.builder when no more old config
assert sphinx_builder in [
'pickle', 'html'
], "sphinx builder %s unknown" % sphinx_builder
options = []
prj = CodeDoubanProject.get(self.project_id)
default_options = {
'master_doc': self.masterdoc,
'source_suffix': '.rst',
'html_short_title': prj.name,
}
options_dict = default_options.copy()
if self.config:
options_dict.update(self.config)
for k, v in options_dict.items():
options.extend(['-D', '%s=%s' % (k, v)])
cmd = [
'sphinx-build',
'-a', # -- write all files; default is to only write new and changed files
'-E', # -- don't use a saved environment, always read all files
'-b',
sphinx_builder, # -- builder to use
'-D',
'project=%s' % prj.name,
# -- override a setting in configuration
]
cmd += options
# -- path for the cached environment and doctree files
cmd += ['-d', os.path.join(self.temp_dir, SPHINX_BUILD_DOCTREES)]
cmd += ['-q']
if self._has_sphinx_conf():
# -- path where configuration file (conf.py) is located
cmd += ['-c', self.temp_dir]
else:
cmd += ['-C'] # No conf.py file
cmd += [self.temp_dir, self._path(tmp=True)]
return cmd
def _q_index(self, request):
user = request.user
project = self.project
if request.method == 'GET':
teams = Team.gets()
owner = User(self.project.owner_id)
committers = project.get_committers_by_project(project.id)
if project.fork_from:
fork_from = CodeDoubanProject.get(project.fork_from)
return st('settings/main.html', **locals())
elif request.method == 'POST':
if user.name == project.owner_id:
summary = request.get_form_var('summary', '')
product = request.get_form_var('product', '')
intern_banned = request.get_form_var('intern_banned', None)
project.update(summary, product, self.proj_name, intern_banned)
return request.redirect('/%s/settings' % self.proj_name)
def _q_index(self, request):
user = request.user
project = self.project
if request.method == 'GET':
teams = Team.gets()
owner = User(self.project.owner_id)
committers = project.get_committers_by_project(project.id)
if project.fork_from:
fork_from = CodeDoubanProject.get(project.fork_from)
return st('settings/main.html', **locals())
elif request.method == 'POST':
if user.name == project.owner_id:
summary = request.get_form_var('summary', '')
product = request.get_form_var('product', '')
intern_banned = request.get_form_var('intern_banned', None)
project.update(summary, product, self.proj_name, intern_banned)
return request.redirect('/%s/settings' % self.proj_name)
def project(self):
from vilya.models.project import CodeDoubanProject
return CodeDoubanProject.get(self.target.project_id)
def proj_name(self):
from vilya.models.project import CodeDoubanProject
return CodeDoubanProject.get(self.project_id).name
def create(request):
user = request.user
if not user:
return request.redirect("/")
errors = ""
template_filename = 'create.html'
if request.method == "POST":
name = request.get_form_var('name')
product = request.get_form_var('product')
org_proj = request.get_form_var('org_proj')
summary = request.get_form_var('summary')
repo_url = request.get_form_var('url')
fork_from = request.get_form_var('fork_from')
intern_banned = request.get_form_var('intern_banned', None)
with_proxy = request.get_form_var('with_proxy', MIRROR_NOT_PROXY)
with_proxy = int(with_proxy)
mirror = None
def add_people_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned)
return _project
def add_org_project(project):
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned)
return _project
def add_mirror_project(project):
name = "mirror/%s" % (project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id='mirror',
summary=project.summary,
product=project.product,
intern_banned=project.intern_banned,
mirror=project.mirror_url)
if _project:
CodeDoubanMirror.add(url=project.mirror_url,
state=MIRROR_STATE_CLONING,
project_id=_project.id,
with_proxy=project.mirror_proxy)
return _project
def add_fork_project(project):
name = "%s/%s" % (project.owner_id, project.name)
_project = CodeDoubanProject.add(
name=name,
owner_id=project.owner_id,
summary=project.summary,
product=project.product,
fork_from=project.fork_from,
intern_banned=project.intern_banned)
if _project:
fork_from_project = CodeDoubanProject.get(project.fork_from)
_project.update(project.summary, project.product, name,
fork_from_project.intern_banned)
return _project
def validate_project(project_type, project):
error = ''
if project_type in (PEOPLE_PROJECT, ORGANIZATION_PROJECT):
error = project.validate()
elif project_type == MIRROR_PROJECT:
error = project.validate()
if not error:
error = CodeDoubanMirror.validate(project.mirror_url)
else:
error = project.validate()
return error
def add_project(project):
_project = None
if project_type == PEOPLE_PROJECT:
_project = add_people_project(project)
elif project_type == ORGANIZATION_PROJECT:
_project = add_org_project(project)
elif project_type == MIRROR_PROJECT:
_project = add_mirror_project(project)
else:
_project = add_fork_project(project)
return _project
project = CodeDoubanProject(None,
name,
user.username,
summary,
datetime.now(),
product,
None,
None,
fork_from=fork_from,
intern_banned=intern_banned,
mirror_url=repo_url,
mirror_proxy=with_proxy)
# FIXME: rename org_proj of html
project_type = org_proj
errors = validate_project(project_type, project)
if errors:
return st(template_filename, **locals())
project = add_project(project)
if not project:
fork_from = ''
errors = 'project exists'
return st(template_filename, **locals())
CodeDoubanProject.add_watch(project.id, user.name)
return request.redirect('/%s/' % project.name)
fork_from = ''
if request.get_form_var('fork_from'):
fork_from = CodeDoubanProject.get(request.get_form_var('fork_from'))
name = "%s/%s" % (user.name, fork_from.realname)
if CodeDoubanProject.exists(name):
return request.redirect('/%s/' % name)
projects = CodeDoubanProject.gets_by_owner_id(user.name)
for p in projects:
if p.origin_project_id == fork_from.id and '/' in p.name:
return request.redirect('/%s/' % p.name)
return st(template_filename, **locals())
def project(self):
return CodeDoubanProject.get(self.project_id)
def projects(self):
from vilya.models.project import CodeDoubanProject
return filter(None,
[CodeDoubanProject.get(_) for _ in self.project_ids])
def get_projects():
rs = store.execute('select project_id from codedouban_projects')
for proj_id, in rs:
yield CodeDoubanProject.get(proj_id)
def get_origin_projects():
rs = store.execute(
'select project_id from codedouban_projects where project_id=origin_project'
) # noqa
for proj_id, in rs:
yield CodeDoubanProject.get(proj_id)
def _tree_hash(project_id, path):
_call = CodeDoubanProject.get(project_id).git.call
return _call('rev-parse HEAD:%s' % path, _raise=False)
def get_mirror_projects():
rs = store.execute(
'select project_id from codedouban_projects where owner_id=mirror')
for proj_id, in rs:
yield CodeDoubanProject.get(proj_id)
def projects(self):
from vilya.models.project import CodeDoubanProject
rs = ProjectGroup.gets(group_id=self.id)
return filter(None, [CodeDoubanProject.get(r.project_id) for r in rs])
def project(self):
return CodeDoubanProject.get(self.project_id)
