Coverage for bc/kwai-bc-training/src/kwai_bc_training/create_training.py: 100%

1"""Module for the use case "Create training".""" 

2 

3from kwai_core.domain.presenter import Presenter 

4from kwai_core.domain.value_objects.owner import Owner 

5from kwai_core.domain.value_objects.period import Period 

6from kwai_core.domain.value_objects.text import DocumentFormat, Locale, LocaleText 

7from kwai_core.domain.value_objects.timestamp import Timestamp 

8from kwai_core.domain.value_objects.unique_id import UniqueId 

9 

10from kwai_bc_training.coaches.coach_repository import CoachRepository 

11from kwai_bc_training.teams.team import TeamIdentifier 

12from kwai_bc_training.teams.team_repository import TeamRepository 

13from kwai_bc_training.training_command import TrainingCommand 

14from kwai_bc_training.trainings.training import TrainingCoachEntity, TrainingEntity 

15from kwai_bc_training.trainings.training_repository import TrainingRepository 

16from kwai_bc_training.trainings.training_schedule import ( 

17 TrainingScheduleIdentifier, 

18) 

19from kwai_bc_training.trainings.training_schedule_repository import ( 

20 TrainingScheduleRepository, 

21) 

22 

23 

24CreateTrainingCommand = TrainingCommand 

25 

26 

27class CreateTraining: 

28 """Use case for creating a training.""" 

29 

30 def __init__( 

31 self, 

32 repo: TrainingRepository, 

33 schema_repo: TrainingScheduleRepository, 

34 coach_repo: CoachRepository, 

35 team_repo: TeamRepository, 

36 owner: Owner, 

37 presenter: Presenter[TrainingEntity], 

38 ): 

39 """Initialize the use case. 

40 

41 Args: 

42 repo: The repository used to create the training. 

43 schema_repo: The repository for getting the training schedule. 

44 coach_repo: The repository for getting the coaches. 

45 team_repo: The repository for getting the teams. 

46 owner: The user that executes this use case. 

47 presenter: A presenter for a training. 

48 """ 

49 self._repo = repo 

50 self._schema_repo = schema_repo 

51 self._coach_repo = coach_repo 

52 self._team_repo = team_repo 

53 self._owner = owner 

54 self._presenter = presenter 

55 

56 async def execute(self, command: CreateTrainingCommand) -> None: 

57 """Execute the use case. 

58 

59 Args: 

60 command: The input for this use case. 

61 

62 Raises: 

63 TrainingSchemaNotFoundException: Raised when a training schedule cannot be found. 

64 """ 

65 if command.schedule: 

66 schedule = await self._schema_repo.get_by_id( 

67 TrainingScheduleIdentifier(command.schedule) 

68 ) 

69 else: 

70 schedule = None 

71 

72 if command.teams: 

73 teams = frozenset( 

74 [ 

75 entity 

76 async for entity in self._team_repo.get_by_ids( 

77 *[TeamIdentifier(team_id) for team_id in command.teams] 

78 ) 

79 ] 

80 ) 

81 else: 

82 teams = frozenset({}) 

83 

84 if command.coaches: 

85 coach_query = self._coach_repo.create_query().filter_by_uuids( 

86 *[UniqueId.create_from_string(coach.uuid) for coach in command.coaches] 

87 ) 

88 coaches = frozenset( 

89 [ 

90 TrainingCoachEntity(coach=coach, owner=self._owner) 

91 async for coach in self._coach_repo.get_all(coach_query) 

92 ] 

93 ) 

94 else: 

95 coaches = frozenset({}) 

96 

97 training = TrainingEntity( 

98 texts=tuple( 

99 [ 

100 LocaleText( 

101 locale=Locale(text.locale), 

102 format=DocumentFormat(text.format), 

103 title=text.title, 

104 content=text.content, 

105 summary=text.summary, 

106 author=self._owner, 

107 ) 

108 for text in command.texts 

109 ] 

110 ), 

111 schedule=schedule, 

112 coaches=coaches, 

113 teams=teams, 

114 period=Period( 

115 start_date=Timestamp.create_from_string(command.start_date), 

116 end_date=Timestamp.create_from_string(command.end_date), 

117 ), 

118 active=command.active, 

119 cancelled=command.cancelled, 

120 location=command.location, 

121 remark=command.remark, 

122 ) 

123 

124 self._presenter.present(await self._repo.create(training))