446 lines
17 KiB
Bash
Executable File
446 lines
17 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
# Generate remaining backend files
|
|
|
|
BASE="/home/claude/ldpv2-monorepo/backend/src/main/java/com/ldpv2"
|
|
|
|
# ============= EXCEPTIONS =============
|
|
cat > "$BASE/exception/ResourceNotFoundException.java" << 'JAVA'
|
|
package com.ldpv2.exception;
|
|
|
|
public class ResourceNotFoundException extends RuntimeException {
|
|
public ResourceNotFoundException(String message) {
|
|
super(message);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
cat > "$BASE/exception/BadRequestException.java" << 'JAVA'
|
|
package com.ldpv2.exception;
|
|
|
|
public class BadRequestException extends RuntimeException {
|
|
public BadRequestException(String message) {
|
|
super(message);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
cat > "$BASE/exception/GlobalExceptionHandler.java" << 'JAVA'
|
|
package com.ldpv2.exception;
|
|
|
|
import org.springframework.http.HttpStatus;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.security.authentication.BadCredentialsException;
|
|
import org.springframework.validation.FieldError;
|
|
import org.springframework.web.bind.MethodArgumentNotValidException;
|
|
import org.springframework.web.bind.annotation.ExceptionHandler;
|
|
import org.springframework.web.bind.annotation.RestControllerAdvice;
|
|
|
|
import java.time.LocalDateTime;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
|
|
@RestControllerAdvice
|
|
public class GlobalExceptionHandler {
|
|
|
|
@ExceptionHandler(ResourceNotFoundException.class)
|
|
public ResponseEntity<Map<String, Object>> handleResourceNotFound(ResourceNotFoundException ex) {
|
|
Map<String, Object> error = new HashMap<>();
|
|
error.put("timestamp", LocalDateTime.now());
|
|
error.put("status", HttpStatus.NOT_FOUND.value());
|
|
error.put("message", ex.getMessage());
|
|
return new ResponseEntity<>(error, HttpStatus.NOT_FOUND);
|
|
}
|
|
|
|
@ExceptionHandler(BadRequestException.class)
|
|
public ResponseEntity<Map<String, Object>> handleBadRequest(BadRequestException ex) {
|
|
Map<String, Object> error = new HashMap<>();
|
|
error.put("timestamp", LocalDateTime.now());
|
|
error.put("status", HttpStatus.BAD_REQUEST.value());
|
|
error.put("message", ex.getMessage());
|
|
return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
|
|
}
|
|
|
|
@ExceptionHandler(MethodArgumentNotValidException.class)
|
|
public ResponseEntity<Map<String, Object>> handleValidationExceptions(MethodArgumentNotValidException ex) {
|
|
Map<String, String> errors = new HashMap<>();
|
|
ex.getBindingResult().getAllErrors().forEach((error) -> {
|
|
String fieldName = ((FieldError) error).getField();
|
|
String errorMessage = error.getDefaultMessage();
|
|
errors.put(fieldName, errorMessage);
|
|
});
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
response.put("timestamp", LocalDateTime.now());
|
|
response.put("status", HttpStatus.BAD_REQUEST.value());
|
|
response.put("message", "Validation failed");
|
|
response.put("errors", errors);
|
|
|
|
return new ResponseEntity<>(response, HttpStatus.BAD_REQUEST);
|
|
}
|
|
|
|
@ExceptionHandler(BadCredentialsException.class)
|
|
public ResponseEntity<Map<String, Object>> handleBadCredentials(BadCredentialsException ex) {
|
|
Map<String, Object> error = new HashMap<>();
|
|
error.put("timestamp", LocalDateTime.now());
|
|
error.put("status", HttpStatus.UNAUTHORIZED.value());
|
|
error.put("message", "Invalid username or password");
|
|
return new ResponseEntity<>(error, HttpStatus.UNAUTHORIZED);
|
|
}
|
|
|
|
@ExceptionHandler(Exception.class)
|
|
public ResponseEntity<Map<String, Object>> handleGlobalException(Exception ex) {
|
|
Map<String, Object> error = new HashMap<>();
|
|
error.put("timestamp", LocalDateTime.now());
|
|
error.put("status", HttpStatus.INTERNAL_SERVER_ERROR.value());
|
|
error.put("message", "An unexpected error occurred");
|
|
error.put("details", ex.getMessage());
|
|
return new ResponseEntity<>(error, HttpStatus.INTERNAL_SERVER_ERROR);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
echo "Exception handlers created"
|
|
|
|
# ============= SERVICES =============
|
|
|
|
cat > "$BASE/service/AuthService.java" << 'JAVA'
|
|
package com.ldpv2.service;
|
|
|
|
import com.ldpv2.domain.entity.User;
|
|
import com.ldpv2.dto.request.LoginRequest;
|
|
import com.ldpv2.dto.request.RegisterRequest;
|
|
import com.ldpv2.dto.response.AuthResponse;
|
|
import com.ldpv2.dto.response.UserResponse;
|
|
import com.ldpv2.exception.BadRequestException;
|
|
import com.ldpv2.repository.UserRepository;
|
|
import com.ldpv2.security.JwtTokenProvider;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.security.authentication.AuthenticationManager;
|
|
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
|
|
import org.springframework.security.core.Authentication;
|
|
import org.springframework.security.core.context.SecurityContextHolder;
|
|
import org.springframework.security.crypto.password.PasswordEncoder;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
@Service
|
|
public class AuthService {
|
|
|
|
@Autowired
|
|
private UserRepository userRepository;
|
|
|
|
@Autowired
|
|
private PasswordEncoder passwordEncoder;
|
|
|
|
@Autowired
|
|
private AuthenticationManager authenticationManager;
|
|
|
|
@Autowired
|
|
private JwtTokenProvider tokenProvider;
|
|
|
|
@Transactional
|
|
public AuthResponse register(RegisterRequest request) {
|
|
// Check if username exists
|
|
if (userRepository.existsByUsername(request.getUsername())) {
|
|
throw new BadRequestException("Username already exists");
|
|
}
|
|
|
|
// Check if email exists
|
|
if (userRepository.existsByEmail(request.getEmail())) {
|
|
throw new BadRequestException("Email already exists");
|
|
}
|
|
|
|
// Create new user
|
|
User user = new User();
|
|
user.setUsername(request.getUsername());
|
|
user.setEmail(request.getEmail());
|
|
user.setPassword(passwordEncoder.encode(request.getPassword()));
|
|
user.setRole("USER");
|
|
|
|
user = userRepository.save(user);
|
|
|
|
// Authenticate the user
|
|
Authentication authentication = authenticationManager.authenticate(
|
|
new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword())
|
|
);
|
|
|
|
SecurityContextHolder.getContext().setAuthentication(authentication);
|
|
String token = tokenProvider.generateToken(authentication);
|
|
|
|
return new AuthResponse(token, mapToUserResponse(user));
|
|
}
|
|
|
|
public AuthResponse login(LoginRequest request) {
|
|
Authentication authentication = authenticationManager.authenticate(
|
|
new UsernamePasswordAuthenticationToken(request.getUsername(), request.getPassword())
|
|
);
|
|
|
|
SecurityContextHolder.getContext().setAuthentication(authentication);
|
|
String token = tokenProvider.generateToken(authentication);
|
|
|
|
User user = userRepository.findByUsername(request.getUsername())
|
|
.orElseThrow(() -> new BadRequestException("User not found"));
|
|
|
|
return new AuthResponse(token, mapToUserResponse(user));
|
|
}
|
|
|
|
private UserResponse mapToUserResponse(User user) {
|
|
return new UserResponse(
|
|
user.getId(),
|
|
user.getUsername(),
|
|
user.getEmail(),
|
|
user.getRole(),
|
|
user.getCreatedAt(),
|
|
user.getUpdatedAt()
|
|
);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
cat > "$BASE/service/EnvironmentService.java" << 'JAVA'
|
|
package com.ldpv2.service;
|
|
|
|
import com.ldpv2.domain.entity.Environment;
|
|
import com.ldpv2.dto.request.CreateEnvironmentRequest;
|
|
import com.ldpv2.dto.request.UpdateEnvironmentRequest;
|
|
import com.ldpv2.dto.response.EnvironmentResponse;
|
|
import com.ldpv2.exception.BadRequestException;
|
|
import com.ldpv2.exception.ResourceNotFoundException;
|
|
import com.ldpv2.repository.EnvironmentRepository;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.domain.Page;
|
|
import org.springframework.data.domain.Pageable;
|
|
import org.springframework.stereotype.Service;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
|
|
import java.util.UUID;
|
|
|
|
@Service
|
|
public class EnvironmentService {
|
|
|
|
@Autowired
|
|
private EnvironmentRepository environmentRepository;
|
|
|
|
@Transactional
|
|
public EnvironmentResponse create(CreateEnvironmentRequest request) {
|
|
// Check if name already exists
|
|
if (environmentRepository.existsByName(request.getName())) {
|
|
throw new BadRequestException("Environment with name '" + request.getName() + "' already exists");
|
|
}
|
|
|
|
Environment environment = new Environment();
|
|
environment.setName(request.getName());
|
|
environment.setDescription(request.getDescription());
|
|
environment.setIsProduction(request.getIsProduction() != null ? request.getIsProduction() : false);
|
|
environment.setCriticalityLevel(request.getCriticalityLevel());
|
|
|
|
environment = environmentRepository.save(environment);
|
|
return mapToResponse(environment);
|
|
}
|
|
|
|
@Transactional
|
|
public EnvironmentResponse update(UUID id, UpdateEnvironmentRequest request) {
|
|
Environment environment = environmentRepository.findById(id)
|
|
.orElseThrow(() -> new ResourceNotFoundException("Environment not found with id: " + id));
|
|
|
|
// Check if new name already exists (excluding current environment)
|
|
if (request.getName() != null && !request.getName().equals(environment.getName())) {
|
|
if (environmentRepository.existsByName(request.getName())) {
|
|
throw new BadRequestException("Environment with name '" + request.getName() + "' already exists");
|
|
}
|
|
environment.setName(request.getName());
|
|
}
|
|
|
|
if (request.getDescription() != null) {
|
|
environment.setDescription(request.getDescription());
|
|
}
|
|
|
|
if (request.getIsProduction() != null) {
|
|
environment.setIsProduction(request.getIsProduction());
|
|
}
|
|
|
|
if (request.getCriticalityLevel() != null) {
|
|
environment.setCriticalityLevel(request.getCriticalityLevel());
|
|
}
|
|
|
|
environment = environmentRepository.save(environment);
|
|
return mapToResponse(environment);
|
|
}
|
|
|
|
public EnvironmentResponse findById(UUID id) {
|
|
Environment environment = environmentRepository.findById(id)
|
|
.orElseThrow(() -> new ResourceNotFoundException("Environment not found with id: " + id));
|
|
return mapToResponse(environment);
|
|
}
|
|
|
|
public Page<EnvironmentResponse> findAll(Pageable pageable) {
|
|
return environmentRepository.findAll(pageable).map(this::mapToResponse);
|
|
}
|
|
|
|
public Page<EnvironmentResponse> search(String query, Pageable pageable) {
|
|
return environmentRepository.findByNameContainingIgnoreCase(query, pageable)
|
|
.map(this::mapToResponse);
|
|
}
|
|
|
|
@Transactional
|
|
public void delete(UUID id) {
|
|
if (!environmentRepository.existsById(id)) {
|
|
throw new ResourceNotFoundException("Environment not found with id: " + id);
|
|
}
|
|
environmentRepository.deleteById(id);
|
|
}
|
|
|
|
private EnvironmentResponse mapToResponse(Environment environment) {
|
|
return new EnvironmentResponse(
|
|
environment.getId(),
|
|
environment.getName(),
|
|
environment.getDescription(),
|
|
environment.getIsProduction(),
|
|
environment.getCriticalityLevel(),
|
|
environment.getCreatedAt(),
|
|
environment.getUpdatedAt()
|
|
);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
echo "Services created"
|
|
|
|
# ============= CONTROLLERS =============
|
|
|
|
cat > "$BASE/controller/AuthController.java" << 'JAVA'
|
|
package com.ldpv2.controller;
|
|
|
|
import com.ldpv2.dto.request.LoginRequest;
|
|
import com.ldpv2.dto.request.RegisterRequest;
|
|
import com.ldpv2.dto.response.AuthResponse;
|
|
import com.ldpv2.service.AuthService;
|
|
import io.swagger.v3.oas.annotations.Operation;
|
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
|
import jakarta.validation.Valid;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.http.HttpStatus;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
|
@RestController
|
|
@RequestMapping("/auth")
|
|
@Tag(name = "Authentication", description = "Authentication and registration endpoints")
|
|
public class AuthController {
|
|
|
|
@Autowired
|
|
private AuthService authService;
|
|
|
|
@PostMapping("/register")
|
|
@Operation(summary = "Register new user", description = "Create a new user account")
|
|
public ResponseEntity<AuthResponse> register(@Valid @RequestBody RegisterRequest request) {
|
|
AuthResponse response = authService.register(request);
|
|
return new ResponseEntity<>(response, HttpStatus.CREATED);
|
|
}
|
|
|
|
@PostMapping("/login")
|
|
@Operation(summary = "Login", description = "Authenticate and receive JWT token")
|
|
public ResponseEntity<AuthResponse> login(@Valid @RequestBody LoginRequest request) {
|
|
AuthResponse response = authService.login(request);
|
|
return ResponseEntity.ok(response);
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
cat > "$BASE/controller/EnvironmentController.java" << 'JAVA'
|
|
package com.ldpv2.controller;
|
|
|
|
import com.ldpv2.dto.request.CreateEnvironmentRequest;
|
|
import com.ldpv2.dto.request.UpdateEnvironmentRequest;
|
|
import com.ldpv2.dto.response.EnvironmentResponse;
|
|
import com.ldpv2.service.EnvironmentService;
|
|
import io.swagger.v3.oas.annotations.Operation;
|
|
import io.swagger.v3.oas.annotations.security.SecurityRequirement;
|
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
|
import jakarta.validation.Valid;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.data.domain.Page;
|
|
import org.springframework.data.domain.PageRequest;
|
|
import org.springframework.data.domain.Pageable;
|
|
import org.springframework.data.domain.Sort;
|
|
import org.springframework.http.HttpStatus;
|
|
import org.springframework.http.ResponseEntity;
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
|
import java.util.UUID;
|
|
|
|
@RestController
|
|
@RequestMapping("/environments")
|
|
@Tag(name = "Environments", description = "Environment management endpoints")
|
|
@SecurityRequirement(name = "bearerAuth")
|
|
public class EnvironmentController {
|
|
|
|
@Autowired
|
|
private EnvironmentService environmentService;
|
|
|
|
@PostMapping
|
|
@Operation(summary = "Create environment", description = "Create a new environment")
|
|
public ResponseEntity<EnvironmentResponse> create(@Valid @RequestBody CreateEnvironmentRequest request) {
|
|
EnvironmentResponse response = environmentService.create(request);
|
|
return new ResponseEntity<>(response, HttpStatus.CREATED);
|
|
}
|
|
|
|
@PutMapping("/{id}")
|
|
@Operation(summary = "Update environment", description = "Update an existing environment")
|
|
public ResponseEntity<EnvironmentResponse> update(
|
|
@PathVariable UUID id,
|
|
@Valid @RequestBody UpdateEnvironmentRequest request) {
|
|
EnvironmentResponse response = environmentService.update(id, request);
|
|
return ResponseEntity.ok(response);
|
|
}
|
|
|
|
@GetMapping("/{id}")
|
|
@Operation(summary = "Get environment", description = "Get environment by ID")
|
|
public ResponseEntity<EnvironmentResponse> getById(@PathVariable UUID id) {
|
|
EnvironmentResponse response = environmentService.findById(id);
|
|
return ResponseEntity.ok(response);
|
|
}
|
|
|
|
@GetMapping
|
|
@Operation(summary = "List environments", description = "Get paginated list of environments")
|
|
public ResponseEntity<Page<EnvironmentResponse>> getAll(
|
|
@RequestParam(defaultValue = "0") int page,
|
|
@RequestParam(defaultValue = "20") int size,
|
|
@RequestParam(defaultValue = "name") String sortBy,
|
|
@RequestParam(defaultValue = "asc") String sortDirection) {
|
|
|
|
Sort sort = sortDirection.equalsIgnoreCase("desc")
|
|
? Sort.by(sortBy).descending()
|
|
: Sort.by(sortBy).ascending();
|
|
|
|
Pageable pageable = PageRequest.of(page, size, sort);
|
|
Page<EnvironmentResponse> response = environmentService.findAll(pageable);
|
|
return ResponseEntity.ok(response);
|
|
}
|
|
|
|
@GetMapping("/search")
|
|
@Operation(summary = "Search environments", description = "Search environments by name")
|
|
public ResponseEntity<Page<EnvironmentResponse>> search(
|
|
@RequestParam String query,
|
|
@RequestParam(defaultValue = "0") int page,
|
|
@RequestParam(defaultValue = "20") int size) {
|
|
|
|
Pageable pageable = PageRequest.of(page, size);
|
|
Page<EnvironmentResponse> response = environmentService.search(query, pageable);
|
|
return ResponseEntity.ok(response);
|
|
}
|
|
|
|
@DeleteMapping("/{id}")
|
|
@Operation(summary = "Delete environment", description = "Delete an environment")
|
|
public ResponseEntity<Void> delete(@PathVariable UUID id) {
|
|
environmentService.delete(id);
|
|
return ResponseEntity.noContent().build();
|
|
}
|
|
}
|
|
JAVA
|
|
|
|
echo "Controllers created"
|
|
echo "✓ All backend Java files created successfully!"
|
|
|