com.lightbend.lagom.scaladsl.api.Service Scala Examples

package com.lightbend.lagom.scaladsl.client

import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.broker.Topic

import scala.collection.immutable

object TestServiceClient extends ServiceClientConstructor {
  override def construct[S <: Service](constructor: (ServiceClientImplementationContext) => S): S = {
    constructor(new ServiceClientImplementationContext {
      override def resolve(descriptor: Descriptor): ServiceClientContext = {
        new ServiceClientContext {
          override def createServiceCall[Request, Response](
              methodName: String,
              params: immutable.Seq[Any]
          ): ServiceCall[Request, Response] = {
            TestServiceCall(descriptor, methodName, params)
          }
          override def createTopic[Message](methodName: String): Topic[Message] = {
            TestTopic(descriptor, methodName)
          }
        }
      }
    })
  }
} 

package docs.scaladsl.mb

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall

trait AnotherService extends Service {
  final override def descriptor = {
    import Service._

    named("another-service")
      .withCalls(
        namedCall("/api/foo", foo)
      )
      .withAutoAcl(true)
  }

  def foo: ServiceCall[NotUsed, String]
} 

package docs.scaladsl.mb

import akka.Done
import akka.NotUsed

//#hello-service
import com.lightbend.lagom.scaladsl.api.broker.Topic
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import play.api.libs.json.Format
import play.api.libs.json.Json

object HelloService {
  val TOPIC_NAME = "greetings"
}
trait HelloService extends Service {
  final override def descriptor = {
    import Service._
    named("brokerdocs")
      .withCalls(
        pathCall("/api/hello/:id", hello _),
        pathCall("/api/hello/:id", useGreeting _)
      )
      .withTopics(
        topic(HelloService.TOPIC_NAME, greetingsTopic)
      )
      .withAutoAcl(true)
  }

  // The topic handle
  def greetingsTopic(): Topic[GreetingMessage]

  def hello(id: String): ServiceCall[NotUsed, String]
  def useGreeting(id: String): ServiceCall[GreetingMessage, Done]
}
//#hello-service

case class GreetingMessage(message: String)

object GreetingMessage {
  implicit val format: Format[GreetingMessage] = Json.format[GreetingMessage]
} 

package docs.scaladsl.mb

import com.lightbend.lagom.scaladsl.api.broker.Topic
import com.lightbend.lagom.scaladsl.server.LagomApplication
import com.lightbend.lagom.scaladsl.server.LagomApplicationContext
import com.lightbend.lagom.scaladsl.server.LagomServer
import com.lightbend.lagom.scaladsl.server.LocalServiceLocator
import com.lightbend.lagom.scaladsl.testkit.ServiceTest
import com.lightbend.lagom.scaladsl.testkit.TestTopicComponents
import play.api.libs.ws.ahc.AhcWSComponents
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AsyncWordSpec
import akka.NotUsed
import akka.Done
import akka.stream.scaladsl.Source
import akka.stream.testkit.scaladsl.TestSink
import akka.stream.testkit.TestSubscriber
import akka.stream.testkit.TestSubscriber.Probe

abstract class PublishApplication(context: LagomApplicationContext)
    extends LagomApplication(context)
    with AhcWSComponents {
  override lazy val lagomServer = serverFor[service.PublishService](new service.PublishServiceImpl())
}

package service {
  import com.lightbend.lagom.scaladsl.api.Service
  import com.lightbend.lagom.scaladsl.broker.TopicProducer

  object PublishService {
    val TOPIC_NAME = "events"
  }

  trait PublishService extends Service {
    final override def descriptor = {
      import Service._
      named("brokerdocs")
        .withTopics(topic(PublishService.TOPIC_NAME, events))
        .withAutoAcl(true)
    }

    def events(): Topic[PubMessage]
  }

  case class PubMessage(message: String)

  object PubMessage {
    import play.api.libs.json.Format
    import play.api.libs.json.Json
    implicit val format: Format[PubMessage] = Json.format[PubMessage]
  }

  class PublishServiceImpl() extends PublishService {
    override def events(): Topic[PubMessage] =
      TopicProducer.singleStreamWithOffset { offset =>
        Source((1 to 10)).map(i => (PubMessage(s"msg $i"), offset))
      }
  }
}

class PublishServiceSpec extends AsyncWordSpec with Matchers {
  import service._

  //#topic-test-publishing-into-a-topic
  "The PublishService" should {
    "publish events on the topic" in ServiceTest.withServer(ServiceTest.defaultSetup) { ctx =>
      new PublishApplication(ctx) with LocalServiceLocator with TestTopicComponents
    } { server =>
      implicit val system = server.actorSystem
      implicit val mat    = server.materializer

      val client: PublishService = server.serviceClient.implement[PublishService]
      val source                 = client.events().subscribe.atMostOnceSource
      source
        .runWith(TestSink.probe[PubMessage])
        .request(1)
        .expectNext should ===(PubMessage("msg 1"))
    }
  }
  //#topic-test-publishing-into-a-topic
} 

package docs.scaladsl.mb

import com.lightbend.lagom.scaladsl.api.broker.Topic
import com.lightbend.lagom.scaladsl.api.broker.kafka.KafkaProperties
import com.lightbend.lagom.scaladsl.api.broker.kafka.PartitionKeyStrategy
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import play.api.libs.json._

import scala.collection.immutable.Seq


trait BlogPostService extends Service {
  final override def descriptor: Descriptor = {
    import Service._

    //#withTopics
    named("blogpostservice")
      .withTopics(
        topic("blogposts", blogPostEvents)
          .addProperty(
            KafkaProperties.partitionKeyStrategy,
            PartitionKeyStrategy[BlogPostEvent](_.postId)
          )
      )
    //#withTopics
  }

  def blogPostEvents: Topic[BlogPostEvent]
}

//#content
sealed trait BlogPostEvent {
  def postId: String
}

case class BlogPostCreated(postId: String, title: String) extends BlogPostEvent

case class BlogPostPublished(postId: String) extends BlogPostEvent
//#content

//#content-formatters
case object BlogPostCreated {
  implicit val blogPostCreatedFormat: Format[BlogPostCreated] = Json.format
}

case object BlogPostPublished {
  implicit val blogPostPublishedFormat: Format[BlogPostPublished] = Json.format
}
//#content-formatters

