@startuml
' skinparam linetype ortho
' skinparam groupInheritance 2
allowmixing

package authentication_api <<Frame>> {
	
	package controller as auth.controller <<Frame>> {
	
		class AuthenticationController <<@RestController>> {
		  + <<create>> AuthenticationController(AuthenticationService, EMailConfigProperties): 
		  + logout(String, HttpServletResponse): HttpStatus
		  + registerUser(UserInfoRequest): HttpStatus
		  + forgotPassword(String): HttpStatus
		  + getDeviceList(String, HttpServletResponse): ResponseEntity<List<DeviceWrapper>>
		  + login(String, HttpServletResponse): HttpStatus
		  + deleteUser(String, PasswordRequest): HttpStatus
		  + changePassword(String, ChangePasswordRequest): HttpStatus
		  + verifyRegistration(String, String, HttpServletResponse): HttpStatus
		  + resetPassword(String, String, PasswordRequest): HttpStatus
		}
		
		entity AuthenticationResponse << record >> {
		  + <<create>> AuthenticationResponse(String): 
		  + token(): String
		}
		
		entity ChangePasswordRequest << record >> {
		  + <<create>> ChangePasswordRequest(String, String): 
		  + oldPassword(): String
		  + newPassword(): String
		}
		
		entity DeviceWrapper << record >> {
		  + <<create>> DeviceWrapper(): 
		  + <<create>> DeviceWrapper(String, String, String, int): 
		  + id(): String
		  + caption(): String
		  + type(): String
		  + subscriptions(): int
		}
		
		entity ForgotPasswordRequest << record >> {
		  + <<create>> ForgotPasswordRequest(String): 
		  + email(): String
		}
		
		entity PasswordRequest << record >> {
		  + <<create>> PasswordRequest(String): 
		  + password(): String
		}
		
		entity UserInfoRequest << record >> {
		  + <<create>> UserInfoRequest(String, String, String): 
		  + password(): String
		  + email(): String
		  + username(): String
		}
	}
	
	package data_access as auth.dao <<Frame>> {
	
		interface AuthenticationDao <<@Repository>> {
		  + findByEmail(String): Optional<User>
		  + deleteAllByEnabledFalseAndCreatedAtLessThan(long): void
		  + existsByUsername(String): boolean
		  + findByUsername(String): Optional<User>
		}
	}
	
	package service as auth.service <<Frame>> {
	
		class AuthenticationService <<@Service>> {
		  + <<create>> AuthenticationService(AuthenticationDao, PasswordEncoder, JwtService, EMailServiceImpl, EncryptionService, InputCheckService): 
		  + verifyRegistration(String, String): HttpStatus
		  + logout(String, HttpServletResponse): HttpStatus
		  + changePassword(String, ChangePasswordRequest): HttpStatus
		  + registerUser(UserInfoRequest): HttpStatus
		  + deleteUser(String, PasswordRequest): HttpStatus
		  + forgotPassword(String): HttpStatus
		  + resetPassword(String, String, PasswordRequest): HttpStatus
		  + deleteInvalidUsersOlderThan(long): void
		  + login(String, HttpServletResponse): HttpStatus
		}
		
		class EMailServiceImpl <<@Service>> {
		  + <<create>> EMailServiceImpl(JavaMailSender, EMailConfigProperties, JwtService): 
		  - substitutePlaceholders(String, UserDetails, String): String
		  + sendVerification(String, UserDetails): void
		  + sendPasswordReset(String, UserDetails): void
		  - generatePasswordResetURLString(UserDetails): String
		  - sendMail(String, String, String): void
		  - generateVerificationURLString(UserDetails): String
		}
		
		class EncryptionService <<@Service>> {
		  + <<create>> EncryptionService(SecurityConfigProperties): 
		  + saltAndHashEmail(String): String
		  - getSalt(): byte[]
		}
		
		class InputCheckService <<@Service>> {
		  + <<create>> InputCheckService(): 
		  + validateEmail(String): boolean
		  + validateUsername(String): boolean
		  + validatePassword(String): boolean
		}
		
		class ResourceReader {
		  + <<create>> ResourceReader(): 
		  + readFileToString(String): String
		}
	}
}

