//设置package包名称以及导入依赖的类
package templates

import aws.Interpreter.ErrorsOr
import cats.data.Validated.{Invalid, Valid}
import cats.data.{NonEmptyList, Validated, ValidatedNel}
import com.amazonaws.regions.{Region, Regions}
import com.ovoenergy.comms.model.{Channel, CommManifest}

object AssetProcessing {

  private val assetTemplateReferenceRegex = "(?:'|\")(?: *)(assets)(?:/[^(\"')]+)(?: *)(?:'|\")".r

  case class ProcessedFiles(templateFiles: List[UploadedTemplateFile], assetFiles: List[UploadedTemplateFile])

  def processAssets(region: Regions,
                    assetsS3Bucket: String,
                    commManifest: CommManifest,
                    uploadedFiles: List[UploadedTemplateFile]): ErrorsOr[ProcessedFiles] = {
    import cats.syntax.traverse._
    import cats.instances.list._
    val (assetFiles, nonAssetFiles) = uploadedFiles.partition(_.fileType == Asset)
    val processedTemplateFiles: Validated[NonEmptyList[String], List[UploadedTemplateFile]] = nonAssetFiles
      .traverseU(templateFile => {
        replaceAssetReferences(region, assetsS3Bucket, templateFile.channel, commManifest, templateFile.contents)
          .map(contents => templateFile.copy(contents = contents))
      })
    processedTemplateFiles.map(ProcessedFiles(_, assetFiles)).toEither
  }

  private def replaceAssetReferences(region: Regions,
                                     assetsS3Bucket: String,
                                     channel: Channel,
                                     commManifest: CommManifest,
                                     contents: Array[Byte]): ValidatedNel[String, Array[Byte]] = {
    def replaceReferences(s3Endpoint: String, contentsString: String) = {
      val replacementAssetsPath = s"$s3Endpoint/assets"
      assetTemplateReferenceRegex
        .replaceAllIn(contentsString, m => m.group(0).replaceFirst(m.group(1), replacementAssetsPath))
        .getBytes
    }
    determineS3Endpoint(region, assetsS3Bucket, channel, commManifest).map(replaceReferences(_, new String(contents)))
  }

  private def determineS3Endpoint(region: Regions,
                                  assetsS3Bucket: String,
                                  channel: Channel,
                                  commManifest: CommManifest): ValidatedNel[String, String] = {
    if (!Region.getRegion(region).isServiceSupported("s3")) {
      Invalid(NonEmptyList.of("S3 not supported in region selected"))
    } else if (!Region.getRegion(region).hasHttpsEndpoint("s3")) {
      Invalid(NonEmptyList.of("No https support for s3 in region selected"))
    } else {
      val s3ServiceEndpoint = Region.getRegion(region).getServiceEndpoint("s3")
      Valid(
        s"https://$s3ServiceEndpoint/$assetsS3Bucket/${commManifest.commType.toString.toLowerCase}/${commManifest.name}/${commManifest.version}/${channel.toString.toLowerCase}")
    }
  }
} 

//设置package包名称以及导入依赖的类
package com.ovoenergy.comms.templates.model

import cats.data.Validated.Valid
import com.ovoenergy.comms.templates.model.RequiredTemplateData._
import org.scalatest.{FlatSpec, Matchers}

class RequiredTemplateDataSpec extends FlatSpec with Matchers {

  behavior of "combine"

  it should "combine two valid objects into one" in {
    val fst = obj(Map("a" -> string, "b" -> optString, "c" -> obj(Map("x" -> string))))

    val snd = obj(Map("b" -> optString, "c" -> obj(Map("y" -> string)), "d" -> strings))

    RequiredTemplateData.combine(List(fst, snd)) should be(
      Valid(obj(Map("a" -> string, "b" -> optString, "c" -> obj(Map("x" -> string, "y" -> string)), "d" -> strings))))
  }

