dsugden

  def update(article: ArticleForUpdate): Try[Unit] = database.withSession { implicit db: Session =>
    Try((ArticleTable.filter(a => a.id === article.id).map(a => a.name ~ a.body ~ a.displayOrder))
      .update(article.name, article.body, article.displayOrder))
  }

dsugden

implicit val ArticleCreate = Json.reads[ArticleForCreation]  
  
  def create = IsAuthenticated { username =>
    implicit request =>
      userIdOpt.map { userId =>
        request.body.asJson.map { json =>
          json.validate[ArticleForCreation].fold(
            invalid => {
              BadRequest(Json.toJson(Map("error" -> invalid.head.toString)))
            },

dsugden

sealed trait ArticlePublishedState
case object UNPUBLISHED extends ArticlePublishedState
case object PUBLISHED extends ArticlePublishedState
case object DIRTY extends ArticlePublishedState


val articlePublishedMappings = Map(UNPUBLISHED.toString() -> UNPUBLISHED,

dsugden

implicit object ArticlePublishedReads extends Reads[ArticlePublishedState] {
    def reads(json: JsValue) = json match {
      case JsString(cat) => {
        val res = articlePublishedMappings collectFirst { case (s, a) if cat.equals(s) => JsSuccess(a) }
        res.getOrElse(JsError(Seq(JsPath() -> Seq(ValidationError("no such category")))))
      }
      case _ => JsError(Seq(JsPath() -> Seq(ValidationError("validate.error.expected.jsnumber"))))
    }
  }

dsugden

package models

import java.sql.Date
import play.Logger
import scala.util.{ Try, Success, Failure }
import play.cache.Cache
import org.mindrot.jbcrypt.BCrypt
import play.api.libs.Crypto
import play.libs.Scala
import be.objectify.deadbolt.core.models.Subject

dsugden

package models

//import play.api.db._
import java.sql.Date
import play.Logger
import scala.util.{ Try, Success, Failure }
import play.cache.Cache
import org.mindrot.jbcrypt.BCrypt
import play.api.libs.Crypto
import play.libs.Scala

dsugden

class Foo{
  private var fooState = 0
  def  next:Int = { fooState = fooState + 1;  fooState  }
  def getFooState:Int = fooState
}

val foo = new Foo()
foo.next
foo.next
val result = foo.next

dsugden

  case class Node(id:Int)
  type SyncResponse = Either[String,List[Node]]
  
  class Network {
    var nodes: ListBuffer[Node] = ListBuffer.empty
    val rng = scala.util.Random
    /**
     * Removes dead nodes
     */
    def purge:SyncResponse = {

dsugden

import scalaz._
import Scalaz._

object StateTLearning extends App with StateTFunctions {

  case class DB(v: Int)

  val initial = DB(1)

dsugden

object MutableBad{

  class MDate(dayIn:Int){ var day = dayIn  }

  type Task = Int

  def scheduleTask(task:Task,date:MDate) = ???

  var d = new MDate(22)