Projekt

Obecné

Profil

« Předchozí | Další » 

Revize 0917eae7

Přidáno uživatelem Tomáš Šimandl před více než 6 roky(ů)

#7 Use SLF4J logger

- added some log messages

Zobrazit rozdíly:

sources/src/main/java/cz/zcu/kiv/offscreen/servlets/ShowGraph.java
1 1
package cz.zcu.kiv.offscreen.servlets;
2 2

  
3
import org.apache.logging.log4j.LogManager;
4
import org.apache.logging.log4j.Logger;
5

  
3 6
import javax.servlet.RequestDispatcher;
4 7
import javax.servlet.ServletException;
5 8
import javax.servlet.http.HttpServletRequest;
......
11 14
 * @author Jindra Pavlíková <jindra.pav2@seznam.cz>
12 15
 */
13 16
public class ShowGraph extends BaseServlet {
17
    private static final Logger logger = LogManager.getLogger();
14 18

  
15 19
    @Override
16 20
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
21
        logger.debug("Processing request");
22

  
17 23
        // render
18 24
        RequestDispatcher rd = getServletContext().getRequestDispatcher("/showGraph.jsp");
19 25
        rd.forward(request, response);
26
        logger.debug("Request processed");
20 27
    }
21 28

  
22 29
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/UploadFiles.java
4 4
import cz.zcu.kiv.offscreen.storage.FileLoader;
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.Diagram;
7
import org.apache.logging.log4j.LogManager;
8
import org.apache.logging.log4j.Logger;
7 9

  
8 10
import javax.servlet.RequestDispatcher;
9 11
import javax.servlet.ServletException;
......
19 21
 * @author Jindra Pavlíková <jindra.pav2@seznam.cz>
20 22
 */
21 23
public class UploadFiles extends BaseServlet {
24
    private static final Logger logger = LogManager.getLogger();
22 25

  
23 26
    @Override
24 27
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
28
        logger.debug("Processing request");
25 29
        DB db = new DB(getServletContext());
26 30
        Diagram diagram = new Diagram(db);
27 31

  
28 32
        List<Map<String, String>> userDiagramList = new ArrayList<>();
29 33
        if (isLoggedIn(request)) {
34
            logger.debug("Logged user");
30 35
            int loggedUserId = getUserId(request);
31 36

  
32 37
            userDiagramList = diagram.getDiagramListByUserId(loggedUserId);
......
39 44
        // render
40 45
        RequestDispatcher rd = getServletContext().getRequestDispatcher("/uploadFiles.jsp");
41 46
        rd.forward(request, response);
47
        logger.debug("Request processed");
42 48
    }
43 49

  
44 50
    @Override
45 51
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
52
        logger.debug("Processing request");
46 53
        Map<String, String> jsonData = new FileLoader().loadFile(request);
47 54

  
48 55
        if(!jsonData.containsKey("file") || !jsonData.containsKey("jsonFileFormat")) {
49 56
            request.setAttribute("errorMessage", "<strong>Invalid request!</strong><br/>");
57
            logger.debug("Invalid request");
50 58
            doGet(request, response);
51 59

  
52 60
        } else if (Strings.isNullOrEmpty(jsonData.get("file"))) {
53 61
            request.setAttribute("errorMessage", "<strong>Unsupported file</strong><br/>");
62
            logger.debug("Empty diagram json");
54 63
            doGet(request, response);
55 64
        } else {
56 65
            request.getSession().setAttribute("json_graph", jsonData.get("file"));
57 66
            request.getSession().setAttribute("json_graph_type", jsonData.get("jsonFileFormat"));
58 67
            request.getSession().setAttribute("graph_filename", jsonData.get("filename"));
59 68
            response.sendRedirect(getServletContext().getInitParameter("APP_HOME_URL") + "graph");
69
            logger.debug("send redirect to /graph");
60 70
        }
71
        logger.debug("Request processed");
61 72
    }
62 73
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/GetDBDiagram.java
4 4
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.Diagram;
7
import org.apache.logging.log4j.LogManager;
8
import org.apache.logging.log4j.Logger;
7 9
import org.json.JSONObject;
8 10

  
9 11
import javax.servlet.http.HttpServletRequest;
......
15 17
 */