package config <<Frame>> {

	class ApplicationConfig <<@Configuration>> {
	  + <<create>> ApplicationConfig(AuthenticationDao): 
	  + userDetailsService(): UserDetailsService
	  + addInterceptors(InterceptorRegistry): void
	  + authenticationManager(AuthenticationConfiguration): AuthenticationManager
	  + passwordEncoder(): PasswordEncoder
	  + corsConfigurer(): WebMvcConfigurer
	  + authenticationProvider(): AuthenticationProvider
	}
	
	class AuthenticationValidatorInterceptor {
	  + <<create>> AuthenticationValidatorInterceptor(): 
	  - extractUsernamePathVariable(HttpServletRequest): String?
	  + preHandle(HttpServletRequest, HttpServletResponse, Object): boolean
	}
	
	entity EMailConfigProperties << record >> {
	  + <<create>> EMailConfigProperties(String, String, String): 
	  + resetUrlPath(): String
	  + verificationUrl(): String
	  + dashboardBaseUrl(): String
	}
	
	class JwtAuthenticationFilter <<@Component>> {
	  + <<create>> JwtAuthenticationFilter(JwtService, UserDetailsService): 
	  # doFilterInternal(HttpServletRequest, HttpServletResponse, FilterChain): void
	  - authenticateIfValid(Cookie, HttpServletRequest): void
	}
	
	class JwtService <<@Service>> {
	  + <<create>> JwtService(SecurityConfigProperties): 
	  + generateUrlTokenString(UserDetails): String
	  + isTokenValid(String, UserDetails): boolean
	  + generateAccessTokenString(UserDetails): String
	  + extractUsername(String): String
	  + extractClaim(String, Function<Claims, T>): T
	  - isTokenExpired(String): boolean
	  + generateTokenString(Map<String, Object>, UserDetails, long): String
	  - extractExpiration(String): Date
	  - extractAllClaims(String): Claims
	  - getSigningKey(): Key
	}
	
	class SecurityConfig <<@Configuration>> {
	  + <<create>> SecurityConfig(JwtAuthenticationFilter, AuthenticationProvider): 
	  ~ corsConfigurationSource(): CorsConfigurationSource
	  + securityFilterChain(HttpSecurity): SecurityFilterChain
	}
	
	entity SecurityConfigProperties << record >> {
	  + <<create>> SecurityConfigProperties(String, String): 
	  + jwtSigningKey(): String
	  + emailSigningKey(): String
	}
}

package episode_actions_api <<Frame>> {

	package controller as episode.controller <<Frame>> {
	
		class EpisodeActionController <<@RestController>> {
		  + <<create>> EpisodeActionController(EpisodeActionService): 
		  + addEpisodeActions(String, List<EpisodeActionPost>): ResponseEntity<UpdateURLsWrapper>
		  + getEpisodeActionsOfPodcast(String, String): ResponseEntity<EpisodeActionGetResponse>
		  + getEpisodeActions(String): ResponseEntity<EpisodeActionGetResponse>
		  + getEpisodeActionsSince(String, long): ResponseEntity<EpisodeActionGetResponse>
		  + getEpisodeActionsOfPodcastSince(String, String, long): ResponseEntity<EpisodeActionGetResponse>
		}
		
		class EpisodeActionGetResponse {
		  + <<create>> EpisodeActionGetResponse(List<EpisodeActionPost>): 
		  + getTimestamp(): long
		  + getActions(): List<EpisodeActionPost>
		}
		
		class EpisodeActionPost {
		  + <<create>> EpisodeActionPost(): 
		  + <<create>> EpisodeActionPost(String, String, String, String, int, EpisodeAction): 
		  + equals(Object): boolean
		  + hashCode(): int
		  + builder(): EpisodeActionPostBuilder
		  + getPodcastURL(): String
		  + getEpisodeURL(): String
		  + getTitle(): String
		  + getGuid(): String
		  + setGuid(String): void
		  + setEpisodeAction(EpisodeAction): void
		  + setTotal(int): void
		  + getTotal(): int
		  + setTitle(String): void
		  # canEqual(Object): boolean
		  + getEpisodeAction(): EpisodeAction
		  + toString(): String
		  + setPodcastURL(String): void
		  + setEpisodeURL(String): void
		}
	}
	
	package data_access as episode.dao <<Frame>> {
	
		interface EpisodeActionDao <<@Repository>> {
		  + findByUserUsernameAndEpisodeSubscriptionUrl(String, String): List<EpisodeAction>
		  + delete(EpisodeAction): void
		  + findByUserUsernameAndTimestampGreaterThanEqual(String, LocalDateTime): List<EpisodeAction>
		  + findByUserUsername(String): List<EpisodeAction>
		  + findByUserAndEpisodeUrlAndAction(User, String, Action): Optional<EpisodeAction>
		  + findByUserUsernameAndTimestampGreaterThanEqualAndEpisodeSubscriptionUrl(String, LocalDateTime, String): List<EpisodeAction>
		  + deleteByUserUsernameAndEpisodeSubscriptionUrl(String, String): void
		  + existsByUserAndEpisodeUrlAndAction(User, String, Action): boolean
		}
		
		interface EpisodeDao <<@Repository>> {
		  + existsByGuid(String): boolean
		  + findByUrl(String): Optional<Episode>
		  + existsByUrl(String): boolean
		  + findByGuid(String): Optional<Episode>
		}
	}
	
	package service as episode.service <<Frame>> {
		
		class EpisodeActionService <<@Service>> {
		  + <<create>> EpisodeActionService(EpisodeActionDao, EpisodeDao, AuthenticationDao, SubscriptionDao, SubscriptionActionDao, RSSParser): 
		  - episodeActionPostsToEpisodeActions(User, List<EpisodeActionPost>): List<EpisodeAction>
		  - createEpisode(EpisodeActionPost): Episode
		  + getEpisodeActionsOfPodcastSince(String, String, long): List<EpisodeActionPost>
		  - getEpisodeFromDatabase(EpisodeActionPost): Episode
		  - addEpisodeActionsToDatabase(User, List<EpisodeAction>): void
		  - addNewestEpisodeActionToDatabase(User, EpisodeAction): void
		  - episodeActionsToEpisodeActionPosts(List<EpisodeAction>): List<EpisodeActionPost>
		  - addEpisodeActionToDatabase(User, EpisodeAction): void
		  + getEpisodeActionsSince(String, long): List<EpisodeActionPost>
		  - episodeActionPostToEpisodeAction(User, EpisodeActionPost): EpisodeAction
		  + getEpisodeActions(String): List<EpisodeActionPost>
		  + getEpisodeActionsOfPodcast(String, String): List<EpisodeActionPost>
		  + addEpisodeActions(String, List<EpisodeActionPost>): void
		}
	}
}

