searchable events.

flurdy · May 20, 2012 · 407c395 · 407c395
1 parent 0e28dfc
commit 407c395
Show file tree

Hide file tree

Showing 8 changed files with 274 additions and 66 deletions.
diff --git a/app/controllers/EventController.scala b/app/controllers/EventController.scala
@@ -40,25 +40,29 @@ object EventController extends Controller with EventWrappers with Secured {
       },
       searchText => {
         if (searchText.trim.length==0){
-          Ok(views.html.events.list(searchText, Event.findAll))
+          Ok(views.html.events.list(searchText, currentParticipant.map{ participant => Event.findAllEventsAsParticipantOrOrganiser(participant.participantId)
+          }.getOrElse(Seq.empty), Event.findAll, Participant.findAll))
         } else {
-          val events = Event.findAllEventsContaining(searchText)
-          val organisersEvents = Event.findAllEventsByOrganisersContaining(searchText)
-          Ok(views.html.events.list(searchText,events ::: organisersEvents))
+          val participantEvents : Seq[Event] = currentParticipant.map{ participant =>
+            Event.searchAllEventsAsParticipantOrOrganiser(searchText.trim,participant.participantId)
+          }.getOrElse(Seq.empty)
+          val events : Seq[Event] = Event.searchAllSearchableEventsContaining(searchText.trim)
+          val participants : Seq[Participant] = Participant.findParticipantsContaining(searchText.trim)
+          Ok(views.html.events.list(searchText,participantEvents,events,participants))
         }
       }
     )
   }
 
 
