We-Eat/server/app/com/weEat/controllers/USDAController.scala

package com.weEat.controllers

import javax.inject.{Inject,Singleton}
import play.api._
import play.api.mvc._
import play.api.libs.json._
import gov.usda.nal.fdc.{controllers => fdc}
import gov.usda.nal.fdc.models._
import gov.usda.nal.fdc.models.FoodsCriteria.Format
import gov.usda.nal.fdc.models.DataType.DataType
import gov.usda.nal.fdc.models.SortCriteria.SortCriteria
import gov.usda.nal.fdc.models.SortOrder.SortOrder
import scala.util.{Try,Success,Failure}
import com.tflucke.webroutes.HTTPException
import com.weEat.shared.util.TryWith
import scala.concurrent.{ExecutionContext,Future,blocking}
import gov.usda.nal.fdc.{controllers => fdcControllers}
import org.mongodb.scala.model.Filters._
import com.weEat.services.MongoDBService

@Singleton
class USDAController @Inject()(
  val controllerComponents: ControllerComponents,
  config: Configuration,
  db: MongoDBService
) extends BaseController {

  import db.withCollection

  implicit val ec = scala.concurrent.ExecutionContext.global

  val fdc = new fdcControllers.FoodController(config.get[String]("fdc.apikey"))

  def getFood(id: Long, fmt: String = "Full") = Action.async
  { implicit request: Request[Any] =>
    fdc.getFood(id, Format.withName(fmt))().map(x => Ok(Json.toJson[FoodItem](x)))
  }    

  def getFoods(ids: String, fmt: String = "Full") = Action.async
  { implicit request: Request[Any] =>
    fdc.getFoods(ids.split(",").toSeq, Format.withName(fmt))().map(x =>
      Ok(Json.toJson(x))
    )
  }

  def getFoodsSearch(
    query: String,
    dataType: Seq[String] = Nil,
    pageSize: Option[Short] = None,
    pageNumber: Option[Long] = None,
    sortBy: Option[String] = None,
    sortOrder: Option[String] = None
  ) = Action.async { implicit request: Request[Any] =>
    fdc.getFoodsSearch(
      query,
      dataType.map(dt => DataType.withName(dt)),
      pageSize,
      pageNumber,
      sortBy.map(x => SortCriteria.withName(x)),
      sortOrder.map(x => SortOrder.withName(x.toLowerCase))
    )().transform({
      case Success(x) =>
        Success(Ok(Json.toJson(x)))
      case Failure(x: HTTPException) =>
        Success((new Status(x.statusCode))(x.responseText))
      case Failure(x) =>
        Success(InternalServerError(x.toString))
    })
  }

  def postFoodsSearch() = Action.async(parse.json) {
    implicit request: Request[JsValue] =>
    fdc.postFoodsSearch()(request.body.as[FoodSearchCriteria]).transform({
      case Success(x) =>
        Success(Ok(Json.toJson(x)))
      case Failure(x: HTTPException) =>
        Success((new Status(x.statusCode))(x.responseText))
      case Failure(x) =>
        Success(InternalServerError(x.toString))
    })
  }

  def getNutrients() = Action.async { implicit request: Request[Any] =>
    withCollection(com.weEat.models.Nutrient) { collection =>
      collection.find()
        .toFuture()
        .transform({
          case Success(x) => Success(Ok(Json.toJson(x)))
          case Failure(x) => throw x
      })
    }.flatten
  }

  def getNutrient(id: Int) = Action.async { implicit request: Request[Any] =>
    withCollection(com.weEat.models.Nutrient) { collection =>
      collection.find(equal("number", id))
        .toFuture()
        .transform({
          case Success(x) => Success(Ok(Json.toJson(x)))
          case Failure(x) => throw x
      })
    }.flatten
  }
}