sso-parent/sso-server/src/main/java/com/uas/sso/service/impl/UserspaceServiceImpl.java

package com.uas.sso.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.uas.sso.common.util.HttpUtil;
import com.uas.sso.core.ICallable;
import com.uas.sso.core.Status;
import com.uas.sso.dao.UserspaceDao;
import com.uas.sso.entity.*;
import com.uas.sso.exception.VisibleError;
import com.uas.sso.logging.LoggerManager;
import com.uas.sso.logging.SyncBufferedLogger;
import com.uas.sso.service.*;
import com.uas.sso.util.ChineseUtils;
import com.uas.sso.util.ExecuteUtils;
import com.uas.sso.util.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.persistence.criteria.*;
import java.sql.Timestamp;
import java.util.*;

/**
 * 企业信息service层
 *
 * @author wangmh
 * @date 2018/1/5
 */
@Service
public class UserspaceServiceImpl implements UserspaceService {

    @Autowired
    private UserspaceDao userspaceDao;

    @Autowired
    private UserService userService;

    @Autowired
    private AppService appService;

    @Autowired
    private UserspaceValidService userspaceValidService;

    @Autowired
    private PartnershipService partnershipService;

    SyncBufferedLogger syncLog = LoggerManager.getLogger(SyncBufferedLogger.class);

    /**
     * 企业初始uu号
     */
    public static final Long SPACE_INIT_UU = 10051000L;

    @Override
    public Userspace register(Userspace userspace, String appId) {
        User admin = userspace.getAdmin();
        if (admin == null) {
            throw new VisibleError("管理员不能为空");
        }

        // 校验企业名是否重复
        checkSpaceName(userspace.getSpaceName());

        // 校验营业执照号是否重复
        checkBusinessCode(userspace.getBusinessCode());

        // 设置域名
       if (StringUtils.isEmpty(userspace.getDomain())) {
           generateDefaultDomain(userspace);
       }

        // 设置uu号
        Long maxUU = userspaceDao.findMaxUU();
        userspace.setSpaceUU(StringUtils.isEmpty(maxUU) ? SPACE_INIT_UU : (maxUU + 1));

        // 设置管理员信息
        if (StringUtils.isEmpty(admin.getUserUU())) {
            User oldUser = userService.findByMobile(admin.getMobile());
            if (oldUser == null) {
                admin = userService.register(admin);
            } else {
                admin = oldUser;
            }

            // 给企业设置管理员
            userspace.setAdmin(admin);
        }
        userspace.setAdminUU(admin.getUserUU());

        // 将管理员设置在企业下
        List<User> users = new ArrayList<>();
        users.add(admin);
        userspace.setUsers(users);
        userspace.setValidCode((short) Status.NOT_APPLYING.getCode());
        userspace.setRegisterDate(new Timestamp(System.currentTimeMillis()));
        userspace.setFromApp(appId);

        // 注册企业
        userspace.setApps(appService.findDefaultUseApp());
        userspace = userspaceDao.save(userspace);

        if (userspace.getInviteSpaceUU() != null && userspace.getInviteUserUU() != null) {
            // 有邀请人添加合作伙伴
            partnershipService.addPartnershipRecord(appId, userspace);
        }

        // 开通应用
        syncUserSpaceInfo(userspace.toView(), "企业注册");
        return userspace;
    }

    private void syncUserSpaceInfo(final UserSpaceView userSpaceView, final String msg) {
        List<String> apps = appService.findUid();
        final UserView admin = userSpaceView.getAdmin();
        userSpaceView.setAdminUU(userSpaceView.getAdmin().getUserUU());
        userSpaceView.setAdmin(null);

        ExecuteUtils.execute(new ICallable<Void, String>() {
            @Override
            public Void call(String appId) throws Exception {
                App tempApp = appService.findOne(appId);
                if (tempApp != null && StringUtils.isEmpty(tempApp.getUserControl())
                        && !StringUtils.isEmpty(tempApp.getBackSpaceUrl())) {
                    String url = tempApp.getBackSpaceUrl();
                    JSONObject formData = JSON.parseObject(JSON.toJSONString(userSpaceView));
                    formData.putAll(JSON.parseObject(JSON.toJSONString(admin)));
                    HttpUtil.ResponseWrap res = null;
                    try {
                        res = HttpUtil.doPost(url, formData, 10000);
                        if (!res.isSuccess()) {
                            syncLog.error(appId, msg + ",同步企业信息失败", JSON.toJSONString(formData), res.getContent());
                        } else {
                            syncLog.info(appId, msg + ",同步企业信息成功", JSON.toJSONString(formData));
                        }
                    } catch (Exception e) {
                        syncLog.error(appId, msg + ",同步企业信息失败", JSON.toJSONString(formData), e.getMessage());
                    }
                }
                return null;
            }
        }, apps);
    }