  it should "combine three valid objects into one" in {
    val fst = obj(Map("a" -> string, "b" -> optString, "c" -> obj(Map("x" -> string))))

    val snd = obj(Map("b" -> optString, "c" -> obj(Map("y" -> string)), "d" -> strings))

    val trd = obj(Map("b" -> optString, "c" -> obj(Map("z" -> string)), "d" -> strings))

    RequiredTemplateData.combine(List(fst, snd, trd)) should be(
      Valid(
        obj(
          Map("a" -> string,
              "b" -> optString,
              "c" -> obj(Map("x" -> string, "y" -> string, "z" -> string)),
              "d" -> strings))))
  }

  it should "fail if two fields in an object have conflicting types" in {
    val fst = obj(Map("a" -> string, "b" -> strings, "c" -> obj(Map("x" -> string))))

    val snd = obj(Map("b" -> optString, "c" -> obj(Map("x" -> optString, "y" -> string)), "d" -> strings))

    val result = RequiredTemplateData.combine(List(fst, snd))
    result should be('Invalid)
    result.swap.foreach { nel =>
      nel.exists(_.startsWith("b is referenced")) should be(true)
      nel.exists(_.startsWith("c.x is referenced")) should be(true)
    }
  }

} 

//设置package包名称以及导入依赖的类
package com.ovoenergy.comms.templates.model.template.processed.email

import cats.Id
import cats.data.Validated.Valid
import cats.scalatest.ValidatedMatchers
import com.ovoenergy.comms.templates.ErrorsOr
import com.ovoenergy.comms.templates.model.{HandlebarsTemplate, RequiredTemplateData}
import com.ovoenergy.comms.templates.model.RequiredTemplateData.{obj, optString, string, strings}
import org.scalatest.{FlatSpec, Matchers}

class EmailTemplateSpec extends FlatSpec with Matchers with ValidatedMatchers {

  val reqData1 = obj(Map("a" -> string, "b" -> optString, "c" -> obj(Map("x" -> string))))

  val reqData2 = obj(Map("b" -> optString, "c" -> obj(Map("y" -> string)), "d" -> strings))

  val reqData3 = obj(Map("b" -> optString, "c" -> obj(Map("z" -> string)), "d" -> strings))

  behavior of "EmailTemplate"

  it should "combine the required data from parts forming the template" in {
    val template = EmailTemplate[Id](
      subject = HandlebarsTemplate("", reqData1),
      htmlBody = HandlebarsTemplate("", reqData2),
      textBody = Some(HandlebarsTemplate("", reqData3)),
      sender = None
    )

    template.requiredData should beValid(
      obj(
        Map("a" -> string,
            "b" -> optString,
            "c" -> obj(Map("x" -> string, "y" -> string, "z" -> string)),
            "d" -> strings)))
  }

  it should "combine the required data from parts forming the template no Text Body" in {
    val template = EmailTemplate[Id](
      subject = HandlebarsTemplate("", reqData1),
      htmlBody = HandlebarsTemplate("", reqData2),
      textBody = None,
      sender = None
    )

    template.requiredData should beValid(
      obj(Map("a" -> string, "b" -> optString, "c" -> obj(Map("x" -> string, "y" -> string)), "d" -> strings)))
  }

} 

//设置package包名称以及导入依赖的类
package objektwerks.validated

import org.scalatest.{FunSuite, Matchers}

class ValidatedTest extends FunSuite with Matchers {
  test("instances") {
    import cats.data.Validated
    import cats.data.Validated.Valid
    import cats.data.Validated.Invalid

    Validated.Valid(3) shouldEqual Valid(3)
    Validated.Invalid("three") shouldEqual Invalid("three")
    Validated.valid[String, Int](3) shouldEqual Valid(3)
    Validated.invalid[String, Int]("three") shouldEqual Invalid("three")
  }

  test("syntax") {
    import cats.syntax.validated._
    import cats.data.Validated.Valid
    import cats.data.Validated.Invalid

    3.valid[String] shouldEqual Valid(3)
    "three".invalid[Int] shouldEqual Invalid("three")
  }