package model <<Frame>> {

	enum Action << enumeration >> {
	  + <<create>> Action(): 
	  + valueOf(String): Action
	  + getJsonProperty(): String
	  + values(): Action[]
	}
	
	class Episode <<@Entity>> {
	  + <<create>> Episode(): 
	  + <<create>> Episode(Long, String, String, String, int, Subscription, List<EpisodeAction>): 
	  + getId(): Long
	  # canEqual(Object): boolean
	  + getGuid(): String
	  + setTitle(String): void
	  + builder(): EpisodeBuilder
	  + setTotal(int): void
	  + setGuid(String): void
	  + equals(Object): boolean
	  + setSubscription(Subscription): void
	  + getUrl(): String
	  + getTitle(): String
	  + toString(): String
	  + getTotal(): int
	  + setUrl(String): void
	  + setEpisodeActions(List<EpisodeAction>): void
	  + getSubscription(): Subscription
	  + getEpisodeActions(): List<EpisodeAction>
	  + setId(Long): void
	  + hashCode(): int
	}
	
	class EpisodeAction <<@Entity>> {
	  + <<create>> EpisodeAction(Long, User, Episode, LocalDateTime, Action, int, int): 
	  + <<create>> EpisodeAction(): 
	  + getEpisode(): Episode
	  + setEpisode(Episode): void
	  + setPosition(int): void
	  # canEqual(Object): boolean
	  + setUser(User): void
	  + setStarted(int): void
	  + getId(): Long
	  + getUser(): User
	  + getTimestamp(): LocalDateTime
	  + getAction(): Action
	  + getStarted(): int
	  + hashCode(): int
	  + setTimestamp(LocalDateTime): void
	  + equals(Object): boolean
	  + getPosition(): int
	  + builder(): EpisodeActionBuilder
	  + setId(Long): void
	  + setAction(Action): void
	  + toString(): String
	  + toEpisodeActionPost(): EpisodeActionPost
	}
	
	enum Role << enumeration >> {
	  + <<create>> Role(): 
	  + valueOf(String): Role
	  + toString(): String
	  + values(): Role[]
	}
	
	class Subscription <<@Entity>> {
	  + <<create>> Subscription(): 
	  + <<create>> Subscription(Long, String, String, long, List<SubscriptionAction>, List<Episode>): 
	  + setId(Long): void
	  + getId(): Long
	  + equals(Object): boolean
	  + getUrl(): String
	  + hashCode(): int
	  + builder(): SubscriptionBuilder
	  # canEqual(Object): boolean
	  + toString(): String
	  + getTitle(): String
	  + getTimestamp(): long
	  + setEpisodes(List<Episode>): void
	  + getSubscriptionActions(): List<SubscriptionAction>
	  + getEpisodes(): List<Episode>
	  + setSubscriptionActions(List<SubscriptionAction>): void
	  + setUrl(String): void
	  + setTitle(String): void
	  + setTimestamp(long): void
	  + addEpisode(Episode): void
	}
	
	class SubscriptionAction <<@Entity>> {
	  + <<create>> SubscriptionAction(): 
	  + <<create>> SubscriptionAction(int, User, long, Subscription, boolean): 
	  + equals(Object): boolean
	  + getId(): int
	  + getUser(): User
	  + getTimestamp(): long
	  + getSubscription(): Subscription
	  + isAdded(): boolean
	  # canEqual(Object): boolean
	  + setId(int): void
	  + hashCode(): int
	  + setUser(User): void
	  + toString(): String
	  + builder(): SubscriptionActionBuilder
	  + setTimestamp(long): void
	  + setSubscription(Subscription): void
	  + setAdded(boolean): void
	}
	
	class User <<@Entity>> {
	  + <<create>> User(Long, String, String, String, boolean, long, Role, List<SubscriptionAction>, List<EpisodeAction>): 
	  + <<create>> User(): 
	  + getId(): Long
	  + setCreatedAt(long): void
	  + getUsername(): String
	  + builder(): UserBuilder
	  + toString(): String
	  + getEmail(): String
	  + setPassword(String): void
	  + setSubscriptionActions(List<SubscriptionAction>): void
	  + equals(Object): boolean
	  + getPassword(): String
	  + setEmail(String): void
	  + setRole(Role): void
	  + isEnabled(): boolean
	  + setUsername(String): void
	  + getCreatedAt(): long
	  + getRole(): Role
	  + getSubscriptionActions(): List<SubscriptionAction>
	  # canEqual(Object): boolean
	  + hashCode(): int
	  + setEnabled(boolean): void
	  + setEpisodeActions(List<EpisodeAction>): void
	  + getEpisodeActions(): List<EpisodeAction>
	  + setId(Long): void
	  + getAuthorities(): Collection<GrantedAuthority>
	  + isCredentialsNonExpired(): boolean
	  + isAccountNonLocked(): boolean
	  + isAccountNonExpired(): boolean
	}
}

