persist external scheduler events to add or remove schedule - add Ext…

build.sbt

@@ -31,7 +31,7 @@ ThisBuild / organization := "app.softnetwork"
 
 name := "payment"
 
-ThisBuild / version := "0.1.5.1"
+ThisBuild / version := "0.2.0"
 
 ThisBuild / scalaVersion := "2.12.15"
 

common/src/main/protobuf/message/payment/payment.proto

@@ -5,7 +5,6 @@ import "google/protobuf/timestamp.proto";
 import "model/payment/card.proto";
 import "model/payment/document.proto";
 import "model/payment/paymentUser.proto";
-import "message/schedule.proto";
 
 package app.softnetwork.payment.message.PaymentEvents;
 
@@ -16,14 +15,15 @@ option (scalapb.options) = {
     import: "app.softnetwork.persistence.model._"
     import: "app.softnetwork.protobuf.ScalaPBTypeMappers._"
     import: "app.softnetwork.serialization._"
+    import: "app.softnetwork.payment.message.PaymentMessages._"
     import: "app.softnetwork.payment.model._"
     import: "app.softnetwork.payment.serialization._"
-    import: "org.softnetwork.akka.message.SchedulerEvents.SchedulerEventWithCommand"
-    preamble: "trait PaymentEvent extends Event"
-    preamble: "trait PaymentAccountEvent extends PaymentEvent"
-    preamble: "trait PaymentCommandEvent extends PaymentEvent"
-    preamble: "trait WrapPaymentCommandEvent extends PaymentCommandEvent {def event: PaymentCommandEvent}"
-    preamble: "trait PaymentToSchedulerEvent extends SchedulerEventWithCommand with PaymentEvent"
+    import: "app.softnetwork.scheduler.message.SchedulerEvents.ExternalSchedulerEvent"
+    preamble: "trait PaymentEvent extends ExternalSchedulerEvent"
+    preamble: "sealed trait PaymentAccountEvent extends PaymentEvent"
+    preamble: "sealed trait PaymentCommandEvent extends PaymentEvent"
+    preamble: "trait ExternalPaymentEvent extends PaymentEvent"
+    preamble: "trait PaymentEventWithCommand extends ExternalPaymentEvent {def command: Option[PaymentCommandEvent]}"
     preserve_unknown_fields: false
 };
 
@@ -153,6 +153,24 @@ message BankAccountDeletedEvent {
     required google.protobuf.Timestamp lastUpdated = 2 [(scalapb.field).type = "java.util.Date"];
 }
 