  test("methods") {
    import cats.data.Validated
    import cats.syntax.validated._
    import cats.data.Validated.Valid

    Validated.catchOnly[NumberFormatException]("three".toInt).isInvalid shouldBe true
    Validated.catchNonFatal(sys.error("Nonfatal")).isInvalid shouldBe true
    Validated.fromTry(scala.util.Try("three".toInt)).isInvalid shouldBe true
    Validated.fromEither[String, Int](Left("Error")).isInvalid shouldBe true
    Validated.fromOption[String, Int](None, "Error").isInvalid shouldBe true
    3.valid.map(_ * 3) shouldEqual Valid(9)
  }
} 

//设置package包名称以及导入依赖的类
package com.ovoenergy.orchestration.profile

import cats.data.Validated.{Invalid, Valid}
import cats.data.{NonEmptyList, Validated}
import cats.{Apply, Semigroup}
import com.ovoenergy.comms.model.InvalidProfile
import com.ovoenergy.orchestration.domain.CustomerProfile
import com.ovoenergy.orchestration.logging.LoggingWithMDC
import com.ovoenergy.orchestration.processes.Orchestrator.ErrorDetails

object ProfileValidation extends LoggingWithMDC {

  case class ValidationError(message: String)
  case class ValidationErrors(errors: NonEmptyList[ValidationError]) {
    def errorsString: String = {
      errors.map(_.message).toList.mkString(", ")
    }
  }
  object ValidationErrors {
    def apply(message: String): ValidationErrors        = ValidationErrors(ValidationError(message))
    def apply(error: ValidationError): ValidationErrors = ValidationErrors(NonEmptyList.of(error))
    implicit val sg = new Semigroup[ValidationErrors] {
      def combine(x: ValidationErrors, y: ValidationErrors): ValidationErrors =
        ValidationErrors(x.errors.concat(y.errors))
    }
  }
  private type ValidationErrorsOr[A] = Validated[ValidationErrors, A]

  def apply(customerProfile: CustomerProfile): Either[ErrorDetails, CustomerProfile] = {
    val firstName: ValidationErrorsOr[String] = {
      if (customerProfile.name.firstName.isEmpty) Validated.invalid(ValidationErrors("Customer has no first name"))
      else Validated.valid(customerProfile.name.firstName)
    }

    val lastName: ValidationErrorsOr[String] = {
      if (customerProfile.name.lastName.isEmpty) Validated.invalid(ValidationErrors("Customer has no last name"))
      else Validated.valid(customerProfile.name.lastName)
    }

    val profileOrErrors = Apply[ValidationErrorsOr].map2(firstName, lastName) {
      case (validFirstName, validLastName) =>
        customerProfile
    }

    profileOrErrors match {
      case Valid(profile) => Right(profile)
      case Invalid(errors) =>
        Left(ErrorDetails(errors.errorsString, InvalidProfile))
    }
  }
} 

//设置package包名称以及导入依赖的类
package pl.touk.nussknacker.engine.compile

import cats.data.Validated.{Invalid, Valid}
import cats.data.{ValidatedNel, _}
import pl.touk.nussknacker.engine.compile.ProcessCompilationError.{NoParentContext, NodeId, OverwrittenVariable}
import pl.touk.nussknacker.engine.definition.DefinitionExtractor.{ClazzRef, PlainClazzDefinition}

case class ValidationContext(variables: Map[String, ClazzRef] = Map.empty,
                             typesInformation: List[PlainClazzDefinition] = List.empty,
                             parent: Option[ValidationContext] = None) {

  def apply(name: String): ClazzRef =
    get(name).getOrElse(throw new RuntimeException(s"Unknown variable: $name"))

  def get(name: String): Option[ClazzRef] =
    variables.get(name)

  def contains(name: String): Boolean = variables.contains(name)

  def withVariable(name: String, value: ClazzRef)(implicit nodeId: NodeId): ValidatedNel[PartSubGraphCompilationError, ValidationContext] =
    if (variables.contains(name)) Invalid(NonEmptyList.of(OverwrittenVariable(name))) else Valid(copy(variables = variables + (name -> value)))

  def getTypeInfo(clazzRef: ClazzRef): PlainClazzDefinition = {
    typesInformation.find(_.clazzName == clazzRef).getOrElse(throw new RuntimeException(s"Unknown clazz ref: $clazzRef"))
  }

  def pushNewContext() : ValidationContext
    = ValidationContext(Map(), typesInformation, Some(this))

  def popContext(implicit nodeId: NodeId) : ValidatedNel[PartSubGraphCompilationError, ValidationContext] = parent match {
    case Some(ctx) => Valid(ctx)
    case None => Invalid(NonEmptyList.of(NoParentContext(nodeId.id)))
  }

} 

//设置package包名称以及导入依赖的类
package pl.touk.nussknacker.engine.definition

import argonaut.PrettyParams
import cats.data.Validated.Valid
import org.scalatest.{FlatSpec, Matchers}
import pl.touk.nussknacker.engine.definition.DefinitionExtractor.{ClazzRef, ObjectDefinition, Parameter}
import pl.touk.nussknacker.engine.definition.ProcessDefinitionExtractor.{CustomTransformerAdditionalData, ProcessDefinition}
import pl.touk.nussknacker.engine.types.EspTypeUtils

class ProcessDefinitionMarshallerTest extends FlatSpec with Matchers {

