content: /*
   * Copyright (C) 2010-2101 Alibaba Group Holding Limited.
   *
   * 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 com.alibaba.otter.manager.biz.config.datamatrix.impl;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.springframework.transaction.TransactionStatus;
  import org.springframework.transaction.support.TransactionCallbackWithoutResult;
  import org.springframework.transaction.support.TransactionTemplate;
  
  import com.alibaba.otter.shared.common.utils.Assert;
  import com.alibaba.otter.manager.biz.common.exceptions.ManagerException;
  import com.alibaba.otter.manager.biz.common.exceptions.RepeatConfigureException;
  import com.alibaba.otter.manager.biz.config.datamatrix.DataMatrixService;
  import com.alibaba.otter.manager.biz.config.datamatrix.dal.DataMatrixDAO;
  import com.alibaba.otter.manager.biz.config.datamatrix.dal.dataobject.DataMatrixDO;
  import com.alibaba.otter.manager.biz.config.node.impl.NodeServiceImpl;
  import com.alibaba.otter.shared.common.model.config.data.DataMatrix;
  import com.alibaba.otter.shared.common.utils.JsonUtils;
  
  public class DataMatrixServiceImpl implements DataMatrixService {
  
      private static final Logger logger = LoggerFactory.getLogger(NodeServiceImpl.class);
  
      private DataMatrixDAO       dataMatrixDao;
      private TransactionTemplate transactionTemplate;
  
      /**
       * 添加
       */
      public void create(final DataMatrix matrix) {
          Assert.assertNotNull(matrix);
          transactionTemplate.execute(new TransactionCallbackWithoutResult() {
  
              protected void doInTransactionWithoutResult(TransactionStatus status) {
  
                  try {
                      DataMatrixDO matrixlDO = modelToDo(matrix);
                      matrixlDO.setId(0L);
                      if (!dataMatrixDao.checkUnique(matrixlDO)) {
                          String exceptionCause = "exist the same repeat canal in the database.";
                          logger.warn("WARN ## " + exceptionCause);
                          throw new RepeatConfigureException(exceptionCause);
                      }
                      dataMatrixDao.insert(matrixlDO);
                  } catch (RepeatConfigureException rce) {
                      throw rce;
                  } catch (Exception e) {
                      logger.error("ERROR ## create canal has an exception!");
                      throw new ManagerException(e);
                  }
              }
          });
      }
  
      /**
       * 删除
       */
      public void remove(final Long matrixId) {
          Assert.assertNotNull(matrixId);
          transactionTemplate.execute(new TransactionCallbackWithoutResult() {
  
              protected void doInTransactionWithoutResult(TransactionStatus status) {
  
                  try {
                      dataMatrixDao.delete(matrixId);
                  } catch (Exception e) {
                      logger.error("ERROR ## remove canal(" + matrixId + ") has an exception!");
                      throw new ManagerException(e);
                  }
              }
          });
  
      }
  
      /**
       * 修改
       */
      public void modify(final DataMatrix matrix) {
          Assert.assertNotNull(matrix);
          transactionTemplate.execute(new TransactionCallbackWithoutResult() {
  
              protected void doInTransactionWithoutResult(TransactionStatus status) {
  
                  try {
                      DataMatrixDO matrixDo = modelToDo(matrix);
                      if (dataMatrixDao.checkUnique(matrixDo)) {
                          dataMatrixDao.update(matrixDo);
                      } else {
                          String exceptionCause = "exist the same repeat matrix in the database.";
                          logger.warn("WARN ## " + exceptionCause);
                          throw new RepeatConfigureException(exceptionCause);
                      }
                  } catch (RepeatConfigureException rce) {
                      throw rce;
                  } catch (Exception e) {
                      logger.error("ERROR ## modify canal(" + matrix.getId() + ") has an exception!");
                      throw new ManagerException(e);
                  }
              }
          });
  
      }
  
      public List<DataMatrix> listByIds(Long... identities) {
          List<DataMatrix> matrixs = new ArrayList<DataMatrix>();
          try {
              List<DataMatrixDO> matrixDos = null;
              if (identities.length < 1) {
                  matrixDos = dataMatrixDao.listAll();
                  if (matrixDos.isEmpty()) {
                      logger.debug("DEBUG ## couldn't query any canal, maybe hasn't create any canal.");
                      return matrixs;
                  }
              } else {
                  matrixDos = dataMatrixDao.listByMultiId(identities);
                  if (matrixDos.isEmpty()) {
                      String exceptionCause = "couldn't query any canal by matrixIds:" + Arrays.toString(identities);
                      logger.error("ERROR ## " + exceptionCause);
                      throw new ManagerException(exceptionCause);
                  }
              }
              matrixs = doToModel(matrixDos);
          } catch (Exception e) {
              logger.error("ERROR ## query channels has an exception!");
              throw new ManagerException(e);
          }
  
          return matrixs;
      }
  
      public List<DataMatrix> listAll() {
          return listByIds();
      }
  
      public DataMatrix findById(Long matrixId) {
          Assert.assertNotNull(matrixId);
          List<DataMatrix> canals = listByIds(matrixId);
          if (canals.size() != 1) {
              String exceptionCause = "query matrixId:" + matrixId + " return null.";
              logger.error("ERROR ## " + exceptionCause);
              throw new ManagerException(exceptionCause);
          }
  
          return canals.get(0);
      }
  
      public DataMatrix findByGroupKey(String groupKey) {
          Assert.assertNotNull(groupKey);
          DataMatrixDO matrixDo = dataMatrixDao.findByGroupKey(groupKey);
          if (matrixDo == null) {
              String exceptionCause = "query name:" + groupKey + " return null.";
              logger.error("ERROR ## " + exceptionCause);
              throw new ManagerException(exceptionCause);
          }
  
          return doToModel(matrixDo);
      }
  
      @Override
      public int getCount(Map condition) {
          return dataMatrixDao.getCount(condition);
      }
  
      @Override
      public List<DataMatrix> listByCondition(Map condition) {
          List<DataMatrixDO> matrixDos = dataMatrixDao.listByCondition(condition);
          if (matrixDos.isEmpty()) {
              logger.debug("DEBUG ## couldn't query any canal by the condition:" + JsonUtils.marshalToString(condition));
              return new ArrayList<DataMatrix>();
          }
  
          return doToModel(matrixDos);
      }
  
      /**
       * 用于Model对象转化为DO对象
       */
      private DataMatrixDO modelToDo(DataMatrix matrix) {
          DataMatrixDO matrixDo = new DataMatrixDO();
          try {
              matrixDo.setId(matrix.getId());
              matrixDo.setGroupKey(matrix.getGroupKey());
              matrixDo.setDescription(matrix.getDescription());
              matrixDo.setMaster(matrix.getMaster());
              matrixDo.setSlave(matrix.getSlave());
              matrixDo.setGmtCreate(matrix.getGmtCreate());
              matrixDo.setGmtModified(matrix.getGmtModified());
          } catch (Exception e) {
              logger.error("ERROR ## change the matrix Model to Do has an exception");
              throw new ManagerException(e);
          }
          return matrixDo;
      }
  
      /**
       * 用于DO对象转化为Model对象
       */
      private DataMatrix doToModel(DataMatrixDO matrixDo) {
          DataMatrix matrix = new DataMatrix();
          try {
              matrix.setId(matrixDo.getId());
              matrix.setGroupKey(matrixDo.getGroupKey());
              matrix.setDescription(matrixDo.getDescription());
              matrix.setMaster(matrixDo.getMaster());
              matrix.setSlave(matrixDo.getSlave());
              matrix.setGmtCreate(matrixDo.getGmtCreate());
              matrix.setGmtModified(matrixDo.getGmtModified());
          } catch (Exception e) {
              logger.error("ERROR ## change the canal Do to Model has an exception");
              throw new ManagerException(e);
          }
  
          return matrix;
      }
  
      private List<DataMatrix> doToModel(List<DataMatrixDO> matrixDos) {
          List<DataMatrix> matrixs = new ArrayList<DataMatrix>();
          for (DataMatrixDO matrixDo : matrixDos) {
              matrixs.add(doToModel(matrixDo));
          }
          return matrixs;
      }
  
      /* ------------------------setter / getter--------------------------- */
  
      public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
          this.transactionTemplate = transactionTemplate;
      }
  
      public void setDataMatrixDao(DataMatrixDAO dataMatrixDao) {
          this.dataMatrixDao = dataMatrixDao;
      }
  
  }
  