OrganizationHKServiceImpl.java

package pwc.taxtech.atms.service.impl;

import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.BooleanUtils;
import org.nutz.lang.Files;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.dao.DuplicateKeyException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.util.Assert;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import pwc.taxtech.atms.common.*;
import pwc.taxtech.atms.common.message.LogMessage;
import pwc.taxtech.atms.common.message.OrganizationMessage;
import pwc.taxtech.atms.common.util.FileExcelUtil;
import pwc.taxtech.atms.dto.OperationLogDto;
import pwc.taxtech.atms.dto.OperationResultDto;
import pwc.taxtech.atms.dto.UpdateLogParams;
import pwc.taxtech.atms.dto.navtree.NavTreeDto;
import pwc.taxtech.atms.entity.ServiceType;
import pwc.taxtech.atms.exception.ApplicationException;
import pwc.taxtech.atms.organization.dao.OrganizationAttachmentMapper;
import pwc.taxtech.atms.organization.dao.OrganizationDirectorMapper;
import pwc.taxtech.atms.organization.dao.OrganizationHKMapper;
import pwc.taxtech.atms.organization.dao.OrganizationShareholderMapper;
import pwc.taxtech.atms.organization.dao.extension.OrganizationShareholderExtMapper;
import pwc.taxtech.atms.organization.dpo.*;
import pwc.taxtech.atms.organization.entity.*;
import pwc.taxtech.atms.organization.mapper.OrganizationAttachmentTMapper;
import pwc.taxtech.atms.organization.mapper.OrganizationDirectorTMapper;
import pwc.taxtech.atms.organization.mapper.OrganizationHKTMapper;
import pwc.taxtech.atms.organization.mapper.OrganizationShareholderTMapper;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.stream.Collectors;

import static pwc.taxtech.atms.common.CommonConstants.SystemError;
import static pwc.taxtech.atms.common.CommonUtils.copyProperties;
import static pwc.taxtech.atms.common.OperateLogType.OperationLogOrganization;
import static pwc.taxtech.atms.common.message.LogMessage.AddOrganization;
import static pwc.taxtech.atms.common.util.SpringContextUtil.distributedIdService;

@Service
public class OrganizationHKServiceImpl {
    private static final Logger logger = LoggerFactory.getLogger(OrganizationHKServiceImpl.class);

    @Resource
    private OrganizationHKMapper organizationHKMapper;

    @Resource
    private OrganizationDirectorMapper organizationDirectorMapper;

    @Resource
    private OrganizationShareholderMapper organizationShareholderMapper;

    @Autowired
    private OperationLogServiceImpl operationLogService;

    @Autowired
    private AuthUserHelper authUserHelper;

    @Autowired
    private OrgHKUtil orgHKUtil;

    @Autowired
    private FileService fileService;

    @Resource
    private OrganizationAttachmentMapper organizationAttachmentMapper;

    @Autowired
    private OrganizationShareholderTMapper organizationShareholderTMapper;

    @Autowired
    private OrganizationAttachmentTMapper organizationAttachmentTMapper;

    @Autowired
    private OrganizationDirectorTMapper organizationDirectorTMapper;

    @Autowired
    private OrganizationHKTMapper organizationHKTMapper;

    @Resource
    private OrganizationShareholderExtMapper organizationShareholderExtMapper;

    @Value("${orgaization.file.location}")
    private String fileDirectory;

