#1633 remove all deprecated

Author: tanjjj

docs/rpc/service.md

@@ -16,28 +16,24 @@ exchange in [XLON, XAMS, NYSE]
 You may have noticed when you type in the filter in the grid you get a typeahead hint for the available values. If I had
 typed "exchange in [" the UI offers up to 10 values based on the contents of the tables.
 
-These suggestions are implemented as an RPC service within the type ahead module:
+These suggestions are implemented as an RPC service ViewportTypeAheadRpcHandler within the DefaultRpcHandler:
 
 ```scala
-
-object TypeAheadModule extends DefaultModule {
-
-  final val NAME = "TYPEAHEAD"
-
-  def apply()(implicit clock: Clock, lifecycle: LifecycleContainer): ViewServerModule = {
-    ModuleFactory.withNamespace(NAME)
-      .addRpcHandler(server => new GenericTypeAheadRpcHandler(server.tableContainer))
-      .asModule()
-  }
-}
+class DefaultRpcHandler(implicit tableContainer: TableContainer) extends RpcHandler with StrictLogging {
+  ...
+  private val viewportTypeAheadRpcHandler = new ViewportTypeAheadRpcHandler(tableContainer)
+  viewportTypeAheadRpcHandler.register(this)
 ```
 
-You can see we've defined an RpcHandler called GenericTypeAheadRpcHandler, which implements the interface:
+You can see we've defined an RpcHandler called ViewportTypeAheadRpcHandler:
 
 ```scala
-trait TypeAheadRpcHandler{
-  def getUniqueFieldValues(tableMap: Map[String, String], column: String, ctx: RequestContext): Array[String]
-  def getUniqueFieldValuesStartingWith(tableMap: Map[String, String], column: String, starts: String, ctx: RequestContext): Array[String]
+class ViewportTypeAheadRpcHandler(tableContainer: TableContainer) {
+  ...
+  def processGetUniqueFieldValuesRequest(params: RpcParams): RpcFunctionResult = {
+  ...
+  def processGetUniqueFieldValuesStartWithRequest(params: RpcParams): RpcFunctionResult = {
+  ...
 }
 ```
 

example/apache-ignite/src/main/scala/org/finos/vuu/example/ignite/IgniteVuuMain.scala

@@ -7,19 +7,12 @@ import org.finos.toolbox.lifecycle.LifecycleContainer
 import org.finos.toolbox.time.{Clock, DefaultClock}
 import org.finos.vuu.core._
 import org.finos.vuu.core.module.TableDefContainer
-import org.finos.vuu.core.module.authn.AuthNModule
-import org.finos.vuu.core.module.auths.PermissionModule
 import org.finos.vuu.core.module.metrics.MetricsModule
-import org.finos.vuu.core.module.price.PriceModule
-import org.finos.vuu.core.module.simul.SimulationModule
-import org.finos.vuu.core.module.typeahead.TypeAheadModule
-import org.finos.vuu.core.module.vui.VuiStateModule
 import org.finos.vuu.example.ignite.loader.IgniteOrderGenerator
 import org.finos.vuu.example.ignite.module.IgniteOrderDataModule
 import org.finos.vuu.net.auth.AlwaysHappyAuthenticator
 import org.finos.vuu.net.http.{AbsolutePathWebRoot, VuuHttp2ServerOptions}
 import org.finos.vuu.net.{AlwaysHappyLoginValidator, Authenticator, LoggedInTokenValidator}
-import org.finos.vuu.order.oms.OmsApi
 import org.finos.vuu.plugin.virtualized.VirtualizedTablePlugin
 import org.finos.vuu.state.MemoryBackedVuiStateStore
 
@@ -78,8 +71,7 @@ object IgniteVuuMain extends App with StrictLogging {
     VuuThreadingOptions()
       .withViewPortThreads(4)
       .withTreeThreads(4)
-  ).withModule(TypeAheadModule())
-    .withModule(MetricsModule())
+  ).withModule(MetricsModule())
     .withModule(IgniteOrderDataModule(igniteOrderStore))
     .withPlugin(VirtualizedTablePlugin)
 

