Add Pricing Plans to Organization Page

CHANGELOG.unreleased.md

@@ -17,8 +17,16 @@ For upgrade instructions, please check the [migration guide](MIGRATIONS.released
 - The new datasets tab in the dashboard allows multi-selection of datasets so that multiple datasets can be moved to a folder at once. As in typical file explorers, CTRL + left click adds individual datasets to the current selection. Shift + left click selects a range of datasets. [#6683](https://github.com/scalableminds/webknossos/pull/6683)
 
 ### Changed
+- The log viewer in the Voxelytics workflow reporting now uses a virtualized list. [#6579](https://github.com/scalableminds/webknossos/pull/6579)
+- Node positions are always handled as integers. They have always been persisted as integers by the server, anyway, but the session in which a node was created handled the position as floating point in earlier versions. [#6589](https://github.com/scalableminds/webknossos/pull/6589)
+- Jobs can no longer be started on datastores without workers. [#6595](https://github.com/scalableminds/webknossos/pull/6595)
+- When downloading volume annotations with volume data skipped, the nml volume tag is now included anyway (but has no location attribute in this case). [#6566](https://github.com/scalableminds/webknossos/pull/6566)
+- Re-phrased some backend (error) messages to improve clarity and provide helping hints. [#6616](https://github.com/scalableminds/webknossos/pull/6616)
+- The layer visibility is now encoded in the sharing link. The user opening the link will see the same layers that were visible when copying the link. [#6634](https://github.com/scalableminds/webknossos/pull/6634)
+- Voxelytics workflows can now be viewed by anyone with the link who is in the right organization. [#6622](https://github.com/scalableminds/webknossos/pull/6622)
 - webKnossos is now able to recover from a lost webGL context. [#6663](https://github.com/scalableminds/webknossos/pull/6663)
 - Bulk task creation now needs the taskTypeId, the task type summary will no longer be accepted. [#6640](https://github.com/scalableminds/webknossos/pull/6640)
+- Redesigned organization page to include more infos on organization users, storage, webKnossos plan and provided opportunities to upgrade. [#6602](https://github.com/scalableminds/webknossos/pull/6602)
 
 ### Fixed
 - Fixed import of N5 datasets. [#6668](https://github.com/scalableminds/webknossos/pull/6668)

app/controllers/AuthenticationController.scala

@@ -99,6 +99,8 @@ class AuthenticationController @Inject()(
                 organization <- organizationService.findOneByInviteByNameOrDefault(
                   inviteBox.toOption,
                   organizationName)(GlobalAccessContext) ?~> Messages("organization.notFound", signUpData.organization)
+                _ <- organizationService
+                  .assertUsersCanBeAdded(organization)(GlobalAccessContext, ec) ?~> "organization.users.userLimitReached"
                 autoActivate = inviteBox.toOption.map(_.autoActivate).getOrElse(organization.enableAutoVerify)
                 _ <- createUser(organization,
                                 email,
@@ -331,6 +333,10 @@ class AuthenticationController @Inject()(
       invite <- inviteDAO.findOneByTokenValue(inviteToken) ?~> "invite.invalidToken"
       organization <- organizationDAO.findOne(invite._organization)(GlobalAccessContext) ?~> "invite.invalidToken"
       _ <- userService.assertNotInOrgaYet(request.identity._multiUser, organization._id)
+      requestingMultiUser <- multiUserDAO.findOne(request.identity._multiUser)
+      _ <- Fox.runIf(!requestingMultiUser.isSuperUser)(
+        organizationService
+          .assertUsersCanBeAdded(organization)(GlobalAccessContext, ec)) ?~> "organization.users.userLimitReached"
       _ <- userService.joinOrganization(request.identity, organization._id, autoActivate = invite.autoActivate)
       _ = analyticsService.track(JoinOrganizationEvent(request.identity, organization))
       userEmail <- userService.emailFor(request.identity)

app/controllers/InitialDataController.scala

@@ -68,13 +68,18 @@ Samplecountry
 """
   private val organizationTeamId = ObjectId.generate
   private val defaultOrganization =
-    Organization(ObjectId.generate,
-                 "sample_organization",
-                 additionalInformation,
-                 "/assets/images/oxalis.svg",
-                 "Sample Organization",
-                 PricingPlan.Custom,
-                 ObjectId.generate)
+    Organization(
+      ObjectId.generate,
+      "sample_organization",
+      additionalInformation,
+      "/assets/images/oxalis.svg",
+      "Sample Organization",
+      PricingPlan.Custom,
+      None,
+      None,
+      None,
+      ObjectId.generate
+    )
   private val organizationTeam =
     Team(organizationTeamId, defaultOrganization._id, "Default", isOrganizationTeam = true)
   private val userId = ObjectId.generate

app/controllers/OrganizationController.scala

@@ -1,17 +1,21 @@
 package controllers
 
+import akka.actor.ActorSystem
 import com.mohiva.play.silhouette.api.Silhouette
 import com.scalableminds.util.accesscontext.{DBAccessContext, GlobalAccessContext}
 import com.scalableminds.util.tools.{Fox, FoxImplicits}
 import javax.inject.Inject
 import models.organization.{OrganizationDAO, OrganizationService}
-import models.user.{InviteDAO, MultiUserDAO, UserDAO}
+import models.user.{InviteDAO, MultiUserDAO, UserDAO, UserService}
+import models.team.{PricingPlan}
 import oxalis.security.{WkEnv, WkSilhouetteEnvironment}
 import play.api.i18n.Messages
 import play.api.libs.functional.syntax._
 import play.api.libs.json.{JsNull, JsValue, Json, __}
 import play.api.mvc.{Action, AnyContent}
 import utils.WkConf
+import scala.concurrent.duration._
+import oxalis.mail.{DefaultMails, Send}
 
 import scala.concurrent.ExecutionContext
 
@@ -22,11 +26,15 @@ class OrganizationController @Inject()(organizationDAO: OrganizationDAO,
                                        userDAO: UserDAO,
                                        multiUserDAO: MultiUserDAO,
                                        wkSilhouetteEnvironment: WkSilhouetteEnvironment,
+                                       userService: UserService,
+                                       defaultMails: DefaultMails,
+                                       actorSystem: ActorSystem,
                                        sil: Silhouette[WkEnv])(implicit ec: ExecutionContext)
     extends Controller
     with FoxImplicits {
 
   private val combinedAuthenticatorService = wkSilhouetteEnvironment.combinedAuthenticatorService
+  private lazy val Mailer = actorSystem.actorSelection("/user/mailActor")
 
   def organizationsIsEmpty: Action[AnyContent] = Action.async { implicit request =>
     for {
@@ -99,7 +107,7 @@ class OrganizationController @Inject()(organizationDAO: OrganizationDAO,
       organization <- organizationDAO.findOneByName(organizationName) ?~> Messages("organization.notFound",
                                                                                    organizationName) ~> NOT_FOUND
       _ <- bool2Fox(request.identity.isAdminOf(organization._id)) ?~> "notAllowed" ~> FORBIDDEN
-      _ = logger.info(s"Deleting organizaion ${organization._id}")
+      _ = logger.info(s"Deleting organization ${organization._id}")
       _ <- organizationDAO.deleteOne(organization._id)
       _ <- userDAO.deleteAllWithOrganization(organization._id)
       _ <- multiUserDAO.removeLastLoggedInIdentitiesWithOrga(organization._id)
@@ -111,4 +119,91 @@ class OrganizationController @Inject()(organizationDAO: OrganizationDAO,
     ((__ \ 'displayName).read[String] and
       (__ \ 'newUserMailingList).read[String]).tupled
 
+  def sendExtendPricingPlanEmail(): Action[AnyContent] = sil.SecuredAction.async { implicit request =>
+    for {
+      _ <- bool2Fox(request.identity.isAdmin) ?~> Messages("organization.pricingUpgrades.notAuthorized")
+      organization <- organizationDAO
+        .findOne(request.identity._organization) ?~> Messages("organization.notFound") ~> NOT_FOUND
+      userEmail <- userService.emailFor(request.identity)
+      _ = Mailer ! Send(defaultMails.extendPricingPlanMail(request.identity, userEmail))
+      _ = Mailer ! Send(
+        defaultMails.upgradePricingPlanRequestMail(request.identity,
+                                                   userEmail,
+                                                   organization.displayName,
+                                                   "Extend webKnossos plan by a year"))
+    } yield Ok
+  }
+
+  def sendUpgradePricingPlanEmail(requestedPlan: String): Action[AnyContent] = sil.SecuredAction.async {
+    implicit request =>
+      for {
+        _ <- bool2Fox(request.identity.isAdmin) ?~> Messages("organization.pricingUpgrades.notAuthorized")
+        organization <- organizationDAO
+          .findOne(request.identity._organization) ?~> Messages("organization.notFound") ~> NOT_FOUND
+        userEmail <- userService.emailFor(request.identity)
+        requestedPlan <- PricingPlan.fromString(requestedPlan)
+        mail = if (requestedPlan == PricingPlan.Team) {
+          defaultMails.upgradePricingPlanToTeamMail _
+        } else {
+          defaultMails.upgradePricingPlanToTeamMail _
+        }
+        _ = Mailer ! Send(mail(request.identity, userEmail))
+        _ = Mailer ! Send(
+          defaultMails.upgradePricingPlanRequestMail(request.identity,
+                                                     userEmail,
+                                                     organization.displayName,
+                                                     s"Upgrade webKnossos Plan to $requestedPlan"))
+      } yield Ok
+  }
+
+  def sendUpgradePricingPlanUsersEmail(requestedUsers: Int): Action[AnyContent] =
+    sil.SecuredAction.async { implicit request =>
+      for {
+        _ <- bool2Fox(request.identity.isAdmin) ?~> Messages("organization.pricingUpgrades.notAuthorized")
+        organization <- organizationDAO.findOne(request.identity._organization) ?~> Messages("organization.notFound") ~> NOT_FOUND
+        userEmail <- userService.emailFor(request.identity)
+        _ = Mailer ! Send(defaultMails.upgradePricingPlanUsersMail(request.identity, userEmail, requestedUsers))
+        _ = Mailer ! Send(
+          defaultMails.upgradePricingPlanRequestMail(request.identity,
+                                                     userEmail,
+                                                     organization.displayName,
+                                                     s"Purchase $requestedUsers additional users"))
+      } yield Ok
+    }
+
+  def sendUpgradePricingPlanStorageEmail(requestedStorage: Int): Action[AnyContent] =
+    sil.SecuredAction.async { implicit request =>
+      for {
+        _ <- bool2Fox(request.identity.isAdmin) ?~> Messages("organization.pricingUpgrades.notAuthorized")
+        organization <- organizationDAO.findOne(request.identity._organization) ?~> Messages("organization.notFound") ~> NOT_FOUND
+        userEmail <- userService.emailFor(request.identity)
+        _ = Mailer ! Send(defaultMails.upgradePricingPlanStorageMail(request.identity, userEmail, requestedStorage))
+        _ = Mailer ! Send(
+          defaultMails.upgradePricingPlanRequestMail(request.identity,
+                                                     userEmail,
+                                                     organization.displayName,
+                                                     s"Purchase $requestedStorage TB additional storage"))
+      } yield Ok
+    }
+
+  def pricingStatus: Action[AnyContent] =
+    sil.SecuredAction.async { implicit request =>
+      for {
+        organization <- organizationDAO.findOne(request.identity._organization)
+        activeUserCount <- userDAO.countAllForOrganization(request.identity._organization)
+        // Note that this does not yet account for storage
+        isExceeded = organization.includedUsers.exists(userLimit => activeUserCount > userLimit) || organization.paidUntil
+          .exists(_.isPast)
+        isAlmostExceeded = (activeUserCount > 1 && organization.includedUsers.exists(userLimit =>
+          activeUserCount > userLimit - 2)) || organization.paidUntil.exists(paidUntil =>
+          (paidUntil - (6 * 7 days)).isPast)
+      } yield
+        Ok(
+          Json.obj(
+            "pricingPlan" -> organization.pricingPlan,
+            "isExceeded" -> isExceeded,
+            "isAlmostExceeded" -> isAlmostExceeded
+          ))
+    }
+
 }

app/models/organization/Organization.scala

@@ -21,6 +21,9 @@ case class Organization(
     logoUrl: String,
     displayName: String,
     pricingPlan: PricingPlan,
+    paidUntil: Option[Instant],
+    includedUsers: Option[Int], // None means unlimited
+    includedStorage: Option[Long], // None means unlimited
     _rootFolder: ObjectId,
     newUserMailingList: String = "",
     overTimeMailingList: String = "",
@@ -48,6 +51,9 @@ class OrganizationDAO @Inject()(sqlClient: SQLClient)(implicit ec: ExecutionCont
         r.logourl,
         r.displayname,
         pricingPlan,
+        r.paiduntil.map(Instant.fromSql),
+        r.includedusers,
+        r.includedstorage,
         ObjectId(r._Rootfolder),
         r.newusermailinglist,
         r.overtimemailinglist,
@@ -83,10 +89,14 @@ class OrganizationDAO @Inject()(sqlClient: SQLClient)(implicit ec: ExecutionCont
 
   def insertOne(o: Organization): Fox[Unit] =
     for {
-      _ <- run(
-        sqlu"""insert into webknossos.organizations(_id, name, additionalInformation, logoUrl, displayName, _rootFolder, newUserMailingList, overTimeMailingList, enableAutoVerify, created, isDeleted)
-                  values(${o._id.id}, ${o.name}, ${o.additionalInformation}, ${o.logoUrl}, ${o.displayName}, ${o._rootFolder},
-                   ${o.newUserMailingList}, ${o.overTimeMailingList}, ${o.enableAutoVerify}, ${o.created}, ${o.isDeleted})
+      _ <- run(sqlu"""INSERT INTO webknossos.organizations
+                      (_id, name, additionalInformation, logoUrl, displayName, _rootFolder,
+                      newUserMailingList, overTimeMailingList, enableAutoVerify,
+                      pricingplan, paidUntil, includedusers, includedstorage, created, isDeleted)
+                      VALUES
+                      (${o._id.id}, ${o.name}, ${o.additionalInformation}, ${o.logoUrl}, ${o.displayName}, ${o._rootFolder},
+                      ${o.newUserMailingList}, ${o.overTimeMailingList}, ${o.enableAutoVerify},
+                      '#${o.pricingPlan}', ${o.paidUntil}, ${o.includedUsers}, ${o.includedStorage}, ${o.created}, ${o.isDeleted})
             """)
     } yield ()
 

app/models/organization/OrganizationService.scala

@@ -9,14 +9,15 @@ import javax.inject.Inject
 import models.binary.{DataStore, DataStoreDAO}
 import models.folder.{Folder, FolderDAO, FolderService}
 import models.team.{PricingPlan, Team, TeamDAO}
-import models.user.{Invite, MultiUserDAO, User}
+import models.user.{Invite, MultiUserDAO, User, UserDAO}
 import play.api.libs.json.{JsObject, Json}
 import utils.{ObjectId, WkConf}
 
 import scala.concurrent.{ExecutionContext, Future}
 
 class OrganizationService @Inject()(organizationDAO: OrganizationDAO,
                                     multiUserDAO: MultiUserDAO,
+                                    userDAO: UserDAO,
                                     teamDAO: TeamDAO,
                                     dataStoreDAO: DataStoreDAO,
                                     folderDAO: FolderDAO,
@@ -31,7 +32,10 @@ class OrganizationService @Inject()(organizationDAO: OrganizationDAO,
     val adminOnlyInfo = if (requestingUser.exists(_.isAdminOf(organization._id))) {
       Json.obj(
         "newUserMailingList" -> organization.newUserMailingList,
-        "pricingPlan" -> organization.pricingPlan
+        "pricingPlan" -> organization.pricingPlan,
+        "paidUntil" -> organization.paidUntil,
+        "includedUsers" -> organization.includedUsers,
+        "includedStorage" -> organization.includedStorage.map(bytes => bytes / 1000000)
       )
     } else Json.obj()
     Fox.successful(
@@ -80,15 +84,22 @@ class OrganizationService @Inject()(organizationDAO: OrganizationDAO,
         .replaceAll(" ", "_")
       existingOrganization <- organizationDAO.findOneByName(organizationName)(GlobalAccessContext).futureBox
       _ <- bool2Fox(existingOrganization.isEmpty) ?~> "organization.name.alreadyInUse"
-      initialPricingPlan = if (conf.Features.isDemoInstance) PricingPlan.Basic else PricingPlan.Custom
+      initialPricingParameters = if (conf.Features.isDemoInstance) (PricingPlan.Basic, Some(3), Some(50000000000L))
+      else (PricingPlan.Custom, None, None)
       organizationRootFolder = Folder(ObjectId.generate, folderService.defaultRootName)
-      organization = Organization(ObjectId.generate,
-                                  organizationName,
-                                  "",
-                                  "",
-                                  organizationDisplayName,
-                                  initialPricingPlan,
-                                  organizationRootFolder._id)
+
+      organization = Organization(
+        ObjectId.generate,
+        organizationName,
+        "",
+        "",
+        organizationDisplayName,
+        initialPricingParameters._1,
+        None,
+        initialPricingParameters._2,
+        initialPricingParameters._3,
+        organizationRootFolder._id
+      )
       organizationTeam = Team(ObjectId.generate, organization._id, "Default", isOrganizationTeam = true)
       _ <- folderDAO.insertAsRoot(organizationRootFolder)
       _ <- organizationDAO.insertOne(organization)
@@ -109,4 +120,13 @@ class OrganizationService @Inject()(organizationDAO: OrganizationDAO,
     } yield ()
   }
 
+  def assertUsersCanBeAdded(organization: Organization, usersToAddCount: Int = 1)(implicit ctx: DBAccessContext,
+                                                                                  ec: ExecutionContext): Fox[Unit] =
+    for {
+      _ <- organizationDAO.findOne(organization._id)
+      userCount <- userDAO.countAllForOrganization(organization._id)
+      _ <- Fox.runOptional(organization.includedUsers)(includedUsers =>
+        bool2Fox(userCount + usersToAddCount <= includedUsers))
+    } yield ()
+
 }

app/models/team/PricingPlan.scala

@@ -4,5 +4,5 @@ import com.scalableminds.util.enumeration.ExtendedEnumeration
 
 object PricingPlan extends ExtendedEnumeration {
   type PricingPlan = Value
-  val Basic, Premium, Pilot, Custom = Value
+  val Basic, Team, Power, Team_Trial, Power_Trial, Custom = Value
 }

app/models/user/User.scala

@@ -192,7 +192,7 @@ class UserDAO @Inject()(sqlClient: SQLClient)(implicit ec: ExecutionContext)
   def countAllForOrganization(organizationId: ObjectId): Fox[Int] =
     for {
       resultList <- run(
-        sql"select count(_id) from #$existingCollectionName where _organization = $organizationId and not isUnlisted"
+        sql"select count(_id) from #$existingCollectionName where _organization = $organizationId and not isDeactivated and not isUnlisted"
           .as[Int])
       result <- resultList.headOption
     } yield result