From 388d631b75acec04440b8f285fd98d89bbd898db Mon Sep 17 00:00:00 2001 From: Sergey Nastich Date: Thu, 20 Sep 2018 13:43:28 -0400 Subject: DFC-775 Improve PhoneNumber (backport from master without TN extensions) (#223) --- src/main/scala/xyz/driver/core/domain.scala | 38 +++++++++++++++++++--- src/main/scala/xyz/driver/core/json.scala | 27 ++++++++++++--- src/test/scala/xyz/driver/core/JsonTest.scala | 15 +++++++++ .../scala/xyz/driver/core/PhoneNumberTest.scala | 19 +++++++++++ 4 files changed, 90 insertions(+), 9 deletions(-) diff --git a/src/main/scala/xyz/driver/core/domain.scala b/src/main/scala/xyz/driver/core/domain.scala index 59bed54..459c804 100644 --- a/src/main/scala/xyz/driver/core/domain.scala +++ b/src/main/scala/xyz/driver/core/domain.scala @@ -1,13 +1,20 @@ package xyz.driver.core import com.google.i18n.phonenumbers.PhoneNumberUtil +import com.google.i18n.phonenumbers.PhoneNumberUtil.PhoneNumberFormat import scalaz.Equal import scalaz.std.string._ import scalaz.syntax.equal._ +import scala.util.Try +import scala.util.control.NonFatal + object domain { final case class Email(username: String, domain: String) { + + val value: String = toString + override def toString: String = username + "@" + domain } @@ -23,18 +30,39 @@ object domain { } } - final case class PhoneNumber(countryCode: String = "1", number: String) { + final case class PhoneNumber(countryCode: String, number: String) { + + /** This is a more human-friendly alias for #toE164String() */ + def toCompactString: String = s"+$countryCode$number" + + /** Outputs the phone number in a E.164-compliant way, e.g. +14151234567 */ + def toE164String: String = toCompactString + + /** + * Outputs the phone number in a "readable" way, e.g. "+1 415-123-45-67 ext. 1234" + * @throws IllegalStateException if the contents of this object is not a valid phone number + */ + @throws[IllegalStateException] + def toHumanReadableString: String = + try { + val phoneNumber = PhoneNumber.phoneUtil.parse(toE164String, "US") + PhoneNumber.phoneUtil.format(phoneNumber, PhoneNumberFormat.INTERNATIONAL) + } catch { + case NonFatal(e) => throw new IllegalStateException(s"$toString is not a valid number", e) + } + override def toString: String = s"+$countryCode $number" } object PhoneNumber { - private val phoneUtil = PhoneNumberUtil.getInstance() + private[PhoneNumber] val phoneUtil = PhoneNumberUtil.getInstance() def parse(phoneNumber: String): Option[PhoneNumber] = { - val validated = - util.Try(phoneUtil.parseAndKeepRawInput(phoneNumber, "US")).toOption.filter(phoneUtil.isValidNumber) - validated.map(pn => PhoneNumber(pn.getCountryCode.toString, pn.getNationalNumber.toString)) + val validated = Try(phoneUtil.parseAndKeepRawInput(phoneNumber, "US")).toOption.filter(phoneUtil.isValidNumber) + validated.map { pn => + PhoneNumber(pn.getCountryCode.toString, pn.getNationalNumber.toString) + } } } } diff --git a/src/main/scala/xyz/driver/core/json.scala b/src/main/scala/xyz/driver/core/json.scala index d9319e9..d87e0c4 100644 --- a/src/main/scala/xyz/driver/core/json.scala +++ b/src/main/scala/xyz/driver/core/json.scala @@ -234,11 +234,30 @@ object json { } } + def PhoneInPath: PathMatcher1[PhoneNumber] = new PathMatcher1[PhoneNumber] { + def apply(path: Path) = path match { + case Path.Segment(segment, tail) => + PhoneNumber + .parse(segment) + .map(parsed => Matched(tail, Tuple1(parsed))) + .getOrElse(Unmatched) + case _ => Unmatched + } + } + implicit object phoneNumberFormat extends RootJsonFormat[PhoneNumber] { - private val basicFormat = jsonFormat2(PhoneNumber.apply) - override def write(obj: PhoneNumber): JsValue = basicFormat.write(obj) - override def read(json: JsValue): PhoneNumber = { - PhoneNumber.parse(basicFormat.read(json).toString).getOrElse(deserializationError("Invalid phone number")) + + private val basicFormat = jsonFormat2(PhoneNumber.apply) + + def write(obj: PhoneNumber): JsValue = basicFormat.write(obj) + + def read(json: JsValue): PhoneNumber = { + val maybePhone = json match { + case JsString(number) => PhoneNumber.parse(number) + case obj: JsObject => PhoneNumber.parse(basicFormat.read(obj).toString) + case _ => None + } + maybePhone.getOrElse(deserializationError("Invalid phone number")) } } diff --git a/src/test/scala/xyz/driver/core/JsonTest.scala b/src/test/scala/xyz/driver/core/JsonTest.scala index 2aa3572..5c1274c 100644 --- a/src/test/scala/xyz/driver/core/JsonTest.scala +++ b/src/test/scala/xyz/driver/core/JsonTest.scala @@ -247,6 +247,21 @@ class JsonTest extends WordSpec with Matchers with Inspectors { json.phoneNumberFormat.read(phoneJson) }.getMessage shouldBe "Invalid phone number" } + + "parse phone number from string" in { + JsString("+14243039608").convertTo[PhoneNumber] shouldBe PhoneNumber("1", "4243039608") + } + } + + "Path matcher for PhoneNumber" should { + "read valid phone number" in { + val string = "+14243039608" + val phone = PhoneNumber("1", "4243039608") + + val matcher = PathMatcher("foo") / PhoneInPath + + matcher(Uri.Path("foo") / string / "bar") shouldBe Matched(Uri.Path./("bar"), Tuple1(phone)) + } } "Json format for ADT mappings" should { diff --git a/src/test/scala/xyz/driver/core/PhoneNumberTest.scala b/src/test/scala/xyz/driver/core/PhoneNumberTest.scala index 384c7be..7ccf0d8 100644 --- a/src/test/scala/xyz/driver/core/PhoneNumberTest.scala +++ b/src/test/scala/xyz/driver/core/PhoneNumberTest.scala @@ -76,4 +76,23 @@ class PhoneNumberTest extends FlatSpec with Matchers { List(PhoneNumber("45", "27452522"), PhoneNumber("86", "13452522256")) } + "PhoneNumber.toCompactString/toE164String" should "produce phone number in international format without whitespaces" in { + PhoneNumber.parse("+1 800 5252225").get.toCompactString shouldBe "+18005252225" + PhoneNumber.parse("+1 800 5252225").get.toE164String shouldBe "+18005252225" + } + + "PhoneNumber.toHumanReadableString" should "produce nice readable result for different countries" in { + PhoneNumber.parse("+14154234567").get.toHumanReadableString shouldBe "+1 415-423-4567" + + PhoneNumber.parse("+78005252225").get.toHumanReadableString shouldBe "+7 800 525-22-25" + + PhoneNumber.parse("+41219437898").get.toHumanReadableString shouldBe "+41 21 943 78 98" + } + + it should "throw an IllegalArgumentException if the PhoneNumber object is not parsable/valid" in { + intercept[IllegalStateException] { + PhoneNumber("+123", "1238123120938120938").toHumanReadableString + }.getMessage should include("+123 1238123120938120938 is not a valid number") + } + } -- cgit v1.2.3