OO-152: manage rolle / weblogin in admin interface

src/main/scala/ch/openolitor/stammdaten/StammdatenAktionenService.scala

@@ -93,6 +93,8 @@ class StammdatenAktionenService(override val sysConfig: SystemConfig, override v
       sendEinladung(meta, einladung)
     case PasswortResetGesendetEvent(meta, einladung) =>
       sendPasswortReset(meta, einladung)
+    case RolleGewechseltEvent(meta, _, personId, rolle) =>
+      changeRolle(meta, personId, rolle)
     case e =>
       logger.warn(s"Unknown event:$e")
   }
@@ -261,6 +263,15 @@ Summe [${projekt.waehrung}]: ${bestellung.preisTotal}"""
     }
   }
 
+  def changeRolle(meta: EventMetadata, personId: PersonId, rolle: Rolle)(implicit originator: PersonId = meta.originator) = {
+    DB localTx { implicit session =>
+      stammdatenWriteRepository.getById(personMapping, personId) map { person =>
+        val updated = person.copy(rolle = Some(rolle))
+        stammdatenWriteRepository.updateEntity[Person, PersonId](updated)
+      }
+    }
+  }
+
   def auslieferungAusgeliefert(meta: EventMetadata, id: AuslieferungId)(implicit personId: PersonId = meta.originator) = {
     DB autoCommit { implicit session =>
       stammdatenWriteRepository.getById(depotAuslieferungMapping, id) map { auslieferung =>

src/main/scala/ch/openolitor/stammdaten/StammdatenCommandHandler.scala

@@ -52,6 +52,7 @@ object StammdatenCommandHandler {
   case class EinladungSendenCommand(originator: PersonId, kundeId: KundeId, personId: PersonId) extends UserCommand
   case class BestellungenAlsAbgerechnetMarkierenCommand(originator: PersonId, datum: DateTime, ids: Seq[BestellungId]) extends UserCommand
   case class PasswortResetCommand(originator: PersonId, personId: PersonId) extends UserCommand
+  case class RolleWechselnCommand(originator: PersonId, kundeId: KundeId, personId: PersonId, rolle: Rolle) extends UserCommand
 
   case class LieferplanungAbschliessenEvent(meta: EventMetadata, id: LieferplanungId) extends PersistentEvent with JSONSerializable
   case class LieferplanungAbrechnenEvent(meta: EventMetadata, id: LieferplanungId) extends PersistentEvent with JSONSerializable
@@ -63,6 +64,7 @@ object StammdatenCommandHandler {
   case class AuslieferungAlsAusgeliefertMarkierenEvent(meta: EventMetadata, id: AuslieferungId) extends PersistentEvent with JSONSerializable
   case class BestellungAlsAbgerechnetMarkierenEvent(meta: EventMetadata, datum: DateTime, id: BestellungId) extends PersistentEvent with JSONSerializable
   case class PasswortResetGesendetEvent(meta: EventMetadata, einladung: EinladungCreate) extends PersistentEvent with JSONSerializable
+  case class RolleGewechseltEvent(meta: EventMetadata, kundeId: KundeId, personId: PersonId, rolle: Rolle) extends PersistentEvent with JSONSerializable
 }
 
 trait StammdatenCommandHandler extends CommandHandler with StammdatenDBMappings with ConnectionPoolContextAware {
@@ -188,6 +190,9 @@ trait StammdatenCommandHandler extends CommandHandler with StammdatenDBMappings
     case PasswortResetCommand(originator, personId) => idFactory => meta =>
       sendPasswortReset(idFactory, meta, personId)
 
+    case RolleWechselnCommand(originator, kundeId, personId, rolle) if originator.id != personId => idFactory => meta =>
+      changeRolle(idFactory, meta, kundeId, personId, rolle)
+
     /*
        * Insert command handling
        */
@@ -437,6 +442,24 @@ trait StammdatenCommandHandler extends CommandHandler with StammdatenDBMappings
       }
     }
   }
+
+  def changeRolle(idFactory: IdFactory, meta: EventMetadata, kundeId: KundeId, personId: PersonId, rolle: Rolle) = {
+    DB readOnly { implicit session =>
+      stammdatenWriteRepository.getById(personMapping, personId) map { person =>
+        person.rolle map { existingRolle =>
+          if (existingRolle != rolle) {
+            Success(Seq(RolleGewechseltEvent(meta, kundeId, personId, rolle)))
+          } else {
+            Failure(new InvalidStateException(s"Die Person mit der Id: $personId hat bereits die Rolle: $rolle."))
+          }
+        } getOrElse {
+          Success(Seq(RolleGewechseltEvent(meta, kundeId, personId, rolle)))
+        }
+      } getOrElse {
+        Failure(new InvalidStateException(s"Person wurde nicht gefunden."))
+      }
+    }
+  }
 }
 
 class DefaultStammdatenCommandHandler(override val sysConfig: SystemConfig, override val system: ActorSystem) extends StammdatenCommandHandler

src/main/scala/ch/openolitor/stammdaten/StammdatenInsertService.scala

@@ -248,18 +248,23 @@ class StammdatenInsertService(override val sysConfig: SystemConfig) extends Even
   }
 
   def createPerson(meta: EventMetadata, id: PersonId, create: PersonCreate)(implicit personId: PersonId = meta.originator) = {
-    val person = copyTo[PersonCreate, Person](create, "id" -> id,
+    val rolle: Option[Rolle] = Some(KundenZugang)
+
+    val person = copyTo[PersonCreate, Person](
+      create,
+      "id" -> id,
       "kundeId" -> create.kundeId,
       "sort" -> create.sort,
       "loginAktiv" -> FALSE,
       "letzteAnmeldung" -> None,
       "passwort" -> None,
       "passwortWechselErforderlich" -> FALSE,
-      "rolle" -> None,
+      "rolle" -> rolle,
       "erstelldat" -> meta.timestamp,
       "ersteller" -> meta.originator,
       "modifidat" -> meta.timestamp,
-      "modifikator" -> meta.originator)
+      "modifikator" -> meta.originator
+    )
 
     DB autoCommit { implicit session =>
       stammdatenWriteRepository.insertEntity[Person, PersonId](person)

src/main/scala/ch/openolitor/stammdaten/StammdatenJsonProtocol.scala

@@ -79,7 +79,7 @@ trait StammdatenJsonProtocol extends BaseJsonProtocol with LazyLogging with Auto
       }
   }
 
-  implicit val rolleFormat = new JsonFormat[Rolle] {
+  implicit val rolleFormat = new RootJsonFormat[Rolle] {
     def write(obj: Rolle): JsValue =
       obj match {
         case AdministratorZugang => JsString("Administrator")

src/main/scala/ch/openolitor/stammdaten/StammdatenRoutes.scala

@@ -201,6 +201,15 @@ trait StammdatenRoutes extends HttpService with ActorReferences
       path("kunden" / kundeIdPath / "personen" / personIdPath / "aktionen" / "einladungsenden") { (kundeId, personId) =>
         (post)(sendEinladung(kundeId, personId))
       } ~
+      path("kunden" / kundeIdPath / "personen" / personIdPath / "aktionen" / "rollewechseln") { (kundeId, personId) =>
+        post {
+          requestInstance { request =>
+            entity(as[Rolle]) { rolle =>
+              changeRolle(kundeId, personId, rolle)
+            }
+          }
+        }
+      } ~
       path("kunden" / kundeIdPath / "rechnungen") { (kundeId) =>
         get(list(buchhaltungReadRepository.getKundenRechnungen(kundeId)))
       }
@@ -642,6 +651,15 @@ trait StammdatenRoutes extends HttpService with ActorReferences
     }
   }
 
+  def changeRolle(kundeId: KundeId, personId: PersonId, rolle: Rolle)(implicit idPersister: Persister[KundeId, _], subject: Subject) = {
+    onSuccess((entityStore ? StammdatenCommandHandler.RolleWechselnCommand(subject.personId, kundeId, personId, rolle))) {
+      case UserCommandFailed =>
+        complete(StatusCodes.BadRequest, s"Die Rolle der Person konnte nicht gewechselt werden.")
+      case _ =>
+        complete("")
+    }
+  }
+
   def vorlagenRoute(implicit subject: Subject) =
     path("vorlagetypen") {
       get {

src/main/scala/ch/openolitor/stammdaten/eventsourcing/StammdatenEventStoreSerializer.scala

@@ -140,6 +140,7 @@ trait StammdatenEventStoreSerializer extends StammdatenJsonProtocol with EntityS
   implicit val einladungCreatePersister = persister[EinladungCreate]("einladung-create")
   implicit val einladungGesendetEventPersister = persister[EinladungGesendetEvent]("einladung-gesendet")
   implicit val passwortResetGesendetEventPersister = persister[PasswortResetGesendetEvent]("passwort-reset-gesendet")
+  implicit val rolleGewechseltEventPersister = persister[RolleGewechseltEvent]("rolle-gewechselt-gesendet")
 
   val stammdatenPersisters = List(
     depotModifyPersister,
@@ -222,6 +223,7 @@ trait StammdatenEventStoreSerializer extends StammdatenJsonProtocol with EntityS
     auslieferungAlsAusgeliefertMarkierenEventPersister,
     bestellungAlsAbgerechnetMarkierenEventPersister,
     einladungGesendetEventPersister,
-    passwortResetGesendetEventPersister
+    passwortResetGesendetEventPersister,
+    rolleGewechseltEventPersister
   )
 }