    public List<OrganizationHKDto> getOrgInfo() {
        List<OrganizationHKDto> organizationHKDtos = new ArrayList<>();
        OrganizationHKExample organizationHKExample =new OrganizationHKExample();
        organizationHKExample.createCriteria().andIsActiveEqualTo(true);
        List<OrganizationHK> organizationHKS = organizationHKMapper.selectByExample(organizationHKExample);
        OrganizationShareholderExample organizationShareholderExample = new OrganizationShareholderExample();
        organizationShareholderExample.createCriteria().andIsDeleteEqualTo(false);
        List<OrganizationShareholder> organizationShareholders = organizationShareholderMapper.selectByExample(organizationShareholderExample);
        OrganizationDirectorExample organizationDirectorExample = new OrganizationDirectorExample();
        organizationDirectorExample.createCriteria().andIsDeleteEqualTo(false);
        List<OrganizationDirector> organizationDirectors = organizationDirectorMapper.selectByExample(organizationDirectorExample);
        List<OrganizationAttachment> organizationAttachments = organizationAttachmentMapper.selectByExample(null);
        organizationHKS.forEach(a -> {
            OrganizationHKDto organizationHKDto = organizationHKTMapper.toOrganizationHKDto(a);
            List<OrganizationShareholderDto> tempShareholders = organizationShareholders.stream().filter(b -> b.getEntityId().equals(a.getId()))
                    .map(organizationShareholderTMapper::toOrgShareholder).collect(Collectors.toList());
            List<OrganizationDirectorDto> tempDirectors = organizationDirectors.stream().filter(c -> c.getEntityId().equals(a.getId()))
                    .map(organizationDirectorTMapper::toOrganizationDirectorDto).collect(Collectors.toList());
            List<OrganizationAttachmentDto> tempAttachments = organizationAttachments.stream().filter(d -> d.getEntityId().equals(a.getId()))
                    .map(organizationAttachmentTMapper::toOrganizationAttachmentDto).collect(Collectors.toList());
            organizationHKDto.setShareholders(tempShareholders);
            organizationHKDto.setDirectors(tempDirectors);
            organizationHKDto.setAttachments(tempAttachments);
            List<ShareholderDto> shareholderDtos = organizationShareholderExtMapper.selectShareholder(a.getId());
            List<SubsidaryDto> subsidaryDtos = organizationShareholderExtMapper.selectSubsidary(a.getId());
            List<OrgShareholderDto> orgShareholderDtos = shareholderDtos.stream()
                    .map(organizationShareholderTMapper::toOrgShareholderDto).collect(Collectors.toList());
            List<OrgSubsidaryDto> orgSubsidaryDtos = subsidaryDtos.stream()
                    .map(organizationShareholderTMapper::toOrgSubsidaryDto).collect(Collectors.toList());
            List<OrgDirectorDto> orgDirectorDtos = organizationDirectors.stream()
                    .map(organizationDirectorTMapper::toOrgDirectorDto).collect(Collectors.toList());
            organizationHKDto.setOrgShareholderDtos(orgShareholderDtos);
            organizationHKDto.setOrgSubsidaryDtos(orgSubsidaryDtos);
            organizationHKDto.setOrgDirectorDtos(orgDirectorDtos);
            organizationHKDtos.add(organizationHKDto);
        });
        return organizationHKDtos;
    }

    public OperationResultDto enableOrgs(Long orgId) {
        OrganizationHK curOrg = orgId != null ? organizationHKMapper.selectByPrimaryKey(orgId) : null;
        if (curOrg == null) {
            return new OperationResultDto(false, OrganizationMessage.NotFindOrgEnable);
        } else {
            if (!curOrg.getIsActive()) {
                curOrg.setIsActive(true);
                organizationHKMapper.updateByPrimaryKey(curOrg);
                OperationLogDto opLog = new OperationLogDto();
                opLog.setAction(OperationAction.Update.value());
                opLog.setOperationContent(LogMessage.IsActive);
                opLog.setOperationObject(curOrg.getName());
                opLog.setOriginalState(LogMessage.Disable);
                opLog.setUpdateState(LogMessage.Enable);
                opLog.setIp("");
                opLog.setModule(OperationModule.Organization.value());
                opLog.setComment("");
                opLog.setLogType(OperateLogType.OperationLogOrganization.value());
                operationLogService.addOperationLog(opLog);
            }
            return new OperationResultDto(true);
        }
    }

    public OperationResultDto disableOrgs(List<Long> orgIds) {
        try {
            List<OperationLogDto> logList = new ArrayList<>();
            for (Long orgId : orgIds) {
                OrganizationHK rootOrg = orgId != null ? organizationHKMapper.selectByPrimaryKey(orgId) : null;
                Assert.notNull(rootOrg, "rootOrg is null");
                if (rootOrg.getIsActive()) {
                    rootOrg.setIsActive(false);
                    organizationHKMapper.updateByPrimaryKey(rootOrg);
                    OperationLogDto opLog = new OperationLogDto();
                    opLog.setAction(OperationAction.Update.value());
                    opLog.setOperationContent(LogMessage.IsActive);
                    opLog.setOperationObject(rootOrg.getName());
                    opLog.setOriginalState(BooleanUtils.isTrue(rootOrg.getIsActive()) ? "False" : "True");
                    opLog.setUpdateState(BooleanUtils.isTrue(rootOrg.getIsActive()) ? "True" : "False");
                    opLog.setModule(OperationModule.Organization.value());
                    opLog.setComment("");
                    opLog.setLogType(OperateLogType.OperationLogOrganization.value());
                    logList.add(opLog);
                }
            }
            operationLogService.addOperationLogList(logList);
            return new OperationResultDto(true);
        } catch (Exception ex) {
            logger.error("DisableOrgs出错了:" + ex, ex);
            logger.error("标记回滚, ready to call setRollbackOnly");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new OperationResultDto(false, ex.getMessage());
        }
    }

