OperationLogServiceImpl.java

package pwc.taxtech.atms.service.impl;

import com.google.common.collect.Lists;
import org.apache.ibatis.session.RowBounds;
import org.nutz.lang.Lang;
import org.nutz.lang.Strings;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import pwc.taxtech.atms.common.AuthUserHelper;
import pwc.taxtech.atms.common.CommonConstants;
import pwc.taxtech.atms.common.CommonUtils;
import pwc.taxtech.atms.common.OperateLogType;
import pwc.taxtech.atms.common.OperationAction;
import pwc.taxtech.atms.common.OperationModule;
import pwc.taxtech.atms.constant.EnterpriseAccountConstant;
import pwc.taxtech.atms.constant.OrganizationConstant;
import pwc.taxtech.atms.constant.UserConstant;
import pwc.taxtech.atms.dao.OperationLogBasicDataMapper;
import pwc.taxtech.atms.dpo.PagingDto;
import pwc.taxtech.atms.dto.OperationLogDto;
import pwc.taxtech.atms.dto.PagingResultDto;
import pwc.taxtech.atms.dto.QueryOperateParamDto;
import pwc.taxtech.atms.dto.UpdateLogParams;
import pwc.taxtech.atms.entity.*;
import pwc.taxtech.atms.entity.OperationLogBasicDataExample.Criteria;
import pwc.taxtech.atms.exception.ApplicationException;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 */
@Service
public class OperationLogServiceImpl extends AbstractService {
    private static final Logger logger = LoggerFactory.getLogger(OperationLogServiceImpl.class);
    @Autowired
    private OperationLogBasicDataMapper operationLogBasicDataMapper;

    @Autowired
    private AuthUserHelper authUserHelper;

    public void addOperationLog(OperationLogDto operationLogDto) {
        OperationLogSmart record = new OperationLogSmart();
        Integer logtype = operationLogDto.getLogType();
        Assert.notNull(logtype, "Null logType");
        String table = OperateLogType.getTableName(logtype);
        Assert.hasText(table, "Empty tableName");
        record.setTableName(table);
        // 股权变更记录不生成新id和创建时间
        if(operationLogDto.isEquityLog()){
            record.setId(operationLogDto.getId());
            record.setCreateTime(operationLogDto.getCreateTime());
        }else{
            record.setId(CommonUtils.getUUID());
            record.setCreateTime(new Date());
        }
        record.setIp(authUserHelper.getClientIp());
        record.setOperationUser(authUserHelper.getCurrentAuditor().get());

        record.setOperationContent(operationLogDto.getOperationContent());
        Assert.notNull(operationLogDto.getModule(), "Null module");
        String operationModuleString = OperationModule.getName(operationLogDto.getModule());
        Assert.hasText(operationModuleString, "Wrong int value for OperationModule: " + operationLogDto.getModule());
        record.setModuleName(operationModuleString);
        record.setOperationObject(operationLogDto.getOperationObject());
        record.setOperationAction(OperationAction.getName(operationLogDto.getAction()));
        record.setOriginalState(operationLogDto.getOriginalState());
        record.setUpdateState(operationLogDto.getUpdateState());
        record.setComment(operationLogDto.getComment());
        if (Strings.isNotBlank(record.getOperationObject()) && record.getOperationObject().length() > 100) {
            record.setOperationObject(record.getOperationObject().substring(0, 100));
        }
        if (Strings.isNotBlank(record.getOperationContent()) && record.getOperationContent().length() > 1000) {
            record.setOperationContent(record.getOperationContent().substring(0, 1000));
        }
        if (Strings.isNotBlank(record.getOperationAction()) && record.getOperationAction().length() > 100) {
            record.setOperationAction(record.getOperationAction().substring(0, 100));
        }
        if (Strings.isNotBlank(record.getModuleName()) && record.getModuleName().length() > 1000) {
            record.setModuleName(record.getModuleName().substring(0, 100));
        }
        if (Strings.isNotBlank(record.getOperationUser()) && record.getOperationUser().length() > 100) {
            record.setOperationUser(record.getOperationUser().substring(0, 100));
        }
        operationLogBasicDataMapper.insertSmart(record);
    }

