Add navigation history with urls

1 files changed, 13 insertions, 70 deletions

diff --git a/src/main/scala/reading/models/Filter.scala b/src/main/scala/reading/models/Filter.scala
index 5aabcc6..c3d81c6 100644
--- a/src/main/scala/reading/models/Filter.scala
+++ b/src/main/scala/reading/models/Filter.scala
@@ -3,89 +3,32 @@ package reading.models
 trait Filter {
   def filter(book: Book): Boolean
   def kind: FilterKind
+  def nonFormattedName: String
   def name: String
 }
 
-sealed trait FilterKind
-case object PeriodKind extends FilterKind
-case object ThemeKind extends FilterKind
-case object GenreKind extends FilterKind
-case object LevelKind extends FilterKind
-case object ProgramKind extends FilterKind
-case object GradeKind extends FilterKind
-
 object Filter {
   def apply[T](in: T)(implicit filterFactory: FilterFactory[T]): Filter =
     filterFactory.create(in)
 
+  def apply(kind: FilterKind, nonFormattedName: String): Option[Filter] =
+    kind match {
+      case FilterKind.Period => Period.withNameOption(nonFormattedName).map(apply[Period])
+      case FilterKind.Theme => Theme.withNameOption(nonFormattedName).map(apply[Theme])
+      case FilterKind.Genre => Genre.withNameOption(nonFormattedName).map(apply[Genre])
+      case FilterKind.Level => Level.withNameOption(nonFormattedName).map(apply[Level])
+      case FilterKind.Program => Program.withNameOption(nonFormattedName).map(apply[Program])
+      case FilterKind.Grade => Grade.withNameOption(nonFormattedName).map(apply[Grade])
+    }
+
   def contains(filters: Seq[Filter], filter: Filter): Boolean =
-    filters.find(f => f.kind == filter.kind && f.name == filter.name).nonEmpty
+    filters.find(equals(_, filter)).nonEmpty
 
   def equals(f1: Filter, f2: Filter): Boolean =
     f1.kind == f2.kind && f1.name == f2.name
 
   def remove(fs: Seq[Filter], rf: Filter): Seq[Filter] =
     fs.filterNot { f =>
-      equals(f, rf) || rf.kind == GradeKind && f.kind == ProgramKind
+      equals(f, rf) || rf.kind == FilterKind.Grade && f.kind == FilterKind.Program
     }
 }
-
-trait FilterFactory[T] {
-  def create(in: T): Filter
-}
-
-object FilterFactory {
-  implicit object PeriodFilter extends FilterFactory[Period] {
-    def create(period: Period): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.period == Some(period)
-        val kind: FilterKind = PeriodKind
-        val name: String = period.toString()
-      }
-  }
-
-  implicit object ThemeFilter extends FilterFactory[Theme] {
-    def create(theme: Theme): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.themes.contains(theme)
-        val kind: FilterKind = ThemeKind
-        val name: String = theme.toString()
-      }
-  }
-
-  implicit object GenreFilter extends FilterFactory[Genre] {
-    def create(genre: Genre): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.genres.contains(genre)
-        val kind: FilterKind = GenreKind
-        val name: String = genre.toString()
-      }
-  }
-
-  implicit object ProgramFilter extends FilterFactory[Program] {
-    def create(program: Program): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.programs.contains(program)
-        val kind: FilterKind = ProgramKind
-        val name: String = program.toString()
-      }
-  }
-
-  implicit object GradeFilter extends FilterFactory[Grade] {
-    def create(grade: Grade): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.programs.map(Program.grade).contains(grade)
-        val kind: FilterKind = GradeKind
-        val name: String = grade.toString()
-      }
-  }
-
-  implicit object LevelFilter extends FilterFactory[Level] {
-    def create(level: Level): Filter =
-      new Filter {
-        def filter(book: Book): Boolean = book.level == level
-        val kind: FilterKind = LevelKind
-        val name: String = level.toString()
-      }
-  }
-}