  it should "work round-trip" in {
    val definition = ProcessDefinition(
      services = Map("fooService" -> ObjectDefinition.withParamsAndCategories(List(Parameter(name = "foo", typ = ClazzRef(classOf[String]))), List("cat1"))),
      sourceFactories = Map("fooSourceFactory" -> ObjectDefinition.withParamsAndCategories(List(Parameter(name = "foo", typ = ClazzRef(classOf[String]))), List("cat1"))),
      sinkFactories = Map("fooSinkFactory" -> ObjectDefinition.withParamsAndCategories(List(Parameter(name = "foo", typ = ClazzRef(classOf[String]))), List("cat1", "cat2"))),
      customStreamTransformers = Map("fooExecutorServiceFactory" ->
        (ObjectDefinition.withParamsAndCategories(List(Parameter(name = "foo", typ = ClazzRef(classOf[String]))), List("cat1")), CustomTransformerAdditionalData(Set(), false))),
      signalsWithTransformers = Map.empty,
      exceptionHandlerFactory = ObjectDefinition.noParam,
      globalVariables = Map.empty,
      typesInformation = EspTypeUtils.clazzAndItsChildrenDefinition(List.empty)
    )

    val json = ProcessDefinitionMarshaller.toJson(definition, PrettyParams.spaces2)

    ProcessDefinitionMarshaller.fromJson(json) shouldEqual Valid(definition)
  }

} 

//设置package包名称以及导入依赖的类
package pl.touk.nussknacker.engine.process.runner

import java.io.{File, FileReader}

import cats.data.Validated.{Invalid, Valid}
import com.typesafe.config.{Config, ConfigFactory}
import org.apache.commons.io.IOUtils
import pl.touk.nussknacker.engine.api.process.ProcessConfigCreator
import pl.touk.nussknacker.engine.canonicalgraph.CanonicalProcess
import pl.touk.nussknacker.engine.canonize.ProcessCanonizer
import pl.touk.nussknacker.engine.graph.EspProcess
import pl.touk.nussknacker.engine.marshall.ProcessMarshaller
import pl.touk.nussknacker.engine.util.ThreadUtils

trait FlinkRunner {

  private val ProcessMarshaller = new ProcessMarshaller


  protected def readConfigFromArgs(args: Array[String]): Config = {
    val optionalConfigArg = if (args.length > 1) Some(args(1)) else None
    readConfigFromArg(optionalConfigArg)
  }

  protected def loadCreator(config: Config): ProcessConfigCreator =
    ThreadUtils.loadUsingContextLoader(config.getString("processConfigCreatorClass")).newInstance().asInstanceOf[ProcessConfigCreator]

