ProjectServiceImpl.java

package pwc.taxtech.atms.service.impl;

import com.beust.jcommander.internal.Lists;
import com.google.common.base.Predicate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import pwc.taxtech.atms.common.CommonUtils;
import pwc.taxtech.atms.common.OperateLogType;
import pwc.taxtech.atms.common.OperationModule;
import pwc.taxtech.atms.dao.OrganizationServiceTemplateGroupMapper;
import pwc.taxtech.atms.dao.ProjectClientMapper;
import pwc.taxtech.atms.dao.ProjectMapper;
import pwc.taxtech.atms.dao.ProjectServiceTypeMapper;
import pwc.taxtech.atms.dao.ServiceTypeMapper;
import pwc.taxtech.atms.dao.TemplateGroupMapper;
import pwc.taxtech.atms.dto.FieldsMapper;
import pwc.taxtech.atms.dto.ProjectClientDto;
import pwc.taxtech.atms.dto.ServiceTypeDto;
import pwc.taxtech.atms.dto.TemplateGroupDto;
import pwc.taxtech.atms.dto.taxadmin.AddProjectResult;
import pwc.taxtech.atms.dto.taxadmin.ProjectDisplayDto;
import pwc.taxtech.atms.dto.taxadmin.ProjectYearParam;
import pwc.taxtech.atms.entitiy.*;
import pwc.taxtech.atms.entitiy.ProjectClientExample.Criteria;
import pwc.taxtech.atms.service.OperationLogService;
import pwc.taxtech.atms.service.ProjectService;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

@Service
public class ProjectServiceImpl implements ProjectService {
    /**
     * @see PwC.Tax.Tech.Atms..Admin.Application\Services\Impl\ProjectService.cs
     */
    private static final int FIRST_OR_DEFAULT = 0;
    private static Logger LOGGER = LoggerFactory.getLogger(ProjectServiceImpl.class);

    @Autowired
    private ServiceTypeMapper serviceTypeMapper;

    @Autowired
    private TemplateGroupMapper templateGroupMapper;

    @Autowired
    private ProjectClientMapper projectClientMapper;

    @Autowired
    private ProjectMapper projectMapper;

    @Autowired
    private OrganizationServiceTemplateGroupMapper organizationServiceTemplateGroupMapper;

    @Autowired
    private ProjectServiceTypeMapper projectServiceTypeMapper;

    @Autowired
    private OperationLogService operationLogService;

    private final OperateLogType LOG_TYPE = OperateLogType.OperationLogProject;
    private static final Logger logger = LoggerFactory.getLogger(ProjectServiceImpl.class);

    public ProjectServiceImpl() {
    }

    @Override
    public List<ServiceTypeDto> getServiceList() {

        ServiceTypeExample serviceTypeExample = new ServiceTypeExample();
        serviceTypeExample.createCriteria().andIsActiveEqualTo(true);

        logger.debug("获取ServiceType Start");
        List<ServiceType> serviceTypeList = serviceTypeMapper.selectByExample(serviceTypeExample);

        logger.debug("获取TemplateGroup Start");
        List<TemplateGroup> templateGroupList = templateGroupMapper.selectByExample(new TemplateGroupExample());

        List<ServiceTypeDto> serviceTypeDtoList = serviceTypeList.stream().map(this::rotateServiceType)
                .collect(Collectors.toList());
        List<TemplateGroupDto> templateGroupDtoList = templateGroupList.stream().map(this::rotateTemplateGroup)
                .collect(Collectors.toList());

        for (ServiceTypeDto serviceTypeDto : serviceTypeDtoList) {
            // serviceType 和 templateGroup是上下层级关系，遍历ServiceTypeDto,
            // 并将每个ServiceType下级关联的templateGroup填充进去
            serviceTypeDto.setTemplateGroupList(templateGroupDtoList.stream()
                    .filter(templateGroupDto -> (serviceTypeDto.getID().equals(templateGroupDto.getServiceTypeID())))
                    .collect(Collectors.toList()));
        }
        return serviceTypeDtoList;
    }