16 18
public class GetDBDiagram extends BaseServlet {
17 19

  
20
    private static final Logger logger = LogManager.getLogger();
21

  
18 22
    @Override
19 23
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
24
        logger.debug("Processing request");
20 25
        String diagramId = request.getParameter("id");
21 26

  
22 27
        if (Strings.isNullOrEmpty(diagramId)) {
23 28
            response.sendError(HttpServletResponse.SC_BAD_REQUEST);
29
            logger.debug("Diagram id is empty");
24 30
            return;
25 31
        }
26 32

  
......
29 35

  
30 36
        if (!diagram.isPublic() && (!isLoggedIn(request) || (isLoggedIn(request) && diagram.getUserId() != getUserId(request)))) {
31 37
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
38
            logger.debug("User is unauthorized");
32 39
            return;
33 40
        }
34 41

  
......
39 46
        response.setStatus(HttpServletResponse.SC_OK);
40 47
        response.getWriter().write(json.toString());
41 48
        response.getWriter().flush();
49
        logger.debug("Response OK");
42 50
    }
43 51
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/GetPrivateDiagrams.java
3 3
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
4 4
import cz.zcu.kiv.offscreen.user.DB;
5 5
import cz.zcu.kiv.offscreen.user.Diagram;
6
import org.apache.logging.log4j.LogManager;
7
import org.apache.logging.log4j.Logger;
6 8
import org.json.JSONArray;
7 9
import org.json.JSONObject;
8 10

  
......
14 16

  
15 17
public class GetPrivateDiagrams extends BaseServlet {
16 18

  
19
    private static final Logger logger = LogManager.getLogger();
20

  
17 21
    @Override
18 22
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
23
        logger.debug("Processing request");
24

  
19 25
        if (!isLoggedIn(request)) {
20 26
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
27
            logger.debug("User is unauthorized");
21 28
            return;
22 29
        }
23 30

  
......
37 44
        response.setStatus(HttpServletResponse.SC_OK);
38 45
        response.getWriter().write(json.toString());
39 46
        response.getWriter().flush();
47
        logger.debug("Response OK");
48

  
40 49
    }
41 50
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/GetSessionDiagram.java
8 8
import cz.zcu.kiv.offscreen.graph.loader.JSONConfigLoader;
9 9
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
10 10
import net.sf.json.JSONObject;
11
import org.apache.logging.log4j.LogManager;
12
import org.apache.logging.log4j.Logger;
11 13

  
12 14
import javax.servlet.http.HttpServletRequest;
13 15
import javax.servlet.http.HttpServletResponse;
......
17 19
 * This class is used for loading diagrams from session.
18 20
 */
19 21
public class GetSessionDiagram extends BaseServlet {
22
    private static final Logger logger = LogManager.getLogger();
20 23

  
21 24
    /**
22 25
     * Constructs graph data using either the current graph version or the version set in query parameter. Resulting
......
24 27
     */
25 28
    @Override
26 29
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
30
        logger.debug("Processing request");
31

  
27 32
        response.setContentType("application/json");
28 33
        response.setCharacterEncoding("UTF-8");
29 34

  
......
44 49

  
45 50
            switch (jsonType) {
46 51
                case "spade":
52
                    logger.debug("Processing Spade json");
47 53
                    rawJson = convertSpadeToRawJson(jsonToDisplay);
48 54
                    break;
49 55
                default:
56
                    logger.debug("Processing Raw json");
50 57
                    rawJson = jsonToDisplay;
51 58
            }
52 59

  
......
57 64
            response.setStatus(HttpServletResponse.SC_OK);
58 65
            response.getWriter().write(jsonObject.toString());
59 66
            response.getWriter().flush();
67
            logger.debug("Response OK");
60 68
            return;
61 69
        }
62 70

  
63 71
        response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
72
        logger.debug("Response BAD REQUEST");
64 73
    }
