Is there a way to tell all methods inside a class to do function call without writing those function calls to every method - scala

Question

I'm coding request calls to tens of services which should be authorized.
I noticed I have written a lot of copy&paste code to the beginning of all methods inside service classes because they all must be authorized before using any services.
Little example...
class AuthorizationService {
val authorized = List("James", "007")
def authorize(user: String) = {
if (!authorized.contains(user)) throw new RuntimeException(s"User '$user' not authorized")
}
}
class Service1 {
val authorizationService = new AuthorizationService
def doThis(user: String) = {
authorizationService.authorize(user)
println(s"User '$user' did this")
}
def doThat(user: String) = {
authorizationService.authorize(user)
println(s"User '$user' did that")
}
}
Now imagine there are 30 service classes with three methods each and I continue to do authorization like the way I have I end up writing 90 functions calls.

Answer 1

Something like this maybe ... It still requires your service to change, but not as much:
object AuthToken {
implicit def auth(s: String)(implicit service: AuthService) = {
service.authorize(s)
AuthToken(s)
}
}
case class AuthToken private[AuthToken] (s: String) {
override def toString = s;
}
class Service1 {
implicit val authorizationService = new AuthorizationService
def doThis(user: AuthToken) = {
println(s"User '$user' did this")
}
}
Now, if you do new Service1().doThis("James"), it will implicitly call your auth service first to convert the name into token.

Answer 2

You could use it like this:
object Tester {
class AuthorizationService {
val authorized = List("James", "007")
def authorize(user: String) = {
if (!authorized.contains(user)) throw new RuntimeException(s"User '$user' not authorized")
}
}
def authorize(businessLogic: => Unit)(implicit
authorizationService: AuthorizationService,
user: String): Unit = {
// authorization logic
authorizationService.authorize(user)
println(s"User '$user' did this")
// actual code that needs to be executed
businessLogic
}
class Service1(implicit val authorizationService: AuthorizationService) {
def doThis(implicit user: String) = authorize {
println("doThis()")
}
def doThat(implicit user: String) = authorize {
println("doThat()")
}
}
def main(args: Array[String]) {
implicit val authorizationService = new AuthorizationService
val s = new Service1()
s.doThat("James")
s.doThat("007")
s.doThat("Neo")
}
}

Answer 3

you could use a crude composition pattern:
class ServiceAuthorizationExecutor {
def call(user: String, delegate: DELGATE_TYPE) = {
authorizationService.authorize(user)
delegate()
}
}

Answer 4

This is a classic AOP problem. The last time I looked at AOP was 12 years ago though, so I'm not sure what the state of it all is.