    public OperationResultDto<Object> updateOrg(OrganizationHKDto orgDto) {
        try {
            Assert.notNull(orgDto, "orgDto Null Exception on updateOrg");
            OrganizationHK org = orgDto.getId() != null ? organizationHKMapper.selectByPrimaryKey(orgDto.getId()) : null;
            if (org == null) {
                return new OperationResultDto(false, OrganizationMessage.NotFindOrg);
            }
            OrganizationHK orgOriginal = new OrganizationHK();
            orgOriginal = CommonUtils.copyProperties(org, orgOriginal);
            // code唯一验证

            CommonUtils.copyProperties(orgDto, org);
            org.setUpdateTime(new Date());
            OrganizationHK orgUpdate = org;
            organizationHKMapper.updateByPrimaryKeySelective(org);

            // 更新自定义属性
            UpdateLogParams updateLogParams = new UpdateLogParams();
            updateLogParams.setOriginalState(orgOriginal);
            updateLogParams.setUpdateState(orgUpdate);
            updateLogParams.setOperationModule(OperationModule.Organization.value());
            updateLogParams.setOperateLogType(OperationLogOrganization.value());
            updateLogParams.setOperationContent(orgUpdate.getName());
            updateLogParams.setOperationObject(org.getName());
            updateLogParams.setOperationAction(OperationAction.Update.value());
            updateLogParams.setComment("");
            operationLogService.updateDataAddLog(updateLogParams);
            return new OperationResultDto(true);
        } catch (DuplicateKeyException e) {
            //万不得已出此下策
            return new OperationResultDto(true, "保存成功!");
        } catch (Exception ex) {
            logger.error("UpdateOrg出错了:" + ex, ex);
            logger.error("标记回滚, ready to call setRollbackOnly");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new OperationResultDto(false, ex.getMessage());
        }
    }

    public List<NavTreeDto> getOrgListToJson(Integer useType) {
        List<OrganizationHKDto> orgList = getOrgList(useType);
        return orgList.stream().map(this::rotateOrganizationDtoToNavTreeDto).collect(Collectors.toList());
    }

    private List<OrganizationHKDto> getOrgList(Integer useType) {
        List<OrganizationHKDto> orgDtoList = new ArrayList<>();
        List<OrganizationHK> orgList = findAllOrganizations();
        if (!orgList.isEmpty()) {
            // find rootOrg
            List<OrganizationHK> rootOrgs = null;
            if (useType == 1) {
                rootOrgs = orgList.stream().filter(x -> x.getParentId() == 0).collect(Collectors.toList());
            } else {
                rootOrgs = orgList.stream()
                        .filter(x -> x.getParentId() == 0 && CommonConstants.ACTIVE_STATUS.equals(x.getIsActive()))
                        .collect(Collectors.toList());
            }

            List<ServiceType> serviceList = new ArrayList<>();
            for (OrganizationHK rootOrg : rootOrgs) {
                OrganizationHKDto rootDto = rotateOrganizationToOrganizationDto(rootOrg);
                OrganizationHKDto subOrgs = genarateSubOrgs(rootDto, orgList, serviceList, useType);
                orgDtoList.add(subOrgs);
            }
        }
        orgDtoList.sort(Comparator.comparing(OrganizationHKDto::getName));
        return orgDtoList;
    }

    private NavTreeDto rotateOrganizationDtoToNavTreeDto(OrganizationHKDto organizationDto) {
        NavTreeDto navTreeDto = new NavTreeDto();
        navTreeDto.setLabel(organizationDto.getName());
        navTreeDto.setData(organizationDto);
        navTreeDto.setChildren(organizationDto.getSubOrgs().stream().map(this::rotateOrganizationDtoToNavTreeDto)
                .collect(Collectors.toList()));
        return navTreeDto;
    }

    private OrganizationHKDto rotateOrganizationToOrganizationDto(OrganizationHK organization) {
        OrganizationHKDto organizationDto = new OrganizationHKDto();
        CommonUtils.copyProperties(organization, organizationDto);
        return organizationDto;
    }

