easytests.api.v1.controllers.UsersController - Code Metrics - Inspection of "Delete method for Users" - malinink/easy-tests - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — dev (#389)

unknown

created 2018-05-28 12:21 UTC

easytests.api.v1.controllers.UsersController A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	92
Duplicated Lines	0 %

Importance

Changes	4
Bugs	4	Features	0

Metric	Value
wmc	14
c	4
b	4
f	0
dl	0
loc	92
rs	10

9 Methods

Rating	Name	Size	Complexity
	isAdmin	2	?
A	isAdmin()	2	1
A	list()	11	2
A	show(Integer)	13	3
	showme	8	?
A	showme()	8	2
A	getUserModel(Integer,UsersOptionsInterface)	6	2
A	getUserModel(Integer)	2	1
A	delete(Integer)	14	3

package easytests.api.v1.controllers;

import easytests.api.v1.exceptions.*;
import easytests.api.v1.mappers.UsersMapper;
import easytests.api.v1.models.User;
import easytests.auth.services.SessionServiceInterface;
import easytests.core.models.UserModelInterface;
import easytests.core.options.UsersOptionsInterface;
import easytests.core.options.builder.UsersOptionsBuilderInterface;
import easytests.core.services.UsersServiceInterface;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;


/**
 * @author SvetlanaTselikova
 */
@RestController("UsersControllerV1")
@SuppressWarnings("checkstyle:MultipleStringLiterals")
@RequestMapping("/v1/users")
public class UsersController {

    @Autowired
    protected UsersServiceInterface usersService;

    @Autowired
    private UsersOptionsBuilderInterface usersOptionsBuilder;

    @Autowired
    private SessionServiceInterface sessionService;

    @Autowired
    @Qualifier("UsersMapperV1")
    private UsersMapper usersMapper;

    private Boolean isAdmin() {
        return this.sessionService.getUserModel().getIsAdmin();
    }

    @GetMapping("")
    public List<User> list() throws ForbiddenException {
        if (!this.isAdmin()) {
            throw new ForbiddenException();
        }
        final List<UserModelInterface> usersModels = this.usersService.findAll();

        return usersModels
                .stream()
                .map(model -> this.usersMapper.map(model, User.class))
                .collect(Collectors.toList());
    }

    /**
     * create
     */
    /**
     * update
     */
    @GetMapping("/{userId}")
    public User show(@PathVariable Integer userId) throws NotFoundException, ForbiddenException {
        final UserModelInterface userModel = this.usersService.find(userId);

        if (!this.isAdmin()) {
            throw new ForbiddenException();
        }

        if (userModel == null) {
            throw new NotFoundException();
        }

        return this.usersMapper.map(userModel, User.class);
    }

    @DeleteMapping("/{userId}")
    public void delete(@PathVariable Integer userId) throws NotFoundException, ForbiddenException {
        if (!this.isAdmin()) {
            throw new ForbiddenException();
        }

        final UsersOptionsInterface usersOptions = this.usersOptionsBuilder.forDelete();
        final UserModelInterface userModel = this.usersService.find(userId, usersOptions);

        if (userModel == null) {
            throw new NotFoundException();
        }

        this.usersService.delete(userModel, usersOptions);
    }

    @GetMapping("/me")
    public User showme() throws ForbiddenException {

        if (!this.sessionService.isUser()) {
            throw new ForbiddenException();
        }
        final UserModelInterface userModel = this.sessionService.getUserModel();
        return this.usersMapper.map(userModel, User.class);
    }

    private UserModelInterface getUserModel(Integer id, UsersOptionsInterface userOptions) throws NotFoundException {
        final UserModelInterface userModel = this.usersService.find(id, userOptions);
        if (userModel == null) {
            throw new NotFoundException();
        }
        return userModel;
    }

    private UserModelInterface getUserModel(Integer id) throws NotFoundException {

        return this.getUserModel(id, this.usersOptionsBuilder.forAuth());
    }

}


1			package easytests.api.v1.controllers;
2
3			import easytests.api.v1.exceptions.*;
4			import easytests.api.v1.mappers.UsersMapper;
5			import easytests.api.v1.models.User;
6			import easytests.auth.services.SessionServiceInterface;
7			import easytests.core.models.UserModelInterface;
8			import easytests.core.options.UsersOptionsInterface;
9			import easytests.core.options.builder.UsersOptionsBuilderInterface;
10			import easytests.core.services.UsersServiceInterface;
11			import java.util.List;
12			import java.util.stream.Collectors;
13			import org.springframework.beans.factory.annotation.Autowired;
14			import org.springframework.beans.factory.annotation.Qualifier;
15			import org.springframework.web.bind.annotation.*;
16
17
18			/**
19			* @author SvetlanaTselikova
20			*/
21			@RestController("UsersControllerV1")
22			@SuppressWarnings("checkstyle:MultipleStringLiterals")
23			@RequestMapping("/v1/users")
24			public class UsersController {
25
26			@Autowired
27			protected UsersServiceInterface usersService;
28
29			@Autowired
30			private UsersOptionsBuilderInterface usersOptionsBuilder;
31
32			@Autowired
33			private SessionServiceInterface sessionService;
34
35			@Autowired
36			@Qualifier("UsersMapperV1")
37			private UsersMapper usersMapper;
38
39			private Boolean isAdmin() {
40			return this.sessionService.getUserModel().getIsAdmin();
41			}
42
43			@GetMapping("")
44			public List<User> list() throws ForbiddenException {
45			if (!this.isAdmin()) {
46			throw new ForbiddenException();
47			}
48			final List<UserModelInterface> usersModels = this.usersService.findAll();
49
50			return usersModels
51			.stream()
52			.map(model -> this.usersMapper.map(model, User.class))
53			.collect(Collectors.toList());
54			}
55
56			/**
57			* create
58			*/
59			/**
60			* update
61			*/
62			@GetMapping("/{userId}")
63			public User show(@PathVariable Integer userId) throws NotFoundException, ForbiddenException {
64			final UserModelInterface userModel = this.usersService.find(userId);
65
66			if (!this.isAdmin()) {
67			throw new ForbiddenException();
68			}
69
70			if (userModel == null) {
71			throw new NotFoundException();
72			}
73
74			return this.usersMapper.map(userModel, User.class);
75			}
76
77			@DeleteMapping("/{userId}")
78			public void delete(@PathVariable Integer userId) throws NotFoundException, ForbiddenException {
79			if (!this.isAdmin()) {
80			throw new ForbiddenException();
81			}
82
83			final UsersOptionsInterface usersOptions = this.usersOptionsBuilder.forDelete();
84			final UserModelInterface userModel = this.usersService.find(userId, usersOptions);
85
86			if (userModel == null) {
87			throw new NotFoundException();
88			}
89
90			this.usersService.delete(userModel, usersOptions);
91			}
92
93			@GetMapping("/me")
94			public User showme() throws ForbiddenException {
95
96			if (!this.sessionService.isUser()) {
97			throw new ForbiddenException();
98			}
99			final UserModelInterface userModel = this.sessionService.getUserModel();
100			return this.usersMapper.map(userModel, User.class);
101			}
102
103			private UserModelInterface getUserModel(Integer id, UsersOptionsInterface userOptions) throws NotFoundException {
104			final UserModelInterface userModel = this.usersService.find(id, userOptions);
105			if (userModel == null) {
106			throw new NotFoundException();
107			}
108			return userModel;
109			}
110
111			private UserModelInterface getUserModel(Integer id) throws NotFoundException {
			0 ignored issues – show Unused Code introduced 2018-05-25 18:27 UTC by Report Bug Copy Issue Report Remove this unused private "getUserModel" method. Loading history...
112			return this.getUserModel(id, this.usersOptionsBuilder.forAuth());
113			}
114
115			}
116

malinink / easy-tests

Pull Request — dev (#389)

easytests.api.v1.controllers.UsersController A

Complexity

Size/Duplication

Importance

9 Methods

Duplication Side-by-Side

Filter issues like