diff --git a/src/main/java/fr/la_banquise/backend/data/model/Instance.java b/src/main/java/fr/la_banquise/backend/data/model/Instance.java index a229682..4938994 100644 --- a/src/main/java/fr/la_banquise/backend/data/model/Instance.java +++ b/src/main/java/fr/la_banquise/backend/data/model/Instance.java @@ -13,6 +13,9 @@ import jakarta.persistence.Table; import lombok.AllArgsConstructor; import lombok.NoArgsConstructor; + + + /** * Instances */ @@ -38,9 +41,12 @@ public class Instance { @JoinColumn(name = "user_id", nullable = false) public User owner; - public Instance(String name, int port, User user) { + public String containerId; + + public Instance(String name, int port, User user, String containerId) { this.name = name; this.port = port; this.owner = user; + this.containerId = containerId; } } diff --git a/src/main/java/fr/la_banquise/backend/rest/InstanceEndpoints.java b/src/main/java/fr/la_banquise/backend/rest/InstanceEndpoints.java index 7fdd51d..b13700c 100644 --- a/src/main/java/fr/la_banquise/backend/rest/InstanceEndpoints.java +++ b/src/main/java/fr/la_banquise/backend/rest/InstanceEndpoints.java @@ -29,12 +29,33 @@ public class InstanceEndpoints { @Inject InstanceService instanceService; @Inject UserService userService; + /////////////////////////////////////////////////////////////////////////// + /// + /// First, we create our Instance and basic functions + + @POST + @RolesAllowed("ROOT") + @Path("/{id}/instance") + public Response createInstance(@PathParam("id") Long jiId, + @QueryParam("userId") Long userId) { + jiService.createInstance(jiId, userId); + return Response.ok().build(); + } + @GET @RolesAllowed("ROOT") @Path("/instances") public Response getAllInstances() { return Response.ok(instanceService.getAllInstances()).build(); } + + @GET + @RolesAllowed("ROOT") + @Path("/{id}/all-instances") + public Response getAllInstancesJi(@PathParam("id") Long jiId) { + // TODO : a modif, la c est juste all instances + return Response.ok(instanceService.getAllInstances()).build(); + } @GET @Authenticated @@ -45,27 +66,66 @@ public class InstanceEndpoints { return Response.ok(jiService.getInstance(jiId, userId)).build(); } + /////////////////////////////////////////////////////////////////////////// + + /// Now that the Instance is created, create their containers ! + @POST - @Path("/{id}/instance") - public Response createInstance(@PathParam("id") Long jiId, - @QueryParam("userId") Long userId) { - jiService.createInstance(jiId, userId); + @RolesAllowed("ROOT") + @Path("/{id}/containers") + public Response createContainers(@PathParam("id") Long jiId) { + jiService.createContainers(jiId); + return Response.ok().build(); + } + + /// Finally, start/stop the containers + + @POST + @RolesAllowed("ROOT") + @Path("/{id}/container/start") + public Response startContainers(@PathParam("id") Long jiId) { + jiService.startContainers(jiId); return Response.ok().build(); } @POST - @Path("/{id}/instance/container") - public Response createContainer(@PathParam("id") Long jiId, - @QueryParam("username") String username) { - return Response.ok(jiService.createContainer(jiId, username)).build(); + @RolesAllowed("ROOT") + @Path("/{id}/container/stop") + public Response stopContainers(@PathParam("id") Long jiId) { + jiService.stopContainers(jiId); + return Response.ok().build(); + } + + @GET + @Authenticated + @Path("/{id}/containers") + public Response getStatusContainers(@PathParam("id") Long jiId) { + return Response.ok(jiService.getStatusContainers(jiId)).build(); } @GET - @Path("/{id}/instance/container") - public Response - getStatusContainer(@PathParam("id") Long jiId, - @QueryParam("username") String username) { - return Response.ok(jiService.getStatusContainer(jiId, username)) - .build(); + @RolesAllowed("ROOT") + @Path("/{id}/container-admin-lookup") + public Response getStatusContainer(@PathParam("id") Long jiId, + @QueryParam("userId") Long userId) { + return Response.ok(jiService.getStatusContainer(jiId, userId)).build(); } + + @GET + @RolesAllowed("ROOT") + @Path("/{id}/container") + public Response getStatusMyContainer(@PathParam("id") Long jiId) { + String name = identity.getPrincipal().getName(); + Long userId = userService.getId(name); + return Response.ok(jiService.getStatusContainer(jiId, userId)).build(); + } + + + /////////////////////////////////////////////////////////////////////////// + + /// Last but not least, be able do delete every container and instance + /// + /// TODO + + } diff --git a/src/main/java/fr/la_banquise/backend/rest/JiEndpoints.java b/src/main/java/fr/la_banquise/backend/rest/JiEndpoints.java index 66154b6..fb0f748 100644 --- a/src/main/java/fr/la_banquise/backend/rest/JiEndpoints.java +++ b/src/main/java/fr/la_banquise/backend/rest/JiEndpoints.java @@ -1,7 +1,9 @@ package fr.la_banquise.backend.rest; import fr.la_banquise.backend.data.model.Ji; +import fr.la_banquise.backend.data.model.User; import fr.la_banquise.backend.services.JiService; +import fr.la_banquise.backend.services.UserService; import io.quarkus.security.identity.SecurityIdentity; import jakarta.annotation.security.RolesAllowed; import jakarta.inject.Inject; @@ -21,6 +23,30 @@ public class JiEndpoints { @Inject SecurityIdentity identity; @Inject JiService jiService; + @Inject UserService userService; + + /////////////////////////////////////////////////////////////////////////// + /// + /// First, we create our JI and basic functions + @POST + @Path("/create") + @RolesAllowed("ROOT") + public Response createJi(@QueryParam("name") String name, + @QueryParam("date") String date, + @QueryParam("desc") String desc, + @QueryParam("site_id") Long siteId) { + try { + String username = identity.getPrincipal().getName(); + User user = userService.getUser(username); + Long id = jiService.createJi(name, desc, date, siteId, user.id).id; + return Response.ok(Map.of("id", id)).build(); + } catch (Exception e) { + return Response.status(500) + .entity(Map.of("error", e.getMessage())) + .build(); + } + } + @GET @Path("/listall") @@ -37,22 +63,6 @@ public class JiEndpoints { } } - @POST - @Path("/create") - @RolesAllowed("ROOT") - public Response createJi(@QueryParam("name") String name, - @QueryParam("date") String date, - @QueryParam("desc") String desc, - @QueryParam("site_id") Long siteId) { - try { - Long id = jiService.createJi(name, desc, date, siteId).id; - return Response.ok(Map.of("id", id)).build(); - } catch (Exception e) { - return Response.status(500) - .entity(Map.of("error", e.getMessage())) - .build(); - } - } @GET @Path("/{ID}") @@ -67,7 +77,20 @@ public class JiEndpoints { .build(); } } + /////////////////////////////////////////////////////////////////////////// + /// Now that the JI is created, we want to add users to it and assign them + /// instances, but DONT create their containers yet ! + + /// Then, when an admin decides it, we create the containers + + /// Finally, start/stop the containers + + /// => These endpoints are into InstanceEndpoint + + /////////////////////////////////////////////////////////////////////////// + + /// Last but not least, be able do delete every container and instance @DELETE @Path("/del") @RolesAllowed("ROOT") diff --git a/src/main/java/fr/la_banquise/backend/services/DockerService.java b/src/main/java/fr/la_banquise/backend/services/DockerService.java index 5f714ce..82cfe59 100644 --- a/src/main/java/fr/la_banquise/backend/services/DockerService.java +++ b/src/main/java/fr/la_banquise/backend/services/DockerService.java @@ -10,23 +10,20 @@ import com.github.dockerjava.api.model.ExposedPort; import com.github.dockerjava.api.model.HostConfig; import com.github.dockerjava.api.model.PortBinding; import com.github.dockerjava.api.model.Ports; - +import fr.la_banquise.backend.rest.response.DockerResponse; import jakarta.enterprise.context.ApplicationScoped; import jakarta.inject.Inject; - import java.io.File; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; -import java.util.ArrayList; -import fr.la_banquise.backend.rest.response.DockerResponse; @ApplicationScoped public class DockerService { - @Inject - DockerClient dockerClient; + @Inject DockerClient dockerClient; public String createAndStartNginx() { ExposedPort tcp80 = ExposedPort.tcp(80); @@ -34,14 +31,16 @@ public class DockerService { Ports portBindings = new Ports(); portBindings.bind(tcp80, Ports.Binding.bindPort(8081)); - HostConfig hostConfig = HostConfig.newHostConfig().withPortBindings(portBindings); + HostConfig hostConfig = + HostConfig.newHostConfig().withPortBindings(portBindings); Map labels = new HashMap<>(); labels.put("test", "banquise"); labels.put("environment", "development"); labels.put("version", "1.0"); labels.put("created-by", "java-docker-api"); - CreateContainerResponse container = dockerClient.createContainerCmd("nginx:latest") + CreateContainerResponse container = + dockerClient.createContainerCmd("nginx:latest") .withName("my-nginx") .withLabels(labels) .withExposedPorts(tcp80) @@ -58,19 +57,19 @@ public class DockerService { * List containers = dockerClient.listContainersCmd() * .withShowAll(true) * .exec(); - * + * * json.append("["); - * + * * for (int i = 0; i < containers.size(); i++) { * Container container = containers.get(i); - * + * * json.append("{"); * json.append("\"name\":\"").append(container.getNames()[0].substring(1)). * append("\","); * json.append("\"id\":\"").append(container.getId()).append("\","); * json.append("\"image\":\"").append(container.getImage()).append("\","); * json.append("\"status\":\"").append(container.getStatus()).append("\","); - * + * * // Ports * InspectContainerResponse inspectResponse = * dockerClient.inspectContainerCmd(container.getId()).exec(); @@ -96,7 +95,7 @@ public class DockerService { * } * } * json.append("]"); - * + * * // Ports * String ports = "[]"; * try { @@ -116,14 +115,14 @@ public class DockerService { * if (i < containers.size() - 1) { * json.append(","); * } - * + * * json.append("}"); - * + * * if (i < containers.size() - 1) { * json.append(","); * } * } - * + * * json.append("]"); * return json.toString(); * } @@ -140,9 +139,9 @@ public class DockerService { * try { * var inspectResponse = * dockerClient.inspectContainerCmd(container.getId()).exec(); if - * (inspectResponse.getConfig().getExposedPorts() != null) { var exposedPorts = - * inspectResponse.getConfig().getExposedPorts(); int count = 0; for (var port - * : exposedPorts) { if (count > 0) portsList.append(","); + * (inspectResponse.getConfig().getExposedPorts() != null) { var + * exposedPorts = inspectResponse.getConfig().getExposedPorts(); int count = + * 0; for (var port : exposedPorts) { if (count > 0) portsList.append(","); * portsList.append(String.format("\"%s\"", * port.toString())); count = 1; * } @@ -155,9 +154,9 @@ public class DockerService { * > 0) { ports = java.util.Arrays.toString(container.getPorts()); * } * } - * + * * //json.append(containerJson); - * + * * if (i < containers.size() - 1) { * json.append(","); * } @@ -168,13 +167,18 @@ public class DockerService { */ //////////////////// + /// + /////////////////////////////////////////////////////////////////////////// + /// + /// First, we create our container and basic functions public String createContainer(String name, int port) { ExposedPort tcpSsh = ExposedPort.tcp(2222); Ports portBindings = new Ports(); portBindings.bind(tcpSsh, Ports.Binding.bindPort(port)); - HostConfig hostConfig = HostConfig.newHostConfig().withPortBindings(portBindings); + HostConfig hostConfig = + HostConfig.newHostConfig().withPortBindings(portBindings); Map labels = new HashMap<>(); labels.put("test", "banquise"); labels.put("environment", "development"); @@ -182,42 +186,27 @@ public class DockerService { labels.put("created-by", "java-docker-api"); dockerClient.buildImageCmd() - .withDockerfile(new File("./dockerfile/Dockerfile")) - .withBaseDirectory(new File("./dockerfile")) - .withTags(Set.of("ji-python:latest")) - .exec(new BuildImageResultCallback()) - .awaitImageId(); + .withDockerfile(new File("./dockerfile/Dockerfile")) + .withBaseDirectory(new File("./dockerfile")) + .withTags(Set.of("ji-python:latest")) + .exec(new BuildImageResultCallback()) + .awaitImageId(); - CreateContainerResponse container = dockerClient.createContainerCmd("ji-python:latest") + CreateContainerResponse container = + dockerClient.createContainerCmd("ji-python:latest") .withName(name) .withLabels(labels) .withExposedPorts(tcpSsh) .withHostConfig(hostConfig) - .withEnv( - "SUDO_ACCESS=false", - "PASSWORD_ACCESS=true", - "USER_NAME=test", // TODO: CHANGE THIS - "USER_PASSWORD=test" // AND this also oc - ) + .withEnv("SUDO_ACCESS=false", "PASSWORD_ACCESS=true", + "USER_NAME=test", // TODO : User login + "USER_PASSWORD=test" // TODO : Random passwd + ) .exec(); return container.getId(); } - public InspectContainerResponse.ContainerState getStatusContainer(String name) { - InspectContainerResponse container = dockerClient.inspectContainerCmd(name).exec(); - return container.getState(); - } - - public boolean remove(String name) { - try { - dockerClient.removeContainerCmd(name).exec(); - return true; - } catch (Exception e) { - return false; - } - } - public boolean containerExists(String name) { try { dockerClient.inspectContainerCmd(name).exec(); @@ -227,6 +216,31 @@ public class DockerService { } } + public List listAllContainers() { + List containers = + dockerClient.listContainersCmd().withShowAll(true).exec(); + return containers.stream().map(this::toDockerResponse).toList(); + } + + private DockerResponse toDockerResponse(Container container) { + List portsList = new ArrayList<>(); + for (var port : container.getPorts()) { + portsList.add(String.format("%s:%s", port.getPrivatePort(), + port.getPublicPort())); + } + + return new DockerResponse(container.getNames()[0].substring(1), + container.getStatus(), container.getImage(), + portsList); + } + + public InspectContainerResponse.ContainerState + getStatusContainer(String name) { + InspectContainerResponse container = + dockerClient.inspectContainerCmd(name).exec(); + return container.getState(); + } + public void start(String containerId) { dockerClient.startContainerCmd(containerId).exec(); } @@ -235,21 +249,12 @@ public class DockerService { dockerClient.stopContainerCmd(containerId).exec(); } - public List listAllContainers() { - List containers = dockerClient.listContainersCmd() - .withShowAll(true) - .exec(); - return containers.stream().map(this::toDockerResponse).toList(); - } - - private DockerResponse toDockerResponse(Container container) { - List portsList = new ArrayList<>(); - for (var port : container.getPorts()) { - portsList.add(String.format("%s:%s", port.getPrivatePort(), port.getPublicPort())); + public boolean remove(String name) { + try { + dockerClient.removeContainerCmd(name).exec(); + return true; + } catch (Exception e) { + return false; } - - return new DockerResponse(container.getNames()[0].substring(1), container.getStatus(), container.getImage(), - portsList); } - } diff --git a/src/main/java/fr/la_banquise/backend/services/InstanceService.java b/src/main/java/fr/la_banquise/backend/services/InstanceService.java index c89e419..f2396c4 100644 --- a/src/main/java/fr/la_banquise/backend/services/InstanceService.java +++ b/src/main/java/fr/la_banquise/backend/services/InstanceService.java @@ -28,6 +28,19 @@ public class InstanceService { @Inject DockerService dockerService; + /////////////////////////////////////////////////////////////////////////// + /// + /// First, we create our Instance and basic functions + + @Transactional + public Instance createInstance(Long userId, Ji ji) { + User user = userRepository.findById(userId); + String name = user.name + "-" + ji.id; + int port = getFreePort(1).iterator().next(); + Instance instance = new Instance(name, port, user, "Not created"); + instanceRepository.persist(instance); + return instance; + } public List getAllInstances() { return instanceRepository.findAll().list(); } @@ -41,41 +54,58 @@ public class InstanceService { return instanceRepository.findById(id); } + /////////////////////////////////////////////////////////////////////////// + + /// Now that the Instance is created, create their containers (and handle + /// if it is already created) ! + + public void createContainer(Long instanceId) { + Instance instance = instanceRepository.findById(instanceId); + if (instance.containerId.equals("Not created")) + instance.containerId = + dockerService.createContainer(instance.name, instance.port); + } + public InspectContainerResponse.ContainerState getStatusContainer(Long id) { Instance instance = instanceRepository.findById(id); return dockerService.getStatusContainer(instance.name); } + + /////////////////////////////////////////////////////////////////////////// - @Transactional - public Instance createInstance(Long id, Ji ji) { - User user = userRepository.findById(id); - String name = user.name + "-" + ji.id; - int port = getFreePort(1).iterator().next(); - Instance instance = new Instance(name, port, user); - instanceRepository.persist(instance); - return instance; - } + /// Finally, start/stop the containers - public String createContainer(Long instanceId) { + public void startContainer(Long instanceId) { Instance instance = instanceRepository.findById(instanceId); - - return dockerService.createContainer(instance.name, instance.port); + dockerService.start(instance.containerId); } + public void stopContainer(Long instanceId) { + Instance instance = instanceRepository.findById(instanceId); + dockerService.stop(instance.containerId); + } + + /////////////////////////////////////////////////////////////////////////// + + /// Last but not least, be able do delete every container and instance + public boolean deleteContainer(Long id) { Instance instance = instanceRepository.findById(id); return dockerService.remove(instance.name); } + @Transactional - public boolean deleteInstance(Long id) { + public void deleteInstance(Long id) { Instance instance = instanceRepository.findById(id); - if (!dockerService.containerExists(instance.name)) - return instanceRepository.deleteById(id); - return false; + if (dockerService.containerExists(instance.containerId)) + dockerService.remove(instance.containerId); + instanceRepository.deleteById(id); } + /////////////////////////////////////////////////////////////////////////// + ///UTILS FOR PORTS NUMBERS HANDLING public Set getUsedPorts() { Set retour = new HashSet<>(); List allInstances = getAllInstances(); diff --git a/src/main/java/fr/la_banquise/backend/services/JiService.java b/src/main/java/fr/la_banquise/backend/services/JiService.java index 44eeb7b..5cece85 100644 --- a/src/main/java/fr/la_banquise/backend/services/JiService.java +++ b/src/main/java/fr/la_banquise/backend/services/JiService.java @@ -18,18 +18,22 @@ public class JiService { @Inject JiRepository jiRepository; @Inject UserRepository userRepository; @Inject SiteService siteService; + @Inject UserService userService; @Inject InstanceService instanceService; @Inject SecurityContext security; + /////////////////////////////////////////////////////////////////////////// + /// + /// First, we create our JI and basic functions @Transactional public Ji createJi(String name, String description, String date, - Long siteId) { + Long siteId, Long ownerId) { Site site = siteService.getSite(siteId); - User currentUser = - userRepository.findByName(security.getUserPrincipal().getName()); - Ji ji = new Ji(name, description, List.of(currentUser), date, site); + User user = userService.getUser(ownerId); + Ji ji = new Ji(name, description, List.of(user), date, site); jiRepository.persist(ji); - siteService.addJi(site, ji); + siteService.registerJi(site, ji); + createInstance(user.id, ji.id); return ji; } @@ -42,15 +46,13 @@ public class JiService { public Ji getJi(Long id) { return jiRepository.findById(id); } - @Transactional - public void deleteJi(Long id) { - Ji ji = getJi(id); - siteService.removeJi(ji.site, ji); - jiRepository.deleteById(id); - } + /////////////////////////////////////////////////////////////////////////// + + /// Now that the JI is created, we want to add users to it and assign them + /// instances, but DONT create their containers yet ! @Transactional - public Instance createInstance(Long jiId, Long userId) { + public Instance createInstance(Long userId, Long jiId) { Ji ji = jiRepository.findById(jiId); Instance instance = instanceService.createInstance(userId, ji); ji.instances.add(instance); @@ -69,34 +71,103 @@ public class JiService { } @Transactional - public String createContainer(Long id, String username) { - Ji ji = jiRepository.findById(id); - String retour = ""; + public void registerUser(Long userId, Long jiId) { + User user = userService.getUser(userId); + Ji ji = getJi(jiId); + ji.participants.add(user); + createInstance(userId, jiId); + } + + /////////////////////////////////////////////////////////////////////////// + + /// Then, when an admin decides it, we create the containers + + /*@Transactional + public void createContainer(Long jiId, Long userId) { + Ji ji = jiRepository.findById(jiId); + String username = userService.getUser(userId).name; for (Instance instance : ji.instances) { - if (instance.name.equals(username + "-" + id)) { - retour = instanceService.createContainer(instance.id); + if (instance.name.equals(username + "-" + jiId)) { + instanceService.createContainer(instance.id); + break; + } + } + }*/ + + // On dit a toute les instances de creer leur container. + // Instance gere le cas ou le container existe deja. + @Transactional + public void createContainers(Long jiId) { + Ji ji = jiRepository.findById(jiId); + for (Instance instance : ji.instances) { + instanceService.createContainer(instance.id); + } + } + + public String getStatusContainer(Long jiId, Long userId) { + Ji ji = jiRepository.findById(jiId); + String username = userService.getUser(userId).name; + String retour = ""; + for (Instance instance : ji.instances) { + if (instance.name.equals(username + "-" + jiId)) { + if (instance.containerId.equals("Not created")) + return "Not created"; + retour = instanceService.getStatusContainer(instance.id) + .toString() + .replaceAll(".*status=([^,]+).*", "$1"); break; } } if (retour == "") - throw new Error("instance or container not found"); - + return "Not created"; return retour; } - public String getStatusContainer(Long id, String username) { - Ji ji = jiRepository.findById(id); + public String getStatusContainers(Long jiId) { + Ji ji = jiRepository.findById(jiId); String retour = ""; for (Instance instance : ji.instances) { - if (instance.name.equals(username + "-" + id)) { - retour = + if (instance.containerId.equals("Not created")) + retour += "Not created"; + else { + retour += instanceService.getStatusContainer(instance.id).toString(); - break; } } - if (retour == "") - throw new Error("instance or container not found"); return retour; } + /////////////////////////////////////////////////////////////////////////// + + /// Finally, start/stop the containers + + @Transactional + public void startContainers(Long jiId) { + Ji ji = jiRepository.findById(jiId); + for (Instance instance : ji.instances) { + instanceService.startContainer(instance.id); + } + } + + @Transactional + public void stopContainers(Long jiId) { + Ji ji = jiRepository.findById(jiId); + for (Instance instance : ji.instances) { + instanceService.stopContainer(instance.id); + } + } + + /////////////////////////////////////////////////////////////////////////// + + /// Last but not least, be able do delete every container and instance + + @Transactional + public void deleteJi(Long jiId) { + Ji ji = getJi(jiId); + for (Instance instance : ji.instances) { + instanceService.deleteInstance(instance.id); + } + siteService.removeJi(ji.site, ji); + jiRepository.deleteById(jiId); + } } diff --git a/src/main/java/fr/la_banquise/backend/services/SiteService.java b/src/main/java/fr/la_banquise/backend/services/SiteService.java index 95c0eff..f78fad8 100644 --- a/src/main/java/fr/la_banquise/backend/services/SiteService.java +++ b/src/main/java/fr/la_banquise/backend/services/SiteService.java @@ -20,18 +20,12 @@ public class SiteService { return site; } - /*@Transactional - public List saveAllSites(List sites) { - sites.forEach(site -> siteRepository.persist(site)); - return sites; - }*/ - public List getAllSites() { return siteRepository.listAll(); } public Site getSite(Long id) { return siteRepository.findById(id); } @Transactional - public void addJi(Site site, Ji ji) { + public void registerJi(Site site, Ji ji) { site.listJi.add(ji); } diff --git a/src/main/java/fr/la_banquise/backend/services/UserService.java b/src/main/java/fr/la_banquise/backend/services/UserService.java index 81aaedd..b972466 100644 --- a/src/main/java/fr/la_banquise/backend/services/UserService.java +++ b/src/main/java/fr/la_banquise/backend/services/UserService.java @@ -26,6 +26,7 @@ public class UserService { @Inject UserRepository userRepository; @Inject InstanceService instanceService; + @Inject JiService jiService; @Inject JiRepository jiRepository; public List getAllUsers() { return userRepository.listAll(); } @@ -35,6 +36,15 @@ public class UserService { public Long getId(String name) { return userRepository.findByName(name).id; } + public boolean userExists(String name) { + try { + if (userRepository.findByName(name) != null) + return true; + return false; + } catch (Exception e) { + return false; + } + } @Transactional public UserPostResponse createUser(UserRequest request, String code) { @@ -100,14 +110,12 @@ public class UserService { if (jiRepository.findById(usersRequest.jiId) != null) { for (UserRequest user : usersRequest.users) { - try { - Random rand = new Random(); - int random = rand.nextInt(8999) + 1000; - createUser(user, String.valueOf(random)); - response.successMails.add(user.email); - response.successPasswd.add(user.name + - String.valueOf(random)); - } catch (Exception e) { + if (!userExists(user.name)) { + UserPostResponse resp = createUserRandom(user); + response.successMails.add(resp.user.email); + response.successPasswd.add(resp.passwd); + jiService.registerUser(resp.user.id, usersRequest.jiId); + } else { response.alreadyCreated.add(user.name); } } diff --git a/src/main/webui b/src/main/webui index 69955ac..afc23d1 160000 --- a/src/main/webui +++ b/src/main/webui @@ -1 +1 @@ -Subproject commit 69955ac4336fc9c492bbe24b23c8098f7afb69ab +Subproject commit afc23d1208d476279930f4852388d30c39258593