-  def notEventParticipant(event: Event)(implicit session:Session, flash: Flash) = {
+  private def notEventParticipant(event: Event)(implicit session:Session, flash: Flash) = {
     Logger.info("Not an event participant")
     Unauthorized(views.html.events.unauthorised(event)).withSession(session+("eventId"->event.eventId.toString))
      //.flashing("errorMessage"->"Event private, and you do not have access to it")
   }
 
 
-  def eventRequireAuthentication(eventId: Long)(implicit request: RequestHeader, currentParticipant: Option[Participant], flash: Flash)  = {
+  private def eventRequireAuthentication(eventId: Long)(implicit request: RequestHeader, currentParticipant: Option[Participant], flash: Flash)  = {
     Logger.info("Event requires authentication")
     onUnauthenticated(request).withSession("eventId"-> eventId.toString).flashing("errorMessage"->"Event private, please log in")
   }
@@ -148,7 +152,7 @@ object EventController extends Controller with EventWrappers with Secured {
   }
 
 
-  def eventParticipantNotFound(eventId: Long) = {
+  private def eventParticipantNotFound(eventId: Long) = {
     Logger.warn("Participant not found for remove participant")
     Redirect(routes.EventController.showEditEvent(eventId)).flashing("errorMessage" -> "Participant not found")
   }
@@ -185,7 +189,7 @@ object EventController extends Controller with EventWrappers with Secured {
       addAnyParticipant(event,Participant.findById(participantId))
   }
 
-  def addAnyParticipant(event: Event, participantFound: Option[Participant]) = {
+  private def addAnyParticipant(event: Event, participantFound: Option[Participant]) = {
     participantFound.map { participant =>
       event.addParticipant(participant)
       event.removeJoinRequest(participant)

diff --git a/app/models/Event.scala b/app/models/Event.scala
@@ -13,7 +13,8 @@ case class Event (
   organiserId: Option[Long],
   eventDate: Option[String],
   description: Option[String],
-  public: Boolean = true
+  public: Boolean = true,
+  searchable: Boolean = true
 ){
 
   require(eventName.trim.length > 1)
@@ -97,14 +98,16 @@ case class Event (
 
 object Event {
 
+
   val simple = {
     get[Long]("eventid") ~
       get[String]("eventname") ~
       get[Option[Long]]("organiserid") ~
       get[Option[String]]("eventdate") ~
       get[Option[String]]("description") ~
-      get[Boolean]("publicevent") map {
-      case eventid~eventname~organiserid~eventdate~description~publicevent => Event( eventid, eventname, organiserid, eventdate, description, publicevent )
+      get[Boolean]("publicevent") ~
+      get[Boolean]("searchable") map {
+      case eventid~eventname~organiserid~eventdate~description~publicevent~searchable => Event( eventid, eventname, organiserid, eventdate, description, publicevent, searchable )
     }
   }
 
@@ -119,24 +122,65 @@ object Event {
       SQL(
         """
           INSERT INTO snapevent
-          (eventid, eventname, organiserid, eventdate, description, publicevent)
+          (eventid, eventname, organiserid, eventdate, description, publicevent, searchable)
           VALUES
           ({eventid}, {eventname}, {organiserid},
-              {eventdate}, {description},{publicevent})
+              {eventdate}, {description},{publicevent},{searchable})
         """
       ).on(
         'eventid -> eventId,
         'eventname -> event.eventName,
         'organiserid -> event.organiserId,
         'eventdate -> event.eventDate,
         'description -> event.description,
-        'publicevent -> event.public
+        'publicevent -> event.public,
+        'searchable -> event.searchable
       ).executeInsert()
       new Event(eventId,event)
     }
   }
 
 
+  def updateEvent(event: Event) = {
+    assert(event.eventName.trim.length > 1)
+    DB.withConnection { implicit connection =>
+      SQL(
+        """
+          UPDATE snapevent
+          SET eventname = {eventname},
+            organiserid = {organiserid},
+            eventdate = {eventdate},
+            description = {description},
+            publicevent = {publicevent},
+            searchable = {searchable}
+          WHERE eventid = {eventid}
+        """
+      ).on(
+        'eventid -> event.eventId,
+        'eventname -> event.eventName,
+        'organiserid -> event.organiserId,
+        'eventdate -> event.eventDate,
+        'description -> event.description,
+        'publicevent -> event.public,
+        'searchable -> event.searchable
+      ).executeUpdate()
+      event
+    }
+  }
+
+  def deleteEvent(eventId: Long){
+    DB.withConnection { implicit connection =>
+      SQL(
+        """
+          DELETE FROM snapevent
+          WHERE eventid = {eventid}
+        """
+      ).on(
+        'eventid -> eventId
+      ).execute()
+    }
+  }
+
   def findEvent(eventId : Long): Option[Event] = {
     DB.withConnection { implicit connection =>
       SQL(
@@ -163,58 +207,61 @@ object Event {
       SQL(
         """
           SELECT * FROM snapevent
+          WHERE searchable = TRUE
           ORDER BY eventdate DESC,eventname ASC
         """
       ).on(
       ).as(Event.simple *)
     }
   }
 
-  def updateEvent(event: Event) = {
-    assert(event.eventName.trim.length > 1)
+
+  def findAllEventsAsParticipantOrOrganiser(participantId: Long) : Seq[Event] = {
+    findAllEventsByOrganiser(participantId) union findAllEventsByParticipant(participantId)
+  }
+
+
+  private def findAllEventsByOrganiser(organiserId: Long) = {
     DB.withConnection { implicit connection =>
       SQL(
         """
-          UPDATE snapevent
-          SET eventname = {eventname},
-            organiserid = {organiserid},
-            eventdate = {eventdate},
-            description = {description},
-            publicevent = {publicevent}
-          WHERE eventid = {eventid}
+          SELECT sn.*
+          FROM snapevent sn
+          WHERE sn.organiserid = {organiserid}
+          ORDER BY sn.eventdate DESC, sn.eventname ASC
         """
       ).on(
-        'eventid -> event.eventId,
-        'eventname -> event.eventName,
-        'organiserid -> event.organiserId,
-        'eventdate -> event.eventDate,
-        'description -> event.description,
-        'publicevent -> event.public
-      ).executeUpdate()
-      event
+        'organiserid -> organiserId
+      ).as(Event.simple *)
     }
   }
 
-  def deleteEvent(eventId: Long){
+  private def findAllEventsByParticipant(participantid: Long) = {
     DB.withConnection { implicit connection =>
       SQL(
         """
-          DELETE FROM snapevent
-          WHERE eventid = {eventid}
+        SELECT sn.*
+        FROM eventparticipant ep
+        LEFT JOIN snapevent sn
+          ON ep.eventid = sn.eventid
+        WHERE ep.participantid = {participantid}
+        ORDER BY sn.eventdate DESC, sn.eventname ASC
         """
       ).on(
-        'eventid -> eventId
-      ).execute()
+        'participantid -> participantid
+      ).as(Event.simple *)
     }
   }
 
-  def findAllEventsContaining(searchText: String) = {
+
+  def searchAllSearchableEventsContaining(searchText: String) = {
     val sqlSearch = "%" + searchText +"%"
     DB.withConnection { implicit connection =>
       SQL(
         """
           SELECT * FROM snapevent
           WHERE eventname like {searchtext}
+          AND searchable = TRUE
           ORDER BY eventdate DESC,eventname ASC
         """
       ).on(
@@ -223,24 +270,51 @@ object Event {
     }
   }
 
-  def findAllEventsByOrganisersContaining(searchText: String) = {
-    val sqlSearch = "%" + searchText +"%"
+
+  private def searchAllEventsAsParticipant(sqlSearch: String, participantId: Long) : Seq[Event] = {
     DB.withConnection { implicit connection =>
       SQL(
         """
           SELECT sn.*
-          FROM participant pa
+          FROM eventparticipant ep
           LEFT JOIN snapevent sn
-            ON pa.participantid = sn.organiserid
-          WHERE pa.username like {searchtext}
-          ORDER BY pa.username ASC, sn.eventdate DESC, sn.eventname ASC
+            ON ep.eventid = sn.eventid
+          WHERE sn.eventname like {searchtext}
+          AND ep.participantid = {participantid}
+          ORDER BY sn.eventdate DESC, sn.eventname ASC
         """
       ).on(
-        'searchtext -> sqlSearch
+        'searchtext -> sqlSearch,
+        'participantid -> participantId
+      ).as(Event.simple *)
+    }
+  }
+
+  private def searchAllEventsAsOrganiser(sqlSearch: String, participantId: Long) : Seq[Event] = {
+    DB.withConnection { implicit connection =>
+      SQL(
+        """
+        SELECT sn.*
+        FROM snapevent sn
+        WHERE sn.eventname like {searchtext}
+        AND sn.organiserid = {participantid}
+        ORDER BY sn.eventdate DESC, sn.eventname ASC
+        """
+      ).on(
+        'searchtext -> sqlSearch,
+        'participantid -> participantId
       ).as(Event.simple *)
     }
   }
 
+
+  def searchAllEventsAsParticipantOrOrganiser(searchText: String, participantId: Long) : Seq[Event] = {
+    val   sqlSearch = "%" + searchText +"%"
+    searchAllEventsAsParticipant(sqlSearch,participantId) union searchAllEventsAsOrganiser(sqlSearch,participantId)
+  }
+
+
+
   def isParticipant(eventId: Long, participantId: Long) : Boolean = {
     DB.withConnection { implicit connection =>
       SQL(
@@ -340,5 +414,4 @@ object Event {
   }
 
 
-
 }
diff --git a/app/models/Participant.scala b/app/models/Participant.scala
@@ -78,6 +78,17 @@ object Participant {
     }
   }
 
+  def findAll = {
+    DB.withConnection { implicit connection =>
+      SQL(
+        """
+          SELECT * FROM participant
+          ORDER BY username
+        """
+      ).as(Participant.simple *)
+    }
+  }
+
   def authenticate(username: String, password: String) : Option[Participant]  = {
     DB.withConnection { implicit connection =>
       SQL(
@@ -164,4 +175,21 @@ object Participant {
     }
   }
 
+  def findParticipantsContaining(searchText: String) = {
+      val sqlSearch = "%" + searchText +"%"
+      DB.withConnection { implicit connection =>
+        SQL(
+          """
+            SELECT * FROM participant pa
+            WHERE pa.username like {searchtext}
+            OR pa.fullname like {searchtext}
+            ORDER BY pa.username ASC
+          """
+        ).on(
+          'searchtext -> sqlSearch
+        ).as(Participant.simple *)
+      }
+  }
+
+
 }