小编Ror*_*ory的帖子

我有一系列[start_time, end_time]时间范围如下:

let timeSegments = [];
timeSegments.push(["02:00", "07:00"])
timeSegments.push(["03:00", "04:00"])

这些时间段重叠,因为2AM - 7AM包括3AM - 4AM

同样:

let timeSegments = [];
timeSegments.push(["14:00", "18:00"])
timeSegments.push(["15:00", "19:00"])

2PM以6PM与重叠3PM到7PM.

我正在使用momentjs库,并想知道一种方法来确定我的timeSegments数组是否包含任何重叠的timeSegments？timeSegments数组最多可包含10 [start_time, end_time]对.谢谢!

我只想知道是否有任何段重叠(真/假),我不需要知道哪些段重叠等.

我有以下 sbt 任务，我想将参数传递给它：

import sbt.complete._
import complete.DefaultParsers._

val stageEnv: Parser[String] = " staging" 
val prodEnv : Parser[String] = " production"
val combinedParser: Parser[String] = stageEnv | prodEnv

slick := slickCodeGenTask.value

lazy val slick = inputKey[InputTask[Seq[File]]]("gen-tables")

lazy val slickCodeGenTask = Def.inputTask {
  ...
  s.log.info(combinedParser.parsed.trim)
  Seq(file(fname))
}

但是，当我运行它并传递像“sbt slick prodEnv”这样的参数时，我收到以下错误：

[error] Not a valid command: prodEnv
[error] Not a valid project ID: prodEnv
[error] Expected ':' (if selecting a configuration)
[error] Not a valid key: prodEnv (similar: products)
[error] prodEnv
[error]  

我的数据库中有以下列，多数民众赞成是布尔值，但也接受NULL，因此true，false和NULL都是有效的：

def rtb = column[Option[Boolean]]("rtb")

并从我要过滤的客户端中获取以下可选输入：

rtbFromClient: Option[Boolean] = ... 

我有以下内容（基于有关如何在光滑的查询中进行查询的答案：https : //stackoverflow.com/a/40888918/5300930）：

val query = userTable.
      filter(row => 
          if (rtbFromClient.isDefined) 
              row.rtb.get === rtbFromClient.get 
          else 
              LiteralColumn(true)
      )

但是在代码运行时出现此错误：

Caught exception while computing default value for Rep[Option[_]].getOrElse -- This cannot be done lazily when the value is needed on the database side

我认为可能是因为row.rtb.get在调用时抛出异常，因为db中的值为null，所以尝试将其更改为row.rtb.getOrElse（null）和row.rtb.getOrElse（None），但是这些都不起作用）

还尝试了以下方法：

if (rtbFromClient.isDefined) {
    val query = query.filter(_.rtb.isDefined).filter(_.rtb.get === rtbFromClient.get)
}

但这也会在运行时引发相同的错误：

Caught exception while computing default value for Rep[Option[_]].getOrElse -- This cannot be done lazily …

我在我的路线中定义了(OData)查询参数,如下所示:

