root/blogbird/src/main/scala/org/aiotrade/blog/frontend/Views.scala @ 132:add99b61e833

/*
 * To change this template, choose Tools case class Templates
 * and open the template in the editor.
 */

package org.aiotrade.blog.frontend

import org.aiotrade.blog.frontend.{Feeds => F}
import org.aiotrade.blog.model.{Entry => B}
import org.aiotrade.blog.model.Entry.Item
import org.aiotrade.blog.model.Entry.Model
import org.aiotrade.blog.{Constants => C}

object Views {
  trait View extends Viewable[View] {
    def url = url_(this) + page_suffix(page_number)

    def page_number = this match {
      case ByYMDPermatitle(_, _, _, _) => None
      case ByPermatitle(_) => None
      case All(page_n) => page_n
      case ByYear(_, page_n) => page_n
      case ByMonth(_, _, page_n) => page_n
      case ByDay(_, _, _, page_n) => page_n
      case ByTags(_, page_n) => page_n
      case ByTag(_, page_n) => page_n
    }

    def page_size = this match {
      case All(_) => C.default_page_size
      case ByYear(_, _) => C.default_page_size
      case ByMonth(_, _, _) => C.default_page_size
      case ByDay(_, _, _, _) => C.default_page_size
      case ByTags(_, _) => C.default_page_size
      case ByTag(_, _) => C.default_page_size
      case ByYMDPermatitle(_, _, _, _) => C.default_page_size
      case ByPermatitle(_) => C.default_page_size
    }

    def kind = this match {
      case ByYMDPermatitle(_, _, _, _) => Single
      case ByPermatitle(_) => Single
      case _ => Multiple
    }

    def lens(md: Model) = this match {
      case All(_) => md.all_posts filter (_.kind == B.Post)
      case ByYear(y, _) => B.year_filter(y) (md.all_posts)
      case ByMonth(y, m, _) => B.month_filter(y, m) (md.all_posts)
      case ByDay(y, m, d, _) => B.day_filter(y, m, d) (md.all_posts)
      case ByTag(t, _) => B.tag_filter(t) (md.all_posts)
      case ByTags(t, _) => B.tags_filter(t) (md.all_posts)
      case ByYMDPermatitle(_, _, _, t) => md.maybe_post_by_permatitle(t) toList
      case ByPermatitle(t) => md.maybe_post_by_permatitle(t) toList
    }

    def no_posts_message = this match {
      case All(_) => "No posts were found at all...  Something's fishy."
      case ByYear(y, _) => "No posts from year " + y + " were found."
      case ByMonth(y, m, _) => "No posts from " + y + pad_(m) + " were found."
      case ByDay(y, m, d, _) => "No posts were made on " + y + pad_(m) + pad_(d) + "."
      case ByTags(ts, _) => "No posts are in the intersection of the tags {" + ts.mkString(",") + "}."
      case ByTag(t, _) => "No posts are tagged " + t + "."
      case ByYMDPermatitle(y, m, d, t) => "No posts with permatitle " + t + " were made on" + y + pad_(m) + pad_(d) +
        "; try the same URL without the " +
        "/" + y + "/" + pad_(m) + "/" + pad_ (d) + " fragment."
      case ByPermatitle(t) => "No post with permatitle " + t + " was found."
    }

    def title = this match {
      case All(_) => "All Posts"
      case ByYear(y, _) => y.toString
      case ByMonth(y, m, _) => y + "/" + m
      case ByDay(y, m, d, _) => y + "/" + m + "/" + d
      case ByTag(t, _) => "Posts tagged \"" + t + "\""
      case ByTags(ts, _) => "Posts tagged " + ts
      case ByYMDPermatitle(_, _, _, t) => t
      case ByPermatitle(t) => t
    }

