Issue #KN231 merge: Merge pull request #875 from project-sunbird/release-4.10.1

Issue #KN231 merge: From release-4.10.1 to release-5.0.0

content-api/content-actors/src/main/scala/org/sunbird/content/util/CopyManager.scala

@@ -222,7 +222,7 @@ object CopyManager {
     protected def getFileNameFromURL(fileUrl: String): String = if (!FilenameUtils.getExtension(fileUrl).isEmpty)
         FilenameUtils.getBaseName(fileUrl) + "_" + System.currentTimeMillis + "." + FilenameUtils.getExtension(fileUrl) else FilenameUtils.getBaseName(fileUrl) + "_" + System.currentTimeMillis
 
-    protected def isInternalUrl(url: String)(implicit ss: StorageService): Boolean = url.contains(ss.getContainerName())
+    protected def isInternalUrl(url: String)(implicit ss: StorageService): Boolean = url.contains(ss.getContainerName)
 
     def prepareHierarchyRequest(originHierarchy: util.Map[String, AnyRef], originNode: Node, node: Node, copyType: String, request: Request):util.HashMap[String, AnyRef] = {
         val children:util.List[util.Map[String, AnyRef]] = originHierarchy.get("children").asInstanceOf[util.List[util.Map[String, AnyRef]]]

content-api/content-actors/src/test/scala/org/sunbird/content/actors/TestContentActor.scala

@@ -93,7 +93,7 @@ class TestContentActor extends BaseSpec with MockFactory {
         val graphDB = mock[GraphService]
         (oec.graphService _).expects().returns(graphDB)
         (graphDB.getNodeByUniqueId(_: String, _: String, _: Boolean, _: Request)).expects(*, *, *, *).returns(Future(getValidNode()))
-        implicit val ss = mock[StorageService]
+        implicit val ss: StorageService = mock[StorageService]
         (ss.getSignedURL(_: String, _: Option[Int], _: Option[String])).expects(*, *, *).returns("cloud store url")
         val request = getContentRequest()
         request.getRequest.putAll(mapAsJavaMap(Map("fileName" -> "presigned_url", "filePath" -> "/data/cloudstore/", "type" -> "assets", "identifier" -> "do_1234")))

platform-modules/mimetype-manager/pom.xml

@@ -30,7 +30,7 @@
         <dependency>
             <groupId>org.sunbird</groupId>
             <artifactId>cloud-store-sdk</artifactId>
-            <version>1.4.0</version>
+            <version>1.4.1</version>
         </dependency>
         <dependency>
             <groupId>org.scala-lang</groupId>

platform-modules/mimetype-manager/src/main/scala/org/sunbird/cloudstore/StorageService.scala

 package org.sunbird.cloudstore
 
-import java.io.File
-
 import org.apache.commons.lang3.StringUtils
+import org.apache.tika.Tika
 import org.sunbird.cloud.storage.BaseStorageService
-import org.sunbird.common.Platform
-import org.sunbird.cloud.storage.factory.StorageConfig
-import org.sunbird.cloud.storage.factory.StorageServiceFactory
+import org.sunbird.cloud.storage.factory.{StorageConfig, StorageServiceFactory}
+import org.sunbird.common.{Platform, Slug}
 import org.sunbird.common.exception.ServerException
-import org.sunbird.common.Slug
 
-import scala.concurrent.ExecutionContext
+import java.io.File
+import scala.concurrent.{ExecutionContext, Future}
 
 class StorageService {
 
@@ -18,20 +16,20 @@ class StorageService {
     var storageService: BaseStorageService = null
 
     @throws[Exception]
-    def getService(): BaseStorageService = {
+    def getService: BaseStorageService = {
         if (null == storageService) {
             if (StringUtils.equalsIgnoreCase(storageType, "azure")) {
                 val storageKey = Platform.config.getString("azure_storage_key")
                 val storageSecret = Platform.config.getString("azure_storage_secret")
-                storageService = StorageServiceFactory.getStorageService(new StorageConfig(storageType, storageKey, storageSecret))
+                storageService = StorageServiceFactory.getStorageService(StorageConfig(storageType, storageKey, storageSecret))
             } else if (StringUtils.equalsIgnoreCase(storageType, "aws")) {
                 val storageKey = Platform.config.getString("aws_storage_key")
                 val storageSecret = Platform.config.getString("aws_storage_secret")
-                storageService = StorageServiceFactory.getStorageService(new StorageConfig(storageType, storageKey, storageSecret))
+                storageService = StorageServiceFactory.getStorageService(StorageConfig(storageType, storageKey, storageSecret))
             } else if (StringUtils.equalsIgnoreCase(storageType, "gcloud")) {
                 val storageKey = Platform.config.getString("gcloud_client_key")
                 val storageSecret = Platform.config.getString("gcloud_private_secret")
-                storageService = StorageServiceFactory.getStorageService(new StorageConfig(storageType, storageKey, storageSecret))
+                storageService = StorageServiceFactory.getStorageService(StorageConfig(storageType, storageKey, storageSecret))
             }
 //            else if (StringUtils.equalsIgnoreCase(storageType, "cephs3")) {
 //                val storageKey = Platform.config.getString("cephs3_storage_key")
@@ -44,17 +42,13 @@ class StorageService {
         storageService
     }
 
-    def getContainerName(): String = {
-        if (StringUtils.equalsIgnoreCase(storageType, "azure"))
-            Platform.config.getString("azure_storage_container")
-        else if (StringUtils.equalsIgnoreCase(storageType, "aws"))
-            Platform.config.getString("aws_storage_container")
-        else if (StringUtils.equalsIgnoreCase(storageType, "gcloud"))
-          Platform.config.getString("gcloud_storage_bucket")
-        else if (StringUtils.equalsIgnoreCase(storageType, "cephs3"))
-            Platform.config.getString("cephs3_storage_container")
-        else
-            throw new ServerException("ERR_INVALID_CLOUD_STORAGE", "Container name not configured.")
+    def getContainerName: String = {
+      storageType match {
+        case "azure" => Platform.config.getString("azure_storage_container")
+        case "aws" => Platform.config.getString("aws_storage_container")
+        case "gcloud" => Platform.config.getString("gcloud_storage_bucket")
+        case _ => throw new ServerException("ERR_INVALID_CLOUD_STORAGE", "Container name not configured.")
+      }
     }
 
     def uploadFile(folderName: String, file: File, slug: Option[Boolean] = Option(true)): Array[String] = {
@@ -67,11 +61,11 @@ class StorageService {
     def uploadDirectory(folderName: String, directory: File, slug: Option[Boolean] = Option(true)): Array[String] = {
         val slugFile = if (slug.getOrElse(true)) Slug.createSlugFile(directory) else directory
         val objectKey = folderName + File.separator
-        val url = getService.upload(getContainerName(), slugFile.getAbsolutePath, objectKey, Option.apply(true), Option.apply(1), Option.apply(5), Option.empty)
+        val url = getService.upload(getContainerName, slugFile.getAbsolutePath, objectKey, Option.apply(true), Option.apply(1), Option.apply(5), Option.empty)
         Array[String](objectKey, url)
     }
 
-    def uploadDirectoryAsync(folderName: String, directory: File, slug: Option[Boolean] = Option(true))(implicit ec: ExecutionContext) = {
+    def uploadDirectoryAsync(folderName: String, directory: File, slug: Option[Boolean] = Option(true))(implicit ec: ExecutionContext): Future[List[String]] = {
         val slugFile = if (slug.getOrElse(true)) Slug.createSlugFile(directory) else directory
         val objectKey = folderName + File.separator
         getService.uploadFolder(getContainerName, slugFile.getAbsolutePath, objectKey, Option.apply(false), None, None, 1)
@@ -82,26 +76,34 @@ class StorageService {
         blob.contentLength
     }
 
-    def copyObjectsByPrefix(source: String, destination: String) = {
+    def copyObjectsByPrefix(source: String, destination: String): Unit = {
         getService.copyObjects(getContainerName, source, getContainerName, destination, Option.apply(true))
     }
 
-    def deleteFile(key: String, isDirectory: Option[Boolean] = Option(false)) = {
+    def deleteFile(key: String, isDirectory: Option[Boolean] = Option(false)): Unit = {
         getService.deleteObject(getContainerName, key, isDirectory)
     }
 
     def getSignedURL(key: String, ttl: Option[Int], permission: Option[String]): String = {
-        getService().getSignedURL(getContainerName, key, ttl, permission)
+      storageType match {
+        case "gcloud" => getService.getPutSignedURL(getContainerName, key, ttl, permission, Option.apply(getMimeType(key)))
+        case _ => getService.getSignedURL (getContainerName, key, ttl, permission)
+      }
     }
 
     def getUri(key: String): String = {
         try {
            getService.getUri(getContainerName, key, Option.apply(false))
         } catch {
-            case e:Exception => {
-               println("StorageService --> getUri --> Exception: " + e.getMessage)
-               ""
-            }
+            case e:Exception =>
+              println("StorageService --> getUri --> Exception: " + e.getMessage)
+              ""
         }
     }
+
+  def getMimeType(fileName: String): String = {
+    val tika: Tika = new Tika()
+    tika.detect(fileName)
+  }
+
 }

platform-modules/mimetype-manager/src/test/scala/org/sunbird/cloudstore/StorageServiceTest.scala

@@ -2,16 +2,54 @@ package org.sunbird.cloudstore
 
 import org.scalatest.{AsyncFlatSpec, Matchers}
 
+import java.io.File
+
 class StorageServiceTest extends AsyncFlatSpec with Matchers {
     val ss = new StorageService
 
     "getService" should "return a Storage Service" in {
-        val service = ss.getService()
+        val service = ss.getService
         assert(service != null)
     }
 
     "getContainerName" should "return the container name" in {
-        val container = ss.getContainerName()
+        val container = ss.getContainerName
         assert(container == "sunbird-content-dev")
     }
+
+    "getSignedURL" should "return the signed url" in {
+        val objectKey = "content" + File.separator + "asset" + File.separator + "do_53245" + File.separator + "abc.png"
+        val preSignedURL = ss.getSignedURL(objectKey, Option.apply(600), Option.apply("w"))
+        assert(preSignedURL.contains(objectKey))
+    }
+
+    "getUri" should "return the signed url" in {
+        val uri = ss.getUri("content/abc.json")
+        assert(uri != null)
+    }
+
+    "getMimeType" should "return the mimetype application/epub+zip for epub" in {
+        val result = ss.getMimeType("test.alert.epub")
+        assert(result == "application/epub+zip")
+    }
+
+    "getMimeType" should "return the mimetype application/octet-stream for h5p" in {
+        val result = ss.getMimeType("test.alert.h5p")
+        assert(result == "application/octet-stream")
+    }
+
+    "getMimeType" should "return the mimetype text/csv for csv" in {
+        val result = ss.getMimeType("test.alert.csv")
+        assert(result == "text/csv")
+    }
+
+    "getMimeType" should "return the mimetype application/pdf for pdf" in {
+        val result = ss.getMimeType("test.alert.pdf")
+        assert(result == "application/pdf")
+    }
+
+    "getMimeType" should "return the mimetype application/zip for zip" in {
+        val result = ss.getMimeType("test.alert.zip")
+        assert(result == "application/zip")
+    }
 }