Scalaz Validations attempt for Resolvers

gistfile1.scala

  /**
   * The function merges job template and job type and
   * adds source and destination to the resolved object
   */
  def resolve(jobType: JobType,
              jobTemplate: JobTemplate,
              dataSource: DataSource,
              dataDestination: DataDestination): Try[JobTypeResolved] = {
    // include needed imports here to reduce lookup
    import scalaz._
    import scalaz.syntax.validation._


    /** the function implements overriding logic for fields from jobTemplate and jobType
      * @note rf == resolve field*/
    def rf[T <: AnyRef](field1: Option[T],
                        field2: Option[T],
                        fieldName: String): ValidationNel[String, T] = {
      val option = field1 orElse field2
      val err: scalaz.ValidationNel[String, T] =
        s"Neither JobTemplate nor JobType have field '$fieldName' defined.\n".failureNel
      option.fold(err)(_.successNel[String])
    }

    /** the fuction implements overriding logic but uses default instead of error
      * @note rfd == resolve field with default*/
    def rfd[T <: AnyRef](field1: Option[T], field2: Option[T], default: T): ValidationNel[String, T] = {
      (field1 orElse field2 getOrElse default).successNel[String]
    }

    /** The function is to get value from an option field */
    def get[T](field: Option[T], fieldName: String): ValidationNel[String, T] = {
      val err: scalaz.ValidationNel[String, T] =
        s"The field '$fieldName' is undefined.\n".failureNel
      field.fold(err)(_.successNel[String])
    }

    val src = {
      if (jobTemplate.sourceId == get(dataSource.id, "DataSource.id")) {
        dataSource.successNel[String]
      } else {
        s"JobTemplate.sourceId refers to wrong 'source'.\n".failureNel
      }
    }

    val dest = {
      if (jobType.destinationId == get(dataDestination.id, "DataDestination.id")) {
        dataDestination.successNel[String]
      } else {
        s"JobType.destinationId refers to wrong 'destination'.\n".failureNel
      }
    }

    val id = get(jobType.id, "JobType.id")
    val name = jobType.name.getOrElse(jobTemplate.name).successNel[String]
    val source = src
    val destination = dest
    val schedule = rf(jobType.schedule, jobTemplate.schedule, "schedule")
    val timeZone = rf(jobType.timeZone, jobTemplate.timeZone, "timeZone")
    val extractionSQL = jobTemplate.extractionSQL.successNel[String]
    val handler = rf(jobType.handler, jobTemplate.handler, "handler")
    val headerTemplates = rf(jobType.headerTemplates, jobTemplate.headerTemplates, "headerTemplate")
    val rowTemplates = rf(jobType.rowTemplates, jobTemplate.rowTemplates, "rowTemplate")
    val footerTemplates = rf(jobType.footerTemplates, jobTemplate.footerTemplates, "footerTemplate")
    val delimiter = rfd(jobType.delimiter, jobTemplate.delimiter, defaultDelimiter)
    val postProcess = rfd(jobType.postProcess, jobTemplate.postProcess, defaultPostProcess)
    val fileNameTemplates = rf(jobType.fileNameTemplates, jobTemplate.fileNameTemplates, "fileNameTemplates")
    val fileColumnSubsets = rfd(jobType.fileColumnSubsets, jobTemplate.fileColumnSubsets, defaultFileColumnSubsets)
    val columnTypes = jobTemplate.columnTypes.successNel[String]
    val columnDefaults = rfd(jobType.columnDefaults, jobTemplate.columnDefaults, defaultColumnDefaults)
    val paramValidators = jobTemplate.paramValidators.successNel[String]
    val paramValues = jobType.paramValues.successNel[String]
    val scheduledAt = jobType.scheduledAt.successNel[String]

    //could not find implicit value for parameter M1: scalaz.Semigroup[Any]
    // val errors = (id +++
    //              ^
    val result = (id |@|
      name |@|
      source |@|
      destination |@|
      schedule |@|
      timeZone |@|
      extractionSQL |@|
      handler |@|
      headerTemplates |@|
      rowTemplates |@|
      footerTemplates |@|
      delimiter |@|
      postProcess |@|
      fileNameTemplates |@|
      fileColumnSubsets |@|
      columnTypes |@|
      columnDefaults |@|
      paramValidators |@|
      paramValues |@|
      scheduledAt).apply(JobTypeResolved.apply _)
    
    println(result)
    
  }