plugins {
  id 'java'
  id 'org.springframework.boot' version '2.5.1'
  id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}
group = 'ru.dhabits.spring_boot_example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
  mavenCentral()
}
dependencies {
  implementation 'org.springframework.boot:spring-boot-starter'
  testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
test {
  useJUnitPlatform()
}

implementation "org.springframework.boot:spring-boot-starter-web"

@RestController
public class controller {
   @Value("${spring.application.name}")
   private String name;
   @GetMapping
   public String getNameApplication() {
       return name;
   }
}

spring.application.name=spring_boot_example

@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "address")

@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
private Address address;

@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "users")
public class User {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer id;
   @Column(name = "login",nullable = false, unique = true)
   private String login;
   @Column(name = "firstName")
   private String firstName;
   @Column(name = "middleName")
   private String middleName;
   @Column(name = "lastName")
   private String lastName;
   @Column(name = "age")
   private Integer age;
   @OneToOne(fetch = FetchType.LAZY)
   @JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
   private Address address;
   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       User user = (User) o;
       return login.equals(user.login);
   }
   @Override
   public int hashCode() {
       return Objects.hash(login);
   }
   @Override
   public String toString() {
       return "User{" +
               "id=" + id +
               ", login='" + login + '\'' +
               ", firstName='" + firstName + '\'' +
               ", middleName='" + middleName + '\'' +
               ", lastName='" + lastName + '\'' +
               ", age=" + age +
               '}';
   }
}

@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "address")
public class Address {
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Integer id;
   @Column(name = "street")
   private String street;
   @Column(name = "city")
   private String city;
   @Column(name = "building")
   private String building;
   @Override
   public boolean equals(Object o) {
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Address address = (Address) o;
       return street.equals(address.street) && city.equals(address.city) && building.equals(address.building);
   }
   @Override
   public int hashCode() {
       return Objects.hash(street, city, building);
   }
   @Override
   public String toString() {
       return "Address{" +
               "id=" + id +
               ", street='" + street + '\'' +
               ", city='" + city + '\'' +
               ", building='" + building + '\'' +
               '}';
   }
}

public interface UserRepository extends JpaRepository<User, Integer> {}

@Data
@Accessors(chain = true)
public class UserResponse {
   private Integer id;
   private String login;
   private String firstName;
   private String middleName;
   private String lastName;
   private Integer age;
   private AddressResponse address;
}
@Data
@Accessors(chain = true)
public class AddressResponse {
   private String street;
   private String city;
   private String building;
}
@Data
@Accessors(chain = true)
public class CreateUserRequest {
   private Integer id;
   private String login;
   private String firstName;
   private String middleName;
   private String lastName;
   private Integer age;
   private CreateAddressRequest address;
}
@Data
@Accessors(chain = true)
public class CreateAddressRequest {
   private String street;
   private String city;
   private String building;
}

@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserController {
   private UserService userService;
}

@GetMapping(produces = APPLICATION_JSON_VALUE)
public List<UserResponse> findAll() {
   return userService.findAll();
}

@GetMapping(value = "/{userId}", produces = APPLICATION_JSON_VALUE)
public UserResponse findById(@PathVariable Integer userId) {
   return userService.findById(userId);
}

@PostMapping(consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE)
public UserResponse create(@RequestBody CreateUserRequest request) {
   return userService.createUser(request);
}

@PatchMapping(value = "/{userId}", consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE)
public UserResponse update(@PathVariable Integer userId, @RequestBody CreateUserRequest request) {
   return userService.update(userId, request);
}

@ResponseStatus(HttpStatus.NO_CONTENT)
@DeleteMapping(value = "/{userId}", produces = APPLICATION_JSON_VALUE)
public void delete(@PathVariable Integer userId) {
   userService.delete(userId);
}