package subscriptions_api <<Frame>> {

	package controller as subscription.controller <<Frame>> {
	
		class SubscriptionController <<@RestController>> {
		  + <<create>> SubscriptionController(SubscriptionService): 
		  + applySubscriptionDelta(String, String, SubscriptionDelta): ResponseEntity<UpdateURLsWrapper>
		  + getSubscriptions(String, String, String): ResponseEntity<List<String>>
		  + getSubscriptionDelta(String, String, long): ResponseEntity<SubscriptionDelta>
		  + getTitles(String): ResponseEntity<List<SubscriptionTitles>>
		  + uploadSubscriptions(String, String, List<String>): ResponseEntity<String>
		}
		
		class SubscriptionDelta {
		  + <<create>> SubscriptionDelta(List<String>, List<String>): 
		  + getTimestamp(): long
		  + getRemove(): List<String>
		  + getAdd(): List<String>
		}
		
		entity SubscriptionTitles << record >> {
		  + <<create>> SubscriptionTitles(Subscription, List<EpisodeActionPost>): 
		  + episodes(): List<EpisodeActionPost>
		  + subscription(): Subscription
		}
	}
	
	package data_access as subscription.dao <<Frame>> {

		interface SubscriptionActionDao <<@Repository>> {
		  + findByUserUsernameAndAddedTrue(String): List<SubscriptionAction>
		  + existsByUserAndSubscription(User, Subscription): boolean
		  + findByUserAndSubscription(User, Subscription): Optional<SubscriptionAction>
		  + findByUserUsernameAndTimestampGreaterThanEqual(String, long): List<SubscriptionAction>
		  + findByUserUsernameAndAddedTrueAndTimestampGreaterThanEqual(String, long): List<SubscriptionAction>
		}
		
		interface SubscriptionDao <<@Repository>> {
		  + findByUrl(String): Optional<Subscription>
		  + existsByUrl(String): boolean
		}
	}
	
	package service as subscription.service <<Frame>> {
		
		class SubscriptionService <<@Service>> {
		  + <<create>> SubscriptionService(RSSParser, AuthenticationDao, SubscriptionDao, SubscriptionActionDao, EpisodeActionDao, EpisodeActionService): 
		  + getTitles(String): List<SubscriptionTitles>
		  + getSubscriptions(String): List<String>
		  + applySubscriptionDelta(String, SubscriptionDelta): int
		  + getSubscriptionDelta(String, long): SubscriptionDelta
		  + uploadSubscriptions(String, List<String>): int
		}
	}
}