    public void addOperationLogList(List<OperationLogDto> operationLogDtoList) {
        logger.debug("OperationLogService addOperationLogList");
        if (!operationLogDtoList.isEmpty()) {
            for (OperationLogDto operationLogDto : operationLogDtoList) {
                addOperationLog(operationLogDto);
            }
        }
    }

    public PagingResultDto<OperationLogDto> getOperationLogList(QueryOperateParamDto queryOperateParamDto) {
        logger.debug("OperationLogService getOperationLogList");
        // validate
       // Assert.hasText(queryOperateParamDto.getModuleName(), "Empty moduleName");

        final PagingDto pageInfo = queryOperateParamDto.getPageInfo();

        final PagingResultDto<OperationLogDto> pagingResultDto = new PagingResultDto<>();
        pagingResultDto.setList(new ArrayList<>());
        // build the smart example
        final OperationLogSmartExample example = buildExample(queryOperateParamDto);

        // 查找总记录数
        final int totalCount = (int) operationLogBasicDataMapper.countByExampleSmart(example);

        final PagingDto outputPageInfo = new PagingDto();
        outputPageInfo.setPageIndex(pageInfo.getPageIndex());
        outputPageInfo.setPageSize(pageInfo.getPageSize());
        outputPageInfo.setTotalCount(totalCount);
        pagingResultDto.setPageInfo(outputPageInfo);

        if (totalCount > 0) {
            final RowBounds rowBounds = buildRowBounds(pageInfo);
            List<OperationLogBasicData> operationLogBasicDataList = operationLogBasicDataMapper
                    .selectByExampleWithRowboundsSmart(example, rowBounds);
            Assert.notNull(operationLogBasicDataList, "Null list");
            List<OperationLogDto> operationLogDtoList = new ArrayList<>();
            for (OperationLogBasicData operationLogBasicData : operationLogBasicDataList) {
                OperationLogDto operationLogDto = toOperationLogDto(operationLogBasicData);
                operationLogDtoList.add(operationLogDto);
            }
            pagingResultDto.setList(operationLogDtoList);
        }

        return pagingResultDto;
    }

    private OperationLogDto toOperationLogDto(OperationLogBasicData operationLogBasicData) {
        OperationLogDto operationLogDto = new OperationLogDto();
        operationLogDto.setId(operationLogBasicData.getId());
        operationLogDto.setCreateTime(operationLogBasicData.getCreateTime());
        operationLogDto.setOperationObject(operationLogBasicData.getOperationObject());
        operationLogDto.setOperationContent(operationLogBasicData.getOperationContent());
        operationLogDto.setOriginalState(operationLogBasicData.getOriginalState());
        operationLogDto.setUpdateState(operationLogBasicData.getUpdateState());
        operationLogDto.setOperationUser(operationLogBasicData.getOperationUser());
        operationLogDto.setComment(operationLogBasicData.getComment());
        operationLogDto.setIp(operationLogBasicData.getIp());
        // 参考C#代码，logtype为null，所以这里填零
        operationLogDto.setLogType(0);
        try {
            OperationAction actionEnum = OperationAction.valueOf(operationLogBasicData.getOperationAction());
            if (actionEnum != null) {
                operationLogDto.setAction(actionEnum.value());
            }
        } catch (Exception e) {
            logger.warn("Data error: not found the OperationAction by database value:"
                    + operationLogBasicData.getOperationAction());
            operationLogDto.setAction(0);
        }
        try {
            OperationModule moduleEnum = OperationModule.valueOf(operationLogBasicData.getModuleName());
            if (moduleEnum != null) {
                operationLogDto.setModule(moduleEnum.value());
            }
        } catch (Exception e) {
            logger.warn("Data error: not found the OperationModule by database value:"
                    + operationLogBasicData.getModuleName());
            // not found the OperationModule
            operationLogDto.setModule(0);
        }
        return operationLogDto;
    }