    private OrganizationHKDto genarateSubOrgs(OrganizationHKDto parentOrg, List<OrganizationHK> orgs, List<ServiceType> serviceList, Integer useType) {
        if (parentOrg.getParentId() > 0) {
            OrganizationHK organization = orgs.stream().filter(x -> x.getId().equals(parentOrg.getParentId()))
                    .collect(Collectors.toList()).get(0);
            parentOrg.setParentName(organization == null ? null : organization.getName());
        }
        List<OrganizationHK> subOrgs = null;
        if (useType == 1) {
            subOrgs = orgs.stream().filter(x -> parentOrg.getId().equals(x.getParentId())).collect(Collectors.toList());
        } else {
            subOrgs = orgs.stream().filter(x -> parentOrg.getId().equals(x.getParentId())
                    && CommonConstants.ACTIVE_STATUS.equals(x.getIsActive())).collect(Collectors.toList());
        }
        parentOrg.setSubOrgs(new ArrayList<>());

        // create and add subtrees to the current node
        for (OrganizationHK subOrg : subOrgs) {
            OrganizationHKDto subDto = rotateOrganizationToOrganizationDto(subOrg);
            subDto.setLevel(parentOrg.getLevel() == null ? 1 : parentOrg.getLevel() + 1);
            parentOrg.getSubOrgs().add(genarateSubOrgs(subDto, orgs, serviceList, useType));
        }
        return parentOrg;
    }

    public List<OrganizationHK> findAllOrganizations() {
        OrganizationHKExample organizationExample = new OrganizationHKExample();
        return organizationHKMapper.selectByExample(organizationExample);
    }

    public OrganizationHKDto getSingleOrgByOrgId(Long orgId) {
        OrganizationHK organizationHK = organizationHKMapper.selectByPrimaryKey(orgId);
        OrganizationHKDto result = new OrganizationHKDto();
        CommonUtils.copyProperties(organizationHK, result);
        Assert.notNull(result, "result is null");
        result.setLevel(result.getLevel() == null ? 0 : result.getLevel());
        result.setParentName("");
        OrganizationShareholderExample shareholderExample = new OrganizationShareholderExample();
        shareholderExample.createCriteria().andEntityIdEqualTo(orgId).andIsDeleteEqualTo(false);
        List<OrganizationShareholderDto> organizationShareholderDtos = organizationShareholderMapper.selectByExample(shareholderExample).stream()
                .map(a -> organizationShareholderTMapper.toOrgShareholder(a)).collect(Collectors.toList());
        OrganizationDirectorExample directorExample = new OrganizationDirectorExample();
        directorExample.createCriteria().andEntityIdEqualTo(orgId).andIsDeleteEqualTo(false);
        List<OrganizationDirectorDto> organizationDirectorDtos = organizationDirectorMapper.selectByExample(directorExample).stream()
                .map(a -> organizationDirectorTMapper.toOrganizationDirectorDto(a)).collect(Collectors.toList());
        result.setDirectors(organizationDirectorDtos);
        result.setShareholders(organizationShareholderDtos);
        OrganizationAttachmentExample organizationAttachmentExample = new OrganizationAttachmentExample();
        organizationAttachmentExample.createCriteria().andEntityIdEqualTo(orgId);
        List<OrganizationAttachmentDto> organizationAttachmentDtos = organizationAttachmentMapper.selectByExample(organizationAttachmentExample).stream()
                .map(organizationAttachmentTMapper::toOrganizationAttachmentDto).collect(Collectors.toList());
        result.setAttachments(organizationAttachmentDtos);
        List<OrgShareholderDto> orgShareholderDtos = organizationShareholderExtMapper.selectShareholder(orgId).stream()
                .map(organizationShareholderTMapper::toOrgShareholderDto).collect(Collectors.toList());
        List<OrgSubsidaryDto> orgSubsidaryDtos = organizationShareholderExtMapper.selectSubsidary(orgId).stream()
                .map(organizationShareholderTMapper::toOrgSubsidaryDto).collect(Collectors.toList());
        List<OrgDirectorDto> orgDirectorDtos = organizationDirectorMapper.selectByExample(directorExample).stream()
                .map(organizationDirectorTMapper::toOrgDirectorDto).collect(Collectors.toList());
        result.setOrgShareholderDtos(orgShareholderDtos);
        result.setOrgSubsidaryDtos(orgSubsidaryDtos);
        result.setOrgDirectorDtos(orgDirectorDtos);
        return result;
    }

