def projectWasOpened()

in app/controllers/ProjectEntryController.scala [443:502]
56 lines of code
10 McCabe index (conditional complexity)

  def projectWasOpened(id: Int): EssentialAction = IsAuthenticatedAsync { uid=> request =>
    import models.EntryStatusMapper._

    def updateProject() = TableQuery[ProjectEntryRow]
      .filter(_.id === id)
      .filter(_.status === EntryStatus.New)
      .map(_.status)
      .update(EntryStatus.InProduction)
      .map(rows => {
        if (rows > 0) {
          sendToRabbitMq(UpdateOperation(), id, rabbitMqPropagator)
        }
      })

    def updateCommission(commissionId: Option[Int]) = TableQuery[PlutoCommissionRow]
      .filter(_.id === commissionId)
      .filter(_.status === EntryStatus.New)
      .map(_.status)
      .update(EntryStatus.InProduction).flatMap(rows => {
      if (rows > 0) {
        TableQuery[PlutoCommissionRow].filter(_.id === commissionId).result.map({
          case Seq() =>
            logger.error(s"Failed to update commission, commission not updated: $commissionId")
            throw new IllegalStateException(s"Failed to update commission, commission not updated: $commissionId")
          case Seq(commission) =>
            val commissionsSerializer = new PlutoCommissionSerializer {}
            implicit val commissionsWrites: Writes[PlutoCommission] = commissionsSerializer.plutoCommissionWrites
            rabbitMqPropagator ! ChangeEvent(Seq(commissionsWrites.writes(commission)), getItemType(commission), UpdateOperation())
          case _ =>
            logger.error(s"Failed to update commission, multiple commissions updated: $commissionId")
            throw new IllegalStateException(s"Failed to update commission, multiple commissions updated: $commissionId")
        })
      } else {
        DBIOAction.successful(())
      }
    })

    auditor ! Auditor.LogEvent(uid, AuditAction.OpenProject, id, ZonedDateTime.now(), request.headers.get("User-Agent"))

    dbConfig.db.run(
        TableQuery[ProjectEntryRow]
          .filter(_.id === id)
          .result
          .flatMap(result => {
            val acts = result match {
              case Seq() => DBIOAction.successful(NotFound)
              case Seq(project: ProjectEntry) =>
                DBIO.seq(updateProject(), updateCommission(project.commissionId)).map(_ => Ok)
              case _ =>
                logger.error(s"Database inconsistency, multiple projects found for id=$id")
                DBIOAction.successful(InternalServerError)
            }
            acts
          })
    ).recover({
      case err: Throwable =>
        logger.error("Failed to mark project as opened", err)
        InternalServerError(Json.obj("status" -> "error", "detail" -> "Failed to mark project as opened"))
    })
  }