    private OperationLogSmartExample buildExample(QueryOperateParamDto queryOperateParamDto) {
        OperationLogSmartExample example = new OperationLogSmartExample();
        Integer logtype = queryOperateParamDto.getLogType();
        Assert.notNull(logtype, "Null logType");
        String tableName = OperateLogType.getTableName(logtype);
        example.setTableName(tableName);
        example.setOrderByClause("create_time desc");
        String searchText = queryOperateParamDto.getSearchText();
        if (StringUtils.hasText(searchText)) {
            // todo 多个模糊查询的慢sql，可确认需求进行拆分
            String sqlValue = "%" + searchText + "%";
            Criteria criteria1 = example.createCriteria();
            criteria1.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            criteria1.andCommentLike(sqlValue);
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria1.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }

            Criteria criteria2 = example.createCriteria();
            criteria2.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            criteria2.andOperationObjectLike(sqlValue);
            example.or(criteria2);
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria2.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }

            Criteria criteria3 = example.createCriteria();
            criteria3.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            criteria3.andOperationUserLike(sqlValue);
            example.or(criteria3);
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria3.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }

            Criteria criteria4 = example.createCriteria();
            criteria4.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            criteria4.andUpdateStateLike(sqlValue);
            example.or(criteria4);
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria4.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }

            Criteria criteria5 = example.createCriteria();
            criteria5.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            criteria5.andOriginalStateLike(sqlValue);
            example.or(criteria5);
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria5.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }
        } else {
            Criteria criteria = example.createCriteria();
            criteria.andModuleNameEqualTo(queryOperateParamDto.getModuleName());
            if (!Lang.isEmpty(queryOperateParamDto.getFilterOperationObjectList())) {
                criteria.andOperationObjectIn(queryOperateParamDto.getFilterOperationObjectList());
            }
        }

        // @see below C# codes:
        // o.Comment.Contains(paras.SearchText) ||
        // o.OperationObject.Contains(paras.SearchText) ||
        // o.OperationUser.Contains(paras.SearchText) ||
        // o.UpdateState.Contains(paras.SearchText) ||
        // o.OriginalState.Contains(paras.SearchText))
        return example;
    }

    private RowBounds buildRowBounds(PagingDto pageInfo) {
        Assert.notNull(pageInfo, "Null pageInfo");
        Assert.notNull(pageInfo.getPageIndex(), "Null pageInfo.pageIndex");
        Assert.notNull(pageInfo.getPageSize(), "Null pageInfo.pagesize");
        int offset = Math.max(0, pageInfo.getPageSize() * (pageInfo.getPageIndex() - 1));
        int limit = pageInfo.getPageSize();
        return new RowBounds(offset, limit);
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * pwc.taxtech.atms.service.OperationLogService#updateDataAddLog(java.util.List)
     */
    public void updateDataAddLog(List<UpdateLogParams> updateLogParamsList) {

        for (UpdateLogParams updateLogParams : updateLogParamsList) {
            updateDataAddLog(updateLogParams);
        }

    }

    // check how many properties being updated and the log number should be same
    public void updateDataAddLog(UpdateLogParams updateLogParams) {
        logger.debug("OperationLogService updateDataAddLog, parameter: {}", updateLogParams);
        if (updateLogParams != null && updateLogParams.getOriginalState() != null
                && updateLogParams.getUpdateState() != null) {
            Object originObject = updateLogParams.getOriginalState();
            Object updateObject = updateLogParams.getUpdateState();
            // logger.debug("origin object: {}", JSON.toJSONString(originObject, true));
            // logger.debug("update object: {}", JSON.toJSONString(updateObject, true));
            Class<?> cls = originObject.getClass();
            Field[] fileds = cls.getDeclaredFields();
            if (fileds != null && fileds.length > 0) {
                for (Field field : fileds) {
                    field.setAccessible(true);
                    // skip create time, update time and serialVersionUId
                    if (CommonConstants.CREATETIME.equalsIgnoreCase(field.getName())
                            || CommonConstants.UPDATETIME.equalsIgnoreCase(field.getName())
                            || CommonConstants.SERIALVERSIONUId.equalsIgnoreCase(field.getName())) {
                        continue;
                    }

                    try {
                        Object originValue = field.get(originObject);
                        String originalState = getValue(field.getName(), originValue, cls);
                        Object updateValue = field.get(updateObject);
                        String updateState = getValue(field.getName(), updateValue, cls);

                        if (!Objects.equals(originalState, updateState)) {
                            logger.debug("value is updated for field: {}, origin value: {}, updated value: {}",
                                    field.getName(), originValue, updateValue);
                            OperationLogDto operationLogDto = new OperationLogDto();
                            operationLogDto.setOperationObject(updateLogParams.getOperationObject());
                            operationLogDto.setOperationContent(Strings.upperFirst(field.getName()));
                            operationLogDto.setOriginalState(originalState);
                            operationLogDto.setUpdateState(updateState);
                            operationLogDto.setModule(updateLogParams.getOperationModule());
                            operationLogDto.setComment(updateLogParams.getComment());
                            operationLogDto.setLogType(updateLogParams.getOperateLogType());
                            operationLogDto.setAction(updateLogParams.getOperationAction());
                            addOperationLog(operationLogDto);
                        }
                    } catch (IllegalArgumentException | IllegalAccessException e) {
                        throw new ApplicationException(
                                "exception happened during comparing object properties, Object name: " + cls.getName()
                                        + " exception: " + e.getMessage());
                    }
                }
            }
        }
    }

    private String getValue(String fieldName, Object fieldValue, Class objClass) {
        String value = fieldValue == null ? "" : toDotNetStyleString(fieldValue);
        try {
            if (objClass.equals(EnterpriseAccount.class)) {
                if (EnterpriseAccountConstant.DirectionField.equalsIgnoreCase(fieldName)) {
                    value = EnterpriseAccountConstant.DirectionMap.get(value);
                    return value;
                }
                if (EnterpriseAccountConstant.IgnoreFieldList.stream().anyMatch(s -> fieldName.equalsIgnoreCase(s))) {
                    return "";
                }
                if (EnterpriseAccountConstant.AcctPropField.equalsIgnoreCase(fieldName)) {
                    int temp = Integer.parseInt(value);
                    if (temp < EnterpriseAccountConstant.acctPropLogList.size()) {
                        return EnterpriseAccountConstant.acctPropLogList.get(temp - 1);
                    }
                }
            } else if (objClass.equals(Organization.class)) {
                return getOrganizationSpecialName(fieldName, value);
            } else if (objClass.equals(User.class)) {
                return getUserSpecialName(fieldName, value);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return value;
    }

    private String getOrganizationSpecialName(String fieldName, String value) {
        if (OrganizationConstant.IgnoreFieldList.stream().anyMatch(sa -> fieldName.equalsIgnoreCase(sa))) {
            return null;
        }
        if (OrganizationConstant.ParentIdField.equalsIgnoreCase(fieldName)) {
            Organization temp = organizationMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (OrganizationConstant.RegionIdField.equalsIgnoreCase(fieldName)) {
            Region temp = regionMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (OrganizationConstant.StructureIdField.equalsIgnoreCase(fieldName)) {
            OrganizationStructure temp = organizationStructureMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (OrganizationConstant.BusinessUnitIdField.equalsIgnoreCase(fieldName)) {
            BusinessUnit temp = businessUnitMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (OrganizationConstant.IndustryIdField.equalsIgnoreCase(fieldName)) {
            Industry temp = industryMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (OrganizationConstant.AreaIdField.equalsIgnoreCase(fieldName)) {
            Area temp = areaMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        }
        return value;
    }

    private String getUserSpecialName(String fieldName, String value) {
        if (UserConstant.OrganizationIdField.equalsIgnoreCase(fieldName)) {
            Organization temp = organizationMapper.selectByPrimaryKey(value);
            if (temp != null) {
                return temp.getName();
            }
        } else if (UserConstant.IsAdminField.equalsIgnoreCase(fieldName)) {
        }
        return value;
    }

    /*
     * (non-Javadoc)
     *
     * @see
     * pwc.taxtech.atms.service.OperationLogService#addOrDeleteDataAddLog(java.util.
     * List)
     */
    public void addOrDeleteDataAddLog(List<UpdateLogParams> updateLogParamsList) {

        for (UpdateLogParams updateLogParams : updateLogParamsList) {
            addOrDeleteDataAddLog(updateLogParams);
        }
    }

    /*
     * (non-Javadoc)
     *
     * @see pwc.taxtech.atms.service.OperationLogService#addOrDeleteDataAddLog(pwc.
     * taxtech.atms.service.dto.UpdateLogParams)
     */
    public void addOrDeleteDataAddLog(UpdateLogParams updateLogParams) {

        logger.debug("OperationLogService addOrDeleteDataAddLog, parameter: {}", updateLogParams);

        OperationLogDto operationLogDto = new OperationLogDto();
        CommonUtils.copyProperties(updateLogParams, operationLogDto);
        operationLogDto.setModule(updateLogParams.getOperationModule());
        operationLogDto.setLogType(updateLogParams.getOperateLogType());
        operationLogDto.setAction(updateLogParams.getOperationAction());
        addOperationLog(operationLogDto);
    }

    private String toDotNetStyleString(Object inputObject) {
        if (inputObject == null) {
            return "";
        }
        boolean upcaseFirstFlag = false;
        if (inputObject instanceof Boolean) {
            upcaseFirstFlag = true;
        }
        String result = inputObject.toString();
        return upcaseFirstFlag ? Strings.upperFirst(result) : result;
    }

    public void addDataAddLog(Object newObj, OperationModule operationModule, String userName, String operationDesc,
                              String operationContent, String OperationObject, OperateLogType logType) {
        OperationLogDto addLog = new OperationLogDto();

        addLog.setId(CommonUtils.getUUID());
        addLog.setOperationContent(operationContent);
        addLog.setOperationObject(OperationObject);
        addLog.setOriginalState("");
        addLog.setUpdateState("");
        addLog.setOperationUser(userName);
        addLog.setIp(authUserHelper.getClientIp());
        addLog.setModule(operationModule.value());
        addLog.setComment(operationDesc);
        addLog.setAction(OperationAction.New.value());
        addLog.setLogType(logType.value());

        this.addOperationLog(addLog);
    }

    public void updateDataAddLog(Object originalObj, Object updateObj, OperationModule operationModule, String userName,
                                 String comment, String operationObject, String operationContent, OperateLogType logType) {
        UpdateLogParams params = new UpdateLogParams();
        params.setOriginalState(originalObj);
        params.setOperationContent(operationContent);
        params.setOperationObject(operationObject);
        params.setUpdateState(updateObj);
        params.setOperationModule(operationModule.value());
        params.setOperationUser(userName);
        params.setComment(comment);
        params.setOperationAction(OperationAction.Update.value());
        params.setOperateLogType(logType.value());
        this.updateDataAddLog(params);
    }

    public void deleteDataAddLog(Object deleteObj, OperationModule operationModule, String userName, String comment,
                                 String operationContent, String OperationObject, OperateLogType logType) {
        OperationLogDto addLog = new OperationLogDto();
        addLog.setId(CommonUtils.getUUID());
        addLog.setOperationContent(operationContent);
        addLog.setOperationObject(OperationObject);
        addLog.setOriginalState("");
        addLog.setUpdateState("");
        addLog.setOperationUser(userName);
        addLog.setIp(authUserHelper.getClientIp());
        addLog.setModule(operationModule.value());
        addLog.setComment(comment);
        addLog.setAction(OperationAction.New.value());
        addLog.setLogType(logType.value());
        this.addOperationLog(addLog);
    }

    /**
     * 18/01/2019 14:15
     * 根据机构名称获取股权变更记录
     * [orgName]
     * @author Gary J Li
     * @return
     */
    public List<OperationLogBasicData> getEquityChangeLogByOrgName(String orgName) {
        OperationLogBasicDataExample example = new OperationLogBasicDataExample();
        List<String> opeActions = Lists.newArrayList();
        opeActions.add(OperationAction.ChangeEquity.name());
        opeActions.add(OperationAction.NewEquity.name());
        example.createCriteria().andOperationObjectEqualTo(orgName).andOperationActionIn(opeActions);
        example.setOrderByClause("create_time desc");
        return operationLogBasicDataMapper.selectEquityLogByExample(example);
    }

    public int deleteById(Long id) {
        OperationLogBasicDataExample example = new OperationLogBasicDataExample();
        example.createCriteria().andIdEqualTo(String.valueOf(id));
        return operationLogBasicDataMapper.deleteEquityLogByExample(example);
    }
}