    /**
     * 生成默认域名
     *
     * @return
     */
    private String generateDefaultDomain(Userspace userspace) {
        String domain = null;
        Userspace oldOne = null;
        /// 代码复制，以后可能用到这个
//        if (!StringUtils.isEmpty(userspace.getUrl())) {
//            Pattern p = Pattern.compile("http(s)*://(.+\\.)*(.+)\\..+", Pattern.CASE_INSENSITIVE);
//            Matcher m = p.matcher(userspace.getUrl());
//            if (m.find()) {
//                domain = m.group(3);
//                if ("1688".equals(domain) || "taobao".equals(domain) || "qq".equals(domain) || "baidu".equals(domain)) {
//                    domain = m.group(2);
//                }
//            }
//        }
        if (domain == null) {
            domain = StringUtil.substr(ChineseUtils.converterToFirstSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
        } else {
            oldOne = findByDomain(domain);
            if (oldOne != null) {
                domain = StringUtil.substr(ChineseUtils.converterToFirstSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
            }
        }
        oldOne = findByDomain(domain);
        if (oldOne != null) {
            domain = StringUtil.substr(ChineseUtils.converterToSpell(StringUtils.trimAllWhitespace(userspace.getSpaceName())), 0, 16);
            oldOne = findByDomain(domain);
            if (oldOne != null) {
                domain = null;
            }
        }
        return domain;
    }

    @Override
    public void checkSpaceName(String spaceName) {
        Userspace userSpace = userspaceDao.findBySpaceName(spaceName);
        if (userSpace != null) {
            throw new VisibleError("企业已被注册，请确认无误后联系管理员（"+userSpace.getAdmin().getVipName()+"）处理");
        }
    }

    @Override
    public void checkBusinessCode(String businessCode) {
        Userspace userSpace = userspaceDao.findByBusinessCode(businessCode);
        if (userSpace != null) {
            throw new VisibleError("该企业营业执照已被注册，请确认");
        }
    }

    @Override
    public Userspace findByDomain(String domain) {
        return userspaceDao.findByDomain(domain);
    }

    @Override
    public boolean spaceNameIsValid(String spaceName) {
        Userspace userSpace = userspaceDao.findBySpaceName(spaceName);
        return userSpace == null ? false : userSpace.getValidCode() == Status.AUTHENTICATED.getCode();
    }

    @Override
    public boolean businessCodeIsValid(String businessCode) {
        Userspace userSpace = userspaceDao.findByBusinessCode(businessCode);
        return userSpace == null ? false : userSpace.getValidCode() == Status.AUTHENTICATED.getCode();
    }

    @Override
    public void submitValidInfo(Userspace validSpace, Userspace userspace, User submitter) {
        // 校验企业名和营业执照是否被认证
        boolean isValid = spaceNameIsValid(userspace.getSpaceName());
        if (isValid) {
            throw new VisibleError("该企业名已被认证，请确认");
        }
        isValid = businessCodeIsValid(userspace.getBusinessCode());
        if (isValid) {
            throw new VisibleError("该企业营业执照号已被认证，请确认");
        }

        // 添加提交申请日志
        validSpace = userspaceDao.findOne(validSpace.getSpaceUU());
        validSpace.setValidCode((short) Status.TO_BE_CERTIFIED.getCode());
        userspaceDao.save(validSpace);
        userspace.setSpaceUU(validSpace.getSpaceUU());
        userspaceValidService.submitValid(userspace, submitter);
    }

    @Override
    public Userspace findOne(Long spaceUU) {
        return userspaceDao.findOne(spaceUU);
    }

    @Override
    public Page<String> searchName(String keyword, Integer number) {
        Pageable pageable = new PageRequest(0, number);
        Page<String> pUserSpaces = userspaceDao.findByPageInfo(keyword, pageable);
        return pUserSpaces;
    }

    @Override
    public Userspace findBySpaceName(String spaceName) {
        return userspaceDao.findBySpaceName(spaceName);
    }

    @Override
    public void unbindApp(Long spaceUU, String appId) {
        // 获取企业信息和应用信息，并校验
        Userspace userspace = userspaceDao.findOne(spaceUU);
        if (userspace == null) {
            throw new VisibleError("该企业不存在");
        }
        App app = appService.findOne(appId);
        if (app == null) {
            throw new VisibleError("该应用不存在");
        }

        // 解除绑定
        if (userspace.getApps().contains(app)) {
            userspace.getApps().remove(app);
        }
        userspaceDao.save(userspace);

    }

    @Override
    public void bindApp(Long spaceUU, String appId) {
        // 获取企业信息和应用信息，并校验
        Userspace userspace = userspaceDao.findOne(spaceUU);
        if (userspace == null) {
            throw new VisibleError("该企业不存在");
        }
        App app = appService.findOne(appId);
        if (app == null) {
            throw new VisibleError("该应用不存在");
        }

        // 开通应用
        if (userspace.getApps().contains(app)) {
            throw new VisibleError(String.format("该企业已开通%s应用", app.getUid()));
        }
        userspace.getApps().add(app);
        userspaceDao.save(userspace);
    }

    @Override
    public Userspace findByBusinessCode(String businessCode) {
        return userspaceDao.findByBusinessCode(businessCode);
    }

    @Override
    public void addUser(Userspace userspace, List<User> users) {
        userspace.getUsers().addAll(users);
        userspaceDao.save(userspace);
    }

    @Override
    public Userspace save(Userspace userspace) {
        return userspaceDao.save(userspace);
    }

    @Override
    public List<String> findRepeatName() {
        return userspaceDao.findRepeatName();
    }

    @Override
    public List<Userspace> findAllBySpaceName(String name) {
        return userspaceDao.findAllBySpaceName(name);
    }

    @Override
    public List<Userspace> findAll(String ids) {
        List<Long> idList = JSONObject.parseArray(ids, Long.class);
        if (!CollectionUtils.isEmpty(idList)) {
            return userspaceDao.findAll(idList);
        }
        return Collections.emptyList();
    }

    @Override
    public void changeAdmin(String appId, Userspace space, User afterAdmin) {
        space.setAdminUU(afterAdmin.getUserUU());
        space.setAdmin(afterAdmin);
        if (!space.getUsers().contains(afterAdmin)) {
            space.getUsers().add(afterAdmin);
        }
        space = userspaceDao.save(space);

        syncUserSpaceInfo(space.toView(), "从应用：" + appId + "更换管理员");
    }

    @Override
    public Page<Userspace> findByKeyword(final String keyword, int pageNumber, int pageSize) {
        Pageable pageable = PageInfo.pageRequest(pageNumber, pageSize);
        Page<Userspace> page = userspaceDao.findAll(new Specification<Userspace>() {
            @Override
            public Predicate toPredicate(Root<Userspace> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                List<Predicate> keyPredicates = new ArrayList<>();
                // 模糊查询企业名称，营业执照号，注册地址，管理员姓名
                keyPredicates.add(cb.like(cb.upper(root.get("spaceName").as(String.class)), "%" + keyword.toUpperCase() + "%"));
                keyPredicates.add(cb.like(cb.upper(root.get("businessCode").as(String.class)), "%" + keyword.toUpperCase() + "%"));
                keyPredicates.add(cb.like(cb.upper(root.get("regAddress").as(String.class)), "%" + keyword.toUpperCase() + "%"));
                keyPredicates.add(cb.like(cb.upper(root.join("admin", JoinType.INNER).get("vipName").as(String.class)), "%" + keyword.toUpperCase() + "%"));

                Predicate[] predicates = new Predicate[keyPredicates.size()];
                query.where(cb.or(keyPredicates.toArray(predicates)));
                query.orderBy(cb.desc(root.get("registerDate").as(Integer.class)));

                return query.getRestriction();
            }
        }, pageable);
        return new PageInfo<Userspace>(page.getContent(), pageable, page.getTotalElements());
    }
}