playframeworkのScalaの配列[フューチャー[モデル]]フューチャー

Question

を取り除く、私は次の問題を持って、

は私がSeq[Future[ProcessStepTemplatesModel]]を持っていると私は、内側の未来を削除したいです。

私が得意とするものは、Seq[ProcessStepTemplatesModel]です。

完全なコードは、この

Future.sequence { 
     processSteps.map { step => // This is a "for each" over a Seq[ProcessStepTemplatesModel] 
      val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get) 

      prerequisiteFuture.map(prereqTemplates => { 

      processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => { 
       step.stepPrerequisites ++Some(pres) 
       step 
       }) 

      }) 
     } 
     } 

おかげ

がUPDATEのようになります。

def getEditProcessTemplateData(processTemplateId: Int) = Action.async { 
    //Get all steps of this process templates 
    val stepIds: Future[Seq[Int]] = processTemplateDTO.getProcessStepTemplateIds(processTemplateId) 

    val process = for { 
     allApprovedProcessTemplates <- processTemplateDTO.getApprovedProcessTemplates //Get all approved process templates 
     processTemplate <- processTemplateDTO.getProcessTemplate(processTemplateId) // Get the Process Template 
     prerequisites <- getProcessTemplateForEdit(processPrerequisitesDTO.getProcessPrerequisiteProcessTemplateIdsByProcessTemplateId(processTemplateId)) 
     postConditions <- getProcessTemplateForEdit(processPostConditionsDTO.getProcessPostConditionProcessTemplateIdsByProcessTemplateId(processTemplateId)) 
     approvedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.approveprocess) 
     trainedProcessTemplate <- processTemplateDTO.getProcessTemplate(processTemplate.get.trainingsprocess) 
     processSteps <- processTemplateDTO.getProcessStepTemplates(processTemplateId) 
     // Step prerequisites 
     processStepsPrerequisites <- getProcessStepsPrerequisites(stepIds) 
     processStepsPrerequisiteProcessTemplate <- getProcessStepsPrerequisiteProcessTemplate(stepIds) 
     processTemplatesForStepPrerequisites <- getProcessTemplateForStepPrerequisite(stepIds) 
     // Step post conditions 
     processStepsPostConditions <- getProcessStepsPostConditions(stepIds) 
     processStepPostConditionProcessTemplate <- getProcessStepPostConditionProcessTemplate(stepIds) 
     processTemplatesForStepPostConditions <- getProcessTemplateForStepPostCondition(stepIds) 
     // Derived processes 
     derivedProcesses <- getDerivedProcesses(stepIds) 
     processTemplatesForStepDerivedProcesses <- getProcessStepsDerivedProcesses(stepIds) 
     // Process to process step 
     processStepsTemplates_ProcessTemplates <- getProcessStepsTemplates_ProcessTemplates(stepIds) 
     processTemplatesForProcessTemplatesToProcessStep <- getProcessTemplateToProcessStepId(stepIds) 
     responsible <- raciProcessTemplateDTO.getResponsibleProcessTemplates(processTemplateId) // get all responsibles for this process template 
     accountable <- raciProcessTemplateDTO.getAccountableProcessTemplates(processTemplateId) // get all accountables for this process template 
     consulted <- raciProcessTemplateDTO.getConsultedProcessTemplates(processTemplateId) // get all consulted for this process template 
     informed <- raciProcessTemplateDTO.getInformedProcessTemplates(processTemplateId) // get all consulted for this process template 
    } yield (allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, processStepsPrerequisites, 
     processStepsPrerequisiteProcessTemplate, processTemplatesForStepPrerequisites, processStepsPostConditions, processStepPostConditionProcessTemplate, processTemplatesForStepPostConditions, derivedProcesses, 
     processTemplatesForStepDerivedProcesses, processStepsTemplates_ProcessTemplates, processTemplatesForProcessTemplatesToProcessStep, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed) 

    process.flatMap({ case (allApprovedProcessTemplates, processTemplate, prerequisites, postConditions, processSteps, processStepsPrerequisites, 
    processStepsPrerequisiteProcessTemplate, processTemplatesForStepPrerequisites, processStepsPostConditions, processStepPostConditionProcessTemplate, processTemplatesForStepPostConditions, derivedProcesses, 
    processTemplatesForStepDerivedProcesses, processStepsTemplates_ProcessTemplates, processTemplatesForProcessTemplatesToProcessStep, approvedProcessTemplate, trainedProcessTemplate, responsible, accountable, consulted, informed) => 

     Future.sequence { 
     processSteps.map { 
      step => 
      val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get) 

      prerequisiteFuture.map(prereqTemplates => { 

       processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => { 
        println("test", pres) // they are printed 
        step.stepPrerequisites ++Some(pres) 
        println("test2", step) 
       step 
       }) 

      }) 
     } 
     }.map { 
     stepTemplates => 
      Ok(Json.obj(
      "allApprovedProcessTemplates" -> allApprovedProcessTemplates, 
      "processTemplate" -> processTemplate, 
      "prerequisites" -> prerequisites, 
      "postConditions" -> postConditions, 
      "approvedProcessTemplate" -> approvedProcessTemplate, 
      "trainedProcessTemplate" -> trainedProcessTemplate, 
      // Step prerequisites 
      "processStepsPrerequisites" -> processStepsPrerequisites, 
      "processStepsPrerequisiteProcessTemplate" -> processStepsPrerequisiteProcessTemplate, 
      "processTemplatesForStepPrerequisites" -> processTemplatesForStepPrerequisites, 
      // Step post conditions 
      "processStepsPostConditions" -> processStepsPostConditions, 
      "processStepPostConditionProcessTemplate" -> processStepPostConditionProcessTemplate, 
      "processTemplatesForStepPostConditions" -> processTemplatesForStepPostConditions, 
      // Derived processes 
      "derivedProcesses" -> derivedProcesses, 
      "processTemplatesForStepDerivedProcesses" -> processTemplatesForStepDerivedProcesses, 
      // Process to process step 
      "processStepsTemplates_ProcessTemplates" -> processStepsTemplates_ProcessTemplates, 
      "processTemplatesForProcessTemplatesToProcessStep" -> processTemplatesForProcessTemplatesToProcessStep, 
      "steps" -> "stepTemplates", 
      "responsible" -> responsible, 
      "accountable" -> accountable, 
      "consulted" -> consulted, 
      "informed" -> informed 
     )) 
     } 
    }) 
    } 

