X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=otf-service-api%2Fsrc%2Fmain%2Fjava%2Forg%2Foran%2Fotf%2Fapi%2Fservice%2Fimpl%2FVirtualTestHeadServiceImpl.java;fp=otf-service-api%2Fsrc%2Fmain%2Fjava%2Forg%2Foran%2Fotf%2Fapi%2Fservice%2Fimpl%2FVirtualTestHeadServiceImpl.java;h=d2a662b6fd127e4a2ae5c9c120be0ec8e316d60c;hb=6f7e46b4562b31f748670be8947d315963240ddd;hp=0000000000000000000000000000000000000000;hpb=f49bd1efeaaddd4891c1f329b18d8cfb28b3e75b;p=it%2Fotf.git

diff --git a/otf-service-api/src/main/java/org/oran/otf/api/service/impl/VirtualTestHeadServiceImpl.java b/otf-service-api/src/main/java/org/oran/otf/api/service/impl/VirtualTestHeadServiceImpl.java
new file mode 100644
index 0000000..d2a662b
--- /dev/null
+++ b/otf-service-api/src/main/java/org/oran/otf/api/service/impl/VirtualTestHeadServiceImpl.java
@@ -0,0 +1,164 @@
+/*  Copyright (c) 2019 AT&T Intellectual Property.                             #
+#                                                                              #
+#   Licensed under the Apache License, Version 2.0 (the "License");            #
+#   you may not use this file except in compliance with the License.           #
+#   You may obtain a copy of the License at                                    #
+#                                                                              #
+#       http://www.apache.org/licenses/LICENSE-2.0                             #
+#                                                                              #
+#   Unless required by applicable law or agreed to in writing, software        #
+#   distributed under the License is distributed on an "AS IS" BASIS,          #
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
+#   See the License for the specific language governing permissions and        #
+#   limitations under the License.                                             #
+##############################################################################*/
+
+
+package org.oran.otf.api.service.impl;
+
+import org.oran.otf.api.Utilities;
+import org.oran.otf.api.service.VirtualTestHeadService;
+import org.oran.otf.common.model.Group;
+import org.oran.otf.common.model.TestHead;
+import org.oran.otf.common.model.User;
+import org.oran.otf.common.repository.GroupRepository;
+import org.oran.otf.common.repository.TestHeadRepository;
+import org.oran.otf.common.repository.UserRepository;
+import org.oran.otf.common.utility.Utility;
+import org.oran.otf.common.utility.database.Generic;
+import org.oran.otf.common.utility.http.ResponseUtility;
+import org.oran.otf.common.utility.permissions.PermissionChecker;
+import org.oran.otf.common.utility.permissions.UserPermission;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.stereotype.Service;
+
+import javax.ws.rs.core.Response;
+import java.util.Date;
+import java.util.Optional;
+
+@Service
+public class VirtualTestHeadServiceImpl implements VirtualTestHeadService {
+
+    @Autowired
+    private UserRepository userRepository;
+    @Autowired
+    private GroupRepository groupRepository;
+
+    @Autowired
+    TestHeadRepository testHeadRepository;
+
+    @Autowired
+    MongoTemplate mongoTemplate;
+
+    private static final String logPrefix = Utility.getLoggerPrefix();
+
+    @Override
+    public Response updateVirtualTestHead(String authorization, String testHeadName, TestHead newTestHead) {
+        if (authorization == null) {
+            return Utilities.Http.BuildResponse.unauthorizedWithMessage("Missing authorization header.");
+        }
+
+        // try to find the test head
+        Optional<TestHead> optionalTestHead =
+                testHeadRepository.findByTestHeadName(testHeadName);
+        TestHead testHead = Utilities.resolveOptional(optionalTestHead);
+        if (testHead == null) {
+            return Utilities.Http.BuildResponse.badRequestWithMessage(
+                    String.format("A test head with identifier %s was not found.", testHeadName));
+        }
+
+        // try to find the group of the test head
+        String testHeadGroupId = testHead.getGroupId().toString();
+        Group testHeadGroup = Generic.findByIdGeneric(groupRepository, testHead.getGroupId());
+        if (testHeadGroup == null) {
+            return Utilities.Http.BuildResponse.badRequestWithMessage(
+                    String.format(
+                            "The group (id: %s) associated with the test head does not exist.",
+                            testHeadGroupId));
+        }
+
+        // try to find the user for the mechanizedId used to make this request
+        User user = Utilities.findUserByAuthHeader(authorization, userRepository);
+        if (user == null) {
+            return Utilities.Http.BuildResponse.badRequestWithMessage(
+                    "No user associated with mechanized identifier used for this request.");
+        }
+
+        if (!PermissionChecker.hasPermissionTo(user, testHeadGroup, UserPermission.Permission.WRITE, groupRepository)) {
+            String error =
+                    String.format(
+                            "Unauthorized the write to test head with name, %s.",
+                            testHeadGroupId);
+            return ResponseUtility.Build.unauthorizedWithMessage(error);
+        }
+
+        return updateTestHeadFields(testHead, newTestHead, user);
+    }
+
+    private Response updateTestHeadFields(TestHead testHead, TestHead newTestHead, User user) {
+        Query select = Query.query(Criteria.where("_id").is(testHead.get_id()));
+        Update update = new Update();
+
+        if (newTestHead.getTestHeadName() != null) {
+            if (doesTestHeadWithNameExist(newTestHead.getTestHeadName())) {
+                String error =
+                        String.format(
+                                "Cant change testHeadName to %s since it already exists.",
+                                newTestHead.getTestHeadName());
+                return ResponseUtility.Build.badRequestWithMessage(error);
+            }
+            testHead.setTestHeadName(newTestHead.getTestHeadName());
+            update.set("testHeadName", newTestHead.getTestHeadName());
+        }
+        if (newTestHead.getTestHeadDescription() != null) {
+            testHead.setTestHeadDescription(newTestHead.getTestHeadDescription());
+            update.set("testHeadDescription", newTestHead.getTestHeadDescription());
+        }
+        if (newTestHead.getHostname() != null) {
+            testHead.setHostname(newTestHead.getHostname());
+            update.set("hostname", newTestHead.getHostname());
+        }
+        if (newTestHead.getPort() != null) {
+            testHead.setPort(newTestHead.getPort());
+            update.set("port", newTestHead.getPort());
+        }
+        if (newTestHead.getResourcePath() != null) {
+            testHead.setResourcePath(newTestHead.getResourcePath());
+            update.set("resourcePath", newTestHead.getResourcePath());
+        }
+        if (newTestHead.getAuthorizationType() != null) {
+            testHead.setAuthorizationType(newTestHead.getAuthorizationType());
+            update.set("authorizationType", newTestHead.getAuthorizationType());
+        }
+        if (newTestHead.getAuthorizationCredential() != null) {
+            testHead.setAuthorizationCredential(newTestHead.getAuthorizationCredential());
+            update.set("authorizationCredential", newTestHead.getAuthorizationCredential());
+        }
+        if (newTestHead.getAuthorizationEnabled() != null) {
+            testHead.setAuthorizationEnabled(newTestHead.getAuthorizationEnabled());
+            update.set("authorizationEnabled", newTestHead.getAuthorizationEnabled());
+        }
+        if (newTestHead.getVthInputTemplate() != null) {
+            testHead.setVthInputTemplate(newTestHead.getVthInputTemplate());
+            update.set("vthInputTemplate", newTestHead.getVthInputTemplate());
+        }
+        testHead.setUpdatedAt(new Date());
+        update.set("updatedAt", testHead.getUpdatedAt());
+        testHead.setUpdatedBy(user.get_id());
+        update.set("updatedBy", user.get_id());
+
+        mongoTemplate.updateFirst(select, update, "testHeads");
+        return ResponseUtility.Build.okRequestWithObject(testHead);
+    }
+
+    // check if test head exists in database by name
+    private boolean doesTestHeadWithNameExist(String name) {
+        Optional<TestHead> optionalTestHead =
+                testHeadRepository.findByTestHeadName(name);
+        return optionalTestHead.isPresent();
+    }
+}