    @Override
    public List<ProjectClientDto> getProjectClientList() {
        logger.debug("获取ProjectClient Start");
        ProjectClientExample example = new ProjectClientExample();
        example.setOrderByClause("CreateTime desc");
        Criteria criteria = example.createCriteria();
        criteria.andIsActiveEqualTo(true);
        List<ProjectClient> projectClientList = projectClientMapper.selectByExample(example);
        return projectClientList.stream().map(this::rotateProjectClient).collect(Collectors.toList());
    }

    /**
     * @TODO: this dmeo only for running,should change to query data from db (neo)
     */
    @Override
    public List<ProjectDisplayDto> getProjectByID(String projectID) {
        List<ProjectDisplayDto> displayDtos = new ArrayList<>();
        displayDtos.add(new ProjectDisplayDto().demo());
        return displayDtos;
    }

    @Override
    public List<ProjectDisplayDto> getAllProjectList(String orgID, String serviceID, Integer projectYear) {
        List<ProjectDisplayDto> pList = new ArrayList<>();
        List<ProjectDisplayDto> data = projectMapper.getProjectList(orgID, serviceID, projectYear);
        //获取每个项目的项目状态
        data.forEach(p -> {
            p.setProjectStatusList(projectMapper.getProjectSatusListByDbName(p.getDbName()));
        });
        //添加账套中需要创建的项目
        List<ProjectDisplayDto> orgList = getProjectFromEnterpriseAccountSetOrg(data, orgID, serviceID, projectYear);
        //修改账套时间变化引起的已建项目的月份更改
        List<ProjectDisplayDto> removeList = new ArrayList<>();

        orgList.forEach(p -> {
            List<ProjectDisplayDto> fixList = data.stream()
                    .filter((Predicate<ProjectDisplayDto>) x -> x.getOrganizationID() == p.getOrganizationID()
                            && x.getEnterpriseAccountSetID() == p.getEnterpriseAccountSetID()
                            && x.getServiceTypeID() == p.getServiceTypeID()
                            && x.getYear() == p.getYear()
                            && (x.getStartPeriod() != p.getStartPeriod() || x.getEndPeriod() != p.getEndPeriod()))
                    .collect(Collectors.toList());

            if (fixList != null && !fixList.isEmpty()) {
                ProjectDisplayDto pddFirst = fixList.get(FIRST_OR_DEFAULT);

                //修改数据库对应项目起始月
                Project project = new Project();
                project.setID(pddFirst.getId());
                project.setStartPeriod(p.getStartPeriod());
                project.setEndPeriod(p.getEndPeriod());

                projectMapper.updateByPrimaryKey(project);

                //修改已取出数据中项目起始月
                pddFirst.setStartPeriod(p.getStartPeriod());
                pddFirst.setEndPeriod(p.getEndPeriod());
                //删除该条为创建项目记录
                removeList.add(p);
            }
        });

        removeList.forEach(r -> {
            orgList.remove(r);
        });

        pList.addAll(data);
        pList.addAll(orgList);
        return pList;
    }

    @Override
    public AddProjectResult addProject(ProjectDisplayDto projectDto, String userName) {
        projectDto.setActive(true);
        projectDto.setRuleType(1);

        Project project = new Project();
        try {
            FieldsMapper.map(projectDto, project);
        } catch (Exception e) {
            LOGGER.warn("map project dto to project may be some error");
            e.printStackTrace();
        }

        try {
            project.setID(UUID.randomUUID().toString());

            OrganizationServiceTemplateGroupExample example = new OrganizationServiceTemplateGroupExample();
            example.createCriteria().andOrganizationIDEqualTo(projectDto.getOrganizationID());
            organizationServiceTemplateGroupMapper.selectByExample(example).forEach(ostg -> {
                ProjectServiceType pst = new ProjectServiceType();
                pst.setID(UUID.randomUUID().toString());
                pst.setProjectID(project.getID());
                pst.setServiceTypeID(ostg.getServiceTypeID());
                pst.setTemplateGroupID(ostg.getTemplateGroupID());

                projectServiceTypeMapper.insert(pst);
                operationLogService.addDataAddLog(pst, OperationModule.ProjectServiceType, userName,
                        Message.Project.AddProjectServiceType, pst.getID(), projectDto.getName(), LOG_TYPE);
            });

            project.setDbName(generateDatabase(project, projectDto.getEnterpriseAccountSetID()));
            project.setUpdateTime(new Date());
            projectMapper.insert(project);
            operationLogService.addDataAddLog(project, OperationModule.Project, userName, Message.Project.AddProject,
                    project.getID(), projectDto.getName(), LOG_TYPE);

            AddProjectResult addProjectResult = new AddProjectResult();
            addProjectResult.setResult(true);
            addProjectResult.setDbName(project.getDbName());
            addProjectResult.setProjectID(project.getID());
            return addProjectResult;
        }catch (Exception e){
            operationLogService.addDataAddLog(null, OperationModule.Project, userName,
                    Message.Project.AddProjectFail, e.getMessage(), projectDto.getName(), LOG_TYPE);

            AddProjectResult addProjectResult = new AddProjectResult();
            addProjectResult.setResult(false);
            addProjectResult.setResultMsg(e.getMessage());
            return addProjectResult;
        }

    }