    public OperationResultDto<Object> addOrg(OrganizationHKDto orgDto) {
        try {
            OperationResultDto result = checkExist(orgDto);
            if (result != null && !BooleanUtils.isTrue(result.getResult())) {
                return new OperationResultDto(result.getResult(), result.getResultMsg());
            }
            orgDto.setParentId(null);
            orgDto.setPLevel(0);
            orgDto.setId(distributedIdService.nextId());
            Date now = new Date();
            OrganizationHK org = copyProperties(orgDto, new OrganizationHK());
            org.setCreateTime(now);
            org.setUpdateTime(now);
            if (orgDto.getDirectors() != null && orgDto.getDirectors().size() > 0) {
                orgDto.getDirectors().forEach(a -> {
                    OrganizationDirector organizationDirector = CommonUtils.copyProperties(a, new OrganizationDirector());
                    organizationDirector.setUpdateTime(now);
                    organizationDirector.setCreateTime(now);
                    organizationDirector.setEntityId(org.getId());
                    organizationDirector.setId(distributedIdService.nextId());
                    organizationDirectorMapper.insertSelective(organizationDirector);
                });
            }
            if (orgDto.getShareholders() != null && orgDto.getShareholders().size() > 0) {
                orgDto.getShareholders().forEach(a -> {
                    OrganizationShareholder organizationShareholder = CommonUtils.copyProperties(a, new OrganizationShareholder());
                    organizationShareholder.setId(distributedIdService.nextId());
                    organizationShareholder.setInvestmentEntityId(0L);
                    organizationShareholder.setEntityId(org.getId());
                    organizationShareholder.setCreateTime(now);
                    organizationShareholder.setUpdateTime(now);
                    organizationShareholderMapper.insertSelective(organizationShareholder);
                });
            }
            organizationHKMapper.insertSelective(org);

            UpdateLogParams tempCommonLogParms = new UpdateLogParams();
            tempCommonLogParms.setOperationModule(OperationModule.Organization.value());
            tempCommonLogParms.setComment(AddOrganization);
            tempCommonLogParms.setOperateLogType(OperationLogOrganization.value());
            tempCommonLogParms.setOperationContent(org.getName());
            tempCommonLogParms.setOperationAction(OperationAction.New.value());
            tempCommonLogParms.setOperationObject(orgDto.getName());
            tempCommonLogParms.setUpdateState("");
            tempCommonLogParms.setOriginalState("");
            operationLogService.addOrDeleteDataAddLog(tempCommonLogParms);
            return new OperationResultDto(true);
        } catch (Exception e) {
            logger.error("addOrg出错:" + e, e);
            logger.error("标记回滚, ready to call setRollbackOnly");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return new OperationResultDto(false, SystemError);
        }
    }

    private OperationResultDto checkExist(OrganizationHKDto orgDto) {
        Assert.notNull(orgDto, "orgDto null point error");
        OrganizationHK queryRoot = null;
        OrganizationHKExample example = new OrganizationHKExample();
        OrganizationHKExample.Criteria criteria = example.createCriteria();
        criteria.andCodeEqualTo(orgDto.getCode());
        if (orgDto.getId() != null) {
            criteria.andIdNotEqualTo(orgDto.getId());
        }
        queryRoot = organizationHKMapper.selectByExample(example).stream().findFirst().orElse(null);

        if (queryRoot != null && orgDto.getId() != null && orgDto.getId() == 0) {
            return new OperationResultDto(false, OrganizationMessage.ClientCodeIsExist);
        }
        OperationResultDto operationResult = checkOrgNameOrOrgCode(orgDto);
        return operationResult;
    }

    private OperationResultDto checkOrgNameOrOrgCode(OrganizationHKDto orgDto) {
        OrganizationHKExample example = new OrganizationHKExample();
        if (orgDto.getId() == null) {
            example.or().andCodeEqualTo(orgDto.getCode()).andNameEqualTo(orgDto.getName());
        } else {
            example.or().andCodeEqualTo(orgDto.getCode()).andIdNotEqualTo(orgDto.getId())
                    .andNameEqualTo(orgDto.getName());
        }
        OrganizationHK query = organizationHKMapper.selectByExample(example).stream().findFirst().orElse(null);
        if (query != null) {
            return new OperationResultDto(false, OrganizationMessage.OrgNameOrCodeIsExiste);
        }
        return new OperationResultDto(true);
    }

    public OperationResultDto<Object> addOrgDirector(OrganizationDirector organizationDirector) {
        OperationResultDto<Object> operationResultDto = new OperationResultDto<>();
        organizationDirectorMapper.insertSelective(organizationDirector);
        operationResultDto.setResult(true);
        return operationResultDto;
    }

    public OperationResultDto<Object> addOrgShareholder(OrganizationShareholder organizationShareholder) {
        OperationResultDto<Object> operationResultDto = new OperationResultDto<>();
        organizationShareholderMapper.insertSelective(organizationShareholder);
        operationResultDto.setResult(true);
        return operationResultDto;
    }

    public OperationResultDto<Object> updateDirector(OrganizationDirector organizationDirector) {
        OperationResultDto<Object> resultDto = new OperationResultDto<>();
        if (existDirector(organizationDirector.getId())) {
            Date now = new Date();
            organizationDirector.setUpdateTime(now);
            organizationDirector.setUpdateBy(authUserHelper.getCurrentUserId());
            organizationDirectorMapper.updateByPrimaryKey(organizationDirector);
            resultDto.setResult(true);
        } else {
            resultDto.setResult(false);
            resultDto.setResultMsg("Not exist director");
        }

        return resultDto;

    }

