Dev/frontend update (#312)

Changes

Updated frontend dependencies to latest versions
Refactored themes to only offer 2 for simplicity: dark and light (and system, which chooses the system default)
Removed the stale theme-ui and styled-components, migrating to tailwind, headlessui/react and daisyUI for theming and UI building blocks
Restructured frontend components into primitives, ui components and features for better DX
Detailed guides on how to use the component system and other DX specific things to make dev onboarding easier
Got rid of getInitialProps, moved to getServerSideProps in NextJS
Locale is now entirely cookie>user-agent based to allow us to not use locale prefixes. This will make sharing links between people with different locales a more consistent experience.
Mobile version is no longer a switch based on user agent strings but completely responsive
Replaced icons with lucide-react and simple-icons/react (for brands), removing all non-libre icons
Refactored all views, streamlining lists (replacing the user list experiment with a traditional list), adding more information
Refactored all forms, form element components for better UX, including filter forms, modal forms, ...
Refactored components that we built custom to use headlessui and daisyUI primitives whenever possible, like modals, selects, etc - using daisyUI for styling and headlessui for interactivity
Use class variance authority patterns whenever possible
Complete new set of empty states based on context
Projects are shown with a last activity date
i18n string keys are no longer the default values but actual keys based on context plus a default value
Nivo charts got more colors and they are now assigned based on hashing the display value instead of the default random assignment. The palette is adjusted for light and dark mode.
Add backend config for minimal demo dataset (users only)
Removed the no longer needed layout wrapping (getLayout())
Replaced lodash with es-toolkit
Notable new features and improvements

Tag group administration UI redesigned
Working hours definition UI redesigned
Time input UI redesigned
Ability to choose from existing, favourite or team bookings when creating a new booking (opposed to starting a booking from an existing one via context menu)
Stats data can now be exported and received some love as well
All exports now available as CSV, ODS or XLSX
New dashboard with a focus on personal time management, rather than business intelligence. Dashboard now also calculates monthly time based on planned working hours. Also will notify if booked time is higher than planned.
Plausible event tracking actually - finally - works
Ability to move start/end times in multiple places: if gaps were detected directly on the notification ui element, the context menu and the booking form itself
Specials

Online help system, context based, with information about each view and modals
Onboarding with checklist and helpful information to get a fresh user started
Extended locales: we now offer en, de, es, fr, it (well, machine translated)
.. and many, many more small optimisations and improvements to make working with Lasius even easier.

Author: genox

backend/.gitignore

@@ -23,3 +23,9 @@ activator-*.sbt
 .bloop/
 .metals/
 metals.sbt
+
+# MCP/Agents
+CLAUDE.md
+/.serena
+/.claude
+/.playwright*

backend/app/controllers/ProjectsController.scala

@@ -24,11 +24,17 @@ package controllers
 import com.typesafe.config.Config
 import core.SystemServices
 import models._
+import models.BaseFormat.localDateTimeFormat
 import org.joda.time.DateTime
 import play.api.libs.json.Json
 import play.api.mvc.{Action, ControllerComponents}
 import play.modules.reactivemongo.ReactiveMongoApi
-import repositories.{InvitationRepository, ProjectRepository, UserRepository}
+import repositories.{
+  BookingHistoryRepository,
+  InvitationRepository,
+  ProjectRepository,
+  UserRepository
+}
 
 import javax.inject.Inject
 import scala.concurrent.{ExecutionContext, Future}
@@ -41,15 +47,17 @@ class ProjectsController @Inject() (
     override val reactiveMongoApi: ReactiveMongoApi,
     projectRepository: ProjectRepository,
     userRepository: UserRepository,
-    invitationRepository: InvitationRepository)(implicit ec: ExecutionContext)
+    invitationRepository: InvitationRepository,
+    bookingHistoryRepository: BookingHistoryRepository)(implicit
+    ec: ExecutionContext)
     extends BaseLasiusController() {
   def getProjects(orgId: OrganisationId): Action[Unit] =
     HasUserRole(FreeUser, parse.empty, withinTransaction = false) {
       implicit dbSession => implicit subject => user => implicit request =>
         HasOrganisationRole(user, orgId, OrganisationAdministrator) { userOrg =>
           projectRepository
             .findByOrganisation(userOrg.organisationReference)
-            .map(p => Ok(Json.toJson(p)))
+            .map(projects => Ok(Json.toJson(projects)))
         }
     }
 
@@ -132,6 +140,32 @@ class ProjectsController @Inject() (
         }
     }
 
