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.Status;
import com.uas.sso.dao.UserspaceDao;
import com.uas.sso.entity.*;
import com.uas.sso.exception.VisibleError;
import com.uas.sso.i.CountCallBack;
import com.uas.sso.logging.LoggerManager;
import com.uas.sso.logging.SyncBufferedLogger;
import com.uas.sso.service.*;
import com.uas.sso.support.SyncFail;
import com.uas.sso.sync.service.SyncUserspaceService;
import com.uas.sso.util.ChineseUtils;
import com.uas.sso.util.CountUtils;
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.text.ParseException;
import java.util.*;
import java.util.concurrent.ExecutorService;

/**
 * 企业信息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;

    @Autowired
    private ExecutorService executorService;

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

    @Autowired
    private SyncUserspaceService syncUserspaceService;

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

    @Override
    public Userspace register(Userspace userspace, String appId) {
        return register(userspace, appId, true);
    }

    @Override
    public Userspace register(Userspace userspace, String appId, boolean isSyncSource) {
        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, appId);
            } 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.setAccessSecret(UUID.randomUUID().toString().replaceAll("\\-", ""));

        // 注册企业
        App app = appService.findOne(appId);
        List<App> apps = appService.findDefaultUseApp();
        if (!apps.contains(app)) {
            apps.add(app);
        }
        userspace.setApps(apps);
        userspace = userspaceDao.save(userspace);

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

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

    /**
     * 同步企业信息到其他应用
     *
     * @param userSpaceView 企业信息
     * @param msg           同步日志信息
     * @param otherApp      需要同步的其他应用
     */
    private void syncUserSpaceInfo(UserSpaceView userSpaceView, String msg, App otherApp) {
        syncUserSpaceInfo(userSpaceView, msg, otherApp, null);
    }

    /**
     * 同步企业信息到其他应用
     * 如果需要同步的应用和不需要同步的应用相同，则不同步改应用
     *
     * @param userSpaceView 企业信息
     * @param msg           同步日志信息
     * @param otherApp      需要同步的其他应用
     * @param noSyncApp     不需要同步的应用
     */
    private void syncUserSpaceInfo(final UserSpaceView userSpaceView, final String msg, App otherApp, App noSyncApp) {
        // 封装数据
        final UserView admin = userSpaceView.getAdmin();
        userSpaceView.setAdminUU(userSpaceView.getAdmin().getUserUU());
        userSpaceView.setAdmin(null);
        JSONObject formData = JSON.parseObject(JSON.toJSONString(userSpaceView));
        formData.putAll(JSON.parseObject(JSON.toJSONString(admin)));

        // 同步默认企业
        List<App> apps = appService.findDefaultUseApp();
        if (!apps.contains(otherApp)) {
            apps.add(otherApp);
        }
        if (noSyncApp != null && apps.contains(noSyncApp)) {
            apps.remove(noSyncApp);
        }
        syncUserSpaceInfo(formData, msg, apps);
        syncUserspaceService.sendUserspaceToSso(userSpaceView.getSpaceUU());
    }

    private void syncUserSpaceInfo(final Map<String, Object> formData, final String msg, List<App> apps) {
        for (final App app : apps) {
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    String url = app.getBackSpaceUrl();
                    if (StringUtils.isEmpty(url)) {
                        return;
                    }
                    HttpUtil.ResponseWrap res;
                    try {
                        res = HttpUtil.doPost(url, formData, 10000);
                        if (!res.isSuccess()) {
                            SyncLog syncLog = syncLogger.error(app.getUid(), msg + ",同步企业信息失败", JSON.toJSONString(formData), res.getContent());
                            SyncFail.add(syncLog.getId(), formData, url, app.getUid());
                        } else {
                            syncLogger.info(app.getUid(), msg + ",同步企业信息成功", JSON.toJSONString(formData));
                        }
                    } catch (Exception e) {
                        syncLogger.error(app.getUid(), msg + ",同步企业信息失败", JSON.toJSONString(formData), e.getMessage());
                    }
                }
            });
        }
    }

    /**
     * 生成默认域名
     *
     * @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<Userspace> save(List<Userspace> userspaceList) {
        return userspaceDao.save(userspaceList);
    }

    @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 List<Userspace> findAll(List<Long> idList) {
        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);

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

    @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) {
                if (StringUtils.isEmpty(keyword)) {
                    return null;
                }
                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() + "%"));
                keyPredicates.removeAll(Collections.singletonList(null));
                Predicate[] predicates = new Predicate[keyPredicates.size()];
                query.where(cb.or(keyPredicates.toArray(predicates)));
                query.orderBy(cb.desc(root.get("registerDate").as(Integer.class)));

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

    @Override
    public long count() {
        return userspaceDao.count();
    }

    @Override
    public Map<String, Long> countByapps(final List<String> fromApps) {
        Map<String, Long> data = new HashMap<>();
        List<Map<String, Object>> counts = userspaceDao.getCountByApps(fromApps);
        for(Map<String, Object> count : counts){
            data.put((String) count.get("appId"),(Long) count.get("count"));
        }
        return data;
    }

    @Override
    public long getCountByRegisterDate(final Calendar start, final Calendar end) {
        return userspaceDao.count(new Specification<Userspace>() {
            @Override
            public Predicate toPredicate(Root<Userspace> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                Predicate predicate = cb.between(root.get("registerDate").as(Calendar.class), start, end);
                query.where(predicate);
                return null;
            }
        });
    }

    @Override
    public Map<String, Long> countByRegisterDate(Timestamp start, Timestamp end, List<String> fromApps) {
        Map<String, Long> data = new HashMap<>();
        List<Map<String, Object>> Counts = userspaceDao.getCountByRegisterDate(start, end, fromApps);
        for (Map<String, Object> Count : Counts) {
            data.put((String) Count.get("appId"), (Long) Count.get("count"));
            fromApps.remove(Count.get("appId"));
        }
        for (String app : fromApps) {
            data.put(app, 0L);
        }
        return data;
    }

    @Override
    public long countInCurrentMonth() {
        return CountUtils.countInCurrentMonth(new CountCallBack<Long>() {
            @Override
            public Long countByTime(Calendar start, Calendar end) {
                return getCountByRegisterDate(start, end);
            }
        });
    }

    @Override
    public long countInLastMonth() {
        return CountUtils.countInLastMonth(new CountCallBack<Long>() {
            @Override
            public Long countByTime(Calendar start, Calendar end) {
                return getCountByRegisterDate(start, end);
            }
        });
    }

    @Override
    public long countInCurrentWeek() {
        return CountUtils.countInCurrentWeek(new CountCallBack<Long>() {
            @Override
            public Long countByTime(Calendar start, Calendar end) {
                return getCountByRegisterDate(start, end);
            }
        });
    }

    @Override
    public Map<String, Long> countInInputTime(String startTime, String endTime, List<String> fromApps) throws ParseException {
        CountCallBack<Map<String, Long>> countCallBack = new CountCallBack<Map<String, Long>>() {
            @Override
            public Map<String, Long> countByTime(Calendar start, Calendar end) {
                return countByRegisterDate(new Timestamp(start.getTimeInMillis()), new Timestamp(end.getTimeInMillis()), fromApps);
            }
        };
        return CountUtils.countInInputTime(countCallBack, startTime, endTime);
    }

    @Override
    public PageInfo<Userspace> getUserspaceInfo(int pageNumber, int pageSize) {
        Pageable pageable = PageInfo.pageRequest(pageNumber, pageSize);
        Page<Userspace> userspacePage = userspaceDao.findAll((root, query, cb) -> {
            query.orderBy(cb.asc(root.get("spaceUU").as(Long.class)));
            return null;
        }, pageable);
        return new PageInfo<Userspace>(userspacePage.getContent(), pageable, userspacePage.getTotalElements());
    }
}