package util <<Frame>> {

	class RSSParser <<@Component>> {
	  + <<create>> RSSParser(EpisodeDao, SubscriptionDao): 
	  + validate(Subscription): void
	  - parseTimeToSeconds(String): int
	  - parseEpisode(SyndEntry, Subscription): Episode
	  - saveEpisodes(List<Episode>): void
	  - fetchSubscriptionFeed(Subscription): Map<String, Episode>?
	  - saveSubscription(Subscription): void
	  - deleteSubscription(Subscription): void
	  - getFetchedEpisodeForURL(String, Map<String, Episode>): Episode
	  - deleteEpisodes(List<Episode>): void
	}
	
	class Scheduler <<@Component>> {
	  + <<create>> Scheduler(): 
	  + clean(): void
	}
	
	class UpdateURLsWrapper {
	  + <<create>> UpdateURLsWrapper(): 
	  + getTimestamp(): long
	  + getUpdateURLs(): List<Pair<String, String>>
	}
}

class ServerApplication <<@SpringBootApplication>> {
  + <<create>> ServerApplication(): 
  + main(String[]): void
}

database Datenbank
Datenbank <-[hidden]d- subscriptions_api
Datenbank <-[hidden]d- episode_actions_api
Datenbank <-[hidden]d- authentication_api
() SQL as SQLSub
() SQL as SQLAuth
() SQL as SQLEpisode

Datenbank -- SQLSub
Datenbank -- SQLAuth
Datenbank -- SQLEpisode

SubscriptionController ..o ServerApplication 
AuthenticationController ..o ServerApplication 
EpisodeActionController ..o ServerApplication

ServerApplication --() HTTP 

SQLSub )-- SubscriptionActionDao: JPA
SQLSub )-- SubscriptionDao: JPA
SQLAuth )-- AuthenticationDao: JPA
SQLEpisode )-- EpisodeActionDao: JPA
SQLEpisode )-- EpisodeDao: JPA

model .o Datenbank: ORM (User, SubscriptionAction, Subscription, EpisodeAction, Episode)
' Datenbank o.. Subscription: ORM
' Datenbank o.. SubscriptionAction: ORM
' Datenbank o.. Episode: ORM
' Datenbank o.. EpisodeAction: ORM
' Datenbank o.. User: ORM