  protected def readProcessFromArg(arg: String): EspProcess = {
    val canonicalJson = if (arg.startsWith("@")) {
      IOUtils.toString(new FileReader(arg.substring(1)))
    } else {
      arg
    }
    ProcessMarshaller.fromJson(canonicalJson).toValidatedNel[Any, CanonicalProcess] andThen { canonical =>
      ProcessCanonizer.uncanonize(canonical)
    } match {
      case Valid(p) => p
      case Invalid(err) => throw new IllegalArgumentException(err.toList.mkString("Unmarshalling errors: ", ", ", ""))
    }
  }

  private def readConfigFromArg(arg: Option[String]): Config =
    arg match {
      case Some(name) if name.startsWith("@") =>
        ConfigFactory.parseFile(new File(name.substring(1)))
      case Some(string) =>
        ConfigFactory.parseString(string)
      case None =>
        ConfigFactory.load()
    }


} 

//设置package包名称以及导入依赖的类
package ch.becompany.akka.io.csv

import cats.data.NonEmptyList
import cats.data.Validated.{Invalid, Valid}
import org.scalatest._

class LineParserSpec extends FlatSpec with Matchers with EitherValues {

  import Parsers._

  case class Record(a: String, b: String)

  "A LineParser" should "parse lines" in {
    val line = List("foo", "bar")
    val result = LineParser[Record](line)
    result shouldBe Valid(Record("foo", "bar"))
  }

  "A LineParser" should "fail on missing elements" in {
    val line = List("foo")
    val result = LineParser[Record](line)
    result shouldBe Invalid(NonEmptyList("Excepted list element."))
  }

  "A LineParser" should "fail on surplus elements" in {
    val line = List("foo", "bar", "baz")
    val result = LineParser[Record](line)
    result shouldBe Invalid(NonEmptyList("""Expected end, got "baz"."""))
  }

} 

//设置package包名称以及导入依赖的类
package com.eddsteel.feedfilter

import model._
import model.config._
import model.Errors.{ConfigLoadError, ConfigParseError}
import cats.data.{NonEmptyList, ValidatedNel}
import cats.data.Validated.{Invalid, Valid}
import cats.implicits._

import scala.io.Source

object FeedFilters {
  type ConfigErrors = NonEmptyList[ConfigParseError]

  def allFeeds: Either[ConfigErrors, List[FeedFilter[String]]] = {
    def accumulate[L, R](in: List[ValidatedNel[L, R]]): Either[NonEmptyList[L], List[R]] = {
      val (lefts, rights) = in.foldRight((List.empty[L], List.empty[R])) {
        case (Invalid(es), (ls, rs)) => (es.toList ++ ls, rs)
        case (Valid(r), (ls, rs)) => (ls, r :: rs)
      }

      lefts match {
        case (l :: ls) =>
          Left[NonEmptyList[L], List[R]](NonEmptyList(l, ls))
        case _ =>
          Right[NonEmptyList[L], List[R]](rights)
      }
    }

    def wrap[R](either: Either[ConfigParseError, R]): Either[ConfigErrors, R] =
      either.leftMap(NonEmptyList(_, Nil))

    val sourceE: Either[ConfigErrors, String] =
      wrap(
        Either
          .catchOnly[RuntimeException](Source.fromResource("feeds.yaml"))
          .map(_.mkString)
          .leftMap[ConfigParseError](e => ConfigLoadError(e)))

    for {
      source <- sourceE
      config <- wrap(YamlFeedConfig.parse(source.mkString))
      validatedConfig <- accumulate(config.map(_.toFeedConfig))
      filters = validatedConfig.map(_.toFeedFilter)
    } yield filters
  }
} 

//设置package包名称以及导入依赖的类
package allawala.chassis.core.validation

import cats.data.Validated.{Invalid, Valid}
import cats.data.{NonEmptyList, ValidatedNel}

trait ValidateRequired {
  protected def required[T](name: String, value: Option[T]): ValidatedNel[ValidationError, T] = value match {
    case Some(v) => Valid(v)
    case None => Invalid(NonEmptyList.of(RequiredField(name)))
  }

