parse links & direct api calls

Author: rtfpessoa

src/main/scala/com/codacy/client/bitbucket/PullRequest.scala

@@ -8,10 +8,30 @@ case class PullRequest(id: Long, title: String, description: String,
                        authorUsername: String, authorAvatar: Option[String],
                        state: String, created_on: DateTime, updated_on: DateTime,
                        sourceRepository: String, sourceBranch: String, sourceCommit: String,
-                       destRepository: String, destBranch: String, destCommit: String) {
-  val url: String = s"https://bitbucket.org/$destRepository/pull-request/$id"
+                       destRepository: String, destBranch: String, destCommit: String,
+                       apiUrls: Seq[ApiUrl]) {
+  val url = s"https://bitbucket.org/$destRepository/pull-request/$id"
 }
 
+object ApiUrlType extends Enumeration {
+  val Commits = Value("commits")
+  val Decline = Value("decline")
+  val Self = Value("self")
+  val Comments = Value("comments")
+  val Patch = Value("patch")
+  val Merge = Value("merge")
+  val Html = Value("html")
+  val Activity = Value("activity")
+  val Diff = Value("diff")
+  val Approve = Value("approve")
+
+  def find(urlType: String): Option[Value] = {
+    values.find(_.toString == urlType)
+  }
+}
+
+case class ApiUrl(urlType: ApiUrlType.Value, link: String)
+
 object PullRequest {
   val dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSZZ"
   implicit val jodaDateTimeReads = Reads.jodaDateReads(dateFormat)
@@ -30,6 +50,15 @@ object PullRequest {
       (__ \ "source" \ "commit" \ "hash").read[String] and
       (__ \ "destination" \ "repository" \ "full_name").read[String] and
       (__ \ "destination" \ "branch" \ "name").read[String] and
-      (__ \ "destination" \ "commit" \ "hash").read[String]
+      (__ \ "destination" \ "commit" \ "hash").read[String] and
+      (__ \ "links").read[Map[String, Map[String, String]]].map(parseLinks)
     )(PullRequest.apply _)
+
+  private def parseLinks(links: Map[String, Map[String, String]]): Seq[ApiUrl] = {
+    (for {
+      (linkName, linkMap) <- links
+      urlType <- ApiUrlType.find(linkName)
+      linkUrl <- linkMap.get("href")
+    } yield ApiUrl(urlType, linkUrl)).toSeq
+  }
 }

src/main/scala/com/codacy/client/bitbucket/Repository.scala

@@ -4,44 +4,61 @@ import org.joda.time.DateTime
 import play.api.libs.functional.syntax._
 import play.api.libs.json._
 
-case class Repository(name: String, full_name: String, description: String,
-                      scm: String, created_on: DateTime, updated_on: DateTime,
-                      httpsUrl: String, sshUrl: String, owner: String, size: Long,
-                      has_issues: Boolean, is_private: Boolean, language: String)
+case class Repository(name: String, full_name: String, description: String, scm: String,
+                      created_on: DateTime, updated_on: DateTime, owner: String, size: Long,
+                      has_issues: Boolean, is_private: Boolean, language: String,
+                      url: Seq[RepositoryUrl])
 
 object Repository {
   val dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SSSSSSZZ"
   implicit val jodaDateTimeReads = Reads.jodaDateReads(dateFormat)
 
   implicit val reader: Reads[Repository] = {
-    val url1 = (__ \ "links" \ "clone")(0).read[Url]
-    val url2 = (__ \ "links" \ "clone")(1).read[Url]
-
-    val httpUrl = url1.filter(_.name == "https").orElse(url2).map(_.href)
-    val sshUrl = url2.filter(_.name == "ssh").orElse(url1).map(_.href)
-
     ((__ \ "name").read[String] and
       (__ \ "full_name").read[String] and
       (__ \ "description").read[String] and
       (__ \ "scm").read[String] and
       (__ \ "created_on").read[DateTime] and
       (__ \ "updated_on").read[DateTime] and
-      httpUrl and
-      sshUrl and
       (__ \ "owner" \ "username").read[String] and
       (__ \ "size").read[Long] and
       (__ \ "has_issues").read[Boolean] and
       (__ \ "is_private").read[Boolean] and
-      (__ \ "language").read[String]
+      (__ \ "language").read[String] and
+      (__ \ "links").read[Map[String, JsValue]].map(parseLinks)
       )(Repository.apply _)
   }
+
+  private def parseLinks(links: Map[String, JsValue]): Seq[RepositoryUrl] = {
+    links.flatMap {
+      case (linkName, linkMap) =>
+
+        val simpleLinks = for {
+          ref <- linkMap.asOpt[Map[String, String]]
+          urlType <- RepositoryUrlType.find(linkName)
+          linkUrl <- ref.get("href")
+        } yield RepositoryUrl(urlType, linkUrl)
+
+        val complexLinks = for {
+          refs <- linkMap.asOpt[Seq[Map[String, String]]].toSeq
+          ref <- refs
+          linkName <- ref.get("name")
+          urlType <- RepositoryUrlType.find(linkName)
+          linkUrl <- ref.get("href")
+        } yield RepositoryUrl(urlType, linkUrl)
+
+        simpleLinks ++ complexLinks
+    }.toSeq
+  }
 }
 
-case class Url(name: String, href: String)
+object RepositoryUrlType extends Enumeration {
+  val Https = Value("https")
+  val Ssh = Value("ssh")
 
-object Url {
-  implicit val reader: Reads[Url] = (
-    (__ \ "name").read[String] and
-      (__ \ "href").read[String]
-    )(Url.apply _)
+  def find(urlType: String): Option[Value] = {
+    values.find(_.toString == urlType)
+  }
 }
+
+case class RepositoryUrl(urlType: RepositoryUrlType.Value, link: String)

src/main/scala/com/codacy/client/bitbucket/service/UrlServices.scala

@@ -0,0 +1,15 @@
+package com.codacy.client.bitbucket.service
+
+import com.codacy.client.bitbucket.client.{BitbucketClient, Request, RequestResponse}
+import play.api.libs.json.JsValue
+
+class UrlServices(client: BitbucketClient) {
+
+  /*
+   * Post to a api url
+   */
+  def post(url: String): RequestResponse[JsValue] = {
+    client.post(Request(url, classOf[JsValue]), Map.empty)
+  }
+
+}