Liftweb JSON serialization and deserialization using Scala

play.core.ActionInvoker$$anonfun$receive$1$$anon$1: Execution exception [[MappingException: No usable value for year
No usable value for $outer
Parsed JSON values do not match with class constructor
args=
arg types=
constructor=public scala.Enumeration()]]
	at play.core.ActionInvoker$$anonfun$receive$1.apply(Invoker.scala:82) [play_2.9.1.jar:2.0]
	at play.core.ActionInvoker$$anonfun$receive$1.apply(Invoker.scala:63) [play_2.9.1.jar:2.0]
	at akka.actor.Actor$class.apply(Actor.scala:290) [akka-actor.jar:2.0]
	at play.core.ActionInvoker.apply(Invoker.scala:61) [play_2.9.1.jar:2.0]

/*
*  Serializer and Deserializers for Enumeration
*/
class EnumerationSerializer(enumList: List[Enumeration]) extends net.liftweb.json.Serializer[Enumeration#Value] {
  import JsonDSL._
  val EnumerationClass = classOf[Enumeration#Value]
  val formats = Serialization.formats(NoTypeHints)

 //  Deserializer Function for Enumeration
  def deserialize(implicit format: Formats): PartialFunction[(TypeInfo, JValue), Enumeration#Value] = { 
    case (TypeInfo(EnumerationClass, _), json) => json match {
      case JObject(List(JField(name, JString(value)))) => fetchEnumValue(enumList, value)  // Here we can perform the
      case JString(value) => fetchEnumValue(enumList, value)                               // desired function
      case value => throw new MappingException("Can't convert " +
        value + " to " + EnumerationClass)
    }
  }

  def serialize(implicit format: Formats): PartialFunction[Any, JValue] = {
    case i: Enumeration#Value => i.toString
  }

  private def fetchEnumValue(enumList: List[Enumeration], value: String): Enumeration#Value = {
    var defaultEnumValue: Enumeration#Value = Year.withName("FinalYear")
    for (enumItem <- enumList) {
      for (enumValue <- enumItem.values) {
        enumValue.toString == value match {
          case true => {
            defaultEnumValue = enumItem.withName(value)
          }
          case _ => None
        }
      }
    }
    defaultEnumValue
  }

}

/*
*  Serializer and Deserializers for Date
*/
object DateTimeSerializer extends Serializer[Option[Date]] {
  
  val formatter: DateFormat = new java.text.SimpleDateFormat("dd/MM/yyyy")
  
  private val MyDateClass = classOf[Option[Date]]

 //  Deserializer Function for java.util.Date
  def deserialize(implicit format: Formats): PartialFunction[(TypeInfo, JValue), Option[Date]] = {
    case (TypeInfo(MyDateClass, _), json) => json match {
      case JString(s) => {
        Option(formatter.parse(s))
      }

      case x => throw new MappingException("Can't convert " + x + " to Date")
    }
  
  }

  def serialize(implicit format: Formats): PartialFunction[Any, JValue] = {
    case x: Date => JObject(JField("graduationDate", JString(x.toString)) :: Nil)
  }
}

/*
*  Serializer and Deserializers for ObjectId
*/
class ObjectIdSerializer extends Serializer[ObjectId] {
  private val Class = classOf[ObjectId]

 //  Deserializer Function for ObjectId
  def deserialize(implicit format: Formats) = {
    case (TypeInfo(Class, _), json) => json match {
      case JInt(s) =>  new ObjectId
      case x => throw new MappingException("Can't convert " + x + " to ObjectId")
    }
  }

  def serialize(implicit format: Formats) = {
    case x: ObjectId => JObject(JField("schoolId", JString(x.toString)) :: Nil)
  }
}

 implicit val formats = new net.liftweb.json.DefaultFormats {
    override def dateFormatter = new SimpleDateFormat("dd/MM/yyyy")
  }