Coverage for apps/kwai-api/src/kwai_api/v1/teams/presenters.py: 100%

1"""Module for defining presenters of the teams api.""" 

2 

3from typing import Self 

4 

5from kwai_bc_teams.domain.team import TeamEntity 

6from kwai_bc_teams.domain.team_member import MemberEntity, TeamMember 

7from kwai_core.domain.presenter import AsyncPresenter, IterableResult, Presenter 

8from kwai_core.json_api import ( 

9 JsonApiPresenter, 

10 Meta, 

11 Relationship, 

12 RelationshipList, 

13 ResourceMeta, 

14) 

15 

16from kwai_api.schemas.resources import CountryResourceIdentifier, TeamResourceIdentifier 

17from kwai_api.v1.presenters import JsonApiCountryPresenter 

18from kwai_api.v1.teams.resources import TeamMemberResourceIdentifier 

19from kwai_api.v1.teams.schemas import ( 

20 TeamAttributes, 

21 TeamDocument, 

22 TeamMemberAttributes, 

23 TeamMemberDocument, 

24 TeamMemberRelationships, 

25 TeamMemberResource, 

26 TeamMembersDocument, 

27 TeamRelationships, 

28 TeamResource, 

29 TeamsDocument, 

30) 

31 

32 

33class JsonApiTeamMemberPresenter( 

34 JsonApiPresenter[TeamMemberDocument], 

35 Presenter[tuple[TeamMember, TeamEntity | None]], 

36): 

37 """A presenter that transforms a team member into a JSON:API document.""" 

38 

39 def present(self, use_case_result: tuple[TeamMember, TeamEntity | None]) -> Self: 

40 team_member, team = use_case_result 

41 

42 nationality_document = ( 

43 JsonApiCountryPresenter() 

44 .present(team_member.member.nationality) 

45 .get_document() 

46 ) 

47 

48 self._document = TeamMemberDocument( 

49 data=TeamMemberResource( 

50 id=str(team_member.member.uuid), 

51 attributes=TeamMemberAttributes( 

52 active=team_member.active, 

53 first_name=team_member.member.name.first_name, 

54 last_name=team_member.member.name.last_name, 

55 license_number=team_member.member.license.number, 

56 license_end_date=str(team_member.member.license.end_date), 

57 gender=team_member.member.gender, 

58 birthdate=str(team_member.member.birthdate), 

59 active_in_club=team_member.member.active_in_club, 

60 ), 

61 meta=ResourceMeta( 

62 created_at=str(team_member.traceable_time.created_at), 

63 updated_at=str(team_member.traceable_time.updated_at) 

64 if team_member.traceable_time.is_updated 

65 else None, 

66 ), 

67 relationships=TeamMemberRelationships( 

68 nationality=Relationship[CountryResourceIdentifier]( 

69 data=CountryResourceIdentifier(id=nationality_document.data.id), 

70 ), 

71 team=Relationship[TeamResourceIdentifier]( 

72 data=None 

73 if team is None 

74 else TeamResourceIdentifier(id=str(team.id)) 

75 ), 

76 ), 

77 ), 

78 included={nationality_document.data}, 

79 ) 

80 

81 return self 

82 

83 

84class JsonApiTeamMembersPresenter( 

85 JsonApiPresenter[TeamMembersDocument], Presenter[TeamEntity] 

86): 

87 """A presenter that transforms team members into a JSON:API document.""" 

88 

89 def present(self, team: TeamEntity) -> Self: 

90 self._document = TeamMembersDocument( 

91 meta=Meta(count=len(team.members), limit=0, offset=0), 

92 data=[], 

93 ) 

94 for member in team.members.values(): 

95 team_member_document = ( 

96 JsonApiTeamMemberPresenter().present((member, team)).get_document() 

97 ) 

98 self._document.data.append(team_member_document.data) 

99 self._document.included |= team_member_document.included 

100 

101 return self 

102 

103 

104class JsonApiTeamPresenter(JsonApiPresenter[TeamDocument], Presenter[TeamEntity]): 

105 """A presenter that transform a team entity into a JSON:API document.""" 

106 

107 def present(self, team: TeamEntity) -> Self: 

108 team_members_document = ( 

109 JsonApiTeamMembersPresenter().present(team).get_document() 

110 ) 

111 for team_member_resource in team_members_document.data: 

112 team_member_resource.relationships.team.data = None 

113 

114 self._document = TeamDocument( 

115 data=TeamResource( 

116 id=str(team.id), 

117 meta=ResourceMeta( 

118 created_at=str(team.traceable_time.created_at), 

119 updated_at=str(team.traceable_time.updated_at) 

120 if team.traceable_time.is_updated 

121 else None, 

122 ), 

123 attributes=TeamAttributes( 

124 name=team.name, active=team.active, remark=team.remark 

125 ), 

126 relationships=TeamRelationships( 

127 team_members=RelationshipList[TeamMemberResourceIdentifier]( 

128 data=[ 

129 TeamMemberResourceIdentifier(id=tm.id) 

130 for tm in team_members_document.data 

131 ] 

132 ) 

133 ), 

134 ), 

135 included={*team_members_document.data} | team_members_document.included, 

136 ) 

137 

138 return self 

139 

140 

141class JsonApiTeamsPresenter( 

142 JsonApiPresenter[TeamsDocument], AsyncPresenter[IterableResult[TeamEntity]] 

143): 

144 """A presenter that transforms an iterator of teams into a JSON:API document.""" 

145 

146 async def present(self, result: IterableResult[TeamEntity]) -> Self: 

147 self._document = TeamsDocument( 

148 meta=Meta(count=result.count, offset=result.offset, limit=result.limit), 

149 ) 

150 async for team in result.iterator: 

151 team_document = JsonApiTeamPresenter().present(team).get_document() 

152 self._document.data.append(team_document.data) 

153 self._document.included |= team_document.included 

154 return self 

155 

156 

157class JsonApiMembersPresenter( 

158 JsonApiPresenter[TeamMembersDocument], AsyncPresenter[IterableResult[MemberEntity]] 

159): 

160 """A presenter that transforms an iterator of members into a TeamMember document.""" 

161 

162 async def present(self, result: IterableResult[MemberEntity]) -> Self: 

163 self._document = TeamMembersDocument( 

164 meta=Meta(count=result.count, offset=result.offset, limit=result.limit), 

165 ) 

166 async for member in result.iterator: 

167 team_member_document = ( 

168 JsonApiTeamMemberPresenter() 

169 .present((TeamMember(member=member), None)) 

170 .get_document() 

171 ) 

172 self._document.data.append(team_member_document.data) 

173 self._document.included |= team_member_document.included 

174 return self