1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.technical.storage
21 
22 import java.io.{ByteArrayOutputStream, File, FileInputStream, InputStream}
23 import java.net.URL
24 
25 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
26 import io.circe.{Decoder, Encoder}
27 import io.swagger.annotations.ApiModelProperty
28 import org.make.api.ConfigComponent
29 import org.make.core.user.UserType
30 
31 import scala.annotation.meta.field
32 import scala.concurrent.Future
33 
34 trait StorageService {
35 
36   def uploadImage(fileType: FileType, name: String, contentType: String, content: Content): Future[String]
37   def uploadUserAvatar(name: String, contentType: String, content: Content): Future[String]
38   def uploadAdminUserAvatar(
39     extension: String,
40     contentType: String,
41     content: Content,
42     userType: UserType
43   ): Future[String]
44   def uploadReport(fileType: FileType, name: String, contentType: String, content: Content): Future[String]
45 }
46 
47 final case class UploadResponse(
48   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/path/to/image.png", required = true)
49   path: String
50 )
51 
52 object UploadResponse {
53   implicit val encoder: Encoder[UploadResponse] = deriveEncoder[UploadResponse]
54   implicit val decoder: Decoder[UploadResponse] = deriveDecoder[UploadResponse]
55 }
56 
57 sealed trait FileType {
58   def name: String
59   def path: String
60 }
61 
62 object FileType {
63 
64   // Use this file type for logos and avatars
65   case object Avatar extends FileType {
66     override def name: String = "Avatar"
67     override def path: String = "avatars"
68   }
69 
70   // Use this file type for the images related to operations, on home page or operation page
71   case object Operation extends FileType {
72     override def name: String = "Operation"
73     override def path: String = "content/operations"
74   }
75 
76   case object Home extends FileType {
77     override def name: String = "Home"
78     override def path: String = "content/home"
79   }
80 
81   case object Report extends FileType {
82     override def name: String = "Report"
83     override def path: String = "consultations"
84   }
85 }
86 
87 trait Content {
88   def toByteArray(): Array[Byte]
89 }
90 
91 object Content {
92   @SuppressWarnings(Array("org.wartremover.warts.ArrayEquals"))
93   final case class ByteArrayContent(content: Array[Byte]) extends Content {
94     override def toByteArray(): Array[Byte] = content
95   }
96 
97   // *Blocking* implementation of reading files
98   final case class InputStreamContent(content: InputStream) extends Content {
99     @SuppressWarnings(Array("org.wartremover.warts.While"))
100     override def toByteArray(): Array[Byte] = {
101       val bufferSize = 2048
102       val buffer = Array.ofDim[Byte](bufferSize)
103       val output = new ByteArrayOutputStream()
104       while ({
105         val readBytes = content.read(buffer)
106         if (readBytes != -1) {
107           output.write(buffer, 0, readBytes)
108         }
109         readBytes != -1
110       }) {}
111 
112       output.toByteArray
113     }
114   }
115 
116   final case class FileContent(content: File) extends Content {
117     override def toByteArray(): Array[Byte] = InputStreamContent(new FileInputStream(content)).toByteArray()
118   }
119 
120   // *Blocking* implementation of retrieving files from URL
121   final case class UrlContent(content: URL) extends Content {
122     override def toByteArray(): Array[Byte] = {
123       InputStreamContent(content.openStream()).toByteArray()
124     }
125   }
126 
127 }
128 
129 trait StorageServiceComponent {
130   def storageService: StorageService
131 }
132 
133 final case class StorageConfiguration(bucketName: String, reportBucketName: String, baseUrl: String, maxFileSize: Long)
134 
135 trait StorageConfigurationComponent {
136   def storageConfiguration: StorageConfiguration
137 }
138 
139 trait DefaultStorageConfigurationComponent extends StorageConfigurationComponent {
140   self: ConfigComponent =>
141 
142   override lazy val storageConfiguration: StorageConfiguration = {
143     val configuration = config.getConfig("make-api.storage")
144     StorageConfiguration(
145       bucketName = configuration.getString("bucket-name"),
146       reportBucketName = configuration.getString("report-bucket-name"),
147       baseUrl = configuration.getString("base-url"),
148       maxFileSize = configuration.getLong("max-upload-file-size")
149     )
150   }
151 }