/*
 * QybgsqDomain.java
 * 版权所有 © 2011-2017 北京神舟良实信息技术有限公司
 * Copyright © 2011-2017 All Rights Reserved    京ICP备13013562号
 *  created by lipenghe with LAPTOP-IJQ2SDFV
 */
package com.unis.base.server.domain;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.unis.base.common.util.IdWorkerUtils;
import com.unis.base.common.vo.QybgsqVO;
import com.unis.base.server.dao.QybgsqDao;
import com.unis.base.server.entity.QybgsqDO;
import com.unis.common.utils.JsonUtils;
import com.unis.common.utils.LsBeanUtils;
import com.unis.common.utils.ResponseWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.session.ExecutorType;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.List;


/**
 * TY_QYBGSQ-企业变更申请表
 * DO处理自身, VO处理包括子表
 * @author lipenghe at 
 */
@Component
//Transactional注解加在service
//@Transactional
@Slf4j
public class QybgsqDomain {

    @Autowired
    QybgsqDao qybgsqDao;

    @Autowired
    IdWorkerUtils idWorkerUtils;

    @Autowired
    SqlSessionTemplate sqlSessionTemplate;

    /**
     * 通用的数据处理,只对VO参数接口有效,早于buildInsertData, buildUpdateData
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void buildData(QybgsqVO qybgsqVO){
        //QybgsqVO qybgsqVODb= selectById(qybgsqVO);
    }

    /**
     * 通用的插入处理,通用最晚执行
     * @param entity    <企业变更申请表>对象
     */
    private void buildInsertData(QybgsqDO entity){
        Long pk= null;
        //当前为主表
        pk= idWorkerUtils.nextId();
        entity.setSqid(String.valueOf(pk));
        entity.buildInsertData(String.valueOf(pk));
        entity.setVersion(0);
    }

    /**
     * 通用的插入处理,只对VO参数接口有效,晚于buildData
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void buildInsertData(QybgsqVO qybgsqVO){

    }

    /**
     * 通用的插入处理,只对VO参数接口有效,晚于buildInsertData
     * 专用于处理 VO 部分字段因安全等原因不能序列化为字符串的情况
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void buildInsertVoToDoData(QybgsqVO qybgsqVO, QybgsqDO entity){

    }

    /**
     * 通用的更新处理,通用最晚执行
     * @param entity    <企业变更申请表>对象
     */
    private void buildUpdateData(QybgsqDO entity){
        entity.buildUpdateData();
    }

