LightPIT: src/main/java/de/uapcore/lightpit/modules/ProjectsModule.java@f47e82cd6077

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2018 Mike Becker. All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  *

    28  */

    29 package de.uapcore.lightpit.modules;

    32 import de.uapcore.lightpit.*;

    33 import de.uapcore.lightpit.dao.DataAccessObjects;

    34 import de.uapcore.lightpit.entities.*;

    35 import de.uapcore.lightpit.types.WebColor;

    36 import de.uapcore.lightpit.viewmodel.*;

    37 import de.uapcore.lightpit.viewmodel.util.IssueSorter;

    38 import org.slf4j.Logger;

    39 import org.slf4j.LoggerFactory;

    41 import javax.servlet.annotation.WebServlet;

    42 import javax.servlet.http.HttpServletRequest;

    43 import javax.servlet.http.HttpServletResponse;

    44 import java.io.IOException;

    45 import java.sql.Date;

    46 import java.sql.SQLException;

    47 import java.util.List;

    48 import java.util.NoSuchElementException;

    49 import java.util.stream.Collectors;

    50 import java.util.stream.Stream;

    52 @WebServlet(

    53         name = "ProjectsModule",

    54         urlPatterns = "/projects/*"

    55 )

    56 public final class ProjectsModule extends AbstractLightPITServlet {

    58     private static final Logger LOG = LoggerFactory.getLogger(ProjectsModule.class);

    60     @Override

    61     protected String getResourceBundleName() {

    62         return "localization.projects";

    63     }

    65     private void populate(ProjectView viewModel, PathParameters pathParameters, DataAccessObjects dao) throws SQLException {

    66         final var projectDao = dao.getProjectDao();

    67         final var versionDao = dao.getVersionDao();

    68         final var componentDao = dao.getComponentDao();

    70         projectDao.list().stream().map(ProjectInfo::new).forEach(viewModel.getProjectList()::add);

    72         if (pathParameters == null)

    73             return;

    75         // Select Project

    76         final int pid = Functions.parseIntOrZero(pathParameters.get("project"));

    77         if (pid > 0) {

    78             final var project = projectDao.find(pid);

    79             if (project != null) {

    80                 final var info = new ProjectInfo(project);

    81                 info.setVersions(versionDao.list(project));

    82                 info.setComponents(componentDao.list(project));

    83                 info.setIssueSummary(projectDao.getIssueSummary(project));

    84                 viewModel.setProjectInfo(info);

    85             }

    86         }

    88         // Select Version

    89         final var pathParamVersion = pathParameters.get("version");

    90         if ("no-version".equals(pathParamVersion)) {

    91             viewModel.setVersionFilter(ProjectView.NO_VERSION);

    92         } else if ("all-versions".equals(pathParamVersion)) {

    93             viewModel.setVersionFilter(ProjectView.ALL_VERSIONS);

    94         } else {

    95             final int vid = Functions.parseIntOrZero(pathParamVersion);

    96             if (vid > 0) {

    97                 viewModel.setVersionFilter(versionDao.find(vid));

    98             }

    99         }

   101         // Select Component

   102         final var pathParamComponent = pathParameters.get("component");

   103         if ("no-component".equals(pathParamComponent)) {

   104             viewModel.setComponentFilter(ProjectView.NO_COMPONENT);

   105         } else if ("all-components".equals(pathParamComponent)) {

   106             viewModel.setComponentFilter(ProjectView.ALL_COMPONENTS);

   107         } else {

   108             final int cid = Functions.parseIntOrZero(pathParamComponent);

   109             if (cid > 0) {

   110                 viewModel.setComponentFilter(componentDao.find(cid));

   111             }

   112         }

   113     }

   115     private ResponseType forwardView(HttpServletRequest req, ProjectView viewModel, String name) {

   116         setViewModel(req, viewModel);

   117         setContentPage(req, name);

   118         setStylesheet(req, "projects");

   119         setNavigationMenu(req, "project-navmenu");

   120         return ResponseType.HTML;

   121     }

   123     @RequestMapping(method = HttpMethod.GET)

   124     public ResponseType index(HttpServletRequest req, DataAccessObjects dao) throws SQLException {

   125         final var viewModel = new ProjectView();

   126         populate(viewModel, null, dao);

   128         final var projectDao = dao.getProjectDao();

   129         final var versionDao = dao.getVersionDao();

   131         for (var info : viewModel.getProjectList()) {

   132             info.setVersions(versionDao.list(info.getProject()));

   133             info.setIssueSummary(projectDao.getIssueSummary(info.getProject()));

   134         }

   136         return forwardView(req, viewModel, "projects");

   137     }

   139     private void configureProjectEditor(ProjectEditView viewModel, Project project, DataAccessObjects dao) throws SQLException {

   140         viewModel.setProject(project);

   141         viewModel.setUsers(dao.getUserDao().list());

   142     }

   144     @RequestMapping(requestPath = "$project/edit", method = HttpMethod.GET)

   145     public ResponseType edit(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws IOException, SQLException {

   146         final var viewModel = new ProjectEditView();

   147         populate(viewModel, pathParams, dao);

   149         if (!viewModel.isProjectInfoPresent()) {

   150             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   151             return ResponseType.NONE;

   152         }

   154         configureProjectEditor(viewModel, viewModel.getProjectInfo().getProject(), dao);

   155         return forwardView(req, viewModel, "project-form");

   156     }

   158     @RequestMapping(requestPath = "create", method = HttpMethod.GET)

   159     public ResponseType create(HttpServletRequest req, DataAccessObjects dao) throws SQLException {

   160         final var viewModel = new ProjectEditView();

   161         populate(viewModel, null, dao);

   162         configureProjectEditor(viewModel, new Project(-1), dao);

   163         return forwardView(req, viewModel, "project-form");

   164     }

   166     @RequestMapping(requestPath = "commit", method = HttpMethod.POST)

   167     public ResponseType commit(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException {

   169         try {

   170             final var project = new Project(getParameter(req, Integer.class, "pid").orElseThrow());

   171             project.setName(getParameter(req, String.class, "name").orElseThrow());

   172             getParameter(req, String.class, "description").ifPresent(project::setDescription);

   173             getParameter(req, String.class, "repoUrl").ifPresent(project::setRepoUrl);

   174             getParameter(req, Integer.class, "owner").map(

   175                     ownerId -> ownerId >= 0 ? new User(ownerId) : null

   176             ).ifPresent(project::setOwner);

   178             dao.getProjectDao().saveOrUpdate(project);

   180             setRedirectLocation(req, "./projects/");

   181             setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);

   182             LOG.debug("Successfully updated project {}", project.getName());

   184             return ResponseType.HTML;

   185         } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {

   186             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

   187             // TODO: implement - fix issue #21

   188             return ResponseType.NONE;

   189         }

   190     }

   192     @RequestMapping(requestPath = "$project/$component/$version/issues/", method = HttpMethod.GET)

   193     public ResponseType issues(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParams, DataAccessObjects dao) throws SQLException, IOException {

   194         final var viewModel = new ProjectDetailsView();

   195         populate(viewModel, pathParams, dao);

   197         if (!viewModel.isEveryFilterValid()) {

   198             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   199             return ResponseType.NONE;

   200         }

   202         final var project = viewModel.getProjectInfo().getProject();

   203         final var version = viewModel.getVersionFilter();

   204         final var component = viewModel.getComponentFilter();

   206         final var issueDao = dao.getIssueDao();

   208         final List<Issue> issues;

   209         if (version.equals(ProjectView.NO_VERSION)) {

   210             if (component.equals(ProjectView.ALL_COMPONENTS)) {

   211                 issues = issueDao.list(project, (Version) null);

   212             } else if (component.equals(ProjectView.NO_COMPONENT)) {

   213                 issues = issueDao.list(project, null, null);

   214             } else {

   215                 issues = issueDao.list(project, component, null);

   216             }

   217         } else if (version.equals(ProjectView.ALL_VERSIONS)) {

   218             if (component.equals(ProjectView.ALL_COMPONENTS)) {

   219                 issues = issueDao.list(project);

   220             } else if (component.equals(ProjectView.NO_COMPONENT)) {

   221                 issues = issueDao.list(project, (Component)null);

   222             } else {

   223                 issues = issueDao.list(project, component);

   224             }

   225         } else {

   226             if (component.equals(ProjectView.ALL_COMPONENTS)) {

   227                 issues = issueDao.list(project, version);

   228             } else if (component.equals(ProjectView.NO_COMPONENT)) {

   229                 issues = issueDao.list(project, null, version);

   230             } else {

   231                 issues = issueDao.list(project, component, version);

   232             }

   233         }

   235         for (var issue : issues) issueDao.joinVersionInformation(issue);

   236         issues.sort(new IssueSorter(

   237                 new IssueSorter.Criteria(IssueSorter.Field.PHASE, true),

   238                 new IssueSorter.Criteria(IssueSorter.Field.ETA, true),

   239                 new IssueSorter.Criteria(IssueSorter.Field.UPDATED, false)

   240         ));

   243         viewModel.getProjectDetails().updateDetails(issues);

   244         if (version.getId() > 0)

   245             viewModel.getProjectDetails().updateVersionInfo(version);

   247         return forwardView(req, viewModel, "project-details");

   248     }

   250     @RequestMapping(requestPath = "$project/versions/", method = HttpMethod.GET)

   251     public ResponseType versions(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   252         final var viewModel = new VersionsView();

   253         populate(viewModel, pathParameters, dao);

   255         final var projectInfo = viewModel.getProjectInfo();

   256         if (projectInfo == null) {

   257             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   258             return ResponseType.NONE;

   259         }

   261         final var issueDao = dao.getIssueDao();

   262         final var issues = issueDao.list(projectInfo.getProject());

   263         for (var issue : issues) issueDao.joinVersionInformation(issue);

   264         viewModel.update(projectInfo.getVersions(), issues);

   266         return forwardView(req, viewModel, "versions");

   267     }

   269     @RequestMapping(requestPath = "$project/versions/$version/edit", method = HttpMethod.GET)

   270     public ResponseType editVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   271         final var viewModel = new VersionEditView();

   272         populate(viewModel, pathParameters, dao);

   274         if (viewModel.getProjectInfo() == null || viewModel.getVersionFilter() == null) {

   275             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   276             return ResponseType.NONE;

   277         }

   279         viewModel.setVersion(viewModel.getVersionFilter());

   281         return forwardView(req, viewModel, "version-form");

   282     }

   284     @RequestMapping(requestPath = "$project/create-version", method = HttpMethod.GET)

   285     public ResponseType createVersion(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   286         final var viewModel = new VersionEditView();

   287         populate(viewModel, pathParameters, dao);

   289         if (viewModel.getProjectInfo() == null) {

   290             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   291             return ResponseType.NONE;

   292         }

   294         viewModel.setVersion(viewModel.getVersionFilter());

   296         return forwardView(req, viewModel, "version-form");

   297     }

   299     @RequestMapping(requestPath = "commit-version", method = HttpMethod.POST)

   300     public ResponseType commitVersion(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException {

   302         try {

   303             final var project = new Project(getParameter(req, Integer.class, "pid").orElseThrow());

   304             final var version = new Version(getParameter(req, Integer.class, "id").orElseThrow());

   305             version.setName(getParameter(req, String.class, "name").orElseThrow());

   306             getParameter(req, Integer.class, "ordinal").ifPresent(version::setOrdinal);

   307             version.setStatus(VersionStatus.valueOf(getParameter(req, String.class, "status").orElseThrow()));

   308             dao.getVersionDao().saveOrUpdate(version, project);

   310             setRedirectLocation(req, "./projects/" + project.getId() + "/versions/");

   311             setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);

   312         } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {

   313             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

   314             // TODO: implement - fix issue #21

   315             return ResponseType.NONE;

   316         }

   318         return ResponseType.HTML;

   319     }

   321     @RequestMapping(requestPath = "$project/components/", method = HttpMethod.GET)

   322     public ResponseType components(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   323         final var viewModel = new ComponentsView();

   324         populate(viewModel, pathParameters, dao);

   326         final var projectInfo = viewModel.getProjectInfo();

   327         if (projectInfo == null) {

   328             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   329             return ResponseType.NONE;

   330         }

   332         final var issueDao = dao.getIssueDao();

   333         final var issues = issueDao.list(projectInfo.getProject());

   334         viewModel.update(projectInfo.getComponents(), issues);

   336         return forwardView(req, viewModel, "components");

   337     }

   339     @RequestMapping(requestPath = "$project/components/$component/edit", method = HttpMethod.GET)

   340     public ResponseType editComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   341         final var viewModel = new ComponentEditView();

   342         populate(viewModel, pathParameters, dao);

   344         if (viewModel.getProjectInfo() == null || viewModel.getComponentFilter() == null) {

   345             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   346             return ResponseType.NONE;

   347         }

   349         viewModel.setComponent(viewModel.getComponentFilter());

   350         viewModel.setUsers(dao.getUserDao().list());

   352         return forwardView(req, viewModel, "component-form");

   353     }

   355     @RequestMapping(requestPath = "$project/create-component", method = HttpMethod.GET)

   356     public ResponseType createComponent(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   357         final var viewModel = new ComponentEditView();

   358         populate(viewModel, pathParameters, dao);

   360         if (viewModel.getProjectInfo() == null) {

   361             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   362             return ResponseType.NONE;

   363         }

   365         viewModel.setComponent(new Component(-1));

   366         viewModel.setUsers(dao.getUserDao().list());

   368         return forwardView(req, viewModel, "component-form");

   369     }

   371     @RequestMapping(requestPath = "commit-component", method = HttpMethod.POST)

   372     public ResponseType commitComponent(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException {

   374         try {

   375             final var project = new Project(getParameter(req, Integer.class, "pid").orElseThrow());

   376             final var component = new Component(getParameter(req, Integer.class, "id").orElseThrow());

   377             component.setName(getParameter(req, String.class, "name").orElseThrow());

   378             component.setColor(getParameter(req, WebColor.class, "color").orElseThrow());

   379             getParameter(req, Integer.class, "ordinal").ifPresent(component::setOrdinal);

   380             getParameter(req, Integer.class, "lead").map(

   381                     userid -> userid >= 0 ? new User(userid) : null

   382             ).ifPresent(component::setLead);

   383             getParameter(req, String.class, "description").ifPresent(component::setDescription);

   385             dao.getComponentDao().saveOrUpdate(component, project);

   387             setRedirectLocation(req, "./projects/" + project.getId() + "/components/");

   388             setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);

   389         } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {

   390             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

   391             // TODO: implement - fix issue #21

   392             return ResponseType.NONE;

   393         }

   395         return ResponseType.HTML;

   396     }

   398     private void configureIssueEditor(IssueEditView viewModel, Issue issue, DataAccessObjects dao) throws SQLException {

   399         final var project = viewModel.getProjectInfo().getProject();

   400         issue.setProject(project);

   401         viewModel.setIssue(issue);

   402         viewModel.configureVersionSelectors(viewModel.getProjectInfo().getVersions());

   403         viewModel.setUsers(dao.getUserDao().list());

   404         viewModel.setComponents(dao.getComponentDao().list(project));

   405         if (issue.getId() >= 0) {

   406             viewModel.setComments(dao.getIssueDao().listComments(issue));

   407         }

   408     }

   410     @RequestMapping(requestPath = "$project/issues/$issue/edit", method = HttpMethod.GET)

   411     public ResponseType editIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   412         final var viewModel = new IssueEditView();

   413         populate(viewModel, pathParameters, dao);

   415         final var projectInfo = viewModel.getProjectInfo();

   416         if (projectInfo == null) {

   417             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   418             return ResponseType.NONE;

   419         }

   421         final var issueDao = dao.getIssueDao();

   422         final var issue = issueDao.find(Functions.parseIntOrZero(pathParameters.get("issue")));

   423         if (issue == null) {

   424             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   425             return ResponseType.NONE;

   426         }

   428         issueDao.joinVersionInformation(issue);

   429         configureIssueEditor(viewModel, issue, dao);

   431         return forwardView(req, viewModel, "issue-form");

   432     }

   434     @RequestMapping(requestPath = "$project/create-issue", method = HttpMethod.GET)

   435     public ResponseType createIssue(HttpServletRequest req, HttpServletResponse resp, PathParameters pathParameters, DataAccessObjects dao) throws IOException, SQLException {

   436         final var viewModel = new IssueEditView();

   437         populate(viewModel, pathParameters, dao);

   439         final var projectInfo = viewModel.getProjectInfo();

   440         if (projectInfo == null) {

   441             resp.sendError(HttpServletResponse.SC_NOT_FOUND);

   442             return ResponseType.NONE;

   443         }

   445         final var issue = new Issue(-1);

   446         issue.setProject(projectInfo.getProject());

   447         configureIssueEditor(viewModel, issue, dao);

   449         return forwardView(req, viewModel, "issue-form");

   450     }

   452     @RequestMapping(requestPath = "commit-issue", method = HttpMethod.POST)

   453     public ResponseType commitIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException {

   454         try {

   455             final var issue = new Issue(getParameter(req, Integer.class, "id").orElseThrow());

   456             issue.setProject(new Project(getParameter(req, Integer.class, "pid").orElseThrow()));

   457             getParameter(req, String.class, "category").map(IssueCategory::valueOf).ifPresent(issue::setCategory);

   458             getParameter(req, String.class, "status").map(IssueStatus::valueOf).ifPresent(issue::setStatus);

   459             issue.setSubject(getParameter(req, String.class, "subject").orElseThrow());

   460             getParameter(req, Integer.class, "assignee").map(

   461                     userid -> userid >= 0 ? new User(userid) : null

   462             ).ifPresent(issue::setAssignee);

   463             getParameter(req, Integer.class, "component").map(

   464                     cid -> cid >= 0 ? new Component(cid) : null

   465             ).ifPresent(issue::setComponent);

   466             getParameter(req, String.class, "description").ifPresent(issue::setDescription);

   467             getParameter(req, Date.class, "eta").ifPresent(issue::setEta);

   469             getParameter(req, Integer[].class, "affected")

   470                     .map(Stream::of)

   471                     .map(stream ->

   472                             stream.map(Version::new).collect(Collectors.toList())

   473                     ).ifPresent(issue::setAffectedVersions);

   474             getParameter(req, Integer[].class, "resolved")

   475                     .map(Stream::of)

   476                     .map(stream ->

   477                             stream.map(Version::new).collect(Collectors.toList())

   478                     ).ifPresent(issue::setResolvedVersions);

   480             dao.getIssueDao().saveOrUpdate(issue, issue.getProject());

   482             // TODO: fix issue #14

   483             setRedirectLocation(req, "./projects/" + issue.getProject().getId() + "/all-components/all-versions/issues/");

   484             setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);

   486             return ResponseType.HTML;

   487         } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {

   488             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

   489             // TODO: implement - fix issue #21

   490             return ResponseType.NONE;

   491         }

   492     }

   494     @RequestMapping(requestPath = "commit-issue-comment", method = HttpMethod.POST)

   495     public ResponseType commentIssue(HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws SQLException, IOException {

   496         final var issueIdParam = getParameter(req, Integer.class, "issueid");

   497         if (issueIdParam.isEmpty()) {

   498             resp.sendError(HttpServletResponse.SC_FORBIDDEN, "Detected manipulated form.");

   499             return ResponseType.NONE;

   500         }

   501         final var issue = new Issue(issueIdParam.get());

   502         try {

   503             final var issueComment = new IssueComment(getParameter(req, Integer.class, "commentid").orElse(-1), issue);

   504             issueComment.setComment(getParameter(req, String.class, "comment").orElse(""));

   506             if (issueComment.getComment().isBlank()) {

   507                 throw new IllegalArgumentException("comment.null");

   508             }

   510             LOG.debug("User {} is commenting on issue #{}", req.getRemoteUser(), issue.getId());

   511             if (req.getRemoteUser() != null) {

   512                 dao.getUserDao().findByUsername(req.getRemoteUser()).ifPresent(issueComment::setAuthor);

   513             }

   515             dao.getIssueDao().saveComment(issueComment);

   517             // TODO: fix redirect location (e.g. after fixing #24)

   518             setRedirectLocation(req, "./projects/" + issue.getProject().getId()+"/issues/"+issue.getId()+"/edit");

   519             setContentPage(req, Constants.JSP_COMMIT_SUCCESSFUL);

   521             return ResponseType.HTML;

   522         } catch (NoSuchElementException | IllegalArgumentException | SQLException ex) {

   523             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED);

   524             // TODO: implement - fix issue #21

   525             return ResponseType.NONE;

   526         }

   527     }

   528 }

Mercurial > hg > LightPIT / file revision

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

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