Add support for external signature content (#254)

* Add support for external signature content.

* External signature type should always have the placeholder text until replaced by the external service.

* Add new input and output fields to external signature input call.

* Add new TextElement for external signature placeholder text.

* Always apply white-text class to external signature.

* try with style instead of class.

* Fix formatting.

* Add accessToken parameter to external signature call.

* Add token expiry and refresh token fields.

* Add refresh token and expiry date.

* Fix syntax

* print error.

* Try custom encoding.

* Remove custom decoder and replace with a new strategy.

* Remove print statements.

* Verify external signature properly.

* Fix formatting.

Co-authored-by: David Roon <[email protected]>

Author: Happy0

shared/src/main/scala/org/adridadou/openlaw/oracles/OpenlawSignatureOracle.scala

@@ -24,6 +24,32 @@ final case class OpenlawSignatureOracle(
       data: EthereumData,
       signatureEvent: SignatureEvent
   ): Result[Boolean] = signatureEvent match {
+    case event: ExternalSignatureEvent =>
+      event.getServiceName match {
+        case None => Failure(s"No registered with name ${event.getServiceName}")
+        case Some(serviceName) => {
+          val externalAccount =
+            externalSignatureAccounts.get(serviceName) match {
+              case Some(account) => Success(account)
+              case None =>
+                Failure(s"unknown service ${serviceName.serviceName}")
+            }
+
+          val signedData = EthereumData(crypto.sha256(event.email.email))
+            .merge(EthereumData(crypto.sha256(data.data)))
+
+          externalAccount.flatMap { signatureServiceAccount =>
+            EthereumAddress(
+              crypto
+                .validateECSignature(signedData.data, event.signature.signature)
+            ).map(derivedAddress => {
+              signatureServiceAccount.withLeading0x === derivedAddress.withLeading0x
+            })
+          }
+
+        }
+      }
+
     case event: SignatureEvent =>
       val signedData = EthereumData(crypto.sha256(event.email.email))
         .merge(EthereumData(crypto.sha256(data.data)))

shared/src/main/scala/org/adridadou/openlaw/parser/template/OpenlawTemplateLanguageParserService.scala

@@ -259,6 +259,10 @@ class OpenlawTemplateLanguageParserService {
         )
       case txt: FreeText =>
         Success(agreementPrinter.text(txt.elem))
+
+      case placeholder: SignaturePlaceholder =>
+        Success(agreementPrinter.signaturePlaceholder(placeholder.text))
+
       case image: ImageElement =>
         Success(agreementPrinter.image(image))
       case link: Link =>

shared/src/main/scala/org/adridadou/openlaw/parser/template/StructuredDocument.scala

@@ -1502,6 +1502,9 @@ final case class ImageElement(url: String) extends AgreementElement {
 final case class FreeText(elem: TextElement) extends AgreementElement {
   override def serialize: Json = this.asJson
 }
+final case class SignaturePlaceholder(text: String) extends AgreementElement {
+  override def serialize: Json = this.asJson
+}
 final case class Link(label: String, url: String) extends AgreementElement {
   override def serialize: Json = this.asJson
 }

shared/src/main/scala/org/adridadou/openlaw/parser/template/formatters/SignatureFormatter.scala

@@ -3,18 +3,39 @@ package org.adridadou.openlaw.parser.template.formatters
 import org.adridadou.openlaw.OpenlawValue
 import org.adridadou.openlaw.parser.template._
 import org.adridadou.openlaw.parser.template.expressions.Expression
-import org.adridadou.openlaw.parser.template.variableTypes.Identity
+import org.adridadou.openlaw.parser.template.variableTypes.{
+  ExternalSignature,
+  ExternalSignatureType,
+  Identity
+}
 import org.adridadou.openlaw.result.{Failure, Result, Success}
 
 /**
   * Created by davidroon on 12.06.17.
   */
 class SignatureFormatter extends Formatter {
+
+  private def formatExternalSignature(
+      expression: Expression
+  ): Result[List[AgreementElement]] = {
+    Success(List(SignaturePlaceholder(missingSignatureText(expression))))
+  }
+
+  private def formatExternalSignatureString(
+      expression: Expression
+  ): Result[String] = {
+    Success(missingSignatureText(expression))
+  }
+
   override def format(
       expression: Expression,
       value: OpenlawValue,
       executionResult: TemplateExecutionResult
   ): Result[List[AgreementElement]] = value match {
+    case externalSignature: ExternalSignature =>
+      // External signatures are just placeholder text until the external service replaces them with the signature
+      // applied by the user
+      formatExternalSignature(expression)
     case identity: Identity =>
       executionResult
         .getSignatureProof(identity)
@@ -28,6 +49,7 @@ class SignatureFormatter extends Formatter {
           )
         })
         .getOrElse(Success(missingValueFormat(expression)))
+
     case other =>
       Failure(
         "invalid type " + other.getClass.getSimpleName + ". expecting Identity"
@@ -45,6 +67,8 @@ class SignatureFormatter extends Formatter {
           .getSignatureProof(identity)
           .map(proof => Success(s"/s/ ${proof.fullName}"))
           .getOrElse(Success(missingSignatureText(expression)))
+      case externalSignature: ExternalSignature =>
+        formatExternalSignatureString(expression)
       case other =>
         Failure(
           "invalid type " + other.getClass.getSimpleName + ". expecting Identity"

shared/src/main/scala/org/adridadou/openlaw/parser/template/printers/AgreementPrinter.scala

@@ -19,6 +19,7 @@ trait AgreementPrinter[T] {
   def title(title: TemplateTitle): AgreementPrinter[T]
   def link(link: Link): AgreementPrinter[T]
   def text(txt: TextElement): AgreementPrinter[T]
+  def signaturePlaceholder(text: String): AgreementPrinter[T]
   def conditionalStart(): AgreementPrinter[T] =
     newState(state.copy(conditionalDepth = state.conditionalDepth + 1))
   def conditionalStartWithElse(): AgreementPrinter[T] =

shared/src/main/scala/org/adridadou/openlaw/parser/template/printers/XHtmlAgreementPrinter.scala

@@ -4,7 +4,10 @@ import java.util.concurrent.atomic.AtomicInteger
 
 import cats.implicits._
 import org.adridadou.openlaw.parser.template._
-import org.adridadou.openlaw.parser.template.variableTypes.IdentityType
+import org.adridadou.openlaw.parser.template.variableTypes.{
+  ExternalSignature,
+  IdentityType
+}
 import scalatags.Text.all._
 import slogging._
 
@@ -335,6 +338,18 @@ final case class XHtmlAgreementPrinter(
               continue(a(href := url)(label) +: elems)
             })
 
+          case SignaturePlaceholder(str) =>
+            // Generate text output
+            val innerFrag = text(str)
+
+            val spanFrag: List[Frag] = List(
+              span(`style` := "color: white;")(innerFrag)
+            )
+
+            tailRecurse(xs, conditionalBlockDepth, inSection, { elems =>
+              continue(spanFrag ++ elems)
+            })
+
           case PlainText(str) =>
             tailRecurse(xs, conditionalBlockDepth, inSection, { elems =>
               continue(text(str) ++ elems)

shared/src/main/scala/org/adridadou/openlaw/parser/template/variableTypes/AbstractStructureType.scala

@@ -3,6 +3,7 @@ package org.adridadou.openlaw.parser.template.variableTypes
 import cats.implicits._
 import io.circe.{Decoder, Encoder, HCursor, Json}
 import cats.kernel.Eq
+import io.circe.Json.JString
 import org.adridadou.openlaw.parser.template._
 import io.circe.parser._
 import io.circe.syntax._
@@ -215,20 +216,33 @@ final case class DefinedStructureType(structure: Structure, typeName: String)
       executionResult: TemplateExecutionResult
   ): Result[OpenlawMap[VariableName, OpenlawValue]] =
     for {
-      values <- decode[Map[String, String]](value).leftMap(FailureException(_))
+      values <- decode[Map[String, Json]](value).leftMap(FailureException(_))
       list <- structure.typeDefinition
         .flatMap {
           case (fieldName, fieldType) =>
             values
               .get(fieldName.name)
               .map(value =>
-                fieldType.cast(value, executionResult).map(fieldName -> _)
+                fieldType
+                  .cast(jsonToString(value), executionResult)
+                  .map(fieldName -> _)
               )
         }
         .toList
         .sequence
     } yield OpenlawMap(list.toMap)
 
+  private def jsonToString(json: Json): String = {
+    json.fold[String](
+      "null",
+      bool => bool.toString,
+      number => number.toString,
+      string => string,
+      array => array.asJson.noSpaces,
+      jsonObject => jsonObject.asJson.noSpaces
+    )
+  }
+
   override def internalFormat(value: OpenlawValue): Result[String] =
     VariableType
       .convert[OpenlawMap[VariableName, OpenlawValue]](value)

shared/src/main/scala/org/adridadou/openlaw/parser/template/variableTypes/ExternalCall.scala

@@ -28,8 +28,8 @@ object IntegratedServiceDefinition {
   val parser = new OpenlawTemplateLanguageParserService()
   val engine = new OpenlawExecutionEngine()
   private val signatureDefinitionStr =
-    "[[Input:Structure(signerEmail: Text; contractContentBase64: Text; contractTitle: Text)]] " +
-      "[[Output:Structure(signerEmail: Text; signature: Text; recordLink: Text)]]"
+    "[[Input:Structure(signerEmail: Text; contractContentBase64: Text; contractTitle: Text; signaturePlaceholderText: Text; accessToken: Text; tokenExpiry: Number; refreshToken: Text)]] " +
+      "[[Output:Structure(signerEmail: Text; signature: Text; recordLink: Text; pdfContentsBase64: Text)]]"
 
   private val storageDefinitionStr =
     "[[Input:Structure(accessToken: Text; operation: Text; filePath: Text; fileBase64Content: Text)]] " +
@@ -41,10 +41,12 @@ object IntegratedServiceDefinition {
     IntegratedServiceDefinition(storageDefinitionStr).getOrThrow()
 
   def apply(definition: String): result.Result[IntegratedServiceDefinition] = {
-    for {
+    val result = for {
       i <- getStructure(definition, "Input")
       o <- getStructure(definition, "Output")
     } yield new IntegratedServiceDefinition(i, o)
+
+    result
   }
 
   private def getStructure(
@@ -159,26 +161,36 @@ object StorageOutput {
 final case class SignatureInput(
     signerEmail: Email,
     contractContentBase64: String,
-    contractTitle: String
+    contractTitle: String,
+    // The text that the signature service should match to determine where on the document the user should sign.
+    signaturePlaceholderText: String,
+    accessToken: String,
+    // When the token will expire as a unix timestamp
+    tokenExpiry: Long,
+    // The token to refresh the access token
+    refreshToken: String
 )
+
 object SignatureInput {
-  implicit val signatureInputEnc: Encoder[SignatureInput] = deriveEncoder
   implicit val signatureInputDec: Decoder[SignatureInput] = deriveDecoder
-  implicit val signatureInputEq: Eq[SignatureInput] = Eq.fromUniversalEquals
+
+  implicit val signatureInputEnc: Encoder[SignatureInput] = deriveEncoder
 }
 
 final case class SignatureOutput(
     signerEmail: Email,
     signature: EthereumSignature,
-    recordLink: String
+    recordLink: String,
+    pdfContentsBase64: String
 )
 object SignatureOutput {
   implicit val signatureOutputEnc: Encoder[SignatureOutput] =
     Encoder.instance[SignatureOutput] { output =>
       Json.obj(
         "signerEmail" -> Json.fromString(output.signerEmail.email),
         "signature" -> Json.fromString(output.signature.toString),
-        "recordLink" -> Json.fromString(output.recordLink)
+        "recordLink" -> Json.fromString(output.recordLink),
+        "pdfContentsBase64" -> Json.fromString(output.pdfContentsBase64)
       )
     }
   implicit val signatureOutputDec: Decoder[SignatureOutput] =
@@ -187,10 +199,12 @@ object SignatureOutput {
         signerEmail <- c.downField("signerEmail").as[Email]
         signature <- c.downField("signature").as[String]
         recordLink <- c.downField("recordLink").as[String]
+        pdfContentsBase64 <- c.downField("pdfContentsBase64").as[String]
       } yield SignatureOutput(
         signerEmail,
         EthereumSignature(signature).getOrThrow(),
-        recordLink
+        recordLink,
+        pdfContentsBase64
       )
     }
   implicit val signatureOutputEq: Eq[SignatureOutput] = Eq.fromUniversalEquals

shared/src/main/scala/org/adridadou/openlaw/parser/template/variableTypes/ExternalSignatureType.scala

@@ -7,7 +7,7 @@ import io.circe.generic.semiauto._
 import org.adridadou.openlaw.parser.template._
 import org.adridadou.openlaw.parser.template.formatters.{
   Formatter,
-  NoopFormatter
+  SignatureFormatter
 }
 import org.adridadou.openlaw.result.{Failure, FailureException, Result, Success}
 import org.adridadou.openlaw.result.Implicits._
@@ -37,7 +37,7 @@ case object ExternalSignatureType extends VariableType("ExternalSignature") {
         )
     }
 
-  override def defaultFormatter: Formatter = new NoopFormatter
+  override def defaultFormatter: Formatter = new SignatureFormatter
 
   override def construct(
       constructorParams: Parameter,