Answer 1

作業溶液は次のとおりです。

Future.sequence { 
     processSteps.map { 
      step => 
      val prerequisiteFuture = processStepPrerequisitesDTO.getProcessStepPrerequisiteProcessTemplateIds(step.id.get) 
      prerequisiteFuture.map(prereqTemplates => { 
       processTemplateDTO.getProessTemplatesForStepPreqrequsites(prereqTemplates).map(pres => { 
        println("test", pres) // they are printed 
        step.stepPrerequisites = Some(pres) 
        println("test2", step) 
       step 
       }) 
      }) 
     } 
     }.flatMap { 
     stepTemplates => { 

      Future.sequence(stepTemplates).map(test => 

      Ok(Json.obj([....] 

Answer 2

Future.sequenceはにSeq[Future[ProcessStepTemplatesModel]]を変換します。あなただけのSeq[ProcessStepTemplatesModel]が必要な場合、将来は

Await.result({ 
    Future.sequence { 
    processSteps.map ... 
    } 
}, 1 minute) 

が来るまで、だからあなたは待つことができますが、ブロッキングがあなたの状況では良いアイデアであるかどうかあなただけが知っていることができます。例えば

---

ここList[Future[Int]]を有するFuture.sequenceプリント整数適用することは、コントローラである：

/app/controllers/HomeController.scala

package controllers 

import javax.inject._ 

import play.api._ 
import play.api.mvc._ 

import scala.concurrent.Future 

import scala.concurrent.ExecutionContext.Implicits.global 

@Singleton 
class HomeController @Inject()(cc: ControllerComponents) extends AbstractController(cc) { 

    def index() = 
    Action.async { 
     Future.sequence { 
     List(Future(1), Future(2)) 
     }.map { nums => 
      Ok(views.html.index(nums)) 
     } 
    } 
} 

/アプリ/ビュー/インデックスを.scala.html

@(nums: List[Int]) 

@main("Welcome to Play") { 
    <h1>Welcome to Play!</h1> 
    <ul> 
    @for(num <- nums) { 
     <li>@num</li> 
    } 
    </ul> 
} 

---

[OK]を、これはあなたに、より似ており、11を印刷し、12：ここで

def index() = 
    Action.async { 
     Future.sequence { 
     List(1, 2).map(num => 
      Future{ 
      Thread.sleep(5000) 
      10 
      }.map(n => 
      num + n 
     ) 
     ) 
     }.map { 
     nums => 
      Ok(views.html.index(nums)) 
     } 
    } 

   step.stepPrerequisites ++Some(pres) 
      step 

私はあなたがstep.stepPrerequisites ++Some(pres)の値を使用する方法を見ることができない、あなたは元のstepを返します。副作用はありますか？