Merge pull request #5 from SOFTNETWORK-APP/feature/grpc

update grpc api

Author: fupelaqu

api/build.sbt

@@ -23,7 +23,7 @@ dockerRepository := Some("softnetwork.jfrog.io/default-docker-local")
 
 bashScriptDefines / scriptClasspath ~= (cp => "../conf" +: cp)
 
-organization := "app.softnetwork.persistence"
+organization := "app.softnetwork.notification"
 
 name := "notification-api"
 

build.sbt

@@ -31,7 +31,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "notification"
 
-ThisBuild / version := "0.1.3"
+ThisBuild / version := "0.1.4-SNAPSHOT"
 
 ThisBuild / scalaVersion := "2.12.15"
 

common/src/main/protobuf/api/notification.proto

@@ -1,7 +1,6 @@
 syntax = "proto3";
 
 import "scalapb/scalapb.proto";
-import "google/protobuf/wrappers.proto";
 import "model/notifications.proto";
 
 package app.softnetwork.notification.api;
@@ -15,6 +14,11 @@ service NotificationServiceApi {
     rpc AddMail (AddMailRequest) returns (AddNotificationResponse) {}
     rpc AddSMS (AddSMSRequest) returns (AddNotificationResponse) {}
     rpc AddPush (AddPushRequest) returns (AddNotificationResponse) {}
+    rpc RemoveNotification (RemoveNotificationRequest) returns (RemoveNotificationResponse) {}
+    rpc SendMail (SendMailRequest) returns (SendNotificationResponse) {}
+    rpc SendSMS (SendSMSRequest) returns (SendNotificationResponse) {}
+    rpc SendPush (SendPushRequest) returns (SendNotificationResponse) {}
+    rpc GetNotificationStatus (GetNotificationStatusRequest) returns (GetNotificationStatusResponse) {}
 }
 
 message AddMailRequest{
@@ -32,3 +36,35 @@ message AddPushRequest{
 message AddNotificationResponse{
     bool succeeded = 1;
 }
+
+message RemoveNotificationRequest{
+    string uuid = 1;
+}
+
+message RemoveNotificationResponse{
+    bool succeeded = 1;
+}
+
+message SendMailRequest{
+    org.softnetwork.notification.model.Mail mail = 1;
+}
+
+message SendSMSRequest{
+    org.softnetwork.notification.model.SMS sms = 1;
+}
+
+message SendPushRequest{
+    org.softnetwork.notification.model.Push push = 1;
+}
+
+message SendNotificationResponse{
+    repeated org.softnetwork.notification.model.NotificationStatusResult results = 1;
+}
+
+message GetNotificationStatusRequest{
+    string uuid = 1;
+}
+
+message GetNotificationStatusResponse{
+    repeated org.softnetwork.notification.model.NotificationStatusResult results = 1;
+}

common/src/main/scala/app/softnetwork/notification/api/NotificationClient.scala

@@ -2,7 +2,7 @@ package app.softnetwork.notification.api
 
 import akka.actor.typed.ActorSystem
 import akka.grpc.GrpcClientSettings
-import org.softnetwork.notification.model.{Mail, Push, SMS}
+import org.softnetwork.notification.model.{Mail, NotificationStatusResult, Push, SMS}
 
 import scala.concurrent.Future
 
@@ -24,6 +24,27 @@ trait NotificationClient extends GrpcClient {
   def addPush(push: Push): Future[Boolean] = {
     grpcClient.addPush(AddPushRequest(Some(push))) map (_.succeeded)
   }
+
+  def removeNotification(uuid: String): Future[Boolean] = {
+    grpcClient.removeNotification(RemoveNotificationRequest(uuid)) map (_.succeeded)
+  }
+
+  def sendMail(mail: Mail): Future[Seq[NotificationStatusResult]] = {
+    grpcClient.sendMail(SendMailRequest(Some(mail))) map (_.results)
+  }
+
+  def sendSMS(sms: SMS): Future[Seq[NotificationStatusResult]] = {
+    grpcClient.sendSMS(SendSMSRequest(Some(sms))) map (_.results)
+  }
+
+  def sendPush(push: Push): Future[Seq[NotificationStatusResult]] = {
+    grpcClient.sendPush(SendPushRequest(Some(push))) map (_.results)
+  }
+
+  def getNotificationStatus(uuid: String): Future[Seq[NotificationStatusResult]] = {
+    grpcClient.getNotificationStatus(GetNotificationStatusRequest(uuid)) map (_.results)
+  }
+
 }
 
 object NotificationClient extends GrpcClientFactory[NotificationClient] {

common/src/main/scala/app/softnetwork/notification/message/package.scala

@@ -44,17 +44,21 @@ package object message {
 
   case object NotificationRemoved extends NotificationCommandResult
 
+  trait NotificationResults extends NotificationCommandResult {
+    def results: Seq[NotificationStatusResult]
+  }
+
   @SerialVersionUID(0L)
   case class NotificationSent(uuid: String, results: Seq[NotificationStatusResult])
-      extends NotificationCommandResult
+      extends NotificationResults
 
   @SerialVersionUID(0L)
   case class NotificationDelivered(uuid: String, results: Seq[NotificationStatusResult])
-      extends NotificationCommandResult
+      extends NotificationResults
 
   @SerialVersionUID(0L)
   case class NotificationPending(uuid: String, results: Seq[NotificationStatusResult])
-      extends NotificationCommandResult
+      extends NotificationResults
 
   case class Schedule4NotificationTriggered(schedule: Schedule) extends NotificationCommandResult
 
@@ -66,10 +70,12 @@ package object message {
   @SerialVersionUID(0L)
   case class NotificationUndelivered(uuid: String, results: Seq[NotificationStatusResult])
       extends NotificationErrorMessage("NotificationUndelivered")
+      with NotificationResults
 
   @SerialVersionUID(0L)
   case class NotificationRejected(uuid: String, results: Seq[NotificationStatusResult])
       extends NotificationErrorMessage("NotificationRejected")
+      with NotificationResults
 
   case object NotificationNotFound extends NotificationErrorMessage("NotificationNotFound")
 

core/src/main/scala/app/softnetwork/notification/api/NotificationServer.scala

@@ -2,7 +2,16 @@ package app.softnetwork.notification.api
 
 import akka.actor.typed.ActorSystem
 import app.softnetwork.notification.handlers.NotificationHandler
-import app.softnetwork.notification.message.{AddNotification, NotificationAdded}
+import app.softnetwork.notification.message.{
+  AddNotification,
+  GetNotificationStatus,
+  NotificationAdded,
+  NotificationRemoved,
+  NotificationResults,
+  RemoveNotification,
+  SendNotification
+}
+import app.softnetwork.notification.model.Notification
 
 import scala.concurrent.{ExecutionContextExecutor, Future}
 
@@ -13,35 +22,66 @@ trait NotificationServer extends NotificationServiceApi {
   implicit lazy val ec: ExecutionContextExecutor = system.executionContext
 
   override def addMail(in: AddMailRequest): Future[AddNotificationResponse] = {
-    in.mail match {
-      case Some(mail) =>
-        ?(mail.uuid, AddNotification(mail)) map {
-          case _: NotificationAdded => AddNotificationResponse(true)
-          case _                    => AddNotificationResponse()
-        }
-      case _ => Future.successful(AddNotificationResponse())
-    }
+    addNotification(in.mail)
   }
 
   override def addSMS(in: AddSMSRequest): Future[AddNotificationResponse] = {
-    in.sms match {
-      case Some(sms) =>
-        ?(sms.uuid, AddNotification(sms)) map {
+    addNotification(in.sms)
+  }
+
+  override def addPush(in: AddPushRequest): Future[AddNotificationResponse] = {
+    addNotification(in.push)
+  }
+
+  protected def addNotification(maybe: Option[Notification]): Future[AddNotificationResponse] = {
+    maybe match {
+      case Some(notification) =>
+        ?(notification.uuid, AddNotification(notification)) map {
           case _: NotificationAdded => AddNotificationResponse(true)
           case _                    => AddNotificationResponse()
         }
       case _ => Future.successful(AddNotificationResponse())
     }
   }
 
-  override def addPush(in: AddPushRequest): Future[AddNotificationResponse] = {
-    in.push match {
-      case Some(push) =>
-        ?(push.uuid, AddNotification(push)) map {
-          case _: NotificationAdded => AddNotificationResponse(true)
-          case _                    => AddNotificationResponse()
+  override def removeNotification(
+    in: RemoveNotificationRequest
+  ): Future[RemoveNotificationResponse] = {
+    ?(in.uuid, RemoveNotification(in.uuid)) map {
+      case NotificationRemoved => RemoveNotificationResponse(true)
+      case _                   => RemoveNotificationResponse()
+    }
+  }
+
+  override def sendMail(in: SendMailRequest): Future[SendNotificationResponse] = {
+    sendNotification(in.mail)
+  }
+
+  override def sendSMS(in: SendSMSRequest): Future[SendNotificationResponse] = {
+    sendNotification(in.sms)
+  }
+
+  override def sendPush(in: SendPushRequest): Future[SendNotificationResponse] = {
+    sendNotification(in.push)
+  }
+
+  protected def sendNotification(maybe: Option[Notification]): Future[SendNotificationResponse] = {
+    maybe match {
+      case Some(notification) =>
+        ?(notification.uuid, SendNotification(notification)) map {
+          case r: NotificationResults => SendNotificationResponse(r.results)
+          case _                      => SendNotificationResponse()
         }
-      case _ => Future.successful(AddNotificationResponse())
+      case _ => Future.successful(SendNotificationResponse())
+    }
+  }
+
+  override def getNotificationStatus(
+    in: GetNotificationStatusRequest
+  ): Future[GetNotificationStatusResponse] = {
+    ?(in.uuid, GetNotificationStatus(in.uuid)) map {
+      case r: NotificationResults => GetNotificationStatusResponse(r.results)
+      case _                      => GetNotificationStatusResponse()
     }
   }
 }

testkit/src/test/scala/app/softnetwork/notification/handlers/AllNotificationsHandlerSpec.scala

@@ -4,6 +4,8 @@ import org.scalatest.wordspec.AnyWordSpecLike
 import app.softnetwork.notification.message._
 import app.softnetwork.notification.scalatest.AllNotificationsTestKit
 
+import scala.util.{Failure, Success}
+
 /** Created by smanciot on 14/04/2020.
   */
 class AllNotificationsHandlerSpec
@@ -96,22 +98,75 @@ class AllNotificationsHandlerSpec
       }
     }
 
-    "add mail" in {
+    "add mail using client" in {
       val uuid = "mail"
       assert(client.addMail(generateMail(uuid)) complete ())
       assert(probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey")
     }
 
-    "add sms" in {
+    "send mail using client" in {
+      val uuid = "mail2"
+      val mail = generateMail(uuid)
+      client.sendMail(mail) complete () match {
+        case Success(result) =>
+          assert(result.exists(r => r.recipient == mail.to.head && r.status.isSent))
+        case Failure(_) => fail()
+      }
+    }
+
+    "remove notification using client" in {
+      assert(client.removeNotification("mail") complete ())
+    }
+
+    "add sms using client" in {
       val uuid = "sms"
       assert(client.addSMS(generateSMS(uuid)) complete ())
-      assert(probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey")
+      assert(
+        probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey"
+      ) // pending
+      assert(
+        probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey"
+      ) // ack
     }
 
-    "add push" in {
+    "send sms using client" in {
+      val uuid = "sms2"
+      val sms = generateSMS(uuid)
+      client.sendSMS(sms) complete () match {
+        case Success(result) =>
+          assert(result.exists(r => r.recipient == sms.to.head && r.status.isPending))
+          assert(
+            probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey"
+          ) // ack
+        case Failure(_) => fail()
+      }
+    }
+
+    "add push using client" in {
       val uuid = "push"
-      assert(client.addPush(generatePush(uuid)) complete ())
+      assert(client.addPush(generatePush(uuid, androidDevice, iosDevice)) complete ())
       assert(probe.receiveMessage().schedule.uuid == s"Notification#$uuid#NotificationTimerKey")
     }
+
+    "retrieve push notification status using client" in {
+      client.getNotificationStatus("push") complete () match {
+        case Success(result) =>
+          assert(result.exists(r => r.recipient == androidDevice.regId && r.status.isSent))
+          assert(result.exists(r => r.recipient == iosDevice.regId && r.status.isSent))
+        case Failure(_) => fail()
+      }
+    }
+
+    "send push using client" in {
+      val uuid = "push2"
+      val push = generatePush(uuid, androidDevice, iosDevice)
+      client.sendPush(push) complete () match {
+        case Success(result) =>
+          assert(result.exists(r => r.recipient == androidDevice.regId && r.status.isSent))
+          assert(result.exists(r => r.recipient == iosDevice.regId && r.status.isSent))
+        case Failure(_) => fail()
+      }
+    }
+
   }
 }