example/basket/src/test/scala/org/finos/vuu/core/module/basket/BasketConstituentMutateTest.scala

@@ -49,7 +49,7 @@ class BasketConstituentMutateTest extends VuuServerTestCase {
           val basketTradingConstituentJoinService = vpBasketTradingConsJoin.getStructure.viewPortDef.service
           val selection = vpBasketTradingConsJoin.getSelection
           val vpSelection = ViewPortSelection(selection, vpBasketTradingConsJoin)
-          basketTradingConstituentJoinService.processRpcRequest("setSell", new RpcParams(null, Map("selection" -> vpSelection), None, None, vuuServer.requestContext))
+          basketTradingConstituentJoinService.processRpcRequest("setSell", new RpcParams(Map("selection" -> vpSelection), None, None, vuuServer.requestContext))
           vuuServer.runOnce()
 
           Then("get all the updates that have occurred for all view ports from the outbound queue")

example/basket/src/test/scala/org/finos/vuu/core/module/basket/BasketCreateTest.scala

@@ -70,7 +70,7 @@ class BasketCreateTest extends VuuServerTestCase {
 
           val basketService = viewportBasket.getStructure.viewPortDef.service
 
-          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(null, Map("sourceBasketId" -> basketId, "basketTradeName" -> "TestBasket"), None, None, vuuServer.requestContext))
+          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(Map("sourceBasketId" -> basketId, "basketTradeName" -> "TestBasket"), None, None, vuuServer.requestContext))
           vuuServer.runOnce()
           assert(rpcResult.isInstanceOf[RpcFunctionSuccess])
           val basketTradeInstanceId = rpcResult.asInstanceOf[RpcFunctionSuccess].optionalResult.get.asInstanceOf[String]

example/basket/src/test/scala/org/finos/vuu/core/module/basket/BasketMutateOffMarketTest.scala

@@ -69,7 +69,7 @@ class BasketMutateOffMarketTest extends VuuServerTestCase {
 
           Then("Get the Basket RPC Service and call create basket")
           val basketService = vpBasket.getStructure.viewPortDef.service
-          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(null, Map("sourceBasketId" -> ".FTSE", "basketTradeName" -> "MyCustomBasket"), None, None, vuuServer.requestContext))
+          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(Map("sourceBasketId" -> ".FTSE", "basketTradeName" -> "MyCustomBasket"), None, None, vuuServer.requestContext))
           assert(rpcResult.isInstanceOf[RpcFunctionSuccess])
           val basketTradeInstanceId = rpcResult.asInstanceOf[RpcFunctionSuccess].optionalResult.get.asInstanceOf[String]
 
@@ -210,7 +210,7 @@ class BasketMutateOffMarketTest extends VuuServerTestCase {
           vuuServer.runOnce()
 
           When("we edit the side of the parent basket to same side as current value")
-          basketTradingConstituentJoinService.processRpcRequest("addConstituent", new RpcParams(null, Map("ric" -> "0001.HK"), None, None, vuuServer.requestContext))
+          basketTradingConstituentJoinService.processRpcRequest("addConstituent", new RpcParams(Map("ric" -> "0001.HK"), None, None, vuuServer.requestContext))
           vuuServer.runOnce()
 
           Then("get all the updates that have occurred for all view ports from the outbound queue")
@@ -243,7 +243,7 @@ class BasketMutateOffMarketTest extends VuuServerTestCase {
 
     val vpBasket = vuuServer.createViewPort(BasketModule.NAME, BasketModule.BasketTable)
     val basketService = vpBasket.getStructure.viewPortDef.service
-    val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(null, Map("sourceBasketId" -> basketId, "basketTradeName" -> basketTradeName), None, None, vuuServer.requestContext))
+    val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(Map("sourceBasketId" -> basketId, "basketTradeName" -> basketTradeName), None, None, vuuServer.requestContext))
     assert(rpcResult.isInstanceOf[RpcFunctionSuccess])
     rpcResult.asInstanceOf[RpcFunctionSuccess].optionalResult.get.asInstanceOf[String]
   }