  protected def requiredString(name: String, value: Option[String]): ValidatedNel[ValidationError, String] =
    required[String](name, value)
}

trait ValidateUnexpected {
  protected def unexpected[T](name: String, value: Option[T]): ValidatedNel[ValidationError, Option[T]] = value match {
    case Some(v) => Invalid(NonEmptyList.of(UnexpectedField(name)))
    case None => Valid(value)
  }

  protected def unexpectedString(name: String, value: Option[String]): ValidatedNel[ValidationError, Option[String]] =
    unexpected[String](name, value)
}

trait ValidateNotBlank {
  protected def notBlank(name: String, value: String): ValidatedNel[ValidationError, String] =
    if (value.trim.isEmpty) Invalid(NonEmptyList.of(NotBlank(name))) else Valid(value)

  protected def notBlank(name: String, value: Option[String]): ValidatedNel[ValidationError, Option[String]] = value match {
    case Some(v) => notBlank(name, v).map(_ => value)
    case None => Invalid(NonEmptyList.of(NotBlank(name)))
  }
}

trait ValidateMinLength {
  protected def minLength(name: String, value: String, min: Int): ValidatedNel[ValidationError, String] =
    if (value.trim.length < min) Invalid(NonEmptyList.of(MinLength(name, min))) else Valid(value)

  protected def minLength(name: String, value: Option[String], min: Int): ValidatedNel[ValidationError, Option[String]] = value match {
    case Some(v) => minLength(name, v, min).map(_ => value)
    case None => Invalid(NonEmptyList.of(MinLength(name, min)))
  }
}

trait ValidateMaxLength {
  protected def maxLength(name: String, value: String, max: Int): ValidatedNel[ValidationError, String] =
    if (value.trim.length > max) Invalid(NonEmptyList.of(MaxLength(name, max))) else Valid(value)

  protected def maxLength(name: String, value: Option[String], max: Int): ValidatedNel[ValidationError, Option[String]] = value match {
    case Some(v) => maxLength(name, v, max).map(_ => value)
    case None => Invalid(NonEmptyList.of(MaxLength(name, max)))
  }
}

trait Validate
  extends ValidateRequired
    with ValidateUnexpected
    with ValidateNotBlank
    with ValidateMinLength
    with ValidateMaxLength 

//设置package包名称以及导入依赖的类
package com.ovoenergy.comms.composer.repo

import cats.Id
import cats.data.{ReaderT, ValidatedNel}
import cats.data.Validated.{Invalid, Valid}
import com.ovoenergy.comms.model._
import com.ovoenergy.comms.templates.model.template.processed.email.EmailTemplate
import com.ovoenergy.comms.templates.model.template.processed.sms.SMSTemplate
import com.ovoenergy.comms.templates.{TemplatesContext, TemplatesRepo}

object S3TemplateRepo {

  type ErrorOr[A] = Either[String, A]

  // TODO caching: cache template files indefinitely, fragments for 5 minutes

  def getEmailTemplate(commManifest: CommManifest) = ReaderT[ErrorOr, TemplatesContext, EmailTemplate[Id]] { context =>
    val template = TemplatesRepo.getTemplate(context, commManifest).map(_.email)
    wrangle(template, commManifest)
  }

  def getSMSTemplate(commManifest: CommManifest) = ReaderT[ErrorOr, TemplatesContext, SMSTemplate[Id]] { context =>
    val template = TemplatesRepo.getTemplate(context, commManifest).map(_.sms)
    wrangle(template, commManifest)
  }