    @Override
    public Map<Integer, Integer> getProjectAllStatus(String dbName) {
        List<ProjectStatusManage> psmList= projectMapper.selectProjectAllStatus(dbName);
        Map<Integer,Integer> result =new HashMap<>(psmList.size());
        psmList.forEach(m->{
            result.put(m.getPeriodId(),m.getStatus());
        });

        return result;
    }

    private String generateDatabase(Project project, String accsetid) {//TODO: should be impl future(neo)
        return "db_test";
    }

    private String GenerateProjectDbName(String maxName, String year) {
        year = year.substring(2);
        String pre2 = maxName.charAt(0) + "", post2 = "";
        int post = Integer.parseInt(maxName.substring(3)) + 1;
        if (post >= 100000) {
            Integer pre = Integer.parseInt(String.valueOf(maxName.charAt(0)));
            pre2 = ((char)(pre+1))+"";
            post2 = "00000";
        } else if (post >= 10000) {
            post2 = post + "";
        } else if (post >= 1000) {
            post2 = "0" + post;
        } else if (post >= 100) {
            post2 = "00" + post;
        } else if (post >= 10) {
            post2 = "000" + post;
        } else {
            post2 = "0000" + post;
        }
        return pre2 + year + post2;
    }

    private List<ProjectDisplayDto> getProjectFromEnterpriseAccountSetOrg(List<ProjectDisplayDto> pList, String orgID,
                                                                          String serviceID, Integer projectYear) {
        List<ProjectDisplayDto> list = new ArrayList<>();
        List<ProjectDisplayDto> data = projectMapper.getProjectFromEnterpriseAccountSetOrg(orgID, serviceID);
        Map<String, ProjectDisplayDto> groupMap = new HashMap<>();

        if (data != null && data.size() > 0) {
            //去除project表已经存在的项目 g
            data.forEach(dto -> {
                getOrgProjectYears(dto.getEffectiveDate(), dto.getExpiredDate()).forEach(yDto -> {
                    dto.setYear(yDto.year);
                    dto.setStartPeriod(yDto.startMonth);
                    dto.setEndPeriod(yDto.endMonth);
                    dto.setName(dto.getOrganizationName() + "(" + dto.getYear() + "）");

                    //判断是否已经创建过该项目
                    //对于VAT，只创建今年及之后年份的项目(2018.1.2经Michelle确定，已放开vat限制)
                    //if ((projectList != null && projectList.Count > 0) || (int.Parse(orgDto.ServiceTypeID) == 2 && orgDto.Year < DateTime.Now.Year))
                    if (!pList.stream().anyMatch((Predicate<ProjectDisplayDto>) t -> t.getYear() == dto.getYear()
                            && t.getServiceTypeID() == dto.getServiceTypeID()
                            && t.getOrganizationID() == dto.getOrganizationID()
                            && t.getEnterpriseAccountSetID() == dto.getEnterpriseAccountSetID()
                            && t.getStartPeriod() == dto.getStartPeriod()
                            && t.getEndPeriod() == dto.getEndPeriod())) {
                        list.add(dto);
                    }
                });
            });

            if (!list.isEmpty()) {
                list.forEach(m -> {
                    StringBuilder groupKeyBulder = new StringBuilder(m.getOrganizationID()).append("_")
                            .append(m.getEnterpriseAccountSetID()).append("_")
                            .append(m.getYear()).append("_")
                            .append(m.getServiceTypeID()).append("_")
                            .append(m.getStartPeriod()).append("_")
                            .append(m.getEndPeriod());

                    groupMap.putIfAbsent(groupKeyBulder.toString(), m);
                });
            }
        }

        return Lists.newArrayList(groupMap.values());

    }

