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 __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 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_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 __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 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 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_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 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