    def first_page = this match {
      case All(_) => All(Some(1))
      case ByYear(y, _) => ByYear(y, Some(1))
      case ByMonth(y, m, _) => ByMonth(y, m, Some(1))
      case ByDay(y, m, d, _) => ByDay(y, m, d, Some(1))
      case ByTag(t, _) => ByTag(t, Some(1))
      case ByTags(t, _) => ByTags(t, Some(1))
      case _ => this
    }

    def next_page = this match {
      case All(None) => All(Some(2))
      case All(Some(a)) => All(Some(a + 1))
      case ByYear(y, None) => ByYear(y, Some(2))
      case ByYear(y, Some(a)) => ByYear(y, Some(a + 1))
      case ByMonth(y, m, None) => ByMonth(y, m, Some(2))
      case ByMonth(y, m, Some(a)) => ByMonth(y, m, Some(a + 1))
      case ByDay(y, m, d, None) => ByDay(y, m, d, Some(2))
      case ByDay(y, m, d, Some(a)) => ByDay(y, m, d, Some(a + 1))
      case ByTag(t, None) => ByTag(t, Some(2))
      case ByTag(t, Some(a)) => ByTag(t, Some(a + 1))
      case ByTags(ts, None) => ByTags(ts, Some(2))
      case ByTags(ts, Some(a)) => ByTags(ts, Some(a + 1))
      case _ => this
    }

    def discoverable_feeds = this match {
      case All(_) => List(F.articles_feed, F.all_comments_feed)
      case ByYear(_, _) => List(F.articles_feed, F.all_comments_feed)
      case ByMonth(_, _, _) => List(F.articles_feed, F.all_comments_feed)
      case ByDay(_, _, _, _) => List(F.articles_feed, F.all_comments_feed)
      case ByYMDPermatitle(_, _, _, t) => List(F.articles_feed, F.all_comments_feed, F.comments_feed(t))
      case ByPermatitle(t) => List(F.articles_feed, F.all_comments_feed, F.comments_feed(t))
      case ByTag(t, _) => List(F.articles_feed, F.all_comments_feed, F.tags_feed(List(t)))
      case ByTags(ts, _) => List(F.articles_feed, F.all_comments_feed, F.tags_feed(ts))
    }
  }
  
  case class All(page_n: Option[Int]) extends View
  case class ByYear(year: Int, page_n: Option[Int]) extends View
  case class ByMonth(year: Int, month: Int, page_n: Option[Int]) extends View
  case class ByDay(year: Int, month: Int, day: Int, page_n: Option[Int]) extends View
  case class ByTags(tags: List[String], page_n: Option[Int]) extends View
  case class ByTag(tag: String, page_n: Option[Int]) extends View
  case class ByYMDPermatitle(year: Int, month: Int, day: Int, permalink: String) extends View
  case class ByPermatitle (permalink: String) extends View

  trait ViewKind
  case object Single extends ViewKind
  case object Multiple extends ViewKind

  trait Viewable[V] {
    def url: String
    def kind: ViewKind
    def lens(m: Model): List[Item]
    def title: String
    def discoverable_feeds: List[F.DiscoverableFeed]
    def page_number: Option[Int]
    def page_size: Int
    def no_posts_message: String
    def next_page: V
    def first_page: V
  }

  def url_(v: View): String =
    v match {
      case All(_) => "/a"
      case ByYear(y, _) => "/a/" + y
      case ByTag(t, _) => "/t/" + t
      case ByTags(ts, _) => "/t/" + ts.mkString(",")
      case ByMonth(y, m, _) => "/a/" + y + "/" + pad_(m)
      case ByDay(y, m, d, _) => "/a/" + y + "/" + pad_(m) + "/" + pad_(d)
      case ByPermatitle(t) => "/p/" + t
      case ByYMDPermatitle(_, _, _, t) => "/p/" + t
    }


  def page_suffix(n_? : Option[Int]): String =
    n_? match {
      case None => ""
      case Some(n) => "/page/" + n
    }

  def pad_(n: Int): String =
    if (n < 10) "0" + n else "" + n
}