    private List<ProjectYearParam> getOrgProjectYears(Date startDate, Date endDate) {
        List<ProjectYearParam> pList = new ArrayList<>();

        ProjectYearParam pYear = new ProjectYearParam();
        Calendar nowCal = Calendar.getInstance();
        Date nowDate = new Date();
        nowCal.setTime(nowDate);

        Calendar startCal = Calendar.getInstance();
        startCal.setTime(startDate);

        Calendar endCal = Calendar.getInstance();
        endCal.setTime(endDate);
        if (startDate == null && endDate == null) {
            pYear.year = nowCal.get(Calendar.YEAR);
            pYear.startMonth = 1;
            pYear.endMonth = 12;

            pList.add(pYear);
        } else if (startDate == null && endDate != null && endCal.after(nowCal)) {
            pList.addAll(getProjectYears(nowDate, endDate));
        } else if (startDate != null && endDate == null && startCal.before(nowCal)) {
            pList.addAll(getProjectYears(startDate, nowDate));
        } else if (startDate != null && endDate != null && startCal.get(Calendar.YEAR) <= endCal.get(Calendar.YEAR)) {
            pList.addAll(getProjectYears(startDate, endDate));
        }
        return pList;
    }

    private List<ProjectYearParam> getProjectYears(Date startDate, Date endDate) {
        List<ProjectYearParam> pList = new ArrayList<>();

        Calendar start = Calendar.getInstance();
        start.setTime(startDate);
        int startYear = start.get(Calendar.YEAR);

        Calendar end = Calendar.getInstance();
        end.setTime(endDate);
        int endYear = end.get(Calendar.YEAR);

        if (startDate != null && endDate != null && startYear <= endYear) {
            for (int i = startYear; i <= endYear; i++) {
                ProjectYearParam pYear = new ProjectYearParam();
                pYear.year = i;
                if (startYear == endYear) {
                    pYear.startMonth = start.get(Calendar.MONTH);
                    pYear.endMonth = end.get(Calendar.MONTH);
                } else if (i == startYear && i < endYear) {
                    pYear.startMonth = start.get(Calendar.MONTH);
                    pYear.endMonth = 12;
                } else if (i > startYear && i < endYear) {
                    pYear.startMonth = 1;
                    pYear.endMonth = 12;
                } else if (i > startYear && i == endYear) {
                    pYear.startMonth = 1;
                    pYear.endMonth = end.get(Calendar.MONTH);
                }
                pList.add(pYear);
            }
        }
        return pList;
    }

    /**
     * @TODO: change the return part after copyProperties function updated
     */
    private ServiceTypeDto rotateServiceType(ServiceType serviceType) {
        ServiceTypeDto serviceTypeDto = new ServiceTypeDto();
        return CommonUtils.copyProperties(serviceType, serviceTypeDto);
    }

    /**
     * @TODO: change the return part after copyProperties function updated
     */
    private TemplateGroupDto rotateTemplateGroup(TemplateGroup templateGroup) {
        TemplateGroupDto templateGroupDto = new TemplateGroupDto();
        return CommonUtils.copyProperties(templateGroup, templateGroupDto);
    }

    /**
     * @TODO: change the return part after copyProperties function updated
     */
    private ProjectClientDto rotateProjectClient(ProjectClient projectClient) {
        ProjectClientDto projectClientDto = new ProjectClientDto();
        return CommonUtils.copyProperties(projectClient, projectClientDto);
    }

}