scala-news-reader

BlogWriterUser.scala

(5883B)

 package com.joereader.model
 
 import com.joereader._
 import lib._
 import Helper._
 import rss._
 import config._, S3Config._
 
 import net.liftmodules.extras.Gravatar
 import net.liftweb._
 import util._
 import common._
 
 import dispatch._
 import Defaults._
 
 /**
  * A container of a user, blog, blog writer.
  * A user is allowed to follow another user's blog, but
  * for flexibility, we allow user's to follow BlogWriter's that haven't
  * registered. So what type are we following? User or BlogWriter?
  * BlogWriterUser solves that problem.
  */
 class BlogWriterUser(
   _user: Option[User],
   _blog: Option[Blog] = None,
   _blogWriter: Option[BlogWriter] = None) {
 
   def user = _user
   def blog = _blog
   def blogWriter = _blogWriter
 
   def this(user: User) =
     this(Some(user))
 
   def this(blog: Blog, blogWriter: BlogWriter) =
     this(None, Some(blog), Some(blogWriter))
 
   def this(user: User, blog: Blog, blogWriter: BlogWriter) =
     this(Some(user), Some(blog), Some(blogWriter))
 
   def gravatarSize = 300
   private def defaultColor: String =
     BlogWriter.createRecord.color.defaultValue
 
   /*
    * Creates a link that points to the user's page
    * if present else the blog writer's page.
    */
   def link: String =
     user.map(Site.userProfileLoc.calcHref) orElse {
       for {
         blogWriter <- blogWriter
         blog <- blog
       } yield Site.blogWriterProfileLoc.calcHref(this)
     } getOrElse "/"
 
   /*
    * We try everything possible to display the writer's image.
    * Below is the order of importance.
    * 1. user's image
    * 2. user's email gravatar
    * 3. blogWriters's image
    * 4. blogWriter's email gravatar
    * 5. mrnoman
    */
 
   private def userImage: Option[String] = {
     val img = user.map(_.img.get) getOrElse ""
     if (img.isEmpty) None
     else Some(s3.fileUrl(img))
   }
 
   private def userEmailImage: Option[String] = {
     val email = user.map(_.email.get) getOrElse ""
     if (email.isEmpty) None
     else Some(Gravatar.imageUrl(email, gravatarSize))
   }
 
   private def blogWriterImage: Option[String] = {
     val img = blogWriter.map(_.img.get) getOrElse ""
     if (img.isEmpty) None
     else Some(img)
   }
 
   private def blogWriterEmailImage: Option[String] = {
     val email = blogWriter.map(_.email.get) getOrElse ""
     if (email.isEmpty) None
     else Some(Gravatar.imageUrl(email, gravatarSize))
   }
 
   def image: String =
     userImage orElse
       userEmailImage orElse
       blogWriterImage orElse
       blogWriterEmailImage getOrElse
       s3.fileUrl("mr_noman")
 
   def name: String =
     user.map(_.name.get) orElse
       blogWriter.map(_.name.get) getOrElse
       ""
 
   def dashName = name.split(" ").mkString("-")
 
   def categories =
     blogWriter.map(_.categories.get.mkString(", ")).
       getOrElse("")
 
   def color = blogWriter.map(_.color.get).getOrElse(defaultColor)
 
   def url = blog.map(_.urlHtml.get).getOrElse("")
 
   override def toString =
     user.map(BlogWriterUser.create) orElse {
       for {
         blogWriter <- blogWriter
         blog <- blog
       } yield BlogWriterUser.create(blogWriter, blog)
     } getOrElse (Helpers.nextFuncName).split(" ").mkString("-")
 
 }
 
 object BlogWriterUser {
 
   import collection.breakOut
 
   def partDivider = "~"
 
   /* 
    * Indicator that this BlogWriterUser only has user, no blog 
    * or BlogWriter. This must be used to view the user's shared 
    * articles, hence the abbreviation "sa"
    */
   def sa = "sa"
 
   def empty = new BlogWriterUser(User.createRecord)
 
   /* Creates string format given the type */
   def create(writer: BlogWriter, blog: Blog): String =
     blog.id.get + partDivider + writer.name.get.str2bytes.bytes2hex
 
   /* Creates string format given the type */
   def create(user: User): String =
     user.id.get + partDivider + sa.str2bytes.bytes2hex
 
   def fromString(s: String): BlogWriterUser = s.split(partDivider).toList match {
     case id :: nameHex :: Nil =>
       val name = nameHex.hex2bytes.bytes2str
       val blog = if (name != sa) Blog.findByStringId(id) else Empty
       val user = if (name == sa) User.findByStringId(id) else Empty
       val blogWriter = blog.flatMap(_.writers.findStr(name))
       val blogUser = blogWriter.flatMap(_.user.obj)
       new BlogWriterUser(user or blogUser, blog, blogWriter)
     case bwu =>
       error("Invalid BlogWriterUser in data store -> " + bwu.mkString(partDivider))
       BlogWriterUser.empty
   }
 
   /*
    * Removes repeats by grouping user id if user is available, else by
    * grouping the string format of blog-writer to blog
    * This is needed in case we're following a user's multiple blogs
    * so the user may appear multiple times in our list of following. 
    * This function assures the user is not repeated. 
    */
   def uniqueOnly(l: Seq[BlogWriterUser]): List[BlogWriterUser] =
     l.groupBy {
       bwu =>
         val userId = bwu.user.map(_.id.get)
         val writer =
           for (bw <- bwu.blogWriter; blog <- bwu.blog)
             yield create(bw, blog)
 
         userId.getOrElse(writer getOrElse "")
     }.map {
       _._2.head
     }(breakOut)
 
   def fromBlogFeedEntry(blog: Box[Blog], entry: Box[FeedEntry]): BlogWriterUser = {
     val writer = for {
       blog <- blog
       entry <- entry
       blogWriter <- blog.writers.findStr(entry.author.name)
     } yield blogWriter
     val user = writer.flatMap(_.user.obj)
     new BlogWriterUser(user, blog, writer)
   }
 
   // parse and encode functions are used by SiteMap
   def parse(path: List[String]): Box[BlogWriterUser] = {
     val blog = Blog.findByBlogName(path(0))
     val writer = blog.flatMap(_.writers.findStr(path(1).
         replace('+', ' ')))
     val user = writer.flatMap(_.user.obj)
     
     for (b <- blog; bw <- writer)
       yield new BlogWriterUser(user, blog, writer)
   }
 
   def encode(bwu: BlogWriterUser): List[String] = List(
     bwu.blog.map(_.blogname.get),
     bwu.blogWriter.map(_.name.get)).flatten
 }