def _get_issue_comment_by_uid(uid):
issue = {}
# uid: issue-type-id-number
if uid and uid.startswith('issue-'):
fields = uid.split('-')
if len(fields) != 6:
return issue
_, _, type, id, number, comment_number = fields
if type == 'project':
_issue = ProjectIssue.get(id, number=number)
_issue = Issue.get_cached_issue(_issue.issue_id)
_target = _get_project_by_name(_issue.target.name)
elif type == 'team':
_issue = TeamIssue.get(id, number=number)
_issue = Issue.get_cached_issue(_issue.issue_id)
_target = _get_team_by_uid(_issue.target.uid)
else:
return issue
_author = _get_user_by_name(_issue.creator_id)
_closer = _get_user_by_name(_issue.closer_id) if _issue.closer_id else {}
issue = dict(
id=_issue.issue_id,
name=_issue.title,
author=_author,
closer=_closer,
)
issue[_issue.target_type] = _target
return issue
def __init__(self,
id,
team_id,
issue_id,
number,
title=None,
creator=None,
assignee=None,
closer=None,
created_at=None,
updated_at=None,
closed_at=None,
type=''):
Issue.__init__(self,
issue_id,
title,
creator,
assignee,
closer,
created_at,
updated_at,
closed_at,
type=type,
target_id=team_id)
self.id = id
self.team_id = team_id
self.issue_id = issue_id
self.number = number
def test_issue_stat(self):
issue_rs = get_all_issue()
assert len(issue_rs) == 0
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 0
assert len(issue_rs) - issue_open_count == 0
i1 = Issue.add('test1', 'test des1', 'testuser1', 'assignee')
issue_rs = get_all_issue()
assert len(issue_rs) == 1
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 1
assert len(issue_rs) - issue_open_count == 0
i2 = Issue.add('test2', 'test des1', 'testuser1', 'assignee')
i3 = Issue.add('test3', 'test des1', 'testuser2', 'assignee')
issue_rs = get_all_issue()
assert len(issue_rs) == 3
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 3
assert len(issue_rs) - issue_open_count == 0
i1.close('testuser1')
issue_rs = get_all_issue()
assert len(issue_rs) == 3
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 2
assert len(issue_rs) - issue_open_count == 1
issue_comment_count = get_issue_comment_count()
assert issue_comment_count == 0
IssueComment.add(i2.id, 'content', 'test')
IssueComment.add(i3.id, 'content', 'test1')
issue_comment_count = get_issue_comment_count()
assert issue_comment_count == 2
def assign(self, user_id):
Issue.assign(self, user_id)
self.clear_cache()
mc.delete(MC_KEY_PROJECT_ISSUE_ASSIGNEE_N %
(self.project_id, user_id, 'open'))
mc.delete(MC_KEY_PROJECT_ISSUE_ASSIGNEE_N %
(self.project_id, user_id, 'closed'))
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 __init__(
self,
id,
project_id,
issue_id,
number,
title=None,
creator=None,
assignee=None,
closer=None,
created_at=None,
updated_at=None,
closed_at=None,
type="",
):
Issue.__init__(
self,
issue_id,
title,
creator,
assignee,
closer,
created_at,
updated_at,
closed_at,
type=type,
target_id=project_id,
)
self.id = id
self.project_id = project_id
self.issue_id = issue_id
self.number = number
def assign(self, user_id):
Issue.assign(self, user_id)
self.clear_cache()
mc.delete(MC_KEY_PROJECT_ISSUE_ASSIGNEE_N % (
self.project_id, user_id, 'open'))
mc.delete(MC_KEY_PROJECT_ISSUE_ASSIGNEE_N % (
self.project_id, user_id, 'closed'))
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 test_update_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
i.update("test1", "test1 description")
i = Issue.get(i.id)
assert i.title == 'test1'
assert i.description == 'test1 description'
assert i.creator_id == 'test'
assert i.assignee_id == 'assignee'
assert i.closer_id is None
def test_close_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
i.close("test")
i = Issue.get(i.id)
assert i.title == 'test'
assert i.description == 'test description'
assert i.creator_id == 'test'
assert i.closer_id == "test"
assert i.assignee_id == 'assignee'
def test_update_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
i.update("test1", "test1 description")
i = Issue.get(i.id)
assert i.title == 'test1'
assert i.description == 'test1 description'
assert i.creator_id == 'test'
assert i.assignee_id == 'assignee'
assert i.closer_id is None
def test_close_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
i.close("test")
i = Issue.get(i.id)
assert i.title == 'test'
assert i.description == 'test description'
assert i.creator_id == 'test'
assert i.closer_id == "test"
assert i.assignee_id == 'assignee'
def __init__(self, id, team_id, issue_id, number, title=None,
creator=None, assignee=None, closer=None,
created_at=None, updated_at=None, closed_at=None,
type=''):
Issue.__init__(self, issue_id, title, creator, assignee, closer,
created_at, updated_at, closed_at, self.target_type)
self.number = self.id
from vilya.models.fair import FAIR_ID
self.team_id = FAIR_ID
def __init__(self, id, team_id, issue_id, number, title=None,
creator=None, assignee=None, closer=None,
created_at=None, updated_at=None, closed_at=None, type=''):
Issue.__init__(self, issue_id, title,
creator, assignee, closer,
created_at, updated_at, closed_at, type=type,
target_id=team_id)
self.id = id
self.team_id = team_id
self.issue_id = issue_id
self.number = number
def test_closed_issue_should_not_vote(self):
self.test_team_issue.close(self.testuser1)
self.test_team_issue = Issue.get_cached_issue(
self.test_team_issue.issue_id)
count = self.test_team_issue.upvote_by_user(self.testuser2)
assert count == 0
self.test_project_issue.close(self.testuser1)
self.test_project_issue = Issue.get_cached_issue(
self.test_project_issue.issue_id)
count = self.test_project_issue.upvote_by_user(self.testuser2)
assert count == 0
def test_closed_issue_should_not_vote(self):
self.test_team_issue.close(self.testuser1)
self.test_team_issue = Issue.get_cached_issue(
self.test_team_issue.issue_id)
count = self.test_team_issue.upvote_by_user(self.testuser2)
assert count == 0
self.test_project_issue.close(self.testuser1)
self.test_project_issue = Issue.get_cached_issue(
self.test_project_issue.issue_id)
count = self.test_project_issue.upvote_by_user(self.testuser2)
assert count == 0
def test_add_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
assert isinstance(i, Issue)
assert i.title == 'test'
assert i.description == 'test description'
assert i.creator_id == 'test'
assert i.assignee_id == 'assignee'
def test_add_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
assert isinstance(c, IssueComment)
assert c.issue_id == i.id
assert c.content == 'content'
assert c.author_id == 'test'
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=team)
if issue and team:
number = TICounter.incr(team, number)
team_issue_id = store.execute(
'insert into team_issues (team_id, issue_id, number) '
'values (%s, %s, %s)', (team, issue.id, number))
store.commit()
return cls(team_issue_id, team, issue.id, number, title, creator,
assignee, closer, issue.created_at, issue.updated_at)
def get_by_proj_name_and_number(cls, proj_name, number):
from vilya.models.project import CodeDoubanProject
project = CodeDoubanProject.get_by_name(proj_name)
project_issue = cls.get(project.id, number=number)
issue_id = project_issue.issue_id
return Issue.get_cached_issue(issue_id)
def _gets_by_people_id(cls, project, people_id, state, type):
ids = cls._get_ids_by_project_id(project, order='updated_at',
state=state)
issues = Issue.get_cached_issues(ids)
issues = [issue for issue in issues
if getattr(issue, type) == people_id]
return issues
def get_participated_issues(cls, user_id, state=None):
from vilya.models.issue import Issue
issues_created = cls.gets_by_creator_id(user_id, state)
issues = [issue for issue in Issue.gets_by_participated_user(user_id,
state)
if issue not in issues_created]
return issues
def get_multi_by(cls, *a, **kw):
""" A wrapper to get project issues """
# args
issue_ids = kw.get('issue_ids')
project = kw.get('project')
creator = kw.get('creator')
assignee = kw.get('assignee')
state = kw.get('state')
start = kw.get('start')
limit = kw.get('limit')
milestone = kw.get('milestone')
tags = kw.get('tags')
order = kw.get('order')
ids = None
# get ids
issue_ids = cls._get_ids_by_project_id(
project.id, order=order,
state=state) if not issue_ids else issue_ids
if milestone:
ids = set(issue_ids) & set(milestone.issue_ids)
if tags:
ids = set(issue_ids) if not ids else ids
for tag in tags:
ids = ids & set(tag.project_issue_ids)
if ids is not None:
issue_ids = filter(lambda x: x in ids, issue_ids)
issues = Issue.get_cached_issues(issue_ids)
# filter
if assignee:
issues = filter(lambda x: x.assignee_id == assignee.name, issues)
if creator:
issues = filter(lambda x: x.creator_id == creator.name, issues)
return dict(issues=issues[start:start + limit], total=len(issues))
def __init__(self, issue_id):
self.target = get_fair()
self.issue_number = issue_id # fair issue 直接拿 issue_id 当 number
self.issue_id = issue_id
self.issue = Issue.get_cached_issue(issue_id)
self.issue_template = 'issue/team_issue.html'
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='fair',
target_id=team)
if issue:
number = issue.id
'''
team_issue_id = store.execute(
'insert into team_issues (team_id, issue_id, number) '
'values (%s, %s, %s)',
(team, issue.id, number))
store.commit()
'''
return cls(issue.id, team, issue.id, number, title, creator,
assignee, closer, issue.created_at, issue.updated_at)
def test_add_issue(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
assert isinstance(i, Issue)
assert i.title == 'test'
assert i.description == 'test description'
assert i.creator_id == 'test'
assert i.assignee_id == 'assignee'
def test_add_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
assert isinstance(c, IssueComment)
assert c.issue_id == i.id
assert c.content == 'content'
assert c.author_id == 'test'
def get_multi_by(cls, *a, **kw):
""" A wrapper to get project issues """
# args
issue_ids = kw.get('issue_ids')
project = kw.get('project')
creator = kw.get('creator')
assignee = kw.get('assignee')
state = kw.get('state')
start = kw.get('start')
limit = kw.get('limit')
milestone = kw.get('milestone')
tags = kw.get('tags')
order = kw.get('order')
ids = None
# get ids
issue_ids = cls._get_ids_by_project_id(
project.id, order=order,
state=state) if not issue_ids else issue_ids
if milestone:
ids = set(issue_ids) & set(milestone.issue_ids)
if tags:
ids = set(issue_ids) if not ids else ids
for tag in tags:
ids = ids & set(tag.project_issue_ids)
if ids is not None:
issue_ids = filter(lambda x: x in ids, issue_ids)
issues = Issue.get_cached_issues(issue_ids)
# filter
if assignee:
issues = filter(lambda x: x.assignee_id == assignee.name, issues)
if creator:
issues = filter(lambda x: x.creator_id == creator.name, issues)
return dict(issues=issues[start:start + limit], total=len(issues))
def __init__(self, issue_id):
self.target = get_fair()
self.issue_number = issue_id # fair issue 直接拿 issue_id 当 number
self.issue_id = issue_id
self.issue = Issue.get_cached_issue(issue_id)
self.issue_template = 'issue/team_issue.html'
def test_update_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
c.update('content1')
c = IssueComment.get(c.id)
assert c.issue_id == i.id
assert c.content == 'content1'
assert c.author_id == 'test'
def __init__(self, team_uid, issue_number):
self.target = Team.get_by_uid(team_uid)
self.issue_number = issue_number
team_issue = TeamIssue.get(self.target.id, number=self.issue_number)
self.issue_id = team_issue.issue_id
self.issue = Issue.get_cached_issue(self.issue_id)
self.issue_template = 'issue/team_issue.html'
def get_by_issue_id(cls, issue_id):
issue = Issue.get(issue_id)
if issue:
from vilya.models.fair import FAIR_ID
return cls(id, FAIR_ID, issue.id, issue.id, issue.title,
issue.creator_id, issue.assignee_id, issue.closer_id,
issue.created_at, issue.updated_at, issue.closed_at,
issue.type)
def __init__(self, team_uid, issue_number):
self.target = Team.get_by_uid(team_uid)
self.issue_number = issue_number
team_issue = TeamIssue.get(self.target.id, number=self.issue_number)
self.issue_id = team_issue.issue_id
self.issue = Issue.get_cached_issue(self.issue_id)
self.issue_template = "issue/team_issue.html"
def test_update_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
c.update('content1')
c = IssueComment.get(c.id)
assert c.issue_id == i.id
assert c.content == 'content1'
assert c.author_id == 'test'
def get_by_issue_id(cls, issue_id):
issue = Issue.get(issue_id)
if issue:
from vilya.models.fair import FAIR_ID
return cls(id, FAIR_ID, issue.id, issue.id, issue.title,
issue.creator_id, issue.assignee_id, issue.closer_id,
issue.created_at, issue.updated_at, issue.closed_at,
issue.type)
def __init__(self,
id,
team_id,
issue_id,
number,
title=None,
creator=None,
assignee=None,
closer=None,
created_at=None,
updated_at=None,
closed_at=None,
type=''):
Issue.__init__(self, issue_id, title, creator, assignee, closer,
created_at, updated_at, closed_at, self.target_type)
self.number = self.id
from vilya.models.fair import FAIR_ID
self.team_id = FAIR_ID
def __init__(self, proj_name, issue_number):
self.target = CodeDoubanProject.get_by_name(proj_name)
self.issue_number = issue_number
project_issue = ProjectIssue.get(self.target.id,
number=self.issue_number)
self.issue_id = project_issue.issue_id
self.issue = Issue.get_cached_issue(self.issue_id)
self.issue_template = 'issue/issue.html'
def __init__(self, proj_name, issue_number):
self.target = CodeDoubanProject.get_by_name(proj_name)
self.issue_number = issue_number
project_issue = ProjectIssue.get(self.target.id,
number=self.issue_number)
self.issue_id = project_issue.issue_id
self.issue = Issue.get_cached_issue(self.issue_id)
self.issue_template = 'issue/issue.html'
def _gets_by_people_id(cls, project, people_id, state, type):
ids = cls._get_ids_by_project_id(project,
order='updated_at',
state=state)
issues = Issue.get_cached_issues(ids)
issues = [
issue for issue in issues if getattr(issue, type) == people_id
]
return issues
def gets_by_project_ids(cls, project_ids, state=None, limit=25, start=0):
data = []
for id in project_ids:
data.extend(cls.get_data_by_target(id))
data = filter_issue_ids_by_state(data, state)
data = filter_issue_ids_by_score(data, 'updated_at')
data = data[start:start + limit]
ids = [issue_id for (issue_id, _, _, _) in data]
return Issue.get_cached_issues(ids)
def gets_by_project_ids(cls, project_ids, state=None, limit=25, start=0):
data = []
for id in project_ids:
data.extend(cls.get_data_by_target(id))
data = filter_issue_ids_by_state(data, state)
data = filter_issue_ids_by_score(data, 'updated_at')
data = data[start:start + limit]
ids = [issue_id for (issue_id, _, _, _) in data]
return Issue.get_cached_issues(ids)
def delete(self, request):
user = request.user
if self.comment.author_id != user.username:
raise AccessError
issue_id = self.comment.issue_id
ok = self.comment.delete()
if not ok:
return {'r': 0}
pissue = Issue.get_cached_issue(issue_id)
pissue.update_rank_score()
return {'r': 1}
def get_n_by_issue_ids(cls, issue_ids, state=None):
if not state:
return len(issue_ids)
else:
issues = Issue.get_cached_issues(issue_ids)
open_issues = [issue for issue in issues if issue and not issue.is_closed]
close_issues = [issue for issue in issues if issue and issue.is_closed]
if state == "open":
return len(open_issues)
else:
return len(close_issues)
def delete(self, request):
user = request.user
if self.comment.author_id != user.username:
raise AccessError
issue_id = self.comment.issue_id
ok = self.comment.delete()
if not ok:
return {'r': 0}
pissue = Issue.get_cached_issue(issue_id)
pissue.update_rank_score()
return {'r': 1}
def get_by_issue_id(cls, issue_id):
sql = ("select id, team_id, issue_id, number from team_issues "
"where issue_id = %s ")
rs = store.execute(sql, (issue_id,))
if rs and rs[0]:
id, team_id, issue_id, number = rs[0]
issue = Issue.get(issue_id)
if issue:
return cls(id, team_id, issue.id, number, issue.title,
issue.creator_id, issue.assignee_id,
issue.closer_id, issue.created_at, issue.updated_at,
issue.closed_at, issue.type)
def get_by_issue_id(cls, issue_id):
sql = ("select id, team_id, issue_id, number from team_issues "
"where issue_id = %s ")
rs = store.execute(sql, (issue_id, ))
if rs and rs[0]:
id, team_id, issue_id, number = rs[0]
issue = Issue.get(issue_id)
if issue:
return cls(id, team_id, issue.id, number, issue.title,
issue.creator_id, issue.assignee_id,
issue.closer_id, issue.created_at, issue.updated_at,
issue.closed_at, issue.type)
def test_get_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
c = IssueComment.get(c.id)
assert isinstance(c, IssueComment)
assert c.issue_id == i.id
assert c.content == 'content'
assert c.author_id == 'test'
c = IssueComment.add(i.id, 'content', 'test')
cs = IssueComment.gets_by_issue_id(i.id)
assert all([isinstance(t, IssueComment) for t in cs])
assert len(cs) == 2
def _get_issue_by_project_and_number(id, number):
issue = {}
project_issue = ProjectIssue.get(id, number=number)
_issue = Issue.get_cached_issue(project_issue.issue_id)
_author = _get_user_by_name(_issue.creator_id)
_closer = _get_user_by_name(_issue.closer_id) if _issue.closer_id else {}
issue = dict(
id=_issue.issue_id,
name=_issue.title,
author=_author,
closer=_closer,
)
return issue
def test_get_comment(self):
i = Issue.add('test', 'test description', 'test', 'assignee')
c = IssueComment.add(i.id, 'content', 'test')
c = IssueComment.get(c.id)
assert isinstance(c, IssueComment)
assert c.issue_id == i.id
assert c.content == 'content'
assert c.author_id == 'test'
c = IssueComment.add(i.id, 'content', 'test')
cs = IssueComment.gets_by_issue_id(i.id)
assert all([isinstance(t, IssueComment) for t in cs])
assert len(cs) == 2
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=team)
if issue and team:
number = TICounter.incr(team, number)
team_issue_id = store.execute(
'insert into team_issues (team_id, issue_id, number) '
'values (%s, %s, %s)',
(team, issue.id, number))
store.commit()
return cls(team_issue_id, team, issue.id, number, title, creator,
assignee, closer, issue.created_at, issue.updated_at)
def test_issue_stat(self):
issue_rs = get_all_issue()
store.execute("delete from issues where id < 20")
assert len(issue_rs) == 0
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 0
assert len(issue_rs) - issue_open_count == 0
i1 = Issue.add('test1', 'test des1', 'testuser1', 'assignee')
issue_rs = get_all_issue()
assert len(issue_rs) == 1
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 1
assert len(issue_rs) - issue_open_count == 0
i2 = Issue.add('test2', 'test des1', 'testuser1', 'assignee')
i3 = Issue.add('test3', 'test des1', 'testuser2', 'assignee')
issue_rs = get_all_issue()
assert len(issue_rs) == 3
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 3
assert len(issue_rs) - issue_open_count == 0
i1.close('testuser1')
issue_rs = get_all_issue()
assert len(issue_rs) == 3
issue_open_count = len(filter(lambda x: x[1] is None, issue_rs))
assert issue_open_count == 2
assert len(issue_rs) - issue_open_count == 1
issue_comment_count = get_issue_comment_count()
assert issue_comment_count == 0
IssueComment.add(i2.id, 'content', 'test')
IssueComment.add(i3.id, 'content', 'test1')
issue_comment_count = get_issue_comment_count()
assert issue_comment_count == 2
def get_n_by_issue_ids(cls, issue_ids, state=None):
if not state:
return len(issue_ids)
else:
issues = Issue.get_cached_issues(issue_ids)
open_issues = [
issue for issue in issues if issue and not issue.is_closed
]
close_issues = [
issue for issue in issues if issue and issue.is_closed
]
if state == "open":
return len(open_issues)
else:
return len(close_issues)
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='fair', target_id=team)
if issue:
number = issue.id
'''
team_issue_id = store.execute(
'insert into team_issues (team_id, issue_id, number) '
'values (%s, %s, %s)',
(team, issue.id, number))
store.commit()
'''
return cls(issue.id, team, issue.id, number, title, creator,
assignee, closer, issue.created_at, issue.updated_at)
def test_get_issue(self):
p = ProjectIssue.add('test', 'test description', 'test', project=1)
r = ProjectIssue.get(p.project_id, issue_id=p.issue_id)
assert isinstance(r, ProjectIssue)
assert r.project_id == 1
r = ProjectIssue.get(p.project_id, number=p.number)
assert isinstance(r, ProjectIssue)
assert r.project_id == 1
r = Issue.get_cached_issue(p.issue_id)
assert isinstance(r, ProjectIssue)
assert r.title == 'test'
assert r.description == 'test description'
assert r.project_id == 1
p2 = ProjectIssue.add(
'test2', 'test2 description', 'test', project=1,
assignee='assignee')
p3 = ProjectIssue.add(
'test3', 'test3 description', 'test', project=1,
assignee='assignee')
p4 = ProjectIssue.add(
'test4', 'test4 description', 'test', project=1, assignee='test')
p5 = ProjectIssue.add(
'test5', 'test5 description', 'test1', project=2, assignee='test')
rs = ProjectIssue._gets_by_project_id(1)
assert len(rs) == 4
rs = ProjectIssue._get_issues_by_project_id(1)
assert all([isinstance(i, ProjectIssue) for i in rs])
assert len(rs) == 4
rs = ProjectIssue.gets_by_assignee_id(1, 'assignee')
assert all([isinstance(i, ProjectIssue) for i in rs])
assert len(rs) == 2
rs = ProjectIssue.gets_by_creator_id(1, 'test')
assert all([isinstance(i, ProjectIssue) for i in rs])
assert len(rs) == 4
for p in [p, p2, p3, p4, p5]:
p.delete()
def patch(self, request):
issue = Issue.get_cached_issue(self.project_issue.issue_id)
if self.user.username != issue.creator_id:
raise api_errors.NotTheAuthorError('project issue', 'edit')
data = request.data
state = data.get("state")
if state in ("open", "closed") and state != issue.state:
if state == "open":
issue.open(self.user.username)
else:
issue.close(self.user.username)
title = data.get("title")
title = title if title else issue.title
description = data.get("description")
description = description if description else issue.description
issue.update(title, description)
new_issue = ProjectIssue.get(project_id=self.project.id,
number=self.issue_number)
return new_issue.as_dict()
def test_get_issue(self):
issue1 = Issue.add('test1', 'test1 description', 'test', 'assignee')
issue2 = Issue.add('test2', 'test2 description', 'test', 'assignee')
issue2.close("test")
i1 = Issue.get(issue1.id)
assert isinstance(i1, Issue)
assert i1.title == 'test1'
assert i1.description == 'test1 description'
assert i1.creator_id == 'test'
assert i1.assignee_id == 'assignee'
assert i1.closer_id is None
i2 = Issue.get(issue2.id)
assert isinstance(i2, Issue)
assert i2.title == 'test2'
assert i2.description == 'test2 description'
assert i2.creator_id == 'test'
assert i2.assignee_id == 'assignee'
assert i2.closer_id == 'test'
i1 = Issue.get(issue1.id)
assert isinstance(i1, Issue)
assert i1.title == 'test1'
assert i1.description == 'test1 description'
assert i1.creator_id == 'test'
assert i1.assignee_id == 'assignee'
assert i1.closer_id is None
iss = Issue.gets_by_creator_id("test")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 4
iss = Issue.gets_by_creator_id("test", "open")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 4
iss = Issue.gets_by_creator_id("test", "closed")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 2
iss = Issue.gets_by_assignee_id("assignee")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 6
iss = Issue.gets_by_assignee_id("assignee", "open")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 4
iss = Issue.gets_by_assignee_id("assignee", "closed")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 2
iss = Issue.gets_by_closer_id("test")
assert all([isinstance(i, Issue) for i in iss])
assert len(iss) == 2
