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

import time.api.TimeService
import com.lightbend.lagom.javadsl.api.ServiceCall
import akka.NotUsed
import java.util.concurrent.CompletableFuture
import java.util.concurrent.CompletionStage
import java.time.LocalTime
import java.time.ZoneId

class TimeServiceImpl extends TimeService{

  
  override def timeAt(tz: String): ServiceCall[NotUsed, String] = {
    new ServiceCall[NotUsed, String] {
      
      override def invoke(obj: NotUsed) : CompletionStage[String] = {
        val c = new CompletableFuture[String]
        c.complete(LocalTime.now(ZoneId.of(tz, ZoneId.SHORT_IDS)).toString)
        c
      }
      
    }
  }
  
} 

//设置package包名称以及导入依赖的类
package io.scalac.lagom.calculator

import java.util.concurrent.CompletableFuture
import javax.inject.Inject

import akka.NotUsed
import com.lightbend.lagom.javadsl.api.ServiceCall
import io.scalac.lagom.calculator.api.{CalculatedValue, CalculatorService}
import io.scalac.lagom.rates.api.{ExchangeRatesService, ExchangeRatio}
import io.scalac.lagom.utils.Implicits._
import io.scalac.lagom.utils.ServerError

class CalculatorServiceImpl @Inject()(exchangeRatesService: ExchangeRatesService) extends CalculatorService {
  def calculate(fromValue: BigDecimal, fromUnit: String, toUnit: String): ServiceCall[NotUsed, CalculatedValue] =
    (_: NotUsed) => {
      exchangeRatesService.getExchangeRate(fromUnit, toUnit).invoke().thenCompose(
        (v1: ExchangeRatio) => v1.ratio match {
          case Some(ratio) => CompletableFuture.completedFuture[CalculatedValue](CalculatedValue(ratio, toUnit))
          case _ => {
            val v = new CompletableFuture[CalculatedValue]()
            v.completeExceptionally(ServerError(s"Could not retrive a ratio for $fromUnit-$toUnit"))
            v
          }
        }
      )
    }
} 

//设置package包名称以及导入依赖的类
package onextent.eventhubs.publisher

import java.util.concurrent.CompletableFuture
import com.microsoft.azure.eventhubs.EventHubClient
import com.microsoft.azure.servicebus.ConnectionStringBuilder
import com.typesafe.config.ConfigFactory

object EhPublisher {

  private val config = ConfigFactory.load().getConfig("main")
  private val namespaceName = config.getString("eventhubs.eventHubNamespace")
  private val eventHubName = config.getString("eventhubs.eventHubName")
  private val sasKeyName = config.getString("eventhubs.policyName")
  private val sasKey = config.getString("eventhubs.policyKey")
  private val connStr = new ConnectionStringBuilder(namespaceName,
                                                    eventHubName,
                                                    sasKeyName,
                                                    sasKey)

  val f: CompletableFuture[EventHubClient] =
    EventHubClient.createFromConnectionString(connStr.toString)
  final val ehClient: EventHubClient = f.join()

}