Gallardo7761/miarma-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add: full basic Huertos functionality

Browse Source
This commit is contained in:
Jose
2026-01-21 11:03:15 +01:00
parent 21281b10cc
commit e95d5a0793
69 changed files with 1683 additions and 257 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
core/src/main/java/net/miarma/backend/core/CoreApplication.java
View File

@@ -1,9 +1,14 @@
package net.miarma.backend.core;
import net.miarma.backlib.config.SecurityCommonConfig;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Import;
@SpringBootApplication
@SpringBootApplication(scanBasePackages = {
"net.miarma.backend.core",
"net.miarma.backlib"
})
public class CoreApplication {
public static void main(String[] args) {
SpringApplication.run(CoreApplication.class, args);

2
core/src/main/java/net/miarma/backend/core/config/SecurityConfig.java
View File

@@ -30,7 +30,7 @@ public class SecurityConfig {
.csrf(csrf -> csrf.disable())
.sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
.authorizeHttpRequests(auth -> auth
.requestMatchers("/auth/**").permitAll()
.requestMatchers("/auth/**", "/screenshot").permitAll()
.anyRequest().authenticated()
);

13
core/src/main/java/net/miarma/backend/core/config/WebClientConfig.java Normal file
View File

@@ -0,0 +1,13 @@
package net.miarma.backend.core.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.reactive.function.client.WebClient;
@Configuration
public class WebClientConfig {
@Bean
public WebClient.Builder webClientBuilder() {
return WebClient.builder();
}
}

8
core/src/main/java/net/miarma/backend/core/controller/AuthController.java
View File

@@ -41,7 +41,9 @@ public class AuthController {
@PostMapping("/login")
public ResponseEntity<LoginResponse> login(@Valid @RequestBody LoginRequest request) {
LoginResponse response = authService.login(request);
return ResponseEntity.ok(response);
return ResponseEntity.ok(
new LoginResponse(response.token(), response.user(), response.account())
);
}
@PostMapping("/register")
@@ -90,13 +92,13 @@ public class AuthController {
Credential cred = credentialService.getByUserId(userId)
.stream()
.filter(c -> c.getServiceId().equals(request.getServiceId()))
.filter(c -> c.getServiceId().equals(request.serviceId()))
.findFirst().get();
if (cred == null) {
return ResponseEntity.status(404).body("Credential not found");
}
if (!passwordEncoder.matches(request.getOldPassword(), cred.getPassword())) {
if (!passwordEncoder.matches(request.oldPassword(), cred.getPassword())) {
return ResponseEntity.status(400).body("Old password is incorrect");
}

38
core/src/main/java/net/miarma/backend/core/controller/CredentialController.java
View File

@@ -3,21 +3,15 @@ package net.miarma.backend.core.controller;
import java.util.List;
import java.util.UUID;
import net.miarma.backlib.dto.ChangeRoleRequest;
import net.miarma.backlib.dto.ChangeStatusRequest;
import net.miarma.backend.core.mapper.CredentialMapper;
import net.miarma.backend.core.mapper.UserMapper;
import net.miarma.backlib.dto.*;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import net.miarma.backend.core.model.Credential;
import net.miarma.backend.core.service.CredentialService;
import net.miarma.backlib.dto.CredentialDto;
@RestController
@RequestMapping("/credentials")
@@ -35,6 +29,16 @@ public class CredentialController {
return ResponseEntity.ok(credentialService.getAll());
}
@PostMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<CredentialDto> create(@RequestBody CreateCredentialDto dto) {
return ResponseEntity.ok(
CredentialMapper.toDto(
credentialService.create(
CredentialMapper.toEntity(dto)))
);
}
@GetMapping("/user/{userId}")
@PreAuthorize("hasRole('ADMIN') or #userId == authentication.principal.userId")
public ResponseEntity<List<Credential>> getByUserId(@PathVariable("userId") UUID userId) {
@@ -77,18 +81,4 @@ public class CredentialController {
credentialService.updateStatus(credentialId, req.status());
return ResponseEntity.noContent().build();
}
@GetMapping("/{credential_id}/role")
public ResponseEntity<Byte> getRole(@PathVariable("credential_id") UUID credentialId) {
return ResponseEntity.ok(credentialService.getRole(credentialId));
}
@PutMapping("/{credential_id}/role")
public ResponseEntity<Void> updateRole(
@PathVariable("credential_id") UUID credentialId,
@RequestBody ChangeRoleRequest req
) {
credentialService.updateRole(credentialId, req.role());
return ResponseEntity.noContent().build();
}
}

30
core/src/main/java/net/miarma/backend/core/controller/FileController.java
View File

@@ -7,6 +7,8 @@ import java.util.List;
import java.util.Map;
import java.util.UUID;
import net.miarma.backend.core.mapper.FileMapper;
import net.miarma.backlib.dto.FileDto;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
@@ -37,40 +39,40 @@ public class FileController {
@GetMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<List<File>> getAll(@RequestParam Map<String,String> params) {
List<File> files = fileService.getAll(params);
public ResponseEntity<List<File>> getAll() {
List<File> files = fileService.getAll();
return ResponseEntity.ok(files);
}
@GetMapping("/{fileId}")
@PreAuthorize("hasRole('ADMIN') or @fileService.isOwner(#fileId, authentication.principal.userId)")
public ResponseEntity<File> getById(@PathVariable UUID fileId) {
public ResponseEntity<File> getById(@PathVariable("file_id") UUID fileId) {
File file = fileService.getById(fileId);
return ResponseEntity.ok(file);
}
@PostMapping
@PreAuthorize("hasRole('ADMIN') or #uploadedBy == authentication.principal.userId")
public ResponseEntity<File> create(
public ResponseEntity<FileDto.Response> create(
@RequestParam String fileName,
@RequestParam String mimeType,
@RequestParam UUID uploadedBy,
@RequestParam Byte context,
@RequestPart("file") MultipartFile file
) throws IOException {
File entity = new File();
entity.setFileName(fileName);
entity.setMimeType(mimeType);
entity.setUploadedBy(uploadedBy);
entity.setContext(context);
FileDto.Request dto = new FileDto.Request();
dto.setFileName(fileName);
dto.setMimeType(mimeType);
dto.setUploadedBy(uploadedBy);
dto.setContext(context);
File created = fileService.create(entity, file.getBytes());
return ResponseEntity.status(HttpStatus.CREATED).body(created);
File created = fileService.create(dto, file.getBytes());
return ResponseEntity.status(HttpStatus.CREATED).body(FileMapper.toResponse(created));
}
@PutMapping("/{fileId}")
@PreAuthorize("hasRole('ADMIN') or @fileService.isOwner(#fileId, authentication.principal.userId)")
public ResponseEntity<File> update(@PathVariable UUID fileId, @RequestBody File file) {
public ResponseEntity<File> update(@PathVariable("file_id") UUID fileId, @RequestBody File file) {
file.setFileId(fileId);
File updated = fileService.update(file);
return ResponseEntity.ok(updated);
@@ -78,10 +80,10 @@ public class FileController {
@DeleteMapping("/{fileId}")
@PreAuthorize("hasRole('ADMIN') or @fileService.isOwner(#fileId, authentication.principal.userId)")
public ResponseEntity<Void> delete(@PathVariable UUID fileId, @RequestBody Map<String,String> body) throws IOException {
public ResponseEntity<Void> delete(@PathVariable("file_id") UUID fileId, @RequestBody Map<String,String> body) throws IOException {
String filePath = body.get("file_path");
Files.deleteIfExists(Paths.get(filePath));
fileService.delete(fileId);
return ResponseEntity.noContent().build();
return ResponseEntity.ok().build();
}
}

74
core/src/main/java/net/miarma/backend/core/controller/UserController.java
View File

@@ -3,38 +3,34 @@ package net.miarma.backend.core.controller;
import java.util.List;
import java.util.UUID;
import net.miarma.backlib.dto.ChangeRoleRequest;
import net.miarma.backlib.dto.ChangeAvatarRequest;
import net.miarma.backlib.dto.ChangeStatusRequest;
import net.miarma.backlib.dto.UserExistsResponse;
import net.miarma.backend.core.mapper.CredentialMapper;
import net.miarma.backend.core.model.Credential;
import net.miarma.backend.core.service.CredentialService;
import net.miarma.backlib.dto.*;
import org.apache.coyote.Response;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import net.miarma.backend.core.mapper.UserMapper;
import net.miarma.backend.core.model.User;
import net.miarma.backlib.security.JwtService;
import net.miarma.backend.core.service.UserService;
import net.miarma.backlib.dto.UserDto;
@RestController
@RequestMapping("/users")
public class UserController {
private UserService userService;
private CredentialService credentialService;
private JwtService jwtService;
public UserController(UserService userService, JwtService jwtService) {
public UserController(UserService userService, CredentialService credentialService, JwtService jwtService) {
this.userService = userService;
this.credentialService = credentialService;
this.jwtService = jwtService;
}
@GetMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<List<UserDto>> getAll() {
@@ -45,13 +41,54 @@ public class UserController {
.toList()
);
}
@PostMapping
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<UserDto> create(@RequestBody UserDto dto) {
return ResponseEntity.ok(
UserMapper.toDto(userService.create(dto))
);
}
@GetMapping("/{user_id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<UserDto> getById(@PathVariable("user_id") UUID userId) {
User user = userService.getById(userId);
return ResponseEntity.ok(UserMapper.toDto(user));
}
@GetMapping("/service/{service_id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<List<UserWithCredentialDto>> getAllWithCredentials(
@PathVariable("service_id") Byte serviceId
) {
List<Credential> credentials = credentialService.getByServiceIdFetchUser(serviceId);
List<UserWithCredentialDto> result = credentials.stream()
.map(cred -> new UserWithCredentialDto(
UserMapper.toDto(cred.getUser()),
CredentialMapper.toDto(cred)
))
.toList();
return ResponseEntity.ok(result);
}
@GetMapping("/{user_id}/service/{service_id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<UserWithCredentialDto> getByIdWithCredentials(
@PathVariable("user_id") UUID userId,
@PathVariable("service_id") Byte serviceId
) {
User user = userService.getById(userId);
Credential credential = credentialService.getByUserIdAndService(userId, serviceId);
return ResponseEntity.ok(
UserMapper.toDtoWithCredentials(
UserMapper.toDto(user),
CredentialMapper.toDto(credential)
)
);
}
@PutMapping("/{user_id}")
@PreAuthorize("hasRole('ADMIN') or #userId == principal.userId")
@@ -121,4 +158,11 @@ public class UserController {
User user = userService.getById(userId);
return ResponseEntity.ok(UserMapper.toDto(user));
}
@DeleteMapping("/{user_id}")
@PreAuthorize("hasRole('ADMIN')")
public ResponseEntity<Void> delete(@PathVariable("user_id") UUID userId) {
userService.delete(userId);
return ResponseEntity.ok().build();
}
}

62
core/src/main/java/net/miarma/backend/core/mapper/CredentialMapper.java
View File

@@ -1,22 +1,68 @@
package net.miarma.backend.core.mapper;
import net.miarma.backend.core.model.Credential;
import net.miarma.backlib.dto.CreateCredentialDto;
import net.miarma.backlib.dto.CredentialDto;
import java.util.UUID;
public class CredentialMapper {
public static CredentialDto toDto(Credential c) {
if (c == null) return null;
return new CredentialDto(
c.getCredentialId(),
c.getUserId(),
c.getServiceId(),
c.getUsername(),
c.getEmail(),
c.getStatus(),
c.getCreatedAt(),
c.getUpdatedAt()
c.getCredentialId(),
c.getUserId(),
c.getServiceId(),
c.getUsername(),
c.getEmail(),
c.getStatus(),
c.getCreatedAt(),
c.getUpdatedAt()
);
}
public static CreateCredentialDto toCreateDto(Credential c) {
if (c == null) return null;
return new CreateCredentialDto(
c.getUserId(),
c.getServiceId(),
c.getUsername(),
c.getEmail(),
c.getPassword(),
c.getStatus()
);
}
public static Credential toEntity(CredentialDto dto) {
if (dto == null) return null;
Credential c = new Credential();
c.setCredentialId(dto.getCredentialId());
c.setUserId(dto.getUserId());
c.setServiceId(dto.getServiceId());
c.setUsername(dto.getUsername());
c.setEmail(dto.getEmail());
c.setStatus(dto.getStatus());
c.setCreatedAt(dto.getCreatedAt());
c.setUpdatedAt(dto.getUpdatedAt());
return c;
}
public static Credential toEntity(CreateCredentialDto dto) {
if (dto == null) return null;
Credential c = new Credential();
c.setUserId(dto.getUserId());
c.setServiceId(dto.getServiceId());
c.setUsername(dto.getUsername());
c.setEmail(dto.getEmail());
c.setPassword(dto.getPassword());
c.setStatus(dto.getStatus());
return c;
}
}

38
core/src/main/java/net/miarma/backend/core/mapper/FileMapper.java Normal file
View File

@@ -0,0 +1,38 @@
package net.miarma.backend.core.mapper;
import net.miarma.backend.core.model.File;
import net.miarma.backlib.dto.FileDto;
import java.time.Instant;
import java.util.UUID;
public class FileMapper {
private FileMapper() {}
public static FileDto.Response toResponse(File file) {
FileDto.Response res = new FileDto.Response();
res.setFileId(file.getFileId());
res.setFileName(file.getFileName());
res.setFilePath(file.getFilePath());
res.setMimeType(file.getMimeType());
res.setUploadedBy(file.getUploadedBy());
res.setUploadedAt(file.getUploadedAt());
res.setContext(file.getContext());
return res;
}
public static File toEntity(FileDto.Request req) {
File file = new File();
file.setFileId(UUID.randomUUID());
file.setFileName(req.getFileName());
file.setFilePath(req.getFilePath());
file.setMimeType(req.getMimeType());
file.setUploadedBy(req.getUploadedBy());
file.setContext(req.getContext());
return file;
}
}

8
core/src/main/java/net/miarma/backend/core/mapper/UserMapper.java
View File

@@ -1,7 +1,9 @@
package net.miarma.backend.core.mapper;
import net.miarma.backend.core.model.User;
import net.miarma.backlib.dto.CredentialDto;
import net.miarma.backlib.dto.UserDto;
import net.miarma.backlib.dto.UserWithCredentialDto;
public class UserMapper {
public static UserDto toDto(User u) {
@@ -17,4 +19,10 @@ public class UserMapper {
u.getUpdatedAt()
);
}
public static UserWithCredentialDto toDtoWithCredentials(UserDto user, CredentialDto account){
if (user == null || account == null) return null;
return new UserWithCredentialDto(user, account);
}
}

11
core/src/main/java/net/miarma/backend/core/model/Credential.java
View File

@@ -50,8 +50,7 @@ public class Credential {
private String email;
private String password;
private Byte status;
private Byte role;
@CreationTimestamp
private Instant createdAt;
@@ -84,10 +83,6 @@ public class Credential {
}
public UUID getCredentialId() {
if (credentialId == null && credentialIdBin != null) {
ByteBuffer bb = ByteBuffer.wrap(credentialIdBin);
credentialId = new UUID(bb.getLong(), bb.getLong());
}
return credentialId;
}
@@ -143,10 +138,6 @@ public class Credential {
this.status = status;
}
public Byte getRole() { return role; }
public void setRole(Byte role) { this.role = role; }
public Instant getCreatedAt() {
return createdAt;
}

7
core/src/main/java/net/miarma/backend/core/repository/CredentialRepository.java
View File

@@ -18,9 +18,14 @@ public interface CredentialRepository extends JpaRepository<Credential, byte[]>
WHERE c.serviceId = :serviceId
AND c.username = :username
""")
Optional<Credential> findByServiceIdAndUsername(@Param("serviceId") Byte serviceId,
Optional<Credential> findByServiceIdAndUsername(@Param("serviceId") Byte serviceId,
@Param("username") String username);
List<Credential> findAllByServiceId(Byte serviceId);
@Query("SELECT c FROM Credential c JOIN FETCH c.user WHERE c.serviceId = :serviceId")
List<Credential> getByServiceIdFetchUser(@Param("serviceId") Byte serviceId);
Optional<Credential> findByServiceIdAndEmail(Byte serviceId, String email);
Optional<Credential> findByUserIdAndServiceId(UUID userId, Byte serviceId);

6
core/src/main/java/net/miarma/backend/core/security/JwtFilter.java
View File

@@ -35,9 +35,6 @@ public class JwtFilter extends OncePerRequestFilter {
protected void doFilterInternal(HttpServletRequest request,
HttpServletResponse response,
FilterChain filterChain) throws ServletException, IOException {
System.out.println("JwtFilter ejecutándose para " + request.getRequestURI());
String authHeader = request.getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
String token = authHeader.substring(7);
@@ -63,9 +60,6 @@ public class JwtFilter extends OncePerRequestFilter {
new UsernamePasswordAuthenticationToken(user, null, authorities);
SecurityContextHolder.getContext().setAuthentication(auth);
System.out.println("Granted Authorities: " +
SecurityContextHolder.getContext().getAuthentication().getAuthorities());
long timeLeft = jwtService.getExpiration(token).getTime() - System.currentTimeMillis();
if (timeLeft < refreshThreshold) {
String newToken = jwtService.generateToken(userId, serviceId);

27
core/src/main/java/net/miarma/backend/core/service/AuthService.java
View File

@@ -14,6 +14,7 @@ import net.miarma.backlib.dto.LoginRequest;
import net.miarma.backlib.dto.LoginResponse;
import net.miarma.backlib.dto.RegisterRequest;
import net.miarma.backlib.dto.UserDto;
import tools.jackson.databind.JsonNode;
@Service
public class AuthService {
@@ -32,46 +33,44 @@ public class AuthService {
}
public LoginResponse login(LoginRequest request) {
Credential cred = credentialService.getByUserIdAndService(request.getServiceId(), request.getUsername());
Credential cred = credentialService.getForLogin(request.serviceId(), request.username());
if (!passwordEncoder.matches(request.getPassword(), cred.getPassword())) {
if (!passwordEncoder.matches(request.password(), cred.getPassword())) {
throw new RuntimeException("Invalid credentials");
}
String token = jwtService.generateToken(cred.getUserId(), request.getServiceId());
String token = jwtService.generateToken(cred.getUserId(), request.serviceId());
UserDto userDto = UserMapper.toDto(cred.getUser());
CredentialDto credentialDto = CredentialMapper.toDto(cred);
return new LoginResponse(token, userDto, credentialDto);
}
public LoginResponse register(RegisterRequest request) {
if (credentialService.existsByUsernameAndService(request.getUsername(), request.getServiceId())) {
if (credentialService.existsByUsernameAndService(request.username(), request.serviceId())) {
throw new RuntimeException("Username already taken");
}
User user;
try {
user = credentialService.getByEmail(request.getEmail());
user = credentialService.getByEmail(request.email());
} catch (RuntimeException e) {
UserDto dto = new UserDto();
dto.userId(UUID.randomUUID());
dto.setDisplayName(request.getDisplayName());
dto.setUserId(UUID.randomUUID());
dto.setDisplayName(request.displayName());
user = userService.create(dto);
}
Credential cred = new Credential();
cred.setCredentialId(UUID.randomUUID());
cred.setUser(user);
cred.setServiceId((byte) request.getServiceId());
cred.setUsername(request.getUsername());
cred.setEmail(request.getEmail());
cred.setPassword(passwordEncoder.encode(request.getPassword()));
cred.setServiceId(request.serviceId());
cred.setUsername(request.username());
cred.setEmail(request.email());
cred.setPassword(passwordEncoder.encode(request.password()));
credentialService.create(cred);
String token = jwtService.generateToken(user.getUserId(), request.getServiceId());
String token = jwtService.generateToken(user.getUserId(), request.serviceId());
return new LoginResponse(token, UserMapper.toDto(user), CredentialMapper.toDto(cred));
}

29
core/src/main/java/net/miarma/backend/core/service/CredentialService.java
View File

@@ -54,14 +54,23 @@ public class CredentialService {
credential.getEmail(), credential.getServiceId());
if (existsEmail) throw new IllegalArgumentException("Email already exists for this service");
credential.setCredentialId(UUID.randomUUID());
credential.setPassword(passwordEncoder.encode(credential.getPassword()));
return credentialRepository.save(credential);
}
public List<Credential> getAll() {
return credentialRepository.findAll();
}
public List<Credential> getByServiceId(Byte serviceId) {
return credentialRepository.findAllByServiceId(serviceId);
}
public List<Credential> getByServiceIdFetchUser(Byte serviceId) {
return credentialRepository.getByServiceIdFetchUser(serviceId);
}
public List<Credential> getByUserId(UUID userId) {
List<Credential> creds = credentialRepository.findByUserId(UuidUtil.uuidToBin(userId));
if (creds.isEmpty()) {
@@ -76,8 +85,8 @@ public class CredentialService {
.getUser();
}
public Credential getByUserIdAndService(Byte serviceId, String username) {
return credentialRepository.findByServiceIdAndUsername(serviceId, username)
public Credential getByUserIdAndService(UUID userId, Byte serviceId) {
return credentialRepository.findByUserIdAndServiceId(userId, serviceId)
.orElseThrow(() -> new RuntimeException("Credential not found in this site"));
}
@@ -154,18 +163,4 @@ public class CredentialService {
credential.setStatus(status);
credentialRepository.save(credential);
}
public Byte getRole(UUID credentialId) {
Credential credential = credentialRepository.findById(UuidUtil.uuidToBin(credentialId))
.orElseThrow(() -> new RuntimeException("User not found"));;
return credential.getRole();
}
public void updateRole(UUID credentialId, Byte role) {
Credential credential = credentialRepository.findById(UuidUtil.uuidToBin(credentialId))
.orElseThrow(() -> new RuntimeException("User not found"));;
credential.setRole(role);
credentialRepository.save(credential);
}
}

22
core/src/main/java/net/miarma/backend/core/service/FileService.java
View File

@@ -9,6 +9,8 @@ import java.util.List;
import java.util.Map;
import java.util.UUID;
import net.miarma.backend.core.mapper.FileMapper;
import net.miarma.backlib.dto.FileDto;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@@ -33,15 +35,7 @@ public class FileService {
.orElseThrow(() -> new RuntimeException("File not found"));
}
public List<File> getAll(Map<String,String> params) {
if (params.containsKey("userId")) {
UUID userId = UUID.fromString(params.get("userId"));
return fileRepository.findByUploadedBy(userId);
}
if (params.containsKey("context")) {
Byte context = Byte.parseByte(params.get("context"));
return fileRepository.findByContext(context);
}
public List<File> getAll() {
return fileRepository.findAll();
}
@@ -49,20 +43,20 @@ public class FileService {
return fileRepository.findByUploadedBy(userId);
}
public File create(File file, byte[] fileBinary) throws IOException {
Path dirPath = Paths.get(basePath, String.valueOf(file.getContext()));
public File create(FileDto.Request dto, byte[] fileBinary) throws IOException {
Path dirPath = Paths.get(basePath, String.valueOf(dto.getContext()));
if (!Files.exists(dirPath)) {
Files.createDirectories(dirPath);
}
Path filePath = dirPath.resolve(file.getFileName());
Path filePath = dirPath.resolve(dto.getFileName());
try (FileOutputStream fos = new FileOutputStream(filePath.toFile())) {
fos.write(fileBinary);
}
file.setFilePath(filePath.toString());
dto.setFilePath(filePath.toString());
return fileRepository.save(file);
return fileRepository.save(FileMapper.toEntity(dto));
}
public File update(File file) {