missing parameter type on file upload with silhouette

Question

now implement file-uploading with silhouette.

got from the original

https://github.com/playframework/play-scala-fileupload-example/tree/2.5.x

silhouette

https://github.com/mohiva/play-silhouette-seed/tree/4.0.0/app

i want to fix def upload method with silhouette to indicate identity(user name) in fileUpload2.scala.html , so added following line;

silhouette.SecuredAction.async { implicit request => 
Future.successful(Ok(views.html.fileUpload2(request.identity,fileOption)))
}

refered to this link;

http://grokbase.com/p/gg/play-framework/133pt061br/2-1-0-scala-action-question

but not work well.

(FileUploadController.scala)

package controllers

import java.io.File
import java.nio.file.attribute.PosixFilePermission._
import java.nio.file.attribute.PosixFilePermissions
import java.nio.file.{ Files, Path }
import java.util
import javax.inject._

import com.mohiva.play.silhouette.api._
import com.mohiva.play.silhouette.api.repositories.AuthInfoRepository
import com.mohiva.play.silhouette.api.services.AvatarService
import com.mohiva.play.silhouette.api.util.PasswordHasherRegistry
import com.mohiva.play.silhouette.impl.providers._

import com.mohiva.play.silhouette.api.Authenticator.Implicits._
import com.mohiva.play.silhouette.api.util.{ Clock, Credentials }

import com.mohiva.play.silhouette.api.actions.SecuredRequest

import utils.auth.{ DefaultEnv, WithProvider }

import forms.{ FileUploadForm, FileUploadFormSupport }
import models.User

import models.services.{ AuthTokenService, UserService }

import net.ceedubs.ficus.Ficus._

import akka.stream.IOResult
import akka.stream.scaladsl._
import akka.util.ByteString

import play.api._
import play.api.data.Form
import play.api.data.Forms._
import play.api.i18n.{ I18nSupport, Messages, MessagesApi }
import play.api.libs.streams._
import play.api.libs.concurrent.Execution.Implicits._
import play.api.libs.mailer.{ Email, MailerClient }

import play.api.mvc.MultipartFormData.FilePart
import play.api.mvc._
import play.core.parsers.Multipart.FileInfo

import scala.concurrent.{ ExecutionContext, Future }
import scala.concurrent.duration._

import scala.language.postfixOps

class FileUploadController @Inject() (
  val messagesApi: MessagesApi,
  silhouette: Silhouette[DefaultEnv],
  userService: UserService,
  authInfoRepository: AuthInfoRepository,
  authTokenService: AuthTokenService,
  avatarService: AvatarService,
  passwordHasherRegistry: PasswordHasherRegistry,
  mailerClient: MailerClient,
  implicit val webJarAssets: WebJarAssets,
  socialProviderRegistry: SocialProviderRegistry,
  ec: ExecutionContext,
  credentialsProvider: CredentialsProvider
)
  extends Controller with i18n.I18nSupport {

  private val logger = org.slf4j.LoggerFactory.getLogger(this.getClass)

  def fileuploadview = silhouette.SecuredAction.async { implicit request =>
    Future.successful(Ok(views.html.fileUpload(request.identity, FileUploadForm.form)))

  }

  type FilePartHandler[A] = FileInfo => Accumulator[ByteString, FilePart[A]]

  def handleFilePartAsFile: FilePartHandler[File] = {
    case FileInfo(partName, filename, contentType) =>
      val attr = PosixFilePermissions.asFileAttribute(util.EnumSet.of(OWNER_READ, OWNER_WRITE))
      val path: Path = Files.createTempFile("multipartBody", "tempFile", attr)
      val file = path.toFile
      val fileSink: Sink[ByteString, Future[IOResult]] = FileIO.toPath(path)
      val accumulator: Accumulator[ByteString, IOResult] = Accumulator(fileSink)
      accumulator.map {
        case IOResult(count, status) =>
          logger.info(s"count = $count, status = $status")
          FilePart(partName, filename, contentType, file)
      }
  }

  def operateOnTempFile(file: File) = {
    val size = Files.size(file.toPath)
    logger.info(s"size = ${size}")
    Files.deleteIfExists(file.toPath)
    size
  }

  def upload = Action(parse.multipartFormData(handleFilePartAsFile)) { implicit request =>

    val fileOption = request.body.file("picName").map {

      case FilePart(key, filename, contentType, file) =>
        logger.info(s"key = ${key}, filename = ${filename}, contentType = ${contentType}, file = $file")

        val data = operateOnTempFile(file)

        data

    }

    FileUploadFormSupport.picsave(_)

    silhouette.SecuredAction.async { implicit request =>

    Future.successful(Ok(views.html.fileUpload2(request.identity,fileOption)))
    }
   }

}

the problem is the last lines;

silhouette.SecuredAction.async { implicit request => Future.successful(Ok(views.html.fileUpload2(request.identity,fileOption)))

compile error;

missing parameter type

occured.

Answer 1

You use the Silhouette action at the wrong place. You should write:

def upload = silhouette.SecuredAction.async(parse.multipartFormData(handleFilePartAsFile)) { 
  implicit request =>
    // Your upload code
}

A Silhouette action is a default Play action with the advantage that the request type is extended with the identity and the authenticator.