+  def getLastActivityDate(orgId: OrganisationId,
+                          projectId: ProjectId): Action[Unit] =
+    HasUserRole(FreeUser, parse.empty, withinTransaction = false) {
+      implicit dbSession => implicit subject => user => implicit request =>
+        isOrgAdminOrHasProjectRoleInOrganisation(user,
+                                                 orgId,
+                                                 projectId,
+                                                 ProjectMember) { _ =>
+          logger.debug(s"Getting last activity for project ${projectId.value}")
+          bookingHistoryRepository
+            .findLastActivityDateByProjects(Seq(projectId))
+            .map { dates =>
+              logger.debug(s"Found dates: $dates")
+              dates.get(projectId) match {
+                case Some(date) =>
+                  logger.debug(s"Returning date: $date")
+                  Ok(Json.toJson(date))
+                case None =>
+                  logger.debug(
+                    s"No activity found for project ${projectId.value}")
+                  NoContent
+              }
+            }
+        }
+    }
+
   def getUsers(orgId: OrganisationId, projectId: ProjectId): Action[Unit] =
     HasUserRole(FreeUser, parse.empty, withinTransaction = true) {
       implicit dbSession => implicit subject => user => implicit request =>

backend/app/core/db/InitialUsersOnlyDataLoader.scala

@@ -0,0 +1,138 @@
+/*
+ *
+ * Lasius - Open source time tracker for teams
+ * Copyright (c) Tegonal Genossenschaft (https://tegonal.com)
+ *
+ * This file is part of Lasius.
+ *
+ * Lasius is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU Affero General Public License as published by the Free
+ * Software Foundation, either version 3 of the License, or (at your option)
+ * any later version.
+ *
+ * Lasius is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+ * details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Lasius. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package core.db
+
+import core.{DBSession, DBSupport, SystemServices}
+import models.UserId.UserReference
+import models._
+import org.mindrot.jbcrypt.BCrypt
+import play.api.Logging
+import play.modules.reactivemongo.ReactiveMongoApi
+import repositories._
+
+import javax.inject.Inject
+import scala.annotation.unused
+import scala.concurrent.{ExecutionContext, Future}
+
+/*
+ * Initialize database with users only - no prepopulated projects or bookings
+ */
+@unused
+class InitialUsersOnlyDataLoader @Inject() (
+    override val reactiveMongoApi: ReactiveMongoApi,
+    oauthUserRepository: OAuthUserRepository,
+    userRepository: UserRepository,
+    organisationRepository: OrganisationRepository,
+    systemServices: SystemServices)(implicit executionContext: ExecutionContext)
+    extends Logging
+    with DBSupport
+    with InitialDataLoader {
+
+  // gets overridden b the withinTransaction call
+  override val supportTransaction = true
+
+  private val user1Key: String   = sys.env.getOrElse("DEMO_USER1_KEY", "demo1")
+  private val user1Email: String =
+    sys.env.getOrElse("DEMO_USER1_EMAIL", "demo1@lasius.ch")
+  private val user1PasswordHash: String = BCrypt.hashpw(
+    sys.env.getOrElse("DEMO_USER1_PASSWORD", "demo"),
+    BCrypt.gensalt())
+
+  private val user2Key: String   = sys.env.getOrElse("DEMO_USER2_KEY", "demo2")
+  private val user2Email: String =
+    sys.env.getOrElse("DEMO_USER2_EMAIL", "demo2@lasius.ch")
+  private val user2PasswordHash: String = BCrypt.hashpw(
+    sys.env.getOrElse("DEMO_USER2_PASSWORD", "demo"),
+    BCrypt.gensalt())
+
+  override def initializeData(supportTransaction: Boolean)(implicit
+      userReference: UserReference): Future[Unit] = {
+    logger.debug(
+      "Initialize users only (with private organizations, no projects/bookings)...")
+    withDBSession(withTransaction = supportTransaction) { implicit dbSession =>
+      for {
+        _ <- initializeUser1()(userReference, dbSession)
+        _ <- initializeUser2()(userReference, dbSession)
+      } yield ()
+    }
+  }
+
+  private def initializeUser1()(implicit
+      userReference: UserReference,
+      dbSession: DBSession): Future[Unit] = {
+    for {
+      // Create OAuth user
+      oauthUser <- oauthUserRepository.upsert(
+        OAuthUser(
+          id = OAuthUserId(),
+          email = user1Email,
+          password = user1PasswordHash,
+          firstName = Some("Demo"),
+          lastName = Some("User 1"),
+          active = true
+        ))
+      // Create private organisation for user
+      org <- organisationRepository.create(user1Key, `private` = true)(
+        systemServices.systemSubject,
+        dbSession)
+      // Create user with UserInfo similar to OAuth flow
+      userInfo = UserInfo(key = user1Key,
+                          firstName = Some("Demo"),
+                          lastName = Some("User 1"),
+                          email = user1Email)
+      user <- userRepository.createInitialUserBasedOnProfile(
+        userInfo,
+        org,
+        OrganisationAdministrator)
+    } yield ()
+  }
+
+  private def initializeUser2()(implicit
+      userReference: UserReference,
+      dbSession: DBSession): Future[Unit] = {
+    for {
+      // Create OAuth user
+      oauthUser <- oauthUserRepository.upsert(
+        OAuthUser(
+          id = OAuthUserId(),
+          email = user2Email,
+          password = user2PasswordHash,
+          firstName = Some("Demo"),
+          lastName = Some("User 2"),
+          active = true
+        ))
+      // Create private organisation for user
+      org <- organisationRepository.create(user2Key, `private` = true)(
+        systemServices.systemSubject,
+        dbSession)
+      // Create user with UserInfo similar to OAuth flow
+      userInfo = UserInfo(key = user2Key,
+                          firstName = Some("Demo"),
+                          lastName = Some("User 2"),
+                          email = user2Email)
+      user <- userRepository.createInitialUserBasedOnProfile(
+        userInfo,
+        org,
+        OrganisationAdministrator)
+    } yield ()
+  }
+}

backend/app/domain/views/CurrentUserTimeBookingsView.scala

@@ -62,10 +62,14 @@ class CurrentUserTimeBookingsView(val clientReceiver: ClientReceiver,
   @unused
   def autoUpdateInterval: FiniteDuration = 100.millis
 
-  override val receive: Receive = ({ case InitializeCurrentTimeBooking(state) =>
-    this.state = state
-    context.become(live)
-    sender() ! JournalReadingViewIsLive
+  override val receive: Receive = ({
+    case InitializeCurrentTimeBooking(state) =>
+      this.state = state
+      context.become(live)
+      sender() ! JournalReadingViewIsLive
+    case GetCurrentTimeBooking(_) =>
+      // Handle query even before full initialization (e.g., when no bookings exist)
+      sender() ! currentUserTimeBookings
   }: Receive).orElse(defaultReceive)
 
   override def restoreViewFromState(snapshot: UserTimeBooking): Unit = {
@@ -86,6 +90,15 @@ class CurrentUserTimeBookingsView(val clientReceiver: ClientReceiver,
   }
 
   override protected val live: Receive = {
+    case GetCurrentTimeBooking(_) =>
+      // check if still on same day
+      val day = LocalDate.now
+      if (!day.equals(state.currentDay)) {
+        val durations = getMapForDay(day)
+        state = updateBooking(state.booking, day, durations)
+      }
+
+      sender() ! currentUserTimeBookings
     case e: UserTimeBookingStartedV2 =>
       log.debug(
         s"CurrentUserTimeBookingsView -> UserTimeBookingStarted($e.booking)")
@@ -202,15 +215,6 @@ class CurrentUserTimeBookingsView(val clientReceiver: ClientReceiver,
         notifyClient()
       }
       sender() ! Ack
-    case GetCurrentTimeBooking(_) =>
-      // check if still on same day
-      val day = LocalDate.now
-      if (!day.equals(state.currentDay)) {
-        val durations = getMapForDay(day)
-        state = updateBooking(state.booking, day, durations)
-      }
-
-      sender() ! currentUserTimeBookings
   }
 
   private def notifyClient(): Unit = {

backend/app/domain/views/JournalReadingView.scala

@@ -21,19 +21,17 @@
 
 package domain.views
 
+import domain.AggregateRoot.{InitializeViewLive, RestoreViewFromState}
+import domain.UserTimeBookingAggregate.UserTimeBooking
+import models.PersistedEvent
 import org.apache.pekko.NotUsed
 import org.apache.pekko.actor.SupervisorStrategy.Restart
 import org.apache.pekko.actor.{Actor, ActorLogging, OneForOneStrategy}
-import pekko.contrib.persistence.mongodb.{
-  MongoReadJournal,
-  ScalaDslMongoReadJournal
-}
+import org.apache.pekko.persistence.query.scaladsl.{CurrentEventsByPersistenceIdQuery, ReadJournal}
 import org.apache.pekko.persistence.query.{EventEnvelope, PersistenceQuery}
 import org.apache.pekko.stream.Materializer
 import org.apache.pekko.stream.scaladsl.Source
-import domain.AggregateRoot.{InitializeViewLive, RestoreViewFromState}
-import domain.UserTimeBookingAggregate.UserTimeBooking
-import models.PersistedEvent
+import pekko.contrib.persistence.mongodb.MongoReadJournal
 
 import scala.concurrent.duration.DurationInt
 import scala.language.postfixOps
@@ -45,9 +43,21 @@ case object JournalReadingViewIsLive
 trait JournalReadingView extends Actor with ActorLogging {
   val persistenceId: String
 
-  private lazy val readJournal: ScalaDslMongoReadJournal =
+  private lazy val readJournal
+      : ReadJournal with CurrentEventsByPersistenceIdQuery = {
+    // Auto-detect journal based on configured persistence plugin
+    val journalPlugin = context.system.settings.config
+      .getString("pekko.persistence.journal.plugin")
+
+    val journalPluginId = journalPlugin match {
+      case "inmemory-journal" => "inmemory-read-journal"
+      case _                  => MongoReadJournal.Identifier
+    }
+
     PersistenceQuery(context.system)
-      .readJournalFor[ScalaDslMongoReadJournal](MongoReadJournal.Identifier)
+      .readJournalFor[ReadJournal with CurrentEventsByPersistenceIdQuery](
+        journalPluginId)
+  }
 
   override val supervisorStrategy: OneForOneStrategy =
     OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1.minute) {

backend/app/domain/views/LatestUserTimeBookingsView.scala

@@ -69,6 +69,13 @@ class LatestUserTimeBookingsView(clientReceiver: ClientReceiver,
   @unused
   def autoUpdateInterval: FiniteDuration = 100.millis
 
+  override val receive: Receive = ({ case GetLatestTimeBooking(_, maxHistory) =>
+    // Handle query even before full initialization (e.g., when no bookings exist)
+    state = state.copy(maxHistory = maxHistory)
+    notifyClient()
+    sender() ! Ack
+  }: Receive).orElse(defaultReceive)
+
   private def getStartTime(booking: BookingStub): DateTime = {
     state.startTimeMap.getOrElse(booking, oldDateTime)
   }

backend/app/repositories/BookingHistoryRepository.scala

@@ -62,6 +62,9 @@ trait BookingHistoryRepository
                             skip: Option[Int])(implicit
       dbSession: DBSession): Future[Iterable[BookingV2]]
 
+  def findLastActivityDateByProjects(projectIds: Seq[ProjectId])(implicit
+      dbSession: DBSession): Future[Map[ProjectId, LocalDateTime]]
+
   def updateBooking(newBooking: BookingV2)(implicit
       format: Format[BookingV2],
       dbSession: DBSession): Future[Boolean]
@@ -102,6 +105,53 @@ class BookingHistoryMongoRepository @Inject() ()(
       dbSession: DBSession): Future[Iterable[BookingV2]] =
     findByRange(None, None, Some(projectId), from, to, limit, skip)
 
+  override def findLastActivityDateByProjects(projectIds: Seq[ProjectId])(
+      implicit dbSession: DBSession): Future[Map[ProjectId, LocalDateTime]] = {
+    if (projectIds.isEmpty) {
+      Future.successful(Map.empty)
+    } else {
+      val collection = coll
+      import collection.AggregationFramework._
+      import reactivemongo.api.bson._
+
+      val pipeline = List(
+        Match(
+          BSONDocument(
+            "projectReference.id" -> BSONDocument(
+              "$in" -> projectIds.map(_.value.toString)),
+            "end" -> BSONDocument("$ne" -> BSONNull)
+          )),
+        Sort(Descending("start.dateTime")),
+        Group(BSONString("$projectReference.id"))(
+          "lastActivityDate" -> First(BSONString("$start.dateTime")),
+          "projectId"        -> First(BSONString("$projectReference.id"))
+        )
+      )
+
+      logger.debug(
+        s"findLastActivityDateByProjects for ${projectIds.size} projects")
+
+      collection
+        .aggregateWith[BSONDocument]()(_ => pipeline)
+        .collect[List]()
+        .map { results =>
+          results.flatMap { doc =>
+            for {
+              projectIdValue  <- doc.getAsOpt[String]("projectId")
+              lastActivityStr <- doc.getAsOpt[String]("lastActivityDate")
+              projectId = ProjectId(java.util.UUID.fromString(projectIdValue))
+              lastActivity = LocalDateTime.parse(lastActivityStr)
+            } yield projectId -> lastActivity
+          }.toMap
+        }
+        .recover { case ex =>
+          logger.error(s"Error finding last activity dates: ${ex.getMessage}",
+                       ex)
+          Map.empty[ProjectId, LocalDateTime]
+        }
+    }
+  }
+
   private def findByRange(userReference: Option[UserReference],
                           orgId: Option[OrganisationId],
                           projectId: Option[ProjectId],