//设置package包名称以及导入依赖的类
package mesosphere.marathon.plugin.http

import java.net.{ URL, URLConnection }
import com.google.common.io.Resources


abstract class HttpRequestHandlerBase extends HttpRequestHandler {

  protected[this] def serveResource(path: String, response: HttpResponse): Unit = {
    val content = withResource(path) { url =>
      response.body(mediaMime(url), Resources.toByteArray(url))
      response.status(200)
    }
    content.getOrElse(response.status(404))
  }

  protected[this] def withResource[T](path: String)(fn: URL => T): Option[T] = {
    Option(getClass.getResource(path)).map(fn)
  }

  protected[this] def mediaMime(url: URL): String = {
    url.getPath.split("\\.").lastOption.flatMap(wellKnownMimes.get)
      .orElse(Option(URLConnection.guessContentTypeFromName(url.toString)))
      .getOrElse("application/octet-stream")
  }

  protected[this] val wellKnownMimes = Map (
    "css" -> "text/css",
    "js" -> "application/javascript",
    "eot" -> "application/vnd.ms-fontobject",
    "svg" -> "image/svg+xml",
    "ttf" -> "application/font-ttf"
  )
} 

//设置package包名称以及导入依赖的类
package repository.storage

import java.io.FileInputStream
import java.net.URLConnection

import com.mongodb.casbah.gridfs.{GridFS, GridFSDBFile}
import conf.connection.HashDB
import domain.storage.FileMeta
import org.bson.types.ObjectId


object FilesRepository {
  val gridfs = GridFS(HashDB.getConnection())

  def getFileType(name: String): String = {
    URLConnection.guessContentTypeFromName(name)
  }

  def save(file: FileInputStream,meta:FileMeta):ObjectId = {
    val fileId = gridfs(file) { f =>
      f.filename = meta.fileName
      f.contentType = meta.contentType
    }

    fileId.get.asInstanceOf[ObjectId]
  }

  def getFileById(id: String): Option[GridFSDBFile] = {
    gridfs.findOne(new ObjectId(id))
  }

  def getFilesByName(fileName: String): Option[GridFSDBFile] = {
    gridfs.findOne(fileName)

  }

  def deleteFileById(id: String) = {
    gridfs.remove(new ObjectId(id))
  }

  def deleteFilesByName(fileName: String) = {
    gridfs.remove(fileName)
  }

} 

//设置package包名称以及导入依赖的类
package org.jmotor.i18n.control

import java.io.InputStreamReader
import java.net.{URL, URLConnection}
import java.util.ResourceBundle.Control
import java.util.{Locale, PropertyResourceBundle, ResourceBundle}


class UTF8Control(suffix: String = "properties") extends Control {

  override def newBundle(baseName: String, locale: Locale, format: String, loader: ClassLoader, reload: Boolean): ResourceBundle = {
    // The below is a copy of the default implementation.
    val bundleName = toBundleName(baseName, locale)
    val resourceName = toResourceName(bundleName, suffix)

    val stream = if (reload) {
      for {
        url: URL ? Option(loader.getResource(resourceName))
        connection: URLConnection ? Option(url.openConnection())
      } yield {
        connection.setUseCaches(false)
        connection.getInputStream
      }
    } else {
      Option(loader.getResourceAsStream(resourceName))
    }

    (for {
      _stream ? stream
    } yield {
      new PropertyResourceBundle(new InputStreamReader(_stream, "UTF-8"))
    }).orNull
  }
} 

//设置package包名称以及导入依赖的类
package slide

import java.io.{File, FileOutputStream}
import java.net.{URL, URLConnection}
import java.nio.channels.{Channels, ReadableByteChannel}

class FileManager {

    var currentFile: String = ""
    var numberOfDownloads: Int = 0

    def downloadFile(dlsite: String, path: String): Unit = {
        val url: URL = new URL(dlsite)
        val file: File = new File(path)

        if (isConnected(url)) {
            currentFile = path
            onDownloadStart()

            new Thread(new Runnable {
                override def run(): Unit = {
                    try {
                        val rbc: ReadableByteChannel = Channels.newChannel(url.openStream())
                        val fos: FileOutputStream = new FileOutputStream(file)

                        fos.getChannel.transferFrom(rbc, 0, java.lang.Long.MAX_VALUE)
                        fos.close()

                        numberOfDownloads += 1
                        onDownloadFinished()
                    } catch {
                        case e: Exception =>
                            println("Error: Could not download ADB, please run as Administrator")
                    }
                }
            }).start()
        }
    }

    def isConnected(site: URL): Boolean = {
        try {
            // test connection
            val conn: URLConnection = site.openConnection()
            conn.setConnectTimeout(5000)
            conn.getContent

            true
        } catch {
            case e: Exception => false
        }
    }

    def onDownloadStart(): Unit = {}

    def onDownloadFinished(): Unit = {}

    // var onDownloadStart: () => Unit = null
    // var onDownloadFinished: () => Unit = null
}