Mercurial > hg > LightPIT / file comparison

comparison: src/main/java/de/uapcore/lightpit/modules/ProjectsModule.java

src/main/java/de/uapcore/lightpit/modules/ProjectsModule.java

changeset 157
1e6f16fad3a5
parent 152
7761c37c5e61
child 158
4f912cd42876
equal deleted inserted replaced
156:c5d6820d884e 157:1e6f16fad3a5
36 import de.uapcore.lightpit.viewmodel.*; 36 import de.uapcore.lightpit.viewmodel.*;
37 import de.uapcore.lightpit.viewmodel.util.IssueSorter; 37 import de.uapcore.lightpit.viewmodel.util.IssueSorter;
38 import org.slf4j.Logger; 38 import org.slf4j.Logger;
39 import org.slf4j.LoggerFactory; 39 import org.slf4j.LoggerFactory;
40 40
41 import javax.servlet.ServletException;
41 import javax.servlet.annotation.WebServlet; 42 import javax.servlet.annotation.WebServlet;
42 import javax.servlet.http.HttpServletRequest; 43 import javax.servlet.http.HttpServletRequest;
43 import javax.servlet.http.HttpServletResponse; 44 import javax.servlet.http.HttpServletResponse;
44 import java.io.IOException; 45 import java.io.IOException;
45 import java.sql.Date; 46 import java.sql.Date;
113 } else { 114 } else {
114 return result; 115 return result;
115 } 116 }
116 } 117 }
117 118
118 private ResponseType forwardView(HttpServletRequest req, ProjectView viewModel, String name) { 119 private void forwardView(HttpServletRequest req, HttpServletResponse resp, ProjectView viewModel, String name) throws ServletException, IOException {
119 setViewModel(req, viewModel); 120 setViewModel(req, viewModel);
120 setContentPage(req, name); 121 setContentPage(req, name);
121 setStylesheet(req, "projects"); 122 setStylesheet(req, "projects");
122 setNavigationMenu(req, "project-navmenu"); 123 setNavigationMenu(req, "project-navmenu");
123 return ResponseType.HTML; 124 renderSite(req, resp);
124 } 125 }
125 126
126 @RequestMapping(method = HttpMethod.GET) 127 @RequestMapping(method = HttpMethod.GET)
127 public ResponseType index(HttpServletRequest req, DataAccessObjects dao) throws SQLException { 128 public void index(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws SQLException, ServletException, IOException {
128 final var viewModel = new ProjectView(); 129 final var viewModel = new ProjectView();
129 populate(viewModel, null, dao); 130 populate(viewModel, null, dao);
130 131
131 final var projectDao = dao.getProjectDao(); 132 final var projectDao = dao.getProjectDao();
132 final var versionDao = dao.getVersionDao(); 133 final var versionDao = dao.getVersionDao();
134 for (var info : viewModel.getProjectList()) { 135 for (var info : viewModel.getProjectList()) {
135 info.setVersions(versionDao.list(info.getProject())); 136 info.setVersions(versionDao.list(info.getProject()));
136 info.setIssueSummary(projectDao.getIssueSummary(info.getProject())); 137 info.setIssueSummary(projectDao.getIssueSummary(info.getProject()));
137 } 138 }
138 139
139 return forwardView(req, viewModel, "projects"); 140 forwardView(req, resp, viewModel, "projects");
140 } 141 }
141 142
142 private void configureProjectEditor(ProjectEditView viewModel, Project project, DataAccessObjects dao) throws SQLException { 143 private void configureProjectEditor(ProjectEditView viewModel, Project project, DataAccessObjects dao) throws SQLException {
143 viewModel.setProject(project); 144 viewModel.setProject(project);
144 viewModel.setUsers(dao.getUserDao().list()); 145 viewModel.setUsers(dao.getUserDao().list());
145 } 146 }
146 147
147 @RequestMapping(requestPath = "$project/edit", method = HttpMethod.GET) 148 @RequestMapping(requestPath = "$project/edit", method = HttpMethod.GET)
148 public ResponseType edit(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws IOException, SQLException { 149 public void edit(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws IOException, SQLException, ServletException {
149 final var viewModel = new ProjectEditView(); 150 final var viewModel = new ProjectEditView();
150 populate(viewModel, pathParams, dao); 151 populate(viewModel, pathParams, dao);
151 152
152 if (!viewModel.isProjectInfoPresent()) { 153 if (!viewModel.isProjectInfoPresent()) {
153 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 154 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
154 return ResponseType.NONE; 155 return;
155 } 156 }
156 157
157 configureProjectEditor(viewModel, viewModel.getProjectInfo().getProject(), dao); 158 configureProjectEditor(viewModel, viewModel.getProjectInfo().getProject(), dao);
158 return forwardView(req, viewModel, "project-form"); 159 forwardView(req, resp, viewModel, "project-form");
159 } 160 }
160 161
161 @RequestMapping(requestPath = "create", method = HttpMethod.GET) 162 @RequestMapping(requestPath = "create", method = HttpMethod.GET)
162 public ResponseType create(HttpServletRequest req, DataAccessObjects dao) throws SQLException { 163 public void create(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws SQLException, ServletException, IOException {
163 final var viewModel = new ProjectEditView(); 164 final var viewModel = new ProjectEditView();
164 populate(viewModel, null, dao); 165 populate(viewModel, null, dao);
165 configureProjectEditor(viewModel, new Project(-1), dao); 166 configureProjectEditor(viewModel, new Project(-1), dao);
166 return forwardView(req, viewModel, "project-form"); 167 forwardView(req, resp, viewModel, "project-form");
167 } 168 }
168 169
169 @RequestMapping(requestPath = "commit", method = HttpMethod.POST) 170 @RequestMapping(requestPath = "commit", method = HttpMethod.POST)
170 public ResponseType commit(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException { 171 public void commit(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException, ServletException {
171 172
172 try { 173 try {
173 final var project = new Project(getParameter(req, Integer.class, "pid").orElseThrow()); 174 final var project = new Project(getParameter(req, Integer.class, "pid").orElseThrow());
174 project.setName(getParameter(req, String.class, "name").orElseThrow()); 175 project.setName(getParameter(req, String.class, "name").orElseThrow());
175 176
186 187
187 setRedirectLocation(req, "./projects/"); 188 setRedirectLocation(req, "./projects/");
188 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL); 189 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);
189 LOG.debug("Successfully updated project {}", project.getName()); 190 LOG.debug("Successfully updated project {}", project.getName());
190 191
191 return ResponseType.HTML; 192 renderSite(req, resp);
192 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) { 193 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {
193 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED); 194 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
194 // TODO: implement - fix issue #21 195 // TODO: implement - fix issue #21
195 return ResponseType.NONE;
196 } 196 }
197 } 197 }
198 198
199 @RequestMapping(requestPath = "$project/$component/$version/issues/", method = HttpMethod.GET) 199 @RequestMapping(requestPath = "$project/$component/$version/issues/", method = HttpMethod.GET)
200 public ResponseType issues(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws SQLException, IOException { 200 public void issues(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws SQLException, IOException, ServletException {
201 final var viewModel = new ProjectDetailsView(); 201 final var viewModel = new ProjectDetailsView();
202 populate(viewModel, pathParams, dao); 202 populate(viewModel, pathParams, dao);
203 203
204 if (!viewModel.isEveryFilterValid()) { 204 if (!viewModel.isEveryFilterValid()) {
205 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 205 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
206 return ResponseType.NONE; 206 return;
207 } 207 }
208 208
209 final var project = viewModel.getProjectInfo().getProject(); 209 final var project = viewModel.getProjectInfo().getProject();
210 final var version = viewModel.getVersionFilter(); 210 final var version = viewModel.getVersionFilter();
211 final var component = viewModel.getComponentFilter(); 211 final var component = viewModel.getComponentFilter();
249 249
250 viewModel.getProjectDetails().updateDetails(issues); 250 viewModel.getProjectDetails().updateDetails(issues);
251 if (version.getId() > 0) 251 if (version.getId() > 0)
252 viewModel.getProjectDetails().updateVersionInfo(version); 252 viewModel.getProjectDetails().updateVersionInfo(version);
253 253
254 return forwardView(req, viewModel, "project-details"); 254 forwardView(req, resp, viewModel, "project-details");
255 } 255 }
256 256
257 @RequestMapping(requestPath = "$project/versions/", method = HttpMethod.GET) 257 @RequestMapping(requestPath = "$project/versions/", method = HttpMethod.GET)
258 public ResponseType versions(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 258 public void versions(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
259 final var viewModel = new VersionsView(); 259 final var viewModel = new VersionsView();
260 populate(viewModel, pathParameters, dao); 260 populate(viewModel, pathParameters, dao);
261 261
262 final var projectInfo = viewModel.getProjectInfo(); 262 final var projectInfo = viewModel.getProjectInfo();
263 if (projectInfo == null) { 263 if (projectInfo == null) {
264 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 264 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
265 return ResponseType.NONE; 265 return;
266 } 266 }
267 267
268 final var issueDao = dao.getIssueDao(); 268 final var issueDao = dao.getIssueDao();
269 final var issues = issueDao.list(projectInfo.getProject()); 269 final var issues = issueDao.list(projectInfo.getProject());
270 for (var issue : issues) issueDao.joinVersionInformation(issue); 270 for (var issue : issues) issueDao.joinVersionInformation(issue);
271 viewModel.update(projectInfo.getVersions(), issues); 271 viewModel.update(projectInfo.getVersions(), issues);
272 272
273 return forwardView(req, viewModel, "versions"); 273 forwardView(req, resp, viewModel, "versions");
274 } 274 }
275 275
276 @RequestMapping(requestPath = "$project/versions/$version/edit", method = HttpMethod.GET) 276 @RequestMapping(requestPath = "$project/versions/$version/edit", method = HttpMethod.GET)
277 public ResponseType editVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 277 public void editVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
278 final var viewModel = new VersionEditView(); 278 final var viewModel = new VersionEditView();
279 populate(viewModel, pathParameters, dao); 279 populate(viewModel, pathParameters, dao);
280 280
281 if (viewModel.getProjectInfo() == null || viewModel.getVersionFilter() == null) { 281 if (viewModel.getProjectInfo() == null || viewModel.getVersionFilter() == null) {
282 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 282 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
283 return ResponseType.NONE; 283 return;
284 } 284 }
285 285
286 viewModel.setVersion(viewModel.getVersionFilter()); 286 viewModel.setVersion(viewModel.getVersionFilter());
287 287
288 return forwardView(req, viewModel, "version-form"); 288 forwardView(req, resp, viewModel, "version-form");
289 } 289 }
290 290
291 @RequestMapping(requestPath = "$project/create-version", method = HttpMethod.GET) 291 @RequestMapping(requestPath = "$project/create-version", method = HttpMethod.GET)
292 public ResponseType createVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 292 public void createVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
293 final var viewModel = new VersionEditView(); 293 final var viewModel = new VersionEditView();
294 populate(viewModel, pathParameters, dao); 294 populate(viewModel, pathParameters, dao);
295 295
296 if (viewModel.getProjectInfo() == null) { 296 if (viewModel.getProjectInfo() == null) {
297 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 297 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
298 return ResponseType.NONE; 298 return;
299 } 299 }
300 300
301 viewModel.setVersion(new Version(-1)); 301 viewModel.setVersion(new Version(-1));
302 302
303 return forwardView(req, viewModel, "version-form"); 303 forwardView(req, resp, viewModel, "version-form");
304 } 304 }
305 305
306 @RequestMapping(requestPath = "commit-version", method = HttpMethod.POST) 306 @RequestMapping(requestPath = "commit-version", method = HttpMethod.POST)
307 public ResponseType commitVersion(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException { 307 public void commitVersion(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException, ServletException {
308 308
309 try { 309 try {
310 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow()); 310 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow());
311 if (project == null) { 311 if (project == null) {
312 // TODO: improve error handling, because not found is not correct for this POST request 312 // TODO: improve error handling, because not found is not correct for this POST request
313 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 313 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
314 return ResponseType.NONE; 314 return;
315 } 315 }
316 final var version = new Version(getParameter(req, Integer.class, "id").orElseThrow()); 316 final var version = new Version(getParameter(req, Integer.class, "id").orElseThrow());
317 version.setName(getParameter(req, String.class, "name").orElseThrow()); 317 version.setName(getParameter(req, String.class, "name").orElseThrow());
318 318
319 final var node = getParameter(req, String.class, "node").orElse(null); 319 final var node = getParameter(req, String.class, "node").orElse(null);
323 version.setStatus(VersionStatus.valueOf(getParameter(req, String.class, "status").orElseThrow())); 323 version.setStatus(VersionStatus.valueOf(getParameter(req, String.class, "status").orElseThrow()));
324 dao.getVersionDao().saveOrUpdate(version, project); 324 dao.getVersionDao().saveOrUpdate(version, project);
325 325
326 setRedirectLocation(req, "./projects/" + project.getNode() + "/versions/"); 326 setRedirectLocation(req, "./projects/" + project.getNode() + "/versions/");
327 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL); 327 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);
328
329 renderSite(req, resp);
328 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) { 330 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {
329 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED); 331 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
330 // TODO: implement - fix issue #21 332 // TODO: implement - fix issue #21
331 return ResponseType.NONE; 333 }
332 }
333
334 return ResponseType.HTML;
335 } 334 }
336 335
337 @RequestMapping(requestPath = "$project/components/", method = HttpMethod.GET) 336 @RequestMapping(requestPath = "$project/components/", method = HttpMethod.GET)
338 public ResponseType components(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 337 public void components(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
339 final var viewModel = new ComponentsView(); 338 final var viewModel = new ComponentsView();
340 populate(viewModel, pathParameters, dao); 339 populate(viewModel, pathParameters, dao);
341 340
342 final var projectInfo = viewModel.getProjectInfo(); 341 final var projectInfo = viewModel.getProjectInfo();
343 if (projectInfo == null) { 342 if (projectInfo == null) {
344 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 343 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
345 return ResponseType.NONE; 344 return;
346 } 345 }
347 346
348 final var issueDao = dao.getIssueDao(); 347 final var issueDao = dao.getIssueDao();
349 final var issues = issueDao.list(projectInfo.getProject()); 348 final var issues = issueDao.list(projectInfo.getProject());
350 viewModel.update(projectInfo.getComponents(), issues); 349 viewModel.update(projectInfo.getComponents(), issues);
351 350
352 return forwardView(req, viewModel, "components"); 351 forwardView(req, resp, viewModel, "components");
353 } 352 }
354 353
355 @RequestMapping(requestPath = "$project/components/$component/edit", method = HttpMethod.GET) 354 @RequestMapping(requestPath = "$project/components/$component/edit", method = HttpMethod.GET)
356 public ResponseType editComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 355 public void editComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
357 final var viewModel = new ComponentEditView(); 356 final var viewModel = new ComponentEditView();
358 populate(viewModel, pathParameters, dao); 357 populate(viewModel, pathParameters, dao);
359 358
360 if (viewModel.getProjectInfo() == null || viewModel.getComponentFilter() == null) { 359 if (viewModel.getProjectInfo() == null || viewModel.getComponentFilter() == null) {
361 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 360 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
362 return ResponseType.NONE; 361 return;
363 } 362 }
364 363
365 viewModel.setComponent(viewModel.getComponentFilter()); 364 viewModel.setComponent(viewModel.getComponentFilter());
366 viewModel.setUsers(dao.getUserDao().list()); 365 viewModel.setUsers(dao.getUserDao().list());
367 366
368 return forwardView(req, viewModel, "component-form"); 367 forwardView(req, resp, viewModel, "component-form");
369 } 368 }
370 369
371 @RequestMapping(requestPath = "$project/create-component", method = HttpMethod.GET) 370 @RequestMapping(requestPath = "$project/create-component", method = HttpMethod.GET)
372 public ResponseType createComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 371 public void createComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
373 final var viewModel = new ComponentEditView(); 372 final var viewModel = new ComponentEditView();
374 populate(viewModel, pathParameters, dao); 373 populate(viewModel, pathParameters, dao);
375 374
376 if (viewModel.getProjectInfo() == null) { 375 if (viewModel.getProjectInfo() == null) {
377 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 376 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
378 return ResponseType.NONE; 377 return;
379 } 378 }
380 379
381 viewModel.setComponent(new Component(-1)); 380 viewModel.setComponent(new Component(-1));
382 viewModel.setUsers(dao.getUserDao().list()); 381 viewModel.setUsers(dao.getUserDao().list());
383 382
384 return forwardView(req, viewModel, "component-form"); 383 forwardView(req, resp, viewModel, "component-form");
385 } 384 }
386 385
387 @RequestMapping(requestPath = "commit-component", method = HttpMethod.POST) 386 @RequestMapping(requestPath = "commit-component", method = HttpMethod.POST)
388 public ResponseType commitComponent(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException { 387 public void commitComponent(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException, ServletException {
389 388
390 try { 389 try {
391 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow()); 390 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow());
392 if (project == null) { 391 if (project == null) {
393 // TODO: improve error handling, because not found is not correct for this POST request 392 // TODO: improve error handling, because not found is not correct for this POST request
394 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 393 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
395 return ResponseType.NONE; 394 return;
396 } 395 }
397 final var component = new Component(getParameter(req, Integer.class, "id").orElseThrow()); 396 final var component = new Component(getParameter(req, Integer.class, "id").orElseThrow());
398 component.setName(getParameter(req, String.class, "name").orElseThrow()); 397 component.setName(getParameter(req, String.class, "name").orElseThrow());
399 398
400 final var node = getParameter(req, String.class, "node").orElse(null); 399 final var node = getParameter(req, String.class, "node").orElse(null);
409 408
410 dao.getComponentDao().saveOrUpdate(component, project); 409 dao.getComponentDao().saveOrUpdate(component, project);
411 410
412 setRedirectLocation(req, "./projects/" + project.getNode() + "/components/"); 411 setRedirectLocation(req, "./projects/" + project.getNode() + "/components/");
413 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL); 412 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);
413
414 renderSite(req, resp);
414 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) { 415 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {
415 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED); 416 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
416 // TODO: implement - fix issue #21 417 // TODO: implement - fix issue #21
417 return ResponseType.NONE; 418 }
418 }
419
420 return ResponseType.HTML;
421 } 419 }
422 420
423 private void configureIssueEditor(IssueEditView viewModel, Issue issue, DataAccessObjects dao) throws SQLException { 421 private void configureIssueEditor(IssueEditView viewModel, Issue issue, DataAccessObjects dao) throws SQLException {
424 final var project = viewModel.getProjectInfo().getProject(); 422 final var project = viewModel.getProjectInfo().getProject();
425 issue.setProject(project); // automatically set current project for new issues 423 issue.setProject(project); // automatically set current project for new issues
428 viewModel.setUsers(dao.getUserDao().list()); 426 viewModel.setUsers(dao.getUserDao().list());
429 viewModel.setComponents(dao.getComponentDao().list(project)); 427 viewModel.setComponents(dao.getComponentDao().list(project));
430 } 428 }
431 429
432 @RequestMapping(requestPath = "$project/issues/$issue/view", method = HttpMethod.GET) 430 @RequestMapping(requestPath = "$project/issues/$issue/view", method = HttpMethod.GET)
433 public ResponseType viewIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 431 public void viewIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
434 final var viewModel = new IssueDetailView(); 432 final var viewModel = new IssueDetailView();
435 populate(viewModel, pathParameters, dao); 433 populate(viewModel, pathParameters, dao);
436 434
437 final var projectInfo = viewModel.getProjectInfo(); 435 final var projectInfo = viewModel.getProjectInfo();
438 if (projectInfo == null) { 436 if (projectInfo == null) {
439 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 437 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
440 return ResponseType.NONE; 438 return;
441 } 439 }
442 440
443 final var issueDao = dao.getIssueDao(); 441 final var issueDao = dao.getIssueDao();
444 final var issue = issueDao.find(Functions.parseIntOrZero(pathParameters.get("issue"))); 442 final var issue = issueDao.find(Functions.parseIntOrZero(pathParameters.get("issue")));
445 if (issue == null) { 443 if (issue == null) {
446 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 444 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
447 return ResponseType.NONE; 445 return;
448 } 446 }
449 447
450 issueDao.joinVersionInformation(issue); 448 issueDao.joinVersionInformation(issue);
451 viewModel.setIssue(issue); 449 viewModel.setIssue(issue);
452 viewModel.setComments(issueDao.listComments(issue)); 450 viewModel.setComments(issueDao.listComments(issue));
453 451
454 return forwardView(req, viewModel, "issue-view"); 452 forwardView(req, resp, viewModel, "issue-view");
455 } 453 }
456 454
457 // TODO: why should the issue editor be child of $project? 455 // TODO: why should the issue editor be child of $project?
458 @RequestMapping(requestPath = "$project/issues/$issue/edit", method = HttpMethod.GET) 456 @RequestMapping(requestPath = "$project/issues/$issue/edit", method = HttpMethod.GET)
459 public ResponseType editIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 457 public void editIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
460 final var viewModel = new IssueEditView(); 458 final var viewModel = new IssueEditView();
461 populate(viewModel, pathParameters, dao); 459 populate(viewModel, pathParameters, dao);
462 460
463 final var projectInfo = viewModel.getProjectInfo(); 461 final var projectInfo = viewModel.getProjectInfo();
464 if (projectInfo == null) { 462 if (projectInfo == null) {
465 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 463 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
466 return ResponseType.NONE; 464 return;
467 } 465 }
468 466
469 final var issueDao = dao.getIssueDao(); 467 final var issueDao = dao.getIssueDao();
470 final var issue = issueDao.find(Functions.parseIntOrZero(pathParameters.get("issue"))); 468 final var issue = issueDao.find(Functions.parseIntOrZero(pathParameters.get("issue")));
471 if (issue == null) { 469 if (issue == null) {
472 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 470 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
473 return ResponseType.NONE; 471 return;
474 } 472 }
475 473
476 issueDao.joinVersionInformation(issue); 474 issueDao.joinVersionInformation(issue);
477 configureIssueEditor(viewModel, issue, dao); 475 configureIssueEditor(viewModel, issue, dao);
478 476
479 return forwardView(req, viewModel, "issue-form"); 477 forwardView(req, resp, viewModel, "issue-form");
480 } 478 }
481 479
482 @RequestMapping(requestPath = "$project/create-issue", method = HttpMethod.GET) 480 @RequestMapping(requestPath = "$project/create-issue", method = HttpMethod.GET)
483 public ResponseType createIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException { 481 public void createIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException, ServletException {
484 final var viewModel = new IssueEditView(); 482 final var viewModel = new IssueEditView();
485 populate(viewModel, pathParameters, dao); 483 populate(viewModel, pathParameters, dao);
486 484
487 final var projectInfo = viewModel.getProjectInfo(); 485 final var projectInfo = viewModel.getProjectInfo();
488 if (projectInfo == null) { 486 if (projectInfo == null) {
489 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 487 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
490 return ResponseType.NONE; 488 return;
491 } 489 }
492 490
493 final var issue = new Issue(-1); 491 final var issue = new Issue(-1);
494 issue.setProject(projectInfo.getProject()); 492 issue.setProject(projectInfo.getProject());
495 configureIssueEditor(viewModel, issue, dao); 493 configureIssueEditor(viewModel, issue, dao);
496 494
497 return forwardView(req, viewModel, "issue-form"); 495 forwardView(req, resp, viewModel, "issue-form");
498 } 496 }
499 497
500 @RequestMapping(requestPath = "commit-issue", method = HttpMethod.POST) 498 @RequestMapping(requestPath = "commit-issue", method = HttpMethod.POST)
501 public ResponseType commitIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException { 499 public void commitIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException, ServletException {
502 try { 500 try {
503 final var issue = new Issue(getParameter(req, Integer.class, "id").orElseThrow()); 501 final var issue = new Issue(getParameter(req, Integer.class, "id").orElseThrow());
504 final var componentId = getParameter(req, Integer.class, "component"); 502 final var componentId = getParameter(req, Integer.class, "component");
505 final Component component; 503 final Component component;
506 if (componentId.isPresent()) { 504 if (componentId.isPresent()) {
510 } 508 }
511 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow()); 509 final var project = dao.getProjectDao().find(getParameter(req, Integer.class, "pid").orElseThrow());
512 if (project == null) { 510 if (project == null) {
513 // TODO: improve error handling, because not found is not correct for this POST request 511 // TODO: improve error handling, because not found is not correct for this POST request
514 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 512 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
515 return ResponseType.NONE; 513 return;
516 } 514 }
517 issue.setProject(project); 515 issue.setProject(project);
518 getParameter(req, String.class, "category").map(IssueCategory::valueOf).ifPresent(issue::setCategory); 516 getParameter(req, String.class, "category").map(IssueCategory::valueOf).ifPresent(issue::setCategory);
519 getParameter(req, String.class, "status").map(IssueStatus::valueOf).ifPresent(issue::setStatus); 517 getParameter(req, String.class, "status").map(IssueStatus::valueOf).ifPresent(issue::setStatus);
520 issue.setSubject(getParameter(req, String.class, "subject").orElseThrow()); 518 issue.setSubject(getParameter(req, String.class, "subject").orElseThrow());
547 545
548 // TODO: fix redirect location 546 // TODO: fix redirect location
549 setRedirectLocation(req, "./projects/" + issue.getProject().getNode()+"/issues/"+issue.getId()+"/view"); 547 setRedirectLocation(req, "./projects/" + issue.getProject().getNode()+"/issues/"+issue.getId()+"/view");
550 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL); 548 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);
551 549
552 return ResponseType.HTML; 550 renderSite(req, resp);
553 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) { 551 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {
554 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED); 552 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
555 // TODO: implement - fix issue #21 553 // TODO: implement - fix issue #21
556 return ResponseType.NONE;
557 } 554 }
558 } 555 }
559 556
560 @RequestMapping(requestPath = "commit-issue-comment", method = HttpMethod.POST) 557 @RequestMapping(requestPath = "commit-issue-comment", method = HttpMethod.POST)
561 public ResponseType commentIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws SQLException, IOException { 558 public void commentIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws SQLException, IOException, ServletException {
562 final var issueIdParam = getParameter(req, Integer.class, "issueid"); 559 final var issueIdParam = getParameter(req, Integer.class, "issueid");
563 if (issueIdParam.isEmpty()) { 560 if (issueIdParam.isEmpty()) {
564 resp.sendError(HttpServletResponse.SC_FORBIDDEN, "Detected manipulated form."); 561 resp.sendError(HttpServletResponse.SC_FORBIDDEN, "Detected manipulated form.");
565 return ResponseType.NONE; 562 return;
566 } 563 }
567 final var issue = dao.getIssueDao().find(issueIdParam.get()); 564 final var issue = dao.getIssueDao().find(issueIdParam.get());
568 if (issue == null) { 565 if (issue == null) {
569 resp.sendError(HttpServletResponse.SC_NOT_FOUND); 566 resp.sendError(HttpServletResponse.SC_NOT_FOUND);
570 return ResponseType.NONE; 567 return;
571 } 568 }
572 try { 569 try {
573 final var issueComment = new IssueComment(getParameter(req, Integer.class, "commentid").orElse(-1)); 570 final var issueComment = new IssueComment(getParameter(req, Integer.class, "commentid").orElse(-1));
574 issueComment.setComment(getParameter(req, String.class, "comment").orElse("")); 571 issueComment.setComment(getParameter(req, String.class, "comment").orElse(""));
575 572
586 583
587 // TODO: fix redirect location 584 // TODO: fix redirect location
588 setRedirectLocation(req, "./projects/" + issue.getProject().getNode()+"/issues/"+issue.getId()+"/view"); 585 setRedirectLocation(req, "./projects/" + issue.getProject().getNode()+"/issues/"+issue.getId()+"/view");
589 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL); 586 setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);
590 587
591 return ResponseType.HTML; 588 renderSite(req, resp);
592 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) { 589 } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {
593 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED); 590 resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);
594 // TODO: implement - fix issue #21 591 // TODO: implement - fix issue #21
595 return ResponseType.NONE;
596 } 592 }
597 } 593 }
598 } 594 }

Mercurial Repository: LightPIT

mercurial