//#polymorphic-play-json
object BlogPostEvent {
  implicit val reads: Reads[BlogPostEvent] = {
    (__ \ "event_type").read[String].flatMap {
      case "postCreated"   => implicitly[Reads[BlogPostCreated]].map(identity)
      case "postPublished" => implicitly[Reads[BlogPostPublished]].map(identity)
      case other           => Reads(_ => JsError(s"Unknown event type $other"))
    }
  }
  implicit val writes: Writes[BlogPostEvent] = Writes { event =>
    val (jsValue, eventType) = event match {
      case m: BlogPostCreated   => (Json.toJson(m)(BlogPostCreated.blogPostCreatedFormat), "postCreated")
      case m: BlogPostPublished => (Json.toJson(m)(BlogPostPublished.blogPostPublishedFormat), "postPublished")
    }
    jsValue.transform(__.json.update((__ \ 'event_type).json.put(JsString(eventType)))).get
  }
}

//#polymorphic-play-json 

package docs.home.scaladsl.persistence

//#imports
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.persistence.PersistentEntityRef
import com.lightbend.lagom.scaladsl.persistence.PersistentEntityRegistry

//#imports

trait BlogServiceImpl {
  trait BlogService extends Service {
    def addPost(id: String): ServiceCall[AddPost, String]

    override def descriptor = ???
  }

  //#service-impl
  class BlogServiceImpl(persistentEntities: PersistentEntityRegistry)(implicit ec: ExecutionContext)
      extends BlogService {
    persistentEntities.register(new Post)

    override def addPost(id: String): ServiceCall[AddPost, String] =
      ServiceCall { request: AddPost =>
        val ref: PersistentEntityRef[BlogCommand] =
          persistentEntities.refFor[Post](id)
        val reply: Future[AddPostDone] = ref.ask(request)
        reply.map(ack => "OK")
      }
  }
  //#service-impl

  class BlogServiceImpl2(persistentEntities: PersistentEntityRegistry)(implicit ec: ExecutionContext)
      extends BlogService {
    persistentEntities.register(new Post)

    //#service-impl2
    override def addPost(id: String) = ServiceCall { request =>
      val ref = persistentEntities.refFor[Post](id)
      ref.ask(request).map(ack => "OK")
    }
    //#service-impl2
  }
} 

package docs.home.scaladsl.persistence

//#imports
import scala.collection.immutable
import scala.collection.immutable.VectorBuilder
import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.persistence.jdbc.JdbcSession

//#imports

trait JdbcReadSideQuery {
  trait BlogService extends Service {
    def getPostSummaries(): ServiceCall[NotUsed, immutable.IndexedSeq[PostSummary]]

    override def descriptor = ???
  }

  //#service-impl
  class BlogServiceImpl(jdbcSession: JdbcSession) extends BlogService {
    import JdbcSession.tryWith

    override def getPostSummaries() = ServiceCall { request =>
      jdbcSession.withConnection { connection =>
        tryWith(connection.prepareStatement("SELECT id, title FROM blogsummary")) { ps =>
          tryWith(ps.executeQuery()) { rs =>
            val summaries = new VectorBuilder[PostSummary]
            while (rs.next()) {
              summaries += PostSummary(rs.getString("id"), rs.getString("title"))
            }
            summaries.result()
          }
        }
      }
    }
    //#service-impl
  }
} 

package docs.home.scaladsl.persistence

import com.lightbend.lagom.scaladsl.persistence.ReadSide

import com.lightbend.lagom.scaladsl.persistence.PersistentEntityRegistry
import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.Service
import akka.stream.scaladsl.Source
import akka.persistence.query.NoOffset
import com.lightbend.lagom.scaladsl.persistence.EventStreamElement
import scala.concurrent.Future

trait BlogServiceImpl3 {
  trait BlogService extends Service {
    def newPosts(): ServiceCall[NotUsed, Source[PostSummary, _]]

    override def descriptor = ???
  }

  //#register-event-processor
  class BlogServiceImpl(persistentEntityRegistry: PersistentEntityRegistry, readSide: ReadSide, myDatabase: MyDatabase)
      extends BlogService {
    readSide.register[BlogEvent](new BlogEventProcessor(myDatabase))
    //#register-event-processor

    //#event-stream
    override def newPosts(): ServiceCall[NotUsed, Source[PostSummary, _]] =
      ServiceCall { request =>
        val response: Source[PostSummary, NotUsed] =
          persistentEntityRegistry
            .eventStream(BlogEvent.Tag.forEntityId(""), NoOffset)
            .collect {
              case EventStreamElement(entityId, event: PostAdded, offset) =>
                PostSummary(event.postId, event.content.title)
            }
        Future.successful(response)
      }
    //#event-stream
  }
} 

package docs.home.scaladsl.persistence

//#imports
import scala.concurrent.Future
import akka.NotUsed
import akka.stream.scaladsl.Source
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.persistence.cassandra.CassandraSession

//#imports

trait CassandraReadSideQuery {
  trait BlogService extends Service {
    def getPostSummaries(): ServiceCall[NotUsed, Source[PostSummary, _]]

    override def descriptor = ???
  }

  //#service-impl
  class BlogServiceImpl(cassandraSession: CassandraSession) extends BlogService {
    override def getPostSummaries() = ServiceCall { request =>
      val response: Source[PostSummary, NotUsed] =
        cassandraSession
          .select("SELECT id, title FROM blogsummary")
          .map(row => PostSummary(row.getString("id"), row.getString("title")))
      Future.successful(response)
    }
  }
  //#service-impl
} 

package docs.home.scaladsl.persistence

import akka.NotUsed
//#imports
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import slick.jdbc.JdbcBackend.Database
//#imports
import docs.home.scaladsl.persistence.SlickRepos.Initial.PostSummaryRepository

trait SlickReadSideQuery {
  trait BlogService extends Service {
    def getPostSummaries(): ServiceCall[NotUsed, Seq[PostSummary]]
    override def descriptor = ???
  }

  //#service-impl
  class BlogServiceImpl(db: Database, val postSummaryRepo: PostSummaryRepository) extends BlogService {
    override def getPostSummaries() = ServiceCall { request =>
      db.run(postSummaryRepo.selectPostSummaries())
    }
    //#service-impl
  }
} 

package com.lightbend.lagom.api.tools.tests.scaladsl

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.Service._
import com.lightbend.lagom.scaladsl.api.transport.Method
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api._

import scala.concurrent.Future

trait AclService extends Service {
  def getMock(id: String): ServiceCall[NotUsed, NotUsed]

  def addMock: ServiceCall[NotUsed, NotUsed]

  def descriptor: Descriptor =
    named("/aclservice")
      .withCalls(
        restCall(Method.GET, "/scala-mocks/:id", getMock _),
        restCall(Method.POST, "/scala-mocks", addMock)
      )
      .withAutoAcl(true)
}

class AclServiceImpl extends AclService {
  def getMock(id: String) = ServiceCall { _ =>
    Future.successful(NotUsed)
  }

  def addMock: ServiceCall[NotUsed, NotUsed] = ServiceCall { _ =>
    Future.successful(NotUsed)
  }
} 

package com.lightbend.lagom.api.tools.tests.scaladsl

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.transport.Method
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.Service._

import scala.concurrent.Future

trait UndescribedService extends Service {
  def getMock(id: String): ServiceCall[NotUsed, NotUsed]

  def descriptor: Descriptor =
    named("/noaclservice").withCalls(
      restCall(Method.GET, "/mocks/:id", getMock _)
    )
}

class UndescribedServiceImpl extends UndescribedService {
  def getMock(id: String) = ServiceCall { _ =>
    Future.successful(NotUsed)
  }
} 

package com.lightbend.lagom.api.tools.tests.scaladsl

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.transport.Method
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.Service._

import scala.concurrent.Future

trait NoAclService extends Service {
  def getMock(id: String): ServiceCall[NotUsed, NotUsed]

  def descriptor: Descriptor =
    named("/noaclservice").withCalls(
      restCall(Method.GET, "/mocks/:id", getMock _)
    )
}

class NoAclServiceImpl extends NoAclService {
  def getMock(id: String) = ServiceCall { _ =>
    Future.successful(NotUsed)
  }
} 

package com.lightbend.lagom.scaladsl.akka.discovery

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.ServiceLocator
import com.lightbend.lagom.scaladsl.server.LagomApplication
import com.lightbend.lagom.scaladsl.server.LagomApplicationContext
import com.lightbend.lagom.scaladsl.server.LagomServer
import com.lightbend.lagom.scaladsl.server.LocalServiceLocator
import com.lightbend.lagom.scaladsl.testkit.ServiceTest
import org.scalatest._
import play.api.libs.ws.WSClient
import play.api.libs.ws.ahc.AhcWSComponents

import scala.concurrent.Future
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AsyncWordSpec

class AkkaDiscoveryServiceLocatorSpec extends AsyncWordSpec with Matchers with BeforeAndAfterAll with OptionValues {
  "ServiceLocator" should {
    "retrieve registered services" in {
      val serviceLocator = server.application.serviceLocator

      serviceLocator.locate("fake-service").map { res =>
        res.value.toString shouldBe "http://fake-service-host:9119"
      }
    }
  }

  private val server = ServiceTest.startServer(ServiceTest.defaultSetup) { ctx =>
    new LagomTestApplication(ctx)
  }

  protected override def afterAll() = server.stop()

  class LagomTestApplication(ctx: LagomApplicationContext)
      extends LagomApplication(ctx)
      with AhcWSComponents
      with AkkaDiscoveryComponents {
    override def lagomServer: LagomServer = serverFor[TestService](new TestServiceImpl)
  }

  trait TestService extends Service {
    def hello(name: String): ServiceCall[NotUsed, String]

    override def descriptor = {
      import Service._
      named("test-service")
        .withCalls(
          pathCall("/hello/:name", hello _)
        )
        .withAutoAcl(true)
    }
  }

  class TestServiceImpl extends TestService {
    override def hello(name: String) = ServiceCall { _ =>
      Future.successful(s"Hello $name")
    }
  }
} 

package docs.scaladsl.services

package implementhelloclient {
  import helloservice.HelloService

  import com.lightbend.lagom.scaladsl.server.LagomApplication
  import com.lightbend.lagom.scaladsl.server.LagomApplicationContext
  import play.api.libs.ws.ahc.AhcWSComponents

  //#implement-hello-client
  abstract class MyApplication(context: LagomApplicationContext)
      extends LagomApplication(context)
      with AhcWSComponents {
    lazy val helloService = serviceClient.implement[HelloService]
  }
  //#implement-hello-client
}

package helloconsumer {
  import akka.NotUsed
  import com.lightbend.lagom.scaladsl.api.Service
  import com.lightbend.lagom.scaladsl.api.ServiceCall
  import helloservice.HelloService

  import scala.concurrent.ExecutionContext
  import scala.concurrent.Future

  trait MyService extends Service {
    def sayHelloLagom: ServiceCall[NotUsed, String]

    override def descriptor = {
      import Service._

      named("myservice").withCalls(call(sayHelloLagom))
    }
  }

  //#hello-consumer
  class MyServiceImpl(helloService: HelloService)(implicit ec: ExecutionContext) extends MyService {
    override def sayHelloLagom = ServiceCall { _ =>
      val result: Future[String] =
        helloService.sayHello.invoke("Lagom")

      result.map { response =>
        s"Hello service said: $response"
      }
    }
  }
  //#hello-consumer
}

package circuitbreakers {
  import com.lightbend.lagom.scaladsl.api.Descriptor
  import com.lightbend.lagom.scaladsl.api.Service
  import com.lightbend.lagom.scaladsl.api.ServiceCall

  trait HelloServiceWithCircuitBreaker extends Service {
    def sayHi: ServiceCall[String, String]

    def hiAgain: ServiceCall[String, String]

    // @formatter:off
    //#circuit-breaker
    import com.lightbend.lagom.scaladsl.api.CircuitBreaker

    def descriptor: Descriptor = {
      import Service._

      named("hello").withCalls(
        namedCall("hi", this.sayHi),
        namedCall("hiAgain", this.hiAgain)
          .withCircuitBreaker(CircuitBreaker.identifiedBy("hello2"))
      )
    }
    //#circuit-breaker
    // @formatter:on
  }
} 

package com.lightbend.lagom.scaladsl.client.compile

import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.client.ServiceClient
import com.lightbend.lagom.scaladsl.client.ServiceClientConstructor
import com.lightbend.lagom.scaladsl.client.ServiceClientImplementationContext
import com.lightbend.lagom.macrotestkit.ShouldNotTypecheck
import Service._

object ServiceClientMacroErrors {
  ShouldNotTypecheck(
    "Abstract non service call check",
    "MacroErrorsServiceClient.implement[AbstractNonServiceCall]",
    "(?s).*abstract methods don't return service calls or topics.*foo.*"
  )

  ShouldNotTypecheck(
    "Abstract descriptor method check",
    "MacroErrorsServiceClient.implement[AbstractDescriptor]",
    ".*AbstractDescriptor\\.descriptor must be implemented.*"
  )

  ShouldNotTypecheck(
    "Overloaded method check",
    "MacroErrorsServiceClient.implement[OverloadedMethods]",
    ".*overloaded methods are: foo.*"
  )
}

object MacroErrorsServiceClient extends ServiceClientConstructor {
  override def construct[S <: Service](constructor: (ServiceClientImplementationContext) => S): S = null.asInstanceOf[S]
}

trait AbstractNonServiceCall extends Service {
  def foo: String

  override def descriptor = named("foo")
}

trait AbstractDescriptor extends Service {}

trait OverloadedMethods extends Service {
  def foo(arg: String): ServiceCall[String, String]
  def foo(arg1: String, arg2: String): ServiceCall[String, String]

  override def descriptor = named("foo")
} 

package com.lightbend.lagom.internal.scaladsl.client

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.deser.DefaultExceptionSerializer
import com.lightbend.lagom.scaladsl.api.CircuitBreaker
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.client.TestServiceClient
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers

class ScaladslServiceResolverSpec extends AnyFlatSpec with Matchers {
  behavior.of("ScaladslServiceResolver")

  it should "setup circuit-breakers for all method calls using default values when nothing is specified" in {
    assertCircuitBreaking(TestServiceClient.implement[Unspecified], CircuitBreaker.PerNode)
  }

  it should "setup circuit-breakers for all method calls using descriptor value when only descriptor's CB is specified" in {
    assertCircuitBreaking(TestServiceClient.implement[General], CircuitBreaker.identifiedBy("general-cb"))
  }

  it should "setup circuit-breakers with each specific CB when each call has a CB described" in {
    assertCircuitBreaking(TestServiceClient.implement[PerCall], CircuitBreaker.identifiedBy("one-cb"))
  }

  // --------------------------------------------------------------------------------------------
  private def assertCircuitBreaking(service: Service, expected: CircuitBreaker) = {
    val resolved = new ScaladslServiceResolver(DefaultExceptionSerializer.Unresolved).resolve(service.descriptor)
    resolved.calls.head.circuitBreaker should be(Some(expected))
  }

  trait Unspecified extends Service {
    import Service._

    def one: ServiceCall[NotUsed, NotUsed]

    override def descriptor: Descriptor = {
      named("Unspecified")
        .withCalls(
          namedCall("one", one)
        )
    }
  }

  trait General extends Service {
    import Service._

    def one: ServiceCall[NotUsed, NotUsed]

    override def descriptor: Descriptor = {
      named("Unspecified")
        .withCalls(
          namedCall("one", one)
        )
        .withCircuitBreaker(CircuitBreaker.identifiedBy("general-cb"))
    }
  }

  trait PerCall extends Service {
    import Service._

    def one: ServiceCall[NotUsed, NotUsed]

    override def descriptor: Descriptor = {
      named("Unspecified")
        .withCalls(
          namedCall("one", one)
            .withCircuitBreaker(CircuitBreaker.identifiedBy("one-cb")) // overwrites default.
        )
        .withCircuitBreaker(CircuitBreaker.identifiedBy("general-cb"))
    }
  }
} 

package com.lightbend.lagom.internal.scaladsl.server

import com.lightbend.lagom.internal.scaladsl.client.ScaladslClientMacroImpl
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.server.LagomServer
import com.lightbend.lagom.scaladsl.server.LagomServiceBinder

import scala.reflect.macros.blackbox

private[lagom] class ScaladslServerMacroImpl(override val c: blackbox.Context) extends ScaladslClientMacroImpl(c) {
  import c.universe._

  val server = q"_root_.com.lightbend.lagom.scaladsl.server"

  def simpleBind[T <: Service](serviceFactory: Tree)(implicit serviceType: WeakTypeTag[T]): Expr[LagomServer] = {
    val binder = createBinder[T]
    c.Expr[LagomServer](q"""{
      $server.LagomServer.forService(
        $binder.to($serviceFactory)
      )
    }
    """)
  }

  
  def readDescriptor[T <: Service](implicit serviceType: WeakTypeTag[T]): Expr[Descriptor] = {
    val extracted = validateServiceInterface[T](serviceType)

    val serviceMethodImpls: Seq[Tree] = (extracted.serviceCalls ++ extracted.topics).map { serviceMethod =>
      val methodParams = serviceMethod.paramLists.map { paramList =>
        paramList.map(param => q"${param.name.toTermName}: ${param.typeSignature}")
      }

      q"""
        override def ${serviceMethod.name}(...$methodParams) = {
          throw new _root_.scala.NotImplementedError("Service methods and topics must not be invoked from service trait")
        }
      """
    } match {
      case Seq() => Seq(EmptyTree)
      case s     => s
    }

    c.Expr[Descriptor](q"""
      new ${serviceType.tpe} {
        ..$serviceMethodImpls
      }.descriptor
    """)
  }
} 

package com.lightbend.lagom.scaladsl.server.mocks

import java.util.concurrent.atomic.AtomicInteger

import akka.NotUsed
import akka.stream.scaladsl.Source
import com.lightbend.lagom.scaladsl.api.Service.pathCall
import com.lightbend.lagom.scaladsl.api.Service.named
import com.lightbend.lagom.scaladsl.api.Service.restCall
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.deser.DefaultExceptionSerializer
import com.lightbend.lagom.scaladsl.api.transport.Method
import play.api.Environment
import play.api.Mode

object PathProvider {
  val PATH = "/some-path"
}


trait SimpleStreamedService extends Service {
  override def descriptor: Descriptor =
    named("simple-streamed")
      .withCalls(pathCall(PathProvider.PATH, streamed _))
      .withExceptionSerializer(new DefaultExceptionSerializer(Environment.simple(mode = Mode.Dev)))

  def streamed(): ServiceCall[Source[String, NotUsed], Source[String, NotUsed]]
} 

package com.lightbend.lagom.scaladsl.server

import akka.NotUsed
import akka.stream.scaladsl.Source
import com.lightbend.lagom.internal.scaladsl.client.ScaladslServiceResolver
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceAcl
import com.lightbend.lagom.scaladsl.api.ServiceCall
import com.lightbend.lagom.scaladsl.api.deser.DefaultExceptionSerializer
import com.lightbend.lagom.scaladsl.api.transport.Method

import scala.concurrent.Future
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AnyWordSpec

class ServiceAclResolverSpec extends AnyWordSpec with Matchers {
  class SomeService extends Service {
    private def echo[A]                                                                 = ServiceCall[A, A](Future.successful)
    def callString: ServiceCall[String, String]                                         = echo
    def callStreamed: ServiceCall[Source[String, NotUsed], Source[String, NotUsed]]     = echo
    def callNotUsed: ServiceCall[NotUsed, NotUsed]                                      = echo
    def restCallString: ServiceCall[String, String]                                     = echo
    def restCallStreamed: ServiceCall[Source[String, NotUsed], Source[String, NotUsed]] = echo
    def restCallNotUsed: ServiceCall[NotUsed, NotUsed]                                  = echo
    def withAutoAclTrue: ServiceCall[String, String]                                    = echo
    def withAutoAclFalse: ServiceCall[String, String]                                   = echo

    override def descriptor = {
      import Service._

      named("some-service").withCalls(
        call(callString),
        call(callStreamed),
        call(callNotUsed),
        restCall(Method.PUT, "/restcallstring", restCallString),
        restCall(Method.PUT, "/restcallstreamed", restCallStreamed),
        restCall(Method.PUT, "/restcallnotused", restCallNotUsed),
        call(withAutoAclTrue).withAutoAcl(true),
        call(withAutoAclFalse).withAutoAcl(false)
      )
    }
  }

  val resolver = new ScaladslServiceResolver(DefaultExceptionSerializer.Unresolved)

  "ScaladslServiceResolver" when {
    "when auto acl is true" should {
      val acls = resolver.resolve(new SomeService().descriptor.withAutoAcl(true)).acls

      "default to POST for service calls with used request messages" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.POST, "\\Q/callString\\E"))
      }

      "default to GET for streamed service calls" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.GET, "\\Q/callStreamed\\E"))
      }

      "default to GET for service calls with not used request messages" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.GET, "\\Q/callNotUsed\\E"))
      }

      "use the specified method and path for rest calls" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.PUT, "\\Q/restcallstring\\E"))
      }

      "use the specified method for rest calls when the request is streamed" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.PUT, "\\Q/restcallstreamed\\E"))
      }

      "use the specified method and path for rest calls even when the request is unused" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.PUT, "\\Q/restcallnotused\\E"))
      }

      "create an acl when an individual method has auto acl set to true" in {
        acls should contain(ServiceAcl.forMethodAndPathRegex(Method.POST, "\\Q/withAutoAclTrue\\E"))
      }

      "not create an acl when an individual method has auto acl set to false" in {
        acls should not contain ServiceAcl.forMethodAndPathRegex(Method.POST, "\\Q/withAutoAclFalse\\E")
      }

      "generate the right number of acls" in {
        acls should have size 7
      }
    }

    "auto acl is false" should {
      val acls = resolver.resolve(new SomeService().descriptor.withAutoAcl(false)).acls

      "create an acl when an individual method has auto acl set to true" in {
        acls should contain only ServiceAcl.forMethodAndPathRegex(Method.POST, "\\Q/withAutoAclTrue\\E")
      }
    }
  }
} 

package com.lightbend.lagom.scaladsl.testkit

import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths

import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.persistence.cassandra.CassandraPersistenceComponents
import com.lightbend.lagom.scaladsl.persistence.jdbc.JdbcPersistenceComponents
import com.lightbend.lagom.scaladsl.persistence.PersistenceComponents
import com.lightbend.lagom.scaladsl.persistence.PersistentEntityRegistry
import com.lightbend.lagom.scaladsl.playjson.EmptyJsonSerializerRegistry
import com.lightbend.lagom.scaladsl.playjson.JsonSerializerRegistry
import com.lightbend.lagom.scaladsl.server._
import play.api.db.HikariCPComponents
import play.api.libs.ws.ahc.AhcWSComponents

import scala.collection.JavaConverters._
import scala.util.Properties
import org.scalatest.matchers.should.Matchers
import org.scalatest.wordspec.AnyWordSpec

class ServiceTestSpec extends AnyWordSpec with Matchers {
  "ServiceTest" when {
    "started with Cassandra" should {
      "create a temporary directory" in {
        val temporaryFileCountBeforeRun = listTemporaryFiles().size

        ServiceTest.withServer(ServiceTest.defaultSetup.withCassandra())(new CassandraTestApplication(_)) { _ =>
          val temporaryFilesDuringRun = listTemporaryFiles()

          temporaryFilesDuringRun should have size (temporaryFileCountBeforeRun + 1)
        }
      }
    }

    "stopped after starting" should {
      "remove its temporary directory" in {
        val temporaryFileCountBeforeRun = listTemporaryFiles().size

        ServiceTest.withServer(ServiceTest.defaultSetup.withCassandra())(new CassandraTestApplication(_)) { _ =>
          ()
        }

        val temporaryFilesAfterRun = listTemporaryFiles()

        temporaryFilesAfterRun should have size temporaryFileCountBeforeRun
      }
    }

    "started with JDBC" should {
      "start successfully" in {
        ServiceTest.withServer(ServiceTest.defaultSetup.withJdbc())(new JdbcTestApplication(_)) { _ =>
          ()
        }
      }
    }
  }

  def listTemporaryFiles(): Iterator[Path] = {
    val tmpDir = Paths.get(Properties.tmpDir)
    Files
      .newDirectoryStream(tmpDir, "ServiceTest_*")
      .iterator()
      .asScala
  }
}

trait TestService extends Service {
  import Service._

  final override def descriptor: Descriptor = named("test")
}

class TestServiceImpl(persistentEntityRegistry: PersistentEntityRegistry) extends TestService

class TestApplication(context: LagomApplicationContext)
    extends LagomApplication(context)
    with LocalServiceLocator
    with AhcWSComponents { self: PersistenceComponents =>

  override lazy val jsonSerializerRegistry: JsonSerializerRegistry = EmptyJsonSerializerRegistry

  override lazy val lagomServer: LagomServer = serverFor[TestService](new TestServiceImpl(persistentEntityRegistry))
}

class CassandraTestApplication(context: LagomApplicationContext)
    extends TestApplication(context)
    with CassandraPersistenceComponents

class JdbcTestApplication(context: LagomApplicationContext)
    extends TestApplication(context)
    with JdbcPersistenceComponents
    with HikariCPComponents 

package docs.home.persistence

// #imports
import akka.NotUsed
import akka.stream.alpakka.couchbase.scaladsl.CouchbaseSession
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}
import com.lightbend.lagom.scaladsl.persistence.ReadSide
import com.lightbend.lagom.scaladsl.persistence.couchbase.CouchbaseReadSide
import docs.home.persistence.CouchbaseReadSideProcessorTwo.HelloEventProcessor
import play.api.libs.json.{Format, Json}

import scala.collection.JavaConverters._
import scala.concurrent.ExecutionContext
// #imports

object CouchbaseReadSideQuery {
  trait GreetingService extends Service {
    def userGreetings(): ServiceCall[NotUsed, List[UserGreeting]]

