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

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