add video list, get and upload apis

Author: attacomsian

src/main/java/com/streaming/Application.java

@@ -1,11 +1,16 @@
 package com.streaming;
 
+import com.streaming.services.FileStorageProperties;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.context.annotation.Bean;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 
 @SpringBootApplication
+@EnableConfigurationProperties({
+		FileStorageProperties.class
+})
 public class Application {
 
 	@Bean

src/main/java/com/streaming/controllers/UserController.java

@@ -4,9 +4,12 @@
 import com.streaming.repositories.UserRepository;
 import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import java.util.Date;
+
 @RestController
 @RequestMapping("/users")
 public class UserController {
@@ -21,8 +24,10 @@ public UserController(UserRepository userRepository,
     }
 
     @PostMapping("/sign-up")
-    public void signUp(String username, String password) {
-        User user = new User(username, bCryptPasswordEncoder.encode(password));
+    public void signUp(@RequestBody User user) {
+        user.setPassword(bCryptPasswordEncoder.encode(user.getPassword()));
+        user.setCreated(new Date());
+        user.setModified(new Date());
         userRepository.save(user);
     }
 }

src/main/java/com/streaming/controllers/VideoController.java

@@ -1,28 +1,93 @@
 package com.streaming.controllers;
 
+import com.streaming.domains.User;
 import com.streaming.domains.Video;
+import com.streaming.repositories.UserRepository;
 import com.streaming.repositories.VideoRepository;
-import org.springframework.web.bind.annotation.PostMapping;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RestController;
+import com.streaming.services.FileStorageService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.Resource;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
 
+import javax.servlet.http.HttpServletRequest;
+import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Optional;
 
 @RestController
 @RequestMapping("/videos")
 public class VideoController {
 
+    private static final Logger logger = LoggerFactory.getLogger(VideoController.class);
+
     private VideoRepository videoRepository;
+    private UserRepository userRepository;
+    private FileStorageService fileStorageService;
 
-    public VideoController(VideoRepository videoRepository) {
+    public VideoController(VideoRepository videoRepository,
+                           UserRepository userRepository,
+                           FileStorageService fileStorageService) {
         this.videoRepository = videoRepository;
+        this.userRepository = userRepository;
+        this.fileStorageService = fileStorageService;
     }
 
-    @PostMapping("/list")
+    @GetMapping("/list")
     public List<Video> listVideos() {
-        List<Video> list = new ArrayList<>();
-       videoRepository.findAll().forEach(list::add);
-       return list;
+        return videoRepository.findByUserUsername(SecurityContextHolder.getContext().getAuthentication().getName());
+    }
+
+    @PostMapping("/upload")
+    public Video uploadVideo(@RequestParam("file") MultipartFile file, String title) {
+        //store video file on the server
+        String fileName = fileStorageService.storeFile(file);
+
+        //load user details
+        User user = userRepository.findByUsername(SecurityContextHolder.getContext().getAuthentication().getName());
+
+        //create a new video object
+        Video video = new Video(user, title, file.getSize(), fileName);
+        videoRepository.save(video);
+
+        //return video object
+        return video;
+    }
+
+    @GetMapping("/get/{id:.+}")
+    public Video getVideo(@PathVariable Long id) {
+        Optional<Video> video = videoRepository.findById(id);
+        return video.isPresent() ? video.get() : null;
+    }
+
+    @GetMapping("/download/{fileName:.+}")
+    public ResponseEntity<Resource> downloadFile(@PathVariable String fileName, HttpServletRequest request) {
+        // Load file as Resource
+        Resource resource = fileStorageService.loadFileAsResource(fileName);
+
+        // try to find file's content type
+        String contentType = null;
+        try {
+            contentType = request.getServletContext().getMimeType(resource.getFile().getAbsolutePath());
+        } catch (IOException ex) {
+            logger.info("Could not determine file type.");
+        }
+
+        // fallback content type
+        if (contentType == null) {
+            contentType = "application/octet-stream";
+        }
+
+        return ResponseEntity.ok()
+                .contentType(MediaType.parseMediaType(contentType))
+                .header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=\"" + resource.getFilename() + "\"")
+                .body(resource);
     }
 }

src/main/java/com/streaming/exceptions/FileStorageException.java

@@ -0,0 +1,11 @@
+package com.streaming.exceptions;
+
+public class FileStorageException extends RuntimeException {
+    public FileStorageException(String message) {
+        super(message);
+    }
+
+    public FileStorageException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/com/streaming/exceptions/MyFileNotFoundException.java

@@ -0,0 +1,15 @@
+package com.streaming.exceptions;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.ResponseStatus;
+
+@ResponseStatus(HttpStatus.NOT_FOUND)
+public class MyFileNotFoundException extends RuntimeException {
+    public MyFileNotFoundException(String message) {
+        super(message);
+    }
+
+    public MyFileNotFoundException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}

src/main/java/com/streaming/repositories/VideoRepository.java

@@ -3,5 +3,8 @@
 import com.streaming.domains.Video;
 import org.springframework.data.repository.PagingAndSortingRepository;
 
+import java.util.List;
+
 public interface VideoRepository extends PagingAndSortingRepository<Video, Long> {
+    List<Video> findByUserUsername(String user);
 }

src/main/java/com/streaming/security/JWTAuthenticationFilter.java

@@ -2,11 +2,11 @@
 
 import com.auth0.jwt.JWT;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.streaming.domains.User;
 import org.springframework.security.authentication.AuthenticationManager;
 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
 import org.springframework.security.core.Authentication;
 import org.springframework.security.core.AuthenticationException;
-import org.springframework.security.core.userdetails.User;
 import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 
 import javax.servlet.FilterChain;
@@ -52,7 +52,7 @@ protected void successfulAuthentication(HttpServletRequest req,
                                             Authentication auth) throws IOException, ServletException {
 
         String token = JWT.create()
-                .withSubject(((User) auth.getPrincipal()).getUsername())
+                .withSubject(((org.springframework.security.core.userdetails.User) auth.getPrincipal()).getUsername())
                 .withExpiresAt(new Date(System.currentTimeMillis() + EXPIRATION_TIME))
                 .sign(HMAC512(SECRET.getBytes()));
         res.addHeader(HEADER_STRING, TOKEN_PREFIX + token);

src/main/java/com/streaming/services/FileStorageProperties.java

@@ -0,0 +1,16 @@
+package com.streaming.services;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+@ConfigurationProperties(prefix = "file")
+public class FileStorageProperties {
+    private String uploadDir;
+
+    public String getUploadDir() {
+        return uploadDir;
+    }
+
+    public void setUploadDir(String uploadDir) {
+        this.uploadDir = uploadDir;
+    }
+}

src/main/java/com/streaming/services/FileStorageService.java

@@ -0,0 +1,69 @@
+package com.streaming.services;
+
+import com.streaming.exceptions.FileStorageException;
+import com.streaming.exceptions.MyFileNotFoundException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.core.io.Resource;
+import org.springframework.core.io.UrlResource;
+import org.springframework.stereotype.Service;
+import org.springframework.util.StringUtils;
+import org.springframework.web.multipart.MultipartFile;
+
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+@Service
+public class FileStorageService {
+
+    private final Path fileStorageLocation;
+
+    @Autowired
+    public FileStorageService(FileStorageProperties fileStorageProperties) {
+        this.fileStorageLocation = Paths.get(fileStorageProperties.getUploadDir())
+                .toAbsolutePath().normalize();
+
+        try {
+            Files.createDirectories(this.fileStorageLocation);
+        } catch (Exception ex) {
+            throw new FileStorageException("Could not create the directory where the uploaded files will be stored.", ex);
+        }
+    }
+
+    public String storeFile(MultipartFile file) {
+        // Normalize file name
+        String fileName = StringUtils.cleanPath(file.getOriginalFilename());
+
+        try {
+            // Check if the file's name contains invalid characters
+            if (fileName.contains("..")) {
+                throw new FileStorageException("Sorry! Filename contains invalid path sequence " + fileName);
+            }
+
+            // Copy file to the target location (Replacing existing file with the same name)
+            Path targetLocation = this.fileStorageLocation.resolve(fileName);
+            Files.copy(file.getInputStream(), targetLocation, StandardCopyOption.REPLACE_EXISTING);
+
+            return fileName;
+        } catch (IOException ex) {
+            throw new FileStorageException("Could not store file " + fileName + ". Please try again!", ex);
+        }
+    }
+
+    public Resource loadFileAsResource(String fileName) {
+        try {
+            Path filePath = this.fileStorageLocation.resolve(fileName).normalize();
+            Resource resource = new UrlResource(filePath.toUri());
+            if (resource.exists()) {
+                return resource;
+            } else {
+                throw new MyFileNotFoundException("File not found " + fileName);
+            }
+        } catch (MalformedURLException ex) {
+            throw new MyFileNotFoundException("File not found " + fileName, ex);
+        }
+    }
+}

src/main/resources/application.properties

@@ -3,3 +3,15 @@ spring.datasource.url=jdbc:mysql://localhost/live-streaming?useUnicode=true&char
 spring.datasource.username=root
 spring.datasource.password=
 spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+
+## MULTIPART (MultipartProperties)
+# Enable multipart uploads
+spring.servlet.multipart.enabled=true
+# Threshold after which files are written to disk.
+spring.servlet.multipart.file-size-threshold=2KB
+# Max file size.
+spring.servlet.multipart.max-file-size=200MB
+# Max Request Size
+spring.servlet.multipart.max-request-size=215MB
+## File Storage Properties
+file.upload-dir=./uploads