example/basket/src/test/scala/org/finos/vuu/core/module/basket/BasketSendToMarketTest.scala

@@ -50,7 +50,7 @@ class BasketSendToMarketTest extends VuuServerTestCase {
           Then("Get the Basket RPC Service and call create basket")
           val basketService = vpBasket.getStructure.viewPortDef.service
 
-          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(null, Map("sourceBasketId" -> ".FTSE", "basketTradeName" -> "TestBasket"), None, None, vuuServer.requestContext))
+          val rpcResult = basketService.processRpcRequest("createBasket", new RpcParams(Map("sourceBasketId" -> ".FTSE", "basketTradeName" -> "TestBasket"), None, None, vuuServer.requestContext))
           assert(rpcResult.isInstanceOf[RpcFunctionSuccess])
           val basketTradeInstanceId = rpcResult.asInstanceOf[RpcFunctionSuccess].optionalResult.get.asInstanceOf[String]
 
@@ -71,7 +71,7 @@ class BasketSendToMarketTest extends VuuServerTestCase {
 
           val tradingService = vpBasketTrading.getStructure.viewPortDef.service
           And("send the basket to market")
-          tradingService.processRpcRequest("sendToMarket", new RpcParams(null, Map("basketInstanceId"-> basketTradeInstanceId), None, None, vuuServer.requestContext))
+          tradingService.processRpcRequest("sendToMarket", new RpcParams(Map("basketInstanceId"-> basketTradeInstanceId), None, None, vuuServer.requestContext))
 
           vuuServer.runOnce()
 
@@ -84,7 +84,7 @@ class BasketSendToMarketTest extends VuuServerTestCase {
           }
 
           Then("Take the basket off the market")
-          tradingService.processRpcRequest("takeOffMarket", new RpcParams(null, Map("basketInstanceId"-> basketTradeInstanceId), None, None, vuuServer.requestContext))
+          tradingService.processRpcRequest("takeOffMarket", new RpcParams(Map("basketInstanceId"-> basketTradeInstanceId), None, None, vuuServer.requestContext))
 
           vuuServer.runOnce()
 

example/main-java/src/main/java/org/finos/vuu/VuuExampleMain.java

@@ -12,7 +12,6 @@
 import org.finos.vuu.core.module.metrics.MetricsModule;
 import org.finos.vuu.core.module.price.PriceModule;
 import org.finos.vuu.core.module.simul.SimulationModule;
-import org.finos.vuu.core.module.typeahead.TypeAheadModule;
 import org.finos.vuu.core.module.vui.VuiStateModule;
 import org.finos.vuu.module.JavaExampleModule;
 import org.finos.vuu.net.AlwaysHappyLoginValidator;
@@ -78,7 +77,6 @@ public static void main( String[] args )
          .withModule(SimulationModule.apply(clock, lifecycle, tableDefContainer))
          .withModule(MetricsModule.apply(clock, lifecycle, metrics, tableDefContainer))
          .withModule(VuiStateModule.apply(store, clock, lifecycle, tableDefContainer))
-         .withModule(TypeAheadModule.apply(clock, lifecycle, tableDefContainer))
          .withModule(AuthNModule.apply(authenticator, loginTokenValidator, clock, lifecycle, tableDefContainer))
          //the modules above are scala, the modules below are java...
          .withModule(new JavaExampleModule().create(tableDefContainer, clock))       ;

vuu-java/src/test/java/org/finos/vuu/net/rpc/RpcMethodHandlerTest.java

@@ -18,8 +18,7 @@
 import test.helper.ViewPortTestUtils;
 
 import java.util.Collections;
-
-import static test.helper.ViewPortTestUtils.createRandomViewServerMessage;
+import java.util.Map;
 
 public class RpcMethodHandlerTest {
 
@@ -34,12 +33,12 @@ public void should_register_java_function_as_rpc_in_default_handler() {
         final DefaultRpcHandler defaultRpcHandler = new DefaultRpcHandler(tableContainer);
         defaultRpcHandler.registerRpc("helloWorld", rpcService::rpcFunction);
 
-        RpcCall call = new RpcCall("service", "helloWorld", new Object[]{}, ScalaCollectionConverter.toScala(Collections.emptyMap()));
-        Option<ViewServerMessage> response = defaultRpcHandler.processRpcCall(createRandomViewServerMessage(new LoginRequest("token", "user")), call, ViewPortTestUtils.requestContext());
+        RpcFunctionResult response = defaultRpcHandler.processRpcRequest("helloWorld", new RpcParams(ScalaCollectionConverter.toScala(Collections.emptyMap()), Option.empty(), Option.empty(), ViewPortTestUtils.requestContext()));
 
-        Assertions.assertThat(response.get().body())
-                .isExactlyInstanceOf(RpcResponse.class)
-                .isEqualTo(new RpcResponse("helloWorld", "It Works", null));
+        Assertions.assertThat(response)
+                .isExactlyInstanceOf(RpcFunctionSuccess.class);
+        Assertions.assertThat(((RpcFunctionSuccess) response).optionalResult().get())
+                .isEqualTo("It Works");
     }
 
     static class TestRpcService {

vuu/src/main/scala/org/finos/vuu/core/CoreServerApiHandler.scala

@@ -15,18 +15,6 @@ class CoreServerApiHandler(val viewPortContainer: ViewPortContainer,
                            val tableContainer: TableContainer,
                            val providers: ProviderContainer)(implicit timeProvider: Clock) extends ServerApi with StrictLogging {
 
-  @deprecated("ViewPortRpcCall is replaced by RpcRequest")
-  override def process(msg: ViewPortRpcCall)(ctx: RequestContext): Option[ViewServerMessage] = {
-    Try(viewPortContainer.callRpcService(msg.vpId, msg.rpcName, msg.params, msg.namedParams, ctx.session)(ctx)) match {
-      case Success(action) =>
-        logger.debug("Processed VP RPC call " + msg)
-        vsMsg(ViewPortRpcResponse(msg.vpId, msg.rpcName, action))(ctx)
-      case Failure(e) =>
-        logger.warn("Failed to process VP RPC call", e)
-        vsMsg(ViewPortMenuRpcReject(msg.vpId, msg.rpcName, e.getMessage))(ctx)
-    }
-  }
-
   override def process(msg: ViewPortMenuCellRpcCall)(ctx: RequestContext): Option[ViewServerMessage] = {
     Try(viewPortContainer.callRpcCell(msg.vpId, msg.rpcName, ctx.session, msg.rowKey, msg.field, msg.value)) match {
       case Success(action) =>

vuu/src/main/scala/org/finos/vuu/core/VuuServer.scala

@@ -145,15 +145,11 @@ class VuuServer(config: VuuServerConfig)(implicit lifecycle: LifecycleContainer,
     val vs = this
 
     val realized = new RealizedViewServerModule {
-      @deprecated("RpcCall is replaced by RpcRequest")
-      override def rpcHandlers: List[RpcHandler] = module.rpcHandlersUnrealized.map(_.apply(vs))
       override def restServices: List[RestService] = module.restServicesUnrealized.map(_.apply(vs))
       override def name: String = module.name
       override def tableDefContainer: TableDefContainer = module.tableDefContainer
       override def tableDefs: List[TableDef] = module.tableDefs
       override def serializationMixin: AnyRef = module.serializationMixin
-      @deprecated("RpcCall is replaced by RpcRequest")
-      override def rpcHandlersUnrealized: List[IVuuServer => RpcHandler] = module.rpcHandlersUnrealized
       override def restServicesUnrealized: List[IVuuServer => RestService] = module.restServicesUnrealized
       override def getProviderForTable(table: DataTable, viewserver: IVuuServer)(implicit time: Clock, life: LifecycleContainer): Provider = {
         module.getProviderForTable(table, viewserver)(time, life)