65 74

  
66 75
    /**
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/Login.java
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.User;
7 7
import cz.zcu.kiv.offscreen.vo.UserVO;
8
import org.apache.logging.log4j.LogManager;
9
import org.apache.logging.log4j.Logger;
8 10
import org.json.JSONObject;
9 11

  
10 12
import javax.servlet.http.HttpServletRequest;
......
14 16
import java.util.Map;
15 17

  
16 18
public class Login extends BaseServlet {
19
    private static final Logger logger = LogManager.getLogger();
17 20

  
18 21
    @Override
19 22
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
23
        logger.debug("Processing request");
20 24
        String username = request.getParameter("username");
21 25
        String password = request.getParameter("password");
22 26

  
......
24 28

  
25 29
        if (Strings.isNullOrEmpty(username)) {
26 30
            errors.put("username", "Please enter username.");
31
            logger.debug("Empty user name");
27 32
        }
28 33

  
29 34
        if (Strings.isNullOrEmpty(password)) {
30 35
            errors.put("password", "Please enter password.");
36
            logger.debug("Empty password");
31 37
        }
32 38

  
33 39
        if (errors.isEmpty()) {
......
54 60
                response.setStatus(HttpServletResponse.SC_ACCEPTED);
55 61
                response.getWriter().write(json.toString());
56 62
                response.getWriter().flush();
63
                logger.debug("Response ACCEPTED");
57 64

  
58 65
            } else {
59 66
                request.getSession().setAttribute("isLoggedIn", false);
......
61 68
                request.getSession().setAttribute("user", null);
62 69

  
63 70
                response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
71
                logger.debug("Response UNAUTHORIZED");
64 72
            }
65 73

  
66 74
        } else {
......
71 79
            response.setContentType("application/json");
72 80
            response.getWriter().write(json.toString());
73 81
            response.getWriter().flush();
82
            logger.debug("Response BAD REQUEST");
74 83
        }
75 84
    }
76 85
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/Logout.java
1 1
package cz.zcu.kiv.offscreen.servlets.api;
2 2

  
3 3
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
4
import org.apache.logging.log4j.LogManager;
5
import org.apache.logging.log4j.Logger;
4 6

  
5 7
import javax.servlet.http.HttpServletRequest;
6 8
import javax.servlet.http.HttpServletResponse;
7 9

  
8 10
public class Logout extends BaseServlet {
9
	
11
    private static final Logger logger = LogManager.getLogger();
12

  
10 13
    @Override
11 14
    protected void doGet(HttpServletRequest request, HttpServletResponse response) {
15
        logger.debug("Processing request");
12 16
        request.getSession().setAttribute("isLoggedIn", false);
13 17
        request.getSession().setAttribute("userId", null);
14 18
        request.getSession().setAttribute("user", null);
15 19

  
16 20
        response.setStatus(HttpServletResponse.SC_RESET_CONTENT);
21
        logger.debug("Response RESET CONTENT");
17 22
    }
18 23
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/Register.java
4 4
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.User;
7
import org.apache.logging.log4j.LogManager;
8
import org.apache.logging.log4j.Logger;
7 9
import org.json.JSONObject;
8 10

  
9 11
import javax.servlet.http.HttpServletRequest;
......
15 17
import java.util.regex.Pattern;
16 18

  
17 19
public class Register extends BaseServlet {
18
    
19
    private static final String EMAIL_ADDRESS_PATTERN = "^[A-Za-z0-9-\\+_]+(\\.[A-Za-z0-9-_]+)*@" +
20
	private static final Logger logger = LogManager.getLogger();
21
	private static final String EMAIL_ADDRESS_PATTERN = "^[A-Za-z0-9-\\+_]+(\\.[A-Za-z0-9-_]+)*@" +
20 22
    											"[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*" +
21 23
    											"(\\.[A-Za-z]{2,})$";
22 24
    
23 25
    @Override
24 26
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
27
		logger.debug("Processing request");
25 28
		String name = request.getParameter("name");
26 29
		String email = request.getParameter("email");
27 30
		String username = request.getParameter("username");
......
35 38

  
36 39
		if (Strings.isNullOrEmpty(name)) {
37 40
			errors.put("name", "Please enter name.");
41
			logger.debug("Empty name");
38 42
		}
39 43

  
40 44
		if (Strings.isNullOrEmpty(email)) {
41 45
			errors.put("email", "Please enter e-mail address.");
46
			logger.debug("Empty e-mail address");
47

  
42 48
		} else if (!isEmailAddressValid(email)) {
43 49
			errors.put("email", "Please enter valid e-mail address.");
50
			logger.debug("Invalid e-mail address");
51

  
44 52
		} else if (user.isEmailExists(email)) {
45 53
			errors.put("email", "E-mail already exists.");
54
			logger.debug("E-mail exists");
46 55
		}
47 56

  
48 57
		if (Strings.isNullOrEmpty(username)) {
49 58
			errors.put("username", "Please enter username.");
59
			logger.debug("Empty user name");
60

  
50 61
		} else if (user.isNickExists(username)) {
51 62
			errors.put("username", "Nickname already exists.");
63
			logger.debug("Username(nickname) exists");
52 64
		}
53 65
    	
54 66
    	if (Strings.isNullOrEmpty(password) || Strings.isNullOrEmpty(passwordCheck)) {
55 67
    		errors.put("password", "Please enter password.");
56
    	} else if (password.length() < 5) {
68
			logger.debug("Empty password");
69

  
70
		} else if (password.length() < 5) {
57 71
    		errors.put("password", "Passwords must be at least 5 characters long.");
72
			logger.debug("Invalid password");
73

  
58 74
		} else if (!password.equals(passwordCheck)) {
59 75
			errors.put("passwordCheck", "Passwords must be equal.");
60
    	}
76
			logger.debug("Passwords not match");
77
		}
61 78

  
62 79
    	if (errors.isEmpty()) {
63 80
    		Map<String, String> userMap = new HashMap<>();
......
70 87
    		user.register(userMap);
71 88

  
72 89
			response.setStatus(HttpServletResponse.SC_CREATED);
90
			logger.debug("User created");
73 91

  
74
    	} else {
92
		} else {
75 93
			JSONObject json = new JSONObject();
76 94
			json.put("error", new JSONObject(errors));
77 95

  
......
79 97
			response.setContentType("application/json");
80 98
			response.getWriter().write(json.toString());
81 99
			response.getWriter().flush();
100
			logger.debug("Response BAD REQUEST");
82 101
		}
83 102
    }
84 103
    
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/RemoveDiagram.java
4 4
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.Diagram;
7
import org.apache.logging.log4j.LogManager;
8
import org.apache.logging.log4j.Logger;
7 9

  
8 10
import javax.servlet.http.HttpServletRequest;
9 11
import javax.servlet.http.HttpServletResponse;
10 12
import java.io.IOException;
11 13

  
12 14
public class RemoveDiagram extends BaseServlet {
15
    private static final Logger logger = LogManager.getLogger();
13 16

  
14 17
    @Override
15 18
    protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws IOException {
19
        logger.debug("Processing request");
16 20
        if (!isLoggedIn(request)) {
17 21
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
22
            logger.debug("User is unauthorized");
18 23
            return;
19 24
        }
20 25

  
......
24 29

  
25 30
        if (Strings.isNullOrEmpty(diagramId)) {
26 31
            response.sendError(HttpServletResponse.SC_BAD_REQUEST);
32
            logger.debug("Empty diagram id");
27 33
            return;
28 34
        }
29 35

  
......
32 38

  
33 39
        if (diagram.getUserId() != loggedUserId) {
34 40
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
41
            logger.debug("User is not owner of diagram");
35 42
            return;
36 43
        }
37 44

  
38 45
        diagram.delete();
46
        logger.debug("Diagram removed");
39 47

  
40 48
        response.setStatus(HttpServletResponse.SC_NO_CONTENT);
41 49
    }
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/api/SaveDiagram.java
4 4
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
5 5
import cz.zcu.kiv.offscreen.user.DB;
6 6
import cz.zcu.kiv.offscreen.user.Diagram;
7
import org.apache.logging.log4j.LogManager;
8
import org.apache.logging.log4j.Logger;
7 9
import org.json.JSONObject;
8 10

  
9 11
import javax.servlet.http.HttpServletRequest;
......
13 15
import java.util.Map;
14 16

  
15 17
public class SaveDiagram extends BaseServlet {
18
    private static final Logger logger = LogManager.getLogger();
16 19

  
17 20
    @Override
18 21
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws IOException {
22
        logger.debug("Processing request");
23

  
19 24
        if (!isLoggedIn(request)) {
20 25
            response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
26
            logger.debug("User is unauthorized");
21 27
            return;
22 28
        }
23 29

  
......
33 39
        // input parameters are invalid
34 40
        if (Strings.isNullOrEmpty(name) || Strings.isNullOrEmpty(graphJson)) {
35 41
            response.sendError(HttpServletResponse.SC_BAD_REQUEST);
42
            logger.debug("Input name or json is empty");
36 43
            return;
37 44
        }
38 45

  
......
40 47
        Diagram diagram;
41 48

  
42 49
        if (Strings.isNullOrEmpty(diagramId)) {
43
            // new diagram
50
            logger.debug("Creating new diagram");
44 51
            diagram = new Diagram(db);
45 52

  
46 53
        } else {
47
            // diagram exists
54
            logger.debug("Getting existing diagram from database");
48 55
            diagram = new Diagram(db, Integer.parseInt(diagramId));
49 56

  
50
            // user is not owner of the diagram
51 57
            if (loggedUserId != diagram.getUserId()) {
52 58
                response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
59
                logger.debug("User is not owner of diagram");
53 60
                return;
54 61
            }
55 62
        }
......
61 68
        diagramParams.put("user_id", Integer.toString(loggedUserId));
62 69

  
63 70
        diagram.update(diagramParams);
71
        logger.debug("Diagram created or updated.");
64 72

  
65 73
        // send response
66 74
        JSONObject json = new JSONObject(diagram.getDiagram());
......
70 78
        response.setStatus(HttpServletResponse.SC_OK);
71 79
        response.getWriter().write(json.toString());
72 80
        response.getWriter().flush();
81
        logger.debug("Response OK");
73 82
    }
74 83
}
sources/src/main/java/cz/zcu/kiv/offscreen/servlets/rest/RawInput.java
2 2

  
3 3
import com.google.common.base.Strings;
4 4
import cz.zcu.kiv.offscreen.servlets.BaseServlet;
5
import org.apache.logging.log4j.LogManager;
6
import org.apache.logging.log4j.Logger;
5 7

  
6 8
import javax.servlet.ServletException;
7 9
import javax.servlet.http.HttpServletRequest;
......
12 14
 * @author Tomáš Šimandl
13 15
 */
