Delete backend/generate_remaining_backend.sh

a
2026-02-09 08:34:25 +01:00
parent 9fb5d64fa3
commit 025bfacd57
1 changed files with 0 additions and 445 deletions
@@ -1,445 +0,0 @@
 #!/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!"