  private def wrangle[A](validated: ValidatedNel[String, Option[A]], commManifest: CommManifest): ErrorOr[A] =
    validated match {
      case Invalid(errs) =>
        Left(
          s"""The specified template (${commManifest.commType}, ${commManifest.name}, ${commManifest.version}) does not exist or is not valid.
           |The following errors were encountered:
           |
                 |${errs.toList.map(e => s" - $e").mkString("\n")}
           |""".stripMargin)

      case Valid(None) =>
        Left(
          s"The specified template (${commManifest.commType}, ${commManifest.name}, ${commManifest.version}) does not contain an email template.")

      case Valid(Some(result)) => Right(result)
    }

} 

//设置package包名称以及导入依赖的类
package com.ovoenergy.comms.composer.rendering

import com.github.jknack.handlebars.helper.DefaultHelperRegistry
import com.github.jknack.handlebars.io.StringTemplateSource
import com.github.jknack.handlebars.{Handlebars, Helper, Options}
import java.util.{Map => JMap}

import cats.data.Validated.{Invalid, Valid}
import com.ovoenergy.comms.model.{InvalidTemplate, MissingTemplateData}
import com.ovoenergy.comms.templates.model.HandlebarsTemplate

import scala.collection.mutable
import scala.util.{Failure, Success, Try}


private[rendering] object HandlebarsWrapper {

  def render(filename: String, template: HandlebarsTemplate)(context: JMap[String, AnyRef]): ErrorsOr[String] = {
    val missingKeys = mutable.Set.empty[String]

    val helperRegistry = {
      val reg = new DefaultHelperRegistry()
      reg.registerHelperMissing(new Helper[JMap[String, AnyRef]] {
        override def apply(context: JMap[String, AnyRef], options: Options): AnyRef = {
          missingKeys.add(options.helperName)
          ""
        }
      })
      reg
    }

    val handlebars = new Handlebars().`with`(helperRegistry)

    Try {
      val compiledTemplate = handlebars.compile(new StringTemplateSource(filename, template.rawExpandedContent))
      compiledTemplate.apply(context)
    } match { // note: Try has a `fold` function in Scala 2.12 :)
      case Success(result) =>
        if (missingKeys.isEmpty)
          Valid(result)
        else
          Invalid(Errors(missingKeys = missingKeys.toSet, exceptions = Nil, MissingTemplateData))
      case Failure(e) =>
        Invalid(Errors(missingKeys = Set.empty, exceptions = List(e), InvalidTemplate))
    }
  }

} 

//设置package包名称以及导入依赖的类
package fp.validated

import cats.data.NonEmptyList
import cats.data.Validated.{Invalid, Valid}
import fp.InvalidParameter
import org.scalatest.{Matchers, WordSpec}


class BookValidationValidatedSpec extends WordSpec with Matchers with BookValidationService {
  import fp.BookData._

