copy sources from internal project

Author: nevi-me

.idea/.name

@@ -1,2 +1,2 @@
-rootProject.name = 'geofancy'
+rootProject.name = 'geofancy-java'
 

.idea/compiler.xml

@@ -0,0 +1,27 @@
+package za.co.movinggauteng.geofancy
+
+import io.github.cdimascio.dotenv.dotenv
+import io.jaegertracing.Configuration
+import io.opentracing.util.GlobalTracer
+import za.co.movinggauteng.geofancy.grpc.*
+
+val dotenv = dotenv {
+    ignoreIfMalformed = true
+    ignoreIfMissing = true
+}
+
+fun main(args: Array<String>) {
+
+    val tracerConfig = Configuration("geofancy-java")
+    tracerConfig.withReporter(Configuration.ReporterConfiguration()
+            .withSender(Configuration.SenderConfiguration()
+                    .withEndpoint(dotenv["OPENTRACING_ENDPOINT"])))
+    val tracer = tracerConfig.tracer
+
+    GlobalTracer.register(tracer)
+
+    val server = GeofancyServer((dotenv["GRPC_SERVER_PORT"] ?: "9003").toInt())
+    server.start()
+
+    server.blockUntilShutdown()
+}

.idea/modules.xml

@@ -0,0 +1,24 @@
+package za.co.movinggauteng.geofancy;
+
+
+import io.lettuce.core.protocol.LettuceCharsets;
+import io.lettuce.core.protocol.ProtocolKeyword;
+
+public enum Tile38ProtocolCommand implements ProtocolKeyword
+{
+    SETHOOK("SETHOOK"),
+    NEARBY("NEARBY"),
+    DELHOOK("DELHOOK"),
+    PDELHOOK("PDELHOOK"),
+    DROP("DROP");
+
+    private final byte[] name;
+
+    Tile38ProtocolCommand(String commandName) {
+        name = commandName.getBytes(LettuceCharsets.ASCII);
+    }
+
+    public byte[] getBytes() {
+        return name;
+    }
+}

.idea/modules/geofancy.iml renamed to .idea/modules/geofancy-java.iml

@@ -0,0 +1,121 @@
+package za.co.movinggauteng.geofancy.geoclient
+
+import io.github.cdimascio.dotenv.dotenv
+import io.lettuce.core.RedisClient
+import io.lettuce.core.api.sync.RedisCommands
+import io.lettuce.core.codec.StringCodec
+import io.lettuce.core.output.MapOutput
+import io.lettuce.core.output.StatusOutput
+import io.lettuce.core.protocol.CommandArgs
+import io.lettuce.core.protocol.CommandType
+import za.co.movinggauteng.geofancy.Tile38ProtocolCommand
+import za.co.movinggauteng.protos.geofancy.Bounds
+import za.co.movinggauteng.protos.geofancy.GeoFence
+import za.co.movinggauteng.protos.geofancy.GeoFence.QueryCase.*
+import za.co.movinggauteng.protos.geofancy.Point
+import za.co.movinggauteng.protos.geofancy.SearchString
+
+class Tile38Client {
+
+    private val redisClient: RedisClient = RedisClient.create(env["TILE38_CONNECTION"])
+
+    private val connection = redisClient.connect()
+
+    private val sync: RedisCommands<String, String> = connection.sync()
+
+    private val codec: StringCodec = StringCodec.UTF8
+
+    companion object {
+        private val env = dotenv()
+    }
+
+    fun setPoint(collection: String, id: String, point: Point) : String {
+        return sync.dispatch(
+                CommandType.SET,
+                StatusOutput(codec),
+                CommandArgs(codec)
+                        .add(collection)
+                        .add(id)
+                        .add("POINT")
+                        .add(point.coord.lat)
+                        .add(point.coord.lng)
+        )
+    }
+
+    fun setBounds(collection: String, id: String, bounds: Bounds) {
+        TODO("Not yet implemented")
+    }
+
+    fun setWebhook(geofence: GeoFence): MutableMap<String, String>? {
+        val commands = CommandArgs(codec)
+        // load commands
+        commands.add(geofence.id)
+        commands.add(geofence.endpoint)
+        when(geofence.queryCase) {
+
+            NEARBY -> {
+                commands.add(geofence.queryCase.name)
+                commands.add(geofence.nearby.collection)
+            }
+            WITHIN -> TODO()
+            INTERSECTS -> TODO()
+            QUERY_NOT_SET -> TODO()
+        }
+        // filter
+        commands.add("MATCH")
+        commands.add(geofence.match)
+        commands.add("FENCE")
+        if (geofence.detectCount > 0) {
+            commands.add("DETECT")
+            commands.add(geofence.detectList.joinToString(",").toLowerCase())
+        }
+        if (geofence.commandsCount > 0) {
+            commands.add("COMMANDS")
+            commands.add(geofence.commandsList.joinToString(",").toLowerCase())
+        }
+        commands.add("POINT")
+        commands.add(geofence.point.coord.lat)
+        commands.add(geofence.point.coord.lng)
+        commands.add(geofence.distance)
+
+        return sync.dispatch(Tile38ProtocolCommand.SETHOOK, MapOutput(codec), commands)
+    }
+
+    fun setObject(collection: String, id: String, geoJson: String): String {
+        return sync.dispatch(
+                CommandType.SET,
+                StatusOutput(codec),
+                CommandArgs(codec)
+                        .add(collection)
+                        .add(id)
+                        .add("OBJECT")
+                        .add(geoJson)
+        )
+    }
+
+    fun deleteDocument(collection: String, id: String): String {
+        return sync.dispatch(
+                CommandType.DEL,
+                StatusOutput(codec),
+                CommandArgs(codec)
+                        .add(collection)
+                        .add(id)
+        )
+    }
+
+    fun deleteCollection(collection: String): String {
+        return sync.dispatch(
+                Tile38ProtocolCommand.DROP,
+                StatusOutput(codec),
+                CommandArgs(codec)
+                        .add(collection)
+        )
+    }
+
+    fun deleteWebhook(searchString: SearchString) : MutableMap<String, String>? {
+        val commands = CommandArgs(codec)
+        commands.add(searchString.value)
+
+        return sync.dispatch(Tile38ProtocolCommand.PDELHOOK, MapOutput(codec), commands)
+    }
+}

