def add(cls, description, owner_id, is_public, gist_names=[],
gist_contents=[], fork_from=None):
now = datetime.now()
if fork_from:
name = cls.get(fork_from).name
id = store.execute(
"insert into gists "
"(`name`, `description`, `owner_id`, `created_at`, `fork_from`) " # noqa
"values (%s, %s, %s, %s, %s)",
(name, description, owner_id, now, fork_from))
store.commit()
gist = cls.get(id)
fork_from = cls.get(fork_from)
fork_from.fork_repo(gist)
gist_forked_signal.send(gist, gist_id=gist.id)
else:
name = cls._get_name(names=gist_names)
id = store.execute(
"insert into gists "
"(`name`, `description`, `owner_id`, `is_public`, `created_at`) " # noqa
"values (%s, %s, %s, %s, %s)",
(name, description, owner_id, is_public, now))
store.commit()
gist = cls.get(id)
gist.create_repo()
gist._commit_all_files(gist_names, gist_contents, create=True)
gist_created_signal.send(gist, gist_id=gist.id)
return gist
def add(cls, name, followed_user_name):
time = datetime.now()
store.execute(
'insert into follow_relationship '
'(user_name, followed_user_name, time) '
'values (%s, %s, %s)', (name, followed_user_name, time))
store.commit()
def revoke(self):
now = datetime.now()
store.execute(
"update api_token set expire_time=%s, refresh_expire_time=%s "
"where id=%s", (now, now, self.id))
store.commit()
self.expire_time = self.refresh_expire_time = now
def discover(cls, name, sort='created', direction='desc', start=0,
limit=5):
assert sort in SORTS
assert direction in DIRECTIONS
sortby = "order by %s_at %s " % (sort, direction)
sort = '%s_at' % sort
reverse = direction == 'desc'
if name == 'forked':
rs = store.execute("select distinct(fork_from) from gists "
"where fork_from!=0 and is_public=1 " +
sortby + "limit %s, %s",
(start, limit))
return [cls.get(r) for r, in rs]
elif name == 'starred':
rs = store.execute("select distinct(gist_id) from gist_stars "
"order by created_at " +
direction + " limit %s, %s",
(start, limit))
gists = filter(None, [cls.get(r) for r, in rs])
return sorted(gists, key=lambda g: getattr(g, sort),
reverse=reverse)
else:
rs = store.execute(
"select id, name, description, owner_id, is_public, "
"fork_from, created_at, updated_at from gists where "
"is_public=1 " + sortby + "limit %s, %s",
(start, limit))
return [cls(*r) for r in rs]
def test_project_stat(self):
store.execute("delete from codedouban_projects where project_id < 5")
project_rs = get_all_project()
assert len(project_rs) == 0
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_name = "project"
project = CodeDoubanProject.add(
project_name, owner_id="test1", summary="test", product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project_rs = get_all_project()
assert len(project_rs) == 1
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_fork = project.fork('project_test_fork', 'test_fork')
project_rs = get_all_project()
assert len(project_rs) == 2
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 1
project.delete()
project_fork.delete()
def test_project_stat(self):
store.execute("delete from codedouban_projects where project_id < 5")
project_rs = get_all_project()
assert len(project_rs) == 0
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_name = "project"
project = CodeDoubanProject.add(project_name,
owner_id="test1",
summary="test",
product="fire")
git_path = os.path.join(get_repo_root(), '%s.git' % project_name)
ok_(os.path.exists(git_path))
project_rs = get_all_project()
assert len(project_rs) == 1
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 0
project_fork = project.fork('project_test_fork', 'test_fork')
project_rs = get_all_project()
assert len(project_rs) == 2
project_fork_count = len(filter(lambda x: x[1] is not None,
project_rs))
assert project_fork_count == 1
project.delete()
project_fork.delete()
def add(cls,
title,
description,
creator,
number=None,
team=None,
project=None,
assignee=None,
closer=None,
created_at=None,
updated_at=None,
closed_at=None):
issue = Issue.add(title,
description,
creator,
assignee=assignee,
closer=closer,
type=cls.target_type,
target_id=project)
if issue and project:
number = PICounter.incr(project, number)
store.execute(
'insert into project_issues (project_id, issue_id, number) '
'values (%s, %s, %s) ', (project, issue.id, number))
store.commit()
mc.delete(MC_KEY_PROJECT_ISSUE_CREATOR_N %
(project, creator, 'open'))
mc.delete(MC_KEY_PROJECT_ISSUE_CREATOR_N %
(project, creator, 'closed'))
cls._clean_cache(project)
return Issue.get_cached_issue(issue.id)
def update(self, title='', description=''):
store.execute(
"update codedouban_ticket set title=%s, description=%s "
"where id=%s", (title, description, self.id))
store.commit()
mc.delete(MCKEY_TICKET % self.id)
bdb.set(BDB_TICKET_DESCRIPTION_KEY % self.id, description)
def add(cls, name, followed_user_name):
time = datetime.now()
store.execute('insert into follow_relationship '
'(user_name, followed_user_name, time) '
'values (%s, %s, %s)',
(name, followed_user_name, time))
store.commit()
def add(
cls,
title,
description,
creator,
number=None,
team=None,
project=None,
assignee=None,
closer=None,
created_at=None,
updated_at=None,
closed_at=None,
):
issue = Issue.add(
title, description, creator, assignee=assignee, closer=closer, type=cls.target_type, target_id=project
)
if issue and project:
number = PICounter.incr(project, number)
store.execute(
"insert into project_issues (project_id, issue_id, number) " "values (%s, %s, %s) ",
(project, issue.id, number),
)
store.commit()
mc.delete(MC_KEY_PROJECT_ISSUE_CREATOR_N % (project, creator, "open"))
mc.delete(MC_KEY_PROJECT_ISSUE_CREATOR_N % (project, creator, "closed"))
cls._clean_cache(project)
return Issue.get_cached_issue(issue.id)
def discover(cls,
name,
sort='created',
direction='desc',
start=0,
limit=5):
assert sort in SORTS
assert direction in DIRECTIONS
sortby = "order by %s_at %s " % (sort, direction)
sort = '%s_at' % sort
reverse = direction == 'desc'
if name == 'forked':
rs = store.execute(
"select distinct(fork_from) from gists "
"where fork_from!=0 and is_public=1 " + sortby +
"limit %s, %s", (start, limit))
return [cls.get(r) for r, in rs]
elif name == 'starred':
rs = store.execute(
"select distinct(gist_id) from gist_stars "
"order by created_at " + direction + " limit %s, %s",
(start, limit))
gists = filter(None, [cls.get(r) for r, in rs])
return sorted(gists,
key=lambda g: getattr(g, sort),
reverse=reverse)
else:
rs = store.execute(
"select id, name, description, owner_id, is_public, "
"fork_from, created_at, updated_at from gists where "
"is_public=1 " + sortby + "limit %s, %s", (start, limit))
return [cls(*r) for r in rs]
def update_product(self, product):
store.execute("update codedouban_projects "
"set product=%s "
"where project_id=%s",
(product, self.id))
store.commit()
self.clear_mc(self.id)
def update_summary(self, summary):
store.execute("update codedouban_projects "
"set summary=%s "
"where project_id=%s",
(summary, self.id))
store.commit()
self.clear_mc(self.id)
def update_intern_banned(self, banned):
store.execute("update codedouban_projects "
"set intern_banned=%s "
"where project_id=%s",
(banned, self.id))
store.commit()
self.clear_mc(self.id)
def update_product(self, product):
store.execute("update codedouban_projects "
"set product=%s "
"where project_id=%s",
(product, self.id))
store.commit()
self.clear_mc(self.id)
def update_summary(self, summary):
store.execute("update codedouban_projects "
"set summary=%s "
"where project_id=%s",
(summary, self.id))
store.commit()
self.clear_mc(self.id)
def main():
rs = store.execute("select id "
"from codedouban_ticket")
for r in rs:
id, = r
ticket = Ticket.get(id)
# update merge
pullreq = PullRequest.get_by_ticket(ticket)
author = pullreq.merge_by or pullreq.to_proj.owner_id
time = pullreq.merge_time
ticket_id = ticket.id
id = 0
if not get_node(author, TICKET_NODE_TYPE_MERGE, id, ticket_id, time) and time:
print id, author, time, ticket_id
store.execute("insert into ticket_nodes "
"(author, type, type_id, ticket_id, created_at) "
"value (%s, %s, %s, %s, %s)",
(author, TICKET_NODE_TYPE_MERGE, id, ticket_id, time))
store.commit()
# update close
author = ticket.close_by or ticket.author
time = ticket.closed
ticket_id = ticket.id
id = 0
if not get_node(author, TICKET_NODE_TYPE_CLOSE, id, ticket_id, time) and time:
print id, author, time, ticket_id
store.execute("insert into ticket_nodes "
"(author, type, type_id, ticket_id, created_at) "
"value (%s, %s, %s, %s, %s)",
(author, TICKET_NODE_TYPE_CLOSE, id, ticket_id, time))
store.commit()
print "update %s close & merge pulls" % len(rs)
def update_intern_banned(self, banned):
store.execute("update codedouban_projects "
"set intern_banned=%s "
"where project_id=%s",
(banned, self.id))
store.commit()
self.clear_mc(self.id)
def add(cls,
description,
owner_id,
is_public,
gist_names=[],
gist_contents=[],
fork_from=None):
now = datetime.now()
if fork_from:
name = cls.get(fork_from).name
id = store.execute(
"insert into gists "
"(`name`, `description`, `owner_id`, `created_at`, `fork_from`) " # noqa
"values (%s, %s, %s, %s, %s)",
(name, description, owner_id, now, fork_from))
store.commit()
gist = cls.get(id)
fork_from = cls.get(fork_from)
fork_from.fork_repo(gist)
gist_forked_signal.send(gist, gist_id=gist.id)
else:
name = cls._get_name(names=gist_names)
id = store.execute(
"insert into gists "
"(`name`, `description`, `owner_id`, `is_public`, `created_at`) " # noqa
"values (%s, %s, %s, %s, %s)",
(name, description, owner_id, is_public, now))
store.commit()
gist = cls.get(id)
gist.create_repo()
gist._commit_all_files(gist_names, gist_contents, create=True)
gist_created_signal.send(gist, gist_id=gist.id)
return gist
def get_item_count(name):
if name == '':
rs = store.execute("select count(1) from badge_item")
else:
rs = store.execute("select count(1) from badge_item where item_id=%s",
(name, ))
data = rs and rs[0]
return data
def update_can_push(self, can_push):
push = 1 if can_push else 0
store.execute("update codedouban_projects "
"set can_push=%s "
"where project_id=%s",
(push, self.id))
store.commit()
self.clear_mc(self.id)
def add_committer(cls, proj_id, user_id):
try:
store.execute("insert into codedouban_committers "
"(project_id, user_id) values (%s, %s)",
(proj_id, user_id))
except IntegrityError:
return None
store.commit()
def delete(self):
store.execute('delete from issues where id=%s', (self.id, ))
store.commit()
mc.delete(MC_KEY_ISSUE % self.id)
mc.delete(MC_KEY_ISSUES_IDS_BY_CREATOR_ID % self.creator_id)
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % self.assignee_id)
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (type, self.target_id))
bdb.set(BDB_ISSUE_DESCRIPTION_KEY % self.id, '')
def delete(self):
store.execute('delete from issues where id=%s', (self.id,))
store.commit()
mc.delete(MC_KEY_ISSUE % self.id)
mc.delete(MC_KEY_ISSUES_IDS_BY_CREATOR_ID % self.creator_id)
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % self.assignee_id)
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (type, self.target_id))
bdb.set(BDB_ISSUE_DESCRIPTION_KEY % self.id, '')
def update(self, title, description):
store.execute("update issues "
"set title=%s, updated_at=null "
"where id=%s", (title, self.issue_id))
store.commit()
bdb.set(BDB_ISSUE_DESCRIPTION_KEY % self.issue_id, description)
self.clear_cache()
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (self.type, self.target_id))
def update_can_push(self, can_push):
push = 1 if can_push else 0
store.execute("update codedouban_projects "
"set can_push=%s "
"where project_id=%s",
(push, self.id))
store.commit()
self.clear_mc(self.id)
def get_item_count(name):
if name == '':
rs = store.execute("select count(1) from badge_item")
else:
rs = store.execute(
"select count(1) from badge_item where item_id=%s", (name,))
data = rs and rs[0]
return data
def add_committer(cls, proj_id, user_id):
try:
store.execute("insert into codedouban_committers "
"(project_id, user_id) values (%s, %s)",
(proj_id, user_id))
except IntegrityError:
return None
store.commit()
def assign(self, user_id):
old_id = self.assignee_id
store.execute("update issues "
"set assignee_id=%s "
"where id=%s", (user_id, self.issue_id))
store.commit()
self.clear_cache()
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % old_id)
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % user_id)
def open(self):
store.execute("update issues "
"set closer_id=null, closed_at=null "
"where id=%s", (self.issue_id,))
store.commit()
self.clear_cache()
mc.delete(MC_KEY_ISSUES_IDS_BY_CREATOR_ID % self.creator_id)
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (self.type, self.target_id))
self.closer_id = None
def transfer_to_top(self, user=None):
new_user = user if user else self.owner_id
sql = ("update codedouban_projects set project_name=%s, "
"git_path=%s, trac_conf=%s, owner_id=%s "
"where owner_id=%s and project_id=%s")
store.execute(sql, (self.realname, self.realname, self.realname,
new_user, self.owner_id, self.id))
store.commit()
self.clear_mc(self.id)
def transfer_to_top(self, user=None):
new_user = user if user else self.owner_id
sql = ("update codedouban_projects set project_name=%s, "
"git_path=%s, trac_conf=%s, owner_id=%s "
"where owner_id=%s and project_id=%s")
store.execute(sql, (self.realname, self.realname, self.realname,
new_user, self.owner_id, self.id))
store.commit()
self.clear_mc(self.id)
def open(self, operator):
opened_time = datetime.now()
store.execute("update codedouban_ticket set closed=null where id=%s",
(self.id,))
store.commit()
mc.delete(MCKEY_TICKET % self.id)
self.close_by = None
self.add_participant(operator)
TicketNode.add_open(self.id, operator, opened_time)
def count_user_all(self, owner_id, is_self=False):
if is_self:
rs = store.execute(
"select count(1) from gists where owner_id=%s", (owner_id,))
else:
rs = store.execute(
"select count(1) from gists where owner_id=%s "
"and is_public=1", (owner_id,))
return rs[0][0]
def open(self, operator):
opened_time = datetime.now()
store.execute("update codedouban_ticket set closed=null where id=%s",
(self.id, ))
store.commit()
mc.delete(MCKEY_TICKET % self.id)
self.close_by = None
self.add_participant(operator)
TicketNode.add_open(self.id, operator, opened_time)
def update(self, description, gist_names=[], gist_contents=[],
gist_oids=[]):
name = self._get_name(gist_names)
store.execute(
"update gists set name=%s, description=%s, updated_at=%s where id=%s", # noqa
(name, description, datetime.now(), self.id))
store.commit()
self._commit_all_files(gist_names, gist_contents, gist_oids)
gist_updated_signal.send(self, gist_id=self.id)
def count_user_all(self, owner_id, is_self=False):
if is_self:
rs = store.execute("select count(1) from gists where owner_id=%s",
(owner_id, ))
else:
rs = store.execute(
"select count(1) from gists where owner_id=%s "
"and is_public=1", (owner_id, ))
return rs[0][0]
def assign(self, user_id):
old_id = self.assignee_id
store.execute("update issues "
"set assignee_id=%s "
"where id=%s", (user_id, self.issue_id))
store.commit()
self.clear_cache()
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % old_id)
mc.delete(MC_KEY_ISSUES_IDS_BY_ASSIGNEE_ID % user_id)
def update(self, title, description):
store.execute(
"update issues "
"set title=%s, updated_at=null "
"where id=%s", (title, self.issue_id))
store.commit()
bdb.set(BDB_ISSUE_DESCRIPTION_KEY % self.issue_id, description)
self.clear_cache()
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (self.type, self.target_id))
def update(cls, summary, product, name, intern_banned=None):
project_id = cls.get_id_by_name(name)
if not project_id:
return False
store.execute(
"update codedouban_projects set summary=%s, product=%s, "
"intern_banned=%s where project_name=_latin1%s",
(summary, product, intern_banned, name))
store.commit()
cls.clear_mc(project_id)
def open(self):
store.execute(
"update issues "
"set closer_id=null, closed_at=null "
"where id=%s", (self.issue_id, ))
store.commit()
self.clear_cache()
mc.delete(MC_KEY_ISSUES_IDS_BY_CREATOR_ID % self.creator_id)
mc.delete(MC_KEY_ISSUES_DATA_BY_TARGET % (self.type, self.target_id))
self.closer_id = None
def award(self, item_id, reason=None, kind=KIND_USER):
params = (item_id, self.id, reason, kind, datetime.now())
store.execute(
"insert into badge_item(item_id, badge_id, reason, kind, date) "
"values(%s, %s, %s, %s, %s)", params)
store.commit()
mc_key = MC_NEW_BADGE % (item_id, kind)
badges = mc.get(mc_key) or []
badges.append(str(self.id))
mc.set(mc_key, badges)
def update(cls, summary, product, name, intern_banned=None):
project_id = cls.get_id_by_name(name)
if not project_id:
return False
store.execute(
"update codedouban_projects set summary=%s, product=%s, "
"intern_banned=%s where project_name=_latin1%s",
(summary, product, intern_banned, name))
store.commit()
cls.clear_mc(project_id)
def add_related_project(self, repo_url):
info = urlparse(repo_url)
project_name = info.path.strip('/')
from vilya.models.project import CodeDoubanProject
prj = CodeDoubanProject.get_by_name(project_name)
if prj not in self.related_projects:
store.execute('insert into issue_related_projects '
'(issue_id, project_id) values(%s, %s)',
(self.issue_id, prj.id))
store.commit()
def main():
rs = store.execute("select id, project_id, issue_id, number from project_issues")
if rs:
for r in rs:
pi = ProjectIssue(*r)
pi.update_rank_score()
rs = store.execute("select id, team_id, issue_id, number from team_issues")
if rs:
for r in rs:
ti = TeamIssue(*r)
ti.update_rank_score()
def add_related_project(self, repo_url):
info = urlparse(repo_url)
project_name = info.path.strip('/')
from vilya.models.project import CodeDoubanProject
prj = CodeDoubanProject.get_by_name(project_name)
if prj not in self.related_projects:
store.execute(
'insert into issue_related_projects '
'(issue_id, project_id) values(%s, %s)',
(self.issue_id, prj.id))
store.commit()
def add(cls, user_id, target_id, kind, time=None):
time = datetime.now()
try:
store.execute('insert into user_fav '
'(user_id, target_id, kind, time) '
'values (%s, %s, %s, %s)',
(user_id, target_id, kind, time))
store.commit()
return True
except IntegrityError:
return False
def add(cls, user_id, target_id, kind, time=None):
time = datetime.now()
try:
store.execute(
'insert into user_fav '
'(user_id, target_id, kind, time) '
'values (%s, %s, %s, %s)', (user_id, target_id, kind, time))
store.commit()
return True
except IntegrityError:
return False
def get_badge_items(cls, item_id=None, kind=KIND_USER):
if item_id or kind != KIND_USER:
params = (item_id, kind)
rs = store.execute(
"select badge_id, item_id, reason, date from badge_item "
"where item_id=%s and kind=%s", params)
else:
rs = store.execute(
"select badge_id, item_id, reason, date from badge_item "
"order by date desc")
return [BadgeItem(*item) for item in rs]
def main():
try:
rs = store.execute("select project_id,owner_id from codedouban_projects")
for r in rs:
try:
store.execute("insert into codedouban_watches (project_id, user_id) "
"values (%s, %s)",
(r[0], r[1]))
except MySQLdb.IntegrityError, e:
print_exc()
store.commit()
def update(self,
description,
gist_names=[],
gist_contents=[],
gist_oids=[]):
name = self._get_name(gist_names)
store.execute(
"update gists set name=%s, description=%s, updated_at=%s where id=%s", # noqa
(name, description, datetime.now(), self.id))
store.commit()
self._commit_all_files(gist_names, gist_contents, gist_oids)
gist_updated_signal.send(self, gist_id=self.id)
def test_gist_stat(self):
store.execute("delete from gists where id < 20")
gist_rs = get_all_gist()
assert len(gist_rs) == 0
g1 = self._add_gist()
gist_rs = get_all_gist()
assert len(gist_rs) == 1
user_id = "testuser"
g1.fork(user_id)
gist_rs = get_all_gist()
assert len(gist_rs) == 2
assert len(filter(lambda x: x[1] != 0, gist_rs)) == 1
def add(cls, name, owner_id, summary='', product=None, fork_from=None,
create_trac=False, intern_banned=None, mirror=None):
# TODO: add project blacklist
assert ' ' not in name, "Cannot create a project with spacey name"
git_path = "%s.git" % name
try:
proj_id = store.execute(
"insert into codedouban_projects "
"(project_name, owner_id, summary, time, product, "
"git_path, trac_conf, fork_from, intern_banned) values "
"(%s, %s, %s, %s, %s, %s, %s, %s, %s)",
(name, owner_id, summary, datetime.now(),
product, git_path, name, fork_from, intern_banned))
except IntegrityError:
raise
return None
if fork_from is not None:
origins = store.execute("select origin_project from "
"codedouban_projects "
"where project_id=%s", fork_from)
origin_id, = origins[0]
else:
origin_id = proj_id
store.execute("update codedouban_projects set origin_project=%s "
"where project_id=%s", (origin_id, proj_id))
store.commit()
cls.clear_mc(proj_id)
project = cls.get(proj_id)
# TODO: split create_repo, fork_repo, mirror_repo
# create git repo
if fork_from:
orig_proj = cls.get(fork_from)
orig_proj.fork_repo(project)
elif mirror:
from queues_handler import mirror_projects_add
mirror_projects_add(mirror, git_path, proj_id)
else:
project.create_repo()
if not mirror:
project.update_hooks()
cls._flush_project_ids_by_owner(owner_id)
if fork_from:
repo_fork_signal.send(
project, project_id=proj_id, author=owner_id)
else:
repo_create_signal.send(
project, project_id=proj_id, creator=owner_id)
return project
def test_gist_stat(self):
store.execute("delete from gists where id < 20")
gist_rs = get_all_gist()
assert len(gist_rs) == 0
g1 = self._add_gist()
gist_rs = get_all_gist()
assert len(gist_rs) == 1
user_id = "testuser"
g1.fork(user_id)
gist_rs = get_all_gist()
assert len(gist_rs) == 2
assert len(filter(lambda x: x[1] != 0, gist_rs)) == 1
def add(cls, name, owner_id, summary='', product=None, fork_from=None,
create_trac=False, intern_banned=None, mirror=None):
# TODO: add project blacklist
assert ' ' not in name, "Cannot create a project with spacey name"
git_path = "%s.git" % name
try:
proj_id = store.execute(
"insert into codedouban_projects "
"(project_name, owner_id, summary, time, product, "
"git_path, trac_conf, fork_from, intern_banned) values "
"(%s, %s, %s, %s, %s, %s, %s, %s, %s)",
(name, owner_id, summary, datetime.now(),
product, git_path, name, fork_from, intern_banned))
except IntegrityError:
raise
return None
if fork_from is not None:
origins = store.execute("select origin_project from "
"codedouban_projects "
"where project_id=%s", fork_from)
origin_id, = origins[0]
else:
origin_id = proj_id
store.execute("update codedouban_projects set origin_project=%s "
"where project_id=%s", (origin_id, proj_id))
store.commit()
cls.clear_mc(proj_id)
project = cls.get(proj_id)
# TODO: split create_repo, fork_repo, mirror_repo
# create git repo
if fork_from:
orig_proj = cls.get(fork_from)
orig_proj.fork_repo(project)
elif mirror:
from queues_handler import mirror_projects_add
mirror_projects_add(mirror, git_path, proj_id)
else:
project.create_repo()
if not mirror:
project.update_hooks()
cls._flush_project_ids_by_owner(owner_id)
if fork_from:
repo_fork_signal.send(
project, project_id=proj_id, author=owner_id)
else:
repo_create_signal.send(
project, project_id=proj_id, creator=owner_id)
return project
def incr(cls, proj_id, count=None):
if count >= 0:
sql = ("insert into pullreq_counter (project_id, counter) "
"values (%s, LAST_INSERT_ID(%s)) on duplicate key "
"update counter = LAST_INSERT_ID(%s)")
id = store.execute(sql, (proj_id, count, count))
else:
sql = ("insert into pullreq_counter (project_id, counter) "
"values (%s, LAST_INSERT_ID(%s)) on duplicate key "
"update counter = LAST_INSERT_ID(counter + 1)")
id = store.execute(sql, (proj_id, 1))
store.commit()
return id