    public OperationResultDto<Object> updateShareholder(OrganizationShareholder organizationShareholder) {
        OperationResultDto<Object> resultDto = new OperationResultDto<>();
        if (existShareholder(organizationShareholder.getId())) {
            Date now = new Date();
            organizationShareholder.setUpdateTime(now);
            organizationShareholder.setUpdateBy(authUserHelper.getCurrentUserId());
            organizationShareholderMapper.updateByPrimaryKey(organizationShareholder);
            resultDto.setResult(true);
        } else {
            resultDto.setResult(false);
            resultDto.setResultMsg("Not exist director");
        }
        return resultDto;
    }

    private boolean existShareholder(Long organizationShardholderId) {
        OrganizationShareholder organizationShareholder = organizationShareholderMapper.selectByPrimaryKey(organizationShardholderId);
        return organizationShareholder != null;
    }

    private boolean existDirector(Long organizationDirectorId) {
        OrganizationDirector organizationDirector = organizationDirectorMapper.selectByPrimaryKey(organizationDirectorId);
        return organizationDirector != null;
    }

    public OperationResultDto<Object> updateDirectors(List<OrganizationDirectorDto> organizationDirectorDtos) {
        OperationResultDto<Object> resultDto = new OperationResultDto<>();
        organizationDirectorDtos.forEach(a -> {
            OrganizationDirector organizationDirector;
            try {
                organizationDirector = CommonUtils.copyProperties(a, new OrganizationDirector());
            } catch (Exception ex) {
                organizationDirector = new OrganizationDirector();
                organizationDirector.setDirectorName(a.getDirectorName());
                organizationDirector.setDateOfAppointment(new Date(a.getDateOfAppointment()));
                organizationDirector.setDateOfResignation(new Date(a.getDateOfResignation()));
                organizationDirector.setResidency(a.getResidency());
                organizationDirector.setEntityId(Long.valueOf(a.getEntityId()));
            }
            if (organizationDirector.getId() != null) {
                organizationDirectorMapper.deleteByPrimaryKey(organizationDirector.getId());
            }
            Date now = new Date();
            organizationDirector.setId(distributedIdService.nextId());
            organizationDirector.setCreateTime(now);
            organizationDirector.setUpdateTime(now);
            organizationDirectorMapper.insertSelective(organizationDirector);
        });
        resultDto.setResult(true);
        return resultDto;
    }

    public OperationResultDto<Object> updateShareholders(List<OrganizationShareholderDto> organizationShareholderDtos) {
        OperationResultDto<Object> resultDto = new OperationResultDto<>();
        organizationShareholderDtos.forEach(a -> {
            OrganizationShareholder organizationShareholder = organizationShareholderTMapper.toOrganizationShareholder(a);
            Date now = new Date();
            if (organizationShareholder.getId() != null) {
                organizationShareholder.setUpdateTime(now);
                organizationShareholderMapper.updateByPrimaryKeySelective(organizationShareholder);
            } else {
                organizationShareholder.setId(distributedIdService.nextId());
                organizationShareholder.setUpdateTime(now);
                organizationShareholder.setCreateTime(now);
                organizationShareholderMapper.insertSelective(organizationShareholder);
            }
        });
        OrganizationShareholderExample organizationShareholderExample = new OrganizationShareholderExample();
        organizationShareholderExample.createCriteria().andEntityIdEqualTo(Long.valueOf(organizationShareholderDtos.get(0).getEntityId())).andIsDeleteEqualTo(false);
        List<OrganizationShareholder> organizationShareholders = organizationShareholderMapper.selectByExample(organizationShareholderExample);
        List<OrganizationShareholderDto> organizationShareholderDtoList = organizationShareholders.stream().map(organizationShareholderTMapper::toOrgShareholder).collect(Collectors.toList());
        resultDto.setResult(true);
        resultDto.setData(organizationShareholderDtoList);
        return resultDto;
    }

    public boolean checkOrgExist(String orgId) {
        OrganizationHKExample example = new OrganizationHKExample();
        example.createCriteria().andIdEqualTo(Long.parseLong(orgId)).andIsActiveEqualTo(true);
        List<OrganizationHK> organizationHKs = organizationHKMapper.selectByExample(example);
        return organizationHKs != null && organizationHKs.size() > 0;
    }

