gistfile1.txt

case class QuoteArticleBlogDummy(var article_id: Int=0, var blog_id: Int=0,var linktable_blog_id: Int=0,var linktable_id: Int=0)
object QuoteArticleBlogDummy{
  implicit var QuoteArticleBlogDummyWrites = new Writes[QuoteArticleBlogDummy] {
    def writes(response: QuoteArticleBlogDummy) = {
      Json.obj(
        "article_id"-> response.article_id,
        "blog_id" -> response.blog_id,
        "linktable_blog_id" -> response.linktable_blog_id,
        "linktable_id" -> response.linktable_id
      )
    }
  }
}

trait WriteGenericTrait[WriteClass]{
  def list_write:List[WriteClass];
  def num_rows:Long;
  def error_string:String;
  def optional_data: List[QuoteArticleBlogDummy];
}

class WriteGenericClass[WriteClass](var list_write_var: List[WriteClass], var num_rows_var: Long, var error_string_var: String, var optional_data_var:List[QuoteArticleBlogDummy]=List()) extends WriteGenericTrait[WriteClass]{
  override def list_write = list_write_var;
  override def num_rows = num_rows_var;
  override def error_string = error_string_var;
  override def optional_data = optional_data_var;
}


def retrieve_one[T](retrieve_params: RetrieveParams):Future[WriteGenericClass[T]]={
    println("inside retrieve_one in commands")
    var sql_string = "SELECT * FROM "+retrieve_params.table+" WHERE ID="+retrieve_params.id.toString
    var sql_string_count="SELECT COUNT(*) FROM "+retrieve_params.table;
    println("value of sql_string_count")
    println(sql_string_count)
    
    var parser = retrieve_params.table match{
      case "BLOG"=>{
        Macro.namedParser[Blog];
      }
      case "ARTICLE"=>{
        Macro.namedParser[Article];
      }
    }
    
    var parserAbqlink = Macro.namedParser[Abqlink]
    var parserQuote = Macro.namedParser[Quote]
    var parserBloglink = Macro.namedParser[Bloglink]
    var parserArticle = Macro.namedParser[Article]
    var parserBlog = Macro.namedParser[Blog]

    val parserQuoteArticleBlog: RowParser[QuoteArticleBlog] = Macro.parser[QuoteArticleBlog]("quote.body", "quote.id","article.title", "article.body", "article.web_address", "article.id", "blog.id", "linktable.blog_id", "linktable.id")

    println("value of parserQuoteArticleBlog")
    println(parserQuoteArticleBlog)

    val parserQuoteArticleBlogDummy: RowParser[QuoteArticleBlogDummy] = Macro.parser[QuoteArticleBlogDummy]("article.id", "blog.id", "linktable.blog_id", "linktable.id")

    println("value of parserQuoteArticleBlogDummy")
    println(parserQuoteArticleBlogDummy)

    val sql_string_2 = """
      SELECT a.id as article_id, b.id as blog_id,
       l.blog_id, l.id as linktable_id
      FROM blog b 
        LEFT JOIN linktable l
          ON l.blog_id= blog_id OR l.parent_id = blog_id 
        LEFT JOIN article a 
          ON l.article_id = article_id;
    """
    

    println("value of sql_string_2 is: ")
    println(sql_string_2)

    var insert_row = Future{
      database.db.withConnection { implicit connection =>
        val returnVal = new WriteGenericClass(
          SQL(sql_string.toString)
          .as(parser.*),
          SQL(sql_string_count.toString)
          .as(scalar[Long].single), 
          "NO ERROR",
          SQL(sql_string_2.toString)
              .as(parserQuoteArticleBlogDummy.*)
        )
        returnVal;
      }
    }(ec)
    val mapped: Future[WriteGenericClass[T]] = insert_row.transform {
      case scala.util.Success(e) => scala.util.Try({
        println("inside mapped success and value of e")
        println(e)
        println(e.list_write)
        println(e.num_rows)
        println(e.error_string)
        println(e.optional_data)
        e.asInstanceOf[WriteGenericClass[T]]
      })
      case scala.util.Failure(e) => scala.util.Try({
        println("inside mapped failure and value of e")
        println(e)
        new WriteGenericClass(List(), 0.toLong, e.toString)
      })
    }
    mapped
  }