    /**
     * 新增成功后,只对VO参数接口有效
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void insertSuccess(QybgsqVO qybgsqVO){

    }

    /**
     * 修改成功后,只对VO参数接口有效
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void updateSuccess(QybgsqVO qybgsqVO){

    }

    /**
     * 新增和修改成功后,只对VO参数接口有效,早于insertSuccess, updateSuccess
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private void saveSuccess(QybgsqVO qybgsqVO){

    }

    /**
     * 通用的返回数据处理,只对VO参数接口有效
     * @param qybgsqVO    <企业变更申请表>对象
     */
    private QybgsqVO buildResult(QybgsqVO qybgsqVO){
        QybgsqVO qybgsqVOResult= new QybgsqVO();
        qybgsqVOResult.setSqid(qybgsqVO.getSqid());
        return qybgsqVOResult;
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>非主键的业务唯一属性校验
     * @param qybgsqVO    <企业变更申请表>对象
     * @param check    是否进行非主键的唯一校验
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper uniqueCheck(QybgsqVO qybgsqVO, boolean check) {
        return ResponseWrapper.success();
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>插入校验
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper insertCheck(QybgsqVO qybgsqVO) {
        //数据校验
        boolean enable= true;
        if(enable){
            return ResponseWrapper.success();
        }else{
            return ResponseWrapper.fail("不允许新增");
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>修改校验
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper updateCheck(QybgsqVO qybgsqVO) {
        //数据校验
        boolean enable= true;
        /*List<QybgsqVO> qybgsqVOList= qybgsqDao.selectByEntity(qybgsqVO);
        for(QybgsqVO temp : qybgsqVOList){
            if(1== 1){
                //..................
                break;
            }
        }*/
        if(enable){
            return ResponseWrapper.success();
        }else{
            return ResponseWrapper.fail("存在不可更新的数据");
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>删除校验
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper deleteCheck(QybgsqVO qybgsqVO) {
        //数据校验
        boolean enable= true;
        /*List<QybgsqVO> qybgsqVOList= qybgsqDao.selectByEntity(qybgsqVO);
        for(QybgsqVO temp : qybgsqVOList){
            if(1== 1){
                //..................
                break;
            }
        }*/
        if(enable){
            return ResponseWrapper.success();
        }else{
            return ResponseWrapper.fail("存在不可删除的数据或无权限操作");
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>选择性保存,包含新增和修改
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper saveEntitySelective(QybgsqVO qybgsqVO) {
        if((StringUtils.isNotEmpty(qybgsqVO.getSqid()))){
            return updateByEntitySelective(qybgsqVO);
        }else{
            return insertEntitySelective(qybgsqVO, true);
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>插入全部字段
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int insertEntity(QybgsqDO entity) {
        buildInsertData(entity);
        return qybgsqDao.insert(entity);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>插入全部字段
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper insertEntity(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapperCheck = insertCheck(qybgsqVO);
        if(responseWrapperCheck.isSuccess()){
            ResponseWrapper responseWrapper= uniqueCheck(qybgsqVO, true);
            if(responseWrapper.isSuccess()){
                buildData(qybgsqVO);
                buildInsertData(qybgsqVO);

                //有属性操作则优先在vo处理
                QybgsqDO entity= LsBeanUtils.copyProperties(qybgsqVO, QybgsqDO.class);
                //处理不能序列化的字段
                buildInsertVoToDoData(qybgsqVO, entity);
                int num= insertEntity(entity);
                if(num> 0){
                    //新增成功后
                    saveSuccess(qybgsqVO);
                    insertSuccess(qybgsqVO);

                    //主键设置回去
                    qybgsqVO.setSqid(entity.getSqid());
                    return ResponseWrapper.success(buildResult(qybgsqVO));
                }
                return ResponseWrapper.fail();
            }else{
                return responseWrapper;
            }
        }else{
            return responseWrapperCheck;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>选择性插入字段
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int insertEntitySelective(QybgsqDO entity) {
        buildInsertData(entity);
        return qybgsqDao.insertSelective(entity);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>选择性插入字段
     * @param qybgsqVO    <企业变更申请表>对象
     * @param check    是否进行非主键的唯一校验
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper insertEntitySelective(QybgsqVO qybgsqVO, boolean check) {
        ResponseWrapper responseWrapperCheck = insertCheck(qybgsqVO);
        if(responseWrapperCheck.isSuccess()){
            ResponseWrapper responseWrapper= uniqueCheck(qybgsqVO, check);
            if(responseWrapper.isSuccess()){
                buildData(qybgsqVO);
                buildInsertData(qybgsqVO);

                //有属性操作则优先在vo处理
                QybgsqDO entity= LsBeanUtils.copyProperties(qybgsqVO, QybgsqDO.class);
                //处理不能序列化的字段
                buildInsertVoToDoData(qybgsqVO, entity);
                int num= insertEntitySelective(entity);
                if(num> 0){
                    //新增成功后
                    saveSuccess(qybgsqVO);
                    insertSuccess(qybgsqVO);

                    //主键设置回去
                    qybgsqVO.setSqid(entity.getSqid());
                    return ResponseWrapper.success(buildResult(qybgsqVO));
                }
                return ResponseWrapper.fail();
            }else{
                return responseWrapper;
            }
        }else{
            return responseWrapperCheck;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>批量插入全部字段
     * @param qybgsqVOList    <企业变更申请表>对象列表
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int insertBatchEntityList(List<QybgsqVO> qybgsqVOList) {
        int eachNum= 500;

        SqlSession sqlSession = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);

        QybgsqVO qybgsqVO= null;
        for(int i=0, size= qybgsqVOList.size(); i< size; i++){
            qybgsqVO= qybgsqVOList.get(i);
            insertEntitySelective(qybgsqVO, false);
            if(i % eachNum == 0 || i == size-1){
                //手动每eachNum条提交一次，提交后无法回滚
                sqlSession.commit();
                //清理缓存，防止溢出
                sqlSession.clearCache();
            }
        }
        return qybgsqVOList.size();

        /*
        for(QybgsqVO qybgsqVOTemp : qybgsqVOList){
            buildData(qybgsqVOTemp);
            buildInsertData(qybgsqVOTemp);
        }
        List<QybgsqDO> qybgsqDOList= JsonUtils.parseList(
            JsonUtils.serialize(qybgsqVOList), QybgsqDO.class);
        int num= 0;
        int max= qybgsqDOList.size();
        int step= Math.min(eachNum, max);
        for(int i= 0; i< max; i+= step){
            List<QybgsqDO> listEach= qybgsqDOList.subList(i, Math.min(i+step, max));
            num+= qybgsqDao.insertBatchEntityList(listEach);
        }
        return num;*/
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>更改状态
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int updateStatusByEntity(QybgsqDO entity) {
        buildUpdateData(entity);
        return qybgsqDao.updateStatusByEntity(entity);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>更改状态
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper updateStatusByEntity(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapperCheck = updateCheck(qybgsqVO);
        if(responseWrapperCheck.isSuccess()){
            ResponseWrapper responseWrapper= uniqueCheck(qybgsqVO, true);
            if(responseWrapper.isSuccess()){
                buildData(qybgsqVO);
                
                //有属性操作则优先在vo处理
                QybgsqDO entity= JsonUtils.parse(
                    JsonUtils.serialize(qybgsqVO), QybgsqDO.class);
                int num= updateStatusByEntity(entity);
                if(num> 0){
                    //修改成功后
                    saveSuccess(qybgsqVO);
                    updateSuccess(qybgsqVO);

                    //主键设置回去(此处实际不需要)
                    qybgsqVO.setSqid(entity.getSqid());
                    return ResponseWrapper.success(buildResult(qybgsqVO));
                }else{
                    return ResponseWrapper.fail();
                }
            }else{
                return responseWrapper;
            }
        }else{
            return responseWrapperCheck;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体批量更新全部字段
     * @param list    <企业变更申请表>对象列表
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int updateBatchByEntityList(List<QybgsqDO> list) {
        for(QybgsqDO temp : list){
            buildUpdateData(temp);
        }
        return qybgsqDao.updateBatchByEntityList(list);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体某些属性更新全部字段
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int updateByEntity(QybgsqDO entity) {
        buildUpdateData(entity);
        return qybgsqDao.updateByEntity(entity);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体某些属性更新全部字段
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper updateByEntity(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapperCheck = updateCheck(qybgsqVO);
        if(responseWrapperCheck.isSuccess()){
            ResponseWrapper responseWrapper= uniqueCheck(qybgsqVO, true);
            if(responseWrapper.isSuccess()){
                buildData(qybgsqVO);
                //有属性操作则优先在vo处理
                QybgsqDO entity= JsonUtils.parse(
                    JsonUtils.serialize(qybgsqVO), QybgsqDO.class);
                int num= updateByEntity(entity);
                if(num> 0){
                    //修改成功后
                    saveSuccess(qybgsqVO);
                    updateSuccess(qybgsqVO);

                    //主键设置回去(此处实际不需要)
                    qybgsqVO.setSqid(entity.getSqid());
                    return ResponseWrapper.success(buildResult(qybgsqVO));
                }
                return ResponseWrapper.fail();
            }else{
                return responseWrapper;
            }
        }else{
            return responseWrapperCheck;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体不为空的属性,选择性更新字段
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int updateByEntitySelective(QybgsqDO entity) {
        buildUpdateData(entity);
        return qybgsqDao.updateByEntitySelective(entity);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体不为空的属性,选择性更新字段(存在则更新,不存在则插入,其余删除)
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper updateByEntitySelective(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapperCheck = updateCheck(qybgsqVO);
        if(responseWrapperCheck.isSuccess()){
            ResponseWrapper responseWrapper= uniqueCheck(qybgsqVO, true);
            if(responseWrapper.isSuccess()){
                buildData(qybgsqVO);
                //此处是直接更新,较为繁琐,适用于子表数据有关联(被其他数据使用),缺少排序在字段会出现顺序与修改数据的顺序不一致的问题,
                //有属性操作则优先在vo处理
                QybgsqDO entity= JsonUtils.parse(
                    JsonUtils.serialize(qybgsqVO), QybgsqDO.class);
                int num= updateByEntitySelective(entity);
                if(num> 0){
                    //修改成功后
                    saveSuccess(qybgsqVO);
                    updateSuccess(qybgsqVO);

                    //主键设置回去(此处实际不需要)
                    qybgsqVO.setSqid(entity.getSqid());
                    return ResponseWrapper.success(buildResult(qybgsqVO));
                }
                return ResponseWrapper.fail();
            }else{
                return responseWrapper;
            }
        }else{
            return responseWrapperCheck;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>[真删除]根据实体的某些属性进行单条或者批量删除
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper deleteByEntity(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapper = deleteCheck(qybgsqVO);
        if(responseWrapper.isSuccess()){
            int num= qybgsqDao.deleteByEntity(qybgsqVO);
            return ResponseWrapper.choose(num);
        }else{
            return responseWrapper;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>[真删除]根据实体的某些属性进行单条或者批量删除
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int deleteByEntity(QybgsqDO entity) {
        QybgsqVO qybgsqVO= JsonUtils.parse(
            JsonUtils.serialize(entity), QybgsqVO.class);
        return qybgsqDao.deleteByEntity(qybgsqVO);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>[假删除]根据实体的某些属性进行单条或者批量删除,根据实体属性单条或批量删除只是改变了状态不在页面显示,数据仍存在
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public ResponseWrapper deleteShamByEntity(QybgsqVO qybgsqVO) {
        ResponseWrapper responseWrapper = deleteCheck(qybgsqVO);
        if(responseWrapper.isSuccess()){
            //自行在controller设置状态,则可删除,亦可还原
            int num= qybgsqDao.deleteShamByEntity(qybgsqVO);
            return ResponseWrapper.choose(num);
        }else{
            return responseWrapper;
        }
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>[假删除]根据实体的某些属性进行单条或者批量删除,根据实体属性单条或批量删除只是改变了状态不在页面显示,数据仍存在
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int deleteShamByEntity(QybgsqDO entity) {
        QybgsqVO qybgsqVO= JsonUtils.parse(
            JsonUtils.serialize(entity), QybgsqVO.class);
        return qybgsqDao.deleteShamByEntity(qybgsqVO);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的某些属性查询数量
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int selectCountByEntity(QybgsqVO qybgsqVO) {
        int num= qybgsqDao.selectCountByEntity(qybgsqVO);
        return num;
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的唯一属性查询数量
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int selectCountById(QybgsqVO qybgsqVO) {
        int num= qybgsqDao.selectCountById(qybgsqVO);
        return num;
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的业务唯一属性(且非指定主键数据)判断是否存在
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public int selectExistsByEntity(QybgsqVO qybgsqVO) {
        int num= qybgsqDao.selectExistsByEntity(qybgsqVO);
        return num;
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体(唯一标示)查询一条数据
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public QybgsqVO selectById(QybgsqVO qybgsqVO) {
        QybgsqVO qybgsqVODb= qybgsqDao.selectById(qybgsqVO);
        return qybgsqVODb;
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体(唯一标示)查询一条数据
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public QybgsqVO selectById(QybgsqDO entity) {
        QybgsqVO qybgsqVO= JsonUtils.parse(
            JsonUtils.serialize(entity), QybgsqVO.class);
        return qybgsqDao.selectById(qybgsqVO);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的某些属性查询分页数据
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public Page<QybgsqVO> selectPageByEntity(int pageNo, int pageSize
        , QybgsqVO qybgsqVO, String order) {
        PageHelper.startPage(pageNo, pageSize, order);
        return qybgsqDao.selectPageByEntity(qybgsqVO);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的某些属性查询列表
     * @param qybgsqVO    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public List<QybgsqVO> selectByEntity(QybgsqVO qybgsqVO) {
        return qybgsqDao.selectByEntity(qybgsqVO);
    }

    /**
     * <TY_QYBGSQ-企业变更申请表>根据实体的某些属性查询列表
     * @param entity    <企业变更申请表>对象
     * @author lipenghe with LAPTOP-IJQ2SDFV
     */
    public List<QybgsqVO> selectByEntity(QybgsqDO entity) {
        QybgsqVO qybgsqVO= JsonUtils.parse(
            JsonUtils.serialize(entity), QybgsqVO.class);
        return qybgsqDao.selectByEntity(qybgsqVO);
    }

}