    public OperationResultDto<Object> uploadAttachs(CommonsMultipartFile[] files, String orgId) {
        logger.debug("OrganizationHKServiceImpl uploadAttachs start");
        OperationResultDto<Object> result = new OperationResultDto<>();
        List<OrganizationAttachmentDto> organizationAttachments = new ArrayList<>();
        for (CommonsMultipartFile file : files) {
            final String orginalName = file.getOriginalFilename();
            logger.debug("orgianal file name[{}]", orginalName);
            Assert.notNull(orginalName, "null orginal file name");
            Assert.state(orginalName.length() <= 500, "invalid file name length for file: " + orginalName.length());
            if (!fileDirectory.endsWith("/")) {
                fileDirectory = fileDirectory + "/";
            }

            final Date now = new Date();
            final String pathYearMonth = orgHKUtil.buildDateFormat("yyyy/MM").format(now);
            final String fileNameYearMonthDay = orgHKUtil.buildDateFormat("yyyyMMdd").format(now);

            // fileNameWithoutExtension：对文件名做处理，删除特殊字符，限制长度为50
            final String fileNameWithoutExtension = orgHKUtil
                    .trimLimit(orgHKUtil.cleanFilename(FilenameUtils.getBaseName(orginalName)), 50);

            final String fileExtension = FilenameUtils.getExtension(orginalName).toLowerCase();
            final String fileNameToSave = (fileNameYearMonthDay + "_" + fileNameWithoutExtension + "_"
                    + CommonUtils.getUUID().substring(0, 6) + "." + fileExtension).toLowerCase();
            // relatedDirectory：相对路径目录，以/结尾
            final String relatedDirectory = pathYearMonth + "/";
            // generatedFileDirectory：绝对路径目录
            final String generatedFileDirectory = fileDirectory + relatedDirectory;

            logger.debug("create file directory does not exist, directory: {}", generatedFileDirectory);
            Files.createDirIfNoExists(generatedFileDirectory);
            String filePath = generatedFileDirectory + fileNameToSave;
            final String filePathToSave = relatedDirectory + fileNameToSave;

            logger.debug("file path: {}", filePath);
            logger.debug("save file in file system");
            OperationResultDto<Object> saveResult = saveAttachFile(file, filePath);

            // if save failed, should roll back all changes
            if (saveResult.getResult() == null || !saveResult.getResult()) {
                throw new ApplicationException("failed to save file in file system");
            }

            logger.debug("save file in database");
            OrganizationAttachment organizationAttachment = saveOrgAttachments(filePath, filePathToSave, fileNameToSave, orgId, file, fileExtension);
            organizationAttachments.add(organizationAttachmentTMapper.toOrganizationAttachmentDto(organizationAttachment));
        }

        if (CollectionUtils.isEmpty(organizationAttachments)) {
            logger.debug("output file is empty");
            result.setResult(false);
            result.setResultMsg("output file is empty");
            return result;
        }
        result.setData(organizationAttachments);
        result.setResult(true);
        logger.debug("output file size: {}", organizationAttachments.size());
        logger.debug("OrganizationHKServiceImpl uploadAttachs end");
        return result;
    }

    private OrganizationAttachment saveOrgAttachments(String filePath, String filePathToSave, String fileNameToSave, String orgId, CommonsMultipartFile file, String fileExtension) {
        OrganizationAttachment organizationAttachment = new OrganizationAttachment();
        organizationAttachment.setId(distributedIdService.nextId());
        organizationAttachment.setEntityId(Long.valueOf(orgId));
        organizationAttachment.setCalendarEventId(0L);
        organizationAttachment.setCalendarConfigId(0L);
        organizationAttachment.setDocumentName(fileNameToSave);
        organizationAttachment.setDocumentPath(filePathToSave);
        organizationAttachment.setDocumentExtension(fileExtension);
        Date now = new Date();
        organizationAttachment.setCreateTime(now);
        organizationAttachment.setUpdateTime(now);
        organizationAttachment.setCreateBy(authUserHelper.getCurrentUserId());
        organizationAttachment.setUpdateBy(authUserHelper.getCurrentUserId());
        organizationAttachmentMapper.insertSelective(organizationAttachment);
        return organizationAttachment;
    }

    private OperationResultDto<Object> saveAttachFile(CommonsMultipartFile inputFile, String filePath) {
        InputStream inputStream;
        try {
            inputStream = inputFile.getInputStream();
        } catch (IOException e) {
            throw new ApplicationException(e.getMessage());
        }
        OperationResultDto<Object> saveResult = fileService.saveFile(inputStream, filePath);
        return saveResult;
    }