  "BookValidation" should {

    "Validate a book" in {
      val validated = validateBook(theFountainhead)
      validated should === (Valid(NonEmptyList(theFountainhead, Nil)))
    }

    "Validate books" in {
      val validatedBooks = validateBooks(List(theFountainhead, atlasShrugged))
      validatedBooks should === (Valid(NonEmptyList(theFountainhead, atlasShrugged :: Nil)))
    }

    "Accumulate errors on a book" in {
      val validated = validateBook(titlelessBook)
      validated should === (
        Invalid(
          NonEmptyList(
            InvalidParameter("title must not be empty"),
            InvalidParameter("Book has invalid genre") :: Nil
          )
        )
      )
    }

    "Accumulate errors on books" in {
      val validatedBooks = validateBooks(List(titlelessBook, theCountOfMontecristo, theFountainhead))
      validatedBooks should === (
        Invalid(
          NonEmptyList(
            InvalidParameter("title must not be empty"),
            InvalidParameter("Book has invalid genre") :: InvalidParameter("isbn has not a valid format") :: Nil
          )
        )
      )
    }


  }
} 

//设置package包名称以及导入依赖的类
package postman.infrastructure.rendering

import com.github.jknack.handlebars.helper.DefaultHelperRegistry
import com.github.jknack.handlebars.io.StringTemplateSource
import com.github.jknack.handlebars.{Handlebars, Helper, Options}
import java.util.{Map => JMap}

import cats.data.Validated.{Invalid, Valid}
import com.ovoenergy.comms.model.{InvalidTemplate, MissingTemplateData}
import com.ovoenergy.comms.templates.model.HandlebarsTemplate

import scala.collection.mutable
import scala.util.{Failure, Success, Try}


private[rendering] object HandlebarsWrapper {

  def render(filename: String, template: HandlebarsTemplate)(context: JMap[String, AnyRef]): ErrorsOr[String] = {
    val missingKeys = mutable.Set.empty[String]

    val helperRegistry = {
      val reg = new DefaultHelperRegistry()
      reg.registerHelperMissing(new Helper[JMap[String, AnyRef]] {
        override def apply(context: JMap[String, AnyRef], options: Options): AnyRef = {
          missingKeys.add(options.helperName)
          ""
        }
      })
      reg
    }

    val handlebars = new Handlebars().`with`(helperRegistry)

    Try {
      val compiledTemplate = handlebars.compile(new StringTemplateSource(filename, template.rawExpandedContent))
      compiledTemplate.apply(context)
    } match { // note: Try has a `fold` function in Scala 2.12 :)
      case Success(result) =>
        if (missingKeys.isEmpty)
          Valid(result)
        else
          Invalid(Errors(missingKeys = missingKeys.toSet, exceptions = Nil, MissingTemplateData))
      case Failure(e) =>
        Invalid(Errors(missingKeys = Set.empty, exceptions = List(e), InvalidTemplate))
    }
  }

} 

//设置package包名称以及导入依赖的类
package postman.infrastructure.templates

import cats.Id
import cats.data.{ReaderT, ValidatedNel}
import cats.data.Validated.{Invalid, Valid}
import com.ovoenergy.comms.model._
import com.ovoenergy.comms.templates.model.template.processed.email.EmailTemplate
import com.ovoenergy.comms.templates.model.template.processed.sms.SMSTemplate
import com.ovoenergy.comms.templates.{TemplatesContext, TemplatesRepo}

object S3TemplateRepo {

  type ErrorOr[A] = Either[String, A]

  def getEmailTemplate(commManifest: CommManifest) = ReaderT[ErrorOr, TemplatesContext, EmailTemplate[Id]] { context =>
    val template = TemplatesRepo.getTemplate(context, commManifest).map(_.email)
    wrangle(template, commManifest)
  }

  def getSMSTemplate(commManifest: CommManifest) = ReaderT[ErrorOr, TemplatesContext, SMSTemplate[Id]] { context =>
    val template = TemplatesRepo.getTemplate(context, commManifest).map(_.sms)
    wrangle(template, commManifest)
  }

  private def wrangle[A](validated: ValidatedNel[String, Option[A]], commManifest: CommManifest): ErrorOr[A] =
    validated match {
      case Invalid(errs) =>
        Left(
          s"""The specified template (${commManifest.commType}, ${commManifest.name}, ${commManifest.version}) does not exist or is not valid.
           |The following errors were encountered:
           |
                 |${errs.toList.map(e => s" - $e").mkString("\n")}
           |""".stripMargin)

      case Valid(None) =>
        Left(
          s"The specified template (${commManifest.commType}, ${commManifest.name}, ${commManifest.version}) does not contain an email template.")

      case Valid(Some(result)) => Right(result)
    }

} 

//设置package包名称以及导入依赖的类
package net.cucumbersome.rpgRoller.warhammer.player.actions

import cats.data.Validated.{Invalid, Valid}
import net.cucumbersome.rpgRoller.warhammer.player.CombatActorValidator.validate
import net.cucumbersome.rpgRoller.warhammer.player.{ActorRepository, CombatActorPresenter}

import scala.concurrent.{ExecutionContext, Future}
object CreateActor {
  def createActor(repository: ActorRepository)(toBeSaved: CombatActorPresenter)(implicit ec: ExecutionContext): Future[CommandResult] =
    validate(toBeSaved) match {
      case Invalid(errors) => Future.successful(CommandFailed(errors.map(_.error).toList))
      case Valid(ca) => repository.add(ca).map(_ => Ok)
    }

}

trait CommandResult
case object Ok extends CommandResult
case class CommandFailed(errors: List[String]) extends CommandResult