    override final def descriptor = {
      import Service._
      named("hello")
        .withCalls(
          pathCall("/api/user-greetings/", userGreetings _)
        )
        .withAutoAcl(true)
    }
  }

  case class UserGreeting(name: String, message: String)
  object UserGreeting {
    implicit val format: Format[UserGreeting] = Json.format[UserGreeting]
  }

  // #service-impl
  //#register-event-processor
  class GreetingServiceImpl(couchbaseReadSide: CouchbaseReadSide, readSideRegistry: ReadSide, session: CouchbaseSession)(
      implicit ec: ExecutionContext
  ) extends GreetingService {
    readSideRegistry.register[HelloEvent](new HelloEventProcessor(couchbaseReadSide))
    //#register-event-processor
    override def userGreetings() =
      ServiceCall { request =>
        session.get("users-actual-greetings").map {
          case Some(jsonDoc) =>
            val json = jsonDoc.content()
            json.getNames().asScala.map(name => UserGreeting(name, json.getString(name))).toList
          case None => List.empty[UserGreeting]
        }
      }
  }
  // #service-impl
} 

package me.alexray.wolfram.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall}
import me.alexray.lagom.kube.api.ServiceDescriptor

trait WolframService extends Service {

  val sd = ServiceDescriptor("wolfram", "v1")

  def query(q: String): ServiceCall[NotUsed, String]
  def simple(q: String): ServiceCall[NotUsed, Array[Byte]]

  override final def descriptor: Descriptor = {
    import Service._

    named(sd.name)
      .withCalls(
        pathCall(sd.versionedPath("query/:q"), query _),
        pathCall(sd.versionedPath("simple/:q"), simple _)
      ).withAutoAcl(true)
  }
} 

package me.alexray.helloWorldService.api

import akka.{Done, NotUsed}
import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall}
import me.alexray.lagom.kube.api.ServiceDescriptor

trait HelloWorldService extends Service {

  val sd = ServiceDescriptor("helloworldservice", "v1")

  def hello(): ServiceCall[NotUsed, List[String]]

  override final def descriptor: Descriptor = {
    import Service._
    // @formatter:off
    named(sd.name).withCalls(
      pathCall(sd.versionedPath("hello"), hello _)
    ).withAutoAcl(true)
    // @formatter:on
  }
} 

package com.packt.publishing.wf.api

import akka.{Done, NotUsed}
import com.lightbend.lagom.scaladsl.api.broker.Topic
import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall}
import com.packt.publishing.wf.api.model.WFMessage

trait WFService extends Service{

  def wfTemperature(city: String, temperature:String): ServiceCall[WFMessage, Done]

  override final def descriptor: Descriptor = {
    import Service._
    named("wfproducer").withCalls(
      pathCall("/wf/:city/:temperature", wfTemperature _)
    ).withTopics(
          topic(WFService.TOPIC_NAME, wfTopic)
     ).withAutoAcl(true)
  }

  def wfTopic(): Topic[WFMessage]
}

object WFService  {
  val TOPIC_NAME = "wfTemparature"
} 

package com.packt.publishing.wf.api

import akka.{Done, NotUsed}
import com.lightbend.lagom.scaladsl.api.broker.Topic
import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceCall}
import com.packt.publishing.wf.api.model.WFMessage

trait WFService extends Service{

  def wfTemperature(city: String, temperature:String): ServiceCall[WFMessage, Done]

  override final def descriptor: Descriptor = {
    import Service._
    named("wfproducer").withCalls(
      pathCall("/wf/:city/:temperature", wfTemperature _)
    ).withTopics(
          topic(WFService.TOPIC_NAME, wfTopic)
     ).withAutoAcl(true)
  }

  def wfTopic(): Topic[WFMessage]
}

object WFService  {
  val TOPIC_NAME = "wfTemparature"
} 

package com.baeldung.hello.api

import akka.NotUsed
import akka.stream.scaladsl.Source
import com.baeldung.hello.akka.{Job, JobAccepted, JobStatus}
import com.lightbend.lagom.scaladsl.api.{Descriptor, Service, ServiceAcl, ServiceCall}

trait HelloService extends Service {

  def submit(): ServiceCall[Job, JobAccepted]

  def status(): ServiceCall[NotUsed, Source[JobStatus, NotUsed]]