ApplicationConfig                  "1" *-[#595959,plain]-> "authenticationDao\n1" AuthenticationDao                  
ApplicationConfig                   -[#595959,dashed]->  AuthenticationValidatorInterceptor : "«create»"
AuthenticationController           "1" *-[#595959,plain]-> "authenticationService\n1" AuthenticationService              
AuthenticationController            -[#595959,dashed]->  DeviceWrapper                      : "«create»"
AuthenticationController           "1" *-[#595959,plain]-> "eMailConfigProperties\n1" EMailConfigProperties              
AuthenticationService              "1" *-[#595959,plain]-> "authenticationDao\n1" AuthenticationDao                  
AuthenticationService              "1" *-[#595959,plain]-> "eMailService\n1" EMailServiceImpl                   
AuthenticationService              "1" *-[#595959,plain]-> "encryptionService\n1" EncryptionService                  
AuthenticationService              "1" *-[#595959,plain]-> "inputCheckService\n1" InputCheckService                  
AuthenticationService              "1" *-[#595959,plain]-> "jwtService\n1" JwtService                         
AuthenticationService              "1" *-[#595959,plain]-> "DEFAULT_USER\n1" Role                               
EMailServiceImpl                   "1" *-[#595959,plain]-> "eMailConfigProperties\n1" EMailConfigProperties              
EMailServiceImpl                   "1" *-[#595959,plain]-> "jwtService\n1" JwtService                         
EncryptionService                  "1" *-[#595959,plain]-> "securityConfigProperties\n1" SecurityConfigProperties           
Episode                            "1" *-[#595959,plain]-> "episodeActions\n*" EpisodeAction                      
Episode                            "1" *-[#595959,plain]-> "subscription\n1" Subscription                       
EpisodeAction                      "1" *-[#595959,plain]-> "action\n1" Action                             
EpisodeAction                      "1" *-[#595959,plain]-> "episode\n1" Episode                            
EpisodeAction                       -[#595959,dashed]->  EpisodeActionPost                  : "«create»"
EpisodeAction                      "1" *-[#595959,plain]-> "user\n1" User                               
EpisodeActionController             -[#595959,dashed]->  EpisodeActionGetResponse           : "«create»"
EpisodeActionController            "1" *-[#595959,plain]-> "episodeActionService\n1" EpisodeActionService               
EpisodeActionController             -[#595959,dashed]->  UpdateURLsWrapper                  : "«create»"
EpisodeActionGetResponse           "1" *-[#595959,plain]-> "actions\n*" EpisodeActionPost                  
EpisodeActionPost                  "1" *-[#595959,plain]-> "episodeAction\n1" EpisodeAction                      
EpisodeActionService               "1" *-[#595959,plain]-> "authenticationDao\n1" AuthenticationDao                  
EpisodeActionService               "1" *-[#595959,plain]-> "episodeActionDao\n1" EpisodeActionDao                   
EpisodeActionService               "1" *-[#595959,plain]-> "episodeDao\n1" EpisodeDao                         
EpisodeActionService               "1" *-[#595959,plain]-> "rssParser\n1" RSSParser                          
EpisodeActionService                -[#595959,dashed]->  Subscription                       : "«create»"
EpisodeActionService               "1" *-[#595959,plain]-> "subscriptionActionDao\n1" SubscriptionActionDao              
EpisodeActionService               "1" *-[#595959,plain]-> "subscriptionDao\n1" SubscriptionDao                    
JwtAuthenticationFilter            "1" *-[#595959,plain]-> "jwtService\n1" JwtService                         
JwtService                         "1" *-[#595959,plain]-> "securityConfigProperties\n1" SecurityConfigProperties           
RSSParser                          "1" *-[#595959,plain]-> "episodeDao\n1" EpisodeDao                         
RSSParser                          "1" *-[#595959,plain]-> "subscriptionDao\n1" SubscriptionDao                    
Scheduler                          "1" *-[#595959,plain]-> "authenticationService\n1" AuthenticationService              
SecurityConfig                     "1" *-[#595959,plain]-> "jwtAuthFilter\n1" JwtAuthenticationFilter            
Subscription                       "1" *-[#595959,plain]-> "episodes\n*" Episode                            
Subscription                       "1" *-[#595959,plain]-> "subscriptionActions\n*" SubscriptionAction                 
SubscriptionAction                 "1" *-[#595959,plain]-> "subscription\n1" Subscription                       
SubscriptionAction                 "1" *-[#595959,plain]-> "user\n1" User                               
SubscriptionController             "1" *-[#595959,plain]-> "subscriptionService\n1" SubscriptionService                
SubscriptionController              -[#595959,dashed]->  UpdateURLsWrapper                  : "«create»"
SubscriptionService                "1" *-[#595959,plain]-> "authenticationDao\n1" AuthenticationDao                  
SubscriptionService                "1" *-[#595959,plain]-> "episodeActionDao\n1" EpisodeActionDao                   
SubscriptionService                "1" *-[#595959,plain]-> "episodeActionService\n1" EpisodeActionService               
SubscriptionService                "1" *-[#595959,plain]-> "rssParser\n1" RSSParser                          
SubscriptionService                "1" *-[#595959,plain]-> "subscriptionActionDao\n1" SubscriptionActionDao              
SubscriptionService                "1" *-[#595959,plain]-> "subscriptionDao\n1" SubscriptionDao                    
SubscriptionService                 -[#595959,dashed]->  SubscriptionDelta                  : "«create»"
SubscriptionService                 -[#595959,dashed]->  SubscriptionTitles                 : "«create»"
SubscriptionTitles                 "1" *-[#595959,plain]-> "subscription\n1" Subscription                       
User                               "1" *-[#595959,plain]-> "episodeActions\n*" EpisodeAction                      
User                               "1" *-[#595959,plain]-> "role\n1" Role                               
User                               "1" *-[#595959,plain]-> "subscriptionActions\n*" SubscriptionAction                 
@enduml