.idea/modules/geofancy_main.iml renamed to .idea/modules/geofancy-java_main.iml

@@ -0,0 +1,56 @@
+package za.co.movinggauteng.geofancy.grpc
+
+import io.grpc.ManagedChannel
+import io.grpc.ManagedChannelBuilder
+import io.grpc.Metadata
+import io.grpc.stub.MetadataUtils
+import za.co.movinggauteng.protos.geofancy.*
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+class GeofancyClient(channelBuilder: ManagedChannelBuilder<*>) {
+    val channel: ManagedChannel = channelBuilder.build()
+    private var greeterBlockingStub: GeofancyServiceGrpc.GeofancyServiceBlockingStub
+    private var greeterStub: GeofancyServiceGrpc.GeofancyServiceStub
+
+    constructor(host: String, port: Int, plainText: Boolean = true) : this(
+            when(plainText) {
+                true -> ManagedChannelBuilder.forAddress(host, port).usePlaintext().executor(Executors.newFixedThreadPool(16))
+                false -> ManagedChannelBuilder.forAddress(host, port).executor(Executors.newFixedThreadPool(16))
+            }
+    )
+
+    init {
+        val metadata: Metadata = Metadata()
+//        metadata.put(io.grpc.Metadata.Key.of("Authorization", io.grpc.Metadata.ASCII_STRING_MARSHALLER), "${accessToken.tokenType} ${accessToken.accessToken}")
+        greeterBlockingStub = MetadataUtils.attachHeaders(GeofancyServiceGrpc.newBlockingStub(channel), metadata)
+        greeterStub = MetadataUtils.attachHeaders(GeofancyServiceGrpc.newStub(channel), metadata)
+    }
+
+    @Throws(InterruptedException::class)
+    fun shutdown() {
+        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS)
+    }
+
+    fun isShutdown() : Boolean = channel.isShutdown
+
+    fun getBlockingStub() : GeofancyServiceGrpc.GeofancyServiceBlockingStub {
+        if (channel.isShutdown) {
+            val metadata: Metadata = Metadata()
+//            metadata.put(Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER), "${accessToken!!.tokenType} ${accessToken!!.accessToken}")
+            greeterBlockingStub = MetadataUtils.attachHeaders(GeofancyServiceGrpc.newBlockingStub(channel), metadata)
+            return greeterBlockingStub
+        }
+        return greeterBlockingStub
+    }
+
+    fun getStub() : GeofancyServiceGrpc.GeofancyServiceStub {
+        if (channel.isShutdown) {
+            val metadata: Metadata = Metadata()
+//            metadata.put(Metadata.Key.of("Authorization", Metadata.ASCII_STRING_MARSHALLER), "${accessToken!!.tokenType} ${accessToken!!.accessToken}")
+            greeterStub = MetadataUtils.attachHeaders(GeofancyServiceGrpc.newStub(channel), metadata)
+            return greeterStub
+        }
+        return greeterStub
+    }
+}