  override final def descriptor: Descriptor = {
    import Service._
    named("hello")
      .withCalls(
        pathCall("/api/submit", submit _),
        pathCall("/api/status", status _)
      )
      .withAutoAcl(true)
      .withAcls(
        ServiceAcl(pathRegex = Some("/api/play"))
      )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserQuery
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserQueryService extends Service with api.service.UserQueryService {

  override def getAll() :  ServiceCall[NotUsed, List[UserQuery]]
  override def getById(id: Int): ServiceCall[NotUsed, UserQuery]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserQuery]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserQuery]]

  def descriptor = {
    import Service._
    named("userQuery").withCalls(
      pathCall("/api/v1_0_0/userQuery/all", getAll _) ,
      pathCall("/api/v1_0_0/userQuery/:id", getById _),
      pathCall("/api/v1_0_0/userQuery/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userQuery?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowNode
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowNodeService extends Service with api.service.WorkflowNodeService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowNode]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowNode]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowNode]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowNode]]

  def descriptor = {
    import Service._
    named("workflowNode").withCalls(
      pathCall("/api/v1_0_0/workflowNode/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowNode/:id", getById _),
      pathCall("/api/v1_0_0/workflowNode/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowNode?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Replication
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationService extends Service with api.service.ReplicationService {

  override def getAll() :  ServiceCall[NotUsed, List[Replication]]
  override def getById(id: Int): ServiceCall[NotUsed, Replication]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Replication]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Replication]]

  def descriptor = {
    import Service._
    named("replication").withCalls(
      pathCall("/api/v1_0_0/replication/all", getAll _) ,
      pathCall("/api/v1_0_0/replication/:id", getById _),
      pathCall("/api/v1_0_0/replication/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replication?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PackageExport
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PackageExportService extends Service with api.service.PackageExportService {

  override def getAll() :  ServiceCall[NotUsed, List[PackageExport]]
  override def getById(id: Int): ServiceCall[NotUsed, PackageExport]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PackageExport]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PackageExport]]

  def descriptor = {
    import Service._
    named("packageExport").withCalls(
      pathCall("/api/v1_0_0/packageExport/all", getAll _) ,
      pathCall("/api/v1_0_0/packageExport/:id", getById _),
      pathCall("/api/v1_0_0/packageExport/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/packageExport?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintColor
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintColorService extends Service with api.service.PrintColorService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintColor]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintColor]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintColor]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintColor]]

  def descriptor = {
    import Service._
    named("printColor").withCalls(
      pathCall("/api/v1_0_0/printColor/all", getAll _) ,
      pathCall("/api/v1_0_0/printColor/:id", getById _),
      pathCall("/api/v1_0_0/printColor/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printColor?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.DocumentActionAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait DocumentActionAccessService extends Service with api.service.DocumentActionAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[DocumentActionAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, DocumentActionAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, DocumentActionAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[DocumentActionAccess]]

  def descriptor = {
    import Service._
    named("documentActionAccess").withCalls(
      pathCall("/api/v1_0_0/documentActionAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/documentActionAccess/:id", getById _),
      pathCall("/api/v1_0_0/documentActionAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/documentActionAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Migration
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MigrationService extends Service with api.service.MigrationService {

  override def getAll() :  ServiceCall[NotUsed, List[Migration]]
  override def getById(id: Int): ServiceCall[NotUsed, Migration]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Migration]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Migration]]

  def descriptor = {
    import Service._
    named("migration").withCalls(
      pathCall("/api/v1_0_0/migration/all", getAll _) ,
      pathCall("/api/v1_0_0/migration/:id", getById _),
      pathCall("/api/v1_0_0/migration/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/migration?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Registration
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait RegistrationService extends Service with api.service.RegistrationService {

  override def getAll() :  ServiceCall[NotUsed, List[Registration]]
  override def getById(id: Int): ServiceCall[NotUsed, Registration]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Registration]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Registration]]

  def descriptor = {
    import Service._
    named("registration").withCalls(
      pathCall("/api/v1_0_0/registration/all", getAll _) ,
      pathCall("/api/v1_0_0/registration/:id", getById _),
      pathCall("/api/v1_0_0/registration/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/registration?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReferenceEntity
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReferenceEntityService extends Service with api.service.ReferenceEntityService {

  override def getAll() :  ServiceCall[NotUsed, List[ReferenceEntity]]
  override def getById(id: Int): ServiceCall[NotUsed, ReferenceEntity]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReferenceEntity]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReferenceEntity]]

  def descriptor = {
    import Service._
    named("referenceEntity").withCalls(
      pathCall("/api/v1_0_0/referenceEntity/all", getAll _) ,
      pathCall("/api/v1_0_0/referenceEntity/:id", getById _),
      pathCall("/api/v1_0_0/referenceEntity/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/referenceEntity?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.MigrationStep
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MigrationStepService extends Service with api.service.MigrationStepService {

  override def getAll() :  ServiceCall[NotUsed, List[MigrationStep]]
  override def getById(id: Int): ServiceCall[NotUsed, MigrationStep]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, MigrationStep]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[MigrationStep]]

  def descriptor = {
    import Service._
    named("migrationStep").withCalls(
      pathCall("/api/v1_0_0/migrationStep/all", getAll _) ,
      pathCall("/api/v1_0_0/migrationStep/:id", getById _),
      pathCall("/api/v1_0_0/migrationStep/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/migrationStep?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AlertProcessorLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AlertProcessorLogService extends Service with api.service.AlertProcessorLogService {

  override def getAll() :  ServiceCall[NotUsed, List[AlertProcessorLog]]
  override def getById(id: Int): ServiceCall[NotUsed, AlertProcessorLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AlertProcessorLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AlertProcessorLog]]

  def descriptor = {
    import Service._
    named("alertProcessorLog").withCalls(
      pathCall("/api/v1_0_0/alertProcessorLog/all", getAll _) ,
      pathCall("/api/v1_0_0/alertProcessorLog/:id", getById _),
      pathCall("/api/v1_0_0/alertProcessorLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/alertProcessorLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Field
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FieldService extends Service with api.service.FieldService {

  override def getAll() :  ServiceCall[NotUsed, List[Field]]
  override def getById(id: Int): ServiceCall[NotUsed, Field]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Field]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Field]]

  def descriptor = {
    import Service._
    named("field").withCalls(
      pathCall("/api/v1_0_0/field/all", getAll _) ,
      pathCall("/api/v1_0_0/field/:id", getById _),
      pathCall("/api/v1_0_0/field/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/field?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReferenceListTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReferenceListTrlService extends Service with api.service.ReferenceListTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ReferenceListTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ReferenceListTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReferenceListTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReferenceListTrl]]

  def descriptor = {
    import Service._
    named("referenceListTrl").withCalls(
      pathCall("/api/v1_0_0/referenceListTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/referenceListTrl/:id", getById _),
      pathCall("/api/v1_0_0/referenceListTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/referenceListTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.BrowseTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait BrowseTrlService extends Service with api.service.BrowseTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[BrowseTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, BrowseTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, BrowseTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[BrowseTrl]]

  def descriptor = {
    import Service._
    named("browseTrl").withCalls(
      pathCall("/api/v1_0_0/browseTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/browseTrl/:id", getById _),
      pathCall("/api/v1_0_0/browseTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/browseTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeU4
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeU4Service extends Service with api.service.TreeNodeU4Service {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeU4]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeU4]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeU4]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeU4]]

  def descriptor = {
    import Service._
    named("treeNodeU4").withCalls(
      pathCall("/api/v1_0_0/treeNodeU4/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeU4/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeU4/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeU4?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package lagomendpoints.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{ Descriptor, Service, ServiceCall }

trait EchoService extends Service {
  def echo(id: String): ServiceCall[NotUsed, String]

  override final def descriptor = {
    import Service._
    // @formatter:off
    named("echo")
      .withCalls(
        pathCall("/api/echo/:id", echo _))
    // @formater:on
  }
} 

package lagomendpoints.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{ Descriptor, Service, ServiceCall }

trait HelloService extends Service {
  def hello(id: String): ServiceCall[NotUsed, String]

  override final def descriptor = {
    import Service._
    // @formatter:off
    named("hello")
      .withCalls(
        pathCall("/api/hello/:id", hello _))
      .withAutoAcl(true)
    // @formater:on
  }
} 

package lagomendpoints.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{ Descriptor, Service, ServiceCall }

trait EchoService extends Service {
  def echo(id: String): ServiceCall[NotUsed, String]

  override final def descriptor = {
    import Service._
    // @formatter:off
    named("echo")
      .withCalls(
        pathCall("/api/echo/:id", echo _))
    // @formater:on
  }
} 

package lagomendpoints.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{ Descriptor, Service, ServiceCall }

trait HelloService extends Service {
  def hello(id: String): ServiceCall[NotUsed, String]

  override final def descriptor = {
    import Service._
    // @formatter:off
    named("hello")
      .withCalls(
        pathCall("/api/hello/:id", hello _))
      .withAutoAcl(true)
    // @formater:on
  }
} 

package com.packt.chapter11.token.api

import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}

trait TokenService extends Service {
  def retrieveToken: ServiceCall[RetrieveTokenRequest, RetrieveTokenResult]
  def validateToken: ServiceCall[ValidateTokenRequest, ValidateTokenResult]

  override final def descriptor = {
    import Service._
    named("token").withCalls(
      pathCall("/token/retrieve", retrieveToken),
      pathCall("/token/validate", validateToken)
    ).withAutoAcl(true)
  }
} 

package com.packt.chapter11.akka.api

import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}

trait CalculatorService extends Service {
  def add(one: Int, other: Int): ServiceCall[NotUsed, Int]
  def multiply(one: Int, other: Int): ServiceCall[NotUsed, Int]

  override final def descriptor = {
    import Service._
    named("calculator").withCalls(
      pathCall("/add/:one/:other", add _),
      pathCall("/multiply/:one/:other", multiply _)
    ).withAutoAcl(true)
  }
} 

package com.packt.chapter11.trip.api

import akka.{Done, NotUsed}
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}

trait TripService extends Service {
  def startTrip(clientId: String): ServiceCall[NotUsed, Done]
  def reportLocation(clientId: String): ServiceCall[ReportLocation, Done]
  def endTrip(clientId: String): ServiceCall[NotUsed, Done]

  override final def descriptor = {
    import Service._
    named("trip").withCalls(
      pathCall("/trip/start/:id", startTrip _),
      pathCall("/trip/report/:id", reportLocation _),
      pathCall("/trip/end/:id", endTrip _)
    ).withAutoAcl(true)
  }
} 

package com.example.helloworld.api

import akka.Done
import akka.NotUsed
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.Service._
import com.lightbend.lagom.scaladsl.api.ServiceCall

trait HelloWorldService extends Service {

  
  def useGreeting(id: String, message:String): ServiceCall[NotUsed, Done]

  override final def descriptor: Descriptor = {
    // @formatter:off
    named("hello-scala")
      .withCalls(
        pathCall("/api-scala/hello/:id", hello _),
        pathCall("/api-scala/set/:id/:message", useGreeting _)
      )
    // @formatter:on
  }
} 

package com.example.shoppingcart.api

import java.time.Instant

import akka.{Done, NotUsed}
import com.lightbend.lagom.scaladsl.api.transport.Method
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}
import play.api.libs.json.{Format, Json}


trait ShoppingCartService extends Service {

  def get(id: String): ServiceCall[NotUsed, String]

  def getReport(id: String): ServiceCall[NotUsed, String]

  def updateItem(id: String, productId: String, qty: Int): ServiceCall[NotUsed, String]

  def checkout(id: String): ServiceCall[NotUsed, String]

  override final def descriptor = {
    import Service._
    named("shopping-cart")
      .withCalls(
        restCall(Method.GET, "/shoppingcart/:id", get _),
        restCall(Method.GET, "/shoppingcart/:id/report", getReport _),
        // for the RESTafarians, my formal apologies but the GET calls below do mutate state
        // we just want an easy way to mutate data from a sbt scripted test, so no POST/PUT here
        restCall(Method.GET, "/shoppingcart/:id/:productId/:num", updateItem _),
        restCall(Method.GET, "/shoppingcart/:id/checkout", checkout _)
      )
      .withAutoAcl(true)
  }
} 

package com.lightbend.lagom.devmode.internal.scaladsl.registry

import java.net.URI

import akka.NotUsed
import akka.util.ByteString
import com.lightbend.lagom.devmode.internal.registry.ServiceRegistryClient
import com.lightbend.lagom.scaladsl.api.deser.MessageSerializer.NegotiatedDeserializer
import com.lightbend.lagom.scaladsl.api.deser.MessageSerializer.NegotiatedSerializer
import com.lightbend.lagom.scaladsl.api.deser.MessageSerializer
import com.lightbend.lagom.scaladsl.api.deser.StrictMessageSerializer
import com.lightbend.lagom.scaladsl.api.transport.MessageProtocol
import com.lightbend.lagom.scaladsl.api.transport.Method
import com.lightbend.lagom.scaladsl.api.Descriptor
import com.lightbend.lagom.scaladsl.api.Service
import com.lightbend.lagom.scaladsl.api.ServiceAcl
import com.lightbend.lagom.scaladsl.api.ServiceCall
import play.api.libs.functional.syntax._
import play.api.libs.json._

import scala.collection.immutable
import scala.collection.immutable.Seq


trait ServiceRegistry extends Service {
  def register(name: String): ServiceCall[ServiceRegistryService, NotUsed]
  def unregister(name: String): ServiceCall[NotUsed, NotUsed]
  def lookup(name: String, portName: Option[String]): ServiceCall[NotUsed, URI]
  def registeredServices: ServiceCall[NotUsed, immutable.Seq[RegisteredService]]

  import Service._
  import ServiceRegistry._

  def descriptor: Descriptor = {
    named(ServiceRegistryClient.ServiceName)
      .withCalls(
        restCall(Method.PUT, "/services/:id", register _),
        restCall(Method.DELETE, "/services/:id", this.unregister _),
        restCall(Method.GET, "/services/:id?portName", lookup _),
        pathCall("/services", registeredServices)
      )
      .withLocatableService(false)
  }
}

object ServiceRegistry {
  implicit val uriMessageSerializer: MessageSerializer[URI, ByteString] = new StrictMessageSerializer[URI] {
    private val serializer = new NegotiatedSerializer[URI, ByteString] {
      override def serialize(message: URI): ByteString = ByteString.fromString(message.toString, "utf-8")
      override val protocol: MessageProtocol           = MessageProtocol.empty.withContentType("text/plain").withCharset("utf-8")
    }
    override def serializerForRequest                                                  = serializer
    override def serializerForResponse(acceptedMessageProtocols: Seq[MessageProtocol]) = serializer

    override def deserializer(protocol: MessageProtocol): NegotiatedDeserializer[URI, ByteString] =
      new NegotiatedDeserializer[URI, ByteString] {
        override def deserialize(wire: ByteString) =
          URI.create(wire.decodeString(protocol.charset.getOrElse("utf-8")))
      }
  }
}

case class RegisteredService(name: String, url: URI, portName: Option[String])

object RegisteredService {
  import UriFormat.uriFormat
  implicit val format: Format[RegisteredService] = Json.format[RegisteredService]
}

case class ServiceRegistryService(uris: immutable.Seq[URI], acls: immutable.Seq[ServiceAcl])

object ServiceRegistryService {
  def apply(uri: URI, acls: immutable.Seq[ServiceAcl]): ServiceRegistryService = ServiceRegistryService(Seq(uri), acls)

  import UriFormat.uriFormat

  implicit val methodFormat: Format[Method] =
    (__ \ "name").format[String].inmap(new Method(_), _.name)

  implicit val serviceAclFormat: Format[ServiceAcl] =
    (__ \ "method")
      .formatNullable[Method]
      .and((__ \ "pathRegex").formatNullable[String])
      .apply(ServiceAcl.apply, acl => (acl.method, acl.pathRegex))

  implicit val format: Format[ServiceRegistryService] = Json.format[ServiceRegistryService]
}

object UriFormat {
  implicit val uriFormat: Format[URI] =
    implicitly[Format[String]].inmap(URI.create, _.toString)
} 

package docs.scaladsl.services.headerfilters

package compose {
  import com.lightbend.lagom.scaladsl.api.transport.HeaderFilter
  import com.lightbend.lagom.scaladsl.api.transport.RequestHeader
  import com.lightbend.lagom.scaladsl.api.transport.ResponseHeader
  import com.lightbend.lagom.scaladsl.api.Service
  import com.lightbend.lagom.scaladsl.api.ServiceCall
  import org.slf4j.LoggerFactory

  //#verbose-filter
  class VerboseFilter(name: String) extends HeaderFilter {
    private val log = LoggerFactory.getLogger(getClass)

    def transformClientRequest(request: RequestHeader) = {
      log.debug(name + " - transforming Client Request")
      request
    }

    def transformServerRequest(request: RequestHeader) = {
      log.debug(name + " - transforming Server Request")
      request
    }

    def transformServerResponse(response: ResponseHeader, request: RequestHeader) = {
      log.debug(name + " - transforming Server Response")
      response
    }

    def transformClientResponse(response: ResponseHeader, request: RequestHeader) = {
      log.debug(name + " - transforming Client Response")
      response
    }
  }
  //#verbose-filter

  trait HelloService extends Service {
    def sayHello: ServiceCall[String, String]

    //#header-filter-composition
    def descriptor = {
      import Service._
      named("hello")
        .withCalls(
          call(sayHello)
        )
        .withHeaderFilter(
          HeaderFilter.composite(
            new VerboseFilter("Foo"),
            new VerboseFilter("Bar")
          )
        )
    }
    //#header-filter-composition
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AccessLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AccessLogService extends Service with api.service.AccessLogService {

  override def getAll() :  ServiceCall[NotUsed, List[AccessLog]]
  override def getById(id: Int): ServiceCall[NotUsed, AccessLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AccessLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AccessLog]]

  def descriptor = {
    import Service._
    named("accessLog").withCalls(
      pathCall("/api/v1_0_0/accessLog/all", getAll _) ,
      pathCall("/api/v1_0_0/accessLog/:id", getById _),
      pathCall("/api/v1_0_0/accessLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/accessLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PinStanceLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PinStanceLogService extends Service with api.service.PinStanceLogService {

  override def getAll() :  ServiceCall[NotUsed, List[PinStanceLog]]
  override def getById(id: Int): ServiceCall[NotUsed, PinStanceLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PinStanceLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PinStanceLog]]

  def descriptor = {
    import Service._
    named("pinStanceLog").withCalls(
      pathCall("/api/v1_0_0/pinStanceLog/all", getAll _) ,
      pathCall("/api/v1_0_0/pinStanceLog/:id", getById _),
      pathCall("/api/v1_0_0/pinStanceLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/pinStanceLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.EntityType
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}




trait EntityTypeService extends Service with api.service.EntityTypeService {

  override def getAll() :  ServiceCall[NotUsed, List[EntityType]]
  override def getById(id: Int): ServiceCall[NotUsed, EntityType]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, EntityType]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[EntityType]]

  def descriptor = {
    import Service._
    named("entityType").withCalls(
      pathCall("/api/v1_0_0/entityType/all", getAll _) ,
      pathCall("/api/v1_0_0/entityType/:id", getById _),
      pathCall("/api/v1_0_0/entityType/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/entityType?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserDefinedField
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserDefinedFieldService extends Service with api.service.UserDefinedFieldService {

  override def getAll() :  ServiceCall[NotUsed, List[UserDefinedField]]
  override def getById(id: Int): ServiceCall[NotUsed, UserDefinedField]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserDefinedField]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserDefinedField]]

  def descriptor = {
    import Service._
    named("userDefinedField").withCalls(
      pathCall("/api/v1_0_0/userDefinedField/all", getAll _) ,
      pathCall("/api/v1_0_0/userDefinedField/:id", getById _),
      pathCall("/api/v1_0_0/userDefinedField/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userDefinedField?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReplicationStrategy
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationStrategyService extends Service with api.service.ReplicationStrategyService {

  override def getAll() :  ServiceCall[NotUsed, List[ReplicationStrategy]]
  override def getById(id: Int): ServiceCall[NotUsed, ReplicationStrategy]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReplicationStrategy]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReplicationStrategy]]

  def descriptor = {
    import Service._
    named("replicationStrategy").withCalls(
      pathCall("/api/v1_0_0/replicationStrategy/all", getAll _) ,
      pathCall("/api/v1_0_0/replicationStrategy/:id", getById _),
      pathCall("/api/v1_0_0/replicationStrategy/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replicationStrategy?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SchedulerRecipient
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SchedulerRecipientService extends Service with api.service.SchedulerRecipientService {

  override def getAll() :  ServiceCall[NotUsed, List[SchedulerRecipient]]
  override def getById(id: Int): ServiceCall[NotUsed, SchedulerRecipient]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SchedulerRecipient]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SchedulerRecipient]]

  def descriptor = {
    import Service._
    named("schedulerRecipient").withCalls(
      pathCall("/api/v1_0_0/schedulerRecipient/all", getAll _) ,
      pathCall("/api/v1_0_0/schedulerRecipient/:id", getById _),
      pathCall("/api/v1_0_0/schedulerRecipient/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/schedulerRecipient?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReplicationOrganizationAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationOrganizationAccessService extends Service with api.service.ReplicationOrganizationAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[ReplicationOrganizationAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, ReplicationOrganizationAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReplicationOrganizationAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReplicationOrganizationAccess]]

  def descriptor = {
    import Service._
    named("replicationOrganizationAccess").withCalls(
      pathCall("/api/v1_0_0/replicationOrganizationAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/replicationOrganizationAccess/:id", getById _),
      pathCall("/api/v1_0_0/replicationOrganizationAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replicationOrganizationAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.BrowseField
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait BrowseFieldService extends Service with api.service.BrowseFieldService {

  override def getAll() :  ServiceCall[NotUsed, List[BrowseField]]
  override def getById(id: Int): ServiceCall[NotUsed, BrowseField]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, BrowseField]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[BrowseField]]

  def descriptor = {
    import Service._
    named("browseField").withCalls(
      pathCall("/api/v1_0_0/browseField/all", getAll _) ,
      pathCall("/api/v1_0_0/browseField/:id", getById _),
      pathCall("/api/v1_0_0/browseField/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/browseField?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeFavorite
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeFavoriteService extends Service with api.service.TreeFavoriteService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeFavorite]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeFavorite]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeFavorite]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeFavorite]]

  def descriptor = {
    import Service._
    named("treeFavorite").withCalls(
      pathCall("/api/v1_0_0/treeFavorite/all", getAll _) ,
      pathCall("/api/v1_0_0/treeFavorite/:id", getById _),
      pathCall("/api/v1_0_0/treeFavorite/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeFavorite?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttributeExtend
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeExtendService extends Service with api.service.AttributeExtendService {

  override def getAll() :  ServiceCall[NotUsed, List[AttributeExtend]]
  override def getById(id: Int): ServiceCall[NotUsed, AttributeExtend]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttributeExtend]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttributeExtend]]

  def descriptor = {
    import Service._
    named("attributeExtend").withCalls(
      pathCall("/api/v1_0_0/attributeExtend/all", getAll _) ,
      pathCall("/api/v1_0_0/attributeExtend/:id", getById _),
      pathCall("/api/v1_0_0/attributeExtend/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attributeExtend?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Reference
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReferenceService extends Service with api.service.ReferenceService {

  override def getAll() :  ServiceCall[NotUsed, List[Reference]]
  override def getById(id: Int): ServiceCall[NotUsed, Reference]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Reference]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Reference]]

  def descriptor = {
    import Service._
    named("reference").withCalls(
      pathCall("/api/v1_0_0/reference/all", getAll _) ,
      pathCall("/api/v1_0_0/reference/:id", getById _),
      pathCall("/api/v1_0_0/reference/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/reference?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TaskAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TaskAccessService extends Service with api.service.TaskAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[TaskAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, TaskAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TaskAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TaskAccess]]

  def descriptor = {
    import Service._
    named("taskAccess").withCalls(
      pathCall("/api/v1_0_0/TaskAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/TaskAccess/:id", getById _),
      pathCall("/api/v1_0_0/TaskAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/TaskAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttachmentNote
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttachmentNoteService extends Service with api.service.AttachmentNoteService {

  override def getAll() :  ServiceCall[NotUsed, List[AttachmentNote]]
  override def getById(id: Int): ServiceCall[NotUsed, AttachmentNote]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttachmentNote]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttachmentNote]]

  def descriptor = {
    import Service._
    named("attachmentNote").withCalls(
      pathCall("/api/v1_0_0/attachmentNote/all", getAll _) ,
      pathCall("/api/v1_0_0/attachmentNote/:id", getById _),
      pathCall("/api/v1_0_0/attachmentNote/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attachmentNote?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ChartDataSource
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ChartDataSourceService extends Service with api.service.ChartDataSourceService {

  override def getAll() :  ServiceCall[NotUsed, List[ChartDataSource]]
  override def getById(id: Int): ServiceCall[NotUsed, ChartDataSource]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ChartDataSource]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ChartDataSource]]

  def descriptor = {
    import Service._
    named("chartDataSource").withCalls(
      pathCall("/api/v1_0_0/chartDataSource/all", getAll _) ,
      pathCall("/api/v1_0_0/chartDataSource/:id", getById _),
      pathCall("/api/v1_0_0/chartDataSource/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/chartDataSource?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeCMM
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeCMMService extends Service with api.service.TreeNodeCMMService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeCMM]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeCMM]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeCMM]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeCMM]]

  def descriptor = {
    import Service._
    named("treeNodeCMM").withCalls(
      pathCall("/api/v1_0_0/treeNodeCMM/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeCMM/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeCMM/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeCMM?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ProcessAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ProcessAccessService extends Service with api.service.ProcessAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[ProcessAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, ProcessAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ProcessAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ProcessAccess]]

  def descriptor = {
    import Service._
    named("processAccess").withCalls(
      pathCall("/api/v1_0_0/processAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/processAccess/:id", getById _),
      pathCall("/api/v1_0_0/processAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/processAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SearchDefinition
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SearchDefinitionService extends Service with api.service.SearchDefinitionService {

  override def getAll() :  ServiceCall[NotUsed, List[SearchDefinition]]
  override def getById(id: Int): ServiceCall[NotUsed, SearchDefinition]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SearchDefinition]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SearchDefinition]]

  def descriptor = {
    import Service._
    named("searchDefinition").withCalls(
      pathCall("/api/v1_0_0/searchDefinition/all", getAll _) ,
      pathCall("/api/v1_0_0/searchDefinition/:id", getById _),
      pathCall("/api/v1_0_0/searchDefinition/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/searchDefinition?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Element
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}


trait ElementService extends Service with api.service.ElementService {

  override def getAll() :  ServiceCall[NotUsed, List[Element]]
  override def getById(id: Int): ServiceCall[NotUsed, Element]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Element]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Element]]

 def descriptor = {
    import Service._
    named("element").withCalls(
      pathCall("/api/v1_0_0/element/all", getAll _) ,
      pathCall("/api/v1_0_0/element/:id", getById _),
      pathCall("/api/v1_0_0/element/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/element?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReportViewTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReportViewTrlService extends Service with api.service.ReportViewTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ReportViewTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ReportViewTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReportViewTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReportViewTrl]]

  def descriptor = {
    import Service._
    named("reportViewTrl").withCalls(
      pathCall("/api/v1_0_0/reportViewTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/reportViewTrl/:id", getById _),
      pathCall("/api/v1_0_0/reportViewTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/reportViewTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.RecentItem
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait RecentItemService extends Service with api.service.RecentItemService {

  override def getAll() :  ServiceCall[NotUsed, List[RecentItem]]
  override def getById(id: Int): ServiceCall[NotUsed, RecentItem]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, RecentItem]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[RecentItem]]

  def descriptor = {
    import Service._
    named("recentItem").withCalls(
      pathCall("/api/v1_0_0/recentItem/all", getAll _) ,
      pathCall("/api/v1_0_0/recentItem/:id", getById _),
      pathCall("/api/v1_0_0/recentItem/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/recentItem?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ImportFormat
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ImportFormatService extends Service with api.service.ImportFormatService {

  override def getAll() :  ServiceCall[NotUsed, List[ImportFormat]]
  override def getById(id: Int): ServiceCall[NotUsed, ImportFormat]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ImportFormat]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ImportFormat]]

  def descriptor = {
    import Service._
    named("importFormat").withCalls(
      pathCall("/api/v1_0_0/importFormat/all", getAll _) ,
      pathCall("/api/v1_0_0/importFormat/:id", getById _),
      pathCall("/api/v1_0_0/importFormat/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/importFormat?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.MigrationData
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MigrationDataService extends Service with api.service.MigrationDataService {

  override def getAll() :  ServiceCall[NotUsed, List[MigrationData]]
  override def getById(id: Int): ServiceCall[NotUsed, MigrationData]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, MigrationData]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[MigrationData]]

  def descriptor = {
    import Service._
    named("migrationData").withCalls(
      pathCall("/api/v1_0_0/migrationData/all", getAll _) ,
      pathCall("/api/v1_0_0/migrationData/:id", getById _),
      pathCall("/api/v1_0_0/migrationData/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/migrationData?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeU1
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeU1Service extends Service with api.service.TreeNodeU1Service {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeU1]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeU1]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeU1]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeU1]]

  def descriptor = {
    import Service._
    named("treeNodeU1").withCalls(
      pathCall("/api/v1_0_0/treeNodeU1/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeU1/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeU1/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeU1?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReportViewAttribute
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReportViewAttributeService extends Service with api.service.ReportViewAttributeService {

  override def getAll() :  ServiceCall[NotUsed, List[ReportViewAttribute]]
  override def getById(id: Int): ServiceCall[NotUsed, ReportViewAttribute]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReportViewAttribute]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReportViewAttribute]]

  def descriptor = {
    import Service._
    named("reportViewAttribute").withCalls(
      pathCall("/api/v1_0_0/reportViewAttribute/all", getAll _) ,
      pathCall("/api/v1_0_0/reportViewAttribute/:id", getById _),
      pathCall("/api/v1_0_0/reportViewAttribute/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/reportViewAttribute?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReplicationTable
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationTableService extends Service with api.service.ReplicationTableService {

  override def getAll() :  ServiceCall[NotUsed, List[ReplicationTable]]
  override def getById(id: Int): ServiceCall[NotUsed, ReplicationTable]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReplicationTable]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReplicationTable]]

  def descriptor = {
    import Service._
    named("replicationTable").withCalls(
      pathCall("/api/v1_0_0/replicationTable/all", getAll _) ,
      pathCall("/api/v1_0_0/replicationTable/:id", getById _),
      pathCall("/api/v1_0_0/replicationTable/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replicationTable?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Language
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait LanguageService extends Service with api.service.LanguageService {

  override def getAll() :  ServiceCall[NotUsed, List[Language]]
  override def getById(id: Int): ServiceCall[NotUsed, Language]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Language]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Language]]

  def descriptor = {
    import Service._
    named("language").withCalls(
      pathCall("/api/v1_0_0/language/all", getAll _) ,
      pathCall("/api/v1_0_0/language/:id", getById _),
      pathCall("/api/v1_0_0/language/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/language?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrivateAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrivateAccessService extends Service with api.service.PrivateAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[PrivateAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, PrivateAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrivateAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrivateAccess]]

  def descriptor = {
    import Service._
    named("privateAccess").withCalls(
      pathCall("/api/v1_0_0/privateAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/privateAccess/:id", getById _),
      pathCall("/api/v1_0_0/privateAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/privateAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Workflow
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowService extends Service with api.service.WorkflowService {

  override def getAll() :  ServiceCall[NotUsed, List[Workflow]]
  override def getById(id: Int): ServiceCall[NotUsed, Workflow]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Workflow]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Workflow]]

  def descriptor = {
    import Service._
    named("workflow").withCalls(
      pathCall("/api/v1_0_0/workflow/all", getAll _) ,
      pathCall("/api/v1_0_0/workflow/:id", getById _),
      pathCall("/api/v1_0_0/workflow/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflow?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SequenceAudit
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SequenceAuditService extends Service with api.service.SequenceAuditService {

  override def getAll() :  ServiceCall[NotUsed, List[SequenceAudit]]
  override def getById(id: Int): ServiceCall[NotUsed, SequenceAudit]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SequenceAudit]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SequenceAudit]]

  def descriptor = {
    import Service._
    named("sequenceAudit").withCalls(
      pathCall("/api/v1_0_0/sequenceAudit/all", getAll _) ,
      pathCall("/api/v1_0_0/sequenceAudit/:id", getById _),
      pathCall("/api/v1_0_0/sequenceAudit/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/sequenceAudit?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service
import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Window
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WindowService extends Service with api.service.WindowService {

  override def getAll() :  ServiceCall[NotUsed, List[Window]]
  override def getById(id: Int): ServiceCall[NotUsed, Window]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Window]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Window]]

  def descriptor = {
    import Service._
    named("window").withCalls(
      pathCall("/api/v1_0_0/window/all", getAll _) ,
      pathCall("/api/v1_0_0/window/:id", getById _),
      pathCall("/api/v1_0_0/window/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/window?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PackageExportCommon
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PackageExportCommonService extends Service with api.service.PackageExportCommonService {

  override def getAll() :  ServiceCall[NotUsed, List[PackageExportCommon]]
  override def getById(id: Int): ServiceCall[NotUsed, PackageExportCommon]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PackageExportCommon]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PackageExportCommon]]

  def descriptor = {
    import Service._
    named("packageExportCommon").withCalls(
      pathCall("/api/v1_0_0/packageExportCommon/all", getAll _) ,
      pathCall("/api/v1_0_0/packageExportCommon/:id", getById _),
      pathCall("/api/v1_0_0/packageExportCommon/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/packageExportCommon?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Message
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MessageService extends Service with api.service.MessageService {

  override def getAll() :  ServiceCall[NotUsed, List[Message]]
  override def getById(id: Int): ServiceCall[NotUsed, Message]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Message]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Message]]

  def descriptor = {
    import Service._
    named("message").withCalls(
      pathCall("/api/v1_0_0/message/all", getAll _) ,
      pathCall("/api/v1_0_0/message/:id", getById _),
      pathCall("/api/v1_0_0/message/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/message?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowNodeTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowNodeTrlService extends Service with api.service.WorkflowNodeTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowNodeTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowNodeTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowNodeTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowNodeTrl]]

  def descriptor = {
    import Service._
    named("workflowNodeTrl").withCalls(
      pathCall("/api/v1_0_0/workflowNodeTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowNodeTrl/:id", getById _),
      pathCall("/api/v1_0_0/workflowNodeTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowNodeTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserRoles
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserRolesService extends Service with api.service.UserRolesService {

  override def getAll() :  ServiceCall[NotUsed, List[UserRoles]]
  override def getById(id: Int): ServiceCall[NotUsed, UserRoles]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserRoles]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserRoles]]

  def descriptor = {
    import Service._
    named("userRoles").withCalls(
      pathCall("/api/v1_0_0/userRoles/all", getAll _) ,
      pathCall("/api/v1_0_0/userRoles/:id", getById _),
      pathCall("/api/v1_0_0/userRoles/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userRoles?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintLabel
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}




trait PrintLabelService extends Service with api.service.PrintLabelService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintLabel]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintLabel]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintLabel]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintLabel]]

  def descriptor = {
    import Service._
    named("printLabel").withCalls(
      pathCall("/api/v1_0_0/printLabel/all", getAll _) ,
      pathCall("/api/v1_0_0/printLabel/:id", getById _),
      pathCall("/api/v1_0_0/printLabel/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printLabel?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodePR
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodePRService extends Service with api.service.TreeNodePRService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodePR]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodePR]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodePR]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodePR]]

  def descriptor = {
    import Service._
    named("treeNodePR").withCalls(
      pathCall("/api/v1_0_0/treeNodePR/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodePR/:id", getById _),
      pathCall("/api/v1_0_0/treeNodePR/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodePR?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ModelValidator
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ModelValidatorService extends Service with api.service.ModelValidatorService {

  override def getAll() :  ServiceCall[NotUsed, List[ModelValidator]]
  override def getById(id: Int): ServiceCall[NotUsed, ModelValidator]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ModelValidator]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ModelValidator]]

  def descriptor = {
    import Service._
    named("modelValidator").withCalls(
      pathCall("/api/v1_0_0/modelValidator/all", getAll _) ,
      pathCall("/api/v1_0_0/modelValidator/:id", getById _),
      pathCall("/api/v1_0_0/modelValidator/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/modelValidator?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeCMS
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeCMSService extends Service with api.service.TreeNodeCMSService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeCMS]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeCMS]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeCMS]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeCMS]]

  def descriptor = {
    import Service._
    named("treeNodeCMS").withCalls(
      pathCall("/api/v1_0_0/treeNodeCMS/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeCMS/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeCMS/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeCMS?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttributeProcess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeProcessService extends Service with api.service.AttributeProcessService {

  override def getAll() :  ServiceCall[NotUsed, List[AttributeProcess]]
  override def getById(id: Int): ServiceCall[NotUsed, AttributeProcess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttributeProcess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttributeProcess]]

  def descriptor = {
    import Service._
    named("attributeProcess").withCalls(
      pathCall("/api/v1_0_0/attributeProcess/all", getAll _) ,
      pathCall("/api/v1_0_0/attributeProcess/:id", getById _),
      pathCall("/api/v1_0_0/attributeProcess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attributeProcess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WindowTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WindowTrlService extends Service with api.service.WindowTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[WindowTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, WindowTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WindowTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WindowTrl]]

  def descriptor = {
    import Service._
    named("windowTrl").withCalls(
      pathCall("/api/v1_0_0/windowTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/windowTrl/:id", getById _),
      pathCall("/api/v1_0_0/windowTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/windowTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SysConfig
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SysConfigService extends Service with api.service.SysConfigService {

  override def getAll() :  ServiceCall[NotUsed, List[SysConfig]]
  override def getById(id: Int): ServiceCall[NotUsed, SysConfig]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SysConfig]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SysConfig]]

  def descriptor = {
    import Service._
    named("sysConfig").withCalls(
      pathCall("/api/v1_0_0/sysConfig/all", getAll _) ,
      pathCall("/api/v1_0_0/sysConfig/:id", getById _),
      pathCall("/api/v1_0_0/sysConfig/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/sysConfig?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.LdapProcessor
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait LdapProcessorService extends Service with api.service.LdapProcessorService {

  override def getAll() :  ServiceCall[NotUsed, List[LdapProcessor]]
  override def getById(id: Int): ServiceCall[NotUsed, LdapProcessor]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, LdapProcessor]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[LdapProcessor]]

  def descriptor = {
    import Service._
    named("ldapProcessor").withCalls(
      pathCall("/api/v1_0_0/ldapProcessor/all", getAll _) ,
      pathCall("/api/v1_0_0/ldapProcessor/:id", getById _),
      pathCall("/api/v1_0_0/ldapProcessor/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/ldapProcessor?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PackageExportDetail
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PackageExportDetailService extends Service with api.service.PackageExportDetailService {

  override def getAll() :  ServiceCall[NotUsed, List[PackageExportDetail]]
  override def getById(id: Int): ServiceCall[NotUsed, PackageExportDetail]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PackageExportDetail]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PackageExportDetail]]

  def descriptor = {
    import Service._
    named("packageExportDetail").withCalls(
      pathCall("/api/v1_0_0/packageExportDetail/all", getAll _) ,
      pathCall("/api/v1_0_0/packageExportDetail/:id", getById _),
      pathCall("/api/v1_0_0/packageExportDetail/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/packageExportDetail?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Attribute
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeService extends Service with api.service.AttributeService {

  override def getAll() :  ServiceCall[NotUsed, List[Attribute]]
  override def getById(id: Int): ServiceCall[NotUsed, Attribute]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Attribute]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Attribute]]

  def descriptor = {
    import Service._
    named("attribute").withCalls(
      pathCall("/api/v1_0_0/attribute/all", getAll _) ,
      pathCall("/api/v1_0_0/attribute/:id", getById _),
      pathCall("/api/v1_0_0/attribute/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attribute?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkbenchTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkbenchTrlService extends Service with api.service.WorkbenchTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkbenchTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkbenchTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkbenchTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkbenchTrl]]

  def descriptor = {
    import Service._
    named("workbenchTrl").withCalls(
      pathCall("/api/v1_0_0/workbenchTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/workbenchTrl/:id", getById _),
      pathCall("/api/v1_0_0/workbenchTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workbenchTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TenantShare
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TenantShareService extends Service with api.service.TenantShareService {

  override def getAll() :  ServiceCall[NotUsed, List[TenantShare]]
  override def getById(id: Int): ServiceCall[NotUsed, TenantShare]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TenantShare]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TenantShare]]

  def descriptor = {
    import Service._
    named("tenantShare").withCalls(
      pathCall("/api/v1_0_0/tenantShare/all", getAll _) ,
      pathCall("/api/v1_0_0/tenantShare/:id", getById _),
      pathCall("/api/v1_0_0/tenantShare/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/tenantShare?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PackageImportBackup
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PackageImportBackupService extends Service with api.service.PackageImportBackupService {

  override def getAll() :  ServiceCall[NotUsed, List[PackageImportBackup]]
  override def getById(id: Int): ServiceCall[NotUsed, PackageImportBackup]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PackageImportBackup]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PackageImportBackup]]

  def descriptor = {
    import Service._
    named("packageImportBackup").withCalls(
      pathCall("/api/v1_0_0/packageImportBackup/all", getAll _) ,
      pathCall("/api/v1_0_0/packageImportBackup/:id", getById _),
      pathCall("/api/v1_0_0/packageImportBackup/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/packageImportBackup?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowNodeNext
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowNodeNextService extends Service with api.service.WorkflowNodeNextService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowNodeNext]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowNodeNext]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowNodeNext]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowNodeNext]]

  def descriptor = {
    import Service._
    named("workflowNodeNext").withCalls(
      pathCall("/api/v1_0_0/workflowNodeNext/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowNodeNext/:id", getById _),
      pathCall("/api/v1_0_0/workflowNodeNext/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowNodeNext?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.View
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ViewService extends Service with api.service.ViewService {

  override def getAll() :  ServiceCall[NotUsed, List[View]]
  override def getById(id: Int): ServiceCall[NotUsed, View]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, View]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[View]]

  def descriptor = {
    import Service._
    named("view").withCalls(
      pathCall("/api/v1_0_0/view/all", getAll _) ,
      pathCall("/api/v1_0_0/view/:id", getById _),
      pathCall("/api/v1_0_0/view/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/view?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Menu
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MenuService extends Service with api.service.MenuService {

  override def getAll() :  ServiceCall[NotUsed, List[Menu]]
  override def getById(id: Int): ServiceCall[NotUsed, Menu]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Menu]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Menu]]

  def descriptor = {
    import Service._
    named("menu").withCalls(
      pathCall("/api/v1_0_0/menu/all", getAll _) ,
      pathCall("/api/v1_0_0/menu/:id", getById _),
      pathCall("/api/v1_0_0/menu/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/menu?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.FieldGroupTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FieldGroupTrlService extends Service with api.service.FieldGroupTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[FieldGroupTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, FieldGroupTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, FieldGroupTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[FieldGroupTrl]]

  def descriptor = {
    import Service._
    named("fieldGroupTrl").withCalls(
      pathCall("/api/v1_0_0/fieldGroupTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/fieldGroupTrl/:id", getById _),
      pathCall("/api/v1_0_0/fieldGroupTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/fieldGroupTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowResponsible
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowResponsibleService extends Service with api.service.WorkflowResponsibleService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowResponsible]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowResponsible]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowResponsible]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowResponsible]]

  def descriptor = {
    import Service._
    named("workflowResponsible").withCalls(
      pathCall("/api/v1_0_0/workflowResponsible/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowResponsible/:id", getById _),
      pathCall("/api/v1_0_0/workflowResponsible/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowResponsible?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.{Attribute, Entity}
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}


trait EntityService extends Service with api.service.EntityService {

  override def getAll() :  ServiceCall[NotUsed, List[Entity]]
  override def getById(id: Int): ServiceCall[NotUsed, Entity]
  override def getAttributes(id: Int): ServiceCall[NotUsed, List[Attribute]]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Entity]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Entity]]

  def descriptor = {
    import Service._
    named("entity").withCalls(
      pathCall("/api/v1_0_0/entity/all", getAll _) ,
      pathCall("/api/v1_0_0/entity/:id", getById _),
      pathCall("/api/v1_0_0/entity/:id/attributes", getAttributes _),
      pathCall("/api/v1_0_0/entity/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/entity?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Find
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FindService extends Service with api.service.FindService {

  override def getAll() :  ServiceCall[NotUsed, List[Find]]
  override def getById(id: Int): ServiceCall[NotUsed, Find]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Find]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Find]]

  def descriptor = {
    import Service._
    named("find").withCalls(
      pathCall("/api/v1_0_0/find/all", getAll _) ,
      pathCall("/api/v1_0_0/find/:id", getById _),
      pathCall("/api/v1_0_0/find/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/find?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttributeAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeAccessService extends Service with api.service.AttributeAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[AttributeAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, AttributeAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttributeAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttributeAccess]]

  def descriptor = {
    import Service._
    named("attributeAccess").withCalls(
      pathCall("/api/v1_0_0/attributeAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/attributeAccess/:id", getById _),
      pathCall("/api/v1_0_0/attributeAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attributeAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.MessageTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MessageTrlService extends Service with api.service.MessageTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[MessageTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, MessageTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, MessageTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[MessageTrl]]

  def descriptor = {
    import Service._
    named("messageTrl").withCalls(
      pathCall("/api/v1_0_0/messageTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/messageTrl/:id", getById _),
      pathCall("/api/v1_0_0/messageTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/messageTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReplicationRoleAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationRoleAccessService extends Service with api.service.ReplicationRoleAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[ReplicationRoleAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, ReplicationRoleAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReplicationRoleAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReplicationRoleAccess]]

  def descriptor = {
    import Service._
    named("replicationRoleAccess").withCalls(
      pathCall("/api/v1_0_0/replicationRoleAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/replicationRoleAccess/:id", getById _),
      pathCall("/api/v1_0_0/replicationRoleAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replicationRoleAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Task
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TaskService extends Service with api.service.TaskService {

  override def getAll() :  ServiceCall[NotUsed, List[Task]]
  override def getById(id: Int): ServiceCall[NotUsed, Task]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Task]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Task]]

  def descriptor = {
    import Service._
    named("task").withCalls(
      pathCall("/api/v1_0_0/task/all", getAll _) ,
      pathCall("/api/v1_0_0/task/:id", getById _),
      pathCall("/api/v1_0_0/task/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/task?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.InformationColumn
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait InformationColumnService extends Service with api.service.InformationColumnService {

  override def getAll() :  ServiceCall[NotUsed, List[InformationColumn]]
  override def getById(id: Int): ServiceCall[NotUsed, InformationColumn]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, InformationColumn]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[InformationColumn]]

  def descriptor = {
    import Service._
    named("informationColumn").withCalls(
      pathCall("/api/v1_0_0/informationColumn/all", getAll _) ,
      pathCall("/api/v1_0_0/informationColumn/:id", getById _),
      pathCall("/api/v1_0_0/informationColumn/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/informationColumn?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.EmailConfig
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait EmailConfigService extends Service with api.service.EmailConfigService {

  override def getAll() :  ServiceCall[NotUsed, List[EmailConfig]]
  override def getById(id: Int): ServiceCall[NotUsed, EmailConfig]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, EmailConfig]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[EmailConfig]]

  def descriptor = {
    import Service._
    named("emailConfig").withCalls(
      pathCall("/api/v1_0_0/emailConfig/all", getAll _) ,
      pathCall("/api/v1_0_0/emailConfig/:id", getById _),
      pathCall("/api/v1_0_0/emailConfig/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/emailConfig?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Session
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SessionService extends Service with api.service.SessionService {

  override def getAll() :  ServiceCall[NotUsed, List[Session]]
  override def getById(id: Int): ServiceCall[NotUsed, Session]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Session]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Session]]

  def descriptor = {
    import Service._
    named("session").withCalls(
      pathCall("/api/v1_0_0/session/all", getAll _) ,
      pathCall("/api/v1_0_0/session/:id", getById _),
      pathCall("/api/v1_0_0/session/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/session?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Workbench
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkbenchService extends Service with api.service.WorkbenchService {

  override def getAll() :  ServiceCall[NotUsed, List[Workbench]]
  override def getById(id: Int): ServiceCall[NotUsed, Workbench]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Workbench]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Workbench]]

  def descriptor = {
    import Service._
    named("workbench").withCalls(
      pathCall("/api/v1_0_0/workbench/all", getAll _) ,
      pathCall("/api/v1_0_0/workbench/:id", getById _),
      pathCall("/api/v1_0_0/workbench/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workbench?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReferenceTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReferenceTrlService extends Service with api.service.ReferenceTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ReferenceTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ReferenceTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReferenceTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReferenceTrl]]

  def descriptor = {
    import Service._
    named("referenceTrl").withCalls(
      pathCall("/api/v1_0_0/referenceTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/referenceTrl/:id", getById _),
      pathCall("/api/v1_0_0/referenceTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/referenceTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SchedulerLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SchedulerLogService extends Service with api.service.SchedulerLogService {

  override def getAll() :  ServiceCall[NotUsed, List[SchedulerLog]]
  override def getById(id: Int): ServiceCall[NotUsed, SchedulerLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SchedulerLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SchedulerLog]]

  def descriptor = {
    import Service._
    named("schedulerLog").withCalls(
      pathCall("/api/v1_0_0/schedulerLog/all", getAll _) ,
      pathCall("/api/v1_0_0/schedulerLog/:id", getById _),
      pathCall("/api/v1_0_0/schedulerLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/schedulerLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Form
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FormService extends Service with api.service.FormService {

  override def getAll() :  ServiceCall[NotUsed, List[Form]]
  override def getById(id: Int): ServiceCall[NotUsed, Form]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Form]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Form]]

  def descriptor = {
    import Service._
    named("form").withCalls(
      pathCall("/api/v1_0_0/form/all", getAll _) ,
      pathCall("/api/v1_0_0/form/:id", getById _),
      pathCall("/api/v1_0_0/form/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/form?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNode
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeService extends Service with api.service.TreeNodeService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNode]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNode]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNode]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNode]]

  def descriptor = {
    import Service._
    named("treeNode").withCalls(
      pathCall("/api/v1_0_0/treeNode/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNode/:id", getById _),
      pathCall("/api/v1_0_0/treeNode/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNode?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Desktop
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait DesktopService extends Service with api.service.DesktopService {

  override def getAll() :  ServiceCall[NotUsed, List[Desktop]]
  override def getById(id: Int): ServiceCall[NotUsed, Desktop]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Desktop]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Desktop]]

  def descriptor = {
    import Service._
    named("desktop").withCalls(
      pathCall("/api/v1_0_0/desktop/all", getAll _) ,
      pathCall("/api/v1_0_0/desktop/:id", getById _),
      pathCall("/api/v1_0_0/desktop/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/desktop?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.OrganizationType
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait OrganizationTypeService extends Service with api.service.OrganizationTypeService {

  override def getAll() :  ServiceCall[NotUsed, List[OrganizationType]]
  override def getById(id: Int): ServiceCall[NotUsed, OrganizationType]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, OrganizationType]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[OrganizationType]]

  def descriptor = {
    import Service._
    named("organizationType").withCalls(
      pathCall("/api/v1_0_0/organizationType/all", getAll _) ,
      pathCall("/api/v1_0_0/organizationType/:id", getById _),
      pathCall("/api/v1_0_0/organizationType/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/organizationType?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeFavoriteNode
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeFavoriteNodeService extends Service with api.service.TreeFavoriteNodeService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeFavoriteNode]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeFavoriteNode]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeFavoriteNode]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeFavoriteNode]]

  def descriptor = {
    import Service._
    named("treeFavoriteNode").withCalls(
      pathCall("/api/v1_0_0/treeFavoriteNode/all", getAll _) ,
      pathCall("/api/v1_0_0/treeFavoriteNode/:id", getById _),
      pathCall("/api/v1_0_0/treeFavoriteNode/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeFavoriteNode?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Process
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ProcessService extends Service with api.service.ProcessService {

  override def getAll() :  ServiceCall[NotUsed, List[Process]]
  override def getById(id: Int): ServiceCall[NotUsed, Process]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Process]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Process]]

  def descriptor = {
    import Service._
    named("process").withCalls(
      pathCall("/api/v1_0_0/process/all", getAll _) ,
      pathCall("/api/v1_0_0/process/:id", getById _),
      pathCall("/api/v1_0_0/process/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/process?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Issue
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait IssueService extends Service with api.service.IssueService {

  override def getAll() :  ServiceCall[NotUsed, List[Issue]]
  override def getById(id: Int): ServiceCall[NotUsed, Issue]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Issue]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Issue]]

  def descriptor = {
    import Service._
    named("issue").withCalls(
      pathCall("/api/v1_0_0/issue/all", getAll _) ,
      pathCall("/api/v1_0_0/issue/:id", getById _),
      pathCall("/api/v1_0_0/issue/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/issue?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReferenceList
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReferenceListService extends Service with api.service.ReferenceListService {

  override def getAll() :  ServiceCall[NotUsed, List[ReferenceList]]
  override def getById(id: Int): ServiceCall[NotUsed, ReferenceList]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReferenceList]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReferenceList]]

  def descriptor = {
    import Service._
    named("referenceList").withCalls(
      pathCall("/api/v1_0_0/referenceList/all", getAll _) ,
      pathCall("/api/v1_0_0/referenceList/:id", getById _),
      pathCall("/api/v1_0_0/referenceList/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/referenceList?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ProcessParameterTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ProcessParameterTrlService extends Service with api.service.ProcessParameterTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ProcessParameterTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ProcessParameterTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ProcessParameterTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ProcessParameterTrl]]

  def descriptor = {
    import Service._
    named("processParameterTrl").withCalls(
      pathCall("/api/v1_0_0/processParameterTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/processParameterTrl/:id", getById _),
      pathCall("/api/v1_0_0/processParameterTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/processParameterTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReplicationDocument
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReplicationDocumentService extends Service with api.service.ReplicationDocumentService {

  override def getAll() :  ServiceCall[NotUsed, List[ReplicationDocument]]
  override def getById(id: Int): ServiceCall[NotUsed, ReplicationDocument]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReplicationDocument]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReplicationDocument]]

  def descriptor = {
    import Service._
    named("replicationDocument").withCalls(
      pathCall("/api/v1_0_0/replicationDocument/all", getAll _) ,
      pathCall("/api/v1_0_0/replicationDocument/:id", getById _),
      pathCall("/api/v1_0_0/replicationDocument/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/replicationDocument?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttributeTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeTrlService extends Service with api.service.AttributeTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[AttributeTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, AttributeTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttributeTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttributeTrl]]

  def descriptor = {
    import Service._
    named("attributeTrl").withCalls(
      pathCall("/api/v1_0_0/attributeTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/attributeTrl/:id", getById _),
      pathCall("/api/v1_0_0/attributeTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attributeTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowProcessData
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowProcessDataService extends Service with api.service.WorkflowProcessDataService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowProcessData]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowProcessData]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowProcessData]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowProcessData]]

  def descriptor = {
    import Service._
    named("workflowProcessData").withCalls(
      pathCall("/api/v1_0_0/workflowProcessData/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowProcessData/:id", getById _),
      pathCall("/api/v1_0_0/workflowProcessData/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowProcessData?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AttributeValueExtend
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttributeValueExtendService extends Service with api.service.AttributeValueExtendService {

  override def getAll() :  ServiceCall[NotUsed, List[AttributeValueExtend]]
  override def getById(id: Int): ServiceCall[NotUsed, AttributeValueExtend]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AttributeValueExtend]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AttributeValueExtend]]

  def descriptor = {
    import Service._
    named("attributeValueExtend").withCalls(
      pathCall("/api/v1_0_0/attributeValueExtend/all", getAll _) ,
      pathCall("/api/v1_0_0/attributeValueExtend/:id", getById _),
      pathCall("/api/v1_0_0/attributeValueExtend/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attributeValueExtend?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowProcess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowProcessService extends Service with api.service.WorkflowProcessService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowProcess]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowProcess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowProcess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowProcess]]

  def descriptor = {
    import Service._
    named("workflowProcess").withCalls(
      pathCall("/api/v1_0_0/workflowProcess/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowProcess/:id", getById _),
      pathCall("/api/v1_0_0/workflowProcess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowProcess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowProcessorLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowProcessorLogService extends Service with api.service.WorkflowProcessorLogService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowProcessorLog]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowProcessorLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowProcessorLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowProcessorLog]]

  def descriptor = {
    import Service._
    named("workflowProcessorLog").withCalls(
      pathCall("/api/v1_0_0/workflowProcessorLog/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowProcessorLog/:id", getById _),
      pathCall("/api/v1_0_0/workflowProcessorLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowProcessorLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Color
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ColorService extends Service with api.service.ColorService {

  override def getAll() :  ServiceCall[NotUsed, List[Color]]
  override def getById(id: Int): ServiceCall[NotUsed, Color]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Color]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Color]]

  def descriptor = {
    import Service._
    named("color").withCalls(
      pathCall("/api/v1_0_0/color/all", getAll _) ,
      pathCall("/api/v1_0_0/color/:id", getById _),
      pathCall("/api/v1_0_0/color/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/color?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.InformationWindowTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait InformationWindowTrlService extends Service with api.service.InformationWindowTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[InformationWindowTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, InformationWindowTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, InformationWindowTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[InformationWindowTrl]]

  def descriptor = {
    import Service._
    named("informationWindowTrl").withCalls(
      pathCall("/api/v1_0_0/informationWindowTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/informationWindowTrl/:id", getById _),
      pathCall("/api/v1_0_0/informationWindowTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/informationWindowTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.User
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserService extends Service with api.service.UserService {

  override def getAll() :  ServiceCall[NotUsed, List[User]]
  override def getById(id: Int): ServiceCall[NotUsed, User]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, User]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[User]]

  def descriptor = {
    import Service._
    named("user").withCalls(
      pathCall("/api/v1_0_0/user/all", getAll _) ,
      pathCall("/api/v1_0_0/user/:id", getById _),
      pathCall("/api/v1_0_0/user/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/user?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ProcessTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ProcessTrlService extends Service with api.service.ProcessTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ProcessTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ProcessTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ProcessTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ProcessTrl]]

  def descriptor = {
    import Service._
    named("processTrl").withCalls(
      pathCall("/api/v1_0_0/processTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/processTrl/:id", getById _),
      pathCall("/api/v1_0_0/processTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/processTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WindowAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WindowAccessService extends Service with api.service.WindowAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[WindowAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, WindowAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WindowAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WindowAccess]]

  def descriptor = {
    import Service._
    named("windowAccess").withCalls(
      pathCall("/api/v1_0_0/windowAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/windowAccess/:id", getById _),
      pathCall("/api/v1_0_0/windowAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/windowAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Preference
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PreferenceService extends Service with api.service.PreferenceService {

  override def getAll() :  ServiceCall[NotUsed, List[Preference]]
  override def getById(id: Int): ServiceCall[NotUsed, Preference]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Preference]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Preference]]

  def descriptor = {
    import Service._
    named("preference").withCalls(
      pathCall("/api/v1_0_0/preference/all", getAll _) ,
      pathCall("/api/v1_0_0/preference/:id", getById _),
      pathCall("/api/v1_0_0/preference/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/preference?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ElementTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ElementTrlService extends Service with api.service.ElementTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ElementTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ElementTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ElementTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ElementTrl]]

  def descriptor = {
    import Service._
    named("elementTrl").withCalls(
      pathCall("/api/v1_0_0/elementTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/elementTrl/:id", getById _),
      pathCall("/api/v1_0_0/elementTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/elementTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Tab
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TabService extends Service with api.service.TabService {

  override def getAll() :  ServiceCall[NotUsed, List[Tab]]
  override def getById(id: Int): ServiceCall[NotUsed, Tab]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Tab]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Tab]]

  def descriptor = {
    import Service._
    named("tab").withCalls(
      pathCall("/api/v1_0_0/tab/all", getAll _) ,
      pathCall("/api/v1_0_0/tab/:id", getById _),
      pathCall("/api/v1_0_0/tab/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/tab?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeU3
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeU3Service extends Service with api.service.TreeNodeU3Service {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeU3]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeU3]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeU3]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeU3]]

  def descriptor = {
    import Service._
    named("treeNodeU3").withCalls(
      pathCall("/api/v1_0_0/treeNodeU3/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeU3/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeU3/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeU3?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.MenuTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MenuTrlService extends Service with api.service.MenuTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[MenuTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, MenuTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, MenuTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[MenuTrl]]

  def descriptor = {
    import Service._
    named("menuTrl").withCalls(
      pathCall("/api/v1_0_0/menuTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/menuTrl/:id", getById _),
      pathCall("/api/v1_0_0/menuTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/menuTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SequenceNo
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SequenceNoService extends Service with api.service.SequenceNoService {

  override def getAll() :  ServiceCall[NotUsed, List[SequenceNo]]
  override def getById(id: Int): ServiceCall[NotUsed, SequenceNo]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SequenceNo]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SequenceNo]]

  def descriptor = {
    import Service._
    named("sequenceNo").withCalls(
      pathCall("/api/v1_0_0/sequenceNo/all", getAll _) ,
      pathCall("/api/v1_0_0/sequenceNo/:id", getById _),
      pathCall("/api/v1_0_0/sequenceNo/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/sequenceNo?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TaskTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TaskTrlService extends Service with api.service.TaskTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[TaskTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, TaskTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TaskTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TaskTrl]]

  def descriptor = {
    import Service._
    named("taskTrl").withCalls(
      pathCall("/api/v1_0_0/taskTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/taskTrl/:id", getById _),
      pathCall("/api/v1_0_0/taskTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/taskTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Attachment
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AttachmentService extends Service with api.service.AttachmentService {

  override def getAll() :  ServiceCall[NotUsed, List[Attachment]]
  override def getById(id: Int): ServiceCall[NotUsed, Attachment]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Attachment]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Attachment]]

  def descriptor = {
    import Service._
    named("attachment").withCalls(
      pathCall("/api/v1_0_0/attachment/all", getAll _) ,
      pathCall("/api/v1_0_0/attachment/:id", getById _),
      pathCall("/api/v1_0_0/attachment/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/attachment?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserOrganizationAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserOrganizationAccessService extends Service with api.service.UserOrganizationAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[UserOrganizationAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, UserOrganizationAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserOrganizationAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserOrganizationAccess]]

  def descriptor = {
    import Service._
    named("userOrganizationAccess").withCalls(
      pathCall("/api/v1_0_0/userOrganizationAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/userOrganizationAccess/:id", getById _),
      pathCall("/api/v1_0_0/userOrganizationAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userOrganizationAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Role
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait RoleService extends Service with api.service.RoleService {

  override def getAll() :  ServiceCall[NotUsed, List[Role]]
  override def getById(id: Int): ServiceCall[NotUsed, Role]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Role]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Role]]

  def descriptor = {
    import Service._
    named("role").withCalls(
      pathCall("/api/v1_0_0/role/all", getAll _) ,
      pathCall("/api/v1_0_0/role/:id", getById _),
      pathCall("/api/v1_0_0/role/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/role?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Note
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait NoteService extends Service with api.service.NoteService {

  override def getAll() :  ServiceCall[NotUsed, List[Note]]
  override def getById(id: Int): ServiceCall[NotUsed, Note]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Note]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Note]]

  def descriptor = {
    import Service._
    named("note").withCalls(
      pathCall("/api/v1_0_0/note/all", getAll _) ,
      pathCall("/api/v1_0_0/note/:id", getById _),
      pathCall("/api/v1_0_0/note/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/note?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.BrowseFieldTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait BrowseFieldTrlService extends Service with api.service.BrowseFieldTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[BrowseFieldTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, BrowseFieldTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, BrowseFieldTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[BrowseFieldTrl]]

  def descriptor = {
    import Service._
    named("browseFieldTrl").withCalls(
      pathCall("/api/v1_0_0/browseFieldTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/browseFieldTrl/:id", getById _),
      pathCall("/api/v1_0_0/browseFieldTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/browseFieldTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ZoomCondition
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ZoomConditionService extends Service with api.service.ZoomConditionService {

  override def getAll() :  ServiceCall[NotUsed, List[ZoomCondition]]
  override def getById(id: Int): ServiceCall[NotUsed, ZoomCondition]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ZoomCondition]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ZoomCondition]]

  def descriptor = {
    import Service._
    named("zoomCondition").withCalls(
      pathCall("/api/v1_0_0/zoomCondition/all", getAll _) ,
      pathCall("/api/v1_0_0/zoomCondition/:id", getById _),
      pathCall("/api/v1_0_0/zoomCondition/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/zoomCondition?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeU2
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeU2Service extends Service with api.service.TreeNodeU2Service {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeU2]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeU2]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeU2]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeU2]]

  def descriptor = {
    import Service._
    named("treeNodeU2").withCalls(
      pathCall("/api/v1_0_0/treeNodeU2/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeU2/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeU2/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeU2?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserMail
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserMailService extends Service with api.service.UserMailService {

  override def getAll() :  ServiceCall[NotUsed, List[UserMail]]
  override def getById(id: Int): ServiceCall[NotUsed, UserMail]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserMail]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserMail]]

  def descriptor = {
    import Service._
    named("userMail").withCalls(
      pathCall("/api/v1_0_0/userMail/all", getAll _) ,
      pathCall("/api/v1_0_0/userMail/:id", getById _),
      pathCall("/api/v1_0_0/userMail/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userMail?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowProcessor
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowProcessorService extends Service with api.service.WorkflowProcessorService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowProcessor]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowProcessor]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowProcessor]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowProcessor]]

  def descriptor = {
    import Service._
    named("workflowProcessor").withCalls(
      pathCall("/api/v1_0_0/workflowProcessor/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowProcessor/:id", getById _),
      pathCall("/api/v1_0_0/workflowProcessor/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowProcessor?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeBP
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeBPService extends Service with api.service.TreeNodeBPService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeBP]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeBP]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeBP]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeBP]]

  def descriptor = {
    import Service._
    named("treeNodeBP").withCalls(
      pathCall("/api/v1_0_0/treeNodeBP/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeBP/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeBP/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeBP?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AlertProcessor
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AlertProcessorService extends Service with api.service.AlertProcessorService {

  override def getAll() :  ServiceCall[NotUsed, List[AlertProcessor]]
  override def getById(id: Int): ServiceCall[NotUsed, AlertProcessor]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AlertProcessor]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AlertProcessor]]

  def descriptor = {
    import Service._
    named("alertProcessor").withCalls(
      pathCall("/api/v1_0_0/alertProcessor/all", getAll _) ,
      pathCall("/api/v1_0_0/alertProcessor/:id", getById _),
      pathCall("/api/v1_0_0/alertProcessor/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/alertProcessor?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AlertRecipient
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AlertRecipientService extends Service with api.service.AlertRecipientService {

  override def getAll() :  ServiceCall[NotUsed, List[AlertRecipient]]
  override def getById(id: Int): ServiceCall[NotUsed, AlertRecipient]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AlertRecipient]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AlertRecipient]]

  def descriptor = {
    import Service._
    named("alertRecipient").withCalls(
      pathCall("/api/v1_0_0/alertRecipient/all", getAll _) ,
      pathCall("/api/v1_0_0/alertRecipient/:id", getById _),
      pathCall("/api/v1_0_0/alertRecipient/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/alertRecipient?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.RelationType
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait RelationTypeService extends Service with api.service.RelationTypeService {

  override def getAll() :  ServiceCall[NotUsed, List[RelationType]]
  override def getById(id: Int): ServiceCall[NotUsed, RelationType]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, RelationType]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[RelationType]]

  def descriptor = {
    import Service._
    named("relationType").withCalls(
      pathCall("/api/v1_0_0/relationType/all", getAll _) ,
      pathCall("/api/v1_0_0/relationType/:id", getById _),
      pathCall("/api/v1_0_0/relationType/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/relationType?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.FieldTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FieldTrlService extends Service with api.service.FieldTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[FieldTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, FieldTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, FieldTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[FieldTrl]]

  def descriptor = {
    import Service._
    named("fieldTrl").withCalls(
      pathCall("/api/v1_0_0/fieldTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/fieldTrl/:id", getById _),
      pathCall("/api/v1_0_0/fieldTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/fieldTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.InformationWindow
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait InformationWindowService extends Service with api.service.InformationWindowService {

  override def getAll() :  ServiceCall[NotUsed, List[InformationWindow]]
  override def getById(id: Int): ServiceCall[NotUsed, InformationWindow]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, InformationWindow]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[InformationWindow]]

  def descriptor = {
    import Service._
    named("informationWindow").withCalls(
      pathCall("/api/v1_0_0/informationWindow/all", getAll _) ,
      pathCall("/api/v1_0_0/informationWindow/:id", getById _),
      pathCall("/api/v1_0_0/informationWindow/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/informationWindow?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PackageImportDetail
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PackageImportDetailService extends Service with api.service.PackageImportDetailService {

  override def getAll() :  ServiceCall[NotUsed, List[PackageImportDetail]]
  override def getById(id: Int): ServiceCall[NotUsed, PackageImportDetail]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PackageImportDetail]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PackageImportDetail]]

  def descriptor = {
    import Service._
    named("packageImportDetail").withCalls(
      pathCall("/api/v1_0_0/packageImportDetail/all", getAll _) ,
      pathCall("/api/v1_0_0/packageImportDetail/:id", getById _),
      pathCall("/api/v1_0_0/packageImportDetail/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/packageImportDetail?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Organization
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait OrganizationService extends Service with api.service.OrganizationService {

  override def getAll() :  ServiceCall[NotUsed, List[Organization]]
  override def getById(id: Int): ServiceCall[NotUsed, Organization]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Organization]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Organization]]

  def descriptor = {
    import Service._
    named("organization").withCalls(
      pathCall("/api/v1_0_0/organization/all", getAll _) ,
      pathCall("/api/v1_0_0/organization/:id", getById _),
      pathCall("/api/v1_0_0/organization/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/organization?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.FieldGroup
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FieldGroupService extends Service with api.service.FieldGroupService {

  override def getAll() :  ServiceCall[NotUsed, List[FieldGroup]]
  override def getById(id: Int): ServiceCall[NotUsed, FieldGroup]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, FieldGroup]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[FieldGroup]]

  def descriptor = {
    import Service._
    named("fieldGroup").withCalls(
      pathCall("/api/v1_0_0/fieldGroup/all", getAll _) ,
      pathCall("/api/v1_0_0/fieldGroup/:id", getById _),
      pathCall("/api/v1_0_0/fieldGroup/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/fieldGroup?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ViewTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ViewTrlService extends Service with api.service.ViewTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[ViewTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, ViewTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ViewTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ViewTrl]]

  def descriptor = {
    import Service._
    named("viewTrl").withCalls(
      pathCall("/api/v1_0_0/viewTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/viewTrl/:id", getById _),
      pathCall("/api/v1_0_0/viewTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/viewTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.AlertRule
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait AlertRuleService extends Service with api.service.AlertRuleService {

  override def getAll() :  ServiceCall[NotUsed, List[AlertRule]]
  override def getById(id: Int): ServiceCall[NotUsed, AlertRule]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, AlertRule]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[AlertRule]]

  def descriptor = {
    import Service._
    named("alertRule").withCalls(
      pathCall("/api/v1_0_0/alertRule/all", getAll _) ,
      pathCall("/api/v1_0_0/alertRule/:id", getById _),
      pathCall("/api/v1_0_0/alertRule/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/alertRule?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Chart
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ChartService extends Service with api.service.ChartService {

  override def getAll() :  ServiceCall[NotUsed, List[Chart]]
  override def getById(id: Int): ServiceCall[NotUsed, Chart]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Chart]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Chart]]

  def descriptor = {
    import Service._
    named("chart").withCalls(
      pathCall("/api/v1_0_0/chart/all", getAll _) ,
      pathCall("/api/v1_0_0/chart/:id", getById _),
      pathCall("/api/v1_0_0/chart/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/chart?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ReportView
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ReportViewService extends Service with api.service.ReportViewService {

  override def getAll() :  ServiceCall[NotUsed, List[ReportView]]
  override def getById(id: Int): ServiceCall[NotUsed, ReportView]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ReportView]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ReportView]]

  def descriptor = {
    import Service._
    named("reportView").withCalls(
      pathCall("/api/v1_0_0/reportView/all", getAll _) ,
      pathCall("/api/v1_0_0/reportView/:id", getById _),
      pathCall("/api/v1_0_0/reportView/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/reportView?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintFont
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintFontService extends Service with api.service.PrintFontService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintFont]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintFont]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintFont]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintFont]]

  def descriptor = {
    import Service._
    named("printFont").withCalls(
      pathCall("/api/v1_0_0/printFont/all", getAll _) ,
      pathCall("/api/v1_0_0/printFont/:id", getById _),
      pathCall("/api/v1_0_0/printFont/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printFont?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.FormAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait FormAccessService extends Service with api.service.FormAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[FormAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, FormAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, FormAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[FormAccess]]

  def descriptor = {
    import Service._
    named("formAccess").withCalls(
      pathCall("/api/v1_0_0/formAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/formAccess/:id", getById _),
      pathCall("/api/v1_0_0/formAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/formAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserDefinedWindow
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserDefinedWindowService extends Service with api.service.UserDefinedWindowService {

  override def getAll() :  ServiceCall[NotUsed, List[UserDefinedWindow]]
  override def getById(id: Int): ServiceCall[NotUsed, UserDefinedWindow]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserDefinedWindow]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserDefinedWindow]]

  def descriptor = {
    import Service._
    named("userDefinedWindow").withCalls(
      pathCall("/api/v1_0_0/userDefinedWindow/all", getAll _) ,
      pathCall("/api/v1_0_0/userDefinedWindow/:id", getById _),
      pathCall("/api/v1_0_0/userDefinedWindow/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userDefinedWindow?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TenantInfo
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TenantInfoService extends Service with api.service.TenantInfoService {

  override def getAll() :  ServiceCall[NotUsed, List[TenantInfo]]
  override def getById(id: Int): ServiceCall[NotUsed, TenantInfo]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TenantInfo]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TenantInfo]]

  def descriptor = {
    import Service._
    named("tenantInfo").withCalls(
      pathCall("/api/v1_0_0/tenantInfo/all", getAll _) ,
      pathCall("/api/v1_0_0/tenantInfo/:id", getById _),
      pathCall("/api/v1_0_0/tenantInfo/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/tenantInfo?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ViewAttribute
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ViewAttributeService extends Service with api.service.ViewAttributeService {

  override def getAll() :  ServiceCall[NotUsed, List[ViewAttribute]]
  override def getById(id: Int): ServiceCall[NotUsed, ViewAttribute]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ViewAttribute]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ViewAttribute]]

  def descriptor = {
    import Service._
    named("viewAttribute").withCalls(
      pathCall("/api/v1_0_0/viewAttribute/all", getAll _) ,
      pathCall("/api/v1_0_0/viewAttribute/:id", getById _),
      pathCall("/api/v1_0_0/viewAttribute/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/viewAttribute?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintFormatItem
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintFormatItemService extends Service with api.service.PrintFormatItemService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintFormatItem]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintFormatItem]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintFormatItem]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintFormatItem]]

  def descriptor = {
    import Service._
    named("printFormatItem").withCalls(
      pathCall("/api/v1_0_0/printFormatItem/all", getAll _) ,
      pathCall("/api/v1_0_0/printFormatItem/:id", getById _),
      pathCall("/api/v1_0_0/printFormatItem/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printFormatItem?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Memo
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait MemoService extends Service with api.service.MemoService {

  override def getAll() :  ServiceCall[NotUsed, List[Memo]]
  override def getById(id: Int): ServiceCall[NotUsed, Memo]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Memo]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Memo]]

  def descriptor = {
    import Service._
    named("memo").withCalls(
      pathCall("/api/v1_0_0/memo/all", getAll _) ,
      pathCall("/api/v1_0_0/memo/:id", getById _),
      pathCall("/api/v1_0_0/memo/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/memo?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintPaper
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintPaperService extends Service with api.service.PrintPaperService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintPaper]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintPaper]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintPaper]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintPaper]]

  def descriptor = {
    import Service._
    named("printPaper").withCalls(
      pathCall("/api/v1_0_0/printPaper/all", getAll _) ,
      pathCall("/api/v1_0_0/printPaper/:id", getById _),
      pathCall("/api/v1_0_0/printPaper/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printPaper?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.LdapProcessorLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait LdapProcessorLogService extends Service with api.service.LdapProcessorLogService {

  override def getAll() :  ServiceCall[NotUsed, List[LdapProcessorLog]]
  override def getById(id: Int): ServiceCall[NotUsed, LdapProcessorLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, LdapProcessorLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[LdapProcessorLog]]

  def descriptor = {
    import Service._
    named("ldapProcessorLog").withCalls(
      pathCall("/api/v1_0_0/ldapProcessorLog/all", getAll _) ,
      pathCall("/api/v1_0_0/ldapProcessorLog/:id", getById _),
      pathCall("/api/v1_0_0/ldapProcessorLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/ldapProcessorLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Tree
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeService extends Service with api.service.TreeService {

  override def getAll() :  ServiceCall[NotUsed, List[Tree]]
  override def getById(id: Int): ServiceCall[NotUsed, Tree]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Tree]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Tree]]

  def descriptor = {
    import Service._
    named("tree").withCalls(
      pathCall("/api/v1_0_0/tree/all", getAll _) ,
      pathCall("/api/v1_0_0/tree/:id", getById _),
      pathCall("/api/v1_0_0/tree/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/tree?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkbenchWindow
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkbenchWindowService extends Service with api.service.WorkbenchWindowService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkbenchWindow]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkbenchWindow]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkbenchWindow]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkbenchWindow]]

  def descriptor = {
    import Service._
    named("workbenchWindow").withCalls(
      pathCall("/api/v1_0_0/workbenchWindow/all", getAll _) ,
      pathCall("/api/v1_0_0/workbenchWindow/:id", getById _),
      pathCall("/api/v1_0_0/workbenchWindow/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workbenchWindow?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserSubstitute
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserSubstituteService extends Service with api.service.UserSubstituteService {

  override def getAll() :  ServiceCall[NotUsed, List[UserSubstitute]]
  override def getById(id: Int): ServiceCall[NotUsed, UserSubstitute]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserSubstitute]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserSubstitute]]

  def descriptor = {
    import Service._
    named("userSubstitute").withCalls(
      pathCall("/api/v1_0_0/userSubstitute/all", getAll _) ,
      pathCall("/api/v1_0_0/userSubstitute/:id", getById _),
      pathCall("/api/v1_0_0/userSubstitute/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userSubstitute?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserDefinedTab
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserDefinedTabService extends Service with api.service.UserDefinedTabService {

  override def getAll() :  ServiceCall[NotUsed, List[UserDefinedTab]]
  override def getById(id: Int): ServiceCall[NotUsed, UserDefinedTab]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserDefinedTab]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserDefinedTab]]

  def descriptor = {
    import Service._
    named("userDefinedTab").withCalls(
      pathCall("/api/v1_0_0/userDefinedTab/all", getAll _) ,
      pathCall("/api/v1_0_0/userDefinedTab/:id", getById _),
      pathCall("/api/v1_0_0/userDefinedTab/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userDefinedTab?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowActivityResult
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowActivityResultService extends Service with api.service.WorkflowActivityResultService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowActivityResult]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowActivityResult]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowActivityResult]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowActivityResult]]

  def descriptor = {
    import Service._
    named("workflowActivityResult").withCalls(
      pathCall("/api/v1_0_0/workflowActivityResult/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowActivityResult/:id", getById _),
      pathCall("/api/v1_0_0/workflowActivityResult/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowActivityResult?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeCMC
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeCMCService extends Service with api.service.TreeNodeCMCService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeCMC]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeCMC]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeCMC]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeCMC]]

  def descriptor = {
    import Service._
    named("treeNodeCMC").withCalls(
      pathCall("/api/v1_0_0/treeNodeCMC/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeCMC/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeCMC/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeCMC?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.SchedulerParameter
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SchedulerParameterService extends Service with api.service.SchedulerParameterService {

  override def getAll() :  ServiceCall[NotUsed, List[SchedulerParameter]]
  override def getById(id: Int): ServiceCall[NotUsed, SchedulerParameter]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, SchedulerParameter]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[SchedulerParameter]]

  def descriptor = {
    import Service._
    named("schedulerParameter").withCalls(
      pathCall("/api/v1_0_0/schedulerParameter/all", getAll _) ,
      pathCall("/api/v1_0_0/schedulerParameter/:id", getById _),
      pathCall("/api/v1_0_0/schedulerParameter/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/schedulerParameter?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.UserBusinessPartnerAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait UserBusinessPartnerAccessService extends Service with api.service.UserBusinessPartnerAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[UserBusinessPartnerAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, UserBusinessPartnerAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, UserBusinessPartnerAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[UserBusinessPartnerAccess]]

  def descriptor = {
    import Service._
    named("userBusinessPartnerAccess").withCalls(
      pathCall("/api/v1_0_0/userBusinessPartnerAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/userBusinessPartnerAccess/:id", getById _),
      pathCall("/api/v1_0_0/userBusinessPartnerAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/userBusinessPartnerAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeMM
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeMMService extends Service with api.service.TreeNodeMMService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeMM]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeMM]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeMM]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeMM]]

  def descriptor = {
    import Service._
    named("treeNodeMM").withCalls(
      pathCall("/api/v1_0_0/treeNodeMM/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeMM/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeMM/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeMM?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Scheduler
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SchedulerService extends Service with api.service.SchedulerService {

  override def getAll() :  ServiceCall[NotUsed, List[Scheduler]]
  override def getById(id: Int): ServiceCall[NotUsed, Scheduler]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Scheduler]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Scheduler]]

  def descriptor = {
    import Service._
    named("scheduler").withCalls(
      pathCall("/api/v1_0_0/scheduler/all", getAll _) ,
      pathCall("/api/v1_0_0/scheduler/:id", getById _),
      pathCall("/api/v1_0_0/scheduler/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/scheduler?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Archive
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ArchiveService extends Service with api.service.ArchiveService {

  override def getAll() :  ServiceCall[NotUsed, List[Archive]]
  override def getById(id: Int): ServiceCall[NotUsed, Archive]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Archive]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Archive]]

  def descriptor = {
    import Service._
    named("archive").withCalls(
      pathCall("/api/v1_0_0/archive/all", getAll _) ,
      pathCall("/api/v1_0_0/archive/:id", getById _),
      pathCall("/api/v1_0_0/archive/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/archive?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintForm
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}

trait PrintFormService extends Service with api.service.PrintFormService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintForm]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintForm]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintForm]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintForm]]

  def descriptor = {
    import Service._
    named("printForm").withCalls(
      pathCall("/api/v1_0_0/printForm/all", getAll _) ,
      pathCall("/api/v1_0_0/printForm/:id", getById _),
      pathCall("/api/v1_0_0/printForm/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printForm?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintLabelLine
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintLabelLineService extends Service with api.service.PrintLabelLineService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintLabelLine]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintLabelLine]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintLabelLine]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintLabelLine]]

  def descriptor = {
    import Service._
    named("printLabelLine").withCalls(
      pathCall("/api/v1_0_0/printLabelLine/all", getAll _) ,
      pathCall("/api/v1_0_0/printLabelLine/:id", getById _),
      pathCall("/api/v1_0_0/printLabelLine/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printLabelLine?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowNextCondition
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowNextConditionService extends Service with api.service.WorkflowNextConditionService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowNextCondition]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowNextCondition]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowNextCondition]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowNextCondition]]

  def descriptor = {
    import Service._
    named("workflowNextCondition").withCalls(
      pathCall("/api/v1_0_0/workflowNextCondition/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowNextCondition/:id", getById _),
      pathCall("/api/v1_0_0/workflowNextCondition/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowNextCondition?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.InfoColumnTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait InfoColumnTrlService extends Service with api.service.InfoColumnTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[InfoColumnTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, InfoColumnTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, InfoColumnTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[InfoColumnTrl]]

  def descriptor = {
    import Service._
    named("infoColumnTrl").withCalls(
      pathCall("/api/v1_0_0/infoColumnTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/infoColumnTrl/:id", getById _),
      pathCall("/api/v1_0_0/infoColumnTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/infoColumnTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ViewDefinition
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ViewDefinitionService extends Service with api.service.ViewDefinitionService {

  override def getAll() :  ServiceCall[NotUsed, List[ViewDefinition]]
  override def getById(id: Int): ServiceCall[NotUsed, ViewDefinition]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ViewDefinition]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ViewDefinition]]

  def descriptor = {
    import Service._
    named("viewDefinition").withCalls(
      pathCall("/api/v1_0_0/viewDefinition/all", getAll _) ,
      pathCall("/api/v1_0_0/viewDefinition/:id", getById _),
      pathCall("/api/v1_0_0/viewDefinition/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/viewDefinition?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.System
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait SystemService extends Service with api.service.SystemService {

  override def getAll() :  ServiceCall[NotUsed, List[System]]
  override def getById(id: Int): ServiceCall[NotUsed, System]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, System]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[System]]

  def descriptor = {
    import Service._
    named("system").withCalls(
      pathCall("/api/v1_0_0/system/all", getAll _) ,
      pathCall("/api/v1_0_0/system/:id", getById _),
      pathCall("/api/v1_0_0/system/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/system?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.BrowseAccess
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait BrowseAccessService extends Service with api.service.BrowseAccessService {

  override def getAll() :  ServiceCall[NotUsed, List[BrowseAccess]]
  override def getById(id: Int): ServiceCall[NotUsed, BrowseAccess]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, BrowseAccess]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[BrowseAccess]]

  def descriptor = {
    import Service._
    named("browseAccess").withCalls(
      pathCall("/api/v1_0_0/browseAccess/all", getAll _) ,
      pathCall("/api/v1_0_0/browseAccess/:id", getById _),
      pathCall("/api/v1_0_0/browseAccess/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/browseAccess?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.PrintLabelLineTrl
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait PrintLabelLineTrlService extends Service with api.service.PrintLabelLineTrlService {

  override def getAll() :  ServiceCall[NotUsed, List[PrintLabelLineTrl]]
  override def getById(id: Int): ServiceCall[NotUsed, PrintLabelLineTrl]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, PrintLabelLineTrl]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[PrintLabelLineTrl]]

  def descriptor = {
    import Service._
    named("printLabelLineTrl").withCalls(
      pathCall("/api/v1_0_0/printLabelLineTrl/all", getAll _) ,
      pathCall("/api/v1_0_0/printLabelLineTrl/:id", getById _),
      pathCall("/api/v1_0_0/printLabelLineTrl/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/printLabelLineTrl?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.RoleIncluded
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait RoleIncludedService extends Service with api.service.RoleIncludedService {

  override def getAll() :  ServiceCall[NotUsed, List[RoleIncluded]]
  override def getById(id: Int): ServiceCall[NotUsed, RoleIncluded]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, RoleIncluded]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[RoleIncluded]]

  def descriptor = {
    import Service._
    named("roleIncluded").withCalls(
      pathCall("/api/v1_0_0/roleIncluded/all", getAll _) ,
      pathCall("/api/v1_0_0/roleIncluded/:id", getById _),
      pathCall("/api/v1_0_0/roleIncluded/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/roleIncluded?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.Modification
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ModificationService extends Service with api.service.ModificationService {

  override def getAll() :  ServiceCall[NotUsed, List[Modification]]
  override def getById(id: Int): ServiceCall[NotUsed, Modification]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, Modification]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[Modification]]

  def descriptor = {
    import Service._
    named("modification").withCalls(
      pathCall("/api/v1_0_0/modification/all", getAll _) ,
      pathCall("/api/v1_0_0/modification/:id", getById _),
      pathCall("/api/v1_0_0/modification/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/modification?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.TreeNodeCMT
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait TreeNodeCMTService extends Service with api.service.TreeNodeCMTService {

  override def getAll() :  ServiceCall[NotUsed, List[TreeNodeCMT]]
  override def getById(id: Int): ServiceCall[NotUsed, TreeNodeCMT]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, TreeNodeCMT]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[TreeNodeCMT]]

  def descriptor = {
    import Service._
    named("treeNodeCMT").withCalls(
      pathCall("/api/v1_0_0/treeNodeCMT/all", getAll _) ,
      pathCall("/api/v1_0_0/treeNodeCMT/:id", getById _),
      pathCall("/api/v1_0_0/treeNodeCMT/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/treeNodeCMT?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.ChangeLog
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait ChangeLogService extends Service with api.service.ChangeLogService {

  override def getAll() :  ServiceCall[NotUsed, List[ChangeLog]]
  override def getById(id: Int): ServiceCall[NotUsed, ChangeLog]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, ChangeLog]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[ChangeLog]]

  def descriptor = {
    import Service._
    named("changeLog").withCalls(
      pathCall("/api/v1_0_0/changeLog/all", getAll _) ,
      pathCall("/api/v1_0_0/changeLog/:id", getById _),
      pathCall("/api/v1_0_0/changeLog/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/changeLog?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.WorkflowEventAudit
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait WorkflowEventAuditService extends Service with api.service.WorkflowEventAuditService {

  override def getAll() :  ServiceCall[NotUsed, List[WorkflowEventAudit]]
  override def getById(id: Int): ServiceCall[NotUsed, WorkflowEventAudit]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, WorkflowEventAudit]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[WorkflowEventAudit]]

  def descriptor = {
    import Service._
    named("workflowEventAudit").withCalls(
      pathCall("/api/v1_0_0/workflowEventAudit/all", getAll _) ,
      pathCall("/api/v1_0_0/workflowEventAudit/:id", getById _),
      pathCall("/api/v1_0_0/workflowEventAudit/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/workflowEventAudit?pageNo&pageSize", getAllByPage _)
    )
  }
} 

package com.eevolution.context.dictionary.infrastructure.service

import java.util.UUID

import akka.NotUsed
import com.eevolution.context.dictionary.domain._
import com.eevolution.context.dictionary.domain.model.OrganizationInfo
import com.eevolution.utils.PaginatedSequence
import com.lightbend.lagom.scaladsl.api.{Service, ServiceCall}



trait OrganizationInfoService extends Service with api.service.OrganizationInfoService {

  override def getAll() :  ServiceCall[NotUsed, List[OrganizationInfo]]
  override def getById(id: Int): ServiceCall[NotUsed, OrganizationInfo]
  override def getByUUID(uuid :UUID): ServiceCall[NotUsed, OrganizationInfo]
  override def getAllByPage(pageNo: Option[Int], pageSize: Option[Int]): ServiceCall[NotUsed, PaginatedSequence[OrganizationInfo]]

  def descriptor = {
    import Service._
    named("organizationInfo").withCalls(
      pathCall("/api/v1_0_0/organizationInfo/all", getAll _) ,
      pathCall("/api/v1_0_0/organizationInfo/:id", getById _),
      pathCall("/api/v1_0_0/organizationInfo/:uuid", getByUUID _) ,
      pathCall("/api/v1_0_0/organizationInfo?pageNo&pageSize", getAllByPage _)
    )
  }
}