@PeterAaser first you need to have a codec for FiniteDuration itself. The easiest way to write this custom codec is by defining a "fake" companion object for FiniteDuration with appropriate apply and unapply and then materializing the codec with GenCodec.fromApplyUnapplyProvider macro:
object CustomCodecs {
private object FiniteDurationAU {
def apply(length: Long, unit: TimeUnit): FiniteDuration = FiniteDuration(length, unit)
def unapply(duration: FiniteDuration): Option[(Long, TimeUnit)] = Some((duration.length, duration.unit))
}
implicit val finiteDurationCodec: GenCodec[FiniteDuration] =
GenCodec.fromApplyUnapplyProvider[FiniteDuration](FiniteDurationAU)
}This codec will yield JSON objects that reflect the signature of apply, e.g. {"length":30,"unit":"MINUTES"}.
Then you can inject it into macro materialization of GenCodec for your case class using HasGenCodecWithDeps:
case class ContainsDuration(duration: FiniteDuration)
object ContainsDuration extends HasGenCodecWithDeps[CustomCodecs.type, ContainsDuration]GenCodec[MyCaseClass] which seems to work too
bt new UdashFramework/udash.g8. Anyway, the issue you're getting is related to the fact, that the docs are updated for 0.8.0 release, but there's no final JAR available yet - only 0.8.0-RC10, which will probably go final as long as we don't find more issues in it
@OndrejSpanel I don't now Mapbox, but I guess the simplest way to start would be to use a wrapper (e.g. https://github.com/bbarker/scalajs-mapbox or https://github.com/oyvindberg/ScalablyTyped/tree/master/m/mapbox-gl) and work with the types. They probably have some API which either returns or works on Elements from JS DOM and you can render such within your views with ease.
The name question is simpler - we usually pronounce it U-dash (IPA: [ˈjudaʃ], AS: [i ̯udaš]). The origins of the name are actually quite funny so I guess we'll add the info at some point :D
RpcClientsService?
udash-rest instead. You can see a minimal integration commit here: ddworak/udash-with-rest@9b93800 - shouldn't be too outdated
DefaultServerRpcCompanion with DefaultRestApiCompanion in several places, I am not sure how to proceed with UserContext, though. The trouble is UserContext uses PermissionId, which already has a companion object I am unable to modify. I have find a documentation how to add serialization for 3rd party classes, but I did not find anything similar how to create REST API for them. The error I get is:
RestSchema for Set[io.udash.auth.PermissionId] not found
Then, implement your trait on server side
ping API defined, but I do not see any implementation for it anywhere.
Hello, @OndrejSpanel. If I understand correctly, you have just equipped UserContext and UserToken with RestDataCompanion by, respectively:
object UserContext extends RestDataCompanion[UserContext]and
object UserToken extends RestDataCompanion[UserToken]According to the provided exception message, RestSchema for UserContext cannot be generated since there is no such for Set[PermissionId]. To provide RestSchema for PermissionId instances, please refer to the last example presented under the Macro materialized ADT schemas section of REST guide (macro materialization without RestDataCompanion). The following should do the trick:
object UserContext extends HasGenCodec[UserContext] {
implicit val permissionIdSchema: RestSchema[PermissionId] = RestStructure.materialize[PermissionId].standaloneSchema
implicit val userContextSchema: RestSchema[UserContext] = RestStructure.materialize[UserContext].standaloneSchema
}Please note a few nuances in this snippet:
- you cannot mix
RestDataCompanion[UserContext]with macro-materialized schema forPermissionIdinsideUserContextcompanion; hence,UserContextdoes not extendRestDataCompanionanymore (appropriate schema is macro-materialized as well), - to provide a (JSON) serializer for
UserContext, aGenCodec[UserContext]has to be defined (either by extendingHasGenCodec[UserContext]or explicitly:implicit val userContextCodec: GenCodec[UserContext] = GenCodec.materialize).
Hope that helps :)
As mentioned above, implementation of io.company.app.shared.rpc.server.AdditionalRpc can be found under io.company.app.backend.serverApplicationServer#createRestServletHolder.
request.startAsync() fails). I had to create an alternative to io.udash.rest.RestServlet, and as the methods like readParameters are private, it involved more copy and paste than I like.
@ddworak
no worries, you can just use udash-rest instead
I think I am able to provide rest services now, but compared to RPC there are substantial limitations. Most of all I am missing client-aware services, which force me to pass Client ID in the REST API (and reimplement client management). Do you think there is some possibility how to use RPC, but not with Atmosphere / Jetty? Providing an alternative to DefaultAtmosphereServiceConfig does not seem difficult, but I fail to see what else would I have to provide to implement the RPC communication protocol without Atmosphere.
trait UserApi { ... }
object UserApi extends DefaultRestApiCompanion[UserApi]
trait RootApi {
@Prefix("") def auth(@Header("Authorization") token: String): UserApi
}
object RootApi extends DefaultRestApiCompanion[RootApi]io.udash.rpc.ServerRawRpc on the client side so that it uses e.g. some opaque, plain HTTP to send invocations to the server. Then on the server side you'll have to implement a servlet or another network endpoint which will receive invocations and translate them back into calls on io.udash.rpc.ServerRawRpc
Still on the theme of REST serialization, how do I get generic types to conform to AsRawReal and RestSchema? I'm basically trying to expose an api that allows one to define policy templates that contain a set of statements of the shape: case class Statement(verb: Verb, operations: VariableOrLiteral[Set[Operation]], condition: Condition) and I'm having a little trouble getting the following to serialize properly:
sealed trait VariableOrLiteral[T]
case class Variable[T](name: String, typeInfo: TypeTag[T]) extends VariableOrLiteral[T]
case class Literal[T](value: T) extends VariableOrLiteral[T]I'm sure I'm missing something obvious, but the only thing that half-worked was completely custom serialization, but then I didn't get any RestSchema
I am not sure if I fully understand you, but this may do the trick for the RestSchema materialization:
object VariableOrLiteral {
implicit def typeTagSchema[T: RestSchema]: RestSchema[TypeTag[T]] = ??? // This should be implemented with method of your choice
implicit def restSchema[T: RestSchema]: RestSchema[VariableOrLiteral[T]] = RestStructure.materialize[VariableOrLiteral[T]].standaloneSchema
}The general concept should propagate to AsRawReal.