public interface UserService {
   @NotNull
   List<UserResponse> findAll();
   @NotNull
   UserResponse findById(@NotNull Integer userId);
   @NotNull
   UserResponse createUser(@NotNull CreateUserRequest request);
   @NotNull
   UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request);
   void delete(@NotNull Integer userId);
}

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
   private static UserRepository userRepository;
   @NotNull
   @Override
   @Transactional(readOnly = true)
   public List<UserResponse> findAll() {
       return null;
   }
   @NotNull
   @Override
   @Transactional(readOnly = true)
   public UserResponse findById(@NotNull Integer userId) {
       return null;
   }
   @NotNull
   @Override
   @Transactional
   public UserResponse createUser(@NotNull CreateUserRequest request) {
       return null;
   }
   @NotNull
   @Override
   @Transactional
   public UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request) {
       return null;
   }
   @Override
   @Transactional
   public void delete(@NotNull Integer userId) {
       return null;
   }

public List<UserResponse> findAll() {
   return userRepository.findAll()
           .stream()
           .map(this::buildUserResponse)
           .collect(Collectors.toList());
}
@NotNull
private UserResponse buildUserResponse(@NotNull User user) {
   return new UserResponse()
           .setId(user.getId())
           .setLogin(user.getLogin())
           .setAge(user.getAge())
           .setFirstName(user.getFirstName())
           .setMiddleName(user.getMiddleName())
           .setLastName(user.getLastName())
           .setAddress(new AddressResponse()
                   .setCity(user.getAddress().getCity())
                   .setBuilding(user.getAddress().getBuilding())
                   .setStreet(user.getAddress().getStreet()));
}

public UserResponse findById(@NotNull Integer userId) {
   return userRepository.findById(userId)
           .map(this::buildUserResponse)
           .orElseThrow(() -> new EntityNotFoundException("User " + userId + " is not found"));
}

public UserResponse createUser(@NotNull CreateUserRequest request) {
   User user = buildUserRequest(request);
   return buildUserResponse(userRepository.save(user));
}
@NotNull
private User buildUserRequest(@NotNull CreateUserRequest request) {
   return new User()
           .setLogin(request.getLogin())
           .setAge(request.getAge())
           .setFirstName(request.getFirstName())
           .setMiddleName(request.getMiddleName())
           .setLastName(request.getLastName())
           .setAddress(new Address()
                   .setCity(request.getAddress().getCity())
                   .setBuilding(request.getAddress().getBuilding())
                   .setStreet(request.getAddress().getStreet()));
}

@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
private Address address;

public UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request) {
   User user =  userRepository.findById(userId)
           .orElseThrow(() -> new EntityNotFoundException("User " + userId + " is not found"));
   userUpdate(user, request);
   return buildUserResponse(userRepository.save(user));
}

private void userUpdate(@NotNull User user, @NotNull CreateUserRequest request) {
   ofNullable(request.getLogin()).map(user::setLogin);
   ofNullable(request.getFirstName()).map(user::setFirstName);
   ofNullable(request.getMiddleName()).map(user::setMiddleName);
   ofNullable(request.getLastName()).map(user::setLastName);
   ofNullable(request.getAge()).map(user::setAge);
   CreateAddressRequest addressRequest = request.getAddress();
   if (addressRequest != null) {
       ofNullable(addressRequest.getBuilding()).map(user.getAddress()::setBuilding);
       ofNullable(addressRequest.getStreet()).map(user.getAddress()::setStreet);
       ofNullable(addressRequest.getCity()).map(user.getAddress()::setCity);
   }
}

public void delete(@NotNull Integer userId) {
   userRepository.deleteById(userId);
}

@Data
public class ExceptionResponse {
   private final String massage;
}

@RestControllerAdvice
public class ExceptionController {
   @ResponseStatus(HttpStatus.NOT_FOUND)
   @ExceptionHandler(EntityNotFoundException.class)
   private ExceptionResponse notFound(EntityNotFoundException ex) {
       return new ExceptionResponse(ex.getMessage());
   }
   @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
   @ExceptionHandler(RuntimeException.class)
   private ExceptionResponse error(RuntimeException ex) {
       return new ExceptionResponse(ex.getMessage());
   }
}

spring.datasource.url=jdbc:postgresql://localhost:5432/spring_demo
spring.datasource.username=program
spring.datasource.password=test
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.generate-ddl=true

CREATE DATABASE spring_demo;
CREATE ROLE program WITH PASSWORD 'test';
GRANT ALL PRIVILEGES ON DATABASE spring_demo TO program;
ALTER ROLE program WITH LOGIN;