parameters(('$top.as[Int].?, '$skip.as[Int].?)) { (top, skip) =>

我有以下拒绝处理程序来处理所有无效参数(handleAll):

RejectionHandler.newBuilder()
  .handleAll[MalformedQueryParamRejection] { paramRejections =>
    // paramRejections is a Seq[MalformedQueryParamRejection]
    ...
  }

问题是当用以下方法调用时

some-endpoint?$top=invalid&$skip=invalid

在paramRejections被拒绝处理器有2个条目,既为$顶部,而不是一个$顶部,一个为$跳过.

似乎与params上的美元符号有关,因为当我删除这些东西按预期工作.这是一个已知问题还是有可用的解决方法(不包括删除美元符号)？

注意,它似乎只是拒绝处理程序,因为多个参数以美元符号开头有问题,因为当$ top和$ skip在URI中提供有效值时,路由中的这一行正确地指定top并跳转到变量:

parameters(('$top.as[Int].?, '$skip.as[Int].?)) { (top, skip) =>

如何提供数组/值列表作为typesafe / lightbend配置的环境变量？

application.conf

default-buckets = [
      10,
      30,
      100,
      300,
      1000,
      3000,
      10000,
      30000,
      100000
    ]
default-buckets = [${?DEFAULT_BUCKETS}]

因此，我想将这样的内容作为环境变量传递，以便能够覆盖默认值：

DEFAULT_BUCKETS=1000,3000

但是，出现以下错误：

com.typesafe.config.ConfigException$WrongType: env variables: buckets.default-buckets has type list of STRING rather than list of NUMBER

这有可能不需要我的应用程序代码通过调用来处理split(',')吗？

以下Java 8代码将lambda传递给一个函数,该函数仅在启用了日志记录时才推迟执行generateMessage(...)函数.

等效的Scala代码是什么样的？

producer.send(true, () -> generateMessage(1, "A Test Message"));

public void send(boolean enabled, Supplier<ProducerRecord> message) {
  if (enabled) {
    something.send(message.get())   
  }
}

对于这个案例类:

import io.circe.generic.JsonCodec

@JsonCodec
case class Stuff(things: Array[String])

此测试通过ok(case类到json测试):

import io.circe.parser.decode
import io.circe.syntax._
import org.scalatest._

val caseClass = Stuff(things = Array("one", "two"))

val json = caseClass.asJson.spaces2

json shouldEqual
      """{
         | "things" : [
         |   "one",
         |   "two"
         | ]
         |}""".stripMargin

然而,这是失败的(json到案例类测试)

import io.circe.parser.decode
import io.circe.syntax._
import org.scalatest._

val json =
      """{
         | "things" : [
         |   "one",
         |   "two"
         | ]
         |}""".stripMargin

val caseClass = Right(decode[Stuff](json))

caseClass shouldEqual Stuff(things = Array("one", "two"))

在调试器中单步执行它,似乎数组不会像我期望的那样被解码,它似乎是对象标识/内存地址,它总是不同的,所以我的测试失败了:

[Ljava.lang.String; @ 2fa7ae9

请注意,这似乎恰好发生在Arrays上,我的json blob中有很多东西我已经省略了这个例子 - Maps和嵌套的case-classes都被解码并且可以比较好,只有当Arrays被添加到比较失败 …

是否有可能在a上lazy val声明匹配,声明为a Try,像这样？

lazy val kafkaProducer: Try[producer.KafkaProducer[Array[Byte], String]] = Try(kafkaProducerSettings.createKafkaProducer())
...
kafkaProducer.get match {
  case Success(_) => Source.single(producerRecord()).runWith(Producer.plainSink(kafkaProducerSettings, kafkaProducer.get))
  case Failure(x) => Future.failed(x)
}

我收到这个错误:

constructor cannot be instantiated to expected type;
[error]  found   : akka.actor.Status.Success
[error]  required: org.apache.kafka.clients.producer.KafkaProducer[Array[Byte],String]
[error]         case Success(_) => Source.single(producerRecord()).runWith(Producer.plainSink(kafkaProducerSettings, kafkaProducer.get))

注意,这个替代代码有效,但我不确定它是"Scala方式":

lazy val kafkaProducer: producer.KafkaProducer[Array[Byte], String] = kafkaProducerSettings.createKafkaProducer()
...
val tryAccessLazyKafkaProducer = Try(kafkaProducer)
if (tryAccessLazyKafkaProducer.isSuccess) {
  Source.single(producerRecord()).runWith(Producer.plainSink(kafkaProducerSettings, kafkaProducer))
} else {
  Future.failed(tryAccessLazyKafkaProducer.failed.get)
}

我有以下光滑的实体：

class Person(personId, houseId, carId)
class House(houseId)
class Car(carId)

我想选择一个人及其可选的房屋和汽车，我的查询是：

val query = personTable
      .filter(_.personId === personId)
      .joinLeft(houseTable)
      .on(_.houseId === _.houseId)
      .joinLeft(carTable)
      .on(_._1.carId === _.carId)
      .result
      .headOption

然而，查询的返回类型看起来有点有趣，我希望它是一个元组（人，房子，汽车）：

Option[(Person, Option[House], Option[Car])]

但它实际上是一个元组（元组（人，房子），汽车）：

Option[((Person, Option[House]), Option[Car])]

返回的数据看起来确实正确，只是结构不寻常，也许我没有正确执行上面的多重连接？

下面的 Scala kafka 消费者没有从 poll调用中。

但是，主题是正确的，我可以看到使用控制台使用者将事件发送到主题：

/opt/kafka_2.11-0.10.1.0/bin/kafka-console-consumer.sh --bootstrap-server kafka:9092 --topic my_topic --from-beginning

当我使用调试器逐步完成并调用时，我还在下面的 Scala 代码示例中看到了该主题 kafkaConsumer.listTopics()

此外，这是从单个单元测试中调用的，所以我只创建了这个特征和消费者的一个实例（即另一个消费者实例不能消费消息）。我也在使用随机 group_id。

下面的代码/配置有什么问题吗？

import java.util.Properties

import org.apache.kafka.clients.consumer.KafkaConsumer
import org.apache.kafka.common.serialization.{ByteArrayDeserializer, StringDeserializer}

import scala.util.Random

trait KafkaTest {

  val kafkaConsumerProperties = new Properties()

  kafkaConsumerProperties.put("bootstrap.servers", "kafka:9092")

  kafkaConsumerProperties.put("group.id", Random.alphanumeric.take(10).mkString)

  kafkaConsumerProperties.put("key.deserializer", classOf[ByteArrayDeserializer])

  kafkaConsumerProperties.put("value.deserializer", classOf[StringDeserializer])

  val kafkaConsumer = new KafkaConsumer[String, String](kafkaConsumerProperties)

kafkaConsumer.subscribe(java.util.Collections.singletonList("my_topic"))

  def checkKafkaHasReceivedEvent(): Assertion = {

    val kafkaEvents = kafkaConsumer.poll(2000) // Always returns 0 events?
    ...
  }
}

增加轮询超时也无济于事。

我试图将以下JSON表示为Scala案例类:

     {
       "cars": {
          "THIS IS A DYNAMIC KEY 1": {
            "name": "bla 1",
          },
          "THIS IS A DYNAMIC KEY 2": {
            "name": "bla 2",
          }
          ...
      }

但是,我的JSON有动态密钥,我在运行时不会知道,我想使用circe来编码/解码.我正在使用正确的方法来使用Scala表示这个？

import io.circe.generic.JsonCodec

@JsonCodec
case class Cars(cars: List[Car])

@JsonCodec
case class Car(whatShouldThisBe: CarDetails) // Not sure how to represent this?

@JsonCodec
case class CarDetails(name: String)

对于这个嵌套数组：

$status = array(
  "house" => "OK",
  "car" => array(
      "car1" => "OK",
      "car2" => "ERROR"
   ),
   "boat" => "OK"
);

我想知道某个值“ERROR”是否在数组中至少存在一次。我不在乎它与什么键相关联，我只想知道 $status 数组中是否包含“错误”状态。

除了使用嵌套的 for 循环迭代元素之外，还有更简洁的方法吗？