14 16
public class RawInput extends BaseServlet {
17
    private static final Logger logger = LogManager.getLogger();
15 18

  
16 19
    @Override
17 20
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
21
        logger.debug("Processing request");
18 22
        request.setCharacterEncoding("UTF-8");
19 23
        String diagram = request.getParameter("rawDiagram");
20 24
        String type = "raw";
21 25

  
22 26
        if (Strings.isNullOrEmpty(diagram)) {
23 27
            response.sendError(HttpServletResponse.SC_BAD_REQUEST);
28
            logger.debug("Diagram json is empty");
24 29
            return;
25 30
        }
26 31

  
27 32
        request.getSession().setAttribute("json_graph", diagram);
28 33
        request.getSession().setAttribute("json_graph_type", type);
29 34
        response.sendRedirect(getServletContext().getInitParameter("HOME_URL") + "graph");
35
        logger.debug("Send redirect to /graph");
30 36
    }
31 37
}
sources/src/main/java/cz/zcu/kiv/offscreen/user/DB.java
28 28
		String password = context.getInitParameter("jdbc.password");
29 29

  
30 30
		try {
31
			logger.debug("Opening database connection");
31 32
			Class.forName(driverClassName);
32 33
			connection = DriverManager.getConnection(url, username, password);
33 34
			connection.setAutoCommit(true);

Také k dispozici: Unified diff