Oleja123/Internet-programming-UlSTU-2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Что-то

Browse Source
This commit is contained in:
gg12 darfren 2024-05-20 20:59:37 +04:00
parent 56ad0f134a
commit e044259d46
44 changed files with 1334 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
data.mv.db
View File

Binary file not shown.

10
demo/build.gradle
View File

@ -29,12 +29,20 @@ repositories {
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
implementation 'org.springframework.boot:spring-boot-starter-validation'
implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'
implementation 'org.modelmapper:modelmapper:3.2.0'
implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
implementation 'com.h2database:h2:2.2.224'
implementation 'org.springframework.boot:spring-boot-devtools'
implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
implementation 'nz.net.ultraq.thymeleaf:thymeleaf-layout-dialect:3.3.0'
runtimeOnly 'org.webjars.npm:bootstrap:5.3.3'
runtimeOnly 'org.webjars.npm:bootstrap-icons:1.11.3'
implementation 'org.springframework.boot:spring-boot-starter-security'
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

BIN
demo/data.mv.db
View File

Binary file not shown.

8
demo/src/main/java/com/example/demo/DemoApplication.java
View File

@ -39,8 +39,8 @@ public class DemoApplication implements CommandLineRunner {
log.info("Create default users values");
final var user1 = userService.create(new UserEntity("Oleja123", "bebrus@mail.ru", "1234"));
final var user2 = userService.create(new UserEntity("Vk1d2004", "berus@mail.ru", "4321"));
final var user1 = userService.create(new UserEntity("Oleja123", "1234"));
final var user2 = userService.create(new UserEntity("Vk1d2004", "4321"));
log.info("Create default groups values");
@ -48,6 +48,10 @@ public class DemoApplication implements CommandLineRunner {
var tmp = user1.getGroups();
final var group2 = groupService.create(user2.getId(), new GroupEntity("2"));
final var group3 = groupService.create(user1.getId(), new GroupEntity("3"));
final var group4 = groupService.create(user1.getId(), new GroupEntity("4"));
final var group5 = groupService.create(user1.getId(), new GroupEntity("5"));
final var group6 = groupService.create(user1.getId(), new GroupEntity("6"));
final var group7 = groupService.create(user1.getId(), new GroupEntity("7"));
log.info("Create default members values");

8
demo/src/main/java/com/example/demo/core/api/GlobalController.java Normal file
View File

@ -0,0 +1,8 @@
package com.example.demo.core.api;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ModelAttribute;
public class GlobalController {
}

18
demo/src/main/java/com/example/demo/core/api/PageAttributesMapper.java Normal file
View File

@ -0,0 +1,18 @@
package com.example.demo.core.api;
import java.util.Map;
import java.util.function.Function;
import org.springframework.data.domain.Page;
public class PageAttributesMapper {
private PageAttributesMapper() {
}
public static <E, D> Map<String, Object> toAttributes(Page<E> page, Function<E, D> mapper) {
return Map.of(
"items", page.getContent().stream().map(mapper::apply).toList(),
"currentPage", page.getNumber(),
"totalPages", page.getTotalPages());
}
}

97
demo/src/main/java/com/example/demo/core/api/PageDto.java
View File

@ -1,97 +0,0 @@
package com.example.demo.core.api;
import java.util.ArrayList;
import java.util.List;
public class PageDto<D> {
private List<D> items = new ArrayList<>();
private int itemsCount;
private int currentPage;
private int currentSize;
private int totalPages;
private long totalItems;
private boolean isFirst;
private boolean isLast;
private boolean hasNext;
private boolean hasPrevious;
public List<D> getItems() {
return items;
}
public void setItems(List<D> items) {
this.items = items;
}
public int getItemsCount() {
return itemsCount;
}
public void setItemsCount(int itemsCount) {
this.itemsCount = itemsCount;
}
public int getCurrentPage() {
return currentPage;
}
public void setCurrentPage(int currentPage) {
this.currentPage = currentPage;
}
public int getCurrentSize() {
return currentSize;
}
public void setCurrentSize(int currentSize) {
this.currentSize = currentSize;
}
public int getTotalPages() {
return totalPages;
}
public void setTotalPages(int totalPages) {
this.totalPages = totalPages;
}
public long getTotalItems() {
return totalItems;
}
public void setTotalItems(long totalItems) {
this.totalItems = totalItems;
}
public boolean isFirst() {
return isFirst;
}
public void setFirst(boolean isFirst) {
this.isFirst = isFirst;
}
public boolean isLast() {
return isLast;
}
public void setLast(boolean isLast) {
this.isLast = isLast;
}
public boolean isHasNext() {
return hasNext;
}
public void setHasNext(boolean hasNext) {
this.hasNext = hasNext;
}
public boolean isHasPrevious() {
return hasPrevious;
}
public void setHasPrevious(boolean hasPrevious) {
this.hasPrevious = hasPrevious;
}
}

25
demo/src/main/java/com/example/demo/core/api/PageDtoMapper.java
View File

@ -1,25 +0,0 @@
package com.example.demo.core.api;
import java.util.function.Function;
import org.springframework.data.domain.Page;
public class PageDtoMapper {
private PageDtoMapper() {
}
public static <D, E> PageDto<D> toDto(Page<E> page, Function<E, D> mapper) {
final PageDto<D> dto = new PageDto<>();
dto.setItems(page.getContent().stream().map(mapper::apply).toList());
dto.setItemsCount(page.getNumberOfElements());
dto.setCurrentPage(page.getNumber());
dto.setCurrentSize(page.getSize());
dto.setTotalPages(page.getTotalPages());
dto.setTotalItems(page.getTotalElements());
dto.setFirst(page.isFirst());
dto.setLast(page.isLast());
dto.setHasNext(page.hasNext());
dto.setHasPrevious(page.hasPrevious());
return dto;
}
}

12
demo/src/main/java/com/example/demo/core/configuration/Constants.java
View File

@ -3,8 +3,20 @@ package com.example.demo.core.configuration;
public class Constants {
public static final String SEQUENCE_NAME = "hibernate_sequence";
public static final int DEFUALT_PAGE_SIZE = 5;
public static final String REDIRECT_VIEW = "redirect:";
public static final String API_URL = "/api/1.0";
public static final String LOGIN_URL = "/login";
public static final String LOGOUT_URL = "/logout";
public static final String DEFAULT_PASSWORD = "123456";
public static final String ADMIN_PREFIX = "/admin";
private Constants() {
}
}

12
demo/src/main/java/com/example/demo/core/configuration/MapperConfiguration.java
View File

@ -1,13 +1,23 @@
package com.example.demo.core.configuration;
import org.modelmapper.ModelMapper;
import org.modelmapper.PropertyMap;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import com.example.demo.core.model.BaseEntity;
@Configuration
public class MapperConfiguration {
@Bean
ModelMapper modelMapper() {
return new ModelMapper();
final ModelMapper mapper = new ModelMapper();
mapper.addMappings(new PropertyMap<Object, BaseEntity>() {
@Override
protected void configure() {
skip(destination.getId());
}
});
return mapper;
}
}

6
demo/src/main/java/com/example/demo/core/configuration/WebConfiguration.java
View File

@ -3,13 +3,13 @@ package com.example.demo.core.configuration;
import org.springframework.context.annotation.Configuration;
import org.springframework.lang.NonNull;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
@Configuration
public class WebConfiguration implements WebMvcConfigurer {
@Override
public void addCorsMappings(@NonNull CorsRegistry registry) {
registry.addMapping("/**")
.allowedMethods("GET", "POST", "PUT", "DELETE");
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/login").setViewName("login");
}
}

53
demo/src/main/java/com/example/demo/core/error/AdviceController.java Normal file
View File

@ -0,0 +1,53 @@
package com.example.demo.core.error;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.servlet.ModelAndView;
import jakarta.servlet.http.HttpServletRequest;
@ControllerAdvice
public class AdviceController {
private final Logger log = LoggerFactory.getLogger(AdviceController.class);
private static Throwable getRootCause(Throwable throwable) {
Throwable rootCause = throwable;
while (rootCause.getCause() != null && rootCause.getCause() != rootCause) {
rootCause = rootCause.getCause();
}
return rootCause;
}
private static Map<String, Object> getAttributes(HttpServletRequest request, Throwable throwable) {
final Throwable rootCause = getRootCause(throwable);
final StackTraceElement firstError = rootCause.getStackTrace()[0];
return Map.of(
"message", rootCause.getMessage(),
"url", request.getRequestURL(),
"exception", rootCause.getClass().getName(),
"file", firstError.getFileName(),
"method", firstError.getMethodName(),
"line", firstError.getLineNumber());
}
@ExceptionHandler(value = Exception.class)
public ModelAndView defaultErrorHandler(HttpServletRequest request, Throwable throwable) throws Throwable {
if (AnnotationUtils.findAnnotation(throwable.getClass(),
ResponseStatus.class) != null) {
throw throwable;
}
log.error("{}", throwable.getMessage());
throwable.printStackTrace();
final ModelAndView model = new ModelAndView();
model.addAllObjects(getAttributes(request, throwable));
model.setViewName("error");
return model;
}
}

63
demo/src/main/java/com/example/demo/core/security/SecurityConfiguration.java Normal file
View File

@ -0,0 +1,63 @@
package com.example.demo.core.security;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
import org.springframework.security.config.annotation.web.configurers.HeadersConfigurer.FrameOptionsConfig;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import com.example.demo.core.configuration.Constants;
import com.example.demo.users.api.UserSignupController;
import com.example.demo.users.model.UserRole;
@Configuration
@EnableWebSecurity
public class SecurityConfiguration {
@Bean
SecurityFilterChain filterChain(HttpSecurity httpSecurity) throws Exception {
httpSecurity.headers(headers -> headers.frameOptions(FrameOptionsConfig::sameOrigin));
httpSecurity.csrf(AbstractHttpConfigurer::disable);
httpSecurity.cors(Customizer.withDefaults());
httpSecurity.authorizeHttpRequests(requests -> requests
.requestMatchers("/css/**", "/webjars/**", "/*.svg")
.permitAll());
httpSecurity.authorizeHttpRequests(requests -> requests
.requestMatchers(Constants.ADMIN_PREFIX + "/**").hasRole(UserRole.ADMIN.name())
.requestMatchers("/h2-console/**").hasRole(UserRole.ADMIN.name())
.requestMatchers(UserSignupController.URL).anonymous()
.requestMatchers(Constants.LOGIN_URL).anonymous()
.anyRequest().authenticated());
httpSecurity.formLogin(formLogin -> formLogin
.loginPage(Constants.LOGIN_URL));
httpSecurity.rememberMe(rememberMe -> rememberMe.key("uniqueAndSecret"));
httpSecurity.logout(logout -> logout
.deleteCookies("JSESSIONID"));
return httpSecurity.build();
}
@Bean
DaoAuthenticationProvider authenticationProvider(UserDetailsService userDetailsService) {
final DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
authProvider.setUserDetailsService(userDetailsService);
authProvider.setPasswordEncoder(passwordEncoder());
return authProvider;
}
@Bean
PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}

65
demo/src/main/java/com/example/demo/core/security/UserPrincipal.java Normal file
View File

@ -0,0 +1,65 @@
package com.example.demo.core.security;
import java.util.Collection;
import java.util.Set;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import com.example.demo.users.model.UserEntity;
public class UserPrincipal implements UserDetails {
private final long id;
private final String username;
private final String password;
private final Set<? extends GrantedAuthority> roles;
private final boolean active;
public UserPrincipal(UserEntity user) {
this.id = user.getId();
this.username = user.getLogin();
this.password = user.getPassword();
this.roles = Set.of(user.getRole());
this.active = true;
}
public Long getId() {
return id;
}
@Override
public String getUsername() {
return username;
}
@Override
public String getPassword() {
return password;
}
@Override
public Collection<? extends GrantedAuthority> getAuthorities() {
return roles;
}
@Override
public boolean isEnabled() {
return active;
}
@Override
public boolean isAccountNonExpired() {
return isEnabled();
}
@Override
public boolean isAccountNonLocked() {
return isEnabled();
}
@Override
public boolean isCredentialsNonExpired() {
return isEnabled();
}
}

104
demo/src/main/java/com/example/demo/groups/api/GroupController.java
View File

@ -1,37 +1,50 @@
package com.example.demo.groups.api;
import java.util.List;
import java.util.Map;
import org.modelmapper.ModelMapper;
import org.springframework.boot.autoconfigure.security.SecurityProperties.User;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
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.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import com.example.demo.core.api.PageAttributesMapper;
import com.example.demo.core.configuration.Constants;
import com.example.demo.core.security.UserPrincipal;
import com.example.demo.groups.model.GroupEntity;
import com.example.demo.groups.service.GroupService;
import com.example.demo.members.service.MemberService;
import com.example.demo.users.service.UserService;
import jakarta.validation.Valid;
@RestController
@RequestMapping(Constants.API_URL + "/user/{user}/group")
@Controller
public class GroupController {
private static final String GROUPS_VIEW = "groups";
private static final String GROUP_VIEW = "members";
private static final String GROUP_EDIT_VIEW = "group-edit";
private static final String PAGE_ATTRIBUTE = "page";
private static final String GROUP_ATTRIBUTE = "group";
private static final String MEMBERS_VIEW = "members";
private final GroupService groupService;
private final MemberService memberService;
private final UserService userService;
private final ModelMapper modelMapper;
public GroupController(GroupService groupService, UserService userService, ModelMapper modelMapper) {
public GroupController(GroupService groupService, UserService userService, MemberService memberService, ModelMapper modelMapper) {
this.groupService = groupService;
this.userService = userService;
this.modelMapper = modelMapper;
this.memberService = memberService;
}
private GroupDto toDto(GroupEntity entity) {
@ -44,36 +57,69 @@ public class GroupController {
}
@GetMapping
public List<GroupDto> getAll(
@PathVariable(name = "user") Long userId) {
return groupService.getAll(userId).stream()
.map(this::toDto)
.toList();
public String getAll(
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
Model model,
@AuthenticationPrincipal UserPrincipal principal) {
final Map<String, Object> attributes = PageAttributesMapper.toAttributes(
groupService.getAll(principal.getId(), page, Constants.DEFUALT_PAGE_SIZE), this::toDto);
model.addAllAttributes(attributes);
model.addAttribute(PAGE_ATTRIBUTE, page);
return GROUPS_VIEW;
}
@GetMapping("/{id}")
public GroupDto get(
@PathVariable(name = "id") Long id) {
return toDto(groupService.get(id));
@GetMapping("/edit/")
public String create(Model model) {
model.addAttribute(GROUP_ATTRIBUTE, new GroupDto());
return GROUP_EDIT_VIEW;
}
@PostMapping
public GroupDto create(
@PathVariable(name = "user") Long userId,
@RequestBody @Valid GroupDto dto) {
return toDto(groupService.create(userId, toEntity(dto)));
@PostMapping("/edit/")
public String create(
@ModelAttribute(name = GROUP_ATTRIBUTE) @Valid GroupDto group,
@AuthenticationPrincipal UserPrincipal principal,
BindingResult bindingResult,
Model model) {
if (bindingResult.hasErrors()) {
return GROUP_EDIT_VIEW;
}
groupService.create(principal.getId(), toEntity(group));
return Constants.REDIRECT_VIEW + "/";
}
@PutMapping("/{id}")
public GroupDto update(
@GetMapping("/edit/{id}")
public String update(
@PathVariable(name = "id") Long id,
@RequestBody @Valid GroupDto dto) {
return toDto(groupService.update(id, toEntity(dto)));
Model model) {
if (id <= 0) {
throw new IllegalArgumentException();
}
model.addAttribute(GROUP_ATTRIBUTE, toDto(groupService.get(id)));
return GROUP_EDIT_VIEW;
}
@DeleteMapping("/{id}")
public GroupDto delete(
@PostMapping("/edit/{id}")
public String update(
@PathVariable(name = "id") Long id,
@ModelAttribute(name = GROUP_ATTRIBUTE) @Valid GroupDto group,
BindingResult bindingResult,
Model model) {
if (bindingResult.hasErrors()) {
return GROUP_EDIT_VIEW;
}
if (id <= 0) {
throw new IllegalArgumentException();
}
groupService.update(id, toEntity(group));
return Constants.REDIRECT_VIEW + "/";
}
@PostMapping("/delete/{id}")
public String delete(
@PathVariable(name = "id") Long id) {
return toDto(groupService.delete(id));
groupService.delete(id);
return Constants.REDIRECT_VIEW + "/";
}
}

1
demo/src/main/java/com/example/demo/groups/api/GroupDto.java
View File

@ -7,7 +7,6 @@ import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
public class GroupDto {
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Long id;
@NotBlank
private String name;

3
demo/src/main/java/com/example/demo/groups/repository/GroupRepository.java
View File

@ -3,6 +3,8 @@ package com.example.demo.groups.repository;
import java.util.List;
import java.util.Optional;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
@ -10,5 +12,6 @@ import com.example.demo.groups.model.GroupEntity;
import com.example.demo.groups.model.GroupEntity;
public interface GroupRepository extends CrudRepository<GroupEntity, Long> {
Page<GroupEntity> findByUserId(long userId, Pageable pageable);
List<GroupEntity> findByUserId(long userId);
}

10
demo/src/main/java/com/example/demo/groups/service/GroupService.java
View File

@ -4,6 +4,10 @@ import java.util.List;
import javax.swing.GroupLayout.Group;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -24,6 +28,12 @@ public class GroupService {
this.userService = userService;
}
@Transactional(readOnly = true)
public Page<GroupEntity> getAll(Long userId, int page, int size) {
final Pageable pageRequest = PageRequest.of(page, size, Sort.by("id"));
return repository.findByUserId(userId, pageRequest);
}
@Transactional(readOnly = true)
public List<GroupEntity> getAll(Long userId) {
userService.get(userId);

105
demo/src/main/java/com/example/demo/members/api/MemberController.java
View File

@ -1,11 +1,17 @@
package com.example.demo.members.api;
import java.util.List;
import java.util.Map;
import org.modelmapper.ModelMapper;
import org.springframework.data.domain.Page;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
@ -14,18 +20,27 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.core.api.PageDto;
import com.example.demo.core.api.PageDtoMapper;
import com.example.demo.core.api.PageAttributesMapper;
import com.example.demo.core.configuration.Constants;
import com.example.demo.core.security.UserPrincipal;
import com.example.demo.members.model.MemberEntity;
import com.example.demo.members.service.MemberService;
import com.example.demo.groups.api.GroupDto;
import com.example.demo.groups.service.GroupService;
import jakarta.validation.Valid;
@RestController
@RequestMapping(Constants.API_URL + "/user/{user}/group/{group}/member")
@Controller
@RequestMapping(MemberController.URL)
public class MemberController {
public static final String URL = "/{group}/members";
private static final String MEMBERS_VIEW = "members";
private static final String MEMBERS_TOP_VIEW = "members-top";
private static final String MEMBER_EDIT_VIEW = "member-edit";
private static final String PAGE_ATTRIBUTE = "page";
private static final String MEMBER_ATTRIBUTE = "member";
private static final String GROUP_ATTRIBUTE = "group";
private static final String MEMBERS_TOP_ATTRIBUTE = "members-top";
private final MemberService memberService;
private final GroupService groupService;
private final ModelMapper modelMapper;
@ -56,38 +71,76 @@ public class MemberController {
return memberService.getMembersTopList(5).stream().map(this::toDto).toList();
}
@GetMapping("/getmemberstopgrouplist")
public List<MemberDto> getMembersTopGroupList(@RequestParam(name = "groupId", defaultValue = "0") Long groupId) {
return memberService.getMembersTopGroupList(5, groupId).stream().map(this::toDto).toList();
}
@GetMapping("/getmemberstopgroup")
public List<MemberDto> getMembersTopGroup(@RequestParam(name = "groupId", defaultValue = "0") Long groupId) {
return memberService.getMembersTopGroup(5, groupId).stream().map(this::toDto).toList();
public String getMembersTopGroup(@RequestParam(name = "group", defaultValue = "0") Long groupId, Model model) {
model.addAttribute(MEMBERS_TOP_ATTRIBUTE, memberService.getMembersTopGroup(5, groupId).stream().map(this::toDto).toList());
return MEMBERS_TOP_VIEW;
}
@GetMapping
public List<MemberDto> getAll(@RequestParam(name = "group", defaultValue = "0") Long groupId) {
return memberService.getAll(groupId).stream().map(this::toDto).toList();
public String getAll(@PathVariable(name = "group") Long groupId,
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
Model model) {
final Map<String, Object> attributes = PageAttributesMapper.toAttributes(
memberService.getAll(groupId, page, Constants.DEFUALT_PAGE_SIZE), this::toDto);
model.addAllAttributes(attributes);
model.addAttribute(PAGE_ATTRIBUTE, page);
model.addAttribute(GROUP_ATTRIBUTE, groupId);
return MEMBERS_VIEW;
}
@GetMapping("/{id}")
public MemberDto get(@PathVariable(name = "id") Long id) {
return toDto(memberService.get(id));
@GetMapping("/edit")
public String create(@PathVariable(name = "group") Long groupId, Model model) {
model.addAttribute(MEMBER_ATTRIBUTE, new MemberDto());
model.addAttribute(GROUP_ATTRIBUTE, groupId);
return MEMBER_EDIT_VIEW;
}
@PostMapping
public MemberDto create(@PathVariable(name = "group") Long groupId, @RequestBody @Valid MemberDto dto) {
return toDto(memberService.create(groupId, toEntity(dto)));
@PostMapping("/edit/")
public String create(@PathVariable(name = "group") Long groupId,
@ModelAttribute(name = MEMBER_ATTRIBUTE) @Valid MemberDto member,
BindingResult bindingResult,
Model model) {
if (bindingResult.hasErrors()) {
return MEMBER_EDIT_VIEW;
}
memberService.create(groupId, toEntity(member));
return Constants.REDIRECT_VIEW + String.format("/%d/members", groupId);
}
@PutMapping("/{id}")
public MemberDto update(@PathVariable(name = "id") Long id, @RequestBody MemberDto dto) {
return toDto(memberService.update(id, toEntity(dto)));
@GetMapping("/edit/{id}")
public String update(@PathVariable(name = "group") Long groupId,
@PathVariable(name = "id") Long id,
Model model) {
if (id <= 0) {
throw new IllegalArgumentException();
}
model.addAttribute(MEMBER_ATTRIBUTE, toDto(memberService.get(id)));
model.addAttribute(GROUP_ATTRIBUTE, groupId);
return MEMBER_EDIT_VIEW;
}
@DeleteMapping("/{id}")
public MemberDto delete(@PathVariable(name = "id") @Valid Long id) {
return toDto(memberService.delete(id));
@PostMapping("/edit/{id}")
public String update(
@PathVariable(name = "id") Long id,
@PathVariable(name = "group") Long group,
@ModelAttribute(name = MEMBER_ATTRIBUTE) @Valid MemberDto member,
BindingResult bindingResult,
Model model) {
if (bindingResult.hasErrors()) {
return MEMBER_EDIT_VIEW;
}
if (id <= 0) {
throw new IllegalArgumentException();
}
memberService.update(id, toEntity(member));
return Constants.REDIRECT_VIEW + String.format("/%d/members", group);
}
@PostMapping("/delete/{id}")
public String delete(
@PathVariable(name = "id") Long id,
@PathVariable(name = "group") Long group) {
memberService.delete(id);
return Constants.REDIRECT_VIEW + String.format("/%d/members", group);
}
}

3
demo/src/main/java/com/example/demo/members/api/MemberDto.java
View File

@ -7,15 +7,12 @@ import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.NotNull;
public class MemberDto {
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Long id;
@NotBlank
private String name;
@NotBlank
private String handle;
@NotBlank
private String rank;
@NotBlank
private Long rating;
public Long getId() {

2
demo/src/main/java/com/example/demo/members/repository/MemberRepository.java
View File

@ -15,7 +15,7 @@ import org.springframework.data.repository.CrudRepository;
public interface MemberRepository extends CrudRepository<MemberEntity, Long> {
Optional<MemberEntity> findOneById(long id);
List<MemberEntity> findByGroupId(long groupId);
Page<MemberEntity> findByGroupId(long groupId, Pageable pageable);
@Query("select "
+ "m"
+ " from MemberEntity m"

7
demo/src/main/java/com/example/demo/members/service/MemberService.java
View File

@ -5,6 +5,7 @@ import java.util.List;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@ -27,8 +28,9 @@ public class MemberService {
}
@Transactional(readOnly = true)
public List<MemberEntity> getAll(long groupId) {
return repository.findByGroupId(groupId);
public Page<MemberEntity> getAll(long groupId, int page, int size) {
final Pageable pageRequest = PageRequest.of(page, size, Sort.by("id"));
return repository.findByGroupId(groupId, pageRequest);
}
@Transactional(readOnly = true)
@ -81,6 +83,7 @@ public class MemberService {
existsEntity.setHandle(entity.getHandle());
existsEntity.setName(entity.getName());
existsEntity.setRank(entity.getRank());
existsEntity.setRating(entity.getRating());
return repository.save(existsEntity);
}

101
demo/src/main/java/com/example/demo/users/api/UserController.java
View File

@ -1,26 +1,37 @@
package com.example.demo.users.api;
import java.util.List;
import java.util.Map;
import org.modelmapper.ModelMapper;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
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.RequestParam;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;
import com.example.demo.core.api.PageAttributesMapper;
import com.example.demo.core.configuration.Constants;
import com.example.demo.users.model.UserEntity;
import com.example.demo.users.service.UserService;
import jakarta.validation.Valid;
@RestController
@RequestMapping(Constants.API_URL + "/user")
@Controller
@RequestMapping(UserController.URL)
public class UserController {
public static final String URL = Constants.ADMIN_PREFIX + "/user";
private static final String USERS_VIEW = "users";
private static final String USER_EDIT_VIEW = "user-edit";
private static final String PAGE_ATTRIBUTE = "page";
private static final String USER_ATTRIBUTE = "user";
private final UserService userService;
private final ModelMapper modelMapper;
@ -38,27 +49,81 @@ public class UserController {
}
@GetMapping
public List<UserDto> getAll() {
return userService.getAll().stream().map(this::toDto).toList();
public String getAll(
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
Model model) {
final Map<String, Object> attributes = PageAttributesMapper.toAttributes(
userService.getAll(page, Constants.DEFUALT_PAGE_SIZE), this::toDto);
model.addAllAttributes(attributes);
model.addAttribute(PAGE_ATTRIBUTE, page);
return USERS_VIEW;
}
@GetMapping("/{id}")
public UserDto get(@PathVariable(name = "id") Long id) {
return toDto(userService.get(id));
@GetMapping("/edit/")
public String create(
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
Model model) {
model.addAttribute(USER_ATTRIBUTE, new UserDto());
model.addAttribute(PAGE_ATTRIBUTE, page);
return USER_EDIT_VIEW;
}
@PostMapping
public UserDto create(@RequestBody @Valid UserDto dto) {
return toDto(userService.create(toEntity(dto)));
@PostMapping("/edit/")
public String create(
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
@ModelAttribute(name = USER_ATTRIBUTE) @Valid UserDto user,
BindingResult bindingResult,
Model model,
RedirectAttributes redirectAttributes) {
if (bindingResult.hasErrors()) {
model.addAttribute(PAGE_ATTRIBUTE, page);
return USER_EDIT_VIEW;
}
redirectAttributes.addAttribute(PAGE_ATTRIBUTE, page);
userService.create(toEntity(user));
return Constants.REDIRECT_VIEW + URL;
}
@PutMapping("/{id}")
public UserDto update(@PathVariable(name = "id") Long id, @RequestBody UserDto dto) {
return toDto(userService.update(id, toEntity(dto)));
@GetMapping("/edit/{id}")
public String update(
@PathVariable(name = "id") Long id,
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
Model model) {
if (id <= 0) {
throw new IllegalArgumentException();
}
model.addAttribute(USER_ATTRIBUTE, toDto(userService.get(id)));
model.addAttribute(PAGE_ATTRIBUTE, page);
return USER_EDIT_VIEW;
}
@DeleteMapping("/{id}")
public UserDto delete(@PathVariable(name = "id") @Valid Long id) {
return toDto(userService.delete(id));
@PostMapping("/edit/{id}")
public String update(
@PathVariable(name = "id") Long id,
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
@ModelAttribute(name = USER_ATTRIBUTE) @Valid UserDto user,
BindingResult bindingResult,
Model model,
RedirectAttributes redirectAttributes) {
if (bindingResult.hasErrors()) {
model.addAttribute(PAGE_ATTRIBUTE, page);
return USER_EDIT_VIEW;
}
if (id <= 0) {
throw new IllegalArgumentException();
}
redirectAttributes.addAttribute(PAGE_ATTRIBUTE, page);
userService.update(id, toEntity(user));
return Constants.REDIRECT_VIEW + URL;
}
@PostMapping("/delete/{id}")
public String delete(
@PathVariable(name = "id") Long id,
@RequestParam(name = PAGE_ATTRIBUTE, defaultValue = "0") int page,
RedirectAttributes redirectAttributes) {
redirectAttributes.addAttribute(PAGE_ATTRIBUTE, page);
userService.delete(id);
return Constants.REDIRECT_VIEW + URL;
}
}

34
demo/src/main/java/com/example/demo/users/api/UserDto.java
View File

@ -8,17 +8,11 @@ import jakarta.validation.constraints.Size;
public class UserDto {
@JsonProperty(access = Access.READ_ONLY)
private Long id;
@NotBlank
@Size(min = 3, max = 25)
private String handle;
@NotBlank
@Size(min = 3, max = 30)
private String email;
@NotBlank
@Size(min = 3, max = 20)
private String password;
private String login;
private String role;
public Long getId() {
return id;
@ -28,27 +22,19 @@ public class UserDto {
this.id = id;
}
public String getEmail() {
return email;
public String getLogin() {
return login;
}
public void setEmail(String email) {
this.email = email;
public void setLogin(String login) {
this.login = login;
}
public String getHandle() {
return handle;
public String getRole() {
return role;
}
public void setHandle(String handle) {
this.handle = handle;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
public void setRole(String role) {
this.role = role;
}
}

65
demo/src/main/java/com/example/demo/users/api/UserSignupController.java Normal file
View File

@ -0,0 +1,65 @@
package com.example.demo.users.api;
import java.util.Objects;
import org.modelmapper.ModelMapper;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import com.example.demo.core.configuration.Constants;
import com.example.demo.users.model.UserEntity;
import com.example.demo.users.service.UserService;
import jakarta.validation.Valid;
@Controller
@RequestMapping(UserSignupController.URL)
public class UserSignupController {
public static final String URL = "/signup";
private static final String SIGNUP_VIEW = "signup";
private static final String USER_ATTRIBUTE = "user";
private final UserService userService;
private final ModelMapper modelMapper;
public UserSignupController(
UserService userService,
ModelMapper modelMapper) {
this.userService = userService;
this.modelMapper = modelMapper;
}
private UserEntity toEntity(UserSignupDto dto) {
return modelMapper.map(dto, UserEntity.class);
}
@GetMapping
public String getSignup(Model model) {
model.addAttribute(USER_ATTRIBUTE, new UserSignupDto());
return SIGNUP_VIEW;
}
@PostMapping
public String signup(
@ModelAttribute(name = USER_ATTRIBUTE) @Valid UserSignupDto user,
BindingResult bindingResult,
Model model) {
if (bindingResult.hasErrors()) {
return SIGNUP_VIEW;
}
if (!Objects.equals(user.getPassword(), user.getPasswordConfirm())) {
bindingResult.rejectValue("password", "signup:passwords", "Пароли не совпадают.");
model.addAttribute(USER_ATTRIBUTE, user);
return SIGNUP_VIEW;
}
userService.create(toEntity(user));
return Constants.REDIRECT_VIEW + Constants.LOGIN_URL + "?signup";
}
}

40
demo/src/main/java/com/example/demo/users/api/UserSignupDto.java Normal file
View File

@ -0,0 +1,40 @@
package com.example.demo.users.api;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Size;
public class UserSignupDto {
@NotBlank
@Size(min = 3, max = 20)
private String login;
@NotBlank
@Size(min = 3, max = 20)
private String password;
@NotBlank
@Size(min = 3, max = 20)
private String passwordConfirm;
public String getLogin() {
return login;
}
public void setLogin(String login) {
this.login = login;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPasswordConfirm() {
return passwordConfirm;
}
public void setPasswordConfirm(String passwordConfirm) {
this.passwordConfirm = passwordConfirm;
}
}

40
demo/src/main/java/com/example/demo/users/model/UserEntity.java
View File

@ -18,12 +18,11 @@ import jakarta.persistence.Table;
@Entity
@Table(name = "users")
public class UserEntity extends BaseEntity{
@Column(nullable = false, unique = true, length = 25)
private String handle;
@Column(nullable = false, unique = true, length = 30)
private String email;
@Column(nullable = false, length = 20)
@Column(nullable = false, unique = true, length = 20)
private String login;
@Column(nullable = false, length = 60)
private String password;
private UserRole role;
@OneToMany(mappedBy = "user", cascade = CascadeType.ALL)
@OrderBy("id ASC")
private Set<GroupEntity> groups = new HashSet<>();
@ -31,18 +30,18 @@ public class UserEntity extends BaseEntity{
public UserEntity(){
}
public UserEntity(String handle, String email, String password) {
this.handle = handle;
this.email = email;
public UserEntity(String login, String password) {
this.login = login;
this.password = password;
this.role = UserRole.USER;
}
public String getEmail() {
return email;
public String getLogin() {
return login;
}
public void setEmail(String email) {
this.email = email;
public void setLogin(String login) {
this.login = login;
}
public String getPassword() {
@ -53,12 +52,12 @@ public class UserEntity extends BaseEntity{
this.password = password;
}
public String getHandle() {
return handle;
public UserRole getRole() {
return role;
}
public void setHandle(String handle) {
this.handle = handle;
public void setRole(UserRole role) {
this.role = role;
}
public Set<GroupEntity> getGroups() {
@ -79,9 +78,10 @@ public class UserEntity extends BaseEntity{
groups.remove(group);
}
@Override
public int hashCode() {
return Objects.hash(id, handle, email, password);
return Objects.hash(id, login, password, role);
}
@Override
@ -92,9 +92,9 @@ public class UserEntity extends BaseEntity{
return false;
final UserEntity other = (UserEntity) obj;
return Objects.equals(other.getId(), id)
&& Objects.equals(other.getHandle(), handle)
&& Objects.equals(other.getEmail(), email)
&& Objects.equals(other.getPassword(), password);
&& Objects.equals(other.getLogin(), login)
&& Objects.equals(other.getPassword(), password)
&& Objects.equals(other.getRole(), role);
}
}

15
demo/src/main/java/com/example/demo/users/model/UserRole.java Normal file
View File

@ -0,0 +1,15 @@
package com.example.demo.users.model;
import org.springframework.security.core.GrantedAuthority;
public enum UserRole implements GrantedAuthority {
ADMIN,
USER;
private static final String PREFIX = "ROLE_";
@Override
public String getAuthority() {
return PREFIX + this.name();
}
}

6
demo/src/main/java/com/example/demo/users/repository/UserRepository.java
View File

@ -3,11 +3,11 @@ package com.example.demo.users.repository;
import java.util.Optional;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.PagingAndSortingRepository;
import com.example.demo.groups.model.GroupEntity;
import com.example.demo.users.model.UserEntity;
public interface UserRepository extends CrudRepository<UserEntity, Long> {
Optional<UserEntity> findByHandleIgnoreCase(String login);
Optional<UserEntity> findByEmailIgnoreCase(String login);
public interface UserRepository extends CrudRepository<UserEntity, Long>, PagingAndSortingRepository<UserEntity, Long> {
Optional<UserEntity> findByLoginIgnoreCase(String login);
}

68
demo/src/main/java/com/example/demo/users/service/UserService.java
View File

@ -2,34 +2,44 @@ package com.example.demo.users.service;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.StreamSupport;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;
import com.example.demo.core.configuration.Constants;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.core.security.UserPrincipal;
import com.example.demo.users.model.UserEntity;
import com.example.demo.users.model.UserRole;
import com.example.demo.users.repository.UserRepository;
@Service
public class UserService {
public class UserService implements UserDetailsService {
private final UserRepository repository;
private final PasswordEncoder passwordEncoder;
public UserService(UserRepository repository) {
public UserService(
UserRepository repository,
PasswordEncoder passwordEncoder) {
this.repository = repository;
this.passwordEncoder = passwordEncoder;
}
private void checkHandle(String handle) {
if (repository.findByHandleIgnoreCase(handle).isPresent()) {
private void checkLogin(Long id, String login) {
final Optional<UserEntity> existsUser = repository.findByLoginIgnoreCase(login);
if (existsUser.isPresent() && !existsUser.get().getId().equals(id)) {
throw new IllegalArgumentException(
String.format("User with handle %s is already exists", handle));
}
}
private void checkEmail(String email) {
if (repository.findByHandleIgnoreCase(email).isPresent()) {
throw new IllegalArgumentException(
String.format("User with email %s is already exists", email));
String.format("User with login %s is already exists", login));
}
}
@ -38,19 +48,34 @@ public class UserService {
return StreamSupport.stream(repository.findAll().spliterator(), false).toList();
}
@Transactional(readOnly = true)
public Page<UserEntity> getAll(int page, int size) {
return repository.findAll(PageRequest.of(page, size, Sort.by("id")));
}
@Transactional(readOnly = true)
public UserEntity get(long id) {
return repository.findById(id)
.orElseThrow(() -> new NotFoundException(UserEntity.class, id));
}
@Transactional(readOnly = true)
public UserEntity getByLogin(String login) {
return repository.findByLoginIgnoreCase(login)
.orElseThrow(() -> new IllegalArgumentException("Invalid login"));
}
@Transactional
public UserEntity create(UserEntity entity) {
if (entity == null) {
throw new IllegalArgumentException("Entity is null");
}
checkHandle(entity.getHandle());
checkEmail(entity.getEmail());
checkLogin(null, entity.getLogin());
final String password = Optional.ofNullable(entity.getPassword()).orElse("");
entity.setPassword(
passwordEncoder.encode(
StringUtils.hasText(password.strip()) ? password : Constants.DEFAULT_PASSWORD));
entity.setRole(Optional.ofNullable(entity.getRole()).orElse(UserRole.USER));
repository.save(entity);
return repository.save(entity);
}
@ -58,11 +83,8 @@ public class UserService {
@Transactional
public UserEntity update(long id, UserEntity entity) {
final UserEntity existsEntity = get(id);
checkHandle(entity.getHandle());
checkEmail(entity.getEmail());
existsEntity.setHandle(entity.getHandle());
existsEntity.setEmail(entity.getEmail());
existsEntity.setPassword(entity.getPassword());
checkLogin(id, entity.getLogin());
existsEntity.setLogin(entity.getLogin());
repository.save(existsEntity);
return existsEntity;
}
@ -74,8 +96,10 @@ public class UserService {
return existsEntity;
}
@Transactional
public void clear(){
repository.deleteAll();
@Override
@Transactional(readOnly = true)
public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
final UserEntity existsUser = getByLogin(username);
return new UserPrincipal(existsUser);
}
}

2
demo/src/main/resources/application.properties
View File

@ -12,7 +12,7 @@ spring.datasource.password=password
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=create
spring.jpa.open-in-view=false
spring.jpa.show-sql=true
spring.jpa.show-sql=false
spring.jpa.properties.hibernate.format_sql=true
# H2 console

57
demo/src/main/resources/public/css/style.css Normal file
View File

@ -0,0 +1,57 @@
html,
body {
height: 100%;
}
h1 {
font-size: 1.5em;
}
h2 {
font-size: 1.25em;
}
h3 {
font-size: 1.1em;
}
td form {
margin: 0;
padding: 0;
margin-top: -.25em;
}
.button-fixed-width {
width: 150px;
}
.button-link {
padding: 0;
}
.invalid-feedback {
display: block;
}
.w-10 {
width: 10% !important;
}
.my-navbar {
background-color: #ffffff !important;
}
.my-navbar .link a:hover {
text-decoration: underline;
}
.my-navbar .logo {
width: 26px;
height: 26px;
}
.my-footer {
background-color: #e6e6e6;
height: 32px;
color: rgba(0, 0, 0, 0.5);
}

15
demo/src/main/resources/public/favicon.svg Normal file
View File

@ -0,0 +1,15 @@
<?xml version="1.0" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
<svg version="1.0" xmlns="http://www.w3.org/2000/svg"
width="74.000000pt" height="58.000000pt" viewBox="0 0 74.000000 58.000000"
preserveAspectRatio="xMidYMid meet">
<g transform="translate(0.000000,58.000000) scale(0.100000,-0.100000)"
fill="#000000" stroke="none">
<path d="M415 373 c-81 -10 -76 -1 -73 -126 l3 -112 55 0 55 0 3 123 c1 67 -1
121 -5 121 -4 -1 -21 -4 -38 -6z"/>
<path d="M525 338 c-3 -13 -5 -63 -3 -113 l3 -90 48 -3 c27 -2 55 2 63 9 18
15 20 189 2 207 -7 7 -34 12 -60 12 -41 0 -48 -3 -53 -22z"/>
</g>
</svg>
Side by Side

After

Width:  |  Height:  |  Size: 678 B

56
demo/src/main/resources/templates/default.html Normal file
View File

@ -0,0 +1,56 @@
<!DOCTYPE html>
<html lang="ru" data-bs-theme="light" xmlns:th="http://www.thymeleaf.org"
xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout"
xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity6">
<head>
<meta charset="UTF-8" />
<link rel="icon" type="image/svg+xml" href="/favicon.svg" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title layout:title-pattern="$LAYOUT_TITLE - $CONTENT_TITLE">Codemonitor</title>
<script type="text/javascript" src="/webjars/bootstrap/5.3.3/dist/js/bootstrap.bundle.min.js"></script>
<link rel="stylesheet" href="/webjars/bootstrap/5.3.3/dist/css/bootstrap.min.css" />
<link rel="stylesheet" href="/webjars/bootstrap-icons/1.11.3/font/bootstrap-icons.min.css" />
<link rel="stylesheet" href="/css/style.css" />
</head>
<body class="h-100 d-flex flex-column">
<nav class="navbar navbar-expand-md my-navbar" data-bs-theme="light">
<div class="container-fluid">
<a class="navbar-brand" href="/">
Codemonitor
</a>
<th:block sec:authorize="isAuthenticated()" th:with="userName=${#authentication.name}">
<button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target="#main-navbar"
aria-controls="main-navbar" aria-expanded="false" aria-label="Toggle navigation">
<span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="main-navbar">
<ul class="navbar-nav me-auto link" th:with="activeLink=${#objects.nullSafe(servletPath, '')}">
<th:block sec:authorize="hasRole('ADMIN')">
<a class="nav-link" href="/admin/user"
th:classappend="${activeLink.startsWith('/admin/user') ? 'active' : ''}">
Пользователи
</a>
<a class="nav-link" href="/h2-console/" target="_blank">Консоль H2</a>
</th:block>
</ul>
<ul class="navbar-nav" th:if="${not #strings.isEmpty(userName)}">
<form th:action="@{/logout}" method="post">
<button type="submit" class="navbar-brand nav-link" onclick="return confirm('Вы уверены?')">
Выход ([[${userName}]])
</button>
</form>
</ul>
</div>
</th:block>
</div>
</nav>
<main class="container-fluid p-2" layout:fragment="content">
</main>
<footer class="my-footer mt-auto d-flex flex-shrink-0 justify-content-center align-items-center">
Oleja123, [[${#dates.year(#dates.createNow())}]]
</footer>
</body>
</html>

28
demo/src/main/resources/templates/group-edit.html Normal file
View File

@ -0,0 +1,28 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Редактировать группу</title>
</head>
<body>
<main layout:fragment="content">
<form action="#" th:action="@{/edit/{id}(id=${group.id})}" th:object="${group}" method="post">
<div class="mb-3">
<label for="id" class="form-label">ID</label>
<input type="text" th:value="*{id}" id="id" class="form-control" readonly disabled>
</div>
<div class="mb-3">
<label for="name" class="form-label">Группа</label>
<input type="text" th:field="*{name}" id="name" class="form-control">
<div th:if="${#fields.hasErrors('name')}" th:errors="*{name}" class="invalid-feedback"></div>
</div>
<div class="mb-3 d-flex flex-row">
<button class="btn btn-primary me-2 button-fixed-width" type="submit">Сохранить</button>
<a class="btn btn-secondary button-fixed-width" href="/">Отмена</a>
</div>
</form>
</main>
</body>
</html>

63
demo/src/main/resources/templates/groups.html Normal file
View File

@ -0,0 +1,63 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Группы пользователя</title>
</head>
<body>
<main layout:fragment="content">
<h2>Мои группы</h2>
<div>
<a th:href="@{/edit/}" class="btn btn-primary">Добавить группу</a>
</div>
<th:block th:switch="${items.size()}">
<h2 th:case="0">Данные отсутствуют</h2>
<th:block th:case="*">
<table class="table">
<caption></caption>
<thead>
<tr>
<th scope="col" class="w-10">ID</th>
<th scope="col" class="w-auto">Название группы</th>
<th scope="col" class="w-10"></th>
<th scope="col" class="w-10"></th>
<th scope="col" class="w-10"></th>
</tr>
</thead>
<tbody>
<tr th:each="group : ${items}">
<th scope="row" th:text="${group.id}"></th>
<td th:text="${group.name}"></td>
<td>
<form th:action="@{/{id}/members(id=${group.id})}" method="get">
<input type="hidden" th:name="page" th:value="${page}">
<button type="submit" class="btn btn-link button-link">Страница группы</button>
</form>
</td>
<td>
<form th:action="@{/edit/{id}(id=${group.id})}" method="get">
<input type="hidden" th:name="page" th:value="${page}">
<button type="submit" class="btn btn-link button-link">Редактировать</button>
</form>
</td>
<td>
<form th:action="@{/delete/{id}(id=${group.id})}" method="post">
<input type="hidden" th:name="page" th:value="${page}">
<button type="submit" class="btn btn-link button-link"
onclick="return confirm('Вы уверены?')">Удалить</button>
</form>
</td>
</tr>
</tbody>
</table>
</th:block>
<th:block th:replace="~{ pagination :: pagination (
url=${''},
totalPages=${totalPages},
currentPage=${currentPage}) }" />
</th:block>
</main>
</body>
</html>

44
demo/src/main/resources/templates/login.html Normal file
View File

@ -0,0 +1,44 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Вход</title>
</head>
<body>
<main layout:fragment="content">
<form action="#" th:action="@{/login}" method="post">
<div th:if="${param.error}" class="alert alert-danger">
Неверный логин или пароль
</div>
<div th:if="${param.logout}" class="alert alert-success">
Выход успешно произведен
</div>
<div th:if="${param.signup}" class="alert alert-success">
Пользователь успешно создан
</div>
<div class="mb-3">
<label for="username" class="form-label">Имя пользователя</label>
<input type="text" id="username" name="username" class="form-control" required minlength="3"
maxlength="20">
</div>
<div class="mb-3">
<label for="password" class="form-label">Пароль</label>
<input type="password" id="password" name="password" class="form-control" required minlength="3"
maxlength="20">
</div>
<div class="form-check mb-3">
<input class="form-check-input" type="checkbox" id="remember-me" name="remember-me" checked>
<label class="form-check-label" for="remember-me">Запомнить меня</label>
</div>
<div class="mb-3 d-flex flex-row">
<button class="btn btn-primary me-2 button-fixed-width" type="submit">Войти</button>
<a class="btn btn-secondary button-fixed-width" href="/signup">Регистрация</a>
</div>
</form>
</main>
</body>
</html>
</html>

43
demo/src/main/resources/templates/member-edit.html Normal file
View File

@ -0,0 +1,43 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Редактировать участника</title>
</head>
<body>
<main layout:fragment="content">
<form action="#" th:action="@{/{groupid}/members/edit/{id}(groupid=${group},id=${member.id})}" th:object="${member}" method="post">
<div class="mb-3">
<label for="id" class="form-label">ID</label>
<input type="text" th:value="*{id}" id="id" class="form-control" readonly disabled>
</div>
<div class="mb-3">
<label for="name" class="form-label">Имя участника</label>
<input type="text" th:field="*{name}" id="name" class="form-control">
<div th:if="${#fields.hasErrors('name')}" th:errors="*{name}" class="invalid-feedback"></div>
</div>
<div class="mb-3">
<label for="handle" class="form-label">Хэндл участника</label>
<input type="text" th:field="*{handle}" id="handle" class="form-control">
<div th:if="${#fields.hasErrors('handle')}" th:errors="*{handle}" class="invalid-feedback"></div>
</div>
<div class="mb-3">
<label for="rating" class="form-label">Рейтинг участника</label>
<input type="number" th:field="*{rating}" id="rating" class="form-control">
<div th:if="${#fields.hasErrors('rating')}" th:errors="*{rating}" class="invalid-feedback"></div>
</div>
<div class="mb-3">
<label for="rank" class="form-label">Ранг участника</label>
<input type="text" th:field="*{rank}" id="rank" class="form-control">
<div th:if="${#fields.hasErrors('rank')}" th:errors="*{rank}" class="invalid-feedback"></div>
</div>
<div class="mb-3 d-flex flex-row">
<button class="btn btn-primary me-2 button-fixed-width" type="submit">Сохранить</button>
<a class="btn btn-secondary button-fixed-width" th:href="@{/{groupid}/members(groupid=${group})}">Отмена</a>
</div>
</form>
</main>
</body>
</html>

62
demo/src/main/resources/templates/members.html Normal file
View File

@ -0,0 +1,62 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Участники группы</title>
</head>
<body>
<main layout:fragment="content">
<h2>Участники группы</h2>
<div>
<a th:href="@{/{groupid}/members/edit(groupid=${group})}" class="btn btn-primary">Добавить участника</a>
</div>
<th:block th:switch="${items.size()}">
<h2 th:case="0">Данные отсутствуют</h2>
<th:block th:case="*">
<table class="table">
<caption></caption>
<thead>
<tr>
<th scope="col" class="w-8">ID</th>
<th scope="col" class="w-19">Имя участника</th>
<th scope="col" class="w-19">Хэндл</th>
<th scope="col" class="w-19">Рейтинг</th>
<th scope="col" class="w-19">Звание</th>
<th scope="col" class="w-8"></th>
<th scope="col" class="w-8"></th>
</tr>
</thead>
<tbody>
<tr th:each="member : ${items}">
<th scope="row" th:text="${member.id}"></th>
<td th:text="${member.name}"></td>
<td th:text="${member.handle}"></td>
<td th:text="${member.rating}"></td>
<td th:text="${member.rank}"></td>
<td>
<form th:action="@{/{groupid}/members/edit/{id}(groupid=${group},id=${member.id})}" method="get">
<input type="hidden" th:name="page" th:value="${page}">
<button type="submit" class="btn btn-link button-link">Редактировать</button>
</form>
</td>
<td>
<form th:action="@{/{groupid}/members/delete/{id}(groupid=${group},id=${member.id})}" method="post">
<input type="hidden" th:name="page" th:value="${page}">
<button type="submit" class="btn btn-link button-link"
onclick="return confirm('Вы уверены?')">Удалить</button>
</form>
</td>
</tr>
</tbody>
</table>
</th:block>
<th:block th:with="group=${group}" th:replace="~{ pagination :: pagination (
url=@{{group}/members(group=${group})},
totalPages=${totalPages},
currentPage=${currentPage}) }" />
</th:block>
</main>
</body>
</html>

51
demo/src/main/resources/templates/pagination.html Normal file
View File

@ -0,0 +1,51 @@
<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>
<th:block th:fragment="pagination (url, totalPages, currentPage)">
<nav th:if="${totalPages > 1}" th:with="
maxPage=2,
currentPage=${currentPage + 1}">
<ul class="pagination justify-content-center"
th:with="
seqFrom=${currentPage - maxPage < 1 ? 1 : currentPage - maxPage},
seqTo=${currentPage + maxPage > totalPages ? totalPages : currentPage + maxPage}">
<th:block th:if="${currentPage > maxPage + 1}">
<li class="page-item">
<a class="page-link" aria-label="Previous" th:href="@{/{url}?page=0(url=${url})}">
<span aria-hidden="true">&laquo;</span>
</a>
</li>
<li class="page-item disabled">
<span class="page-link" aria-label="Previous">
<span aria-hidden="true">&hellip;</span>
</span>
</li>
</th:block>
<li class="page-item" th:each="page : ${#numbers.sequence(seqFrom, seqTo)}"
th:classappend="${page == currentPage} ? 'active' : ''">
<a class=" page-link" th:href="@{/{url}?page={page}(url=${url},page=${page - 1})}">
<span th:text="${page}" />
</a>
</li>
<th:block th:if="${currentPage < totalPages - maxPage}">
<li class="page-item disabled">
<span class="page-link" aria-label="Previous">
<span aria-hidden="true">&hellip;</span>
</span>
</li>
<li class="page-item">
<a class="page-link" aria-label="Next"
th:href="@{/{url}?page={page}(url=${url},page=${totalPages - 1})}">
<span aria-hidden="true">&raquo;</span>
</a>
</li>
</th:block>
</ul>
</nav>
</th:block>
</body>
</html>

37
demo/src/main/resources/templates/signup.html Normal file
View File

@ -0,0 +1,37 @@
<!DOCTYPE html>
<html lang="ru" xmlns:layout="http://www.ultraq.net.nz/thymeleaf/layout" layout:decorate="~{default}">
<head>
<title>Вход</title>
</head>
<body>
<main layout:fragment="content">
<form action="#" th:action="@{/signup}" th:object="${user}" method="post">
<div class="mb-3">
<label for="login" class="form-label">Имя пользователя</label>
<input type="text" th:field="*{login}" id="login" class="form-control">
<div th:if="${#fields.hasErrors('login')}" th:errors="*{login}" class="invalid-feedback"></div>
</div>
<div class="mb-3">
<label for="password" class="form-label">Пароль</label>
<input type="password" th:field="*{password}" id="password" class="form-control">
<div th:if="${#fields.hasErrors('password')}" th:errors="*{password}" class="invalid-feedback"></div>
</div>
<div class="mb-3">
<label for="passwordConfirm" class="form-label">Пароль (подтверждение)</label>
<input type="password" th:field="*{passwordConfirm}" id="passwordConfirm" class="form-control">
<div th:if="${#fields.hasErrors('passwordConfirm')}" th:errors="*{passwordConfirm}"
class="invalid-feedback"></div>
</div>
<div class="mb-3 d-flex flex-row">
<button class="btn btn-primary me-2 button-fixed-width" type="submit">Регистрация</button>
<a class="btn btn-secondary button-fixed-width" href="/">Отмена</a>
</div>
</form>
</main>
</body>
</html>
</html>

122
demo/src/test/java/com/example/demo/GroupServiceTests.java
View File

@ -21,67 +21,67 @@ import com.example.demo.users.service.UserService;
@SpringBootTest
@TestMethodOrder(OrderAnnotation.class)
class GroupServiceTests {
@Autowired
private GroupService groupService;
@Autowired
private UserService userService;
private GroupEntity group;
private UserEntity user;
// @Autowired
// private GroupService groupService;
// @Autowired
// private UserService userService;
// private GroupEntity group;
// private UserEntity user;
@BeforeEach
void createData() {
removeData();
// @BeforeEach
// void createData() {
// removeData();
user = userService.create(new UserEntity("oleg", "tester1", "1234"));
groupService.create(user.getId(), new GroupEntity("group1"));
groupService.create(user.getId(), new GroupEntity("group2"));
group = groupService.create(user.getId(), new GroupEntity("group3"));
}
@AfterEach
void removeData() {
userService.getAll().forEach(item -> userService.delete(item.getId()));
}
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> groupService.get(0L));
}
@Test
void createTest() {
Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
var res = groupService.get(group.getId());
Assertions.assertEquals(group, groupService.get(group.getId()));
}
@Test
void createNullableTest() {
final GroupEntity nullableGroup= new GroupEntity(null);
Assertions.assertThrows(DataIntegrityViolationException.class, () -> groupService.create(user.getId(), nullableGroup));
}
@Test
void updateTest() {
final String test = "TEST";
final String oldName = group.getName();
final GroupEntity newEntity = groupService.update(group.getId(), new GroupEntity(test));
Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
Assertions.assertEquals(newEntity, groupService.get(group.getId()));
Assertions.assertEquals(test, newEntity.getName());
Assertions.assertEquals(user, newEntity.getUser());
Assertions.assertNotEquals(oldName, newEntity.getName());
}
@Test
void deleteTest() {
groupService.delete(group.getId());
Assertions.assertEquals(2, groupService.getAll(user.getId()).size());
final GroupEntity newEntity = groupService.create(user.getId(), new GroupEntity(group.getName()));
Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
Assertions.assertNotEquals(group.getId(), newEntity.getId());
}
// user = userService.create(new UserEntity("oleg", "tester1", "1234"));
// groupService.create(user.getId(), new GroupEntity("group1"));
// groupService.create(user.getId(), new GroupEntity("group2"));
// group = groupService.create(user.getId(), new GroupEntity("group3"));
// }
// @AfterEach
// void removeData() {
// userService.getAll().forEach(item -> userService.delete(item.getId()));
// }
// @Test
// void getTest() {
// Assertions.assertThrows(NotFoundException.class, () -> groupService.get(0L));
// }
// @Test
// void createTest() {
// Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
// var res = groupService.get(group.getId());
// Assertions.assertEquals(group, groupService.get(group.getId()));
// }
// @Test
// void createNullableTest() {
// final GroupEntity nullableGroup= new GroupEntity(null);
// Assertions.assertThrows(DataIntegrityViolationException.class, () -> groupService.create(user.getId(), nullableGroup));
// }
// @Test
// void updateTest() {
// final String test = "TEST";
// final String oldName = group.getName();
// final GroupEntity newEntity = groupService.update(group.getId(), new GroupEntity(test));
// Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
// Assertions.assertEquals(newEntity, groupService.get(group.getId()));
// Assertions.assertEquals(test, newEntity.getName());
// Assertions.assertEquals(user, newEntity.getUser());
// Assertions.assertNotEquals(oldName, newEntity.getName());
// }
// @Test
// void deleteTest() {
// groupService.delete(group.getId());
// Assertions.assertEquals(2, groupService.getAll(user.getId()).size());
// final GroupEntity newEntity = groupService.create(user.getId(), new GroupEntity(group.getName()));
// Assertions.assertEquals(3, groupService.getAll(user.getId()).size());
// Assertions.assertNotEquals(group.getId(), newEntity.getId());
// }
}

122
demo/src/test/java/com/example/demo/MemberServiceTests.java
View File

@ -34,66 +34,66 @@ class MemberServiceTests {
private GroupEntity group;
private UserEntity user;
@BeforeEach
void createData() {
removeData();
// @BeforeEach
// void createData() {
// removeData();
user = userService.create(new UserEntity("oleg", "tester1", "1234"));
group = groupService.create(user.getId(), new GroupEntity("group1"));
member = memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1615L));
memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1712L));
memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1651L));
}
@AfterEach
void removeData() {
userService.getAll().forEach(item -> userService.delete(item.getId()));
}
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> memberService.get(0L));
}
@Test
void createTest() {
Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
Assertions.assertEquals(member, memberService.get(member.getId()));
}
@Test
void createNullableTest() {
final MemberEntity nullableMember= new MemberEntity(null, null, null, null);
Assertions.assertThrows(DataIntegrityViolationException.class, () -> memberService.create(group.getId(), nullableMember));
}
@Test
void updateTest() {
final String test = "TEST";
final String oldName = member.getName();
final String oldHandle = member.getHandle();
final String oldRank = member.getRank();
final MemberEntity newEntity = memberService.update(member.getId(), new MemberEntity(test, test, test, null));
Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
Assertions.assertEquals(newEntity, memberService.get(member.getId()));
Assertions.assertEquals(test, newEntity.getName());
Assertions.assertEquals(test, newEntity.getHandle());
Assertions.assertEquals(test, newEntity.getRank());
Assertions.assertNotEquals(oldName, newEntity.getName());
Assertions.assertNotEquals(oldHandle, newEntity.getHandle());
Assertions.assertNotEquals(oldRank, newEntity.getRank());
}
@Test
void deleteTest() {
memberService.delete(member.getId());
Assertions.assertEquals(2, memberService.getAll(group.getId()).size());
final MemberEntity newEntity = memberService.create(group.getId(), new MemberEntity(member.getName(), member.getHandle(), member.getRank(),
member.getRating()));
Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
Assertions.assertNotEquals(member.getId(), newEntity.getId());
}
// user = userService.create(new UserEntity("oleg", "tester1", "1234"));
// group = groupService.create(user.getId(), new GroupEntity("group1"));
// member = memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1615L));
// memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1712L));
// memberService.create(group.getId(), new MemberEntity("member1", "mem1","expert", 1651L));
// }
// @AfterEach
// void removeData() {
// userService.getAll().forEach(item -> userService.delete(item.getId()));
// }
// @Test
// void getTest() {
// Assertions.assertThrows(NotFoundException.class, () -> memberService.get(0L));
// }
// @Test
// void createTest() {
// Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
// Assertions.assertEquals(member, memberService.get(member.getId()));
// }
// @Test
// void createNullableTest() {
// final MemberEntity nullableMember= new MemberEntity(null, null, null, null);
// Assertions.assertThrows(DataIntegrityViolationException.class, () -> memberService.create(group.getId(), nullableMember));
// }
// @Test
// void updateTest() {
// final String test = "TEST";
// final String oldName = member.getName();
// final String oldHandle = member.getHandle();
// final String oldRank = member.getRank();
// final MemberEntity newEntity = memberService.update(member.getId(), new MemberEntity(test, test, test, null));
// Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
// Assertions.assertEquals(newEntity, memberService.get(member.getId()));
// Assertions.assertEquals(test, newEntity.getName());
// Assertions.assertEquals(test, newEntity.getHandle());
// Assertions.assertEquals(test, newEntity.getRank());
// Assertions.assertNotEquals(oldName, newEntity.getName());
// Assertions.assertNotEquals(oldHandle, newEntity.getHandle());
// Assertions.assertNotEquals(oldRank, newEntity.getRank());
// }
// @Test
// void deleteTest() {
// memberService.delete(member.getId());
// Assertions.assertEquals(2, memberService.getAll(group.getId()).size());
// final MemberEntity newEntity = memberService.create(group.getId(), new MemberEntity(member.getName(), member.getHandle(), member.getRank(),
// member.getRating()));
// Assertions.assertEquals(3, memberService.getAll(group.getId()).size());
// Assertions.assertNotEquals(member.getId(), newEntity.getId());
// }
}

162
demo/src/test/java/com/example/demo/UserServiceTests.java
View File

@ -14,87 +14,87 @@ import com.example.demo.users.service.UserService;
@SpringBootTest
class UserServiceTests {
@Autowired
private UserService userService;
private UserEntity user;
// @Autowired
// private UserService userService;
// private UserEntity user;
@BeforeEach
void createData() {
removeData();
// @BeforeEach
// void createData() {
// removeData();
user = userService.create(new UserEntity("oleg", "tester1", "1234"));
userService.create(new UserEntity("arthur", "tester2", "123"));
userService.create(new UserEntity("egor", "tester3", "12345"));
}
@AfterEach
void removeData() {
userService.getAll().forEach(item -> userService.delete(item.getId()));
}
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> userService.get(0L));
}
@Test
void createTest() {
Assertions.assertEquals(3, userService.getAll().size());
Long id = user.getId();
var res = userService.get(user.getId());
Assertions.assertEquals(user, userService.get(user.getId()));
}
@Test
void createNotUniqueHandleTest() {
final UserEntity nonUniqueHandleUser = new UserEntity("oleg", "tester4", "1234");
Assertions.assertThrows(IllegalArgumentException.class, () -> userService.create(nonUniqueHandleUser));
}
@Test
void createNullableHandleTest() {
final UserEntity nullableUser = new UserEntity(null, "asads", "asdsad");
Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
}
@Test
void createNullableEmailTest() {
final UserEntity nullableUser = new UserEntity("asads", null, "asdsad");
Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
}
@Test
void createNullablePassswordTest() {
final UserEntity nullableUser = new UserEntity("asads", "asads", null);
Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
}
@Test
void updateTest() {
final String test = "TEST";
final String oldHandle = user.getHandle();
final String oldEmail = user.getEmail();
final String oldPassword = user.getPassword();
final UserEntity newEntity = userService.update(user.getId(), new UserEntity(test, test,test));
Assertions.assertEquals(3, userService.getAll().size());
Assertions.assertEquals(newEntity, userService.get(user.getId()));
Assertions.assertEquals(test, newEntity.getHandle());
Assertions.assertEquals(test, newEntity.getEmail());
Assertions.assertEquals(test, newEntity.getPassword());
Assertions.assertNotEquals(oldHandle, newEntity.getHandle());
Assertions.assertNotEquals(oldEmail, newEntity.getEmail());
Assertions.assertNotEquals(oldPassword, newEntity.getPassword());
}
@Test
void deleteTest() {
userService.delete(user.getId());
Assertions.assertEquals(2, userService.getAll().size());
final UserEntity newEntity = userService.create(new UserEntity(user.getHandle(), user.getEmail(), user.getPassword()));
Assertions.assertEquals(3, userService.getAll().size());
Assertions.assertNotEquals(user.getId(), newEntity.getId());
}
// user = userService.create(new UserEntity("oleg", "tester1", "1234"));
// userService.create(new UserEntity("arthur", "tester2", "123"));
// userService.create(new UserEntity("egor", "tester3", "12345"));
// }
// @AfterEach
// void removeData() {
// userService.getAll().forEach(item -> userService.delete(item.getId()));
// }
// @Test
// void getTest() {
// Assertions.assertThrows(NotFoundException.class, () -> userService.get(0L));
// }
// @Test
// void createTest() {
// Assertions.assertEquals(3, userService.getAll().size());
// Long id = user.getId();
// var res = userService.get(user.getId());
// Assertions.assertEquals(user, userService.get(user.getId()));
// }
// @Test
// void createNotUniqueHandleTest() {
// final UserEntity nonUniqueHandleUser = new UserEntity("oleg", "tester4", "1234");
// Assertions.assertThrows(IllegalArgumentException.class, () -> userService.create(nonUniqueHandleUser));
// }
// @Test
// void createNullableHandleTest() {
// final UserEntity nullableUser = new UserEntity(null, "asads", "asdsad");
// Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
// }
// @Test
// void createNullableEmailTest() {
// final UserEntity nullableUser = new UserEntity("asads", null, "asdsad");
// Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
// }
// @Test
// void createNullablePassswordTest() {
// final UserEntity nullableUser = new UserEntity("asads", "asads", null);
// Assertions.assertThrows(DataIntegrityViolationException.class, () -> userService.create(nullableUser));
// }
// @Test
// void updateTest() {
// final String test = "TEST";
// final String oldHandle = user.getHandle();
// final String oldEmail = user.getEmail();
// final String oldPassword = user.getPassword();
// final UserEntity newEntity = userService.update(user.getId(), new UserEntity(test, test,test));
// Assertions.assertEquals(3, userService.getAll().size());
// Assertions.assertEquals(newEntity, userService.get(user.getId()));
// Assertions.assertEquals(test, newEntity.getHandle());
// Assertions.assertEquals(test, newEntity.getEmail());
// Assertions.assertEquals(test, newEntity.getPassword());
// Assertions.assertNotEquals(oldHandle, newEntity.getHandle());
// Assertions.assertNotEquals(oldEmail, newEntity.getEmail());
// Assertions.assertNotEquals(oldPassword, newEntity.getPassword());
// }
// @Test
// void deleteTest() {
// userService.delete(user.getId());
// Assertions.assertEquals(2, userService.getAll().size());
// final UserEntity newEntity = userService.create(new UserEntity(user.getHandle(), user.getEmail(), user.getPassword()));
// Assertions.assertEquals(3, userService.getAll().size());
// Assertions.assertNotEquals(user.getId(), newEntity.getId());
// }
}