Wip

Author: Rafa Paradela

src/main/scala/com/fortysevendeg/github4s/GithubAPIs.scala

@@ -42,4 +42,10 @@ class GHAuth(implicit O : AuthOps[GitHub4s]){
       client_id: String,
       client_secret: String): GHIO[GHResponse[Authorization]] =
     O.newAuth(username, password, scopes, note, client_id, client_secret)
+
+  def authorizeUrl(
+      client_id: String,
+      redirect_uri: String,
+      scopes: List[String]): GHIO[GHResponse[Authorize]] =
+    O.authorizeUrl(client_id, redirect_uri, scopes)
 }

src/main/scala/com/fortysevendeg/github4s/GithubResponses.scala

@@ -52,8 +52,6 @@ object GithubResponses {
     case r => UnexpectedException(s"Failed invoking get with status : ${r.code}, body : \n ${r.body}").left[GHResult[Unit]]
   }
 
-  def toEntityString(s: String): GHResponse[String] = Xor.Right(GHItemResult(s, 0, Map.empty))
-
   private def toLowerCase(headers: Map[String, IndexedSeq[String]]): Map[String, IndexedSeq[String]] = headers.map(e => (e._1.toLowerCase, e._2))
 
 

src/main/scala/com/fortysevendeg/github4s/api/Auth.scala

@@ -1,7 +1,10 @@
 package com.fortysevendeg.github4s.api
 
-import com.fortysevendeg.github4s.GithubResponses.GHResponse
-import com.fortysevendeg.github4s.free.domain.Authorization
+import java.util.UUID
+
+import cats.data.Xor
+import com.fortysevendeg.github4s.GithubResponses.{GHItemResult, GHResponse}
+import com.fortysevendeg.github4s.free.domain._
 import com.fortysevendeg.github4s.HttpClient
 import io.circe.generic.auto._
 import io.circe.syntax._
@@ -12,8 +15,19 @@ object Auth {
 
   protected val httpClient = new HttpClient()
 
-  case class NewAuthRequest(scopes: List[String], note: String, client_id: String, client_secret: String)
+  val authorizeUrl = "https://github.com/login/oauth/authorize?client_id=%s&redirect_uri=%s&scope=%s&state=%s"
 
+  /**
+    * Call to request a new authorization given a basic authentication, the returned object Authorization includes an
+    * access token
+    * @param username
+    * @param password
+    * @param scopes
+    * @param note
+    * @param client_id
+    * @param client_secret
+    * @return
+    */
   def newAuth(
       username: String,
       password: String,
@@ -26,10 +40,35 @@ object Auth {
       headers = Map("Authorization" -> s"Basic ${base64(s"$username:$password")}"),
       data = NewAuthRequest(scopes, note, client_id, client_secret).asJson.noSpaces)
 
+
+  /**
+    * Generates the authorize url with a random state, both are returned within Authorize object
+    *
+    * @param client_id
+    * @param redirect_uri
+    * @param scopes
+    * @return
+    */
   def authorizeUrl(
       client_id: String,
       redirect_uri: String,
-      scopes: List[String]): GHResponse[String] = ???
+      scopes: List[String]): GHResponse[Authorize] = {
+    val state = UUID.randomUUID().toString
+    Xor.Right(
+      GHItemResult(
+        value = Authorize(authorizeUrl.format(client_id, redirect_uri, scopes.mkString(","), state), state),
+        statusCode = 200,
+        headers = Map.empty))
+  }
+
+
+  def getAccessToken(
+      client_id: String,
+      client_secret: String,
+      code: String,
+      redirect_uri: String,
+      state: String): GHResponse[OAuthToken] = ???
+  )
 
 
 }

src/main/scala/com/fortysevendeg/github4s/free/algebra/AuthOps.scala

@@ -2,11 +2,12 @@ package com.fortysevendeg.github4s.free.algebra
 
 import cats.free.{Free, Inject}
 import com.fortysevendeg.github4s.GithubResponses._
-import com.fortysevendeg.github4s.free.domain.Authorization
+import com.fortysevendeg.github4s.free.domain.{Authorize, Authorization}
 
 /** Auths ops ADT
   */
 sealed trait AuthOp[A]
+
 final case class NewAuth(
     username: String,
     password: String,
@@ -15,6 +16,11 @@ final case class NewAuth(
     client_id: String,
     client_secret: String) extends AuthOp[GHResponse[Authorization]]
 
+final case class AuthorizeUrl(
+    client_id: String,
+    redirect_uri: String,
+    scopes: List[String]) extends AuthOp[GHResponse[Authorize]]
+
 
 /** Exposes Auths operations as a Free monadic algebra that may be combined with other Algebras via
   * Coproduct
@@ -30,6 +36,12 @@ class AuthOps[F[_]](implicit I: Inject[AuthOp, F]) {
       client_secret: String): Free[F, GHResponse[Authorization]] =
     Free.inject[AuthOp, F](NewAuth(username, password, scopes, note, client_id, client_secret))
 
+  def authorizeUrl(
+      client_id: String,
+      redirect_uri: String,
+      scopes: List[String]): Free[F, GHResponse[Authorize]] =
+    Free.inject[AuthOp, F](AuthorizeUrl(client_id, redirect_uri, scopes))
+
 }
 
 /** Default implicit based DI factory from which instances of the AuthOps may be obtained

src/main/scala/com/fortysevendeg/github4s/free/domain/Authorization.scala

@@ -1,6 +1,21 @@
 package com.fortysevendeg.github4s.free.domain
 
-case class Authorization (
+case class Authorization(
     id: Int,
     url: String,
-    token: String)
+    token: String)
+
+case class NewAuthRequest(
+    scopes: List[String],
+    note: String,
+    client_id: String,
+    client_secret: String)
+
+case class Authorize(
+    url: String,
+    state: String)
+
+case class OAuthToken(
+  access_token: String,
+  token_type: String,
+  scope: String)

src/main/scala/com/fortysevendeg/github4s/free/interpreters/Interpreters.scala

@@ -50,6 +50,7 @@ trait Interpreters[M[_]] {
   def authOpsInterpreter(implicit A: ApplicativeError[M, Throwable], C : GithubConfig): AuthOp ~> M = new (AuthOp ~> M) {
     def apply[A](fa: AuthOp[A]): M[A] = fa match {
       case NewAuth(username, password, scopes, note, client_id, client_secret) ⇒ A.pureEval(Eval.later(Auth.newAuth(username, password, scopes, note, client_id, client_secret)))
+      case AuthorizeUrl(client_id, redirect_uri, scopes) => A.pureEval(Eval.later(Auth.authorizeUrl(client_id, redirect_uri, scopes)))
     }
   }