gerrit.onap Code Review - vfc/nfvo/catalog.git/blob

   1 /**
   2  * Copyright 2016 ZTE Corporation.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.openo.commontosca.catalog.db.resource;
  17
  18 import org.openo.commontosca.catalog.db.common.Parameters;
  19 import org.openo.commontosca.catalog.db.entity.NodeTemplateData;
  20 import org.openo.commontosca.catalog.db.entity.PackageData;
  21 import org.openo.commontosca.catalog.db.entity.ServiceTemplateData;
  22 import org.openo.commontosca.catalog.db.entity.ServiceTemplateMappingData;
  23 import org.openo.commontosca.catalog.db.entity.TemplateData;
  24 import org.openo.commontosca.catalog.db.exception.CatalogResourceException;
  25 import org.openo.commontosca.catalog.db.util.CatalogDbUtil;
  26 import org.openo.commontosca.catalog.db.util.HqlFactory;
  27 import org.openo.commontosca.catalog.db.wrapper.NodeTemplateHandler;
  28 import org.openo.commontosca.catalog.db.wrapper.ServiceTemplateHandler;
  29 import org.openo.commontosca.catalog.db.wrapper.ServiceTemplateMappingHandler;
  30 import org.openo.commontosca.catalog.db.wrapper.TemplateHandler;
  31
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 import java.util.ArrayList;
  36 import java.util.HashMap;
  37 import java.util.Map;
  38
  39 public class TemplateManager {
  40   private static final Logger LOGGER = LoggerFactory.getLogger(TemplateManager.class);
  41   private static TemplateManager manager;
  42   ServiceTemplateHandler handler = new ServiceTemplateHandler();
  43   NodeTemplateHandler nodeTemplateHandler = new NodeTemplateHandler();
  44   TemplateHandler templateHandler = new TemplateHandler();
  45   ServiceTemplateMappingHandler mappingHandler = new ServiceTemplateMappingHandler();
  46
  47   /**
  48    * get TemplateManager instance.
  49    * @return TemplateManager instance
  50    */
  51   public static synchronized TemplateManager getInstance() {
  52     if (manager == null) {
  53       manager = new TemplateManager();
  54     }
  55     return manager;
  56   }
  57
  58   private TemplateManager() {}
  59
  60   /**
  61    * add service template.
  62    *
  63    * @param templateData TemplateData
  64    * @return TemplateData
  65    * @throws CatalogResourceException e
  66    */
  67   public TemplateData addServiceTemplate(TemplateData templateData)
  68       throws CatalogResourceException {
  69     LOGGER
  70         .info("start add template info  to db.info:" + CatalogDbUtil.objectToString(templateData));
  71     TemplateData data = templateHandler.create(templateData);
  72     LOGGER.info(" template info  to db end.info:" + CatalogDbUtil.objectToString(data));
  73     return data;
  74   }
  75
  76   /**
  77    * add service template mapping.
  78    * @param templateMappingData mapping data
  79    * @return ServiceTemplateMappingData
  80    * @throws CatalogResourceException e
  81    */
  82   public ServiceTemplateMappingData addServiceTemplateMapping(
  83       ServiceTemplateMappingData templateMappingData) throws CatalogResourceException {
  84     LOGGER.info("start add servicetemplate Mapping  info  to db.info:"
  85         + CatalogDbUtil.objectToString(templateMappingData));
  86     ServiceTemplateMappingData data = mappingHandler.create(templateMappingData);
  87     LOGGER.info(" template mapping info  to db end.info:" + CatalogDbUtil.objectToString(data));
  88     return data;
  89   }
  90
  91   /**
  92    * query service template mapping by id.
  93    * @param id id
  94    * @return ServiceTemplateMappingData list
  95    * @throws CatalogResourceException e
  96    */
  97   public ArrayList<ServiceTemplateMappingData> queryServiceTemplateMappingById(String id)
  98       throws CatalogResourceException {
  99     Map<String, String> queryParam = new HashMap<String, String>();
 100     queryParam.put(Parameters.mappingId.name(), id);
 101     LOGGER.info("start query serviceTemplateMapping info by id." + id);
 102     ArrayList<ServiceTemplateMappingData> data = mappingHandler.query(queryParam);
 103     LOGGER.info("query serviceTemplateMapping info end.size:" + data.size() + "detail:"
 104         + CatalogDbUtil.objectToString(data));
 105     return data;
 106   }
 107
 108   /**
 109    * delete service template mapping by id.
 110    * @param id id
 111    * @throws CatalogResourceException e
 112    */
 113   public void deleteServiceTemplateMappingById(String id) throws CatalogResourceException {
 114
 115     LOGGER.info("start delete serviceTemplateMapping info by id." + id);
 116     mappingHandler.delete(id);
 117     LOGGER.info("delete serviceTemplateMapping info end");
 118   }
 119
 120   /**
 121    * delete service template mapping.
 122    * @param nodeType node type
 123    * @param serviceTemplateId service template id
 124    * @throws CatalogResourceException e
 125    */
 126   public void deleteServiceTemplateMapping(String nodeType, String serviceTemplateId)
 127       throws CatalogResourceException {
 128     Map<String, String> delParam = new HashMap<String, String>();
 129     if (CatalogDbUtil.isNotEmpty(nodeType)) {
 130       delParam.put(Parameters.nodeType.name(), nodeType);
 131     }
 132     if (CatalogDbUtil.isNotEmpty(serviceTemplateId)) {
 133       delParam.put(Parameters.serviceTemplateId.name(), serviceTemplateId);
 134     }
 135     LOGGER.info("start delete serviceTemplateMapping info.nodeType:" + nodeType
 136         + " serviceTemplateId:" + serviceTemplateId);
 137     mappingHandler.delete(delParam);
 138     LOGGER.info("delete serviceTemplateMapping info ");
 139   }
 140
 141   /**
 142    * query service template mapping.
 143    * @param nodeType nodeType
 144    * @param serviceTemplateId serviceTemplateId
 145    * @return ServiceTemplateMappingData list
 146    * @throws CatalogResourceException e
 147    */
 148   public ArrayList<ServiceTemplateMappingData> queryServiceTemplateMapping(String nodeType,
 149       String serviceTemplateId) throws CatalogResourceException {
 150     Map<String, String> queryParam = new HashMap<String, String>();
 151     if (CatalogDbUtil.isNotEmpty(nodeType)) {
 152       queryParam.put(Parameters.nodeType.name(), nodeType);
 153     }
 154     if (CatalogDbUtil.isNotEmpty(serviceTemplateId)) {
 155       queryParam.put(Parameters.serviceTemplateId.name(), serviceTemplateId);
 156     }
 157     LOGGER.info("start query serviceTemplateMapping info.nodeType:" + nodeType
 158         + " serviceTemplateId:" + serviceTemplateId);
 159     ArrayList<ServiceTemplateMappingData> data = mappingHandler.query(queryParam);
 160     LOGGER.info("query serviceTemplateMapping info end.size:" + data.size() + "detail:"
 161         + CatalogDbUtil.objectToString(data));
 162     return data;
 163   }
 164
 165   /**
 166    * query service template by id.
 167    * @param id service template id
 168    * @return ServiceTemplateData list
 169    * @throws CatalogResourceException e
 170    */
 171   public ArrayList<ServiceTemplateData> queryServiceTemplateById(String id)
 172       throws CatalogResourceException {
 173     Map<String, String> queryParam = new HashMap<String, String>();
 174     queryParam.put(Parameters.serviceTemplateId.name(), id);
 175     LOGGER.info("start query serviceTemplate info by id." + id);
 176     ArrayList<ServiceTemplateData> data = handler.query(queryParam);
 177     LOGGER.info("query serviceTemplate info end.size:" + data.size() + "detail:"
 178         + CatalogDbUtil.objectToString(data));
 179     return data;
 180   }
 181
 182   /**
 183    * query service template according to condition.
 184    * @param type template type
 185    * @param version template version
 186    * @param vendor template vendor
 187    * @return ServiceTemplateData list
 188    * @throws CatalogResourceException e
 189    */
 190   public ArrayList<ServiceTemplateData> queryServiceTemplate(String type, String version,
 191       String vendor) throws CatalogResourceException {
 192     LOGGER.info("start query serviceTemplate info.type:" + type + " vendor:" + vendor + " version:"
 193         + version);
 194     Map<String, String> queryParam = new HashMap<String, String>();
 195     if (CatalogDbUtil.isNotEmpty(type)) {
 196       queryParam.put(Parameters.type.name(), type);
 197     }
 198     if (CatalogDbUtil.isNotEmpty(vendor)) {
 199       queryParam.put(Parameters.vendor.name(), vendor);
 200     }
 201     if (CatalogDbUtil.isNotEmpty(version)) {
 202       queryParam.put(Parameters.version.name(), version);
 203     }
 204     ArrayList<ServiceTemplateData> data = handler.query(queryParam);
 205     LOGGER.info("query serviceTemplate info end.size:" + data.size() + "detail:"
 206         + CatalogDbUtil.objectToString(data));
 207     return data;
 208   }
 209
 210   /**
 211    * query node template service template id.
 212    * @param serviceTemplateId service template id
 213    * @return NodeTemplateData list
 214    * @throws CatalogResourceException e
 215    */
 216   public ArrayList<NodeTemplateData> queryNodeTemplateBySeriviceTemplateId(String serviceTemplateId)
 217       throws CatalogResourceException {
 218     LOGGER.info("start query NodeTemplate info.serviceTemplateId:" + serviceTemplateId);
 219     Map<String, String> queryParam = new HashMap<String, String>();
 220     queryParam.put(Parameters.serviceTemplateId.name(), serviceTemplateId);
 221     ArrayList<NodeTemplateData> data = nodeTemplateHandler.query(queryParam);
 222     LOGGER.info("query NodeTemplate info end.size:" + data.size() + "detail:"
 223         + CatalogDbUtil.objectToString(data));
 224     return data;
 225   }
 226
 227   /**
 228    * query node template by id.
 229    * @param serviceTemplateId service template id
 230    * @param nodeTemplateId nodetemplate id
 231    * @return NodeTemplateData list
 232    * @throws CatalogResourceException e
 233    */
 234   public ArrayList<NodeTemplateData> queryNodeTemplateById(String serviceTemplateId,
 235       String nodeTemplateId) throws CatalogResourceException {
 236     LOGGER.info("start query NodeTemplate info.serviceTemplateId:" + serviceTemplateId
 237         + "nodeTemplateId:" + nodeTemplateId);
 238     Map<String, String> queryParam = new HashMap<String, String>();
 239     if (CatalogDbUtil.isNotEmpty(serviceTemplateId)) {
 240       queryParam.put(Parameters.serviceTemplateId.name(), serviceTemplateId);
 241     }
 242     if (CatalogDbUtil.isNotEmpty(nodeTemplateId)) {
 243       queryParam.put(Parameters.nodeTemplateId.name(), nodeTemplateId);
 244     }
 245     ArrayList<NodeTemplateData> data = nodeTemplateHandler.query(queryParam);
 246     LOGGER.info("query NodeTemplate info end.size:" + data.size() + "detail:"
 247         + CatalogDbUtil.objectToString(data));
 248     return data;
 249   }
 250
 251   /**
 252    * query service template by package infomation.
 253    * @param packageInfo package information
 254    * @return ServiceTemplateData list
 255    * @throws CatalogResourceException e
 256    */
 257   public ArrayList<ServiceTemplateData> queryServiceTemplateByCsarPackageInfo(
 258       PackageData packageInfo) throws CatalogResourceException {
 259     LOGGER.info("start query serviceTemplate info by package.package:"
 260         + CatalogDbUtil.objectToString(packageInfo));
 261     String filter =
 262         HqlFactory.getQueryHqlByFilter(ServiceTemplateData.class, packageInfo,
 263             Parameters.csarId.name());
 264     ArrayList<ServiceTemplateData> data = handler.unionQuery(filter);
 265     LOGGER.info("query serviceTemplate info end.size:" + data.size() + "detail:"
 266         + CatalogDbUtil.objectToString(data));
 267     return data;
 268   }
 269
 270   /**
 271    * delete service template by id.
 272    * @param serviceTemplateId service template id
 273    * @throws CatalogResourceException e
 274    */
 275   public void deleteServiceTemplateById(String serviceTemplateId) throws CatalogResourceException {
 276     LOGGER.info("start delete serviceTemplate info.id:" + serviceTemplateId);
 277     ArrayList<NodeTemplateData> nodeTemplateList =
 278         queryNodeTemplateBySeriviceTemplateId(serviceTemplateId);
 279     templateHandler.delete(serviceTemplateId, nodeTemplateList);
 280     LOGGER.info(" delete serviceTemplate info end id." + serviceTemplateId);
 281   }
 282
 283   /**
 284    * delete service template by package info.
 285    * @param packageInfo package information
 286    * @throws CatalogResourceException e
 287    */
 288   public void deleteServiceTemplateByCsarPackageInfo(PackageData packageInfo)
 289       throws CatalogResourceException {
 290     LOGGER.info("start delete serviceTemplate info by package.package:"
 291         + CatalogDbUtil.objectToString(packageInfo));
 292
 293     ArrayList<ServiceTemplateData> serviceTemplate =
 294         queryServiceTemplateByCsarPackageInfo(packageInfo);
 295     for (int i = 0; i < serviceTemplate.size(); i++) {
 296       deleteServiceTemplateById(serviceTemplate.get(i).getServiceTemplateId());
 297     }
 298     LOGGER.info("delete serviceTemplate info end.");
 299
 300   }
 301 }