gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2023 highstreet technologies GmbH Intellectual Property.
   6  * All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  */
  22 package org.onap.ccsdk.features.sdnr.wt.dataprovider.model;
  23
  24 import java.io.IOException;
  25 import java.util.ArrayList;
  26 import java.util.List;
  27 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.SortOrder;
  28 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.types.DataTreeChildObject;
  29 import org.onap.ccsdk.features.sdnr.wt.dataprovider.model.types.DataTreeObject;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.InventoryEntity;
  31 import org.opendaylight.yangtools.yang.common.Uint32;
  32
  33 public abstract class BaseInventoryTreeProvider implements InventoryTreeProvider {
  34
  35     private static final String INVENTORY_PROPERTY_TREELEVEL = "tree-level";
  36     protected static final String INVENTORY_PROPERTY_NODEID = "node-id";
  37     protected static final String INVENTORY_PROPERTY_UUID = "uuid";
  38     protected static final String INVENTORY_PROPERTY_PARENTUUID = "parent-uuid";
  39
  40     protected abstract List<String> getAllNodeIds();
  41
  42     protected abstract List<InventoryEntity> search(String filter, String sortOrderProperty, SortOrder sortOrder);
  43
  44     protected abstract List<InventoryEntity> search(String filter, String nodeId, String parentUuid, String uuid,
  45             String sortOrderProperty, SortOrder sortOrder);
  46
  47     protected abstract List<InventoryEntity> getItemsForNodes(List<String> nodeIds, String sortOrderProperty,
  48             SortOrder sortOrder);
  49
  50
  51     @Override
  52     public DataTreeObject readInventoryTree(List<String> tree, String filter) throws IOException {
  53
  54         //root nodes will be node-information -> below inventory
  55         if (tree == null || tree.size() <= 0) {
  56             return this.readInventoryTreeWithNode(filter);
  57         }
  58         //root node will be inventory on tree-level if sliced treePath
  59         else {
  60             return this.readInventoryTreeForNode(tree.get(0), tree.subList(0, tree.size() - 1), filter);
  61         }
  62
  63     }
  64
  65     /**
  66      * Provide inventory list for a node, starting from element described by path
  67      * @param nodeId node
  68      * @param path describing element
  69      * @param filter
  70      * @return Inventory tree
  71      */
  72     private DataTreeObject readInventoryTreeForNode(String nodeId, List<String> path, String filter)
  73             throws IOException {
  74         DataTreeObject tree = new DataTreeObject(INVENTORY_PROPERTY_PARENTUUID, INVENTORY_PROPERTY_UUID);
  75         //get parent uuid of path
  76         final String parentUuid = path.size() > 1 ? path.get(path.size() - 2) : null;
  77         //get uuid of path
  78         final String uuid = path.size() > 0 ? path.get(path.size() - 1) : null;
  79         List<InventoryEntity> matches =
  80                 this.search(filter, nodeId, parentUuid, uuid, INVENTORY_PROPERTY_TREELEVEL, SortOrder.ASCENDING);
  81         //tree.a(subtreePath);
  82         List<InventoryEntity> others =
  83                 this.search((String) null, nodeId, null, null, INVENTORY_PROPERTY_TREELEVEL, SortOrder.ASCENDING);
  84         if (matches.size() > 0) {
  85             int treeLevelToStart = (path == null || path.size() <= 0) ? 0 : path.size() - 1;
  86             //build tree
  87             //fill root elems
  88             for (InventoryEntity hit : matches) {
  89                 if (hit.getTreeLevel().longValue() == treeLevelToStart) {
  90                     tree.put(hit.getId(),
  91                             new DataTreeChildObject(hit.getUuid(), true)
  92                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
  93                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
  94                 }
  95             }
  96             for (InventoryEntity hit : others) {
  97                 if (hit.getTreeLevel().longValue() == treeLevelToStart) {
  98                     tree.putIfNotExists(hit.getId(),
  99                             new DataTreeChildObject(hit.getUuid(), false)
 100                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 101                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
 102                 }
 103             }
 104             //fill child elems
 105             for (InventoryEntity hit : matches) {
 106                 if (hit.getTreeLevel().longValue() > treeLevelToStart) {
 107                     tree.put(hit.getTreeLevel().longValue() - treeLevelToStart - 1, hit.getId(),
 108                             new DataTreeChildObject(hit.getUuid(), true)
 109                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 110                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
 111                 }
 112             }
 113             for (InventoryEntity hit : others) {
 114                 if (hit.getTreeLevel().longValue() > treeLevelToStart) {
 115                     tree.putIfNotExists(hit.getTreeLevel().longValue() - treeLevelToStart - 1, hit.getId(),
 116                             new DataTreeChildObject(hit.getUuid(), false)
 117                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 118                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
 119                 }
 120             }
 121             tree.removeUnmatchedPaths();
 122         }
 123         return tree;
 124     }
 125
 126     /**
 127      * node will be root elements inventory information below from level-1
 128      *
 129      * @param filter
 130      * @return
 131      * @throws IOException
 132      */
 133     private DataTreeObject readInventoryTreeWithNode(String filter) throws IOException {
 134         DataTreeObject tree = new DataTreeObject(INVENTORY_PROPERTY_PARENTUUID, INVENTORY_PROPERTY_UUID);
 135
 136         List<InventoryEntity> matches = this.search(filter, INVENTORY_PROPERTY_TREELEVEL, SortOrder.ASCENDING);
 137         List<InventoryEntity> others = null;
 138         if (matches.size() > 0) {
 139             if (filter != null) {
 140                 //find all parents up to tree-level 0
 141                 String nodeId = "";
 142                 List<String> alreadyInList = new ArrayList<>();
 143                 for (InventoryEntity hit : matches) {
 144                     nodeId = hit.getNodeId();
 145                     if (alreadyInList.contains(nodeId)) {
 146                         continue;
 147                     }
 148                     alreadyInList.add(nodeId);
 149                     tree.put(nodeId,
 150                             new DataTreeChildObject(nodeId, false).setProperty(INVENTORY_PROPERTY_UUID, nodeId));
 151
 152                 }
 153                 others = this.getItemsForNodes(alreadyInList, INVENTORY_PROPERTY_TREELEVEL, SortOrder.ASCENDING);
 154             } else {
 155                 List<String> nodeIds = this.getAllNodeIds();
 156                 for (String node : nodeIds) {
 157                     tree.put(node, new DataTreeChildObject(node, false).setProperty(INVENTORY_PROPERTY_UUID, node));
 158                 }
 159             }
 160
 161             //build tree
 162             //fill root elems
 163             for (InventoryEntity hit : matches) {
 164                 if (hit.getTreeLevel() == Uint32.ZERO) {
 165                     tree.put(0, hit.getId(),
 166                             new DataTreeChildObject(hit.getUuid(), true)
 167                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 168                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getNodeId()));
 169                 }
 170             }
 171             if (others != null) {
 172                 for (InventoryEntity hit : others) {
 173                     if (hit.getTreeLevel() == Uint32.ZERO) {
 174                         tree.putIfNotExists(0, hit.getId(),
 175                                 new DataTreeChildObject(hit.getUuid(), false)
 176                                         .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 177                                         .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getNodeId()));
 178                     }
 179                 }
 180             }
 181             //fill child elements
 182             for (InventoryEntity hit : matches) {
 183                 long treeLevel = hit.getTreeLevel().longValue();
 184                 if (treeLevel > 0) {
 185                     tree.put(treeLevel, hit.getId(),
 186                             new DataTreeChildObject(hit.getUuid(), true)
 187                                     .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 188                                     .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
 189                 }
 190             }
 191             if (others != null) {
 192                 for (InventoryEntity hit : others) {
 193                     long treeLevel = hit.getTreeLevel().longValue();
 194                     if (treeLevel > 0) {
 195                         tree.putIfNotExists(treeLevel, hit.getId(),
 196                                 new DataTreeChildObject(hit.getUuid(), false)
 197                                         .setProperty(INVENTORY_PROPERTY_UUID, hit.getUuid())
 198                                         .setProperty(INVENTORY_PROPERTY_PARENTUUID, hit.getParentUuid()));
 199                     }
 200                 }
 201             }
 202             tree.removeUnmatchedPaths();
 203         }
 204         return tree;
 205     }
 206 }