    public void downloadAttachment(HttpServletRequest request, HttpServletResponse response, Long attachmentId) {
        OrganizationAttachment attachment = organizationAttachmentMapper.selectByPrimaryKey(attachmentId);
        Assert.notNull(attachment, "attachment is null");
        String fileName = attachment.getDocumentName();
        String filePath = fileDirectory + "/" + attachment.getDocumentPath();
        FileExcelUtil.downloadFile(request, response, fileName, filePath);
    }

    public OperationResultDto<Object> deleteAttachment(Long attachmentId) {
        OperationResultDto<Object> resultDto = new OperationResultDto<>();
        OrganizationAttachmentExample example = new OrganizationAttachmentExample();
        example.createCriteria().andIdEqualTo(attachmentId);
        organizationAttachmentMapper.deleteByExample(example);
        resultDto.setResult(true);
        return resultDto;
    }

    public OperationResultDto<List<OrgShareholderTreeDataDto>> getOrgTreeData(Long orgId) {
        OperationResultDto<List<OrgShareholderTreeDataDto>> resultDto = new OperationResultDto<>();
        List<OrgShareholderTreeDataDto> orgShareholderTreeDataDtos = new ArrayList<>();
        List<ShareholderDto> shareholderDtos = organizationShareholderExtMapper.selectShareholder(orgId);
        List<SubsidaryDto> subsidaryDtos = organizationShareholderExtMapper.selectSubsidary(orgId);
        OrganizationHK organizationHK = organizationHKMapper.selectByPrimaryKey(orgId);
        int i = 1;
        List<Integer> parentIds = new ArrayList<>();
        //todo: add shareholder nodes
        for (ShareholderDto shareholderDto : shareholderDtos) {
            OrgShareholderTreeDataDto orgShareholderTreeDataDto = new OrgShareholderTreeDataDto();
            orgShareholderTreeDataDto.setId(i);
            orgShareholderTreeDataDto.setName(shareholderDto.getEntityName());
            orgShareholderTreeDataDto.setPercent(shareholderDto.getVotingPercentage());
//            orgShareholderTreeDataDto.setPid(shareholderDtos.size() + 1);
            orgShareholderTreeDataDto.setSpids(Collections.emptyList());
            orgShareholderTreeDataDtos.add(orgShareholderTreeDataDto);
            if (i > 1) {
                parentIds.add(i);
            }
            i++;
        }
        //todo: add organization node
        OrgShareholderTreeDataDto treeDataDto = new OrgShareholderTreeDataDto();
        treeDataDto.setId(i);
        treeDataDto.setName(organizationHK.getName());
        treeDataDto.setPercent("");
        if (i > 1) {
            treeDataDto.setPid(1);
            treeDataDto.setSpids(parentIds);
        }
        i++;
        orgShareholderTreeDataDtos.add(treeDataDto);

        //todo: add subsidary nodes
        for (SubsidaryDto subsidaryDto : subsidaryDtos) {
            OrgShareholderTreeDataDto orgShareholderTreeDataDto = new OrgShareholderTreeDataDto();
            orgShareholderTreeDataDto.setId(i);
            orgShareholderTreeDataDto.setName(subsidaryDto.getEntityName());
            orgShareholderTreeDataDto.setPercent(subsidaryDto.getVotingPercentage());
            orgShareholderTreeDataDto.setPid(0);
            orgShareholderTreeDataDto.setSpids(Collections.emptyList());
            orgShareholderTreeDataDtos.add(orgShareholderTreeDataDto);
            i++;
        }
        resultDto.setResult(true);
        resultDto.setData(orgShareholderTreeDataDtos);
        return resultDto;
    }

    public OperationResultDto<List<OrgInfoDto>> getOrgsListInfo() {
        OperationResultDto<List<OrgInfoDto>> resultDto = new OperationResultDto<>();
        OrganizationHKExample organizationHKExample = new OrganizationHKExample();
        organizationHKExample.createCriteria().andIsActiveEqualTo(true);
        List<OrganizationHK> organizationHKS = organizationHKMapper.selectByExample(organizationHKExample);
        List<OrgInfoDto> orgInfoDtos = organizationHKS.stream().map(organizationHKTMapper::toOrgInfoDto).collect(Collectors.toList());
        resultDto.setResult(true);
        resultDto.setData(orgInfoDtos);
        return resultDto;
    }

    public OperationResultDto deleteShareholder(Long id) {
        OperationResultDto resultDto =new OperationResultDto();
        OrganizationShareholder organizationShareholder = organizationShareholderMapper.selectByPrimaryKey(id);
        organizationShareholder.setIsDelete(true);
        organizationShareholder.setUpdateTime(new Date());
        organizationShareholderMapper.updateByPrimaryKeySelective(organizationShareholder);
        resultDto.setResult(true);
        return resultDto;
    }
}