+message ExternalEntityToPaymentEvent{
+    option (scalapb.message).extends = "ProtobufEvent";
+    option (scalapb.message).extends = "PaymentEventWithCommand";
+    option (scalapb.message).extends = "ExternalEntityToPaymentEventDecorator";
+    oneof wrapped {
+        PayInWithCardPreAuthorizedCommandEvent payInWithCardPreAuthorized = 1;
+        RefundCommandEvent refund = 2;
+        PayOutCommandEvent payOut = 3;
+        TransferCommandEvent transfer = 4;
+        DirectDebitCommandEvent directDebit = 5;
+        CreateOrUpdatePaymentAccountCommandEvent createOrUpdatePaymentAccount = 6;
+        RegisterRecurringPaymentCommandEvent registerRecurringPayment = 7;
+        CancelPreAuthorizationCommandEvent cancelPreAuthorization = 8;
+        LoadDirectDebitTransactionCommandEvent loadDirectDebitTransaction = 9;
+        CancelMandateCommandEvent cancelMandate = 10;
+    }
+}
+
 message PayInWithCardPreAuthorizedCommandEvent{
     option (scalapb.message).extends = "ProtobufEvent";
     option (scalapb.message).extends = "PaymentCommandEvent";
@@ -211,18 +229,6 @@ message CreateOrUpdatePaymentAccountCommandEvent{
     required app.softnetwork.payment.model.PaymentAccount paymentAccount = 1;
 }
 
-message ScheduleForPaymentAdded {
-    option (scalapb.message).extends = "ProtobufEvent";
-    option (scalapb.message).extends = "PaymentToSchedulerEvent";
-    required app.softnetwork.scheduler.message.AddSchedule command = 1;
-}
-
-message ScheduleForPaymentRemoved {
-    option (scalapb.message).extends = "ProtobufEvent";
-    option (scalapb.message).extends = "PaymentToSchedulerEvent";
-    required app.softnetwork.scheduler.message.RemoveSchedule command = 1;
-}
-
 message RegisterRecurringPaymentCommandEvent {
     option (scalapb.message).extends = "ProtobufEvent";
     option (scalapb.message).extends = "PaymentCommandEvent";
@@ -241,7 +247,7 @@ message RegisterRecurringPaymentCommandEvent {
 
 message RecurringPaymentRegisteredEvent {
     option (scalapb.message).extends = "ProtobufEvent";
-    option (scalapb.message).extends = "PaymentCommandEvent";
+    option (scalapb.message).extends = "PaymentAccountEvent";
     option (scalapb.message).extends = "BroadcastEvent";
     required string externalUuid = 1;
     required app.softnetwork.payment.model.RecurringPayment recurringPayment = 2;

common/src/main/scala/app/softnetwork/payment/message/PaymentMessages.scala

@@ -1,9 +1,14 @@
 package app.softnetwork.payment.message
 
 import app.softnetwork.payment.annotation.InternalApi
+import app.softnetwork.payment.message.PaymentEvents.{
+  ExternalEntityToPaymentEvent,
+  PaymentCommandEvent,
+  PaymentEventWithCommand
+}
 import app.softnetwork.payment.model._
 import app.softnetwork.persistence.message.{Command, CommandResult, EntityCommand, ErrorMessage}
-import org.softnetwork.akka.model.Schedule
+import app.softnetwork.scheduler.model.Schedule
 
 import java.util.Date
 
@@ -814,4 +819,22 @@ object PaymentMessages {
   ) extends PaymentError(s"NextRecurringPaymentFailed: $reason")
 
   case object Schedule4PaymentNotTriggered extends PaymentError("Schedule4PaymentNotTriggered")
+
+  trait ExternalEntityToPaymentEventDecorator extends PaymentEventWithCommand {
+    _: ExternalEntityToPaymentEvent =>
+    override def command: Option[PaymentCommandEvent] =
+      wrapped match {
+        case r: ExternalEntityToPaymentEvent.Wrapped.CreateOrUpdatePaymentAccount => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.PayInWithCardPreAuthorized   => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.Refund                       => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.PayOut                       => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.Transfer                     => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.DirectDebit                  => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.LoadDirectDebitTransaction   => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.RegisterRecurringPayment     => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.CancelPreAuthorization       => Some(r.value)
+        case r: ExternalEntityToPaymentEvent.Wrapped.CancelMandate                => Some(r.value)
+        case _                                                                    => None
+      }
+  }
 }

core/build.sbt

@@ -5,7 +5,6 @@ organization := "app.softnetwork.payment"
 name := "payment-core"
 
 libraryDependencies ++= Seq(
-  "app.softnetwork.scheduler" %% "scheduler-core" % Versions.scheduler,
   "app.softnetwork.persistence" %% "persistence-kv" % Versions.genericPersistence,
   "app.softnetwork.session" %% "session-core" % Versions.session
 )

core/src/main/scala/app/softnetwork/payment/launch/PaymentApplication.scala

@@ -1,11 +1,6 @@
 package app.softnetwork.payment.launch
 
-import akka.actor.typed.ActorSystem
 import app.softnetwork.api.server.launch.Application
 import app.softnetwork.persistence.query.SchemaProvider
 
-trait PaymentApplication extends Application with PaymentRoutes { _: SchemaProvider =>
-  override def initSystem: ActorSystem[_] => Unit = system => {
-    initSchedulerSystem(system)
-  }
-}
+trait PaymentApplication extends Application with PaymentRoutes { _: SchemaProvider => }

core/src/main/scala/app/softnetwork/payment/launch/PaymentGuardian.scala

@@ -10,11 +10,9 @@ import app.softnetwork.payment.persistence.typed.GenericPaymentBehavior
 import app.softnetwork.persistence.launch.PersistentEntity
 import app.softnetwork.persistence.query.{EventProcessorStream, SchemaProvider}
 import app.softnetwork.persistence.typed.Singleton
-import app.softnetwork.scheduler.launch.SchedulerGuardian
-import app.softnetwork.scheduler.persistence.query.Scheduler2EntityProcessorStream
 import app.softnetwork.session.launch.SessionGuardian
 
-trait PaymentGuardian extends SchedulerGuardian with SessionGuardian { _: SchemaProvider =>
+trait PaymentGuardian extends SessionGuardian { _: SchemaProvider =>
 
   import app.softnetwork.persistence.launch.PersistenceGuardian._
 
@@ -28,26 +26,22 @@ trait PaymentGuardian extends SchedulerGuardian with SessionGuardian { _: Schema
   /** initialize all entities
     */
   override def entities: ActorSystem[_] => Seq[PersistentEntity[_, _, _, _]] = sys =>
-    schedulerEntities(sys) ++ sessionEntities(sys) ++ paymentEntities(sys)
+    sessionEntities(sys) ++ paymentEntities(sys)
 
   /** initialize all singletons
     */
   override def singletons: ActorSystem[_] => Seq[Singleton[_]] = _ => Seq(paymentKvDao)
 
   def paymentCommandProcessorStream: ActorSystem[_] => GenericPaymentCommandProcessorStream
 
-  def paymentEventProcessorStreams: ActorSystem[_] => Seq[EventProcessorStream[_]] = sys =>
-    Seq(paymentCommandProcessorStream(sys))
-
   def scheduler2PaymentProcessorStream: ActorSystem[_] => Scheduler2PaymentProcessorStream
 
-  override def scheduler2EntityProcessorStreams
-    : ActorSystem[_] => Seq[Scheduler2EntityProcessorStream[_, _]] = sys =>
-    Seq(scheduler2PaymentProcessorStream(sys))
+  def paymentEventProcessorStreams: ActorSystem[_] => Seq[EventProcessorStream[_]] = sys =>
+    Seq(paymentCommandProcessorStream(sys)) :+ scheduler2PaymentProcessorStream(sys)
 
   /** initialize all event processor streams
     */
   override def eventProcessorStreams: ActorSystem[_] => Seq[EventProcessorStream[_]] = sys =>
-    schedulerEventProcessorStreams(sys) ++ paymentEventProcessorStreams(sys)
+    paymentEventProcessorStreams(sys)
 
 }